def test_close_channel_event_no_offchain_transfers( get_accounts, token_network, create_channel, event_handler, ): """ closeChannel succeeds and emits an event even with nonce 0 and no balance proofs """ ev_handler = event_handler(token_network) (A, B) = get_accounts(2) channel_identifier = create_channel(A, B)[0] # No off-chain transfers have occured # There is no signature data here, because it was never provided to A txn_hash = token_network.functions.closeChannel( channel_identifier, B, EMPTY_BALANCE_HASH, 0, EMPTY_ADDITIONAL_HASH, EMPTY_SIGNATURE, ).transact({'from': A}) ev_handler.add(txn_hash, ChannelEvent.CLOSED, check_channel_closed(channel_identifier, A, 0)) ev_handler.check()
def test_close_channel_event( get_accounts, token_network, create_channel, channel_deposit, create_balance_proof, event_handler, ): """ A successful closeChannel call produces a CLOSED event """ ev_handler = event_handler(token_network) (A, B) = get_accounts(2) deposit_A = 10 channel_identifier = create_channel(A, B)[0] channel_deposit(channel_identifier, A, deposit_A, B) balance_proof = create_balance_proof( channel_identifier, B, transferred_amount=5, locked_amount=0, nonce=3, ) txn_hash = token_network.functions.closeChannel( channel_identifier, B, *balance_proof, ).transact({'from': A}) ev_handler.add(txn_hash, ChannelEvent.CLOSED, check_channel_closed(channel_identifier, A, 3)) ev_handler.check()
def test_close_channel_event( get_accounts: Callable, token_network: Contract, create_channel: Callable, channel_deposit: Callable, create_balance_proof: Callable, event_handler: Callable, create_balance_proof_countersignature: Callable, ) -> None: """ A successful closeChannel call produces a CLOSED event """ ev_handler = event_handler(token_network) (A, B) = get_accounts(2) deposit_A = 10 channel_identifier = create_channel(A, B)[0] channel_deposit(channel_identifier, A, deposit_A, B) balance_proof = create_balance_proof(channel_identifier, B, transferred_amount=5, locked_amount=0, nonce=3) close_sig = create_balance_proof_countersignature( A, channel_identifier, MessageTypeId.BALANCE_PROOF, *balance_proof) txn_hash = token_network.functions.closeChannel( channel_identifier, B, A, *balance_proof, close_sig).call_and_transact({"from": A}) ev_handler.add( txn_hash, ChannelEvent.CLOSED, check_channel_closed(channel_identifier, A, 3, balance_proof[0]), ) ev_handler.check()
def test_close_channel_event_no_offchain_transfers( get_accounts: Callable, token_network: Contract, create_channel: Callable, event_handler: Callable, create_close_signature_for_no_balance_proof: Callable, ) -> None: """ closeChannel succeeds and emits an event even with nonce 0 and no balance proofs """ ev_handler = event_handler(token_network) (A, B) = get_accounts(2) channel_identifier = create_channel(A, B)[0] closing_sig = create_close_signature_for_no_balance_proof( A, channel_identifier) # No off-chain transfers have occured # There is no signature data here, because it was never provided to A txn_hash = token_network.functions.closeChannel( channel_identifier, B, A, EMPTY_BALANCE_HASH, 0, EMPTY_ADDITIONAL_HASH, EMPTY_SIGNATURE, closing_sig, ).call_and_transact({"from": A}) ev_handler.add( txn_hash, ChannelEvent.CLOSED, check_channel_closed(channel_identifier, A, 0, EMPTY_BALANCE_HASH), ) ev_handler.check()
def test_close_channel_event_no_offchain_transfers( get_accounts, token_network, create_channel, create_balance_proof, event_handler, ): ev_handler = event_handler(token_network) (A, B) = get_accounts(2) channel_identifier = create_channel(A, B)[0] # No off-chain transfers have occured # There is no signature data here, because it was never provided to A txn_hash = token_network.functions.closeChannel( B, fake_bytes(32), 0, fake_bytes(32), fake_bytes(64), ).transact({'from': A}) ev_handler.add(txn_hash, EVENT_CHANNEL_CLOSED, check_channel_closed(channel_identifier, A)) ev_handler.check()
def test_close_channel_event_no_offchain_transfers(get_accounts, token_network, create_channel, create_balance_proof, event_handler): ev_handler = event_handler(token_network) (A, B) = get_accounts(2) channel_identifier = create_channel(A, B) balance_proof = create_balance_proof(channel_identifier, B, 0, 0, 0) txn_hash = token_network.transact({'from': A}).closeChannel(*balance_proof) ev_handler.add(txn_hash, E_CHANNEL_CLOSED, check_channel_closed(channel_identifier, A)) ev_handler.check()
def test_close_channel_event(get_accounts, token_network, create_channel, channel_deposit, create_balance_proof, event_handler): ev_handler = event_handler(token_network) (A, B) = get_accounts(2) deposit_A = 10 channel_identifier = create_channel(A, B) channel_deposit(channel_identifier, A, deposit_A) balance_proof = create_balance_proof(channel_identifier, B, 5, 0, 3) txn_hash = token_network.transact({'from': A}).closeChannel(*balance_proof) ev_handler.add(txn_hash, E_CHANNEL_CLOSED, check_channel_closed(channel_identifier, A)) ev_handler.check()
def test_close_channel_event( get_accounts, token_network, create_channel, channel_deposit, create_balance_proof, event_handler, ): ev_handler = event_handler(token_network) (A, B) = get_accounts(2) deposit_A = 10 channel_identifier = create_channel(A, B)[0] channel_deposit(channel_identifier, A, deposit_A, B) balance_proof = create_balance_proof(channel_identifier, B, 5, 0, 3) txn_hash = token_network.functions.closeChannel( channel_identifier, B, *balance_proof, ).transact({'from': A}) ev_handler.add(txn_hash, ChannelEvent.CLOSED, check_channel_closed(channel_identifier, A)) ev_handler.check()
def test_msc_happy_path(token_network, monitoring_service_external, get_accounts, create_channel, channel_deposit, create_balance_proof, create_balance_proof_update_signature, create_reward_proof, event_handler, raiden_service_bundle, custom_token): # setup: two parties + MS ev_handler = event_handler(token_network) (A, B, MS) = get_accounts(3) reward_amount = 10 # mint some tokens custom_token.functions.mint(50).transact({'from': MS}) custom_token.functions.mint(50).transact({'from': A}) custom_token.functions.mint(50).transact({'from': B}) # register MS in the RaidenServiceBundle contract custom_token.functions.approve(raiden_service_bundle.address, 20).transact({'from': MS}) raiden_service_bundle.functions.deposit(20).transact({'from': MS}) ms_balance_after_deposit = monitoring_service_external.functions.balances( MS).call() # raiden node deposit custom_token.functions.approve(monitoring_service_external.address, 20).transact({'from': B}) monitoring_service_external.functions.deposit(B, 20).transact({'from': B}) # 1) open a channel (c1, c2) channel_identifier = create_channel(A, B)[0] txn_hash = channel_deposit(A, 20, B) txn_hash = channel_deposit(B, 20, A) # 2) create balance proof balance_proof_A = create_balance_proof(channel_identifier, B, transferred_amount=10, nonce=1) balance_proof_B = create_balance_proof(channel_identifier, A, transferred_amount=20, nonce=2) non_closing_signature_B = create_balance_proof_update_signature( B, channel_identifier, *balance_proof_B) # 2a) create reward proof reward_proof = create_reward_proof( B, channel_identifier, reward_amount, token_network.address, nonce=balance_proof_B[1], ) # 3) c1 closes channel txn_hash = token_network.functions.closeChannel( B, *balance_proof_A).transact({'from': A}) ev_handler.add(txn_hash, EVENT_CHANNEL_CLOSED, check_channel_closed(channel_identifier, A)) ev_handler.check() # 4) MS calls `MSC::monitor()` using c1's BP and reward proof txn_hash = monitoring_service_external.functions.monitor( A, B, balance_proof_B[0], # balance_hash balance_proof_B[1], # nonce balance_proof_B[2], # additional_hash balance_proof_B[3], # closing signature non_closing_signature_B, # non-closing signature reward_proof[1], # reward amount token_network.address, # token network address reward_proof[5] # reward proof signature ).transact({'from': MS}) # 5) MSC calls TokenNetwork updateTransfer # 6) channel is settled token_network.web3.testing.mine(8) token_network.functions.settleChannel( A, # participant1 20, # participant1_transferred_amount 0, # participant1_locked_amount b'\x00' * 32, # participant1_locksroot B, # participant2 10, # participant2_transferred_amount 0, # participant2_locked_amount b'\x00' * 32, # participant2_locksroot ).transact() # 7) MS claims the reward monitoring_service_external.functions.claimReward( token_network.address, A, B, ).transact({'from': MS}) ms_balance_after_reward = monitoring_service_external.functions.balances( MS).call() assert ms_balance_after_reward == (ms_balance_after_deposit + reward_amount)
def test_close_nonce_zero( get_accounts: Callable, token_network: Contract, create_channel: Callable, create_balance_proof: Callable, create_balance_proof_countersignature: Callable, event_handler: Callable, ) -> None: """ closeChannel with a balance proof with nonce zero should not change the channel state """ (A, B) = get_accounts(2) vals_B = ChannelValues( deposit=20, transferred=5, locksroot=fake_bytes(32, "03"), locked_amounts=LockedAmounts(claimable_locked=3, unclaimable_locked=4), nonce=0, ) # Create channel and deposit channel_identifier = create_channel(A, B)[0] # Create balance proofs balance_proof_B = create_balance_proof( channel_identifier, B, vals_B.transferred, vals_B.locked_amounts.locked, vals_B.nonce, vals_B.locksroot, ) close_sig_A = create_balance_proof_countersignature( A, channel_identifier, MessageTypeId.BALANCE_PROOF, *balance_proof_B) ( _, _, B_is_the_closer, B_balance_hash, B_nonce, _, _, ) = token_network.functions.getChannelParticipantInfo( channel_identifier, B, A).call() assert B_is_the_closer is False assert B_balance_hash == EMPTY_BALANCE_HASH assert B_nonce == 0 ev_handler = event_handler(token_network) close_tx = token_network.functions.closeChannel( channel_identifier, B, A, *balance_proof_B, close_sig_A).call_and_transact({"from": A}) ev_handler.add( close_tx, ChannelEvent.CLOSED, check_channel_closed(channel_identifier, A, 0, balance_proof_B[0]), ) ev_handler.check() # Even though we somehow provide valid values for the balance proof, they are not taken into # consideration if the nonce is 0. # The Raiden client enforces that the nonce is > 0 if off-chain transfers are made. ( _, _, B_is_the_closer, B_balance_hash, B_nonce, _, _, ) = token_network.functions.getChannelParticipantInfo( channel_identifier, B, A).call() assert B_is_the_closer is False assert B_balance_hash == EMPTY_BALANCE_HASH assert B_nonce == 0
def test_msc_happy_path( token_network, monitoring_service_external, get_accounts, create_channel, channel_deposit, create_balance_proof, create_balance_proof_update_signature, create_reward_proof, event_handler, raiden_service_bundle, custom_token, ): # setup: two parties + MS token_network_ev_handler = event_handler(token_network) ms_ev_handler = event_handler(monitoring_service_external) (A, B, MS) = get_accounts(3) reward_amount = 10 # mint some tokens custom_token.functions.mint(50).transact({'from': MS}) custom_token.functions.mint(50).transact({'from': A}) custom_token.functions.mint(50).transact({'from': B}) # register MS in the RaidenServiceBundle contract custom_token.functions.approve(raiden_service_bundle.address, 20).transact({'from': MS}) raiden_service_bundle.functions.deposit(20).transact({'from': MS}) ms_balance_after_deposit = monitoring_service_external.functions.balances( MS).call() # raiden node deposit custom_token.functions.approve(monitoring_service_external.address, 20).transact({'from': B}) txn_hash = monitoring_service_external.functions.deposit(B, 20).transact( {'from': B}) ms_ev_handler.add( txn_hash, MonitoringServiceEvent.NEW_DEPOSIT, check_ms_new_deposit(B, 20), ) ms_ev_handler.check() # 1) open a channel (c1, c2) channel_identifier = create_channel(A, B)[0] txn_hash = channel_deposit(channel_identifier, A, 20, B) txn_hash = channel_deposit(channel_identifier, B, 20, A) # 2) create balance proof balance_proof_A = create_balance_proof(channel_identifier, B, transferred_amount=10, nonce=1) balance_proof_B = create_balance_proof(channel_identifier, A, transferred_amount=20, nonce=2) non_closing_signature_B = create_balance_proof_update_signature( B, channel_identifier, *balance_proof_B, ) # 2a) create reward proof reward_proof = create_reward_proof( B, channel_identifier, reward_amount, token_network.address, nonce=balance_proof_B[1], ) # 3) c1 closes channel txn_hash = token_network.functions.closeChannel( channel_identifier, B, *balance_proof_A, ).transact({'from': A}) token_network_ev_handler.add( txn_hash, ChannelEvent.CLOSED, check_channel_closed(channel_identifier, A, balance_proof_A[1]), ) token_network_ev_handler.check() # 4) MS calls `MSC::monitor()` using c1's BP and reward proof txn_hash = monitoring_service_external.functions.monitor( A, B, balance_proof_B[0], # balance_hash balance_proof_B[1], # nonce balance_proof_B[2], # additional_hash balance_proof_B[3], # closing signature non_closing_signature_B, # non-closing signature reward_proof[1], # reward amount token_network.address, # token network address reward_proof[5], # reward proof signature ).transact({'from': MS}) ms_ev_handler.add( txn_hash, MonitoringServiceEvent.NEW_BALANCE_PROOF_RECEIVED, check_new_balance_proof_received( token_network.address, channel_identifier, reward_amount, balance_proof_B[1], MS, B, ), ) ms_ev_handler.check() # 5) MSC calls TokenNetwork updateTransfer # 6) channel is settled token_network.web3.testing.mine(8) token_network.functions.settleChannel( channel_identifier, B, # participant2 10, # participant2_transferred_amount 0, # participant2_locked_amount EMPTY_LOCKSROOT, # participant2_locksroot A, # participant1 20, # participant1_transferred_amount 0, # participant1_locked_amount EMPTY_LOCKSROOT, # participant1_locksroot ).transact() # 7) MS claims the reward monitoring_service_external.functions.claimReward( channel_identifier, token_network.address, A, B, ).transact({'from': MS}) reward_identifier = Web3.sha3( encode_single('uint256', channel_identifier) + Web3.toBytes(hexstr=token_network.address), ) ms_ev_handler.add( txn_hash, MonitoringServiceEvent.REWARD_CLAIMED, check_reward_claimed( MS, reward_amount, reward_identifier, ), ) ms_ev_handler.check() ms_balance_after_reward = monitoring_service_external.functions.balances( MS).call() assert ms_balance_after_reward == (ms_balance_after_deposit + reward_amount)
def test_close_nonce_zero( get_accounts, token_network, create_channel, create_balance_proof, event_handler, ): """ closeChannel with a balance proof with nonce zero should not change the channel state """ (A, B) = get_accounts(2) vals_B = ChannelValues( deposit=20, transferred=5, locksroot=fake_bytes(32, '03'), claimable_locked=3, unclaimable_locked=4, nonce=0, ) # Create channel and deposit channel_identifier = create_channel(A, B)[0] # Create balance proofs balance_proof_B = create_balance_proof( channel_identifier, B, vals_B.transferred, vals_B.locked, vals_B.nonce, vals_B.locksroot, ) ( _, _, B_is_the_closer, B_balance_hash, B_nonce, _, _, ) = token_network.functions.getChannelParticipantInfo( channel_identifier, B, A).call() assert B_is_the_closer is False assert B_balance_hash == EMPTY_BALANCE_HASH assert B_nonce == 0 ev_handler = event_handler(token_network) close_tx = token_network.functions.closeChannel( channel_identifier, B, *balance_proof_B, ).transact({'from': A}) ev_handler.add(close_tx, ChannelEvent.CLOSED, check_channel_closed(channel_identifier, A, 0)) ev_handler.check() # Even though we somehow provide valid values for the balance proof, they are not taken into # consideration if the nonce is 0. # The Raiden client enforces that the nonce is > 0 if off-chain transfers are made. ( _, _, B_is_the_closer, B_balance_hash, B_nonce, _, _, ) = token_network.functions.getChannelParticipantInfo( channel_identifier, B, A).call() assert B_is_the_closer is False assert B_balance_hash == EMPTY_BALANCE_HASH assert B_nonce == 0