def test_token_addresses(raiden_network, token_addresses):
node1, node2 = raiden_network
token_address = token_addresses[0]
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
assert api1.address == node1.raiden.address
assert set(api1.tokens) == set(token_addresses)
assert set(api1.get_tokens_list()) == set(token_addresses)
channels = api1.get_channel_list(token_address, api2.address)
assert api1.get_channel_list(token_address) == channels
assert len(api1.get_channel_list()) == 2
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
def test_channel_lifecycle(raiden_network, token_addresses, deposit, transport_config):
node1, node2 = raiden_network
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(node1),
node1.raiden.default_registry.address,
token_address,
)
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
registry_address = node1.raiden.default_registry.address
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_UNKNOWN
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_UNKNOWN
assert not api1.get_channel_list(registry_address, token_address, api2.address)
# open is a synchronous api
api1.channel_open(node1.raiden.default_registry.address, token_address, api2.address)
channels = api1.get_channel_list(registry_address, token_address, api2.address)
assert len(channels) == 1
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
event_list1 = api1.get_channel_events(
token_address,
channel12.partner_state.address,
channel12.open_transaction.finished_block_number,
)
assert any(
(
event['event'] == EVENT_CHANNEL_OPENED and
is_same_address(
event['args']['participant1'],
to_normalized_address(api1.address),
) and
is_same_address(
event['args']['participant2'],
to_normalized_address(api2.address),
)
)
for event in event_list1
)
token_events = api1.get_token_network_events(
token_address,
channel12.open_transaction.finished_block_number,
)
assert token_events[0]['event'] == EVENT_CHANNEL_OPENED
registry_address = api1.raiden.default_registry.address
# Load the new state with the deposit
api1.set_total_channel_deposit(
registry_address,
token_address,
api2.address,
deposit,
)
# let's make sure it's idempotent
api1.set_total_channel_deposit(
registry_address,
token_address,
api2.address,
deposit,
)
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
assert channel.get_balance(channel12.our_state, channel12.partner_state) == deposit
assert channel12.our_state.contract_balance == deposit
assert api1.get_channel_list(registry_address, token_address, api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_REACHABLE
event_list2 = api1.get_channel_events(
token_address,
channel12.partner_state.address,
channel12.open_transaction.finished_block_number,
)
assert any(
(
event['event'] == EVENT_CHANNEL_DEPOSIT and
is_same_address(
event['args']['participant'],
to_normalized_address(api1.address),
) and
event['args']['total_deposit'] == deposit
)
for event in event_list2
)
api1.channel_close(registry_address, token_address, api2.address)
# Load the new state with the channel closed
channel12 = get_channelstate(node1, node2, token_network_identifier)
event_list3 = api1.get_channel_events(
token_address,
channel12.partner_state.address,
channel12.open_transaction.finished_block_number,
)
assert len(event_list3) > len(event_list2)
assert any(
(
event['event'] == EVENT_CHANNEL_CLOSED and
is_same_address(
event['args']['closing_participant'],
to_normalized_address(api1.address),
)
)
for event in event_list3
)
assert channel.get_status(channel12) == CHANNEL_STATE_CLOSED
settlement_block = (
channel12.close_transaction.finished_block_number +
channel12.settle_timeout +
10 # arbitrary number of additional blocks, used to wait for the settle() call
)
wait_until_block(node1.raiden.chain, settlement_block)
# Load the new state with the channel settled
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_SETTLED
def test_channel_lifecycle(raiden_network, token_addresses, deposit,
transport_config):
node1, node2 = raiden_network
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(node1),
node1.raiden.default_registry.address,
token_address,
)
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
registry_address = node1.raiden.default_registry.address
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_UNKNOWN
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_UNKNOWN
assert not api1.get_channel_list(registry_address, token_address,
api2.address)
# open is a synchronous api
api1.channel_open(node1.raiden.default_registry.address, token_address,
api2.address)
channels = api1.get_channel_list(registry_address, token_address,
api2.address)
assert len(channels) == 1
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
event_list1 = api1.get_blockchain_events_channel(
token_address,
channel12.partner_state.address,
)
assert any((event['event'] == ChannelEvent.OPENED and is_same_address(
event['args']['participant1'],
to_normalized_address(api1.address),
) and is_same_address(
event['args']['participant2'],
to_normalized_address(api2.address),
)) for event in event_list1)
token_events = api1.get_blockchain_events_token_network(token_address, )
assert token_events[0]['event'] == ChannelEvent.OPENED
registry_address = api1.raiden.default_registry.address
# Load the new state with the deposit
api1.set_total_channel_deposit(
registry_address,
token_address,
api2.address,
deposit,
)
# let's make sure it's idempotent. Same deposit should raise deposit mismatch limit
with pytest.raises(DepositMismatch):
api1.set_total_channel_deposit(
registry_address,
token_address,
api2.address,
deposit,
)
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
assert channel.get_balance(channel12.our_state,
channel12.partner_state) == deposit
assert channel12.our_state.contract_balance == deposit
assert api1.get_channel_list(registry_address, token_address,
api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_REACHABLE
event_list2 = api1.get_blockchain_events_channel(
token_address,
channel12.partner_state.address,
)
assert any((event['event'] == ChannelEvent.DEPOSIT and is_same_address(
event['args']['participant'],
to_normalized_address(api1.address),
) and event['args']['total_deposit'] == deposit) for event in event_list2)
api1.channel_close(registry_address, token_address, api2.address)
# Load the new state with the channel closed
channel12 = get_channelstate(node1, node2, token_network_identifier)
event_list3 = api1.get_blockchain_events_channel(
token_address,
channel12.partner_state.address,
)
assert len(event_list3) > len(event_list2)
assert any((event['event'] == ChannelEvent.CLOSED and is_same_address(
event['args']['closing_participant'],
to_normalized_address(api1.address),
)) for event in event_list3)
assert channel.get_status(channel12) == CHANNEL_STATE_CLOSED
settlement_block = (
channel12.close_transaction.finished_block_number +
channel12.settle_timeout +
10 # arbitrary number of additional blocks, used to wait for the settle() call
)
wait_until_block(node1.raiden.chain, settlement_block)
state_changes = node1.raiden.wal.storage.get_statechanges_by_identifier(
from_identifier=0,
to_identifier='latest',
)
assert must_contain_entry(
state_changes, ContractReceiveChannelSettled, {
'token_network_identifier': token_network_identifier,
'channel_identifier': channel12.identifier,
})
def test_channel_lifecycle(raiden_network, token_addresses, deposit,
transport_config):
node1, node2 = raiden_network
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(node1),
node1.raiden.default_registry.address,
token_address,
)
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
registry_address = node1.raiden.default_registry.address
if transport_config.protocol == TransportProtocol.UDP:
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(
api2.address) == NODE_NETWORK_UNKNOWN
assert api2.get_node_network_state(
api1.address) == NODE_NETWORK_UNKNOWN
elif transport_config.protocol == TransportProtocol.MATRIX:
# with Matrix nodes do not need a health check to know each others reachability
assert api1.get_node_network_state(
api2.address) == NODE_NETWORK_UNREACHABLE
assert api2.get_node_network_state(
api1.address) == NODE_NETWORK_UNREACHABLE
assert not api1.get_channel_list(registry_address, token_address,
api2.address)
# open is a synchronous api
api1.channel_open(node1.raiden.default_registry.address, token_address,
api2.address)
channels = api1.get_channel_list(registry_address, token_address,
api2.address)
assert len(channels) == 1
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
event_list1 = api1.get_channel_events(
channel12.identifier,
channel12.open_transaction.finished_block_number,
)
assert event_list1 == []
token_events = api1.get_token_network_events(
token_address,
channel12.open_transaction.finished_block_number,
)
assert token_events[0]['event'] == EVENT_CHANNEL_NEW
registry_address = api1.raiden.default_registry.address
# Load the new state with the deposit
api1.channel_deposit(
registry_address,
token_address,
api2.address,
deposit,
)
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
assert channel.get_balance(channel12.our_state,
channel12.partner_state) == deposit
assert channel12.our_state.contract_balance == deposit
assert api1.get_channel_list(registry_address, token_address,
api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_REACHABLE
event_list2 = api1.get_channel_events(
channel12.identifier,
channel12.open_transaction.finished_block_number,
)
assert any(
(event['event'] == EVENT_CHANNEL_NEW_BALANCE and is_same_address(
event['args']['registry_address'],
to_normalized_address(registry_address),
) and is_same_address(
event['args']['participant'],
to_normalized_address(api1.address),
)) for event in event_list2)
api1.channel_close(registry_address, token_address, api2.address)
# Load the new state with the channel closed
channel12 = get_channelstate(node1, node2, token_network_identifier)
event_list3 = api1.get_channel_events(
channel12.identifier,
channel12.open_transaction.finished_block_number,
)
assert len(event_list3) > len(event_list2)
assert any((event['event'] == EVENT_CHANNEL_CLOSED and is_same_address(
event['args']['registry_address'],
to_normalized_address(registry_address),
) and is_same_address(
event['args']['closing_address'],
to_normalized_address(api1.address),
)) for event in event_list3)
assert channel.get_status(channel12) == CHANNEL_STATE_CLOSED
settlement_block = (
channel12.close_transaction.finished_block_number +
channel12.settle_timeout +
10 # arbitrary number of additional blocks, used to wait for the settle() call
)
wait_until_block(node1.raiden.chain, settlement_block)
# Load the new state with the channel settled
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_SETTLED
def run(
privatekey,
registry_contract_address,
secret_registry_contract_address,
discovery_contract_address,
listen_address,
structlog,
logfile,
scenario,
stage_prefix,
): # pylint: disable=unused-argument
# TODO: only enabled structlog on "initiators"
structlog.configure(structlog, log_file=logfile)
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.DEFAULT_CONFIG.copy()
config['host'] = listen_host
config['port'] = listen_port
config['privatekey_hex'] = privatekey
privatekey_bin = decode_hex(privatekey)
rpc_client = JSONRPCClient(
'127.0.0.1',
8545,
privatekey_bin,
)
blockchain_service = BlockChainService(
privatekey_bin,
rpc_client,
GAS_PRICE,
)
discovery = ContractDiscovery(
blockchain_service,
decode_hex(discovery_contract_address),
)
registry = blockchain_service.registry(
registry_contract_address,
)
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address,
)
throttle_policy = TokenBucket(
config['protocol']['throttle_capacity'],
config['protocol']['throttle_fill_rate'],
)
transport = UDPTransport(
discovery,
server._udp_socket((listen_host, listen_port)),
throttle_policy,
config['protocol'],
dict(),
)
app = App(
config,
blockchain_service,
registry,
secret_registry,
transport,
discovery,
)
app.discovery.register(
app.raiden.address,
listen_host,
listen_port,
)
app.raiden.install_payment_network_filters(app.raiden.default_registry.address)
if scenario:
script = json.load(scenario)
tools = ConsoleTools(
app.raiden,
app.discovery,
app.config['settle_timeout'],
app.config['reveal_timeout'],
)
transfers_by_peer = {}
tokens = script['tokens']
token_address = None
peer = None
our_node = hexlify(app.raiden.address)
log.warning('our address is {}'.format(our_node))
for token in tokens:
# skip tokens that we're not part of
nodes = token['channels']
if our_node not in nodes:
continue
partner_nodes = [
node
for node in nodes
if node != our_node
]
# allow for prefunded tokens
if 'token_address' in token:
token_address = token['token_address']
else:
token_address = tools.create_token(registry_contract_address)
transfers_with_amount = token['transfers_with_amount']
# FIXME: in order to do bidirectional channels, only one side
# (i.e. only token['channels'][0]) should
# open; others should join by calling
# raiden.api.deposit, AFTER the channel came alive!
# NOTE: leaving unidirectional for now because it most
# probably will get to higher throughput
log.warning('Waiting for all nodes to come online')
api = RaidenAPI(app.raiden)
for node in partner_nodes:
api.start_health_check_for(node)
while True:
all_reachable = all(
api.get_node_network_state(node) == NODE_NETWORK_REACHABLE
for node in partner_nodes
)
if all_reachable:
break
gevent.sleep(5)
log.warning('All nodes are online')
if our_node != nodes[-1]:
our_index = nodes.index(our_node)
peer = nodes[our_index + 1]
tools.token_network_register(app.raiden.default_registry.address, token_address)
amount = transfers_with_amount[nodes[-1]]
while True:
try:
app.discovery.get(peer.decode('hex'))
break
except KeyError:
log.warning('Error: peer {} not found in discovery'.format(peer))
time.sleep(random.randrange(30))
while True:
try:
log.warning('Opening channel with {} for {}'.format(peer, token_address))
api.channel_open(app.raiden.default_registry.address, token_address, peer)
break
except KeyError:
log.warning('Error: could not open channel with {}'.format(peer))
time.sleep(random.randrange(30))
while True:
try:
log.warning('Funding channel with {} for {}'.format(peer, token_address))
api.channel_deposit(
app.raiden.default_registry.address,
token_address,
peer,
amount,
)
break
except Exception:
log.warning('Error: could not deposit {} for {}'.format(amount, peer))
time.sleep(random.randrange(30))
if our_index == 0:
last_node = nodes[-1]
transfers_by_peer[last_node] = int(amount)
else:
peer = nodes[-2]
if stage_prefix is not None:
open('{}.stage1'.format(stage_prefix), 'a').close()
log.warning('Done with initialization, waiting to continue...')
event = gevent.event.Event()
gevent.signal(signal.SIGUSR2, event.set)
event.wait()
transfer_results = {'total_time': 0, 'timestamps': []}
def transfer(token_address, amount_per_transfer, total_transfers, peer, is_async):
def transfer_():
log.warning('Making {} transfers to {}'.format(total_transfers, peer))
initial_time = time.time()
times = [0] * total_transfers
for index in range(total_transfers):
RaidenAPI(app.raiden).transfer(
app.raiden.default_registry.address,
token_address.decode('hex'),
amount_per_transfer,
peer,
)
times[index] = time.time()
transfer_results['total_time'] = time.time() - initial_time
transfer_results['timestamps'] = times
log.warning('Making {} transfers took {}'.format(
total_transfers, transfer_results['total_time']))
log.warning('Times: {}'.format(times))
if is_async:
return gevent.spawn(transfer_)
else:
transfer_()
# If sending to multiple targets, do it asynchronously, otherwise
# keep it simple and just send to the single target on my thread.
if len(transfers_by_peer) > 1:
greenlets = []
for peer_, amount in transfers_by_peer.items():
greenlet = transfer(token_address, 1, amount, peer_, True)
if greenlet is not None:
greenlets.append(greenlet)
gevent.joinall(greenlets)
elif len(transfers_by_peer) == 1:
for peer_, amount in transfers_by_peer.items():
transfer(token_address, 1, amount, peer_, False)
log.warning('Waiting for termination')
open('{}.stage2'.format(stage_prefix), 'a').close()
log.warning('Waiting for transfers to finish, will write results...')
event = gevent.event.Event()
gevent.signal(signal.SIGUSR2, event.set)
event.wait()
open('{}.stage3'.format(stage_prefix), 'a').close()
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
else:
log.warning('No scenario file supplied, doing nothing!')
open('{}.stage2'.format(stage_prefix), 'a').close()
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
app.stop()
def test_raidenapi_channel_lifecycle(raiden_network, token_addresses, deposit,
retry_timeout, settle_timeout_max):
"""Uses RaidenAPI to go through a complete channel lifecycle."""
node1, node2 = raiden_network
token_address = token_addresses[0]
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_app(node1), node1.raiden.default_registry.address,
token_address)
assert token_network_address
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
registry_address = node1.raiden.default_registry.address
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(api2.address) == NetworkState.UNKNOWN
assert api2.get_node_network_state(api1.address) == NetworkState.UNKNOWN
assert not api1.get_channel_list(registry_address, token_address,
api2.address)
# Make sure invalid arguments to get_channel_list are caught
with pytest.raises(UnknownTokenAddress):
api1.get_channel_list(registry_address=registry_address,
token_address=None,
partner_address=api2.address)
address_for_lowest_settle_timeout = make_address()
lowest_valid_settle_timeout = node1.raiden.config.reveal_timeout * 2
# Make sure a small settle timeout is not accepted when opening a channel
with pytest.raises(InvalidSettleTimeout):
api1.channel_open(
registry_address=node1.raiden.default_registry.address,
token_address=token_address,
partner_address=address_for_lowest_settle_timeout,
settle_timeout=lowest_valid_settle_timeout - 1,
)
# Make sure the smallest settle timeout is accepted
api1.channel_open(
registry_address=node1.raiden.default_registry.address,
token_address=token_address,
partner_address=address_for_lowest_settle_timeout,
settle_timeout=lowest_valid_settle_timeout,
)
address_for_highest_settle_timeout = make_address()
highest_valid_settle_timeout = settle_timeout_max
# Make sure a large settle timeout is not accepted when opening a channel
with pytest.raises(InvalidSettleTimeout):
api1.channel_open(
registry_address=node1.raiden.default_registry.address,
token_address=token_address,
partner_address=address_for_highest_settle_timeout,
settle_timeout=highest_valid_settle_timeout + 1,
)
# Make sure the highest settle timeout is accepted
api1.channel_open(
registry_address=node1.raiden.default_registry.address,
token_address=token_address,
partner_address=address_for_highest_settle_timeout,
settle_timeout=highest_valid_settle_timeout,
)
# open is a synchronous api
api1.channel_open(node1.raiden.default_registry.address, token_address,
api2.address)
channels = api1.get_channel_list(registry_address, token_address,
api2.address)
assert len(channels) == 1
channel12 = get_channelstate(node1, node2, token_network_address)
assert channel.get_status(channel12) == ChannelState.STATE_OPENED
channel_event_list1 = api1.get_blockchain_events_channel(
token_address, channel12.partner_state.address)
assert must_have_event(
channel_event_list1,
{
"event": ChannelEvent.OPENED,
"args": {
"participant1": to_checksum_address(api1.address),
"participant2": to_checksum_address(api2.address),
},
},
)
network_event_list1 = api1.get_blockchain_events_token_network(
token_address)
assert must_have_event(network_event_list1, {"event": ChannelEvent.OPENED})
registry_address = api1.raiden.default_registry.address
# Check that giving a 0 total deposit is not accepted
with pytest.raises(DepositMismatch):
api1.set_total_channel_deposit(
registry_address=registry_address,
token_address=token_address,
partner_address=api2.address,
total_deposit=TokenAmount(0),
)
# Load the new state with the deposit
api1.set_total_channel_deposit(
registry_address=registry_address,
token_address=token_address,
partner_address=api2.address,
total_deposit=deposit,
)
# let's make sure it's idempotent. Same deposit should raise deposit mismatch limit
with pytest.raises(DepositMismatch):
api1.set_total_channel_deposit(registry_address, token_address,
api2.address, deposit)
channel12 = get_channelstate(node1, node2, token_network_address)
assert channel.get_status(channel12) == ChannelState.STATE_OPENED
assert channel.get_balance(channel12.our_state,
channel12.partner_state) == deposit
assert channel12.our_state.contract_balance == deposit
assert api1.get_channel_list(registry_address, token_address,
api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NetworkState.REACHABLE
assert api2.get_node_network_state(api1.address) == NetworkState.REACHABLE
event_list2 = api1.get_blockchain_events_channel(
token_address, channel12.partner_state.address)
assert must_have_event(
event_list2,
{
"event": ChannelEvent.DEPOSIT,
"args": {
"participant": to_checksum_address(api1.address),
"total_deposit": deposit
},
},
)
api1.channel_close(registry_address, token_address, api2.address)
# Load the new state with the channel closed
channel12 = get_channelstate(node1, node2, token_network_address)
event_list3 = api1.get_blockchain_events_channel(
token_address, channel12.partner_state.address)
assert len(event_list3) > len(event_list2)
assert must_have_event(
event_list3,
{
"event": ChannelEvent.CLOSED,
"args": {
"closing_participant": to_checksum_address(api1.address)
},
},
)
assert channel.get_status(channel12) == ChannelState.STATE_CLOSED
with pytest.raises(UnexpectedChannelState):
api1.set_total_channel_deposit(registry_address, token_address,
api2.address, deposit + 100)
assert wait_for_state_change(
node1.raiden,
ContractReceiveChannelSettled,
{
"canonical_identifier": {
"token_network_address": token_network_address,
"channel_identifier": channel12.identifier,
}
},
retry_timeout,
)
def test_channel_lifecycle(blockchain_type, raiden_network, token_addresses,
deposit):
if blockchain_type == 'tester':
pytest.skip(
'there is not support ATM for retrieving events from tester')
node1, node2 = raiden_network
token_address = token_addresses[0]
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_UNKNOWN
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_UNKNOWN
assert api1.get_channel_list(token_address, api2.address) == []
# this is a synchronous api
api1.open(token_address, api2.address)
channels = api1.get_channel_list(token_address, api2.address)
assert len(channels) == 1
channel12 = channels[0]
event_list1 = api1.get_channel_events(
channel12.channel_address,
channel12.external_state.opened_block,
)
assert event_list1 == []
# the channel has no deposit yet
assert channel12.state == CHANNEL_STATE_OPENED
api1.deposit(token_address, api2.address, deposit)
assert channel12.state == CHANNEL_STATE_OPENED
assert channel12.balance == deposit
assert channel12.contract_balance == deposit
assert api1.get_channel_list(token_address, api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_REACHABLE
event_list2 = api1.get_channel_events(
channel12.channel_address,
channel12.external_state.opened_block,
)
assert any((event['_event_type'] == 'ChannelNewBalance'
and event['participant'] == hexlify(api1.address))
for event in event_list2)
with pytest.raises(InvalidState):
api1.settle(token_address, api2.address)
api1.close(token_address, api2.address)
node1.raiden.poll_blockchain_events()
event_list3 = api1.get_channel_events(
channel12.channel_address,
channel12.external_state.opened_block,
)
assert len(event_list3) > len(event_list2)
assert any((event['_event_type'] == 'ChannelClosed'
and event['closing_address'] == hexlify(api1.address))
for event in event_list3)
assert channel12.state == CHANNEL_STATE_CLOSED
settlement_block = (
channel12.external_state.closed_block + channel12.settle_timeout +
5 # arbitrary number of additional blocks, used to wait for the settle() call
)
wait_until_block(node1.raiden.chain, settlement_block)
node1.raiden.poll_blockchain_events()
assert channel12.state == CHANNEL_STATE_SETTLED
def run_test_raidenapi_channel_lifecycle(raiden_network, token_addresses,
deposit, retry_timeout):
node1, node2 = raiden_network
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(node1), node1.raiden.default_registry.address,
token_address)
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
registry_address = node1.raiden.default_registry.address
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_UNKNOWN
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_UNKNOWN
assert not api1.get_channel_list(registry_address, token_address,
api2.address)
# Make sure invalid arguments to get_channel_list are caught
with pytest.raises(UnknownTokenAddress):
api1.get_channel_list(registry_address=registry_address,
token_address=None,
partner_address=api2.address)
# open is a synchronous api
api1.channel_open(node1.raiden.default_registry.address, token_address,
api2.address)
channels = api1.get_channel_list(registry_address, token_address,
api2.address)
assert len(channels) == 1
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
channel_event_list1 = api1.get_blockchain_events_channel(
token_address, channel12.partner_state.address)
assert must_have_event(
channel_event_list1,
{
"event": ChannelEvent.OPENED,
"args": {
"participant1": to_checksum_address(api1.address),
"participant2": to_checksum_address(api2.address),
},
},
)
network_event_list1 = api1.get_blockchain_events_token_network(
token_address)
assert must_have_event(network_event_list1, {"event": ChannelEvent.OPENED})
registry_address = api1.raiden.default_registry.address
# Check that giving a 0 total deposit is not accepted
with pytest.raises(DepositMismatch):
api1.set_total_channel_deposit(
registry_address=registry_address,
token_address=token_address,
partner_address=api2.address,
total_deposit=0,
)
# Load the new state with the deposit
api1.set_total_channel_deposit(
registry_address=registry_address,
token_address=token_address,
partner_address=api2.address,
total_deposit=deposit,
)
# let's make sure it's idempotent. Same deposit should raise deposit mismatch limit
with pytest.raises(DepositMismatch):
api1.set_total_channel_deposit(registry_address, token_address,
api2.address, deposit)
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
assert channel.get_balance(channel12.our_state,
channel12.partner_state) == deposit
assert channel12.our_state.contract_balance == deposit
assert api1.get_channel_list(registry_address, token_address,
api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_REACHABLE
event_list2 = api1.get_blockchain_events_channel(
token_address, channel12.partner_state.address)
assert must_have_event(
event_list2,
{
"event": ChannelEvent.DEPOSIT,
"args": {
"participant": to_checksum_address(api1.address),
"total_deposit": deposit
},
},
)
api1.channel_close(registry_address, token_address, api2.address)
# Load the new state with the channel closed
channel12 = get_channelstate(node1, node2, token_network_identifier)
event_list3 = api1.get_blockchain_events_channel(
token_address, channel12.partner_state.address)
assert len(event_list3) > len(event_list2)
assert must_have_event(
event_list3,
{
"event": ChannelEvent.CLOSED,
"args": {
"closing_participant": to_checksum_address(api1.address)
},
},
)
assert channel.get_status(channel12) == CHANNEL_STATE_CLOSED
assert wait_for_state_change(
node1.raiden,
ContractReceiveChannelSettled,
{
"token_network_identifier": token_network_identifier,
"channel_identifier": channel12.identifier,
},
retry_timeout,
)
def run(
privatekey,
registry_contract_address,
discovery_contract_address,
listen_address,
logging,
logfile,
scenario,
stage_prefix,
results_filename): # pylint: disable=unused-argument
# TODO: only enabled logging on "initiators"
slogging.configure(logging, log_file=logfile)
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.DEFAULT_CONFIG.copy()
config['host'] = listen_host
config['port'] = listen_port
config['privatekey_hex'] = privatekey
privatekey_bin = decode_hex(privatekey)
rpc_client = JSONRPCClient(
'127.0.0.1',
8545,
privatekey_bin,
)
blockchain_service = BlockChainService(
privatekey_bin,
rpc_client,
GAS_LIMIT,
GAS_PRICE,
)
discovery = ContractDiscovery(
blockchain_service,
decode_hex(discovery_contract_address)
)
registry = blockchain_service.registry(
registry_contract_address
)
app = App(
config,
blockchain_service,
registry,
discovery,
)
app.discovery.register(
app.raiden.address,
listen_host,
listen_port,
)
app.raiden.register_registry(app.raiden.default_registry.address)
if scenario:
script = json.load(scenario)
tools = ConsoleTools(
app.raiden,
app.discovery,
app.config['settle_timeout'],
app.config['reveal_timeout'],
)
transfers_by_peer = {}
tokens = script['tokens']
token_address = None
peer = None
our_node = hexlify(app.raiden.address)
log.warning("our address is {}".format(our_node))
for token in tokens:
# skip tokens that we're not part of
nodes = token['channels']
if our_node not in nodes:
continue
partner_nodes = [
node
for node in nodes
if node != our_node
]
# allow for prefunded tokens
if 'token_address' in token:
token_address = token['token_address']
else:
token_address = tools.create_token()
transfers_with_amount = token['transfers_with_amount']
# FIXME: in order to do bidirectional channels, only one side
# (i.e. only token['channels'][0]) should
# open; others should join by calling
# raiden.api.deposit, AFTER the channel came alive!
# NOTE: leaving unidirectional for now because it most
# probably will get to higher throughput
log.warning("Waiting for all nodes to come online")
api = RaidenAPI(app.raiden)
for node in partner_nodes:
api.start_health_check_for(node)
while True:
all_reachable = all(
api.get_node_network_state(node) == NODE_NETWORK_REACHABLE
for node in partner_nodes
)
if all_reachable:
break
gevent.sleep(5)
log.warning("All nodes are online")
if our_node != nodes[-1]:
our_index = nodes.index(our_node)
peer = nodes[our_index + 1]
tools.register_token(token_address)
amount = transfers_with_amount[nodes[-1]]
while True:
try:
app.discovery.get(peer.decode('hex'))
break
except KeyError:
log.warning("Error: peer {} not found in discovery".format(peer))
time.sleep(random.randrange(30))
while True:
try:
log.warning("Opening channel with {} for {}".format(peer, token_address))
api.open(token_address, peer)
break
except KeyError:
log.warning("Error: could not open channel with {}".format(peer))
time.sleep(random.randrange(30))
while True:
try:
log.warning("Funding channel with {} for {}".format(peer, token_address))
api.deposit(token_address, peer, amount)
break
except Exception:
log.warning("Error: could not deposit {} for {}".format(amount, peer))
time.sleep(random.randrange(30))
if our_index == 0:
last_node = nodes[-1]
transfers_by_peer[last_node] = int(amount)
else:
peer = nodes[-2]
if stage_prefix is not None:
open('{}.stage1'.format(stage_prefix), 'a').close()
log.warning("Done with initialization, waiting to continue...")
event = gevent.event.Event()
gevent.signal(signal.SIGUSR2, event.set)
event.wait()
transfer_results = {'total_time': 0, 'timestamps': []}
def transfer(token_address, amount_per_transfer, total_transfers, peer, is_async):
def transfer_():
log.warning("Making {} transfers to {}".format(total_transfers, peer))
initial_time = time.time()
times = [0] * total_transfers
for index in range(total_transfers):
RaidenAPI(app.raiden).transfer(
token_address.decode('hex'),
amount_per_transfer,
peer,
)
times[index] = time.time()
transfer_results['total_time'] = time.time() - initial_time
transfer_results['timestamps'] = times
log.warning("Making {} transfers took {}".format(
total_transfers, transfer_results['total_time']))
log.warning("Times: {}".format(times))
if is_async:
return gevent.spawn(transfer_)
else:
transfer_()
# If sending to multiple targets, do it asynchronously, otherwise
# keep it simple and just send to the single target on my thread.
if len(transfers_by_peer) > 1:
greenlets = []
for peer_, amount in transfers_by_peer.items():
greenlet = transfer(token_address, 1, amount, peer_, True)
if greenlet is not None:
greenlets.append(greenlet)
gevent.joinall(greenlets)
elif len(transfers_by_peer) == 1:
for peer_, amount in transfers_by_peer.items():
transfer(token_address, 1, amount, peer_, False)
log.warning("Waiting for termination")
open('{}.stage2'.format(stage_prefix), 'a').close()
log.warning("Waiting for transfers to finish, will write results...")
event = gevent.event.Event()
gevent.signal(signal.SIGUSR2, event.set)
event.wait()
results = tools.channel_stats_for(token_address, peer)
if transfer_results['total_time'] != 0:
results['total_time'] = transfer_results['total_time']
if len(transfer_results['timestamps']) > 0:
results['timestamps'] = transfer_results['timestamps']
results['channel'] = repr(results['channel']) # FIXME
log.warning("Results: {}".format(results))
with open(results_filename, 'w') as fp:
json.dump(results, fp, indent=2)
open('{}.stage3'.format(stage_prefix), 'a').close()
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
else:
log.warning("No scenario file supplied, doing nothing!")
open('{}.stage2'.format(stage_prefix), 'a').close()
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
app.stop()
def test_channel_lifecycle(raiden_network, token_addresses, deposit):
node1, node2 = raiden_network
token_address = token_addresses[0]
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_UNKNOWN
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_UNKNOWN
assert not api1.get_channel_list(token_address, api2.address)
# open is a synchronous api
api1.channel_open(token_address, api2.address)
channels = api1.get_channel_list(token_address, api2.address)
assert len(channels) == 1
channel12 = get_channelstate(node1, node2, token_address)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
event_list1 = api1.get_channel_events(
channel12.identifier,
channel12.open_transaction.finished_block_number,
)
assert event_list1 == []
# Load the new state with the deposit
api1.channel_deposit(token_address, api2.address, deposit)
channel12 = get_channelstate(node1, node2, token_address)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
assert channel.get_balance(channel12.our_state,
channel12.partner_state) == deposit
assert channel12.our_state.contract_balance == deposit
assert api1.get_channel_list(token_address, api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_REACHABLE
event_list2 = api1.get_channel_events(
channel12.identifier,
channel12.open_transaction.finished_block_number,
)
assert any((event['_event_type'] == b'ChannelNewBalance'
and event['participant'] == address_encoder(api1.address))
for event in event_list2)
api1.channel_close(token_address, api2.address)
node1.raiden.poll_blockchain_events()
# Load the new state with the channel closed
channel12 = get_channelstate(node1, node2, token_address)
event_list3 = api1.get_channel_events(
channel12.identifier,
channel12.open_transaction.finished_block_number,
)
assert len(event_list3) > len(event_list2)
assert any((event['_event_type'] == b'ChannelClosed'
and event['closing_address'] == address_encoder(api1.address))
for event in event_list3)
assert channel.get_status(channel12) == CHANNEL_STATE_CLOSED
settlement_block = (
channel12.close_transaction.finished_block_number +
channel12.settle_timeout +
10 # arbitrary number of additional blocks, used to wait for the settle() call
)
wait_until_block(node1.raiden.chain, settlement_block)
# Load the new state with the channel settled
channel12 = get_channelstate(node1, node2, token_address)
node1.raiden.poll_blockchain_events()
assert channel.get_status(channel12) == CHANNEL_STATE_SETTLED
def test_channel_lifecycle(raiden_network, token_addresses, deposit, transport_protocol):
node1, node2 = raiden_network
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(node1),
node1.raiden.default_registry.address,
token_address,
)
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
registry_address = node1.raiden.default_registry.address
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_UNKNOWN
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_UNKNOWN
assert not api1.get_channel_list(registry_address, token_address, api2.address)
# Make sure invalid arguments to get_channel_list are caught
with pytest.raises(UnknownTokenAddress):
api1.get_channel_list(
registry_address=registry_address,
token_address=None,
partner_address=api2.address,
)
# open is a synchronous api
api1.channel_open(node1.raiden.default_registry.address, token_address, api2.address)
channels = api1.get_channel_list(registry_address, token_address, api2.address)
assert len(channels) == 1
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
event_list1 = api1.get_blockchain_events_channel(
token_address,
channel12.partner_state.address,
)
assert any(
(
event['event'] == ChannelEvent.OPENED and
is_same_address(
event['args']['participant1'],
to_normalized_address(api1.address),
) and
is_same_address(
event['args']['participant2'],
to_normalized_address(api2.address),
)
)
for event in event_list1
)
token_events = api1.get_blockchain_events_token_network(
token_address,
)
assert token_events[0]['event'] == ChannelEvent.OPENED
registry_address = api1.raiden.default_registry.address
# Load the new state with the deposit
api1.set_total_channel_deposit(
registry_address,
token_address,
api2.address,
deposit,
)
# let's make sure it's idempotent. Same deposit should raise deposit mismatch limit
with pytest.raises(DepositMismatch):
api1.set_total_channel_deposit(
registry_address,
token_address,
api2.address,
deposit,
)
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
assert channel.get_balance(channel12.our_state, channel12.partner_state) == deposit
assert channel12.our_state.contract_balance == deposit
assert api1.get_channel_list(registry_address, token_address, api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_REACHABLE
event_list2 = api1.get_blockchain_events_channel(
token_address,
channel12.partner_state.address,
)
assert any(
(
event['event'] == ChannelEvent.DEPOSIT and
is_same_address(
event['args']['participant'],
to_normalized_address(api1.address),
) and
event['args']['total_deposit'] == deposit
)
for event in event_list2
)
api1.channel_close(registry_address, token_address, api2.address)
# Load the new state with the channel closed
channel12 = get_channelstate(node1, node2, token_network_identifier)
event_list3 = api1.get_blockchain_events_channel(
token_address,
channel12.partner_state.address,
)
assert len(event_list3) > len(event_list2)
assert any(
(
event['event'] == ChannelEvent.CLOSED and
is_same_address(
event['args']['closing_participant'],
to_normalized_address(api1.address),
)
)
for event in event_list3
)
assert channel.get_status(channel12) == CHANNEL_STATE_CLOSED
settlement_block = (
channel12.close_transaction.finished_block_number +
channel12.settle_timeout +
10 # arbitrary number of additional blocks, used to wait for the settle() call
)
wait_until_block(node1.raiden.chain, settlement_block + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS)
state_changes = node1.raiden.wal.storage.get_statechanges_by_identifier(
from_identifier=0,
to_identifier='latest',
)
assert must_contain_entry(state_changes, ContractReceiveChannelSettled, {
'token_network_identifier': token_network_identifier,
'channel_identifier': channel12.identifier,
})
def test_raidenapi_channel_lifecycle(
raiden_network: List[RaidenService],
token_addresses,
deposit,
retry_timeout,
settle_timeout_max,
):
"""Uses RaidenAPI to go through a complete channel lifecycle."""
app1, app2 = raiden_network
token_address = token_addresses[0]
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_raiden(app1), app1.default_registry.address,
token_address)
assert token_network_address
api1 = RaidenAPI(app1)
api2 = RaidenAPI(app2)
registry_address = app1.default_registry.address
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(api2.address) == NetworkState.UNKNOWN
assert api2.get_node_network_state(api1.address) == NetworkState.UNKNOWN
assert not api1.get_channel_list(registry_address, token_address,
api2.address)
# Make sure invalid arguments to get_channel_list are caught
with pytest.raises(UnknownTokenAddress):
api1.get_channel_list(registry_address=registry_address,
token_address=None,
partner_address=api2.address)
address_for_lowest_settle_timeout = make_address()
lowest_valid_settle_timeout = app1.config.reveal_timeout * 2
# Make sure a small settle timeout is not accepted when opening a channel
with pytest.raises(InvalidSettleTimeout):
api1.channel_open(
registry_address=app1.default_registry.address,
token_address=token_address,
partner_address=address_for_lowest_settle_timeout,
settle_timeout=BlockTimeout(lowest_valid_settle_timeout - 1),
)
# Make sure the smallest settle timeout is accepted
api1.channel_open(
registry_address=app1.default_registry.address,
token_address=token_address,
partner_address=address_for_lowest_settle_timeout,
settle_timeout=BlockTimeout(lowest_valid_settle_timeout),
)
address_for_highest_settle_timeout = make_address()
highest_valid_settle_timeout = settle_timeout_max
# Make sure a large settle timeout is not accepted when opening a channel
with pytest.raises(InvalidSettleTimeout):
api1.channel_open(
registry_address=app1.default_registry.address,
token_address=token_address,
partner_address=address_for_highest_settle_timeout,
settle_timeout=highest_valid_settle_timeout + 1,
)
# Make sure the highest settle timeout is accepted
api1.channel_open(
registry_address=app1.default_registry.address,
token_address=token_address,
partner_address=address_for_highest_settle_timeout,
settle_timeout=highest_valid_settle_timeout,
)
# open is a synchronous api
api1.channel_open(app1.default_registry.address, token_address,
api2.address)
channels = api1.get_channel_list(registry_address, token_address,
api2.address)
assert len(channels) == 1
channel12 = get_channelstate(app1, app2, token_network_address)
assert channel.get_status(channel12) == ChannelState.STATE_OPENED
registry_address = api1.raiden.default_registry.address
# Check that giving a 0 total deposit is not accepted
with pytest.raises(DepositMismatch):
api1.set_total_channel_deposit(
registry_address=registry_address,
token_address=token_address,
partner_address=api2.address,
total_deposit=TokenAmount(0),
)
# Load the new state with the deposit
api1.set_total_channel_deposit(
registry_address=registry_address,
token_address=token_address,
partner_address=api2.address,
total_deposit=deposit,
)
# let's make sure it's idempotent. Same deposit should raise deposit mismatch limit
with pytest.raises(DepositMismatch):
api1.set_total_channel_deposit(registry_address, token_address,
api2.address, deposit)
channel12 = get_channelstate(app1, app2, token_network_address)
assert channel.get_status(channel12) == ChannelState.STATE_OPENED
assert channel.get_balance(channel12.our_state,
channel12.partner_state) == deposit
assert channel12.our_state.contract_balance == deposit
assert api1.get_channel_list(registry_address, token_address,
api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NetworkState.REACHABLE
assert api2.get_node_network_state(api1.address) == NetworkState.REACHABLE
api1.channel_close(registry_address, token_address, api2.address)
# Load the new state with the channel closed
channel12 = get_channelstate(app1, app2, token_network_address)
assert channel.get_status(channel12) == ChannelState.STATE_CLOSED
with pytest.raises(UnexpectedChannelState):
api1.set_total_channel_deposit(registry_address, token_address,
api2.address, deposit + 100)
assert wait_for_state_change(
app1,
ContractReceiveChannelSettled,
{
"canonical_identifier": {
"token_network_address": token_network_address,
"channel_identifier": channel12.identifier,
}
},
retry_timeout,
)
