def _action_init_initiator(self,
transfer: TransferDescriptionWithSecretState):
channel = self.address_to_channel[transfer.target]
if transfer.secrethash not in self.expected_expiry:
self.expected_expiry[transfer.secrethash] = self.block_number + 10
return ActionInitInitiator(
transfer, [factories.make_route_from_channel(channel)])
def test_mediator_task_view():
"""Same as above for mediator tasks."""
secret1 = factories.make_secret(1)
locked_amount1 = 11
payee_transfer = factories.create(
factories.LockedTransferUnsignedStateProperties(secret=secret1))
payer_transfer = factories.create(
factories.LockedTransferSignedStateProperties(
secret=secret1, payment_identifier=1,
locked_amount=locked_amount1))
secrethash1 = payee_transfer.lock.secrethash
initiator = payee_transfer.initiator
initiator_channel = factories.create(
factories.NettingChannelStateProperties(
partner_state=factories.NettingChannelEndStateProperties(
address=initiator, balance=100)))
routes = [factories.make_route_from_channel(initiator_channel)]
transfer_state1 = MediatorTransferState(secrethash=secrethash1,
routes=routes)
transfer_state1.transfers_pair.append(
MediationPairState(
payer_transfer=payer_transfer,
payee_transfer=payee_transfer,
payee_address=payee_transfer.target,
))
task1 = MediatorTask(
token_network_identifier=factories.UNIT_TOKEN_NETWORK_ADDRESS,
mediator_state=transfer_state1,
)
secret2 = factories.make_secret(2)
locked_amount2 = 13
transfer2 = factories.create(
factories.LockedTransferSignedStateProperties(
secret=secret2, payment_identifier=2,
locked_amount=locked_amount2))
secrethash2 = transfer2.lock.secrethash
transfer_state2 = MediatorTransferState(secrethash=secrethash2,
routes=routes)
transfer_state2.waiting_transfer = WaitingTransferState(transfer=transfer2)
task2 = MediatorTask(
token_network_identifier=factories.UNIT_TOKEN_NETWORK_ADDRESS,
mediator_state=transfer_state2,
)
payment_mapping = {secrethash1: task1, secrethash2: task2}
view = transfer_tasks_view(payment_mapping)
assert len(view) == 2
if view[0].get("payment_identifier") == "1":
pending_transfer, waiting_transfer = view
else:
waiting_transfer, pending_transfer = view
assert pending_transfer.get("role") == waiting_transfer.get(
"role") == "mediator"
assert pending_transfer.get("payment_identifier") == "1"
assert waiting_transfer.get("payment_identifier") == "2"
assert pending_transfer.get("locked_amount") == str(locked_amount1)
assert waiting_transfer.get("locked_amount") == str(locked_amount2)
def make_from_route_from_counter(counter):
from_channel = factories.create(
factories.NettingChannelStateProperties(
canonical_identifier=factories.make_canonical_identifier(),
token_address=factories.make_address(),
partner_state=factories.NettingChannelEndStateProperties(
balance=next(counter), address=factories.HOP1),
))
from_route = factories.make_route_from_channel(from_channel)
expiration = factories.UNIT_REVEAL_TIMEOUT + 1
from_transfer = factories.make_signed_transfer_for(
from_channel,
factories.LockedTransferSignedStateProperties(
transferred_amount=0,
canonical_identifier=factories.make_canonical_identifier(
token_network_address=from_channel.token_network_identifier),
amount=1,
expiration=expiration,
secret=sha3(factories.make_secret(next(counter))),
initiator=factories.make_address(),
target=factories.make_address(),
payment_identifier=next(counter),
sender=factories.HOP1,
pkey=factories.HOP1_KEY,
),
)
return from_route, from_transfer
def _action_init_mediator(
self, transfer: LockedTransferSignedState) -> ActionInitMediator:
initiator_channel = self.address_to_channel[transfer.initiator]
target_channel = self.address_to_channel[transfer.target]
return ActionInitMediator(
[factories.make_route_from_channel(target_channel)],
factories.make_route_to_channel(initiator_channel),
transfer,
)
def _action_init_mediator(
self, transfer: LockedTransferSignedState) -> ActionInitMediator:
initiator_channel = self.address_to_channel[transfer.initiator]
target_channel = self.address_to_channel[transfer.target]
return ActionInitMediator(
route_states=[factories.make_route_from_channel(target_channel)],
from_hop=factories.make_hop_to_channel(initiator_channel),
from_transfer=transfer,
balance_proof=transfer.balance_proof,
sender=transfer.balance_proof.sender,
)
def _action_init_mediator(
self, transfer: LockedTransferSignedState, client_address
) -> WithOurAddress:
client = self.address_to_client[client_address]
initiator_channel = client.address_to_channel[transfer.initiator]
target_channel = client.address_to_channel[transfer.target]
action = ActionInitMediator(
route_states=[factories.make_route_from_channel(target_channel)],
from_hop=factories.make_hop_to_channel(initiator_channel),
from_transfer=transfer,
balance_proof=transfer.balance_proof,
sender=transfer.balance_proof.sender,
)
return WithOurAddress(our_address=client_address, data=action)
def test_regression_mediator_not_update_payer_state_twice():
""" Regression Test for https://github.com/raiden-network/raiden/issues/3086
Make sure that after a lock expired the mediator doesn't update the pair
twice causing EventUnlockClaimFailed to be generated at every block.
"""
pseudo_random_generator = random.Random()
pair = factories.mediator_make_channel_pair()
payer_channel, payee_channel = pair.channels
payer_route = factories.make_route_from_channel(payer_channel)
payer_transfer = factories.make_signed_transfer_for(payer_channel, LONG_EXPIRATION)
available_routes = [factories.make_route_from_channel(payee_channel)]
init_state_change = ActionInitMediator(
routes=available_routes, from_route=payer_route, from_transfer=payer_transfer
)
iteration = mediator.state_transition(
mediator_state=None,
state_change=init_state_change,
channelidentifiers_to_channels=pair.channel_map,
nodeaddresses_to_networkstates=pair.nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=5,
block_hash=factories.make_block_hash(),
)
assert iteration.new_state is not None
current_state = iteration.new_state
send_transfer = search_for_item(iteration.events, SendLockedTransfer, {})
assert send_transfer
transfer = send_transfer.transfer
block_expiration_number = channel.get_sender_expiration_threshold(transfer.lock)
block = Block(
block_number=block_expiration_number,
gas_limit=1,
block_hash=factories.make_transaction_hash(),
)
iteration = mediator.state_transition(
mediator_state=current_state,
state_change=block,
channelidentifiers_to_channels=pair.channel_map,
nodeaddresses_to_networkstates=pair.nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=block_expiration_number,
block_hash=factories.make_block_hash(),
)
msg = "At the expiration block we should get an EventUnlockClaimFailed"
assert search_for_item(iteration.events, EventUnlockClaimFailed, {}), msg
current_state = iteration.new_state
next_block = Block(
block_number=block_expiration_number + 1,
gas_limit=1,
block_hash=factories.make_transaction_hash(),
)
# Initiator receives the secret reveal after the lock expired
receive_secret = ReceiveSecretReveal(
secret=UNIT_SECRET, sender=payee_channel.partner_state.address
)
iteration = mediator.state_transition(
mediator_state=current_state,
state_change=receive_secret,
channelidentifiers_to_channels=pair.channel_map,
nodeaddresses_to_networkstates=pair.nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=next_block.block_number,
block_hash=next_block.block_hash,
)
current_state = iteration.new_state
lock = payer_transfer.lock
secrethash = lock.secrethash
assert secrethash in payer_channel.partner_state.secrethashes_to_lockedlocks
assert current_state.transfers_pair[0].payee_state == "payee_expired"
assert not channel.is_secret_known(payer_channel.partner_state, secrethash)
safe_to_wait, _ = mediator.is_safe_to_wait(
lock_expiration=lock.expiration,
reveal_timeout=payer_channel.reveal_timeout,
block_number=lock.expiration + 10,
)
assert not safe_to_wait
iteration = mediator.state_transition(
mediator_state=current_state,
state_change=next_block,
channelidentifiers_to_channels=pair.channel_map,
nodeaddresses_to_networkstates=pair.nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=block_expiration_number,
block_hash=factories.make_block_hash(),
)
msg = "At the next block we should not get the same event"
assert not search_for_item(iteration.events, EventUnlockClaimFailed, {}), msg
def test_multiple_channel_states(chain_state, token_network_state,
channel_properties):
open_block_number = 10
open_block_hash = factories.make_block_hash()
properties, pkey = channel_properties
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b"test_end_state")
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
from_route = factories.make_route_from_channel(channel_state)
init_target = ActionInitTarget(from_route, mediated_transfer)
node.state_transition(chain_state, init_target)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=factories.make_32bytes(),
partner_onchain_locksroot=EMPTY_MERKLE_ROOT,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
# Create new channel while the previous one is pending unlock
new_channel_properties = factories.create_properties(
factories.NettingChannelStateProperties(
canonical_identifier=factories.make_canonical_identifier()),
defaults=properties,
)
new_channel_state = factories.create(new_channel_properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=new_channel_state,
block_number=closed_block_number + 1,
block_hash=factories.make_block_hash(),
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
)
token_network_state_after_new_open = channel_new_iteration.new_state
ids_to_channels = token_network_state_after_new_open.channelidentifiers_to_channels
assert len(ids_to_channels) == 2
assert channel_state.identifier in ids_to_channels
def test_mediator_clear_pairs_after_batch_unlock(chain_state,
token_network_state,
our_address,
channel_properties):
""" Regression test for https://github.com/raiden-network/raiden/issues/2932
The mediator must also clear the transfer pairs once a ReceiveBatchUnlock where
he is a participant is received.
"""
open_block_number = 10
open_block_hash = factories.make_block_hash()
properties, pkey = channel_properties
address = properties.partner_state.address
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b"test_end_state")
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
from_route = factories.make_route_from_channel(channel_state)
init_mediator = ActionInitMediator(routes=[from_route],
from_route=from_route,
from_transfer=mediated_transfer)
node.state_transition(chain_state, init_mediator)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=factories.make_32bytes(),
partner_onchain_locksroot=EMPTY_MERKLE_ROOT,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
block_number = closed_block_number + 1
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
participant=our_address,
partner=address,
locksroot=lock_secrethash,
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=block_number,
block_hash=factories.make_block_hash(),
)
channel_unlock_iteration = node.state_transition(
chain_state=chain_state,
state_change=channel_batch_unlock_state_change)
chain_state = channel_unlock_iteration.new_state
token_network_state = views.get_token_network_by_identifier(
chain_state=chain_state, token_network_id=token_network_state.address)
ids_to_channels = token_network_state.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
# Make sure that all is fine in the next block
block = Block(block_number=block_number + 1,
gas_limit=1,
block_hash=factories.make_transaction_hash())
iteration = node.state_transition(chain_state=chain_state,
state_change=block)
assert iteration.new_state
# Make sure that mediator task was cleared during the next block processing
# since the channel was removed
mediator_task = chain_state.payment_mapping.secrethashes_to_task.get(
lock_secrethash)
assert not mediator_task
def test_channel_data_removed_after_unlock(chain_state, token_network_state,
our_address, channel_properties):
open_block_number = 10
open_block_hash = factories.make_block_hash()
properties, pkey = channel_properties
address = properties.partner_state.address
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b"test_end_state")
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
from_route = factories.make_route_from_channel(channel_state)
init_target = ActionInitTarget(from_route, mediated_transfer)
node.state_transition(chain_state, init_target)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=factories.make_32bytes(),
partner_onchain_locksroot=EMPTY_MERKLE_ROOT,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
unlock_blocknumber = settle_block_number + 5
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
participant=our_address,
partner=address,
locksroot=lock_secrethash,
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=closed_block_number + 1,
block_hash=factories.make_block_hash(),
)
channel_unlock_iteration = token_network.state_transition(
token_network_state=channel_settled_iteration.new_state,
state_change=channel_batch_unlock_state_change,
block_number=unlock_blocknumber,
block_hash=factories.make_block_hash(),
)
token_network_state_after_unlock = channel_unlock_iteration.new_state
ids_to_channels = token_network_state_after_unlock.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
