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 test_refund_transfer_no_more_routes():
amount = UNIT_TRANSFER_AMOUNT
block_number = 1
refund_pkey, refund_address = factories.make_privkey_address()
channel1 = factories.make_channel(
our_balance=amount,
partner_balance=amount,
our_address=UNIT_TRANSFER_INITIATOR,
partner_address=refund_address,
token_address=UNIT_TOKEN_ADDRESS,
)
channelmap = {channel1.identifier: channel1}
available_routes = [factories.route_from_channel(channel1)]
current_state = make_initiator_state(
available_routes,
factories.UNIT_TRANSFER_DESCRIPTION,
channelmap,
block_number,
)
original_transfer = current_state.initiator.transfer
channel_identifier = current_state.initiator.channel_identifier
channel_state = channelmap[channel_identifier]
expiration = original_transfer.lock.expiration - channel_state.reveal_timeout - TRANSIT_BLOCKS
refund_transfer = factories.make_signed_transfer(
amount,
original_transfer.initiator,
original_transfer.target,
expiration,
UNIT_SECRET,
identifier=original_transfer.identifier,
channel_identifier=channel1.identifier,
pkey=refund_pkey,
sender=refund_address,
)
state_change = ReceiveTransferRefundCancelRoute(
sender=channel_state.partner_state.address,
routes=available_routes,
transfer=refund_transfer,
secret=random_secret(),
)
iteration = initiator_manager.state_transition(
current_state,
state_change,
channelmap,
block_number,
)
assert iteration.new_state is None
assert len(iteration.events) == 2
unlocked_failed = next(e for e in iteration.events if isinstance(e, EventUnlockFailed))
sent_failed = next(e for e in iteration.events if isinstance(e, EventTransferSentFailed))
assert unlocked_failed
assert sent_failed
def test_refund_transfer_invalid_sender():
amount = UNIT_TRANSFER_AMOUNT
block_number = 1
pseudo_random_generator = random.Random()
channel1 = factories.make_channel(
our_balance=amount,
our_address=UNIT_TRANSFER_INITIATOR,
token_address=UNIT_TOKEN_ADDRESS,
token_network_identifier=UNIT_TOKEN_NETWORK_ADDRESS,
)
channelmap = {channel1.identifier: channel1}
available_routes = [factories.route_from_channel(channel1)]
current_state = make_initiator_state(
available_routes,
factories.UNIT_TRANSFER_DESCRIPTION,
channelmap,
pseudo_random_generator,
block_number,
)
original_transfer = current_state.initiator.transfer
channel_identifier = current_state.initiator.channel_identifier
channel_state = channelmap[channel_identifier]
expiration = original_transfer.lock.expiration - channel_state.reveal_timeout - TRANSIT_BLOCKS
refund_transfer = factories.make_signed_transfer(
amount,
original_transfer.initiator,
original_transfer.target,
expiration,
UNIT_SECRET,
)
wrong_sender_address = factories.HOP3
state_change = ReceiveTransferRefundCancelRoute(
sender=wrong_sender_address,
routes=available_routes,
transfer=refund_transfer,
secret=random_secret(),
)
before_state = deepcopy(current_state)
iteration = initiator_manager.state_transition(
current_state,
state_change,
channelmap,
pseudo_random_generator,
block_number,
)
assert iteration.new_state is not None
assert not iteration.events
assert iteration.new_state == before_state
def test_refund_transfer_no_more_routes():
amount = UNIT_TRANSFER_AMOUNT
refund_pkey, refund_address = factories.make_privkey_address()
setup = setup_initiator_tests(
amount=amount,
partner_balance=amount,
our_address=UNIT_TRANSFER_INITIATOR,
partner_address=refund_address,
)
original_transfer = setup.current_state.initiator.transfer
refund_transfer = factories.make_signed_transfer(
amount,
original_transfer.initiator,
original_transfer.target,
original_transfer.lock.expiration,
UNIT_SECRET,
payment_identifier=original_transfer.payment_identifier,
channel_identifier=setup.channel.identifier,
pkey=refund_pkey,
sender=refund_address,
)
state_change = ReceiveTransferRefundCancelRoute(
routes=setup.available_routes,
transfer=refund_transfer,
secret=random_secret(),
)
iteration = initiator_manager.state_transition(
setup.current_state,
state_change,
setup.channel_map,
setup.prng,
setup.block_number,
)
assert iteration.new_state is None
unlocked_failed = next(e for e in iteration.events if isinstance(e, EventUnlockFailed))
sent_failed = next(e for e in iteration.events if isinstance(e, EventPaymentSentFailed))
assert unlocked_failed
assert sent_failed
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_get_state_change_with_balance_proof():
""" All state changes which contain a balance proof must be found by when
querying the database.
"""
serializer = JSONSerializer
storage = SQLiteStorage(':memory:', serializer)
counter = itertools.count()
lock_expired = ReceiveLockExpired(
balance_proof=make_signed_balance_proof_from_counter(counter),
secrethash=sha3(factories.make_secret(next(counter))),
message_identifier=next(counter),
)
unlock = ReceiveUnlock(
message_identifier=next(counter),
secret=sha3(factories.make_secret(next(counter))),
balance_proof=make_signed_balance_proof_from_counter(counter),
)
transfer_refund = ReceiveTransferRefund(
transfer=make_signed_transfer_from_counter(counter),
routes=list(),
)
transfer_refund_cancel_route = ReceiveTransferRefundCancelRoute(
routes=list(),
transfer=make_signed_transfer_from_counter(counter),
secret=sha3(factories.make_secret(next(counter))),
)
mediator_from_route, mediator_signed_transfer = make_from_route_from_counter(
counter)
action_init_mediator = ActionInitMediator(
routes=list(),
from_route=mediator_from_route,
from_transfer=mediator_signed_transfer,
)
target_from_route, target_signed_transfer = make_from_route_from_counter(
counter)
action_init_target = ActionInitTarget(
route=target_from_route,
transfer=target_signed_transfer,
)
statechanges_balanceproofs = [
(lock_expired, lock_expired.balance_proof),
(unlock, unlock.balance_proof),
(transfer_refund, transfer_refund.transfer.balance_proof),
(transfer_refund_cancel_route,
transfer_refund_cancel_route.transfer.balance_proof),
(action_init_mediator,
action_init_mediator.from_transfer.balance_proof),
(action_init_target, action_init_target.transfer.balance_proof),
]
timestamp = datetime.utcnow().isoformat(timespec='milliseconds')
for state_change, _ in statechanges_balanceproofs:
storage.write_state_change(state_change, timestamp)
for state_change, balance_proof in statechanges_balanceproofs:
state_change_record = get_state_change_with_balance_proof(
storage=storage,
chain_id=balance_proof.chain_id,
token_network_identifier=balance_proof.token_network_identifier,
channel_identifier=balance_proof.channel_identifier,
sender=balance_proof.sender,
balance_hash=balance_proof.balance_hash,
)
assert state_change_record.data == state_change
def test_refund_transfer_next_route():
amount = UNIT_TRANSFER_AMOUNT
our_address = factories.ADDR
refund_pkey, refund_address = factories.make_privkey_address()
pseudo_random_generator = random.Random()
channel1 = factories.make_channel(
our_balance=amount,
partner_balance=amount,
our_address=our_address,
partner_address=refund_address,
token_address=UNIT_TOKEN_ADDRESS,
token_network_identifier=UNIT_TOKEN_NETWORK_ADDRESS,
)
channel2 = factories.make_channel(
our_balance=0,
our_address=our_address,
token_address=UNIT_TOKEN_ADDRESS,
token_network_identifier=UNIT_TOKEN_NETWORK_ADDRESS,
)
channel3 = factories.make_channel(
our_balance=amount,
our_address=our_address,
token_address=UNIT_TOKEN_ADDRESS,
token_network_identifier=UNIT_TOKEN_NETWORK_ADDRESS,
)
channelmap = {
channel1.identifier: channel1,
channel2.identifier: channel2,
channel3.identifier: channel3,
}
available_routes = [
factories.route_from_channel(channel1),
factories.route_from_channel(channel2),
factories.route_from_channel(channel3),
]
block_number = 10
current_state = make_initiator_state(
available_routes,
factories.UNIT_TRANSFER_DESCRIPTION,
channelmap,
pseudo_random_generator,
block_number,
)
original_transfer = current_state.initiator.transfer
channel_identifier = current_state.initiator.channel_identifier
channel_state = channelmap[channel_identifier]
expiration = original_transfer.lock.expiration - channel_state.reveal_timeout - TRANSIT_BLOCKS
refund_transfer = factories.make_signed_transfer(
amount,
our_address,
original_transfer.target,
expiration,
UNIT_SECRET,
payment_identifier=original_transfer.payment_identifier,
channel_identifier=channel1.identifier,
pkey=refund_pkey,
sender=refund_address,
)
assert channel_state.partner_state.address == refund_address
state_change = ReceiveTransferRefundCancelRoute(
sender=refund_address,
routes=available_routes,
transfer=refund_transfer,
secret=random_secret(),
)
iteration = initiator_manager.state_transition(
current_state,
state_change,
channelmap,
pseudo_random_generator,
block_number,
)
assert iteration.new_state is not None
route_cancelled = next(e for e in iteration.events
if isinstance(e, EventUnlockFailed))
new_transfer = next(e for e in iteration.events
if isinstance(e, SendLockedTransfer))
assert route_cancelled, 'The previous transfer must be cancelled'
assert new_transfer, 'No mediated transfer event emitted, should have tried a new route'
msg = 'the new transfer must use a new secret / secrethash'
assert new_transfer.transfer.lock.secrethash != refund_transfer.lock.secrethash, msg
assert iteration.new_state.initiator is not None
def test_refund_transfer_no_more_routes():
amount = UNIT_TRANSFER_AMOUNT
refund_pkey, refund_address = factories.make_privkey_address()
setup = setup_initiator_tests(
amount=amount,
partner_balance=amount,
our_address=UNIT_TRANSFER_INITIATOR,
partner_address=refund_address,
)
original_transfer = setup.current_state.initiator.transfer
refund_transfer = factories.make_signed_transfer(
amount,
original_transfer.initiator,
original_transfer.target,
original_transfer.lock.expiration,
UNIT_SECRET,
payment_identifier=original_transfer.payment_identifier,
channel_identifier=setup.channel.identifier,
pkey=refund_pkey,
sender=refund_address,
)
state_change = ReceiveTransferRefundCancelRoute(
routes=setup.available_routes,
transfer=refund_transfer,
secret=random_secret(),
)
iteration = initiator_manager.state_transition(
setup.current_state,
state_change,
setup.channel_map,
setup.prng,
setup.block_number,
)
current_state = iteration.new_state
# As per the description of the issue here:
# https://github.com/raiden-network/raiden/issues/3146#issuecomment-447378046
# We can fail the payment but can't delete the payment task if there are no
# more routes, but we have to wait for the lock expiration
assert iteration.new_state is not None
unlocked_failed = next(e for e in iteration.events
if isinstance(e, EventUnlockFailed))
sent_failed = next(e for e in iteration.events
if isinstance(e, EventPaymentSentFailed))
assert unlocked_failed
assert sent_failed
invalid_balance_proof = factories.make_signed_balance_proof(
nonce=2,
transferred_amount=original_transfer.balance_proof.transferred_amount,
locked_amount=0,
token_network_address=original_transfer.balance_proof.
token_network_identifier,
channel_identifier=setup.channel.identifier,
locksroot=EMPTY_MERKLE_ROOT,
extra_hash=original_transfer.lock.secrethash,
sender_address=refund_address,
)
balance_proof = factories.make_signed_balance_proof(
nonce=2,
transferred_amount=original_transfer.balance_proof.transferred_amount,
locked_amount=0,
token_network_address=original_transfer.balance_proof.
token_network_identifier,
channel_identifier=setup.channel.identifier,
locksroot=EMPTY_MERKLE_ROOT,
extra_hash=original_transfer.lock.secrethash,
sender_address=refund_address,
private_key=refund_pkey,
)
invalid_lock_expired_state_change = ReceiveLockExpired(
invalid_balance_proof,
secrethash=original_transfer.lock.secrethash,
message_identifier=5,
)
lock_expired_state_change = ReceiveLockExpired(
balance_proof,
secrethash=original_transfer.lock.secrethash,
message_identifier=5,
)
before_expiry_block = original_transfer.lock.expiration - 1
expiry_block = original_transfer.lock.expiration + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS * 2
# a block before lock expiration, no events should be emitted
current_state = iteration.new_state
state_change = Block(
block_number=before_expiry_block,
gas_limit=1,
block_hash=factories.make_transaction_hash(),
)
iteration = initiator_manager.state_transition(
current_state,
state_change,
setup.channel_map,
setup.prng,
expiry_block,
)
assert not iteration.events
assert iteration.new_state, 'payment task should not be deleted at this block'
# process an invalid lock expired message before lock expiration
current_state = iteration.new_state
iteration = initiator_manager.state_transition(
current_state,
invalid_lock_expired_state_change,
setup.channel_map,
setup.prng,
before_expiry_block,
)
assert iteration.new_state, 'payment task should not be deleted at this lock expired'
# should not be accepted
assert not events.must_contain_entry(iteration.events, SendProcessed, {})
assert events.must_contain_entry(iteration.events,
EventInvalidReceivedLockExpired, {})
# process a valid lock expired message before lock expiration
current_state = iteration.new_state
iteration = initiator_manager.state_transition(
current_state,
lock_expired_state_change,
setup.channel_map,
setup.prng,
before_expiry_block,
)
assert iteration.new_state, 'payment task should not be deleted at this lock expired'
# should not be accepted
assert not events.must_contain_entry(iteration.events, SendProcessed, {})
# now we get to the lock expiration block
current_state = iteration.new_state
state_change = Block(
block_number=expiry_block,
gas_limit=1,
block_hash=factories.make_transaction_hash(),
)
iteration = initiator_manager.state_transition(
current_state,
state_change,
setup.channel_map,
setup.prng,
expiry_block,
)
assert events.must_contain_entry(iteration.events, SendLockExpired, {})
# Since there was a refund transfer the payment task must not have been deleted
assert iteration.new_state is not None
# process the lock expired message after lock expiration
current_state = iteration.new_state
iteration = initiator_manager.state_transition(
current_state,
lock_expired_state_change,
setup.channel_map,
setup.prng,
expiry_block,
)
# should be accepted
assert events.must_contain_entry(iteration.events, SendProcessed, {})
assert iteration.new_state, 'payment task should be there waiting for next block'
# process the the block after lock expiration
current_state = iteration.new_state
state_change = Block(
block_number=expiry_block + 1,
gas_limit=1,
block_hash=factories.make_transaction_hash(),
)
iteration = initiator_manager.state_transition(
current_state,
state_change,
setup.channel_map,
setup.prng,
expiry_block + 1,
)
assert iteration.new_state is None, 'from this point on the payment task should go'
def test_get_state_change_with_balance_proof():
""" All state changes which contain a balance proof must be found by when
querying the database.
"""
serializer = JSONSerializer
storage = SerializedSQLiteStorage(":memory:", serializer)
counter = itertools.count()
lock_expired = ReceiveLockExpired(
balance_proof=make_signed_balance_proof_from_counter(counter),
secrethash=sha3(factories.make_secret(next(counter))),
message_identifier=next(counter),
)
unlock = ReceiveUnlock(
message_identifier=next(counter),
secret=sha3(factories.make_secret(next(counter))),
balance_proof=make_signed_balance_proof_from_counter(counter),
)
transfer_refund = ReceiveTransferRefund(
transfer=make_signed_transfer_from_counter(counter), routes=list())
transfer_refund_cancel_route = ReceiveTransferRefundCancelRoute(
routes=list(),
transfer=make_signed_transfer_from_counter(counter),
secret=sha3(factories.make_secret(next(counter))),
)
mediator_from_route, mediator_signed_transfer = make_from_route_from_counter(
counter)
action_init_mediator = ActionInitMediator(
routes=list(),
from_route=mediator_from_route,
from_transfer=mediator_signed_transfer)
target_from_route, target_signed_transfer = make_from_route_from_counter(
counter)
action_init_target = ActionInitTarget(route=target_from_route,
transfer=target_signed_transfer)
statechanges_balanceproofs = [
(lock_expired, lock_expired.balance_proof),
(unlock, unlock.balance_proof),
(transfer_refund, transfer_refund.transfer.balance_proof),
(transfer_refund_cancel_route,
transfer_refund_cancel_route.transfer.balance_proof),
(action_init_mediator,
action_init_mediator.from_transfer.balance_proof),
(action_init_target, action_init_target.transfer.balance_proof),
]
timestamp = datetime.utcnow().isoformat(timespec="milliseconds")
for state_change, _ in statechanges_balanceproofs:
storage.write_state_change(state_change, timestamp)
# Make sure state changes are returned in the correct order in which they were stored
stored_statechanges = storage.get_statechanges_by_identifier(1, "latest")
assert isinstance(stored_statechanges[0], ReceiveLockExpired)
assert isinstance(stored_statechanges[1], ReceiveUnlock)
assert isinstance(stored_statechanges[2], ReceiveTransferRefund)
assert isinstance(stored_statechanges[3], ReceiveTransferRefundCancelRoute)
assert isinstance(stored_statechanges[4], ActionInitMediator)
assert isinstance(stored_statechanges[5], ActionInitTarget)
# Make sure state changes are returned in the correct order in which they were stored
stored_statechanges = storage.get_statechanges_by_identifier(1, 2)
assert isinstance(stored_statechanges[0], ReceiveLockExpired)
assert isinstance(stored_statechanges[1], ReceiveUnlock)
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.data == state_change
