def test_handle_new_token_network(chain_state, token_network_address):
token_address = factories.make_address()
token_network = TokenNetworkState(
address=token_network_address,
token_address=token_address,
network_graph=TokenNetworkGraphState(token_network_address=token_network_address),
)
token_network_registry_address = factories.make_address()
state_change = ContractReceiveNewTokenNetwork(
token_network_registry_address=token_network_registry_address,
token_network=token_network,
transaction_hash=factories.make_transaction_hash(),
block_hash=factories.make_block_hash(),
block_number=factories.make_block_number(),
)
transition_result = handle_contract_receive_new_token_network(
chain_state=chain_state, state_change=state_change
)
new_chain_state = transition_result.new_state
token_network_registry = new_chain_state.identifiers_to_tokennetworkregistries[
token_network_registry_address
]
assert token_network_registry.address == token_network_registry_address
assert not transition_result.events
assert get_networks(
chain_state=chain_state,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
) == (token_network_registry, token_network)
def create_square_network_topology(
token_network_state, our_address
) -> typing.Tuple[
TokenNetworkState, typing.List[typing.Address], typing.List[NettingChannelState]
]:
address1 = factories.make_address()
address2 = factories.make_address()
address3 = factories.make_address()
address4 = factories.make_address()
# Create a network with the following topology
#
# our ----- 50 ----> (1) <------50------
# | |
# | |
# 100 (4)
# | ^
# v |
# (2) ----- 100 ---> (3) <-------100---
routes = [
factories.RouteProperties(
address1=our_address, address2=address1, capacity1to2=TokenAmount(50)
),
factories.RouteProperties(
address1=our_address, address2=address2, capacity1to2=TokenAmount(100)
),
factories.RouteProperties(
address1=address4, address2=address1, capacity1to2=TokenAmount(50)
),
factories.RouteProperties(
address1=address2, address2=address3, capacity1to2=TokenAmount(100)
),
factories.RouteProperties(
address1=address3,
address2=address4,
capacity1to2=TokenAmount(100),
capacity2to1=TokenAmount(100),
),
]
new_state, channels = factories.create_network(
token_network_state=token_network_state,
our_address=our_address,
routes=routes,
block_number=factories.make_block_number(),
)
return new_state, [address1, address2, address3, address4], channels
def test_routing_priority(chain_state, token_network_state, one_to_n_address,
our_address):
open_block_number = factories.make_block_number()
open_block_number_hash = factories.make_block_hash()
address1 = factories.make_address()
address2 = factories.make_address()
address3 = factories.make_address()
address4 = factories.make_address()
pseudo_random_generator = random.Random()
# Create a network with the following topology
#
# our ----- 1/1 ----> (1)
# | |
# | |
# 2/0 x
# | |
# v v
# (2) ----- x -----> (3)
# | |
# | |
# x x
# | |
# v v
# (4) (4)
channel_state1 = factories.create(
factories.NettingChannelStateProperties(
our_state=factories.NettingChannelEndStateProperties(
balance=1, address=our_address),
partner_state=factories.NettingChannelEndStateProperties(
balance=1, address=address1),
))
channel_state2 = factories.create(
factories.NettingChannelStateProperties(
our_state=factories.NettingChannelEndStateProperties(
balance=2, address=our_address),
partner_state=factories.NettingChannelEndStateProperties(
balance=0, address=address2),
))
# create new channels as participant
channel_new_state_change1 = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state1,
block_number=open_block_number,
block_hash=open_block_number_hash,
)
channel_new_state_change2 = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state2,
block_number=open_block_number,
block_hash=open_block_number_hash,
)
channel_new_iteration1 = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change1,
block_number=open_block_number,
block_hash=open_block_number_hash,
pseudo_random_generator=pseudo_random_generator,
)
channel_new_iteration2 = token_network.state_transition(
token_network_state=channel_new_iteration1.new_state,
state_change=channel_new_state_change2,
block_number=open_block_number,
block_hash=open_block_number_hash,
pseudo_random_generator=pseudo_random_generator,
)
# create new channels without being participant
channel_new_state_change3 = ContractReceiveRouteNew(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=factories.make_canonical_identifier(
token_network_address=token_network_state.address,
channel_identifier=3),
participant1=address2,
participant2=address3,
block_number=open_block_number,
block_hash=open_block_number_hash,
)
channel_new_iteration3 = token_network.state_transition(
token_network_state=channel_new_iteration2.new_state,
state_change=channel_new_state_change3,
block_number=open_block_number + 10,
block_hash=factories.make_block_hash(),
pseudo_random_generator=pseudo_random_generator,
)
channel_new_state_change4 = ContractReceiveRouteNew(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=factories.make_canonical_identifier(
token_network_address=token_network_state.address,
channel_identifier=4),
participant1=address3,
participant2=address1,
block_number=open_block_number,
block_hash=open_block_number_hash,
)
channel_new_iteration4 = token_network.state_transition(
token_network_state=channel_new_iteration3.new_state,
state_change=channel_new_state_change4,
block_number=open_block_number + 10,
block_hash=factories.make_block_hash(),
pseudo_random_generator=pseudo_random_generator,
)
channel_new_state_change5 = ContractReceiveRouteNew(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=factories.make_canonical_identifier(
token_network_address=token_network_state.address,
channel_identifier=4),
participant1=address3,
participant2=address4,
block_number=open_block_number,
block_hash=open_block_number_hash,
)
channel_new_iteration5 = token_network.state_transition(
token_network_state=channel_new_iteration4.new_state,
state_change=channel_new_state_change5,
block_number=open_block_number + 10,
block_hash=factories.make_block_hash(),
pseudo_random_generator=pseudo_random_generator,
)
channel_new_state_change6 = ContractReceiveRouteNew(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=factories.make_canonical_identifier(
token_network_address=token_network_state.address,
channel_identifier=4),
participant1=address2,
participant2=address4,
block_number=open_block_number,
block_hash=open_block_number_hash,
)
token_network.state_transition(
token_network_state=channel_new_iteration5.new_state,
state_change=channel_new_state_change6,
block_number=open_block_number + 10,
block_hash=factories.make_block_hash(),
pseudo_random_generator=pseudo_random_generator,
)
# test routing priority with all nodes available
chain_state.nodeaddresses_to_networkstates = {
address1: NetworkState.REACHABLE,
address2: NetworkState.REACHABLE,
address3: NetworkState.REACHABLE,
}
error_msg, routes, _ = get_best_routes(
chain_state=chain_state,
token_network_address=token_network_state.address,
one_to_n_address=one_to_n_address,
from_address=our_address,
to_address=address3,
amount=1,
previous_address=None,
pfs_config=None,
privkey=b"",
)
assert routes, error_msg
assert routes[0].next_hop_address == address1, error_msg
assert routes[1].next_hop_address == address2, error_msg
# number of hops overwrites refunding capacity (route over node 2 involves less hops)
chain_state.nodeaddresses_to_networkstates = {
address1: NetworkState.REACHABLE,
address2: NetworkState.REACHABLE,
address3: NetworkState.REACHABLE,
address4: NetworkState.REACHABLE,
}
_, routes, _ = get_best_routes(
chain_state=chain_state,
token_network_address=token_network_state.address,
one_to_n_address=one_to_n_address,
from_address=our_address,
to_address=address4,
amount=1,
previous_address=None,
pfs_config=None,
privkey=b"",
)
assert routes[0].next_hop_address == address2
assert routes[1].next_hop_address == address1
def test_encoding_and_decoding():
message_factories = (
factories.LockedTransferProperties(),
factories.RefundTransferProperties(),
factories.LockExpiredProperties(),
factories.UnlockProperties(),
)
messages = [factories.create(factory) for factory in message_factories]
# TODO Handle these with factories once #5091 is implemented
messages.append(
Delivered(
delivered_message_identifier=factories.make_message_identifier(),
signature=factories.make_signature(),
))
messages.append(
Processed(
message_identifier=factories.make_message_identifier(),
signature=factories.make_signature(),
))
messages.append(
RevealSecret(
message_identifier=factories.make_message_identifier(),
secret=factories.make_secret(),
signature=factories.make_signature(),
))
messages.append(
SecretRequest(
message_identifier=factories.make_message_identifier(),
payment_identifier=factories.make_payment_id(),
secrethash=factories.make_secret_hash(),
amount=factories.make_token_amount(),
expiration=factories.make_block_number(),
signature=factories.make_signature(),
))
messages.append(
WithdrawRequest(
message_identifier=factories.make_message_identifier(),
chain_id=factories.make_chain_id(),
token_network_address=factories.make_token_network_address(),
channel_identifier=factories.make_channel_identifier(),
participant=factories.make_address(),
total_withdraw=factories.make_token_amount(),
nonce=factories.make_nonce(),
expiration=factories.make_block_number(),
signature=factories.make_signature(),
))
messages.append(
WithdrawConfirmation(
message_identifier=factories.make_message_identifier(),
chain_id=factories.make_chain_id(),
token_network_address=factories.make_token_network_address(),
channel_identifier=factories.make_channel_identifier(),
participant=factories.make_address(),
total_withdraw=factories.make_token_amount(),
nonce=factories.make_nonce(),
expiration=factories.make_block_number(),
signature=factories.make_signature(),
))
messages.append(
WithdrawExpired(
message_identifier=factories.make_message_identifier(),
chain_id=factories.make_chain_id(),
token_network_address=factories.make_token_network_address(),
channel_identifier=factories.make_channel_identifier(),
participant=factories.make_address(),
total_withdraw=factories.make_token_amount(),
nonce=factories.make_nonce(),
expiration=factories.make_block_number(),
signature=factories.make_signature(),
))
messages.append(
PFSCapacityUpdate(
canonical_identifier=factories.make_canonical_identifier(),
updating_participant=factories.make_address(),
other_participant=factories.make_address(),
updating_nonce=factories.make_nonce(),
other_nonce=factories.make_nonce(),
updating_capacity=factories.make_token_amount(),
other_capacity=factories.make_token_amount(),
reveal_timeout=factories.make_uint64(),
signature=factories.make_signature(),
))
messages.append(
PFSFeeUpdate(
canonical_identifier=factories.make_canonical_identifier(),
updating_participant=factories.make_address(),
fee_schedule=factories.create(
factories.FeeScheduleStateProperties()),
timestamp=datetime.now(),
signature=factories.make_signature(),
))
messages.append(
RequestMonitoring(
reward_amount=factories.make_token_amount(),
balance_proof=SignedBlindedBalanceProof.
from_balance_proof_signed_state(
factories.create(
factories.BalanceProofSignedStateProperties())),
monitoring_service_contract_address=factories.make_address(),
non_closing_participant=factories.make_address(),
non_closing_signature=factories.make_signature(),
signature=factories.make_signature(),
))
for message in messages:
serialized = MessageSerializer.serialize(message)
deserialized = MessageSerializer.deserialize(serialized)
assert deserialized == message