def test_endpointregistry(tester_chain, tester_events):
account0 = tester.a0
sender = address_encoder(account0)
endpointregistry_path = get_contract_path('EndpointRegistry.sol')
endpointregistry_compiled = _solidity.compile_contract(
endpointregistry_path,
"EndpointRegistry"
)
tester_chain.head_state.log_listeners.append(tester_events.append)
endpointregistry_address = tester_chain.contract(
endpointregistry_compiled['bin'],
language='evm'
)
endpoint_registry = tester.ABIContract(
tester_chain,
endpointregistry_compiled['abi'],
endpointregistry_address
)
endpoint_registry.registerEndpoint('127.0.0.1:4001')
assert endpoint_registry.findAddressByEndpoint('127.0.0.1:4001') == sender
assert endpoint_registry.findEndpointByAddress(sender) == b'127.0.0.1:4001'
endpoint_registry.registerEndpoint('192.168.0.1:4002')
assert endpoint_registry.findAddressByEndpoint('192.168.0.1:4002') == sender
assert endpoint_registry.findEndpointByAddress(sender) == b'192.168.0.1:4002'
assert len(tester_events) == 2
event0 = event_decoder(tester_events[0], endpoint_registry.translator)
event1 = event_decoder(tester_events[1], endpoint_registry.translator)
assert event0['_event_type'] == b'AddressRegistered'
assert event1['_event_type'] == b'AddressRegistered'
def test_endpointregistry(tester_chain, tester_events):
account0 = tester.a0
sender = address_encoder(account0)
endpointregistry_path = get_contract_path('EndpointRegistry.sol')
endpointregistry_compiled = _solidity.compile_contract(
endpointregistry_path, "EndpointRegistry")
tester_chain.head_state.log_listeners.append(tester_events.append)
endpointregistry_address = tester_chain.contract(
endpointregistry_compiled['bin'], language='evm')
endpoint_registry = tester.ABIContract(tester_chain,
endpointregistry_compiled['abi'],
endpointregistry_address)
endpoint_registry.registerEndpoint('127.0.0.1:4001')
assert endpoint_registry.findAddressByEndpoint('127.0.0.1:4001') == sender
assert endpoint_registry.findEndpointByAddress(sender) == b'127.0.0.1:4001'
endpoint_registry.registerEndpoint('192.168.0.1:4002')
assert endpoint_registry.findAddressByEndpoint(
'192.168.0.1:4002') == sender
assert endpoint_registry.findEndpointByAddress(
sender) == b'192.168.0.1:4002'
assert len(tester_events) == 2
event0 = event_decoder(tester_events[0], endpoint_registry.translator)
event1 = event_decoder(tester_events[1], endpoint_registry.translator)
assert event0['_event_type'] == b'AddressRegistered'
assert event1['_event_type'] == b'AddressRegistered'
def test_registry(tester_registry, tester_events, private_keys, tester_chain):
privatekey0 = tester.k0
token_address1 = tester_token_address(private_keys, 100, tester_chain, 0)
token_address2 = tester_token_address(private_keys, 100, tester_chain, 1)
unregistered_address = tester_token_address(private_keys, 100,
tester_chain, 2)
tester_chain.head_state.log_listeners.append(tester_events.append)
contract_address1 = tester_registry.addToken(token_address1,
sender=privatekey0)
channel_manager_address1 = tester_registry.channelManagerByToken(
token_address1,
sender=privatekey0,
)
assert channel_manager_address1 == contract_address1
with pytest.raises(tester.TransactionFailed):
tester_registry.addToken(token_address1, sender=privatekey0)
contract_address2 = tester_registry.addToken(token_address2,
sender=privatekey0)
channel_manager_address2 = tester_registry.channelManagerByToken(
token_address2,
sender=privatekey0,
)
assert channel_manager_address2 == contract_address2
with pytest.raises(tester.TransactionFailed):
tester_registry.channelManagerByToken(
unregistered_address,
sender=privatekey0,
)
addresses = tester_registry.tokenAddresses(sender=privatekey0)
assert len(addresses) == 2
assert addresses[0] == address_encoder(token_address1)
assert addresses[1] == address_encoder(token_address2)
assert len(tester_events) == 2
event0 = event_decoder(tester_events[0], tester_registry.translator)
event1 = event_decoder(tester_events[1], tester_registry.translator)
assert event0['_event_type'] == b'TokenAdded'
assert event0['token_address'] == address_encoder(token_address1)
assert event0['channel_manager_address'] == contract_address1
assert event1['_event_type'] == b'TokenAdded'
assert event1['token_address'] == address_encoder(token_address2)
assert event1['channel_manager_address'] == contract_address2
def test_registry(tester_registry, tester_events, private_keys, tester_chain):
privatekey0 = tester.k0
token_address1 = tester_token_address(private_keys, 100, tester_chain, 0)
token_address2 = tester_token_address(private_keys, 100, tester_chain, 1)
unregistered_address = tester_token_address(private_keys, 100, tester_chain, 2)
tester_chain.head_state.log_listeners.append(tester_events.append)
contract_address1 = tester_registry.addToken(token_address1, sender=privatekey0)
channel_manager_address1 = tester_registry.channelManagerByToken(
token_address1,
sender=privatekey0,
)
assert channel_manager_address1 == contract_address1
with pytest.raises(tester.TransactionFailed):
tester_registry.addToken(token_address1, sender=privatekey0)
contract_address2 = tester_registry.addToken(token_address2, sender=privatekey0)
channel_manager_address2 = tester_registry.channelManagerByToken(
token_address2,
sender=privatekey0,
)
assert channel_manager_address2 == contract_address2
with pytest.raises(tester.TransactionFailed):
tester_registry.channelManagerByToken(
unregistered_address,
sender=privatekey0,
)
addresses = tester_registry.tokenAddresses(sender=privatekey0)
assert len(addresses) == 2
assert addresses[0] == address_encoder(token_address1)
assert addresses[1] == address_encoder(token_address2)
assert len(tester_events) == 2
event0 = event_decoder(tester_events[0], tester_registry.translator)
event1 = event_decoder(tester_events[1], tester_registry.translator)
assert event0['_event_type'] == b'TokenAdded'
assert event0['token_address'] == address_encoder(token_address1)
assert event0['channel_manager_address'] == contract_address1
assert event1['_event_type'] == b'TokenAdded'
assert event1['token_address'] == address_encoder(token_address2)
assert event1['channel_manager_address'] == contract_address2
def test_settle_event(
settle_timeout,
tester_registry_address,
tester_chain,
tester_events,
tester_nettingcontracts,
):
""" The event ChannelSettled is emitted when the channel is settled. """
pkey0, _, nettingchannel = tester_nettingcontracts[0]
nettingchannel.close(sender=pkey0)
tester_chain.mine(number_of_blocks=settle_timeout + 1)
previous_events = list(tester_events)
tester_chain.head_state.log_listeners.append(tester_events.append)
nettingchannel.settle(sender=pkey0)
# settle + a transfer per participant
assert len(previous_events) + 3 == len(tester_events)
settle_event = event_decoder(tester_events[-1], nettingchannel.translator)
assert settle_event == {
'_event_type': b'ChannelSettled',
'registry_address': address_encoder(tester_registry_address)
}
def test_channelnew_event(
settle_timeout,
tester_channelmanager,
private_keys,
tester_events):
""" When a new channel is created the channel new event must be emitted. """
pkey0 = private_keys[0]
address0 = privatekey_to_address(pkey0)
address1 = privatekey_to_address(private_keys[1])
# pylint: disable=no-member
netting_channel_address1_hex = tester_channelmanager.newChannel(
address1,
settle_timeout,
sender=pkey0,
)
last_event = event_decoder(tester_events[-1], tester_channelmanager.translator)
assert last_event == {
'_event_type': b'ChannelNew',
'netting_channel': netting_channel_address1_hex,
'participant1': address_encoder(address0),
'participant2': address_encoder(address1),
'settle_timeout': settle_timeout,
}
def test_transfer_update_event(tester_channels, tester_events):
""" The event TransferUpdated is emitted after a successful call to
updateTransfer.
"""
pkey0, pkey1, nettingchannel, channel0, channel1 = tester_channels[0]
address1 = privatekey_to_address(pkey1)
direct0 = make_direct_transfer_from_channel(
channel0,
channel1,
amount=90,
pkey=pkey0,
)
nettingchannel.close(sender=pkey0)
previous_events = list(tester_events)
direct0_hash = sha3(direct0.packed().data[:-65])
nettingchannel.updateTransfer(
direct0.nonce,
direct0.transferred_amount,
direct0.locksroot,
direct0_hash,
direct0.signature,
sender=pkey1,
)
assert len(previous_events) + 1 == len(tester_events)
last_event = event_decoder(tester_events[-1], nettingchannel.translator)
assert last_event == {
'_event_type': b'TransferUpdated',
'node_address': address_encoder(address1),
}
def test_channelnew_event(
settle_timeout,
tester_channelmanager,
private_keys,
tester_events):
""" When a new channel is created the channel new event must be emitted. """
pkey0 = private_keys[0]
address0 = privatekey_to_address(pkey0)
address1 = privatekey_to_address(private_keys[1])
# pylint: disable=no-member
netting_channel_address1_hex = tester_channelmanager.newChannel(
address1,
settle_timeout,
sender=pkey0,
)
last_event = event_decoder(tester_events[-1], tester_channelmanager.translator)
assert last_event == {
'_event_type': b'ChannelNew',
'netting_channel': netting_channel_address1_hex,
'participant1': address_encoder(address0),
'participant2': address_encoder(address1),
'settle_timeout': settle_timeout,
}
def test_deposit_events(
private_keys,
settle_timeout,
tester_chain,
tester_channelmanager,
tester_token,
tester_events):
""" A deposit must emit the events Transfer and a ChannelNewBalance. """
private_key = private_keys[0]
address = privatekey_to_address(private_key)
nettingchannel = new_nettingcontract(
private_key,
private_keys[1],
tester_chain,
tester_events.append,
tester_channelmanager,
settle_timeout,
)
initial_balance0 = tester_token.balanceOf(address, sender=private_key)
deposit_amount = initial_balance0 // 10
assert tester_token.approve(nettingchannel.address, deposit_amount, sender=private_key) is True
assert nettingchannel.deposit(deposit_amount, sender=private_key) is True
transfer_event = event_decoder(tester_events[-2], tester_token.translator)
newbalance_event = event_decoder(tester_events[-1], nettingchannel.translator)
assert transfer_event == {
'_event_type': b'Transfer',
'_from': address_encoder(address),
'_to': nettingchannel.address,
'_value': deposit_amount,
}
assert newbalance_event['_event_type'] == b'ChannelNewBalance'
assert newbalance_event['token_address'] == address_encoder(tester_token.address)
assert newbalance_event['participant'] == address_encoder(address)
assert newbalance_event['balance'] == deposit_amount
def test_deposit_events(private_keys, settle_timeout, tester_chain,
tester_channelmanager, tester_token, tester_events):
""" A deposit must emit the events Transfer and a ChannelNewBalance. """
private_key = private_keys[0]
address = privatekey_to_address(private_key)
nettingchannel = new_nettingcontract(
private_key,
private_keys[1],
tester_chain,
tester_events.append,
tester_channelmanager,
settle_timeout,
)
initial_balance0 = tester_token.balanceOf(address, sender=private_key)
deposit_amount = initial_balance0 // 10
assert tester_token.approve(
nettingchannel.address, deposit_amount, sender=private_key) is True
assert nettingchannel.deposit(deposit_amount, sender=private_key) is True
transfer_event = event_decoder(tester_events[-2], tester_token.translator)
newbalance_event = event_decoder(tester_events[-1],
nettingchannel.translator)
assert transfer_event == {
'_event_type': b'Transfer',
'_from': address_encoder(address),
'_to': nettingchannel.address,
'_value': deposit_amount,
}
assert newbalance_event['_event_type'] == b'ChannelNewBalance'
assert newbalance_event['token_address'] == address_encoder(
tester_token.address)
assert newbalance_event['participant'] == address_encoder(address)
assert newbalance_event['balance'] == deposit_amount
def test_close_event(tester_nettingcontracts, tester_events):
""" The event ChannelClosed is emitted when close is called. """
pkey0, _, nettingchannel = tester_nettingcontracts[0]
address = privatekey_to_address(pkey0)
previous_events = list(tester_events)
nettingchannel.close(sender=pkey0)
assert len(previous_events) + 1 == len(tester_events)
close_event = event_decoder(tester_events[-1], nettingchannel.translator)
assert close_event == {
'_event_type': b'ChannelClosed',
'closing_address': address_encoder(address),
}
def test_close_event(tester_chain, tester_nettingcontracts, tester_events):
""" The event ChannelClosed is emitted when close is called. """
pkey0, _, nettingchannel = tester_nettingcontracts[0]
address = privatekey_to_address(pkey0)
previous_events = list(tester_events)
nettingchannel.close(sender=pkey0)
assert len(previous_events) + 1 == len(tester_events)
close_event = event_decoder(tester_events[-1], nettingchannel.translator)
assert close_event == {
'_event_type': b'ChannelClosed',
'closing_address': address_encoder(address),
}
def test_settle_event(settle_timeout, tester_chain, tester_events, tester_nettingcontracts):
""" The event ChannelSettled is emitted when the channel is settled. """
pkey0, _, nettingchannel = tester_nettingcontracts[0]
nettingchannel.close(sender=pkey0)
tester_chain.mine(number_of_blocks=settle_timeout + 1)
previous_events = list(tester_events)
tester_chain.head_state.log_listeners.append(tester_events.append)
nettingchannel.settle(sender=pkey0)
# settle + a transfer per participant
assert len(previous_events) + 3 == len(tester_events)
settle_event = event_decoder(tester_events[-1], nettingchannel.translator)
assert settle_event == {
'_event_type': b'ChannelSettled',
}
def test_channeldeleted_event(
settle_timeout,
tester_channelmanager,
tester_events,
tester_nettingcontracts,
tester_chain):
""" A channel deleted event must be emmited when the channel is cleaned.
This happens once a *new* channel with *the same parties* is created,
overwritting the old one. This behavior may be unexpected due to the weird
timing.
"""
pkey0, pkey1, nettingchannel = tester_nettingcontracts[0]
address0 = privatekey_to_address(pkey0)
address1 = privatekey_to_address(pkey1)
netting_channel_settled(
tester_chain,
nettingchannel,
pkey0,
settle_timeout,
)
tester_chain.head_state.log_listeners.append(tester_events.append)
# old entry will be deleted when calling newChannel
tester_channelmanager.newChannel(
address1,
settle_timeout,
sender=pkey0,
)
channeldelete_event = event_decoder(tester_events[-2], tester_channelmanager.translator)
assert channeldelete_event == {
'_event_type': b'ChannelDeleted',
'caller_address': address_encoder(address0),
'partner': address_encoder(address1)
}
def test_channeldeleted_event(
settle_timeout,
tester_channelmanager,
tester_events,
tester_nettingcontracts,
tester_chain):
""" A channel deleted event must be emmited when the channel is cleaned.
This happens once a *new* channel with *the same parties* is created,
overwritting the old one. This behavior may be unexpected due to the weird
timing.
"""
pkey0, pkey1, nettingchannel = tester_nettingcontracts[0]
address0 = privatekey_to_address(pkey0)
address1 = privatekey_to_address(pkey1)
netting_channel_settled(
tester_chain,
nettingchannel,
pkey0,
settle_timeout,
)
tester_chain.head_state.log_listeners.append(tester_events.append)
# old entry will be deleted when calling newChannel
tester_channelmanager.newChannel(
address1,
settle_timeout,
sender=pkey0,
)
channeldelete_event = event_decoder(tester_events[-2], tester_channelmanager.translator)
assert channeldelete_event == {
'_event_type': b'ChannelDeleted',
'caller_address': address_encoder(address0),
'partner': address_encoder(address1)
}
def test_transfer_update_event(tester_chain, tester_channels, tester_events):
""" The event TransferUpdated is emitted after a successful call to
updateTransfer.
"""
pkey0, pkey1, nettingchannel, channel0, channel1 = tester_channels[0]
address1 = privatekey_to_address(pkey1)
block_number = tester_chain.block.number
direct0 = make_direct_transfer_from_channel(
block_number,
channel0,
channel1,
amount=90,
pkey=pkey0,
)
nettingchannel.close(sender=pkey0)
previous_events = list(tester_events)
direct0_hash = sha3(direct0.packed().data[:-65])
nettingchannel.updateTransfer(
direct0.nonce,
direct0.transferred_amount,
direct0.locksroot,
direct0_hash,
direct0.signature,
sender=pkey1,
)
assert len(previous_events) + 1 == len(tester_events)
last_event = event_decoder(tester_events[-1], nettingchannel.translator)
assert last_event == {
'_event_type': b'TransferUpdated',
'node_address': address_encoder(address1),
}
