def get_balance_proof(self, partner_address: Address, **kwargs) -> BalanceProof: """Get a signed balance proof for an open channel. Parameters: partner_address - address of a partner the node has channel open with **kwargs - arguments to BalanceProof constructor """ channel_id = self.partner_to_channel_id[partner_address] bp = BalanceProof(channel_id, self.contract.address, **kwargs) bp.signature = encode_hex(sign_data(self.privkey, bp.serialize_bin())) return bp
def test_put_balance_sync_check( api_sut: ServiceApi, api_url: str, token_networks: List[TokenNetwork], token_network_addresses: List[Address], private_keys: List[str], ): url = api_url + '/{}/{}/balance'.format(token_network_addresses[0], ID_12) token_networks[0].update_balance = mock.Mock( return_value=None) # type: ignore balance_proof = BalanceProof( channel_identifier=ChannelIdentifier(ID_123), token_network_address=token_network_addresses[0], nonce=1, chain_id=321, additional_hash="0x%064x" % 0, balance_hash="0x%064x" % 0, ) balance_proof.signature = encode_hex( sign_data(private_keys[0], balance_proof.serialize_bin())) body = balance_proof.serialize_full() # path channel id and BP channel id are not equal response = requests.put(url, json=body) assert response.status_code == 400 assert response.json()['error'].startswith( 'The channel identifier from the balance proof ' f'({ID_123}) and the request ({ID_12}) do not match') balance_proof = BalanceProof( channel_identifier=ChannelIdentifier(ID_123), token_network_address=token_network_addresses[1], nonce=1, chain_id=321, additional_hash="0x%064x" % 0, balance_hash="0x%064x" % 0, ) balance_proof.signature = encode_hex( sign_data(private_keys[0], balance_proof.serialize_bin())) body = balance_proof.serialize_full() # now the network address doesn't match response = requests.put(url, json=body) assert response.status_code == 400 assert response.json()['error'].startswith( 'The token network address from the balance proof')
def get_monitor_requests( self, channel_identifier: ChannelIdentifier = None, non_closing_signer: Address = None, ) -> Dict[tuple, MonitorRequest]: """ Return MRs keyed by (channel_id, non_closing_signer), optionally filtered """ mr_rows = self.get_monitor_request_rows(channel_identifier, non_closing_signer) return { (x['channel_identifier'], x['non_closing_signer']): MonitorRequest( balance_proof=BalanceProof( channel_identifier=x['channel_identifier'], token_network_address=x['token_network_address'], balance_hash=x['balance_hash'], nonce=x['nonce'], additional_hash=x['additional_hash'], chain_id=self.chain_id(), signature=x['closing_signature'], ), non_closing_signature=x['non_closing_signature'], reward_proof_signature=x['reward_proof_signature'], reward_amount=x['reward_amount'], # Monitor address is not used, but required for now, see # https://github.com/raiden-network/raiden-monitoring-service/issues/42 monitor_address='0x' + '0' * 40, ) for x in mr_rows }
def on_channel_close(self, event: Dict, tx: Dict): log.info('on channel close: event=%s tx=%s' % (event, tx)) # check if we have balance proof for the closing closing_participant = event['args']['closing_participant'] channel_id = event['args']['channel_identifier'] tx_data = tx[1] tx_balance_proof = BalanceProof( channel_identifier=tx_data[0], token_network_address=event['address'], balance_hash=tx_data[1], nonce=tx_data[2], additional_hash=tx_data[3], chain_id=int(self.web3.version.network), signature=encode_hex(tx_data[4]), ) assert tx_balance_proof is not None assert is_address(closing_participant) assert is_channel_identifier(channel_id) pkey_to_mr = self.state_db.get_monitor_requests(channel_id) for (_, non_closing_signer), monitor_request in pkey_to_mr.items(): if non_closing_signer == closing_participant: # we don't have to act on behalf of the closing participant continue # submit monitor request self.start_task( OnChannelClose(self.monitor_contract, monitor_request, self.private_key), )
def test_put_balance( api_sut: ServiceApi, api_url: str, token_networks: List[TokenNetwork], token_network_addresses: List[Address], private_keys: List[str], ): url = api_url + '/{}/{}/balance'.format(token_network_addresses[0], ID_123) token_networks[0].update_balance = mock.Mock( return_value=None) # type: ignore balance_proof = BalanceProof( channel_identifier=ChannelIdentifier(ID_123), token_network_address=token_network_addresses[0], nonce=1, chain_id=1, locksroot="0x%064x" % 0, transferred_amount=1, locked_amount=0, additional_hash="0x%064x" % 0, ) balance_proof.signature = encode_hex( sign_data(private_keys[0], balance_proof.serialize_bin())) body = balance_proof.serialize_full() response = requests.put(url, json=body) assert response.status_code == 200 token_networks[0].update_balance.assert_called_once() # type: ignore call_args = token_networks[0].update_balance.call_args[0] # type: ignore channel_identifier: ChannelIdentifier = call_args[0] signer: Address = call_args[1] nonce: int = call_args[2] transferred_amount: int = call_args[3] locked_amount: int = call_args[4] assert channel_identifier == ID_123 assert is_same_address(signer, private_key_to_address(private_keys[0])) assert nonce == 1 assert transferred_amount == 1 assert locked_amount == 0
def f( user=None, reward_amount=0, bad_key_for_bp=False, bad_key_for_non_closing=False, ): if user == 0: privkey = keys[0] privkey_non_closing = keys[1] else: privkey = keys[1] privkey_non_closing = keys[0] balance_proof = BalanceProof( channel_id, token_network_address, balance_hash=encode_hex(sha3(balance_hash_data.encode())), ) balance_proof.signature = encode_hex( eth_sign( privkey if not bad_key_for_bp else keys[2], balance_proof.serialize_bin(), )) non_closing_signature = encode_hex( eth_sign( privkey_non_closing if not bad_key_for_non_closing else keys[2], balance_proof.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE) + decode_hex(balance_proof.signature), )) monitor_request = MonitorRequest( balance_proof, non_closing_signature, reward_amount=reward_amount, monitor_address=get_random_address(), ) monitor_request.reward_proof_signature = encode_hex( eth_sign(privkey, monitor_request.serialize_reward_proof()), ) return monitor_request
def update_transfer(self, partner_address: Address, balance_proof: BalanceProof): """Given a valid signed balance proof, this method calls `updateNonClosingBalanceProof` for an open channel """ non_closing_data = balance_proof.serialize_bin() + decode_hex( balance_proof.signature) non_closing_signature = encode_hex( sign_data(self.privkey, non_closing_data)) self.contract.functions.updateNonClosingBalanceProof( partner_address, self.address, balance_proof.balance_hash, balance_proof.nonce, balance_proof.additional_hash, balance_proof.signature, non_closing_signature).transact({'from': self.address})
def test_balance_proof(): # test balance proof with computed balance hash balance_proof = BalanceProof( channel_identifier=ChannelIdentifier( '0x3131313131313131313131313131313131313131313131313131313131313131', ), token_network_address=Address( '0x82dd0e0eA3E84D00Cc119c46Ee22060939E5D1FC'), nonce=1, chain_id=321, transferred_amount=5, locksroot='0x%064x' % 5, additional_hash='0x%064x' % 0, ) serialized = balance_proof.serialize_data() assert serialized['channel_identifier'] == balance_proof.channel_identifier assert is_same_address( serialized['token_network_address'], balance_proof.token_network_address, ) assert serialized['nonce'] == balance_proof.nonce assert serialized['chain_id'] == balance_proof.chain_id assert serialized['additional_hash'] == balance_proof.additional_hash assert serialized['balance_hash'] == balance_proof.balance_hash assert serialized['locksroot'] == balance_proof.locksroot assert serialized['transferred_amount'] == balance_proof.transferred_amount assert serialized['locked_amount'] == balance_proof.locked_amount # test balance proof with balance hash set from constructor balance_proof = BalanceProof( channel_identifier=ChannelIdentifier( '0x3131313131313131313131313131313131313131313131313131313131313131', ), token_network_address=Address( '0x82dd0e0eA3E84D00Cc119c46Ee22060939E5D1FC'), nonce=1, chain_id=321, balance_hash='0x%064x' % 5, locked_amount=0, additional_hash='0x%064x' % 0, ) serialized = balance_proof.serialize_data() with pytest.raises(KeyError): serialized['transferred_amount'] assert serialized['channel_identifier'] == balance_proof.channel_identifier assert is_same_address( serialized['token_network_address'], balance_proof.token_network_address, ) assert serialized['nonce'] == balance_proof.nonce assert serialized['chain_id'] == balance_proof.chain_id assert serialized['additional_hash'] == balance_proof.additional_hash assert serialized['balance_hash'] == balance_proof.balance_hash
def get_monitor_request(self, partner_address: Address, balance_proof: BalanceProof, reward_amount: int, monitor_address: Address) -> MonitorRequest: """Get monitor request message for a given balance proof.""" monitor_request = MonitorRequest(balance_proof, reward_proof_signature=None, reward_amount=reward_amount, monitor_address=monitor_address) monitor_request.reward_proof_signature = encode_hex( sign_data(self.privkey, monitor_request.serialize_reward_proof())) non_closing_data = balance_proof.serialize_bin() + decode_hex( balance_proof.signature) monitor_request.non_closing_signature = encode_hex( sign_data(self.privkey, non_closing_data)) return monitor_request
def f( channel_identifier: ChannelIdentifier = None, contract_address: Address = None ): contract_address = contract_address or get_random_address() channel_identifier = channel_identifier or ChannelIdentifier(random.randint(0, UINT64_MAX)) balance_hash_data = '%d' % random.randint(0, UINT64_MAX) additional_hash_data = '%d' % random.randint(0, UINT64_MAX) balance_proof = BalanceProof( channel_identifier, contract_address, balance_hash=keccak_256(balance_hash_data.encode()).hexdigest(), nonce=random.randint(0, UINT64_MAX), additional_hash=keccak_256(additional_hash_data.encode()).hexdigest(), chain_id=1, ) return balance_proof
def test_balance_proof(): balance_proof = BalanceProof( channel_identifier=ChannelIdentifier(123), token_network_address=Address('0x82dd0e0eA3E84D00Cc119c46Ee22060939E5D1FC'), nonce=1, chain_id=321, balance_hash='0x%064x' % 5, transferred_amount=1, locked_amount=0, additional_hash='0x%064x' % 0, ) serialized = balance_proof.serialize_data() assert serialized['channel_identifier'] == balance_proof.channel_identifier assert is_same_address( serialized['token_network_address'], balance_proof.token_network_address ) assert serialized['nonce'] == balance_proof.nonce assert serialized['chain_id'] == balance_proof.chain_id assert serialized['additional_hash'] == balance_proof.additional_hash assert serialized['balance_hash'] == balance_proof.balance_hash with pytest.raises(KeyError): serialized['transferred_amount'] balance_proof = BalanceProof( channel_identifier=ChannelIdentifier(123), token_network_address=Address('0x82dd0e0eA3E84D00Cc119c46Ee22060939E5D1FC'), nonce=1, chain_id=321, locksroot='0x%064x' % 5, transferred_amount=1, locked_amount=0, additional_hash='0x%064x' % 0, ) serialized = balance_proof.serialize_data() assert serialized['channel_identifier'] == balance_proof.channel_identifier assert is_same_address( serialized['token_network_address'], balance_proof.token_network_address ) assert serialized['nonce'] == balance_proof.nonce assert serialized['chain_id'] == balance_proof.chain_id assert serialized['additional_hash'] == balance_proof.additional_hash assert serialized['locksroot'] == balance_proof.locksroot assert serialized['transferred_amount'] == balance_proof.transferred_amount assert serialized['locked_amount'] == balance_proof.locked_amount
def update_transfer(self, partner_address: Address, balance_proof: BalanceProof): """Given a valid signed balance proof, this method calls `updateNonClosingBalanceProof` for an open channel """ serialized = balance_proof.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE) non_closing_data = serialized + decode_hex(balance_proof.signature) non_closing_signature = encode_hex( eth_sign(self.privkey, non_closing_data)) self.contract.functions.updateNonClosingBalanceProof( self.partner_to_channel_id[partner_address], partner_address, self.address, balance_proof.balance_hash, balance_proof.nonce, balance_proof.additional_hash, balance_proof.signature, non_closing_signature, ).transact({'from': self.address})
def test_token_network_proxy_update_transfer( token_network_proxy, private_keys, blockchain_rpc_ports, token_proxy, chain_id, web3, ): """Tests channel lifecycle, with `update_transfer` before settling""" token_network_address = to_canonical_address(token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[1], web3=web3, ) c2_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[2], web3=web3, ) c1_token_network_proxy = TokenNetwork( c1_client, token_network_address, ) c2_token_network_proxy = TokenNetwork( c2_client, token_network_address, ) # create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.sender, TEST_SETTLE_TIMEOUT_MIN, ) # deposit to the channel initial_balance = 100 token_proxy.transfer(c1_client.sender, initial_balance) token_proxy.transfer(c2_client.sender, initial_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.sender) assert initial_balance_c1 == initial_balance initial_balance_c2 = token_proxy.balance_of(c2_client.sender) assert initial_balance_c2 == initial_balance c1_token_network_proxy.set_total_deposit( 10, c2_client.sender, ) c2_token_network_proxy.set_total_deposit( 10, c1_client.sender, ) # balance proof signed by c1 transferred_amount_c1 = 1 transferred_amount_c2 = 3 balance_proof_c1 = BalanceProof( channel_identifier=encode_hex(channel_identifier), token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount_c1, ) balance_proof_c1.signature = encode_hex( sign_data(encode_hex(private_keys[1]), balance_proof_c1.serialize_bin()), ) # balance proof signed by c2 balance_proof_c2 = BalanceProof( channel_identifier=encode_hex(channel_identifier), token_network_address=to_checksum_address(token_network_address), nonce=2, chain_id=chain_id, transferred_amount=transferred_amount_c2, ) balance_proof_c2.signature = encode_hex( sign_data(encode_hex(private_keys[2]), balance_proof_c2.serialize_bin()), ) # close by c1 c1_token_network_proxy.close( c2_client.sender, balance_proof_c2.nonce, decode_hex(balance_proof_c2.balance_hash), decode_hex(balance_proof_c2.additional_hash), decode_hex(balance_proof_c2.signature), ) # using invalid non-closing signature # Usual mistake when calling update Transfer - balance proof signature is missing in the data non_closing_data = balance_proof_c1.serialize_bin() non_closing_signature = sign_data( encode_hex(c2_client.privkey), non_closing_data, ) with pytest.raises(TransactionThrew): c2_token_network_proxy.update_transfer( c1_client.sender, balance_proof_c1.nonce, decode_hex(balance_proof_c1.balance_hash), decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) non_closing_data = balance_proof_c1.serialize_bin() + decode_hex(balance_proof_c1.signature) non_closing_signature = sign_data( encode_hex(c2_client.privkey), non_closing_data, ) c2_token_network_proxy.update_transfer( c1_client.sender, balance_proof_c1.nonce, decode_hex(balance_proof_c1.balance_hash), decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) wait_blocks(c1_client.web3, TEST_SETTLE_TIMEOUT_MIN) # settling with an invalid amount with pytest.raises(TransactionThrew): c1_token_network_proxy.settle( 2, 0, EMPTY_HASH, c2_client.sender, 2, 0, EMPTY_HASH, ) # proper settle c1_token_network_proxy.settle( transferred_amount_c1, 0, EMPTY_HASH, c2_client.sender, transferred_amount_c2, 0, EMPTY_HASH, ) assert (token_proxy.balance_of(c2_client.sender) == (initial_balance_c2 + transferred_amount_c1 - transferred_amount_c2)) assert (token_proxy.balance_of(c1_client.sender) == (initial_balance_c1 + transferred_amount_c2 - transferred_amount_c1))
def test_token_network_proxy_basics( token_network_proxy, private_keys, token_proxy, chain_id, web3, contract_manager, ): # check settlement timeouts assert token_network_proxy.settlement_timeout_min( ) == TEST_SETTLE_TIMEOUT_MIN assert token_network_proxy.settlement_timeout_max( ) == TEST_SETTLE_TIMEOUT_MAX token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient(web3, private_keys[1]) c2_client = JSONRPCClient(web3, private_keys[2]) c1_token_network_proxy = TokenNetwork( jsonrpc_client=c1_client, manager_address=token_network_address, contract_manager=contract_manager, ) c2_token_network_proxy = TokenNetwork( jsonrpc_client=c2_client, manager_address=token_network_address, contract_manager=contract_manager, ) initial_token_balance = 100 token_proxy.transfer(c1_client.address, initial_token_balance) token_proxy.transfer(c2_client.address, initial_token_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.address) assert initial_balance_c1 == initial_token_balance initial_balance_c2 = token_proxy.balance_of(c2_client.address) assert initial_balance_c2 == initial_token_balance # instantiating a new channel - test basic assumptions assert c1_token_network_proxy.channel_exists_and_not_settled( c1_client.address, c2_client.address, ) is False assert c1_token_network_proxy.channel_is_opened(c1_client.address, c2_client.address) is False assert c1_token_network_proxy.channel_is_closed(c1_client.address, c2_client.address) is False # test timeout limits with pytest.raises(InvalidSettleTimeout): c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MIN - 1, ) with pytest.raises(InvalidSettleTimeout): c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MAX + 1, ) # channel to self with pytest.raises(SamePeerAddress): c1_token_network_proxy.new_netting_channel( c1_client.address, TEST_SETTLE_TIMEOUT_MIN, ) # Channel is not open yet with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.set_total_deposit( 1, 1, c2_client.address, ) assert 'does not exist' in str(exc) # Channel is not open yet with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.close( 1, c2_client.address, EMPTY_HASH, 0, EMPTY_HASH, EMPTY_HASH, ) assert 'does not exist' in str(exc) # actually create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MIN, ) assert channel_identifier is not None # multiple channels with the same peer are not allowed with pytest.raises(DuplicatedChannelError): c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MIN, ) assert c1_token_network_proxy.channel_exists_and_not_settled( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is True assert c1_token_network_proxy.channel_is_opened( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is True # channel is open. # deposit with no balance with pytest.raises(DepositMismatch): c1_token_network_proxy.set_total_deposit( channel_identifier, 101, c2_client.address, ) # no negative deposit with pytest.raises(DepositMismatch): c1_token_network_proxy.set_total_deposit( channel_identifier, -1, c2_client.address, ) # actual deposit c1_token_network_proxy.set_total_deposit( channel_identifier, 10, c2_client.address, ) # balance proof by c2 transferred_amount = 3 balance_proof = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount, ) balance_proof.signature = encode_hex( eth_sign( privkey=encode_hex(private_keys[1]), data=balance_proof.serialize_bin(), )) # close with invalid signature with pytest.raises(TransactionThrew): c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=b'\x11' * 65, ) # correct close c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=decode_hex(balance_proof.signature), ) assert c1_token_network_proxy.channel_is_closed( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is True assert c1_token_network_proxy.channel_exists_and_not_settled( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is True # closing already closed channel with pytest.raises(RaidenRecoverableError): c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=decode_hex(balance_proof.signature), ) with pytest.raises(RaidenRecoverableError) as exc: c2_token_network_proxy.set_total_deposit( channel_identifier, 20, c1_client.address, ) assert 'not in an open state' in str(exc) with pytest.raises(RaidenRecoverableError) as exc: c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=decode_hex(balance_proof.signature), ) assert 'not in an open state' in str(exc) # update transfer wait_blocks(c1_client.web3, TEST_SETTLE_TIMEOUT_MIN) # try to settle using incorrect data with pytest.raises(RaidenUnrecoverableError): c2_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=1, locked_amount=0, locksroot=EMPTY_HASH, partner=c1_client.address, partner_transferred_amount=transferred_amount, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) c2_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=0, locked_amount=0, locksroot=EMPTY_HASH, partner=c1_client.address, partner_transferred_amount=transferred_amount, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert c1_token_network_proxy.channel_exists_and_not_settled( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is False assert token_proxy.balance_of(c1_client.address) == (initial_balance_c1 - transferred_amount) assert token_proxy.balance_of(c2_client.address) == (initial_balance_c2 + transferred_amount) with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.set_total_deposit( channel_identifier, 10, c2_client.address, ) # No channel exists assert 'getChannelIdentifier returned 0' in str(exc)
def test_token_network_proxy_update_transfer( token_network_proxy, private_keys, token_proxy, chain_id, web3, contract_manager, ): """Tests channel lifecycle, with `update_transfer` before settling""" token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient(web3, private_keys[1]) c2_client = JSONRPCClient(web3, private_keys[2]) c1_token_network_proxy = TokenNetwork( jsonrpc_client=c1_client, manager_address=token_network_address, contract_manager=contract_manager, ) c2_token_network_proxy = TokenNetwork( jsonrpc_client=c2_client, manager_address=token_network_address, contract_manager=contract_manager, ) # create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.address, 10, ) # deposit to the channel initial_balance = 100 token_proxy.transfer(c1_client.address, initial_balance) token_proxy.transfer(c2_client.address, initial_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.address) assert initial_balance_c1 == initial_balance initial_balance_c2 = token_proxy.balance_of(c2_client.address) assert initial_balance_c2 == initial_balance c1_token_network_proxy.set_total_deposit( channel_identifier, 10, c2_client.address, ) c2_token_network_proxy.set_total_deposit( channel_identifier, 10, c1_client.address, ) # balance proof signed by c1 transferred_amount_c1 = 1 transferred_amount_c2 = 3 balance_proof_c1 = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount_c1, ) balance_proof_c1.signature = encode_hex( eth_sign( privkey=encode_hex(private_keys[1]), data=balance_proof_c1.serialize_bin(), )) # balance proof signed by c2 balance_proof_c2 = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=2, chain_id=chain_id, transferred_amount=transferred_amount_c2, ) balance_proof_c2.signature = encode_hex( eth_sign( privkey=encode_hex(private_keys[2]), data=balance_proof_c2.serialize_bin(), )) non_closing_data = balance_proof_c1.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE, ) + decode_hex( balance_proof_c1.signature) non_closing_signature = eth_sign( privkey=encode_hex(c2_client.privkey), data=non_closing_data, ) with pytest.raises(RaidenUnrecoverableError) as exc: c2_token_network_proxy.update_transfer( channel_identifier, c1_client.address, decode_hex(balance_proof_c1.balance_hash), balance_proof_c1.nonce, decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) assert 'not in a closed state' in str(exc) # close by c1 c1_token_network_proxy.close( channel_identifier=channel_identifier, partner=c2_client.address, balance_hash=decode_hex(balance_proof_c2.balance_hash), nonce=balance_proof_c2.nonce, additional_hash=decode_hex(balance_proof_c2.additional_hash), signature=decode_hex(balance_proof_c2.signature), ) # using invalid non-closing signature # Usual mistake when calling update Transfer - balance proof signature is missing in the data non_closing_data = balance_proof_c1.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE) non_closing_signature = eth_sign( privkey=encode_hex(c2_client.privkey), data=non_closing_data, ) with pytest.raises(TransactionThrew): c2_token_network_proxy.update_transfer( channel_identifier, c1_client.address, decode_hex(balance_proof_c1.balance_hash), balance_proof_c1.nonce, decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) non_closing_data = balance_proof_c1.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE, ) + decode_hex( balance_proof_c1.signature) non_closing_signature = eth_sign( privkey=encode_hex(c2_client.privkey), data=non_closing_data, ) c2_token_network_proxy.update_transfer( channel_identifier, c1_client.address, decode_hex(balance_proof_c1.balance_hash), balance_proof_c1.nonce, decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=transferred_amount_c1, locked_amount=0, locksroot=EMPTY_HASH, partner=c2_client.address, partner_transferred_amount=transferred_amount_c2, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert 'cannot be settled before settlement window is over' in str(exc) wait_blocks(c1_client.web3, 10) # settling with an invalid amount with pytest.raises(RaidenUnrecoverableError): c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=2, locked_amount=0, locksroot=EMPTY_HASH, partner=c2_client.address, partner_transferred_amount=2, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) # proper settle c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=transferred_amount_c1, locked_amount=0, locksroot=EMPTY_HASH, partner=c2_client.address, partner_transferred_amount=transferred_amount_c2, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert (token_proxy.balance_of( c2_client.address) == (initial_balance_c2 + transferred_amount_c1 - transferred_amount_c2)) assert (token_proxy.balance_of( c1_client.address) == (initial_balance_c1 + transferred_amount_c2 - transferred_amount_c1)) # Already settled with pytest.raises(RaidenUnrecoverableError) as exc: c2_token_network_proxy.set_total_deposit( channel_identifier, 20, c1_client.address, ) assert 'getChannelIdentifier returned 0' in str(exc)
def test_payment_channel_outdated_channel_close( token_network_proxy, private_keys, chain_id, web3, contract_manager, ): token_network_address = to_canonical_address(token_network_proxy.proxy.contract.address) partner = privatekey_to_address(private_keys[0]) client = JSONRPCClient(web3, private_keys[1]) chain = BlockChainService(private_keys[1], client) token_network_proxy = TokenNetwork( jsonrpc_client=client, token_network_address=token_network_address, contract_manager=contract_manager, ) start_block = web3.eth.blockNumber # create a channel channel_identifier = token_network_proxy.new_netting_channel( partner, TEST_SETTLE_TIMEOUT_MIN, ) assert channel_identifier is not None # create channel proxies channel_proxy_1 = PaymentChannel( token_network=token_network_proxy, channel_identifier=channel_identifier, contract_manager=contract_manager, ) channel_filter = channel_proxy_1.all_events_filter( from_block=start_block, to_block='latest', ) assert channel_proxy_1.channel_identifier == channel_identifier assert channel_proxy_1.opened() is True # balance proof by c1 balance_proof = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=0, chain_id=chain_id, transferred_amount=0, ) balance_proof.signature = encode_hex(eth_sign( privkey=encode_hex(private_keys[0]), data=balance_proof.serialize_bin(), )) # correct close token_network_proxy.close( channel_identifier=channel_identifier, partner=partner, balance_hash=bytes(32), nonce=balance_proof.nonce, additional_hash=bytes(32), signature=decode_hex(balance_proof.signature), ) assert channel_proxy_1.closed() is True events = channel_filter.get_all_entries() assert len(events) == 2 # ChannelOpened, ChannelClosed # check the settlement timeouts again assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN # update transfer wait_until_block(chain, client.block_number() + TEST_SETTLE_TIMEOUT_MIN) token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=0, locked_amount=0, locksroot=EMPTY_HASH, partner=partner, partner_transferred_amount=0, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert channel_proxy_1.settled() is True events = channel_filter.get_all_entries() assert len(events) == 3 # ChannelOpened, ChannelClosed, ChannelSettled # Create a new channel with a different identifier # create a channel new_channel_identifier = token_network_proxy.new_netting_channel( partner, TEST_SETTLE_TIMEOUT_MIN, ) assert new_channel_identifier is not None # create channel proxies channel_proxy_2 = PaymentChannel( token_network=token_network_proxy, channel_identifier=new_channel_identifier, contract_manager=contract_manager, ) assert channel_proxy_2.channel_identifier == new_channel_identifier assert channel_proxy_2.opened() is True with pytest.raises(ChannelOutdatedError): token_network_proxy.close( channel_identifier=channel_identifier, partner=partner, balance_hash=bytes(32), nonce=balance_proof.nonce, additional_hash=bytes(32), signature=decode_hex(balance_proof.signature), )
def test_token_network_proxy_basics( token_network_proxy, private_keys, token_proxy, chain_id, web3, contract_manager, ): # check settlement timeouts assert token_network_proxy.settlement_timeout_min() == TEST_SETTLE_TIMEOUT_MIN assert token_network_proxy.settlement_timeout_max() == TEST_SETTLE_TIMEOUT_MAX token_network_address = to_canonical_address(token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient(web3, private_keys[1]) c1_chain = BlockChainService(private_keys[1], c1_client) c2_client = JSONRPCClient(web3, private_keys[2]) c1_token_network_proxy = TokenNetwork( jsonrpc_client=c1_client, token_network_address=token_network_address, contract_manager=contract_manager, ) c2_token_network_proxy = TokenNetwork( jsonrpc_client=c2_client, token_network_address=token_network_address, contract_manager=contract_manager, ) initial_token_balance = 100 token_proxy.transfer(c1_client.address, initial_token_balance) token_proxy.transfer(c2_client.address, initial_token_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.address) assert initial_balance_c1 == initial_token_balance initial_balance_c2 = token_proxy.balance_of(c2_client.address) assert initial_balance_c2 == initial_token_balance # instantiating a new channel - test basic assumptions assert c1_token_network_proxy.channel_exists_and_not_settled( c1_client.address, c2_client.address, ) is False channel_identifier = c1_token_network_proxy._call_and_check_result( 'latest', 'getChannelIdentifier', to_checksum_address(c1_client.address), to_checksum_address(c2_client.address), ) assert c1_token_network_proxy.channel_is_opened( c1_client.address, c2_client.address, channel_identifier, ) is False assert c1_token_network_proxy.channel_is_closed( c1_client.address, c2_client.address, channel_identifier, ) is False # test timeout limits with pytest.raises(InvalidSettleTimeout): c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MIN - 1, ) with pytest.raises(InvalidSettleTimeout): c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MAX + 1, ) # channel to self with pytest.raises(SamePeerAddress): c1_token_network_proxy.new_netting_channel( c1_client.address, TEST_SETTLE_TIMEOUT_MIN, ) # Channel is not open yet with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.set_total_deposit( 1, 1, c2_client.address, ) assert 'does not exist' in str(exc) # Channel is not open yet with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.close( 1, c2_client.address, EMPTY_HASH, 0, EMPTY_HASH, EMPTY_HASH, ) assert 'does not exist' in str(exc) # actually create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MIN, ) assert channel_identifier is not None # multiple channels with the same peer are not allowed with pytest.raises(DuplicatedChannelError): c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MIN, ) assert c1_token_network_proxy.channel_exists_and_not_settled( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is True assert c1_token_network_proxy.channel_is_opened( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is True # channel is open. # deposit with no balance with pytest.raises(DepositMismatch): c1_token_network_proxy.set_total_deposit( channel_identifier, 101, c2_client.address, ) # no negative deposit with pytest.raises(DepositMismatch): c1_token_network_proxy.set_total_deposit( channel_identifier, -1, c2_client.address, ) # actual deposit c1_token_network_proxy.set_total_deposit( channel_identifier, 10, c2_client.address, ) # balance proof by c2 transferred_amount = 3 balance_proof = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount, ) balance_proof.signature = encode_hex(eth_sign( privkey=encode_hex(private_keys[1]), data=balance_proof.serialize_bin(), )) # close with invalid signature with pytest.raises(RaidenUnrecoverableError): c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=b'\x11' * 65, ) # correct close c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=decode_hex(balance_proof.signature), ) assert c1_token_network_proxy.channel_is_closed( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is True assert c1_token_network_proxy.channel_exists_and_not_settled( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is True # closing already closed channel with pytest.raises(RaidenRecoverableError): c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=decode_hex(balance_proof.signature), ) with pytest.raises(RaidenRecoverableError) as exc: c2_token_network_proxy.set_total_deposit( channel_identifier, 20, c1_client.address, ) assert 'not in an open state' in str(exc) with pytest.raises(RaidenRecoverableError) as exc: c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=decode_hex(balance_proof.signature), ) assert 'not in an open state' in str(exc) # update transfer wait_until_block(c1_chain, c1_chain.block_number() + TEST_SETTLE_TIMEOUT_MIN) # try to settle using incorrect data with pytest.raises(RaidenUnrecoverableError): c2_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=1, locked_amount=0, locksroot=EMPTY_HASH, partner=c1_client.address, partner_transferred_amount=transferred_amount, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) c2_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=0, locked_amount=0, locksroot=EMPTY_HASH, partner=c1_client.address, partner_transferred_amount=transferred_amount, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert c1_token_network_proxy.channel_exists_and_not_settled( participant1=c1_client.address, participant2=c2_client.address, channel_identifier=channel_identifier, ) is False assert token_proxy.balance_of(c1_client.address) == (initial_balance_c1 - transferred_amount) assert token_proxy.balance_of(c2_client.address) == (initial_balance_c2 + transferred_amount) with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.set_total_deposit( channel_identifier, 10, c2_client.address, ) # No channel exists assert 'getChannelIdentifier returned 0' in str(exc)
def test_payment_channel_proxy_basics( token_network_proxy, private_keys, token_proxy, chain_id, web3, contract_manager, ): token_network_address = to_canonical_address(token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient(web3, private_keys[1]) c1_chain = BlockChainService(private_keys[1], c1_client) c2_client = JSONRPCClient(web3, private_keys[2]) c1_token_network_proxy = TokenNetwork( jsonrpc_client=c1_client, token_network_address=token_network_address, contract_manager=contract_manager, ) c2_token_network_proxy = TokenNetwork( jsonrpc_client=c2_client, token_network_address=token_network_address, contract_manager=contract_manager, ) start_block = web3.eth.blockNumber # create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MIN, ) assert channel_identifier is not None # create channel proxies channel_proxy_1 = PaymentChannel( token_network=c1_token_network_proxy, channel_identifier=channel_identifier, contract_manager=contract_manager, ) channel_proxy_2 = PaymentChannel( token_network=c2_token_network_proxy, channel_identifier=channel_identifier, contract_manager=contract_manager, ) channel_filter = channel_proxy_1.all_events_filter( from_block=start_block, to_block='latest', ) assert channel_proxy_1.channel_identifier == channel_identifier assert channel_proxy_2.channel_identifier == channel_identifier assert channel_proxy_1.opened() is True assert channel_proxy_2.opened() is True # check the settlement timeouts assert channel_proxy_1.settle_timeout() == channel_proxy_2.settle_timeout() assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN events = channel_filter.get_all_entries() assert len(events) == 1 # ChannelOpened # test deposits initial_token_balance = 100 token_proxy.transfer(c1_client.address, initial_token_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.address) assert initial_balance_c1 == initial_token_balance initial_balance_c2 = token_proxy.balance_of(c2_client.address) assert initial_balance_c2 == 0 # actual deposit channel_proxy_1.set_total_deposit(10) events = channel_filter.get_all_entries() assert len(events) == 2 # ChannelOpened, ChannelNewDeposit # balance proof by c2 transferred_amount = 3 balance_proof = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount, ) balance_proof.signature = encode_hex(eth_sign( privkey=encode_hex(private_keys[1]), data=balance_proof.serialize_bin(), )) # correct close c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=decode_hex(balance_proof.signature), ) assert channel_proxy_1.closed() is True assert channel_proxy_2.closed() is True events = channel_filter.get_all_entries() assert len(events) == 3 # ChannelOpened, ChannelNewDeposit, ChannelClosed # check the settlement timeouts again assert channel_proxy_1.settle_timeout() == channel_proxy_2.settle_timeout() assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN # update transfer wait_until_block(c1_chain, c1_client.block_number() + TEST_SETTLE_TIMEOUT_MIN) c2_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=0, locked_amount=0, locksroot=EMPTY_HASH, partner=c1_client.address, partner_transferred_amount=transferred_amount, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert channel_proxy_1.settled() is True assert channel_proxy_2.settled() is True events = channel_filter.get_all_entries() assert len(events) == 4 # ChannelOpened, ChannelNewDeposit, ChannelClosed, ChannelSettled
def test_payment_channel_outdated_channel_close( token_network_proxy, private_keys, chain_id, web3, contract_manager, ): token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) partner = privatekey_to_address(private_keys[0]) client = JSONRPCClient(web3, private_keys[1]) chain = BlockChainService(client) token_network_proxy = TokenNetwork( jsonrpc_client=client, token_network_address=token_network_address, contract_manager=contract_manager, ) start_block = web3.eth.blockNumber # create a channel channel_identifier = token_network_proxy.new_netting_channel( partner, TEST_SETTLE_TIMEOUT_MIN, ) assert channel_identifier is not None # create channel proxies channel_proxy_1 = PaymentChannel( token_network=token_network_proxy, channel_identifier=channel_identifier, contract_manager=contract_manager, ) channel_filter = channel_proxy_1.all_events_filter( from_block=start_block, to_block='latest', ) assert channel_proxy_1.channel_identifier == channel_identifier assert channel_proxy_1.opened() is True # balance proof by c1 balance_proof = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=0, chain_id=chain_id, transferred_amount=0, ) balance_proof.signature = encode_hex( LocalSigner(private_keys[0]).sign( data=balance_proof.serialize_bin(), ), ) # correct close token_network_proxy.close( channel_identifier=channel_identifier, partner=partner, balance_hash=bytes(32), nonce=balance_proof.nonce, additional_hash=bytes(32), signature=decode_hex(balance_proof.signature), ) assert channel_proxy_1.closed() is True events = channel_filter.get_all_entries() assert len(events) == 2 # ChannelOpened, ChannelClosed # check the settlement timeouts again assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN # update transfer chain.wait_until_block(target_block_number=client.block_number() + TEST_SETTLE_TIMEOUT_MIN) token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=0, locked_amount=0, locksroot=EMPTY_HASH, partner=partner, partner_transferred_amount=0, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert channel_proxy_1.settled() is True events = channel_filter.get_all_entries() assert len(events) == 3 # ChannelOpened, ChannelClosed, ChannelSettled # Create a new channel with a different identifier # create a channel new_channel_identifier = token_network_proxy.new_netting_channel( partner, TEST_SETTLE_TIMEOUT_MIN, ) assert new_channel_identifier is not None # create channel proxies channel_proxy_2 = PaymentChannel( token_network=token_network_proxy, channel_identifier=new_channel_identifier, contract_manager=contract_manager, ) assert channel_proxy_2.channel_identifier == new_channel_identifier assert channel_proxy_2.opened() is True with pytest.raises(ChannelOutdatedError): token_network_proxy.close( channel_identifier=channel_identifier, partner=partner, balance_hash=bytes(32), nonce=balance_proof.nonce, additional_hash=bytes(32), signature=decode_hex(balance_proof.signature), )
def test_payment_channel_proxy_basics( token_network_proxy, private_keys, blockchain_rpc_ports, token_proxy, chain_id, web3, ): token_network_address = to_canonical_address(token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[1], web3=web3, ) c2_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[2], web3=web3, ) c1_token_network_proxy = TokenNetwork( c1_client, token_network_address, ) c2_token_network_proxy = TokenNetwork( c2_client, token_network_address, ) # create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.sender, TEST_SETTLE_TIMEOUT_MIN, ) assert channel_identifier is not None # create channel proxies channel_proxy_1 = PaymentChannel(c1_token_network_proxy, channel_identifier) channel_proxy_2 = PaymentChannel(c2_token_network_proxy, channel_identifier) channel_filter, unlock_filter = channel_proxy_1.all_events_filter( from_block=web3.eth.blockNumber, to_block='latest', ) assert channel_proxy_1.channel_identifier == channel_identifier assert channel_proxy_2.channel_identifier == channel_identifier assert channel_proxy_1.opened() is True assert channel_proxy_2.opened() is True # check the settlement timeouts assert channel_proxy_1.settle_timeout() == channel_proxy_2.settle_timeout() assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN events = channel_filter.get_all_entries() assert len(events) == 1 # ChannelOpened # test deposits initial_token_balance = 100 token_proxy.transfer(c1_client.sender, initial_token_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.sender) assert initial_balance_c1 == initial_token_balance initial_balance_c2 = token_proxy.balance_of(c2_client.sender) assert initial_balance_c2 == 0 # actual deposit channel_proxy_1.set_total_deposit(10) events = channel_filter.get_all_entries() assert len(events) == 2 # ChannelOpened, ChannelNewDeposit # balance proof by c2 transferred_amount = 3 balance_proof = BalanceProof( channel_identifier=encode_hex(channel_identifier), token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount, ) balance_proof.signature = encode_hex( sign_data(encode_hex(private_keys[1]), balance_proof.serialize_bin()), ) # correct close c2_token_network_proxy.close( c1_client.sender, balance_proof.nonce, decode_hex(balance_proof.balance_hash), decode_hex(balance_proof.additional_hash), decode_hex(balance_proof.signature), ) assert channel_proxy_1.closed() is True assert channel_proxy_2.closed() is True events = channel_filter.get_all_entries() assert len(events) == 3 # ChannelOpened, ChannelNewDeposit, ChannelClosed # check the settlement timeouts again assert channel_proxy_1.settle_timeout() == channel_proxy_2.settle_timeout() assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN # update transfer wait_blocks(c1_client.web3, TEST_SETTLE_TIMEOUT_MIN) c2_token_network_proxy.settle( 0, 0, EMPTY_HASH, c1_client.sender, transferred_amount, 0, EMPTY_HASH, ) assert channel_proxy_1.settled() is True assert channel_proxy_2.settled() is True events = channel_filter.get_all_entries() assert len(events) == 4 # ChannelOpened, ChannelNewDeposit, ChannelClosed, ChannelSettled
def test_token_network_proxy_update_transfer( token_network_proxy, private_keys, blockchain_rpc_ports, token_proxy, chain_id, web3, ): """Tests channel lifecycle, with `update_transfer` before settling""" token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[1], web3=web3, ) c2_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[2], web3=web3, ) c1_token_network_proxy = TokenNetwork( c1_client, token_network_address, ) c2_token_network_proxy = TokenNetwork( c2_client, token_network_address, ) # create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.sender, TEST_SETTLE_TIMEOUT_MIN, ) # deposit to the channel initial_balance = 100 token_proxy.transfer(c1_client.sender, initial_balance) token_proxy.transfer(c2_client.sender, initial_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.sender) assert initial_balance_c1 == initial_balance initial_balance_c2 = token_proxy.balance_of(c2_client.sender) assert initial_balance_c2 == initial_balance c1_token_network_proxy.set_total_deposit( 10, c2_client.sender, ) c2_token_network_proxy.set_total_deposit( 10, c1_client.sender, ) # balance proof signed by c1 transferred_amount_c1 = 1 transferred_amount_c2 = 3 balance_proof_c1 = BalanceProof( channel_identifier=encode_hex(channel_identifier), token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount_c1, ) balance_proof_c1.signature = encode_hex( sign_data(encode_hex(private_keys[1]), balance_proof_c1.serialize_bin()), ) # balance proof signed by c2 balance_proof_c2 = BalanceProof( channel_identifier=encode_hex(channel_identifier), token_network_address=to_checksum_address(token_network_address), nonce=2, chain_id=chain_id, transferred_amount=transferred_amount_c2, ) balance_proof_c2.signature = encode_hex( sign_data(encode_hex(private_keys[2]), balance_proof_c2.serialize_bin()), ) # close by c1 c1_token_network_proxy.close( c2_client.sender, balance_proof_c2.nonce, decode_hex(balance_proof_c2.balance_hash), decode_hex(balance_proof_c2.additional_hash), decode_hex(balance_proof_c2.signature), ) # using invalid non-closing signature # Usual mistake when calling update Transfer - balance proof signature is missing in the data non_closing_data = balance_proof_c1.serialize_bin() non_closing_signature = sign_data( encode_hex(c2_client.privkey), non_closing_data, ) with pytest.raises(TransactionThrew): c2_token_network_proxy.update_transfer( c1_client.sender, balance_proof_c1.nonce, decode_hex(balance_proof_c1.balance_hash), decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) non_closing_data = balance_proof_c1.serialize_bin() + decode_hex( balance_proof_c1.signature) non_closing_signature = sign_data( encode_hex(c2_client.privkey), non_closing_data, ) c2_token_network_proxy.update_transfer( c1_client.sender, balance_proof_c1.nonce, decode_hex(balance_proof_c1.balance_hash), decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) wait_blocks(c1_client.web3, TEST_SETTLE_TIMEOUT_MIN) # settling with an invalid amount with pytest.raises(TransactionThrew): c1_token_network_proxy.settle( 2, 0, EMPTY_HASH, c2_client.sender, 2, 0, EMPTY_HASH, ) # proper settle c1_token_network_proxy.settle( transferred_amount_c1, 0, EMPTY_HASH, c2_client.sender, transferred_amount_c2, 0, EMPTY_HASH, ) assert (token_proxy.balance_of( c2_client.sender) == (initial_balance_c2 + transferred_amount_c1 - transferred_amount_c2)) assert (token_proxy.balance_of( c1_client.sender) == (initial_balance_c1 + transferred_amount_c2 - transferred_amount_c1))
def test_payment_channel_outdated_channel_close( token_network_proxy, private_keys, blockchain_rpc_ports, token_proxy, chain_id, web3, ): token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) partner = privatekey_to_address(private_keys[0]) client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[1], web3=web3, ) token_network_proxy = TokenNetwork( client, token_network_address, ) # create a channel channel_identifier = token_network_proxy.new_netting_channel( partner, TEST_SETTLE_TIMEOUT_MIN, ) assert channel_identifier is not None # create channel proxies channel_proxy_1 = PaymentChannel(token_network_proxy, channel_identifier) channel_filter, _ = channel_proxy_1.all_events_filter( from_block=web3.eth.blockNumber, to_block='latest', ) assert channel_proxy_1.channel_identifier == channel_identifier assert channel_proxy_1.opened() is True # balance proof by c1 balance_proof = BalanceProof( channel_identifier=encode_hex(channel_identifier), token_network_address=to_checksum_address(token_network_address), nonce=0, chain_id=chain_id, transferred_amount=0, ) balance_proof.signature = encode_hex( sign_data(encode_hex(private_keys[0]), balance_proof.serialize_bin()), ) # correct close token_network_proxy.close( channel_identifier, partner, balance_proof.nonce, bytes(32), bytes(32), decode_hex(balance_proof.signature), ) assert channel_proxy_1.closed() is True events = channel_filter.get_all_entries() assert len(events) == 2 # ChannelOpened, ChannelClosed # check the settlement timeouts again assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN # update transfer wait_blocks(client.web3, TEST_SETTLE_TIMEOUT_MIN) token_network_proxy.settle( channel_identifier, 0, 0, EMPTY_HASH, partner, 0, 0, EMPTY_HASH, ) assert channel_proxy_1.settled() is True events = channel_filter.get_all_entries() assert len(events) == 3 # ChannelOpened, ChannelClosed, ChannelSettled # Create a new channel with a different identifier # create a channel new_channel_identifier = token_network_proxy.new_netting_channel( partner, TEST_SETTLE_TIMEOUT_MIN, ) assert new_channel_identifier is not None # create channel proxies channel_proxy_2 = PaymentChannel(token_network_proxy, new_channel_identifier) assert channel_proxy_2.channel_identifier == new_channel_identifier assert channel_proxy_2.opened() is True with pytest.raises(ChannelOutdatedError): token_network_proxy.close( channel_identifier, partner, balance_proof.nonce, bytes(32), bytes(32), decode_hex(balance_proof.signature), )
def test_token_network_proxy_update_transfer( token_network_proxy, private_keys, token_proxy, chain_id, web3, contract_manager, ): """Tests channel lifecycle, with `update_transfer` before settling""" token_network_address = to_canonical_address(token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient(web3, private_keys[1]) c1_chain = BlockChainService(private_keys[1], c1_client) c2_client = JSONRPCClient(web3, private_keys[2]) c1_token_network_proxy = TokenNetwork( jsonrpc_client=c1_client, token_network_address=token_network_address, contract_manager=contract_manager, ) c2_token_network_proxy = TokenNetwork( jsonrpc_client=c2_client, token_network_address=token_network_address, contract_manager=contract_manager, ) # create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.address, 10, ) # deposit to the channel initial_balance = 100 token_proxy.transfer(c1_client.address, initial_balance) token_proxy.transfer(c2_client.address, initial_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.address) assert initial_balance_c1 == initial_balance initial_balance_c2 = token_proxy.balance_of(c2_client.address) assert initial_balance_c2 == initial_balance c1_token_network_proxy.set_total_deposit( channel_identifier, 10, c2_client.address, ) c2_token_network_proxy.set_total_deposit( channel_identifier, 10, c1_client.address, ) # balance proof signed by c1 transferred_amount_c1 = 1 transferred_amount_c2 = 3 balance_proof_c1 = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount_c1, ) balance_proof_c1.signature = encode_hex(eth_sign( privkey=encode_hex(private_keys[1]), data=balance_proof_c1.serialize_bin(), )) # balance proof signed by c2 balance_proof_c2 = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=2, chain_id=chain_id, transferred_amount=transferred_amount_c2, ) balance_proof_c2.signature = encode_hex(eth_sign( privkey=encode_hex(private_keys[2]), data=balance_proof_c2.serialize_bin(), )) non_closing_data = balance_proof_c1.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE, ) + decode_hex(balance_proof_c1.signature) non_closing_signature = eth_sign( privkey=encode_hex(c2_client.privkey), data=non_closing_data, ) with pytest.raises(RaidenUnrecoverableError) as exc: c2_token_network_proxy.update_transfer( channel_identifier, c1_client.address, decode_hex(balance_proof_c1.balance_hash), balance_proof_c1.nonce, decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) assert 'not in a closed state' in str(exc) # close by c1 c1_token_network_proxy.close( channel_identifier=channel_identifier, partner=c2_client.address, balance_hash=decode_hex(balance_proof_c2.balance_hash), nonce=balance_proof_c2.nonce, additional_hash=decode_hex(balance_proof_c2.additional_hash), signature=decode_hex(balance_proof_c2.signature), ) # using invalid non-closing signature # Usual mistake when calling update Transfer - balance proof signature is missing in the data non_closing_data = balance_proof_c1.serialize_bin(msg_type=MessageTypeId.BALANCE_PROOF_UPDATE) non_closing_signature = eth_sign( privkey=encode_hex(c2_client.privkey), data=non_closing_data, ) with pytest.raises(RaidenUnrecoverableError): c2_token_network_proxy.update_transfer( channel_identifier, c1_client.address, decode_hex(balance_proof_c1.balance_hash), balance_proof_c1.nonce, decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) non_closing_data = balance_proof_c1.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE, ) + decode_hex(balance_proof_c1.signature) non_closing_signature = eth_sign( privkey=encode_hex(c2_client.privkey), data=non_closing_data, ) c2_token_network_proxy.update_transfer( channel_identifier, c1_client.address, decode_hex(balance_proof_c1.balance_hash), balance_proof_c1.nonce, decode_hex(balance_proof_c1.additional_hash), decode_hex(balance_proof_c1.signature), non_closing_signature, ) with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=transferred_amount_c1, locked_amount=0, locksroot=EMPTY_HASH, partner=c2_client.address, partner_transferred_amount=transferred_amount_c2, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert 'cannot be settled before settlement window is over' in str(exc) wait_until_block(c1_chain, c1_chain.block_number() + 10) # settling with an invalid amount with pytest.raises(RaidenUnrecoverableError): c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=2, locked_amount=0, locksroot=EMPTY_HASH, partner=c2_client.address, partner_transferred_amount=2, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) # proper settle c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=transferred_amount_c1, locked_amount=0, locksroot=EMPTY_HASH, partner=c2_client.address, partner_transferred_amount=transferred_amount_c2, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert (token_proxy.balance_of(c2_client.address) == (initial_balance_c2 + transferred_amount_c1 - transferred_amount_c2)) assert (token_proxy.balance_of(c1_client.address) == (initial_balance_c1 + transferred_amount_c2 - transferred_amount_c1)) # Already settled with pytest.raises(RaidenUnrecoverableError) as exc: c2_token_network_proxy.set_total_deposit( channel_identifier, 20, c1_client.address, ) assert 'getChannelIdentifier returned 0' in str(exc)
def test_token_network_proxy_basics( token_network_proxy, private_keys, blockchain_rpc_ports, token_proxy, chain_id, web3, ): # check settlement timeouts assert token_network_proxy.settlement_timeout_min() == TEST_SETTLE_TIMEOUT_MIN assert token_network_proxy.settlement_timeout_max() == TEST_SETTLE_TIMEOUT_MAX token_network_address = to_canonical_address(token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[1], web3=web3, ) c2_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[2], web3=web3, ) c1_token_network_proxy = TokenNetwork( c1_client, token_network_address, ) c2_token_network_proxy = TokenNetwork( c2_client, token_network_address, ) # instantiating a new channel - test basic assumptions assert c1_token_network_proxy.channel_exists(c1_client.sender, c2_client.sender) is False assert c1_token_network_proxy.channel_is_opened(c1_client.sender, c2_client.sender) is False assert c1_token_network_proxy.channel_is_closed(c1_client.sender, c2_client.sender) is False # test timeout limits with pytest.raises(InvalidSettleTimeout): c1_token_network_proxy.new_netting_channel( c2_client.sender, TEST_SETTLE_TIMEOUT_MIN - 1, ) with pytest.raises(InvalidSettleTimeout): c1_token_network_proxy.new_netting_channel( c2_client.sender, TEST_SETTLE_TIMEOUT_MAX + 1, ) # channel to self with pytest.raises(SamePeerAddress): c1_token_network_proxy.new_netting_channel( c1_client.sender, TEST_SETTLE_TIMEOUT_MIN, ) # actually create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.sender, TEST_SETTLE_TIMEOUT_MIN, ) assert channel_identifier is not None # multiple channels with the same peer are not allowed with pytest.raises(DuplicatedChannelError): c1_token_network_proxy.new_netting_channel( c2_client.sender, TEST_SETTLE_TIMEOUT_MIN, ) assert c1_token_network_proxy.channel_exists(c1_client.sender, c2_client.sender) is True assert c1_token_network_proxy.channel_is_opened(c1_client.sender, c2_client.sender) is True # channel is open. # deposit with no balance with pytest.raises(ValueError): c1_token_network_proxy.set_total_deposit( 10, c2_client.sender, ) # test deposits initial_token_balance = 100 token_proxy.transfer(c1_client.sender, initial_token_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.sender) assert initial_balance_c1 == initial_token_balance initial_balance_c2 = token_proxy.balance_of(c2_client.sender) assert initial_balance_c2 == 0 # no negative deposit with pytest.raises(ValueError): c1_token_network_proxy.set_total_deposit( -1, c2_client.sender, ) # actual deposit c1_token_network_proxy.set_total_deposit( 10, c2_client.sender, ) # balance proof by c2 transferred_amount = 3 balance_proof = BalanceProof( channel_identifier=encode_hex(channel_identifier), token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount, ) balance_proof.signature = encode_hex( sign_data(encode_hex(private_keys[1]), balance_proof.serialize_bin()), ) # close with invalid signature with pytest.raises(TransactionThrew): c2_token_network_proxy.close( c1_client.sender, balance_proof.nonce, decode_hex(balance_proof.balance_hash), decode_hex(balance_proof.additional_hash), b'\x11' * 65, ) # correct close c2_token_network_proxy.close( c1_client.sender, balance_proof.nonce, decode_hex(balance_proof.balance_hash), decode_hex(balance_proof.additional_hash), decode_hex(balance_proof.signature), ) assert c1_token_network_proxy.channel_is_closed(c1_client.sender, c2_client.sender) is True assert c1_token_network_proxy.channel_exists(c1_client.sender, c2_client.sender) is True # closing already closed channel with pytest.raises(ChannelIncorrectStateError): c2_token_network_proxy.close( c1_client.sender, balance_proof.nonce, decode_hex(balance_proof.balance_hash), decode_hex(balance_proof.additional_hash), decode_hex(balance_proof.signature), ) # update transfer wait_blocks(c1_client.web3, TEST_SETTLE_TIMEOUT_MIN) c2_token_network_proxy.settle( 0, 0, EMPTY_HASH, c1_client.sender, transferred_amount, 0, EMPTY_HASH, ) assert c1_token_network_proxy.channel_exists(c1_client.sender, c2_client.sender) is False assert token_proxy.balance_of(c1_client.sender) == (initial_balance_c1 - transferred_amount) assert token_proxy.balance_of(c2_client.sender) == (initial_balance_c2 + transferred_amount)
def test_payment_channel_proxy_basics( token_network_proxy, private_keys, blockchain_rpc_ports, token_proxy, chain_id, web3, ): token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[1], web3=web3, ) c2_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[2], web3=web3, ) c1_token_network_proxy = TokenNetwork( c1_client, token_network_address, ) c2_token_network_proxy = TokenNetwork( c2_client, token_network_address, ) # create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.sender, TEST_SETTLE_TIMEOUT_MIN, ) assert channel_identifier is not None # create channel proxies channel_proxy_1 = PaymentChannel(c1_token_network_proxy, channel_identifier) channel_proxy_2 = PaymentChannel(c2_token_network_proxy, channel_identifier) channel_filter, unlock_filter = channel_proxy_1.all_events_filter( from_block=web3.eth.blockNumber, to_block='latest', ) assert channel_proxy_1.channel_identifier == channel_identifier assert channel_proxy_2.channel_identifier == channel_identifier assert channel_proxy_1.opened() is True assert channel_proxy_2.opened() is True # check the settlement timeouts assert channel_proxy_1.settle_timeout() == channel_proxy_2.settle_timeout() assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN events = channel_filter.get_all_entries() assert len(events) == 1 # ChannelOpened # test deposits initial_token_balance = 100 token_proxy.transfer(c1_client.sender, initial_token_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.sender) assert initial_balance_c1 == initial_token_balance initial_balance_c2 = token_proxy.balance_of(c2_client.sender) assert initial_balance_c2 == 0 # actual deposit channel_proxy_1.set_total_deposit(10) events = channel_filter.get_all_entries() assert len(events) == 2 # ChannelOpened, ChannelNewDeposit # balance proof by c2 transferred_amount = 3 balance_proof = BalanceProof( channel_identifier=encode_hex(channel_identifier), token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount, ) balance_proof.signature = encode_hex( sign_data(encode_hex(private_keys[1]), balance_proof.serialize_bin()), ) # correct close c2_token_network_proxy.close( channel_identifier, c1_client.sender, balance_proof.nonce, decode_hex(balance_proof.balance_hash), decode_hex(balance_proof.additional_hash), decode_hex(balance_proof.signature), ) assert channel_proxy_1.closed() is True assert channel_proxy_2.closed() is True events = channel_filter.get_all_entries() assert len(events) == 3 # ChannelOpened, ChannelNewDeposit, ChannelClosed # check the settlement timeouts again assert channel_proxy_1.settle_timeout() == channel_proxy_2.settle_timeout() assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN # update transfer wait_blocks(c1_client.web3, TEST_SETTLE_TIMEOUT_MIN) c2_token_network_proxy.settle( channel_identifier, 0, 0, EMPTY_HASH, c1_client.sender, transferred_amount, 0, EMPTY_HASH, ) assert channel_proxy_1.settled() is True assert channel_proxy_2.settled() is True events = channel_filter.get_all_entries() assert len( events ) == 4 # ChannelOpened, ChannelNewDeposit, ChannelClosed, ChannelSettled
def test_token_network_proxy_update_transfer( token_network_proxy, private_keys, token_proxy, chain_id, web3, contract_manager, ): """Tests channel lifecycle, with `update_transfer` before settling""" token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient(web3, private_keys[1]) c1_chain = BlockChainService(c1_client) c2_client = JSONRPCClient(web3, private_keys[2]) c1_token_network_proxy = TokenNetwork( jsonrpc_client=c1_client, token_network_address=token_network_address, contract_manager=contract_manager, ) c2_token_network_proxy = TokenNetwork( jsonrpc_client=c2_client, token_network_address=token_network_address, contract_manager=contract_manager, ) # create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( partner=c2_client.address, settle_timeout=10, given_block_identifier='latest', ) # deposit to the channel initial_balance = 100 token_proxy.transfer(c1_client.address, initial_balance, 'latest') token_proxy.transfer(c2_client.address, initial_balance, 'latest') initial_balance_c1 = token_proxy.balance_of(c1_client.address) assert initial_balance_c1 == initial_balance initial_balance_c2 = token_proxy.balance_of(c2_client.address) assert initial_balance_c2 == initial_balance c1_token_network_proxy.set_total_deposit( given_block_identifier='latest', channel_identifier=channel_identifier, total_deposit=10, partner=c2_client.address, ) c2_token_network_proxy.set_total_deposit( given_block_identifier='latest', channel_identifier=channel_identifier, total_deposit=10, partner=c1_client.address, ) # balance proof signed by c1 transferred_amount_c1 = 1 transferred_amount_c2 = 3 balance_proof_c1 = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount_c1, ) balance_proof_c1.signature = encode_hex( LocalSigner(private_keys[1]).sign( data=balance_proof_c1.serialize_bin(), ), ) # balance proof signed by c2 balance_proof_c2 = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=2, chain_id=chain_id, transferred_amount=transferred_amount_c2, ) balance_proof_c2.signature = encode_hex( LocalSigner(private_keys[2]).sign( data=balance_proof_c2.serialize_bin(), ), ) non_closing_data = balance_proof_c1.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE, ) + decode_hex( balance_proof_c1.signature) non_closing_signature = LocalSigner(c2_client.privkey).sign( data=non_closing_data, ) with pytest.raises(RaidenUnrecoverableError) as exc: c2_token_network_proxy.update_transfer( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof_c1.balance_hash), nonce=balance_proof_c1.nonce, additional_hash=decode_hex(balance_proof_c1.additional_hash), closing_signature=decode_hex(balance_proof_c1.signature), non_closing_signature=non_closing_signature, given_block_identifier='latest', ) assert 'not in a closed state' in str(exc) # close by c1 c1_token_network_proxy.close( channel_identifier=channel_identifier, partner=c2_client.address, balance_hash=decode_hex(balance_proof_c2.balance_hash), nonce=balance_proof_c2.nonce, additional_hash=decode_hex(balance_proof_c2.additional_hash), signature=decode_hex(balance_proof_c2.signature), given_block_identifier='latest', ) # update transfer with completely invalid closing signature with pytest.raises(RaidenUnrecoverableError) as excinfo: c2_token_network_proxy.update_transfer( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof_c1.balance_hash), nonce=balance_proof_c1.nonce, additional_hash=decode_hex(balance_proof_c1.additional_hash), closing_signature=b'', non_closing_signature=b'', given_block_identifier='latest', ) assert str(excinfo.value) == "Couldn't verify the balance proof signature" # using invalid non-closing signature # Usual mistake when calling update Transfer - balance proof signature is missing in the data non_closing_data = balance_proof_c1.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE) non_closing_signature = LocalSigner(c2_client.privkey).sign( data=non_closing_data, ) with pytest.raises(RaidenUnrecoverableError): c2_token_network_proxy.update_transfer( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof_c1.balance_hash), nonce=balance_proof_c1.nonce, additional_hash=decode_hex(balance_proof_c1.additional_hash), closing_signature=decode_hex(balance_proof_c1.signature), non_closing_signature=non_closing_signature, given_block_identifier='latest', ) non_closing_data = balance_proof_c1.serialize_bin( msg_type=MessageTypeId.BALANCE_PROOF_UPDATE, ) + decode_hex( balance_proof_c1.signature) non_closing_signature = LocalSigner(c2_client.privkey).sign( data=non_closing_data, ) c2_token_network_proxy.update_transfer( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof_c1.balance_hash), nonce=balance_proof_c1.nonce, additional_hash=decode_hex(balance_proof_c1.additional_hash), closing_signature=decode_hex(balance_proof_c1.signature), non_closing_signature=non_closing_signature, given_block_identifier='latest', ) with pytest.raises(RaidenUnrecoverableError) as exc: c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=transferred_amount_c1, locked_amount=0, locksroot=EMPTY_HASH, partner=c2_client.address, partner_transferred_amount=transferred_amount_c2, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, given_block_identifier='latest', ) assert 'cannot be settled before settlement window is over' in str(exc) c1_chain.wait_until_block(target_block_number=c1_chain.block_number() + 10) # settling with an invalid amount with pytest.raises(RaidenUnrecoverableError): c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=2, locked_amount=0, locksroot=EMPTY_HASH, partner=c2_client.address, partner_transferred_amount=2, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, given_block_identifier='latest', ) # proper settle c1_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=transferred_amount_c1, locked_amount=0, locksroot=EMPTY_HASH, partner=c2_client.address, partner_transferred_amount=transferred_amount_c2, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, given_block_identifier='latest', ) assert (token_proxy.balance_of( c2_client.address) == (initial_balance_c2 + transferred_amount_c1 - transferred_amount_c2)) assert (token_proxy.balance_of( c1_client.address) == (initial_balance_c1 + transferred_amount_c2 - transferred_amount_c1)) # Already settled with pytest.raises(RaidenUnrecoverableError) as exc: c2_token_network_proxy.set_total_deposit( given_block_identifier='latest', channel_identifier=channel_identifier, total_deposit=20, partner=c1_client.address, ) assert 'getChannelIdentifier returned 0' in str(exc)
def test_token_network_proxy_basics( token_network_proxy, private_keys, blockchain_rpc_ports, token_proxy, chain_id, web3, ): # check settlement timeouts assert token_network_proxy.settlement_timeout_min( ) == TEST_SETTLE_TIMEOUT_MIN assert token_network_proxy.settlement_timeout_max( ) == TEST_SETTLE_TIMEOUT_MAX token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[1], web3=web3, ) c2_client = JSONRPCClient( '0.0.0.0', blockchain_rpc_ports[0], private_keys[2], web3=web3, ) c1_token_network_proxy = TokenNetwork( c1_client, token_network_address, ) c2_token_network_proxy = TokenNetwork( c2_client, token_network_address, ) # instantiating a new channel - test basic assumptions assert c1_token_network_proxy.channel_exists(c1_client.sender, c2_client.sender) is False assert c1_token_network_proxy.channel_is_opened(c1_client.sender, c2_client.sender) is False assert c1_token_network_proxy.channel_is_closed(c1_client.sender, c2_client.sender) is False # test timeout limits with pytest.raises(InvalidSettleTimeout): c1_token_network_proxy.new_netting_channel( c2_client.sender, TEST_SETTLE_TIMEOUT_MIN - 1, ) with pytest.raises(InvalidSettleTimeout): c1_token_network_proxy.new_netting_channel( c2_client.sender, TEST_SETTLE_TIMEOUT_MAX + 1, ) # channel to self with pytest.raises(SamePeerAddress): c1_token_network_proxy.new_netting_channel( c1_client.sender, TEST_SETTLE_TIMEOUT_MIN, ) # actually create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.sender, TEST_SETTLE_TIMEOUT_MIN, ) assert channel_identifier is not None # multiple channels with the same peer are not allowed with pytest.raises(DuplicatedChannelError): c1_token_network_proxy.new_netting_channel( c2_client.sender, TEST_SETTLE_TIMEOUT_MIN, ) assert c1_token_network_proxy.channel_exists(c1_client.sender, c2_client.sender) is True assert c1_token_network_proxy.channel_is_opened(c1_client.sender, c2_client.sender) is True # channel is open. # deposit with no balance with pytest.raises(ValueError): c1_token_network_proxy.set_total_deposit( 10, c2_client.sender, ) # test deposits initial_token_balance = 100 token_proxy.transfer(c1_client.sender, initial_token_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.sender) assert initial_balance_c1 == initial_token_balance initial_balance_c2 = token_proxy.balance_of(c2_client.sender) assert initial_balance_c2 == 0 # no negative deposit with pytest.raises(DepositMismatch): c1_token_network_proxy.set_total_deposit( -1, c2_client.sender, ) # actual deposit c1_token_network_proxy.set_total_deposit( 10, c2_client.sender, ) # balance proof by c2 transferred_amount = 3 balance_proof = BalanceProof( channel_identifier=encode_hex(channel_identifier), token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount, ) balance_proof.signature = encode_hex( sign_data(encode_hex(private_keys[1]), balance_proof.serialize_bin()), ) # close with invalid signature with pytest.raises(TransactionThrew): c2_token_network_proxy.close( c1_client.sender, balance_proof.nonce, decode_hex(balance_proof.balance_hash), decode_hex(balance_proof.additional_hash), b'\x11' * 65, ) # correct close c2_token_network_proxy.close( c1_client.sender, balance_proof.nonce, decode_hex(balance_proof.balance_hash), decode_hex(balance_proof.additional_hash), decode_hex(balance_proof.signature), ) assert c1_token_network_proxy.channel_is_closed(c1_client.sender, c2_client.sender) is True assert c1_token_network_proxy.channel_exists(c1_client.sender, c2_client.sender) is True # closing already closed channel with pytest.raises(ChannelIncorrectStateError): c2_token_network_proxy.close( c1_client.sender, balance_proof.nonce, decode_hex(balance_proof.balance_hash), decode_hex(balance_proof.additional_hash), decode_hex(balance_proof.signature), ) # update transfer wait_blocks(c1_client.web3, TEST_SETTLE_TIMEOUT_MIN) c2_token_network_proxy.settle( 0, 0, EMPTY_HASH, c1_client.sender, transferred_amount, 0, EMPTY_HASH, ) assert c1_token_network_proxy.channel_exists(c1_client.sender, c2_client.sender) is False assert token_proxy.balance_of(c1_client.sender) == (initial_balance_c1 - transferred_amount) assert token_proxy.balance_of(c2_client.sender) == (initial_balance_c2 + transferred_amount)
def test_payment_channel_proxy_basics( token_network_proxy, private_keys, token_proxy, chain_id, web3, contract_manager, ): token_network_address = to_canonical_address( token_network_proxy.proxy.contract.address) c1_client = JSONRPCClient(web3, private_keys[1]) c1_chain = BlockChainService(c1_client) c2_client = JSONRPCClient(web3, private_keys[2]) c1_token_network_proxy = TokenNetwork( jsonrpc_client=c1_client, token_network_address=token_network_address, contract_manager=contract_manager, ) c2_token_network_proxy = TokenNetwork( jsonrpc_client=c2_client, token_network_address=token_network_address, contract_manager=contract_manager, ) start_block = web3.eth.blockNumber # create a channel channel_identifier = c1_token_network_proxy.new_netting_channel( c2_client.address, TEST_SETTLE_TIMEOUT_MIN, ) assert channel_identifier is not None # create channel proxies channel_proxy_1 = PaymentChannel( token_network=c1_token_network_proxy, channel_identifier=channel_identifier, contract_manager=contract_manager, ) channel_proxy_2 = PaymentChannel( token_network=c2_token_network_proxy, channel_identifier=channel_identifier, contract_manager=contract_manager, ) channel_filter = channel_proxy_1.all_events_filter( from_block=start_block, to_block='latest', ) assert channel_proxy_1.channel_identifier == channel_identifier assert channel_proxy_2.channel_identifier == channel_identifier assert channel_proxy_1.opened() is True assert channel_proxy_2.opened() is True # check the settlement timeouts assert channel_proxy_1.settle_timeout() == channel_proxy_2.settle_timeout() assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN events = channel_filter.get_all_entries() assert len(events) == 1 # ChannelOpened # test deposits initial_token_balance = 100 token_proxy.transfer(c1_client.address, initial_token_balance) initial_balance_c1 = token_proxy.balance_of(c1_client.address) assert initial_balance_c1 == initial_token_balance initial_balance_c2 = token_proxy.balance_of(c2_client.address) assert initial_balance_c2 == 0 # actual deposit channel_proxy_1.set_total_deposit(10) events = channel_filter.get_all_entries() assert len(events) == 2 # ChannelOpened, ChannelNewDeposit # balance proof by c2 transferred_amount = 3 balance_proof = BalanceProof( channel_identifier=channel_identifier, token_network_address=to_checksum_address(token_network_address), nonce=1, chain_id=chain_id, transferred_amount=transferred_amount, ) balance_proof.signature = encode_hex( LocalSigner(private_keys[1]).sign( data=balance_proof.serialize_bin(), ), ) # correct close c2_token_network_proxy.close( channel_identifier=channel_identifier, partner=c1_client.address, balance_hash=decode_hex(balance_proof.balance_hash), nonce=balance_proof.nonce, additional_hash=decode_hex(balance_proof.additional_hash), signature=decode_hex(balance_proof.signature), ) assert channel_proxy_1.closed() is True assert channel_proxy_2.closed() is True events = channel_filter.get_all_entries() assert len(events) == 3 # ChannelOpened, ChannelNewDeposit, ChannelClosed # check the settlement timeouts again assert channel_proxy_1.settle_timeout() == channel_proxy_2.settle_timeout() assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN # update transfer c1_chain.wait_until_block(target_block_number=c1_client.block_number() + TEST_SETTLE_TIMEOUT_MIN, ) c2_token_network_proxy.settle( channel_identifier=channel_identifier, transferred_amount=0, locked_amount=0, locksroot=EMPTY_HASH, partner=c1_client.address, partner_transferred_amount=transferred_amount, partner_locked_amount=0, partner_locksroot=EMPTY_HASH, ) assert channel_proxy_1.settled() is True assert channel_proxy_2.settled() is True events = channel_filter.get_all_entries() assert len( events ) == 4 # ChannelOpened, ChannelNewDeposit, ChannelClosed, ChannelSettled