def handle_contract_send_channelupdate(
raiden: RaidenService,
channel_update_event: ContractSendChannelUpdateTransfer,
):
balance_proof = channel_update_event.balance_proof
if balance_proof:
channel = raiden.chain.payment_channel(
token_network_address=channel_update_event.
token_network_identifier,
channel_id=channel_update_event.channel_identifier,
)
non_closing_data = pack_balance_proof_update(
nonce=balance_proof.nonce,
balance_hash=balance_proof.balance_hash,
additional_hash=balance_proof.message_hash,
channel_identifier=balance_proof.channel_identifier,
token_network_identifier=balance_proof.token_network_identifier,
chain_id=balance_proof.chain_id,
partner_signature=balance_proof.signature,
)
our_signature = eth_sign(privkey=raiden.privkey, data=non_closing_data)
try:
channel.update_transfer(
balance_proof.nonce,
balance_proof.balance_hash,
balance_proof.message_hash,
balance_proof.signature,
our_signature,
)
except ChannelOutdatedError as e:
log.error(str(e))
def f():
balance_proof = get_random_bp()
privkey = get_random_privkey()
privkey_non_closing = get_random_privkey()
balance_proof.signature = encode_hex(
eth_sign(privkey, balance_proof.serialize_bin()))
non_closing_signature = encode_hex(
eth_sign(privkey_non_closing, balance_proof.serialize_bin()), )
monitor_request = MonitorRequest(
balance_proof,
non_closing_signature,
reward_amount=random.randint(0, UINT192_MAX),
monitor_address=get_random_address(),
)
monitor_request.reward_proof_signature = encode_hex(
eth_sign(privkey, monitor_request.serialize_reward_proof()), )
return monitor_request
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 make_signed_balance_proof(
nonce: typing.Nonce = EMPTY,
transferred_amount: typing.TokenAmount = EMPTY,
locked_amount: typing.TokenAmount = EMPTY,
token_network_address: typing.TokenNetworkID = EMPTY,
channel_identifier: typing.ChannelID = EMPTY,
locksroot: typing.Locksroot = EMPTY,
extra_hash: typing.Keccak256 = EMPTY,
private_key: PrivateKey = EMPTY,
sender_address: typing.Address = EMPTY,
) -> BalanceProofSignedState:
nonce = if_empty(nonce, make_uint256())
transferred_amount = if_empty(transferred_amount, make_uint256())
locked_amount = if_empty(locked_amount, make_uint256())
token_network_address = if_empty(token_network_address, make_address())
channel_identifier = if_empty(channel_identifier, make_uint256())
locksroot = if_empty(locksroot, make_32bytes())
extra_hash = if_empty(extra_hash, make_keccak_hash())
private_key = if_empty(private_key, make_privatekey())
sender_address = if_empty(sender_address, make_address())
balance_hash = hash_balance_data(
transferred_amount=transferred_amount,
locked_amount=locked_amount,
locksroot=locksroot,
)
data_to_sign = balance_proof.pack_balance_proof(
nonce=nonce,
balance_hash=balance_hash,
additional_hash=extra_hash,
channel_identifier=channel_identifier,
token_network_identifier=token_network_address,
chain_id=UNIT_CHAIN_ID,
)
signature = eth_sign(privkey=private_key, data=data_to_sign)
return BalanceProofSignedState(
nonce=nonce,
transferred_amount=transferred_amount,
locked_amount=locked_amount,
locksroot=locksroot,
token_network_identifier=token_network_address,
channel_identifier=channel_identifier,
message_hash=extra_hash,
signature=signature,
sender=sender_address,
chain_id=UNIT_CHAIN_ID,
)
def make_signed_balance_proof(
nonce,
transferred_amount,
locked_amount,
token_network_address,
channel_identifier,
locksroot,
extra_hash,
private_key,
sender_address,
):
balance_hash = hash_balance_data(
transferred_amount,
locked_amount,
locksroot,
)
data_to_sign = balance_proof.pack_balance_proof(
nonce=nonce,
balance_hash=balance_hash,
additional_hash=extra_hash,
channel_identifier=channel_identifier,
token_network_identifier=token_network_address,
chain_id=UNIT_CHAIN_ID,
)
signature = eth_sign(privkey=private_key, data=data_to_sign)
signed_balance_proof = BalanceProofSignedState(
nonce,
transferred_amount,
locked_amount,
locksroot,
token_network_address,
channel_identifier,
extra_hash,
signature,
sender_address,
UNIT_CHAIN_ID,
)
return signed_balance_proof
def find_max_pending_transfers(gas_limit):
"""Measure gas consumption of TokenNetwork.unlock() depending on number of
pending transfers and find the maximum number of pending transfers so
gas_limit is not exceeded."""
tester = ContractTester(generate_keys=2)
tester.deploy_contract('SecretRegistry')
tester.deploy_contract(
'HumanStandardToken',
_initialAmount=100000,
_decimalUnits=3,
_tokenName='SomeToken',
_tokenSymbol='SMT',
)
tester.deploy_contract(
'TokenNetwork',
_token_address=tester.contract_address('HumanStandardToken'),
_secret_registry=tester.contract_address('SecretRegistry'),
_chain_id=1,
_settlement_timeout_min=100,
_settlement_timeout_max=200,
)
tester.call_transaction(
'HumanStandardToken',
'transfer',
_to=tester.accounts[1],
_value=10000,
)
receipt = tester.call_transaction(
'TokenNetwork',
'openChannel',
participant1=tester.accounts[0],
participant2=tester.accounts[1],
settle_timeout=150,
)
channel_identifier = int(hexlify(receipt['logs'][0]['topics'][1]), 16)
tester.call_transaction(
'HumanStandardToken',
'approve',
sender=tester.accounts[0],
_spender=tester.contract_address('TokenNetwork'),
_value=10000,
)
tester.call_transaction(
'HumanStandardToken',
'approve',
sender=tester.accounts[1],
_spender=tester.contract_address('TokenNetwork'),
_value=5000,
)
tester.call_transaction(
'TokenNetwork',
'setTotalDeposit',
channel_identifier=channel_identifier,
participant=tester.accounts[0],
total_deposit=5000,
partner=tester.accounts[1],
)
tester.call_transaction(
'TokenNetwork',
'setTotalDeposit',
channel_identifier=channel_identifier,
participant=tester.accounts[1],
total_deposit=2000,
partner=tester.accounts[0],
)
print(
"Measuring unlock()'s gas cost for different Merkle tree widths, can take a while..."
)
before_closing = tester.tester.take_snapshot()
enough = 0
too_much = 1024
nonce = 10
additional_hash = urandom(32)
token_network_identifier = tester.contract_address('TokenNetwork')
while enough + 1 < too_much:
tree_size = (enough + too_much) // 2
tester.tester.revert_to_snapshot(before_closing)
pending_transfers_tree = get_pending_transfers_tree(
tester.web3,
unlockable_amounts=[1] * tree_size,
)
balance_hash = hash_balance_data(3000, 2000,
pending_transfers_tree.merkle_root)
data_to_sign = pack_balance_proof(
nonce=nonce,
balance_hash=balance_hash,
additional_hash=additional_hash,
channel_identifier=channel_identifier,
token_network_identifier=token_network_identifier,
chain_id=1,
)
signature = eth_sign(privkey=tester.private_keys[1], data=data_to_sign)
tester.call_transaction(
'TokenNetwork',
'closeChannel',
channel_identifier=channel_identifier,
partner=tester.accounts[1],
balance_hash=balance_hash,
nonce=nonce,
additional_hash=additional_hash,
signature=signature,
)
tester.tester.mine_blocks(160) # close settlement window
tester.call_transaction(
'TokenNetwork',
'settleChannel',
channel_identifier=channel_identifier,
participant1=tester.accounts[0],
participant1_transferred_amount=0,
participant1_locked_amount=0,
participant1_locksroot=b'\x00' * 32,
participant2=tester.accounts[1],
participant2_transferred_amount=3000,
participant2_locked_amount=2000,
participant2_locksroot=pending_transfers_tree.merkle_root,
)
receipt = tester.call_transaction(
'TokenNetwork',
'unlock',
channel_identifier=channel_identifier,
participant=tester.accounts[0],
partner=tester.accounts[1],
merkle_tree_leaves=pending_transfers_tree.packed_transfers,
)
gas_used = receipt['gasUsed']
if gas_used <= gas_limit:
enough = tree_size
print(
f'{tree_size} pending transfers work ({gas_used} gas needed to unlock)'
)
else:
too_much = tree_size
print(
f'{tree_size} pending transfers are too much ({gas_used} gas needed to unlock)'
)
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 _sign(self, data: bytes) -> bytes:
""" Use eth_sign compatible hasher to sign matrix data """
return eth_sign(
privkey=self._raiden_service.private_key,
data=data,
)
def test_payment_channel_proxy_basics(
token_network_proxy,
private_keys,
token_proxy,
chain_id,
web3,
):
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(
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 = 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=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.sender,
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_blocks(c1_client.web3, 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.sender,
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,
):
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])
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=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_blocks(client.web3, 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_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=channel_identifier,
partner=partner,
balance_hash=bytes(32),
nonce=balance_proof.nonce,
additional_hash=bytes(32),
signature=decode_hex(balance_proof.signature),
)
