def test_invalid_instantiation_receive_transfer_refund(additional_args):
wrong_type_transfer = factories.create(factories.TransferDescriptionProperties())
secret = factories.UNIT_SECRET
with pytest.raises(ValueError):
ReceiveTransferRefund(transfer=wrong_type_transfer, **additional_args)
with pytest.raises(ValueError):
ActionTransferReroute(transfer=wrong_type_transfer, secret=secret, **additional_args)
def handle_message_refundtransfer(
raiden: "RaidenService", message: RefundTransfer
) -> List[StateChange]:
chain_state = views.state_from_raiden(raiden)
from_transfer = lockedtransfersigned_from_message(message=message)
role = views.get_transfer_role(
chain_state=chain_state, secrethash=from_transfer.lock.secrethash
)
state_changes: List[StateChange] = []
if role == "initiator":
old_secret = views.get_transfer_secret(chain_state, from_transfer.lock.secrethash)
is_secret_known = old_secret is not None and old_secret != ABSENT_SECRET
state_changes.append(
ReceiveTransferCancelRoute(
transfer=from_transfer,
balance_proof=from_transfer.balance_proof,
sender=from_transfer.balance_proof.sender, # pylint: disable=no-member
)
)
# Currently, the only case where we can be initiators and not
# know the secret is if the transfer is part of an atomic swap. In
# the case of an atomic swap, we will not try to re-route the
# transfer. In all other cases we can try to find another route
# (and generate a new secret)
if is_secret_known:
state_changes.append(
ActionTransferReroute(
transfer=from_transfer,
balance_proof=from_transfer.balance_proof, # pylint: disable=no-member
sender=from_transfer.balance_proof.sender, # pylint: disable=no-member
secret=random_secret(),
)
)
else:
state_changes.append(
ReceiveTransferRefund(
transfer=from_transfer,
balance_proof=from_transfer.balance_proof,
sender=from_transfer.balance_proof.sender, # pylint: disable=no-member
)
)
return state_changes
def test_get_state_change_with_balance_proof():
""" All state changes which contain a balance proof must be found when
querying the database.
"""
serializer = JSONSerializer()
storage = SerializedSQLiteStorage(":memory:", serializer)
counter = itertools.count()
balance_proof = make_signed_balance_proof_from_counter(counter)
lock_expired = ReceiveLockExpired(
sender=balance_proof.sender,
balance_proof=balance_proof,
secrethash=factories.make_secret_hash(next(counter)),
message_identifier=MessageID(next(counter)),
)
received_balance_proof = make_signed_balance_proof_from_counter(counter)
unlock = ReceiveUnlock(
sender=received_balance_proof.sender,
message_identifier=MessageID(next(counter)),
secret=factories.make_secret(next(counter)),
balance_proof=received_balance_proof,
)
transfer = make_signed_transfer_from_counter(counter)
transfer_refund = ReceiveTransferRefund(
transfer=transfer,
balance_proof=transfer.balance_proof,
sender=transfer.balance_proof.sender, # pylint: disable=no-member
)
transfer = make_signed_transfer_from_counter(counter)
transfer_reroute = ActionTransferReroute(
transfer=transfer,
balance_proof=transfer.balance_proof,
sender=transfer.balance_proof.sender, # pylint: disable=no-member
secret=sha3(factories.make_secret(next(counter))),
)
mediator_from_route, mediator_signed_transfer = make_from_route_from_counter(
counter)
action_init_mediator = ActionInitMediator(
route_states=[
RouteState(
route=[factories.make_address(),
factories.make_address()],
forward_channel_id=factories.make_channel_identifier(),
)
],
from_hop=mediator_from_route,
from_transfer=mediator_signed_transfer,
balance_proof=mediator_signed_transfer.balance_proof,
sender=mediator_signed_transfer.balance_proof.sender, # pylint: disable=no-member
)
target_from_route, target_signed_transfer = make_from_route_from_counter(
counter)
action_init_target = ActionInitTarget(
from_hop=target_from_route,
transfer=target_signed_transfer,
balance_proof=target_signed_transfer.balance_proof,
sender=target_signed_transfer.balance_proof.sender, # pylint: disable=no-member
)
statechanges_balanceproofs = [
(lock_expired, lock_expired.balance_proof),
(unlock, unlock.balance_proof),
(transfer_refund, transfer_refund.transfer.balance_proof),
(transfer_reroute, transfer_reroute.transfer.balance_proof),
(action_init_mediator,
action_init_mediator.from_transfer.balance_proof),
(action_init_target, action_init_target.transfer.balance_proof),
]
assert storage.count_state_changes() == 0
state_change_ids = storage.write_state_changes(
[state_change for state_change, _ in statechanges_balanceproofs])
assert storage.count_state_changes() == len(statechanges_balanceproofs)
msg_in_order = "Querying must return state changes in order"
stored_statechanges_records = storage.get_statechanges_records_by_range(
RANGE_ALL_STATE_CHANGES)
assert len(stored_statechanges_records) == 6, msg_in_order
pair_elements = zip(statechanges_balanceproofs, state_change_ids,
stored_statechanges_records)
for statechange_balanceproof, statechange_id, record in pair_elements:
assert record.data == statechange_balanceproof[0], msg_in_order
assert record.state_change_identifier == statechange_id, msg_in_order
# Make sure state changes are returned in the correct order in which they were stored
stored_statechanges = storage.get_statechanges_by_range(
Range(
stored_statechanges_records[1].state_change_identifier,
stored_statechanges_records[2].state_change_identifier,
))
assert len(stored_statechanges) == 2
assert isinstance(stored_statechanges[0], ReceiveUnlock)
assert isinstance(stored_statechanges[1], ReceiveTransferRefund)
for state_change, balance_proof in statechanges_balanceproofs:
state_change_record = get_state_change_with_balance_proof_by_balance_hash(
storage=storage,
canonical_identifier=balance_proof.canonical_identifier,
sender=balance_proof.sender,
balance_hash=balance_proof.balance_hash,
)
assert state_change_record
assert state_change_record.data == state_change
state_change_record = get_state_change_with_balance_proof_by_locksroot(
storage=storage,
canonical_identifier=balance_proof.canonical_identifier,
sender=balance_proof.sender,
locksroot=balance_proof.locksroot,
)
assert state_change_record
assert state_change_record.data == state_change
storage.close()
def test_initiator_skips_used_routes():
defaults = factories.NettingChannelStateProperties(
our_state=factories.NettingChannelEndStateProperties.OUR_STATE,
partner_state=factories.NettingChannelEndStateProperties(balance=10),
open_transaction=factories.TransactionExecutionStatusProperties(
started_block_number=1, finished_block_number=2, result="success"),
)
properties = [
factories.NettingChannelStateProperties(
partner_state=factories.NettingChannelEndStateProperties(
privatekey=factories.HOP1_KEY, address=factories.HOP1))
]
test_chain_state = factories.make_chain_state(number_of_channels=1,
properties=properties,
defaults=defaults)
channels = test_chain_state.channel_set
bob = channels.channels[0].partner_state.address
routes = [[
factories.UNIT_OUR_ADDRESS, bob, factories.UNIT_TRANSFER_TARGET
]]
transfer = factories.create(
factories.TransferDescriptionProperties(
initiator=factories.UNIT_OUR_ADDRESS,
target=factories.UNIT_TRANSFER_TARGET))
init_action = factories.initiator_make_init_action(
channels=channels,
routes=routes,
transfer=transfer,
estimated_fee=FeeAmount(0))
transition_result = handle_action_init_initiator(
chain_state=test_chain_state.chain_state, state_change=init_action)
chain_state = transition_result.new_state
assert transfer.secrethash in chain_state.payment_mapping.secrethashes_to_task
initiator_task = chain_state.payment_mapping.secrethashes_to_task[
transfer.secrethash]
initiator_state = initiator_task.manager_state
assert len(initiator_state.routes) == 1, "Should have one route"
assert len(
initiator_state.routes[0].route) == 3, "Route should not be pruned"
assert initiator_state.routes[0].route == routes[
0], "Should have test route"
events = transition_result.events
assert isinstance(events[-1], SendLockedTransfer)
locked_transfer = initiator_state.initiator_transfers[
transfer.secrethash].transfer
received_transfer = factories.create(
factories.LockedTransferSignedStateProperties(
expiration=locked_transfer.lock.expiration,
payment_identifier=locked_transfer.payment_identifier,
canonical_identifier=locked_transfer.balance_proof.
canonical_identifier,
initiator=factories.UNIT_OUR_ADDRESS,
sender=bob,
pkey=factories.HOP1_KEY,
message_identifier=factories.make_message_identifier(),
routes=[],
secret=transfer.secret,
))
role = views.get_transfer_role(chain_state=chain_state,
secrethash=locked_transfer.lock.secrethash)
assert role == "initiator", "Should keep initiator role"
failed_route_state_change = ReceiveTransferCancelRoute(
transfer=received_transfer,
balance_proof=received_transfer.balance_proof,
sender=received_transfer.balance_proof.sender, # pylint: disable=no-member
)
state_transition(chain_state=chain_state,
state_change=failed_route_state_change)
reroute_state_change = ActionTransferReroute(
transfer=received_transfer,
balance_proof=received_transfer.balance_proof,
sender=received_transfer.balance_proof.sender, # pylint: disable=no-member
secret=factories.make_secret(),
)
iteration = state_transition(chain_state=chain_state,
state_change=reroute_state_change)
assert search_for_item(iteration.events, SendLockedTransfer, {}) is None