def handle_block(target_state, channel_state, block_number):
""" After Raiden learns about a new block this function must be called to
handle expiration of the hash time lock.
"""
transfer = target_state.transfer
secret_known = channel.is_secret_known(
channel_state.partner_state,
transfer.lock.secrethash,
)
if not secret_known and block_number > transfer.lock.expiration:
# XXX: emit the event only once
failed = EventUnlockClaimFailed(
identifier=transfer.payment_identifier,
secrethash=transfer.lock.secrethash,
reason='lock expired',
)
target_state.state = 'expired'
events = [failed]
elif target_state.state != 'waiting_close': # only emit the close event once
events = events_for_close(target_state, channel_state, block_number)
else:
events = list()
iteration = TransitionResult(target_state, events)
return iteration
def handle_lock_expired(
target_state: TargetTransferState,
state_change: ReceiveLockExpired,
channel_state: NettingChannelState,
block_number: typing.BlockNumber,
):
"""Remove expired locks from channel states."""
result = channel.handle_receive_lock_expired(
channel_state=channel_state,
state_change=state_change,
block_number=block_number,
)
if not channel.get_lock(result.new_state.partner_state,
target_state.transfer.lock.secrethash):
transfer = target_state.transfer
unlock_failed = EventUnlockClaimFailed(
identifier=transfer.payment_identifier,
secrethash=transfer.lock.secrethash,
reason='Lock expired',
)
result.events.append(unlock_failed)
return TransitionResult(None, result.events)
return TransitionResult(target_state, result.events)
def handle_block(
target_state: TargetTransferState,
channel_state: NettingChannelState,
block_number: typing.BlockNumber,
pseudo_random_generator: random.Random,
):
""" After Raiden learns about a new block this function must be called to
handle expiration of the hash time lock.
"""
transfer = target_state.transfer
secret_known = channel.is_secret_known(
channel_state.partner_state,
transfer.lock.secrethash,
)
if not secret_known and block_number > transfer.lock.expiration:
if target_state.state != 'expired':
failed = EventUnlockClaimFailed(
identifier=transfer.payment_identifier,
secrethash=transfer.lock.secrethash,
reason='lock expired',
)
target_state.state = 'expired'
events = [failed]
else:
events = list()
elif target_state.state != 'waiting_close': # only emit the close event once
events = events_for_onchain_secretreveal(target_state, channel_state,
block_number)
else:
events = list()
iteration = TransitionResult(target_state, events)
return iteration
def handle_block(
target_state: TargetTransferState,
channel_state: NettingChannelState,
block_number: typing.BlockNumber,
):
""" After Raiden learns about a new block this function must be called to
handle expiration of the hash time lock.
"""
transfer = target_state.transfer
events = list()
secret_known = channel.is_secret_known(
channel_state.partner_state,
transfer.lock.secrethash,
)
is_lock_expired = (not secret_known
and block_number > transfer.lock.expiration)
if secret_known:
events = events_for_onchain_secretreveal(
target_state,
channel_state,
block_number,
)
elif is_lock_expired and target_state.state != 'expired':
failed = EventUnlockClaimFailed(
identifier=transfer.payment_identifier,
secrethash=transfer.lock.secrethash,
reason='lock expired',
)
target_state.state = 'expired'
events = [failed]
return TransitionResult(target_state, events)
def handle_inittarget(
state_change,
channel_state,
pseudo_random_generator,
block_number,
):
""" Handles an ActionInitTarget state change. """
transfer = state_change.transfer
route = state_change.route
target_state = TargetTransferState(
route,
transfer,
)
assert channel_state.identifier == transfer.balance_proof.channel_address
is_valid, _, errormsg = channel.handle_receive_lockedtransfer(
channel_state,
transfer,
)
safe_to_wait = is_safe_to_wait(
transfer.lock.expiration,
channel_state.reveal_timeout,
block_number,
)
# if there is not enough time to safely unlock the token on-chain
# silently let the transfer expire.
if is_valid and safe_to_wait:
message_identifier = message_identifier_from_prng(
pseudo_random_generator)
recipient = transfer.initiator
queue_name = b'global'
secret_request = SendSecretRequest(
recipient,
queue_name,
message_identifier,
transfer.payment_identifier,
transfer.lock.amount,
transfer.lock.secrethash,
)
iteration = TransitionResult(target_state, [secret_request])
else:
if not is_valid:
failure_reason = errormsg
elif not safe_to_wait:
failure_reason = 'lock expiration is not safe'
unlock_failed = EventUnlockClaimFailed(
identifier=transfer.payment_identifier,
secrethash=transfer.lock.secrethash,
reason=failure_reason,
)
iteration = TransitionResult(target_state, [unlock_failed])
return iteration
def set_expired_pairs(transfers_pair, block_number):
""" Set the state transfers to the expired state and return the failed events."""
pending_transfers_pairs = get_pending_transfer_pairs(transfers_pair)
events = list()
for pair in pending_transfers_pairs:
has_payee_transfer_expired = (
block_number > pair.payee_transfer.lock.expiration and
pair.payee_state != 'payee_expired'
)
has_payer_transfer_expired = (
block_number > pair.payer_transfer.lock.expiration and
pair.payer_state != 'payer_expired'
)
if has_payer_transfer_expired:
# For safety, the correct behavior is:
#
# - If the payee has been paid, then the payer must pay too.
#
# And the corollary:
#
# - If the payer transfer has expired, then the payee transfer must
# have expired too.
#
# The problem is that this corollary cannot be asserted. If a user
# is running Raiden without a monitoring service, then it may go
# offline after having paid a transfer to a payee, but without
# getting a balance proof of the payer, and once it comes back
# online the transfer may have expired.
#
# assert pair.payee_state == 'payee_expired'
pair.payer_state = 'payer_expired'
unlock_failed = EventUnlockClaimFailed(
pair.payer_transfer.payment_identifier,
pair.payer_transfer.lock.secrethash,
'lock expired',
)
events.append(unlock_failed)
elif has_payee_transfer_expired:
pair.payee_state = 'payee_expired'
unlock_failed = EventUnlockFailed(
pair.payee_transfer.payment_identifier,
pair.payee_transfer.lock.secrethash,
'lock expired',
)
events.append(unlock_failed)
return events
def handle_lock_expired(
payment_state: InitiatorPaymentState,
state_change: ReceiveLockExpired,
channelidentifiers_to_channels: ChannelMap,
pseudo_random_generator: random.Random,
block_number: BlockNumber,
) -> TransitionResult[InitiatorPaymentState]:
"""Initiator also needs to handle LockExpired messages when refund transfers are involved.
A -> B -> C
- A sends locked transfer to B
- B attempted to forward to C but has not enough capacity
- B sends a refund transfer with the same secrethash back to A
- When the lock expires B will also send a LockExpired message to A
- A needs to be able to properly process it
Related issue: https://github.com/raiden-network/raiden/issues/3183
"""
initiator_state = payment_state.initiator_transfers.get(
state_change.secrethash)
if not initiator_state:
return TransitionResult(payment_state, list())
channel_identifier = initiator_state.channel_identifier
channel_state = channelidentifiers_to_channels.get(channel_identifier)
if not channel_state:
return TransitionResult(payment_state, list())
secrethash = initiator_state.transfer.lock.secrethash
result = channel.handle_receive_lock_expired(
channel_state=channel_state,
state_change=state_change,
block_number=block_number,
)
if not channel.get_lock(result.new_state.partner_state, secrethash):
transfer = initiator_state.transfer
unlock_failed = EventUnlockClaimFailed(
identifier=transfer.payment_identifier,
secrethash=transfer.lock.secrethash,
reason='Lock expired',
)
result.events.append(unlock_failed)
return TransitionResult(payment_state, result.events)
def handle_block(
target_state: TargetTransferState,
channel_state: NettingChannelState,
block_number: BlockNumber,
block_hash: BlockHash,
) -> TransitionResult[TargetTransferState]:
""" After Raiden learns about a new block this function must be called to
handle expiration of the hash time lock.
"""
transfer = target_state.transfer
events = list()
lock = transfer.lock
secret_known = channel.is_secret_known(
channel_state.partner_state,
lock.secrethash,
)
lock_has_expired, _ = channel.is_lock_expired(
end_state=channel_state.our_state,
lock=lock,
block_number=block_number,
lock_expiration_threshold=channel.get_receiver_expiration_threshold(
lock),
)
if lock_has_expired and target_state.state != 'expired':
failed = EventUnlockClaimFailed(
identifier=transfer.payment_identifier,
secrethash=transfer.lock.secrethash,
reason=f'lock expired',
)
target_state.state = TargetTransferState.EXPIRED
events = [failed]
elif secret_known:
events = events_for_onchain_secretreveal(
target_state=target_state,
channel_state=channel_state,
block_number=block_number,
block_hash=block_hash,
)
return TransitionResult(target_state, events)
def handle_block(
target_state: TargetTransferState,
channel_state: NettingChannelState,
block_number: typing.BlockNumber,
):
""" After Raiden learns about a new block this function must be called to
handle expiration of the hash time lock.
"""
transfer = target_state.transfer
events = list()
lock = transfer.lock
secret_known = channel.is_secret_known(
channel_state.partner_state,
lock.secrethash,
)
lock_has_expired, _ = channel.is_lock_expired(
end_state=channel_state.our_state,
lock=lock,
block_number=block_number,
lock_expiration_threshold=typing.BlockNumber(
lock.expiration + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS, ),
)
if lock_has_expired and target_state.state != 'expired':
failed = EventUnlockClaimFailed(
identifier=transfer.payment_identifier,
secrethash=transfer.lock.secrethash,
reason=f'lock expired',
)
target_state.state = 'expired'
events = [failed]
elif secret_known:
events = events_for_onchain_secretreveal(
target_state,
channel_state,
block_number,
)
return TransitionResult(target_state, events)
def handle_lock_expired(
target_state: TargetTransferState,
state_change: ReceiveLockExpired,
channel_state: NettingChannelState,
block_number: BlockNumber,
) -> TransitionResult[Optional[TargetTransferState]]:
"""Remove expired locks from channel states."""
result = channel.handle_receive_lock_expired(
channel_state=channel_state, state_change=state_change, block_number=block_number
)
assert result.new_state, "handle_receive_lock_expired should not delete the task"
if not channel.get_lock(result.new_state.partner_state, target_state.transfer.lock.secrethash):
transfer = target_state.transfer
unlock_failed = EventUnlockClaimFailed(
identifier=transfer.payment_identifier,
secrethash=transfer.lock.secrethash,
reason="Lock expired",
)
result.events.append(unlock_failed)
return TransitionResult(None, result.events)
return TransitionResult(target_state, result.events)
def handle_inittarget(
state_change: ActionInitTarget,
channel_state: NettingChannelState,
pseudo_random_generator: random.Random,
block_number: typing.BlockNumber,
):
""" Handles an ActionInitTarget state change. """
transfer = state_change.transfer
route = state_change.route
assert channel_state.identifier == transfer.balance_proof.channel_identifier
is_valid, channel_events, errormsg = channel.handle_receive_lockedtransfer(
channel_state,
transfer,
)
if is_valid:
# A valid balance proof does not mean the payment itself is still valid.
# e.g. the lock may be near expiration or have expired. This is fine. The
# message with an unusable lock must be handled to properly synchronize the
# local view of the partner's channel state, allowing the next balance
# proofs to be handled. This however, must only be done once, which is
# enforced by the nonce increasing sequentially, which is verified by
# the handler handle_receive_lockedtransfer.
target_state = TargetTransferState(route, transfer)
safe_to_wait, _ = is_safe_to_wait(
transfer.lock.expiration,
channel_state.reveal_timeout,
block_number,
)
# If there is not enough time to safely unlock the lock on-chain
# silently let the transfer expire. The target task must be created to
# handle the ReceiveLockExpired state change, which will clear the
# expired lock.
if safe_to_wait:
message_identifier = message_identifier_from_prng(
pseudo_random_generator)
recipient = transfer.initiator
secret_request = SendSecretRequest(
recipient=typing.Address(recipient),
channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE,
message_identifier=message_identifier,
payment_identifier=transfer.payment_identifier,
amount=transfer.lock.amount,
expiration=transfer.lock.expiration,
secrethash=transfer.lock.secrethash,
)
channel_events.append(secret_request)
iteration = TransitionResult(target_state, channel_events)
else:
# If the balance proof is not valid, do *not* create a task. Otherwise it's
# possible for an attacker to send multiple invalid transfers, and increase
# the memory usage of this Node.
unlock_failed = EventUnlockClaimFailed(
identifier=transfer.payment_identifier,
secrethash=transfer.lock.secrethash,
reason=errormsg,
)
channel_events.append(unlock_failed)
iteration = TransitionResult(None, channel_events)
return iteration
def handle_inittarget(
state_change: ActionInitTarget,
channel_state: NettingChannelState,
pseudo_random_generator: random.Random,
block_number: typing.BlockNumber,
):
""" Handles an ActionInitTarget state change. """
transfer = state_change.transfer
route = state_change.route
target_state = TargetTransferState(
route,
transfer,
)
assert channel_state.identifier == transfer.balance_proof.channel_identifier
is_valid, channel_events, errormsg = channel.handle_receive_lockedtransfer(
channel_state,
transfer,
)
safe_to_wait, unsafe_msg = is_safe_to_wait(
transfer.lock.expiration,
channel_state.reveal_timeout,
block_number,
)
# if there is not enough time to safely unlock the token on-chain
# silently let the transfer expire.
if is_valid and safe_to_wait:
message_identifier = message_identifier_from_prng(
pseudo_random_generator)
recipient = transfer.initiator
secret_request = SendSecretRequest(
recipient=recipient,
channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE,
message_identifier=message_identifier,
payment_identifier=transfer.payment_identifier,
amount=transfer.lock.amount,
expiration=transfer.lock.expiration,
secrethash=transfer.lock.secrethash,
)
channel_events.append(secret_request)
iteration = TransitionResult(target_state, channel_events)
else:
if not is_valid:
failure_reason = errormsg
elif not safe_to_wait:
failure_reason = unsafe_msg
unlock_failed = EventUnlockClaimFailed(
identifier=transfer.payment_identifier,
secrethash=transfer.lock.secrethash,
reason=failure_reason,
)
channel_events.append(unlock_failed)
iteration = TransitionResult(target_state, channel_events)
return iteration
def events_for_expired_pairs(
channelidentifiers_to_channels: typing.ChannelMap,
transfers_pair: typing.List[MediationPairState],
waiting_transfer: WaitingTransferState,
block_number: typing.BlockNumber,
) -> typing.List[Event]:
""" Informational events for expired locks. """
pending_transfers_pairs = get_pending_transfer_pairs(transfers_pair)
events = list()
for pair in pending_transfers_pairs:
payer_balance_proof = pair.payer_transfer.balance_proof
payer_channel = channelidentifiers_to_channels.get(payer_balance_proof.channel_identifier)
payer_lock_expiration_threshold = (
pair.payer_transfer.lock.expiration +
DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS * 2
)
has_payer_lock_expired, _ = channel.is_lock_expired(
end_state=payer_channel.our_state,
lock=pair.payer_transfer.lock,
block_number=block_number,
lock_expiration_threshold=payer_lock_expiration_threshold,
)
has_payer_transfer_expired = (
has_payer_lock_expired and
pair.payer_state != 'payer_expired'
)
if has_payer_transfer_expired:
# For safety, the correct behavior is:
#
# - If the payee has been paid, then the payer must pay too.
#
# And the corollary:
#
# - If the payer transfer has expired, then the payee transfer must
# have expired too.
#
# The problem is that this corollary cannot be asserted. If a user
# is running Raiden without a monitoring service, then it may go
# offline after having paid a transfer to a payee, but without
# getting a balance proof of the payer, and once it comes back
# online the transfer may have expired.
#
# assert pair.payee_state == 'payee_expired'
pair.payer_state = 'payer_expired'
unlock_claim_failed = EventUnlockClaimFailed(
pair.payer_transfer.payment_identifier,
pair.payer_transfer.lock.secrethash,
'lock expired',
)
events.append(unlock_claim_failed)
if waiting_transfer and waiting_transfer.state != 'expired':
waiting_transfer.state = 'expired'
unlock_claim_failed = EventUnlockClaimFailed(
waiting_transfer.transfer.payment_identifier,
waiting_transfer.transfer.lock.secrethash,
'lock expired',
)
events.append(unlock_claim_failed)
return events
def handle_inittarget_light(
state_change: ActionInitTargetLight,
channel_state: NettingChannelState,
pseudo_random_generator: random.Random,
block_number: BlockNumber,
storage
) -> TransitionResult[TargetTransferState]:
""" Handles an ActionInitTarget state change. """
transfer = state_change.transfer
route = state_change.route
assert channel_state.identifier == transfer.balance_proof.channel_identifier
is_valid, channel_events, errormsg, handle_invoice_result = channel.handle_receive_lockedtransfer_light(
channel_state, transfer, storage
)
if is_valid:
# A valid balance proof does not mean the payment itself is still valid.
# e.g. the lock may be near expiration or have expired. This is fine. The
# message with an unusable lock must be handled to properly synchronize the
# local view of the partner's channel state, allowing the next balance
# proofs to be handled. This however, must only be done once, which is
# enforced by the nonce increasing sequentially, which is verified by
# the handler handle_receive_lockedtransfer.
target_state = TargetTransferState(route, transfer)
safe_to_wait, _ = is_safe_to_wait(
transfer.lock.expiration, channel_state.reveal_timeout, block_number
)
# If there is not enough time to safely unlock the lock on-chain
# silently let the transfer expire. The target task must be created to
# handle the ReceiveLockExpired state change, which will clear the
# expired lock.
#
# We add a new validation.
# It is verified that if there was an invoice it was paid successfully,
# if it was not, the payment is interrupted
# by not generating an event send secret request
if safe_to_wait and handle_invoice_result['is_valid']:
payment = LightClientPayment(
state_change.transfer.target, state_change.transfer.initiator,
False,
channel_state.token_network_identifier,
transfer.lock.amount,
str(date.today()),
LightClientPaymentStatus.Pending,
transfer.payment_identifier
)
payment_exists = LightClientService.get_light_client_payment(payment.payment_id, storage)
if not payment_exists:
LightClientMessageHandler.store_light_client_payment(payment, storage)
message_identifier = message_identifier_from_prng(pseudo_random_generator)
recipient = transfer.initiator
secret_request = SendSecretRequest(
recipient=Address(recipient),
channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE,
message_identifier=message_identifier,
payment_identifier=transfer.payment_identifier,
amount=transfer.lock.amount,
expiration=transfer.lock.expiration,
secrethash=transfer.lock.secrethash,
)
store_locked_transfer_event = StoreMessageEvent(transfer.message_identifier, transfer.payment_identifier, 1,
state_change.signed_lockedtransfer, True)
secret_request_message = SecretRequest.from_event(secret_request)
store_secret_request_event = StoreMessageEvent(message_identifier, transfer.payment_identifier, 5,
secret_request_message, False)
channel_events.append(store_secret_request_event)
channel_events.append(store_locked_transfer_event)
iteration = TransitionResult(target_state, channel_events)
else:
# If the balance proof is not valid, do *not* create a task. Otherwise it's
# possible for an attacker to send multiple invalid transfers, and increase
# the memory usage of this Node.
assert errormsg, "handle_receive_lockedtransfer should return error msg if not valid"
unlock_failed = EventUnlockClaimFailed(
identifier=transfer.payment_identifier,
secrethash=transfer.lock.secrethash,
reason=errormsg,
)
channel_events.append(unlock_failed)
iteration = TransitionResult(None, channel_events)
return iteration
