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
