def handle_message_refundtransfer(raiden: RaidenService, message: RefundTransfer):
token_network_address = message.token_network_address
from_transfer = lockedtransfersigned_from_message(message)
chain_state = views.state_from_raiden(raiden)
routes = get_best_routes(
chain_state,
token_network_address,
raiden.address,
from_transfer.target,
from_transfer.lock.amount,
message.sender,
)
role = views.get_transfer_role(
chain_state,
from_transfer.lock.secrethash,
)
if role == 'initiator':
secret = random_secret()
state_change = ReceiveTransferRefundCancelRoute(
message.sender,
routes,
from_transfer,
secret,
)
else:
state_change = ReceiveTransferRefund(
message.sender,
from_transfer,
routes,
)
raiden.handle_state_change(state_change)
def handle_message_refundtransfer(self, raiden: RaidenService,
message: RefundTransfer):
token_network_address = message.token_network_address
from_transfer = lockedtransfersigned_from_message(message)
chain_state = views.state_from_raiden(raiden)
routes = get_best_routes(
chain_state,
token_network_address,
raiden.address,
from_transfer.target,
from_transfer.lock.amount,
message.sender,
)
role = views.get_transfer_role(
chain_state,
from_transfer.lock.secrethash,
)
if role == 'initiator':
secret = random_secret()
state_change = ReceiveTransferRefundCancelRoute(
routes=routes,
transfer=from_transfer,
secret=secret,
)
else:
state_change = ReceiveTransferRefund(
transfer=from_transfer,
routes=routes,
)
raiden.handle_state_change(state_change)
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 handle_message_refundtransfer(raiden: RaidenService,
message: RefundTransfer) -> None:
token_network_address = message.token_network_address
from_transfer = lockedtransfersigned_from_message(message)
chain_state = views.state_from_raiden(raiden)
# FIXME: Shouldn't request routes here
routes, _ = get_best_routes(
chain_state=chain_state,
token_network_id=TokenNetworkID(token_network_address),
one_to_n_address=raiden.default_one_to_n_address,
from_address=InitiatorAddress(raiden.address),
to_address=from_transfer.target,
amount=PaymentAmount(
from_transfer.lock.amount), # FIXME: mypy; deprecated by #3863
previous_address=message.sender,
config=raiden.config,
privkey=raiden.privkey,
)
role = views.get_transfer_role(
chain_state=chain_state, secrethash=from_transfer.lock.secrethash)
state_change: StateChange
if role == "initiator":
old_secret = views.get_transfer_secret(
chain_state, from_transfer.lock.secrethash)
# We currently don't allow multi routes if the initiator does not
# hold the secret. In such case we remove all other possible routes
# which allow the API call to return with with an error message.
if old_secret == EMPTY_SECRET:
routes = list()
secret = random_secret()
state_change = ReceiveTransferRefundCancelRoute(
routes=routes, transfer=from_transfer, secret=secret)
else:
state_change = ReceiveTransferRefund(transfer=from_transfer,
routes=routes)
raiden.handle_and_track_state_change(state_change)
def handle_message_refundtransfer(raiden: 'RaidenService',
message: RefundTransfer):
registry_address = message.registry_address
from_transfer = lockedtransfersigned_from_message(message)
node_state = views.state_from_raiden(raiden)
routes = get_best_routes(
node_state,
registry_address,
from_transfer.token,
raiden.address,
from_transfer.target,
from_transfer.lock.amount,
message.sender,
)
role = views.get_transfer_role(
node_state,
from_transfer.lock.secrethash,
)
if role == 'initiator':
secret = random_secret()
state_change = ReceiveTransferRefundCancelRoute(
registry_address,
message.sender,
routes,
from_transfer,
secret,
)
else:
state_change = ReceiveTransferRefund(
message.message_identifier,
message.sender,
from_transfer,
)
raiden.handle_state_change(state_change)
def handle_message_refundtransfer(raiden: RaidenService,
message: RefundTransfer):
token_network_address = message.token_network_address
from_transfer = lockedtransfersigned_from_message(message)
chain_state = views.state_from_raiden(raiden)
routes = get_best_routes(
chain_state=chain_state,
token_network_id=TokenNetworkID(token_network_address),
from_address=InitiatorAddress(raiden.address),
to_address=from_transfer.target,
amount=from_transfer.lock.amount,
previous_address=message.sender,
config=raiden.config,
privkey=raiden.privkey,
)
role = views.get_transfer_role(
chain_state,
from_transfer.lock.secrethash,
)
state_change: StateChange
if role == 'initiator':
secret = random_secret()
state_change = ReceiveTransferRefundCancelRoute(
routes=routes,
transfer=from_transfer,
secret=secret,
)
else:
state_change = ReceiveTransferRefund(
transfer=from_transfer,
routes=routes,
)
raiden.handle_and_track_state_change(state_change)
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
