signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def handle_offchain_secretreveal(<EOL>target_state: TargetTransferState,<EOL>state_change: ReceiveSecretReveal,<EOL>channel_state: NettingChannelState,<EOL>pseudo_random_generator: random.Random,<EOL>block_number: BlockNumber,<EOL>) -> TransitionResult[TargetTransferState]:
|
valid_secret = is_valid_secret_reveal(<EOL>state_change=state_change,<EOL>transfer_secrethash=target_state.transfer.lock.secrethash,<EOL>secret=state_change.secret,<EOL>)<EOL>has_transfer_expired = channel.is_transfer_expired(<EOL>transfer=target_state.transfer,<EOL>affected_channel=channel_state,<EOL>block_number=block_number,<EOL>)<EOL>if valid_secret and not has_transfer_expired:<EOL><INDENT>channel.register_offchain_secret(<EOL>channel_state=channel_state,<EOL>secret=state_change.secret,<EOL>secrethash=state_change.secrethash,<EOL>)<EOL>route = target_state.route<EOL>message_identifier = message_identifier_from_prng(pseudo_random_generator)<EOL>target_state.state = TargetTransferState.OFFCHAIN_SECRET_REVEAL<EOL>target_state.secret = state_change.secret<EOL>recipient = route.node_address<EOL>reveal = SendSecretReveal(<EOL>recipient=recipient,<EOL>channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE,<EOL>message_identifier=message_identifier,<EOL>secret=target_state.secret,<EOL>)<EOL>iteration = TransitionResult(target_state, [reveal])<EOL><DEDENT>else:<EOL><INDENT>iteration = TransitionResult(target_state, list())<EOL><DEDENT>return iteration<EOL>
|
Validates and handles a ReceiveSecretReveal state change.
|
f9424:m3
|
def handle_onchain_secretreveal(<EOL>target_state: TargetTransferState,<EOL>state_change: ContractReceiveSecretReveal,<EOL>channel_state: NettingChannelState,<EOL>) -> TransitionResult[TargetTransferState]:
|
valid_secret = is_valid_secret_reveal(<EOL>state_change=state_change,<EOL>transfer_secrethash=target_state.transfer.lock.secrethash,<EOL>secret=state_change.secret,<EOL>)<EOL>if valid_secret:<EOL><INDENT>channel.register_onchain_secret(<EOL>channel_state=channel_state,<EOL>secret=state_change.secret,<EOL>secrethash=state_change.secrethash,<EOL>secret_reveal_block_number=state_change.block_number,<EOL>)<EOL>target_state.state = TargetTransferState.ONCHAIN_UNLOCK<EOL>target_state.secret = state_change.secret<EOL><DEDENT>return TransitionResult(target_state, list())<EOL>
|
Validates and handles a ContractReceiveSecretReveal state change.
|
f9424:m4
|
def handle_unlock(<EOL>target_state: TargetTransferState,<EOL>state_change: ReceiveUnlock,<EOL>channel_state: NettingChannelState,<EOL>) -> TransitionResult[TargetTransferState]:
|
balance_proof_sender = state_change.balance_proof.sender<EOL>is_valid, events, _ = channel.handle_unlock(<EOL>channel_state,<EOL>state_change,<EOL>)<EOL>next_target_state: Optional[TargetTransferState] = target_state<EOL>if is_valid:<EOL><INDENT>transfer = target_state.transfer<EOL>payment_received_success = EventPaymentReceivedSuccess(<EOL>payment_network_identifier=channel_state.payment_network_identifier,<EOL>token_network_identifier=TokenNetworkID(channel_state.token_network_identifier),<EOL>identifier=transfer.payment_identifier,<EOL>amount=TokenAmount(transfer.lock.amount),<EOL>initiator=transfer.initiator,<EOL>)<EOL>unlock_success = EventUnlockClaimSuccess(<EOL>transfer.payment_identifier,<EOL>transfer.lock.secrethash,<EOL>)<EOL>send_processed = SendProcessed(<EOL>recipient=balance_proof_sender,<EOL>channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE,<EOL>message_identifier=state_change.message_identifier,<EOL>)<EOL>events.extend([payment_received_success, unlock_success, send_processed])<EOL>next_target_state = None<EOL><DEDENT>return TransitionResult(next_target_state, events)<EOL>
|
Handles a ReceiveUnlock state change.
|
f9424:m5
|
def handle_block(<EOL>target_state: TargetTransferState,<EOL>channel_state: NettingChannelState,<EOL>block_number: BlockNumber,<EOL>block_hash: BlockHash,<EOL>) -> TransitionResult[TargetTransferState]:
|
transfer = target_state.transfer<EOL>events: List[Event] = list()<EOL>lock = transfer.lock<EOL>secret_known = channel.is_secret_known(<EOL>channel_state.partner_state,<EOL>lock.secrethash,<EOL>)<EOL>lock_has_expired, _ = channel.is_lock_expired(<EOL>end_state=channel_state.our_state,<EOL>lock=lock,<EOL>block_number=block_number,<EOL>lock_expiration_threshold=channel.get_receiver_expiration_threshold(lock),<EOL>)<EOL>if lock_has_expired and target_state.state != '<STR_LIT>':<EOL><INDENT>failed = EventUnlockClaimFailed(<EOL>identifier=transfer.payment_identifier,<EOL>secrethash=transfer.lock.secrethash,<EOL>reason=f'<STR_LIT>',<EOL>)<EOL>target_state.state = TargetTransferState.EXPIRED<EOL>events = [failed]<EOL><DEDENT>elif secret_known:<EOL><INDENT>events = events_for_onchain_secretreveal(<EOL>target_state=target_state,<EOL>channel_state=channel_state,<EOL>block_number=block_number,<EOL>block_hash=block_hash,<EOL>)<EOL><DEDENT>return TransitionResult(target_state, events)<EOL>
|
After Raiden learns about a new block this function must be called to
handle expiration of the hash time lock.
|
f9424:m6
|
def handle_lock_expired(<EOL>target_state: TargetTransferState,<EOL>state_change: ReceiveLockExpired,<EOL>channel_state: NettingChannelState,<EOL>block_number: BlockNumber,<EOL>) -> TransitionResult[TargetTransferState]:
|
result = channel.handle_receive_lock_expired(<EOL>channel_state=channel_state,<EOL>state_change=state_change,<EOL>block_number=block_number,<EOL>)<EOL>assert result.new_state, '<STR_LIT>'<EOL>if not channel.get_lock(result.new_state.partner_state, target_state.transfer.lock.secrethash):<EOL><INDENT>transfer = target_state.transfer<EOL>unlock_failed = EventUnlockClaimFailed(<EOL>identifier=transfer.payment_identifier,<EOL>secrethash=transfer.lock.secrethash,<EOL>reason='<STR_LIT>',<EOL>)<EOL>result.events.append(unlock_failed)<EOL>return TransitionResult(None, result.events)<EOL><DEDENT>return TransitionResult(target_state, result.events)<EOL>
|
Remove expired locks from channel states.
|
f9424:m7
|
def state_transition(<EOL>target_state: Optional[TargetTransferState],<EOL>state_change: StateChange,<EOL>channel_state: NettingChannelState,<EOL>pseudo_random_generator: random.Random,<EOL>block_number: BlockNumber,<EOL>) -> TransitionResult[TargetTransferState]:
|
<EOL>iteration = TransitionResult(target_state, list())<EOL>if type(state_change) == ActionInitTarget:<EOL><INDENT>assert isinstance(state_change, ActionInitTarget), MYPY_ANNOTATION<EOL>if target_state is None:<EOL><INDENT>iteration = handle_inittarget(<EOL>state_change,<EOL>channel_state,<EOL>pseudo_random_generator,<EOL>block_number,<EOL>)<EOL><DEDENT><DEDENT>elif type(state_change) == Block:<EOL><INDENT>assert isinstance(state_change, Block), MYPY_ANNOTATION<EOL>assert state_change.block_number == block_number<EOL>assert target_state, '<STR_LIT>'<EOL>iteration = handle_block(<EOL>target_state=target_state,<EOL>channel_state=channel_state,<EOL>block_number=state_change.block_number,<EOL>block_hash=state_change.block_hash,<EOL>)<EOL><DEDENT>elif type(state_change) == ReceiveSecretReveal:<EOL><INDENT>assert isinstance(state_change, ReceiveSecretReveal), MYPY_ANNOTATION<EOL>assert target_state, '<STR_LIT>'<EOL>iteration = handle_offchain_secretreveal(<EOL>target_state=target_state,<EOL>state_change=state_change,<EOL>channel_state=channel_state,<EOL>pseudo_random_generator=pseudo_random_generator,<EOL>block_number=block_number,<EOL>)<EOL><DEDENT>elif type(state_change) == ContractReceiveSecretReveal:<EOL><INDENT>assert isinstance(state_change, ContractReceiveSecretReveal), MYPY_ANNOTATION<EOL>msg = '<STR_LIT>'<EOL>assert target_state, msg<EOL>iteration = handle_onchain_secretreveal(<EOL>target_state,<EOL>state_change,<EOL>channel_state,<EOL>)<EOL><DEDENT>elif type(state_change) == ReceiveUnlock:<EOL><INDENT>assert isinstance(state_change, ReceiveUnlock), MYPY_ANNOTATION<EOL>assert target_state, '<STR_LIT>'<EOL>iteration = handle_unlock(<EOL>target_state=target_state,<EOL>state_change=state_change,<EOL>channel_state=channel_state,<EOL>)<EOL><DEDENT>elif type(state_change) == ReceiveLockExpired:<EOL><INDENT>assert isinstance(state_change, ReceiveLockExpired), MYPY_ANNOTATION<EOL>assert target_state, '<STR_LIT>'<EOL>iteration = handle_lock_expired(<EOL>target_state=target_state,<EOL>state_change=state_change,<EOL>channel_state=channel_state,<EOL>block_number=block_number,<EOL>)<EOL><DEDENT>sanity_check(<EOL>old_state=target_state,<EOL>new_state=iteration.new_state,<EOL>channel_state=channel_state,<EOL>)<EOL>return iteration<EOL>
|
State machine for the target node of a mediated transfer.
|
f9424:m8
|
def clear_if_finalized(<EOL>iteration: TransitionResult,<EOL>) -> TransitionResult[InitiatorPaymentState]:
|
state = cast(InitiatorPaymentState, iteration.new_state)<EOL>if state is None:<EOL><INDENT>return iteration<EOL><DEDENT>if len(state.initiator_transfers) == <NUM_LIT:0>:<EOL><INDENT>return TransitionResult(None, iteration.events)<EOL><DEDENT>return iteration<EOL>
|
Clear the initiator payment task if all transfers have been finalized
or expired.
|
f9425:m0
|
def can_cancel(initiator: InitiatorTransferState) -> bool:
|
return (<EOL>initiator is None or<EOL>initiator.revealsecret is None<EOL>)<EOL>
|
A transfer is only cancellable until the secret is revealed.
|
f9425:m3
|
def cancel_current_route(<EOL>payment_state: InitiatorPaymentState,<EOL>initiator_state: InitiatorTransferState,<EOL>) -> List[Event]:
|
assert can_cancel(initiator_state), '<STR_LIT>'<EOL>transfer_description = initiator_state.transfer_description<EOL>payment_state.cancelled_channels.append(initiator_state.channel_identifier)<EOL>return events_for_cancel_current_route(transfer_description)<EOL>
|
Cancel current route.
This allows a new route to be tried.
|
f9425:m5
|
def handle_cancelpayment(<EOL>payment_state: InitiatorPaymentState,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>) -> TransitionResult[InitiatorPaymentState]:
|
<EOL>events = list()<EOL>for initiator_state in payment_state.initiator_transfers.values():<EOL><INDENT>channel_identifier = initiator_state.channel_identifier<EOL>channel_state = channelidentifiers_to_channels.get(channel_identifier)<EOL>if not channel_state:<EOL><INDENT>continue<EOL><DEDENT>if can_cancel(initiator_state):<EOL><INDENT>transfer_description = initiator_state.transfer_description<EOL>cancel_events = cancel_current_route(payment_state, initiator_state)<EOL>initiator_state.transfer_state = '<STR_LIT>'<EOL>cancel = EventPaymentSentFailed(<EOL>payment_network_identifier=channel_state.payment_network_identifier,<EOL>token_network_identifier=TokenNetworkID(channel_state.token_network_identifier),<EOL>identifier=transfer_description.payment_identifier,<EOL>target=transfer_description.target,<EOL>reason='<STR_LIT>',<EOL>)<EOL>cancel_events.append(cancel)<EOL>events.extend(cancel_events)<EOL><DEDENT><DEDENT>return TransitionResult(payment_state, events)<EOL>
|
Cancel the payment and all related transfers.
|
f9425:m11
|
def handle_lock_expired(<EOL>payment_state: InitiatorPaymentState,<EOL>state_change: ReceiveLockExpired,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>block_number: BlockNumber,<EOL>) -> TransitionResult[InitiatorPaymentState]:
|
initiator_state = payment_state.initiator_transfers.get(state_change.secrethash)<EOL>if not initiator_state:<EOL><INDENT>return TransitionResult(payment_state, list())<EOL><DEDENT>channel_identifier = initiator_state.channel_identifier<EOL>channel_state = channelidentifiers_to_channels.get(channel_identifier)<EOL>if not channel_state:<EOL><INDENT>return TransitionResult(payment_state, list())<EOL><DEDENT>secrethash = initiator_state.transfer.lock.secrethash<EOL>result = channel.handle_receive_lock_expired(<EOL>channel_state=channel_state,<EOL>state_change=state_change,<EOL>block_number=block_number,<EOL>)<EOL>assert result.new_state, '<STR_LIT>'<EOL>if not channel.get_lock(result.new_state.partner_state, secrethash):<EOL><INDENT>transfer = initiator_state.transfer<EOL>unlock_failed = EventUnlockClaimFailed(<EOL>identifier=transfer.payment_identifier,<EOL>secrethash=transfer.lock.secrethash,<EOL>reason='<STR_LIT>',<EOL>)<EOL>result.events.append(unlock_failed)<EOL><DEDENT>return TransitionResult(payment_state, result.events)<EOL>
|
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
|
f9425:m13
|
def is_lock_valid(<EOL>expiration: BlockExpiration,<EOL>block_number: BlockNumber,<EOL>) -> bool:
|
return block_number <= BlockNumber(expiration)<EOL>
|
True if the lock has not expired.
|
f9427:m0
|
def is_safe_to_wait(<EOL>lock_expiration: BlockExpiration,<EOL>reveal_timeout: BlockTimeout,<EOL>block_number: BlockNumber,<EOL>) -> SuccessOrError:
|
<EOL>assert block_number > <NUM_LIT:0><EOL>assert reveal_timeout > <NUM_LIT:0><EOL>assert lock_expiration > reveal_timeout<EOL>lock_timeout = lock_expiration - block_number<EOL>if lock_timeout > reveal_timeout:<EOL><INDENT>return True, None<EOL><DEDENT>msg = (<EOL>f'<STR_LIT>'<EOL>f'<STR_LIT>'<EOL>f'<STR_LIT>'<EOL>)<EOL>return False, msg<EOL>
|
True if waiting is safe, i.e. there are more than enough blocks to safely
unlock on chain.
|
f9427:m1
|
def is_send_transfer_almost_equal(<EOL>send_channel: NettingChannelState,<EOL>send: LockedTransferUnsignedState,<EOL>received: LockedTransferSignedState,<EOL>) -> bool:
|
<EOL>return (<EOL>isinstance(send, LockedTransferUnsignedState) and<EOL>isinstance(received, LockedTransferSignedState) and<EOL>send.payment_identifier == received.payment_identifier and<EOL>send.token == received.token and<EOL>send.lock.amount == received.lock.amount - send_channel.mediation_fee and<EOL>send.lock.expiration == received.lock.expiration and<EOL>send.lock.secrethash == received.lock.secrethash and<EOL>send.initiator == received.initiator and<EOL>send.target == received.target<EOL>)<EOL>
|
True if both transfers are for the same mediated transfer.
|
f9427:m3
|
def filter_reachable_routes(<EOL>routes: List[RouteState],<EOL>nodeaddresses_to_networkstates: NodeNetworkStateMap,<EOL>) -> List[RouteState]:
|
reachable_routes = []<EOL>for route in routes:<EOL><INDENT>node_network_state = nodeaddresses_to_networkstates.get(<EOL>route.node_address,<EOL>NODE_NETWORK_UNREACHABLE,<EOL>)<EOL>if node_network_state == NODE_NETWORK_REACHABLE:<EOL><INDENT>reachable_routes.append(route)<EOL><DEDENT><DEDENT>return reachable_routes<EOL>
|
This function makes sure we use reachable routes only.
|
f9427:m5
|
def filter_used_routes(<EOL>transfers_pair: List[MediationPairState],<EOL>routes: List[RouteState],<EOL>) -> List[RouteState]:
|
channelid_to_route = {r.channel_identifier: r for r in routes}<EOL>routes_order = {route.node_address: index for index, route in enumerate(routes)}<EOL>for pair in transfers_pair:<EOL><INDENT>channelid = pair.payer_transfer.balance_proof.channel_identifier<EOL>if channelid in channelid_to_route:<EOL><INDENT>del channelid_to_route[channelid]<EOL><DEDENT>channelid = pair.payee_transfer.balance_proof.channel_identifier<EOL>if channelid in channelid_to_route:<EOL><INDENT>del channelid_to_route[channelid]<EOL><DEDENT><DEDENT>return sorted(<EOL>channelid_to_route.values(),<EOL>key=lambda route: routes_order[route.node_address],<EOL>)<EOL>
|
This function makes sure we filter routes that have already been used.
So in a setup like this, we want to make sure that node 2, having tried to
route the transfer through 3 will also try 5 before sending it backwards to 1
1 -> 2 -> 3 -> 4
v ^
5 -> 6 -> 7
This function will return routes as provided in their original order.
|
f9427:m6
|
def get_payee_channel(<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>transfer_pair: MediationPairState,<EOL>) -> Optional[NettingChannelState]:
|
payee_channel_identifier = transfer_pair.payee_transfer.balance_proof.channel_identifier<EOL>return channelidentifiers_to_channels.get(payee_channel_identifier)<EOL>
|
Returns the payee channel of a given transfer pair or None if it's not found
|
f9427:m7
|
def get_payer_channel(<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>transfer_pair: MediationPairState,<EOL>) -> Optional[NettingChannelState]:
|
payer_channel_identifier = transfer_pair.payer_transfer.balance_proof.channel_identifier<EOL>return channelidentifiers_to_channels.get(payer_channel_identifier)<EOL>
|
Returns the payer channel of a given transfer pair or None if it's not found
|
f9427:m8
|
def get_pending_transfer_pairs(<EOL>transfers_pair: List[MediationPairState],<EOL>) -> List[MediationPairState]:
|
pending_pairs = list(<EOL>pair<EOL>for pair in transfers_pair<EOL>if pair.payee_state not in STATE_TRANSFER_FINAL or<EOL>pair.payer_state not in STATE_TRANSFER_FINAL<EOL>)<EOL>return pending_pairs<EOL>
|
Return the transfer pairs that are not at a final state.
|
f9427:m9
|
def get_lock_amount_after_fees(<EOL>lock: HashTimeLockState,<EOL>payee_channel: NettingChannelState,<EOL>) -> PaymentWithFeeAmount:
|
return PaymentWithFeeAmount(lock.amount - payee_channel.mediation_fee)<EOL>
|
Return the lock.amount after fees are taken.
Fees are taken only for the outgoing channel, which is the one with
collateral locked from this node.
|
f9427:m10
|
def sanity_check(<EOL>state: MediatorTransferState,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>) -> None:
|
<EOL>all_transfers_states = itertools.chain(<EOL>(pair.payee_state for pair in state.transfers_pair),<EOL>(pair.payer_state for pair in state.transfers_pair),<EOL>)<EOL>if any(state in STATE_TRANSFER_PAID for state in all_transfers_states):<EOL><INDENT>assert state.secret is not None<EOL><DEDENT>if state.transfers_pair:<EOL><INDENT>first_pair = state.transfers_pair[<NUM_LIT:0>]<EOL>assert state.secrethash == first_pair.payer_transfer.lock.secrethash<EOL><DEDENT>for pair in state.transfers_pair:<EOL><INDENT>payee_channel = get_payee_channel(<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>transfer_pair=pair,<EOL>)<EOL>if not payee_channel:<EOL><INDENT>continue<EOL><DEDENT>assert is_send_transfer_almost_equal(<EOL>send_channel=payee_channel,<EOL>send=pair.payee_transfer,<EOL>received=pair.payer_transfer,<EOL>)<EOL>assert pair.payer_state in pair.valid_payer_states<EOL>assert pair.payee_state in pair.valid_payee_states<EOL><DEDENT>for original, refund in zip(state.transfers_pair[:-<NUM_LIT:1>], state.transfers_pair[<NUM_LIT:1>:]):<EOL><INDENT>assert original.payee_address == refund.payer_address<EOL>payer_channel = get_payer_channel(<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>transfer_pair=refund,<EOL>)<EOL>if not payer_channel:<EOL><INDENT>continue<EOL><DEDENT>transfer_sent = original.payee_transfer<EOL>transfer_received = refund.payer_transfer<EOL>assert is_send_transfer_almost_equal(<EOL>send_channel=payer_channel,<EOL>send=transfer_sent,<EOL>received=transfer_received,<EOL>)<EOL><DEDENT>if state.waiting_transfer and state.transfers_pair:<EOL><INDENT>last_transfer_pair = state.transfers_pair[-<NUM_LIT:1>]<EOL>payee_channel = get_payee_channel(<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>transfer_pair=last_transfer_pair,<EOL>)<EOL>if payee_channel:<EOL><INDENT>transfer_sent = last_transfer_pair.payee_transfer<EOL>transfer_received = state.waiting_transfer.transfer<EOL>assert is_send_transfer_almost_equal(<EOL>send_channel=payee_channel,<EOL>send=transfer_sent,<EOL>received=transfer_received,<EOL>)<EOL><DEDENT><DEDENT>
|
Check invariants that must hold.
|
f9427:m11
|
def clear_if_finalized(<EOL>iteration: TransitionResult,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>) -> TransitionResult[MediatorTransferState]:
|
state = cast(MediatorTransferState, iteration.new_state)<EOL>if state is None:<EOL><INDENT>return iteration<EOL><DEDENT>secrethash = state.secrethash<EOL>for pair in state.transfers_pair:<EOL><INDENT>payer_channel = get_payer_channel(channelidentifiers_to_channels, pair)<EOL>if payer_channel and channel.is_lock_pending(payer_channel.partner_state, secrethash):<EOL><INDENT>return iteration<EOL><DEDENT>payee_channel = get_payee_channel(channelidentifiers_to_channels, pair)<EOL>if payee_channel and channel.is_lock_pending(payee_channel.our_state, secrethash):<EOL><INDENT>return iteration<EOL><DEDENT><DEDENT>if state.waiting_transfer:<EOL><INDENT>waiting_transfer = state.waiting_transfer.transfer<EOL>waiting_channel_identifier = waiting_transfer.balance_proof.channel_identifier<EOL>waiting_channel = channelidentifiers_to_channels.get(waiting_channel_identifier)<EOL>if waiting_channel and channel.is_lock_pending(waiting_channel.partner_state, secrethash):<EOL><INDENT>return iteration<EOL><DEDENT><DEDENT>return TransitionResult(None, iteration.events)<EOL>
|
Clear the mediator task if all the locks have been finalized.
A lock is considered finalized if it has been removed from the merkle tree
offchain, either because the transfer was unlocked or expired, or because the
channel was settled on chain and therefore the channel is removed.
|
f9427:m12
|
def next_channel_from_routes(<EOL>available_routes: List['<STR_LIT>'],<EOL>channelidentifiers_to_channels: Dict,<EOL>transfer_amount: PaymentWithFeeAmount,<EOL>lock_timeout: BlockTimeout,<EOL>) -> Optional[NettingChannelState]:
|
for route in available_routes:<EOL><INDENT>channel_state = channelidentifiers_to_channels.get(route.channel_identifier)<EOL>if not channel_state:<EOL><INDENT>continue<EOL><DEDENT>if is_channel_usable(channel_state, transfer_amount, lock_timeout):<EOL><INDENT>return channel_state<EOL><DEDENT><DEDENT>return None<EOL>
|
Returns the first route that may be used to mediated the transfer.
The routing service can race with local changes, so the recommended routes
must be validated.
Args:
available_routes: Current available routes that may be used, it's
assumed that the available_routes list is ordered from best to
worst.
channelidentifiers_to_channels: Mapping from channel identifier
to NettingChannelState.
transfer_amount: The amount of tokens that will be transferred
through the given route.
lock_timeout: Number of blocks until the lock expires, used to filter
out channels that have a smaller settlement window.
Returns:
The next route.
|
f9427:m13
|
def forward_transfer_pair(<EOL>payer_transfer: LockedTransferSignedState,<EOL>available_routes: List['<STR_LIT>'],<EOL>channelidentifiers_to_channels: Dict,<EOL>pseudo_random_generator: random.Random,<EOL>block_number: BlockNumber,<EOL>) -> Tuple[Optional[MediationPairState], List[Event]]:
|
transfer_pair = None<EOL>mediated_events: List[Event] = list()<EOL>lock_timeout = BlockTimeout(payer_transfer.lock.expiration - block_number)<EOL>payee_channel = next_channel_from_routes(<EOL>available_routes=available_routes,<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>transfer_amount=payer_transfer.lock.amount,<EOL>lock_timeout=lock_timeout,<EOL>)<EOL>if payee_channel:<EOL><INDENT>assert payee_channel.settle_timeout >= lock_timeout<EOL>assert payee_channel.token_address == payer_transfer.token<EOL>message_identifier = message_identifier_from_prng(pseudo_random_generator)<EOL>lock = payer_transfer.lock<EOL>lockedtransfer_event = channel.send_lockedtransfer(<EOL>channel_state=payee_channel,<EOL>initiator=payer_transfer.initiator,<EOL>target=payer_transfer.target,<EOL>amount=get_lock_amount_after_fees(lock, payee_channel),<EOL>message_identifier=message_identifier,<EOL>payment_identifier=payer_transfer.payment_identifier,<EOL>expiration=lock.expiration,<EOL>secrethash=lock.secrethash,<EOL>)<EOL>assert lockedtransfer_event<EOL>transfer_pair = MediationPairState(<EOL>payer_transfer,<EOL>payee_channel.partner_state.address,<EOL>lockedtransfer_event.transfer,<EOL>)<EOL>mediated_events = [lockedtransfer_event]<EOL><DEDENT>return (<EOL>transfer_pair,<EOL>mediated_events,<EOL>)<EOL>
|
Given a payer transfer tries a new route to proceed with the mediation.
Args:
payer_transfer: The transfer received from the payer_channel.
available_routes: Current available routes that may be used, it's
assumed that the routes list is ordered from best to worst.
channelidentifiers_to_channels: All the channels available for this
transfer.
pseudo_random_generator: Number generator to generate a message id.
block_number: The current block number.
|
f9427:m14
|
def backward_transfer_pair(<EOL>backward_channel: NettingChannelState,<EOL>payer_transfer: LockedTransferSignedState,<EOL>pseudo_random_generator: random.Random,<EOL>block_number: BlockNumber,<EOL>) -> Tuple[Optional[MediationPairState], List[Event]]:
|
transfer_pair = None<EOL>events: List[Event] = list()<EOL>lock = payer_transfer.lock<EOL>lock_timeout = BlockTimeout(lock.expiration - block_number)<EOL>if is_channel_usable(backward_channel, lock.amount, lock_timeout):<EOL><INDENT>message_identifier = message_identifier_from_prng(pseudo_random_generator)<EOL>refund_transfer = channel.send_refundtransfer(<EOL>channel_state=backward_channel,<EOL>initiator=payer_transfer.initiator,<EOL>target=payer_transfer.target,<EOL>amount=get_lock_amount_after_fees(lock, backward_channel),<EOL>message_identifier=message_identifier,<EOL>payment_identifier=payer_transfer.payment_identifier,<EOL>expiration=lock.expiration,<EOL>secrethash=lock.secrethash,<EOL>)<EOL>transfer_pair = MediationPairState(<EOL>payer_transfer,<EOL>backward_channel.partner_state.address,<EOL>refund_transfer.transfer,<EOL>)<EOL>events.append(refund_transfer)<EOL><DEDENT>return (transfer_pair, events)<EOL>
|
Sends a transfer backwards, allowing the previous hop to try a new
route.
When all the routes available for this node failed, send a transfer
backwards with the same amount and secrethash, allowing the previous hop to
do a retry.
Args:
backward_channel: The original channel which sent the mediated transfer
to this node.
payer_transfer: The *latest* payer transfer which is backing the
mediation.
block_number: The current block number.
Returns:
The mediator pair and the correspoding refund event.
|
f9427:m15
|
def set_offchain_secret(<EOL>state: MediatorTransferState,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>secret: Secret,<EOL>secrethash: SecretHash,<EOL>) -> List[Event]:
|
state.secret = secret<EOL>for pair in state.transfers_pair:<EOL><INDENT>payer_channel = channelidentifiers_to_channels.get(<EOL>pair.payer_transfer.balance_proof.channel_identifier,<EOL>)<EOL>if payer_channel:<EOL><INDENT>channel.register_offchain_secret(<EOL>payer_channel,<EOL>secret,<EOL>secrethash,<EOL>)<EOL><DEDENT>payee_channel = channelidentifiers_to_channels.get(<EOL>pair.payee_transfer.balance_proof.channel_identifier,<EOL>)<EOL>if payee_channel:<EOL><INDENT>channel.register_offchain_secret(<EOL>payee_channel,<EOL>secret,<EOL>secrethash,<EOL>)<EOL><DEDENT><DEDENT>if state.waiting_transfer:<EOL><INDENT>payer_channel = channelidentifiers_to_channels.get(<EOL>state.waiting_transfer.transfer.balance_proof.channel_identifier,<EOL>)<EOL>if payer_channel:<EOL><INDENT>channel.register_offchain_secret(<EOL>payer_channel,<EOL>secret,<EOL>secrethash,<EOL>)<EOL><DEDENT>unexpected_reveal = EventUnexpectedSecretReveal(<EOL>secrethash=secrethash,<EOL>reason='<STR_LIT>',<EOL>)<EOL>return [unexpected_reveal]<EOL><DEDENT>return list()<EOL>
|
Set the secret to all mediated transfers.
|
f9427:m16
|
def set_onchain_secret(<EOL>state: MediatorTransferState,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>secret: Secret,<EOL>secrethash: SecretHash,<EOL>block_number: BlockNumber,<EOL>) -> List[Event]:
|
state.secret = secret<EOL>for pair in state.transfers_pair:<EOL><INDENT>payer_channel = channelidentifiers_to_channels.get(<EOL>pair.payer_transfer.balance_proof.channel_identifier,<EOL>)<EOL>if payer_channel:<EOL><INDENT>channel.register_onchain_secret(<EOL>payer_channel,<EOL>secret,<EOL>secrethash,<EOL>block_number,<EOL>)<EOL><DEDENT>payee_channel = channelidentifiers_to_channels.get(<EOL>pair.payee_transfer.balance_proof.channel_identifier,<EOL>)<EOL>if payee_channel:<EOL><INDENT>channel.register_onchain_secret(<EOL>channel_state=payee_channel,<EOL>secret=secret,<EOL>secrethash=secrethash,<EOL>secret_reveal_block_number=block_number,<EOL>)<EOL><DEDENT><DEDENT>if state.waiting_transfer:<EOL><INDENT>payer_channel = channelidentifiers_to_channels.get(<EOL>state.waiting_transfer.transfer.balance_proof.channel_identifier,<EOL>)<EOL>if payer_channel:<EOL><INDENT>channel.register_onchain_secret(<EOL>channel_state=payer_channel,<EOL>secret=secret,<EOL>secrethash=secrethash,<EOL>secret_reveal_block_number=block_number,<EOL>)<EOL><DEDENT>unexpected_reveal = EventUnexpectedSecretReveal(<EOL>secrethash=secrethash,<EOL>reason='<STR_LIT>',<EOL>)<EOL>return [unexpected_reveal]<EOL><DEDENT>return list()<EOL>
|
Set the secret to all mediated transfers.
The secret should have been learned from the secret registry.
|
f9427:m17
|
def set_offchain_reveal_state(<EOL>transfers_pair: List[MediationPairState],<EOL>payee_address: Address,<EOL>) -> None:
|
for pair in transfers_pair:<EOL><INDENT>if pair.payee_address == payee_address:<EOL><INDENT>pair.payee_state = '<STR_LIT>'<EOL><DEDENT><DEDENT>
|
Set the state of a transfer *sent* to a payee.
|
f9427:m18
|
def events_for_expired_pairs(<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>transfers_pair: List[MediationPairState],<EOL>waiting_transfer: Optional[WaitingTransferState],<EOL>block_number: BlockNumber,<EOL>) -> List[Event]:
|
pending_transfers_pairs = get_pending_transfer_pairs(transfers_pair)<EOL>events: List[Event] = list()<EOL>for pair in pending_transfers_pairs:<EOL><INDENT>payer_balance_proof = pair.payer_transfer.balance_proof<EOL>payer_channel = channelidentifiers_to_channels.get(payer_balance_proof.channel_identifier)<EOL>if not payer_channel:<EOL><INDENT>continue<EOL><DEDENT>has_payer_transfer_expired = channel.is_transfer_expired(<EOL>transfer=pair.payer_transfer,<EOL>affected_channel=payer_channel,<EOL>block_number=block_number,<EOL>)<EOL>if has_payer_transfer_expired:<EOL><INDENT>pair.payer_state = '<STR_LIT>'<EOL>unlock_claim_failed = EventUnlockClaimFailed(<EOL>pair.payer_transfer.payment_identifier,<EOL>pair.payer_transfer.lock.secrethash,<EOL>'<STR_LIT>',<EOL>)<EOL>events.append(unlock_claim_failed)<EOL><DEDENT><DEDENT>if waiting_transfer and waiting_transfer.state != '<STR_LIT>':<EOL><INDENT>waiting_transfer.state = '<STR_LIT>'<EOL>unlock_claim_failed = EventUnlockClaimFailed(<EOL>waiting_transfer.transfer.payment_identifier,<EOL>waiting_transfer.transfer.lock.secrethash,<EOL>'<STR_LIT>',<EOL>)<EOL>events.append(unlock_claim_failed)<EOL><DEDENT>return events<EOL>
|
Informational events for expired locks.
|
f9427:m19
|
def events_for_secretreveal(<EOL>transfers_pair: List[MediationPairState],<EOL>secret: Secret,<EOL>pseudo_random_generator: random.Random,<EOL>) -> List[Event]:
|
events: List[Event] = list()<EOL>for pair in reversed(transfers_pair):<EOL><INDENT>payee_knows_secret = pair.payee_state in STATE_SECRET_KNOWN<EOL>payer_knows_secret = pair.payer_state in STATE_SECRET_KNOWN<EOL>is_transfer_pending = pair.payer_state == '<STR_LIT>'<EOL>should_send_secret = (<EOL>payee_knows_secret and<EOL>not payer_knows_secret and<EOL>is_transfer_pending<EOL>)<EOL>if should_send_secret:<EOL><INDENT>message_identifier = message_identifier_from_prng(pseudo_random_generator)<EOL>pair.payer_state = '<STR_LIT>'<EOL>payer_transfer = pair.payer_transfer<EOL>revealsecret = SendSecretReveal(<EOL>recipient=payer_transfer.balance_proof.sender,<EOL>channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE,<EOL>message_identifier=message_identifier,<EOL>secret=secret,<EOL>)<EOL>events.append(revealsecret)<EOL><DEDENT><DEDENT>return events<EOL>
|
Reveal the secret off-chain.
The secret is revealed off-chain even if there is a pending transaction to
reveal it on-chain, this allows the unlock to happen off-chain, which is
faster.
This node is named N, suppose there is a mediated transfer with two refund
transfers, one from B and one from C:
A-N-B...B-N-C..C-N-D
Under normal operation N will first learn the secret from D, then reveal to
C, wait for C to inform the secret is known before revealing it to B, and
again wait for B before revealing the secret to A.
If B somehow sent a reveal secret before C and D, then the secret will be
revealed to A, but not C and D, meaning the secret won't be propagated
forward. Even if D sent a reveal secret at about the same time, the secret
will only be revealed to B upon confirmation from C.
If the proof doesn't arrive in time and the lock's expiration is at risk, N
won't lose tokens since it knows the secret can go on-chain at any time.
|
f9427:m20
|
def events_for_balanceproof(<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>transfers_pair: List[MediationPairState],<EOL>pseudo_random_generator: random.Random,<EOL>block_number: BlockNumber,<EOL>secret: Secret,<EOL>secrethash: SecretHash,<EOL>) -> List[Event]:
|
events: List[Event] = list()<EOL>for pair in reversed(transfers_pair):<EOL><INDENT>payee_knows_secret = pair.payee_state in STATE_SECRET_KNOWN<EOL>payee_payed = pair.payee_state in STATE_TRANSFER_PAID<EOL>payee_channel = get_payee_channel(channelidentifiers_to_channels, pair)<EOL>payee_channel_open = (<EOL>payee_channel and channel.get_status(payee_channel) == CHANNEL_STATE_OPENED<EOL>)<EOL>payer_channel = get_payer_channel(channelidentifiers_to_channels, pair)<EOL>is_safe_to_send_balanceproof = False<EOL>if payer_channel:<EOL><INDENT>is_safe_to_send_balanceproof, _ = is_safe_to_wait(<EOL>pair.payer_transfer.lock.expiration,<EOL>payer_channel.reveal_timeout,<EOL>block_number,<EOL>)<EOL><DEDENT>should_send_balanceproof_to_payee = (<EOL>payee_channel_open and<EOL>payee_knows_secret and<EOL>not payee_payed and<EOL>is_safe_to_send_balanceproof<EOL>)<EOL>if should_send_balanceproof_to_payee:<EOL><INDENT>assert payee_channel<EOL>payee_channel = cast(NettingChannelState, payee_channel)<EOL>pair.payee_state = '<STR_LIT>'<EOL>message_identifier = message_identifier_from_prng(pseudo_random_generator)<EOL>unlock_lock = channel.send_unlock(<EOL>channel_state=payee_channel,<EOL>message_identifier=message_identifier,<EOL>payment_identifier=pair.payee_transfer.payment_identifier,<EOL>secret=secret,<EOL>secrethash=secrethash,<EOL>)<EOL>unlock_success = EventUnlockSuccess(<EOL>pair.payer_transfer.payment_identifier,<EOL>pair.payer_transfer.lock.secrethash,<EOL>)<EOL>events.append(unlock_lock)<EOL>events.append(unlock_success)<EOL><DEDENT><DEDENT>return events<EOL>
|
While it's safe do the off-chain unlock.
|
f9427:m21
|
def events_for_onchain_secretreveal_if_dangerzone(<EOL>channelmap: ChannelMap,<EOL>secrethash: SecretHash,<EOL>transfers_pair: List[MediationPairState],<EOL>block_number: BlockNumber,<EOL>block_hash: BlockHash,<EOL>) -> List[Event]:
|
events: List[Event] = list()<EOL>all_payer_channels = []<EOL>for pair in transfers_pair:<EOL><INDENT>channel_state = get_payer_channel(channelmap, pair)<EOL>if channel_state:<EOL><INDENT>all_payer_channels.append(channel_state)<EOL><DEDENT><DEDENT>transaction_sent = has_secret_registration_started(<EOL>all_payer_channels,<EOL>transfers_pair,<EOL>secrethash,<EOL>)<EOL>for pair in get_pending_transfer_pairs(transfers_pair):<EOL><INDENT>payer_channel = get_payer_channel(channelmap, pair)<EOL>if not payer_channel:<EOL><INDENT>continue<EOL><DEDENT>lock = pair.payer_transfer.lock<EOL>safe_to_wait, _ = is_safe_to_wait(<EOL>lock.expiration,<EOL>payer_channel.reveal_timeout,<EOL>block_number,<EOL>)<EOL>secret_known = channel.is_secret_known(<EOL>payer_channel.partner_state,<EOL>pair.payer_transfer.lock.secrethash,<EOL>)<EOL>if not safe_to_wait and secret_known:<EOL><INDENT>pair.payer_state = '<STR_LIT>'<EOL>if not transaction_sent:<EOL><INDENT>secret = channel.get_secret(<EOL>payer_channel.partner_state,<EOL>lock.secrethash,<EOL>)<EOL>assert secret, '<STR_LIT>'<EOL>reveal_events = secret_registry.events_for_onchain_secretreveal(<EOL>channel_state=payer_channel,<EOL>secret=secret,<EOL>expiration=lock.expiration,<EOL>block_hash=block_hash,<EOL>)<EOL>events.extend(reveal_events)<EOL>transaction_sent = True<EOL><DEDENT><DEDENT><DEDENT>return events<EOL>
|
Reveal the secret on-chain if the lock enters the unsafe region and the
secret is not yet on-chain.
|
f9427:m22
|
def events_for_onchain_secretreveal_if_closed(<EOL>channelmap: ChannelMap,<EOL>transfers_pair: List[MediationPairState],<EOL>secret: Secret,<EOL>secrethash: SecretHash,<EOL>block_hash: BlockHash,<EOL>) -> List[Event]:
|
events: List[Event] = list()<EOL>all_payer_channels = []<EOL>for pair in transfers_pair:<EOL><INDENT>channel_state = get_payer_channel(channelmap, pair)<EOL>if channel_state:<EOL><INDENT>all_payer_channels.append(channel_state)<EOL><DEDENT><DEDENT>transaction_sent = has_secret_registration_started(<EOL>all_payer_channels,<EOL>transfers_pair,<EOL>secrethash,<EOL>)<EOL>for pending_pair in get_pending_transfer_pairs(transfers_pair):<EOL><INDENT>payer_channel = get_payer_channel(channelmap, pending_pair)<EOL>if payer_channel and channel.get_status(payer_channel) == CHANNEL_STATE_CLOSED:<EOL><INDENT>pending_pair.payer_state = '<STR_LIT>'<EOL>if not transaction_sent:<EOL><INDENT>partner_state = payer_channel.partner_state<EOL>lock = channel.get_lock(partner_state, secrethash)<EOL>if lock:<EOL><INDENT>reveal_events = secret_registry.events_for_onchain_secretreveal(<EOL>channel_state=payer_channel,<EOL>secret=secret,<EOL>expiration=lock.expiration,<EOL>block_hash=block_hash,<EOL>)<EOL>events.extend(reveal_events)<EOL>transaction_sent = True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return events<EOL>
|
Register the secret on-chain if the payer channel is already closed and
the mediator learned the secret off-chain.
Balance proofs are not exchanged for closed channels, so there is no reason
to wait for the unsafe region to register secret.
Note:
If the secret is learned before the channel is closed, then the channel
will register the secrets in bulk, not the transfer.
|
f9427:m23
|
def events_to_remove_expired_locks(<EOL>mediator_state: MediatorTransferState,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>block_number: BlockNumber,<EOL>pseudo_random_generator: random.Random,<EOL>) -> List[Event]:
|
events: List[Event] = list()<EOL>for transfer_pair in mediator_state.transfers_pair:<EOL><INDENT>balance_proof = transfer_pair.payee_transfer.balance_proof<EOL>channel_identifier = balance_proof.channel_identifier<EOL>channel_state = channelidentifiers_to_channels.get(channel_identifier)<EOL>if not channel_state:<EOL><INDENT>continue<EOL><DEDENT>secrethash = mediator_state.secrethash<EOL>lock: Union[None, LockType] = None<EOL>if secrethash in channel_state.our_state.secrethashes_to_lockedlocks:<EOL><INDENT>assert secrethash not in channel_state.our_state.secrethashes_to_unlockedlocks<EOL>lock = channel_state.our_state.secrethashes_to_lockedlocks.get(secrethash)<EOL><DEDENT>elif secrethash in channel_state.our_state.secrethashes_to_unlockedlocks:<EOL><INDENT>lock = channel_state.our_state.secrethashes_to_unlockedlocks.get(secrethash)<EOL><DEDENT>if lock:<EOL><INDENT>lock_expiration_threshold = channel.get_sender_expiration_threshold(lock)<EOL>has_lock_expired, _ = channel.is_lock_expired(<EOL>end_state=channel_state.our_state,<EOL>lock=lock,<EOL>block_number=block_number,<EOL>lock_expiration_threshold=lock_expiration_threshold,<EOL>)<EOL>is_channel_open = channel.get_status(channel_state) == CHANNEL_STATE_OPENED<EOL>if has_lock_expired and is_channel_open:<EOL><INDENT>transfer_pair.payee_state = '<STR_LIT>'<EOL>expired_lock_events = channel.events_for_expired_lock(<EOL>channel_state=channel_state,<EOL>locked_lock=lock,<EOL>pseudo_random_generator=pseudo_random_generator,<EOL>)<EOL>events.extend(expired_lock_events)<EOL>unlock_failed = EventUnlockFailed(<EOL>transfer_pair.payee_transfer.payment_identifier,<EOL>transfer_pair.payee_transfer.lock.secrethash,<EOL>'<STR_LIT>',<EOL>)<EOL>events.append(unlock_failed)<EOL><DEDENT><DEDENT><DEDENT>return events<EOL>
|
Clear the channels which have expired locks.
This only considers the *sent* transfers, received transfers can only be
updated by the partner.
|
f9427:m24
|
def secret_learned(<EOL>state: MediatorTransferState,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>pseudo_random_generator: random.Random,<EOL>block_number: BlockNumber,<EOL>block_hash: BlockHash,<EOL>secret: Secret,<EOL>secrethash: SecretHash,<EOL>payee_address: Address,<EOL>) -> TransitionResult[MediatorTransferState]:
|
secret_reveal_events = set_offchain_secret(<EOL>state,<EOL>channelidentifiers_to_channels,<EOL>secret,<EOL>secrethash,<EOL>)<EOL>set_offchain_reveal_state(<EOL>state.transfers_pair,<EOL>payee_address,<EOL>)<EOL>onchain_secret_reveal = events_for_onchain_secretreveal_if_closed(<EOL>channelmap=channelidentifiers_to_channels,<EOL>transfers_pair=state.transfers_pair,<EOL>secret=secret,<EOL>secrethash=secrethash,<EOL>block_hash=block_hash,<EOL>)<EOL>offchain_secret_reveal = events_for_secretreveal(<EOL>state.transfers_pair,<EOL>secret,<EOL>pseudo_random_generator,<EOL>)<EOL>balance_proof = events_for_balanceproof(<EOL>channelidentifiers_to_channels,<EOL>state.transfers_pair,<EOL>pseudo_random_generator,<EOL>block_number,<EOL>secret,<EOL>secrethash,<EOL>)<EOL>events = secret_reveal_events + offchain_secret_reveal + balance_proof + onchain_secret_reveal<EOL>iteration = TransitionResult(state, events)<EOL>return iteration<EOL>
|
Unlock the payee lock, reveal the lock to the payer, and if necessary
register the secret on-chain.
|
f9427:m25
|
def mediate_transfer(<EOL>state: MediatorTransferState,<EOL>possible_routes: List['<STR_LIT>'],<EOL>payer_channel: NettingChannelState,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>nodeaddresses_to_networkstates: NodeNetworkStateMap,<EOL>pseudo_random_generator: random.Random,<EOL>payer_transfer: LockedTransferSignedState,<EOL>block_number: BlockNumber,<EOL>) -> TransitionResult[MediatorTransferState]:
|
reachable_routes = filter_reachable_routes(<EOL>possible_routes,<EOL>nodeaddresses_to_networkstates,<EOL>)<EOL>available_routes = filter_used_routes(<EOL>state.transfers_pair,<EOL>reachable_routes,<EOL>)<EOL>assert payer_channel.partner_state.address == payer_transfer.balance_proof.sender<EOL>transfer_pair, mediated_events = forward_transfer_pair(<EOL>payer_transfer,<EOL>available_routes,<EOL>channelidentifiers_to_channels,<EOL>pseudo_random_generator,<EOL>block_number,<EOL>)<EOL>if transfer_pair is None:<EOL><INDENT>assert not mediated_events<EOL>if state.transfers_pair:<EOL><INDENT>original_pair = state.transfers_pair[<NUM_LIT:0>]<EOL>original_channel = get_payer_channel(<EOL>channelidentifiers_to_channels,<EOL>original_pair,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>original_channel = payer_channel<EOL><DEDENT>if original_channel:<EOL><INDENT>transfer_pair, mediated_events = backward_transfer_pair(<EOL>original_channel,<EOL>payer_transfer,<EOL>pseudo_random_generator,<EOL>block_number,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>transfer_pair = None<EOL>mediated_events = list()<EOL><DEDENT><DEDENT>if transfer_pair is None:<EOL><INDENT>assert not mediated_events<EOL>mediated_events = list()<EOL>state.waiting_transfer = WaitingTransferState(payer_transfer)<EOL><DEDENT>else:<EOL><INDENT>state.transfers_pair.append(transfer_pair)<EOL><DEDENT>return TransitionResult(state, mediated_events)<EOL>
|
Try a new route or fail back to a refund.
The mediator can safely try a new route knowing that the tokens from
payer_transfer will cover the expenses of the mediation. If there is no
route available that may be used at the moment of the call the mediator may
send a refund back to the payer, allowing the payer to try a different
route.
|
f9427:m26
|
def handle_block(<EOL>mediator_state: MediatorTransferState,<EOL>state_change: Block,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>pseudo_random_generator: random.Random,<EOL>) -> TransitionResult[MediatorTransferState]:
|
expired_locks_events = events_to_remove_expired_locks(<EOL>mediator_state,<EOL>channelidentifiers_to_channels,<EOL>state_change.block_number,<EOL>pseudo_random_generator,<EOL>)<EOL>secret_reveal_events = events_for_onchain_secretreveal_if_dangerzone(<EOL>channelmap=channelidentifiers_to_channels,<EOL>secrethash=mediator_state.secrethash,<EOL>transfers_pair=mediator_state.transfers_pair,<EOL>block_number=state_change.block_number,<EOL>block_hash=state_change.block_hash,<EOL>)<EOL>unlock_fail_events = events_for_expired_pairs(<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>transfers_pair=mediator_state.transfers_pair,<EOL>waiting_transfer=mediator_state.waiting_transfer,<EOL>block_number=state_change.block_number,<EOL>)<EOL>iteration = TransitionResult(<EOL>mediator_state,<EOL>unlock_fail_events + secret_reveal_events + expired_locks_events,<EOL>)<EOL>return iteration<EOL>
|
After Raiden learns about a new block this function must be called to
handle expiration of the hash time locks.
Args:
state: The current state.
Return:
TransitionResult: The resulting iteration
|
f9427:m28
|
def handle_refundtransfer(<EOL>mediator_state: MediatorTransferState,<EOL>mediator_state_change: ReceiveTransferRefund,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>nodeaddresses_to_networkstates: NodeNetworkStateMap,<EOL>pseudo_random_generator: random.Random,<EOL>block_number: BlockNumber,<EOL>) -> TransitionResult[MediatorTransferState]:
|
events: List[Event] = list()<EOL>if mediator_state.secret is None:<EOL><INDENT>transfer_pair = mediator_state.transfers_pair[-<NUM_LIT:1>]<EOL>payee_transfer = transfer_pair.payee_transfer<EOL>payer_transfer = mediator_state_change.transfer<EOL>channel_identifier = payer_transfer.balance_proof.channel_identifier<EOL>payer_channel = channelidentifiers_to_channels.get(channel_identifier)<EOL>if not payer_channel:<EOL><INDENT>return TransitionResult(mediator_state, list())<EOL><DEDENT>is_valid, channel_events, _ = channel.handle_refundtransfer(<EOL>received_transfer=payee_transfer,<EOL>channel_state=payer_channel,<EOL>refund=mediator_state_change,<EOL>)<EOL>if not is_valid:<EOL><INDENT>return TransitionResult(mediator_state, channel_events)<EOL><DEDENT>iteration = mediate_transfer(<EOL>mediator_state,<EOL>mediator_state_change.routes,<EOL>payer_channel,<EOL>channelidentifiers_to_channels,<EOL>nodeaddresses_to_networkstates,<EOL>pseudo_random_generator,<EOL>payer_transfer,<EOL>block_number,<EOL>)<EOL>events.extend(channel_events)<EOL>events.extend(iteration.events)<EOL><DEDENT>iteration = TransitionResult(mediator_state, events)<EOL>return iteration<EOL>
|
Validate and handle a ReceiveTransferRefund mediator_state change.
A node might participate in mediated transfer more than once because of
refund transfers, eg. A-B-C-B-D-T, B tried to mediate the transfer through
C, which didn't have an available route to proceed and refunds B, at this
point B is part of the path again and will try a new partner to proceed
with the mediation through D, D finally reaches the target T.
In the above scenario B has two pairs of payer and payee transfers:
payer:A payee:C from the first SendLockedTransfer
payer:C payee:D from the following SendRefundTransfer
Args:
mediator_state (MediatorTransferState): Current mediator_state.
mediator_state_change (ReceiveTransferRefund): The mediator_state change.
Returns:
TransitionResult: The resulting iteration.
|
f9427:m29
|
def handle_offchain_secretreveal(<EOL>mediator_state: MediatorTransferState,<EOL>mediator_state_change: ReceiveSecretReveal,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>pseudo_random_generator: random.Random,<EOL>block_number: BlockNumber,<EOL>block_hash: BlockHash,<EOL>) -> TransitionResult[MediatorTransferState]:
|
is_valid_reveal = is_valid_secret_reveal(<EOL>state_change=mediator_state_change,<EOL>transfer_secrethash=mediator_state.secrethash,<EOL>secret=mediator_state_change.secret,<EOL>)<EOL>is_secret_unknown = mediator_state.secret is None<EOL>transfer_pair = mediator_state.transfers_pair[-<NUM_LIT:1>]<EOL>payer_transfer = transfer_pair.payer_transfer<EOL>channel_identifier = payer_transfer.balance_proof.channel_identifier<EOL>payer_channel = channelidentifiers_to_channels.get(channel_identifier)<EOL>if not payer_channel:<EOL><INDENT>return TransitionResult(mediator_state, list())<EOL><DEDENT>has_payer_transfer_expired = channel.is_transfer_expired(<EOL>transfer=transfer_pair.payer_transfer,<EOL>affected_channel=payer_channel,<EOL>block_number=block_number,<EOL>)<EOL>if is_secret_unknown and is_valid_reveal and not has_payer_transfer_expired:<EOL><INDENT>iteration = secret_learned(<EOL>state=mediator_state,<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>pseudo_random_generator=pseudo_random_generator,<EOL>block_number=block_number,<EOL>block_hash=block_hash,<EOL>secret=mediator_state_change.secret,<EOL>secrethash=mediator_state_change.secrethash,<EOL>payee_address=mediator_state_change.sender,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>iteration = TransitionResult(mediator_state, list())<EOL><DEDENT>return iteration<EOL>
|
Handles the secret reveal and sends SendBalanceProof/RevealSecret if necessary.
|
f9427:m30
|
def handle_onchain_secretreveal(<EOL>mediator_state: MediatorTransferState,<EOL>onchain_secret_reveal: ContractReceiveSecretReveal,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>pseudo_random_generator: random.Random,<EOL>block_number: BlockNumber,<EOL>) -> TransitionResult[MediatorTransferState]:
|
secrethash = onchain_secret_reveal.secrethash<EOL>is_valid_reveal = is_valid_secret_reveal(<EOL>state_change=onchain_secret_reveal,<EOL>transfer_secrethash=mediator_state.secrethash,<EOL>secret=onchain_secret_reveal.secret,<EOL>)<EOL>if is_valid_reveal:<EOL><INDENT>secret = onchain_secret_reveal.secret<EOL>block_number = onchain_secret_reveal.block_number<EOL>secret_reveal = set_onchain_secret(<EOL>state=mediator_state,<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>secret=secret,<EOL>secrethash=secrethash,<EOL>block_number=block_number,<EOL>)<EOL>balance_proof = events_for_balanceproof(<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>transfers_pair=mediator_state.transfers_pair,<EOL>pseudo_random_generator=pseudo_random_generator,<EOL>block_number=block_number,<EOL>secret=secret,<EOL>secrethash=secrethash,<EOL>)<EOL>iteration = TransitionResult(mediator_state, secret_reveal + balance_proof)<EOL><DEDENT>else:<EOL><INDENT>iteration = TransitionResult(mediator_state, list())<EOL><DEDENT>return iteration<EOL>
|
The secret was revealed on-chain, set the state of all transfers to
secret known.
|
f9427:m31
|
def handle_unlock(<EOL>mediator_state: MediatorTransferState,<EOL>state_change: ReceiveUnlock,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>) -> TransitionResult[MediatorTransferState]:
|
events = list()<EOL>balance_proof_sender = state_change.balance_proof.sender<EOL>channel_identifier = state_change.balance_proof.channel_identifier<EOL>for pair in mediator_state.transfers_pair:<EOL><INDENT>if pair.payer_transfer.balance_proof.sender == balance_proof_sender:<EOL><INDENT>channel_state = channelidentifiers_to_channels.get(channel_identifier)<EOL>if channel_state:<EOL><INDENT>is_valid, channel_events, _ = channel.handle_unlock(<EOL>channel_state,<EOL>state_change,<EOL>)<EOL>events.extend(channel_events)<EOL>if is_valid:<EOL><INDENT>unlock = EventUnlockClaimSuccess(<EOL>pair.payee_transfer.payment_identifier,<EOL>pair.payee_transfer.lock.secrethash,<EOL>)<EOL>events.append(unlock)<EOL>send_processed = SendProcessed(<EOL>recipient=balance_proof_sender,<EOL>channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE,<EOL>message_identifier=state_change.message_identifier,<EOL>)<EOL>events.append(send_processed)<EOL>pair.payer_state = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT><DEDENT>iteration = TransitionResult(mediator_state, events)<EOL>return iteration<EOL>
|
Handle a ReceiveUnlock state change.
|
f9427:m32
|
def handle_node_change_network_state(<EOL>mediator_state: MediatorTransferState,<EOL>state_change: ActionChangeNodeNetworkState,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>pseudo_random_generator: random.Random,<EOL>block_number: BlockNumber,<EOL>) -> TransitionResult:
|
if state_change.network_state != NODE_NETWORK_REACHABLE:<EOL><INDENT>return TransitionResult(mediator_state, list())<EOL><DEDENT>try:<EOL><INDENT>route = next(<EOL>route for route in mediator_state.routes<EOL>if route.node_address == state_change.node_address<EOL>)<EOL><DEDENT>except StopIteration:<EOL><INDENT>return TransitionResult(mediator_state, list())<EOL><DEDENT>if mediator_state.waiting_transfer is None:<EOL><INDENT>return TransitionResult(mediator_state, list())<EOL><DEDENT>transfer = mediator_state.waiting_transfer.transfer<EOL>payer_channel_identifier = transfer.balance_proof.channel_identifier<EOL>payer_channel = channelidentifiers_to_channels.get(payer_channel_identifier)<EOL>payee_channel = channelidentifiers_to_channels.get(route.channel_identifier)<EOL>if not payee_channel or not payer_channel:<EOL><INDENT>return TransitionResult(mediator_state, list())<EOL><DEDENT>payee_channel_open = channel.get_status(payee_channel) == CHANNEL_STATE_OPENED<EOL>if not payee_channel_open:<EOL><INDENT>return TransitionResult(mediator_state, list())<EOL><DEDENT>return mediate_transfer(<EOL>state=mediator_state,<EOL>possible_routes=[route],<EOL>payer_channel=payer_channel,<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>nodeaddresses_to_networkstates={<EOL>state_change.node_address: state_change.network_state,<EOL>},<EOL>pseudo_random_generator=pseudo_random_generator,<EOL>payer_transfer=mediator_state.waiting_transfer.transfer,<EOL>block_number=block_number,<EOL>)<EOL>
|
If a certain node comes online:
1. Check if a channel exists with that node
2. Check that this channel is a route, check if the route is valid.
3. Check that the transfer was stuck because there was no route available.
4. Send the transfer again to this now-available route.
|
f9427:m34
|
def state_transition(<EOL>mediator_state: Optional[MediatorTransferState],<EOL>state_change: StateChange,<EOL>channelidentifiers_to_channels: ChannelMap,<EOL>nodeaddresses_to_networkstates: NodeNetworkStateMap,<EOL>pseudo_random_generator: random.Random,<EOL>block_number: BlockNumber,<EOL>block_hash: BlockHash,<EOL>) -> TransitionResult[MediatorTransferState]:
|
<EOL>iteration = TransitionResult(mediator_state, list())<EOL>if type(state_change) == ActionInitMediator:<EOL><INDENT>assert isinstance(state_change, ActionInitMediator), MYPY_ANNOTATION<EOL>if mediator_state is None:<EOL><INDENT>iteration = handle_init(<EOL>state_change=state_change,<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>nodeaddresses_to_networkstates=nodeaddresses_to_networkstates,<EOL>pseudo_random_generator=pseudo_random_generator,<EOL>block_number=block_number,<EOL>)<EOL><DEDENT><DEDENT>elif type(state_change) == Block:<EOL><INDENT>assert isinstance(state_change, Block), MYPY_ANNOTATION<EOL>assert mediator_state, '<STR_LIT>'<EOL>iteration = handle_block(<EOL>mediator_state=mediator_state,<EOL>state_change=state_change,<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>pseudo_random_generator=pseudo_random_generator,<EOL>)<EOL><DEDENT>elif type(state_change) == ReceiveTransferRefund:<EOL><INDENT>assert isinstance(state_change, ReceiveTransferRefund), MYPY_ANNOTATION<EOL>msg = '<STR_LIT>'<EOL>assert mediator_state, msg<EOL>iteration = handle_refundtransfer(<EOL>mediator_state=mediator_state,<EOL>mediator_state_change=state_change,<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>nodeaddresses_to_networkstates=nodeaddresses_to_networkstates,<EOL>pseudo_random_generator=pseudo_random_generator,<EOL>block_number=block_number,<EOL>)<EOL><DEDENT>elif type(state_change) == ReceiveSecretReveal:<EOL><INDENT>assert isinstance(state_change, ReceiveSecretReveal), MYPY_ANNOTATION<EOL>msg = '<STR_LIT>'<EOL>assert mediator_state, msg<EOL>iteration = handle_offchain_secretreveal(<EOL>mediator_state=mediator_state,<EOL>mediator_state_change=state_change,<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>pseudo_random_generator=pseudo_random_generator,<EOL>block_number=block_number,<EOL>block_hash=block_hash,<EOL>)<EOL><DEDENT>elif type(state_change) == ContractReceiveSecretReveal:<EOL><INDENT>assert isinstance(state_change, ContractReceiveSecretReveal), MYPY_ANNOTATION<EOL>msg = '<STR_LIT>'<EOL>assert mediator_state, msg<EOL>iteration = handle_onchain_secretreveal(<EOL>mediator_state=mediator_state,<EOL>onchain_secret_reveal=state_change,<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>pseudo_random_generator=pseudo_random_generator,<EOL>block_number=block_number,<EOL>)<EOL><DEDENT>elif type(state_change) == ReceiveUnlock:<EOL><INDENT>assert isinstance(state_change, ReceiveUnlock), MYPY_ANNOTATION<EOL>assert mediator_state, '<STR_LIT>'<EOL>iteration = handle_unlock(<EOL>mediator_state=mediator_state,<EOL>state_change=state_change,<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>)<EOL><DEDENT>elif type(state_change) == ReceiveLockExpired:<EOL><INDENT>assert isinstance(state_change, ReceiveLockExpired), MYPY_ANNOTATION<EOL>assert mediator_state, '<STR_LIT>'<EOL>iteration = handle_lock_expired(<EOL>mediator_state=mediator_state,<EOL>state_change=state_change,<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>block_number=block_number,<EOL>)<EOL><DEDENT>elif type(state_change) == ActionChangeNodeNetworkState:<EOL><INDENT>assert isinstance(state_change, ActionChangeNodeNetworkState), MYPY_ANNOTATION<EOL>msg = '<STR_LIT>'<EOL>assert mediator_state, msg<EOL>iteration = handle_node_change_network_state(<EOL>mediator_state=mediator_state,<EOL>state_change=state_change,<EOL>channelidentifiers_to_channels=channelidentifiers_to_channels,<EOL>pseudo_random_generator=pseudo_random_generator,<EOL>block_number=block_number,<EOL>)<EOL><DEDENT>if iteration.new_state is not None:<EOL><INDENT>assert isinstance(iteration.new_state, MediatorTransferState)<EOL>sanity_check(iteration.new_state, channelidentifiers_to_channels)<EOL><DEDENT>return clear_if_finalized(iteration, channelidentifiers_to_channels)<EOL>
|
State machine for a node mediating a transfer.
|
f9427:m35
|
def lockedtransfersigned_from_message(message: '<STR_LIT>') -> '<STR_LIT>':
|
balance_proof = balanceproof_from_envelope(message)<EOL>lock = HashTimeLockState(<EOL>message.lock.amount,<EOL>message.lock.expiration,<EOL>message.lock.secrethash,<EOL>)<EOL>transfer_state = LockedTransferSignedState(<EOL>message.message_identifier,<EOL>message.payment_identifier,<EOL>message.token,<EOL>balance_proof,<EOL>lock,<EOL>message.initiator,<EOL>message.target,<EOL>)<EOL>return transfer_state<EOL>
|
Create LockedTransferSignedState from a LockedTransfer message.
|
f9428:m0
|
def hash_pair(first: Keccak256, second: Optional[Keccak256]) -> Keccak256:
|
assert first is not None<EOL>if second is None:<EOL><INDENT>return first<EOL><DEDENT>if first > second:<EOL><INDENT>return sha3(second + first)<EOL><DEDENT>return sha3(first + second)<EOL>
|
Computes the keccak hash of the elements ordered topologically.
Since a merkle proof will not include all the elements, but only the path
starting from the leaves up to the root, the order of the elements is not
known by the proof checker. The topological order is used as a
deterministic way of ordering the elements making sure the smart contract
verification and the python code are compatible.
|
f9431:m0
|
def compute_layers(elements: List[Keccak256]) -> List[List[Keccak256]]:
|
elements = list(elements) <EOL>assert elements, '<STR_LIT>'<EOL>if not all(isinstance(item, bytes) for item in elements):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if any(len(item) != <NUM_LIT:32> for item in elements):<EOL><INDENT>raise HashLengthNot32()<EOL><DEDENT>if len(elements) != len(set(elements)):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>leaves = sorted(item for item in elements)<EOL>tree = [leaves]<EOL>layer = leaves<EOL>while len(layer) > <NUM_LIT:1>:<EOL><INDENT>paired_items = split_in_pairs(layer)<EOL>layer = [hash_pair(a, b) for a, b in paired_items]<EOL>tree.append(layer)<EOL><DEDENT>return tree<EOL>
|
Computes the layers of the merkletree.
First layer is the list of elements and the last layer is a list with a
single entry, the merkleroot.
|
f9431:m1
|
def compute_merkleproof_for(merkletree: '<STR_LIT>', element: Keccak256) -> List[Keccak256]:
|
idx = merkletree.layers[LEAVES].index(element)<EOL>proof = []<EOL>for layer in merkletree.layers:<EOL><INDENT>if idx % <NUM_LIT:2>:<EOL><INDENT>pair = idx - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>pair = idx + <NUM_LIT:1><EOL><DEDENT>if pair < len(layer):<EOL><INDENT>proof.append(layer[pair])<EOL><DEDENT>idx = idx // <NUM_LIT:2><EOL><DEDENT>return proof<EOL>
|
Containment proof for element.
The proof contains only the entries that are sufficient to recompute the
merkleroot, from the leaf `element` up to `root`.
Raises:
IndexError: If the element is not part of the merkletree.
|
f9431:m2
|
def validate_proof(proof: List[Keccak256], root: Keccak256, leaf_element: Keccak256) -> bool:
|
hash_ = leaf_element<EOL>for pair in proof:<EOL><INDENT>hash_ = hash_pair(hash_, pair)<EOL><DEDENT>return hash_ == root<EOL>
|
Checks that `leaf_element` was contained in the tree represented by
`merkleroot`.
|
f9431:m3
|
def merkleroot(merkletree: '<STR_LIT>') -> Locksroot:
|
assert merkletree.layers, '<STR_LIT>'<EOL>assert merkletree.layers[MERKLEROOT], '<STR_LIT>'<EOL>return Locksroot(merkletree.layers[MERKLEROOT][<NUM_LIT:0>])<EOL>
|
Return the root element of the merkle tree.
|
f9431:m4
|
def pack_balance_proof(<EOL>nonce: Nonce,<EOL>balance_hash: BalanceHash,<EOL>additional_hash: AdditionalHash,<EOL>canonical_identifier: CanonicalIdentifier,<EOL>msg_type: MessageTypeId = MessageTypeId.BALANCE_PROOF,<EOL>) -> bytes:
|
return pack_data([<EOL>'<STR_LIT:address>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>], [<EOL>canonical_identifier.token_network_address,<EOL>canonical_identifier.chain_identifier,<EOL>msg_type,<EOL>canonical_identifier.channel_identifier,<EOL>balance_hash,<EOL>nonce,<EOL>additional_hash,<EOL>])<EOL>
|
Packs balance proof data to be signed
Packs the given arguments in a byte array in the same configuration the
contracts expect the signed data to have.
|
f9435:m0
|
def pack_balance_proof_update(<EOL>nonce: Nonce,<EOL>balance_hash: BalanceHash,<EOL>additional_hash: AdditionalHash,<EOL>canonical_identifier: CanonicalIdentifier,<EOL>partner_signature: Signature,<EOL>) -> bytes:
|
return pack_balance_proof(<EOL>nonce=nonce,<EOL>balance_hash=balance_hash,<EOL>additional_hash=additional_hash,<EOL>canonical_identifier=canonical_identifier,<EOL>msg_type=MessageTypeId.BALANCE_PROOF_UPDATE,<EOL>) + partner_signature<EOL>
|
Packs balance proof data to be signed for updateNonClosingBalanceProof
Packs the given arguments in a byte array in the same configuration the
contracts expect the signed data for updateNonClosingBalanceProof to have.
|
f9435:m1
|
def get_state_change_with_balance_proof_by_balance_hash(<EOL>storage: sqlite.SQLiteStorage,<EOL>canonical_identifier: CanonicalIdentifier,<EOL>balance_hash: BalanceHash,<EOL>sender: Address,<EOL>) -> sqlite.StateChangeRecord:
|
return storage.get_latest_state_change_by_data_field({<EOL>'<STR_LIT>':<EOL>str(canonical_identifier.chain_identifier),<EOL>'<STR_LIT>': to_checksum_address(<EOL>canonical_identifier.token_network_address,<EOL>),<EOL>'<STR_LIT>': str(<EOL>canonical_identifier.channel_identifier,<EOL>),<EOL>'<STR_LIT>': serialize_bytes(balance_hash),<EOL>'<STR_LIT>': to_checksum_address(sender),<EOL>})<EOL>
|
Returns the state change which contains the corresponding balance
proof.
Use this function to find a balance proof for a call to settle, which only
has the blinded balance proof data.
|
f9436:m0
|
def get_state_change_with_balance_proof_by_locksroot(<EOL>storage: sqlite.SQLiteStorage,<EOL>canonical_identifier: CanonicalIdentifier,<EOL>locksroot: Locksroot,<EOL>sender: Address,<EOL>) -> sqlite.StateChangeRecord:
|
return storage.get_latest_state_change_by_data_field({<EOL>'<STR_LIT>': str(<EOL>canonical_identifier.chain_identifier,<EOL>),<EOL>'<STR_LIT>': to_checksum_address(<EOL>canonical_identifier.token_network_address,<EOL>),<EOL>'<STR_LIT>': str(<EOL>canonical_identifier.channel_identifier,<EOL>),<EOL>'<STR_LIT>': serialize_bytes(locksroot),<EOL>'<STR_LIT>': to_checksum_address(sender),<EOL>})<EOL>
|
Returns the state change which contains the corresponding balance
proof.
Use this function to find a balance proof for a call to unlock, which only
happens after settle, so the channel has the unblinded version of the
balance proof.
|
f9436:m1
|
def get_event_with_balance_proof_by_balance_hash(<EOL>storage: sqlite.SQLiteStorage,<EOL>canonical_identifier: CanonicalIdentifier,<EOL>balance_hash: BalanceHash,<EOL>) -> sqlite.EventRecord:
|
return storage.get_latest_event_by_data_field({<EOL>'<STR_LIT>': str(<EOL>canonical_identifier.chain_identifier,<EOL>),<EOL>'<STR_LIT>': to_checksum_address(<EOL>canonical_identifier.token_network_address,<EOL>),<EOL>'<STR_LIT>': str(<EOL>canonical_identifier.channel_identifier,<EOL>),<EOL>'<STR_LIT>': serialize_bytes(balance_hash),<EOL>})<EOL>
|
Returns the event which contains the corresponding balance
proof.
Use this function to find a balance proof for a call to settle, which only
has the blinded balance proof data.
|
f9436:m2
|
def get_event_with_balance_proof_by_locksroot(<EOL>storage: sqlite.SQLiteStorage,<EOL>canonical_identifier: CanonicalIdentifier,<EOL>locksroot: Locksroot,<EOL>recipient: Address,<EOL>) -> sqlite.EventRecord:
|
return storage.get_latest_event_by_data_field({<EOL>'<STR_LIT>': str(<EOL>canonical_identifier.chain_identifier,<EOL>),<EOL>'<STR_LIT>': to_checksum_address(<EOL>canonical_identifier.token_network_address,<EOL>),<EOL>'<STR_LIT>': str(<EOL>canonical_identifier.channel_identifier,<EOL>),<EOL>'<STR_LIT>': serialize_bytes(locksroot),<EOL>'<STR_LIT>': to_checksum_address(recipient),<EOL>})<EOL>
|
Returns the event which contains the corresponding balance proof.
Use this function to find a balance proof for a call to unlock, which only
happens after settle, so the channel has the unblinded version of the
balance proof.
|
f9436:m3
|
def __init__(self, state_transition: Callable, current_state: Optional[State]) -> None:
|
if not callable(state_transition):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.state_transition = state_transition<EOL>self.current_state = current_state<EOL>
|
Initialize the state manager.
Args:
state_transition: function that can apply a StateChange message.
current_state: current application state.
|
f9437:c9:m0
|
def dispatch(self, state_change: StateChange) -> List[Event]:
|
assert isinstance(state_change, StateChange)<EOL>next_state = deepcopy(self.current_state)<EOL>iteration = self.state_transition(<EOL>next_state,<EOL>state_change,<EOL>)<EOL>assert isinstance(iteration, TransitionResult)<EOL>self.current_state = iteration.new_state<EOL>events = iteration.events<EOL>assert isinstance(self.current_state, (State, type(None)))<EOL>assert all(isinstance(e, Event) for e in events)<EOL>return events<EOL>
|
Apply the `state_change` in the current machine and return the
resulting events.
Args:
state_change: An object representation of a state
change.
Return:
A list of events produced by the state transition.
It's the upper layer's responsibility to decided how to handle
these events.
|
f9437:c9:m1
|
def inplace_delete_message_queue(<EOL>chain_state: ChainState,<EOL>state_change: Union[ReceiveDelivered, ReceiveProcessed],<EOL>queueid: QueueIdentifier,<EOL>) -> None:
|
queue = chain_state.queueids_to_queues.get(queueid)<EOL>if not queue:<EOL><INDENT>return<EOL><DEDENT>inplace_delete_message(<EOL>message_queue=queue,<EOL>state_change=state_change,<EOL>)<EOL>if len(queue) == <NUM_LIT:0>:<EOL><INDENT>del chain_state.queueids_to_queues[queueid]<EOL><DEDENT>else:<EOL><INDENT>chain_state.queueids_to_queues[queueid] = queue<EOL><DEDENT>
|
Filter messages from queue, if the queue becomes empty, cleanup the queue itself.
|
f9438:m11
|
def inplace_delete_message(<EOL>message_queue: List[SendMessageEvent],<EOL>state_change: Union[ReceiveDelivered, ReceiveProcessed],<EOL>) -> None:
|
for message in list(message_queue):<EOL><INDENT>message_found = (<EOL>message.message_identifier == state_change.message_identifier and<EOL>message.recipient == state_change.sender<EOL>)<EOL>if message_found:<EOL><INDENT>message_queue.remove(message)<EOL><DEDENT><DEDENT>
|
Check if the message exists in queue with ID `queueid` and exclude if found.
|
f9438:m12
|
def handle_delivered(<EOL>chain_state: ChainState,<EOL>state_change: ReceiveDelivered,<EOL>) -> TransitionResult[ChainState]:
|
queueid = QueueIdentifier(state_change.sender, CHANNEL_IDENTIFIER_GLOBAL_QUEUE)<EOL>inplace_delete_message_queue(chain_state, state_change, queueid)<EOL>return TransitionResult(chain_state, [])<EOL>
|
Check if the "Delivered" message exists in the global queue and delete if found.
|
f9438:m17
|
def is_transaction_effect_satisfied(<EOL>chain_state: ChainState,<EOL>transaction: ContractSendEvent,<EOL>state_change: StateChange,<EOL>) -> bool:
|
<EOL>is_valid_update_transfer = (<EOL>isinstance(state_change, ContractReceiveUpdateTransfer) and<EOL>isinstance(transaction, ContractSendChannelUpdateTransfer) and<EOL>state_change.token_network_identifier == transaction.token_network_identifier and<EOL>state_change.channel_identifier == transaction.channel_identifier and<EOL>state_change.nonce == transaction.balance_proof.nonce<EOL>)<EOL>if is_valid_update_transfer:<EOL><INDENT>return True<EOL><DEDENT>is_valid_close = (<EOL>isinstance(state_change, ContractReceiveChannelClosed) and<EOL>isinstance(transaction, ContractSendChannelClose) and<EOL>state_change.token_network_identifier == transaction.token_network_identifier and<EOL>state_change.channel_identifier == transaction.channel_identifier<EOL>)<EOL>if is_valid_close:<EOL><INDENT>return True<EOL><DEDENT>is_valid_settle = (<EOL>isinstance(state_change, ContractReceiveChannelSettled) and<EOL>isinstance(transaction, ContractSendChannelSettle) and<EOL>state_change.token_network_identifier == transaction.token_network_identifier and<EOL>state_change.channel_identifier == transaction.channel_identifier<EOL>)<EOL>if is_valid_settle:<EOL><INDENT>return True<EOL><DEDENT>is_valid_secret_reveal = (<EOL>isinstance(state_change, ContractReceiveSecretReveal) and<EOL>isinstance(transaction, ContractSendSecretReveal) and<EOL>state_change.secret == transaction.secret<EOL>)<EOL>if is_valid_secret_reveal:<EOL><INDENT>return True<EOL><DEDENT>is_batch_unlock = (<EOL>isinstance(state_change, ContractReceiveChannelBatchUnlock) and<EOL>isinstance(transaction, ContractSendChannelBatchUnlock)<EOL>)<EOL>if is_batch_unlock:<EOL><INDENT>assert isinstance(state_change, ContractReceiveChannelBatchUnlock), MYPY_ANNOTATION<EOL>assert isinstance(transaction, ContractSendChannelBatchUnlock), MYPY_ANNOTATION<EOL>our_address = chain_state.our_address<EOL>partner_address = None<EOL>if state_change.participant == our_address:<EOL><INDENT>partner_address = state_change.partner<EOL><DEDENT>elif state_change.partner == our_address:<EOL><INDENT>partner_address = state_change.participant<EOL><DEDENT>if partner_address:<EOL><INDENT>channel_state = views.get_channelstate_by_token_network_and_partner(<EOL>chain_state,<EOL>TokenNetworkID(state_change.token_network_identifier),<EOL>partner_address,<EOL>)<EOL>if channel_state is None:<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>
|
True if the side-effect of `transaction` is satisfied by
`state_change`.
This predicate is used to clear the transaction queue. This should only be
done once the expected side effect of a transaction is achieved. This
doesn't necessarily mean that the transaction sent by *this* node was
mined, but only that *some* transaction which achieves the same side-effect
was successfully executed and mined. This distinction is important for
restarts and to reduce the number of state changes.
On restarts: The state of the on-chain channel could have changed while the
node was offline. Once the node learns about the change (e.g. the channel
was settled), new transactions can be dispatched by Raiden as a side effect for the
on-chain *event* (e.g. do the batch unlock with the latest merkle tree),
but the dispatched transaction could have been completed by another agent (e.g.
the partner node). For these cases, the transaction from a different
address which achieves the same side-effect is sufficient, otherwise
unnecessary transactions would be sent by the node.
NOTE: The above is not important for transactions sent as a side-effect for
a new *block*. On restart the node first synchronizes its state by querying
for new events, only after the off-chain state is up-to-date, a Block state
change is dispatched. At this point some transactions are not required
anymore and therefore are not dispatched.
On the number of state changes: Accepting a transaction from another
address removes the need for clearing state changes, e.g. when our
node's close transaction fails but its partner's close transaction
succeeds.
|
f9438:m36
|
def is_transaction_invalidated(transaction, state_change):
|
<EOL>is_our_failed_update_transfer = (<EOL>isinstance(state_change, ContractReceiveChannelSettled) and<EOL>isinstance(transaction, ContractSendChannelUpdateTransfer) and<EOL>state_change.token_network_identifier == transaction.token_network_identifier and<EOL>state_change.channel_identifier == transaction.channel_identifier<EOL>)<EOL>if is_our_failed_update_transfer:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>
|
True if the `transaction` is made invalid by `state_change`.
Some transactions will fail due to race conditions. The races are:
- Another transaction which has the same side effect is executed before.
- Another transaction which *invalidates* the state of the smart contract
required by the local transaction is executed before it.
The first case is handled by the predicate `is_transaction_effect_satisfied`,
where a transaction from a different source which does the same thing is
considered. This predicate handles the second scenario.
A transaction can **only** invalidate another iff both share a valid
initial state but a different end state.
Valid example:
A close can invalidate a deposit, because both a close and a deposit
can be executed from an opened state (same initial state), but a close
transaction will transition the channel to a closed state which doesn't
allow for deposits (different end state).
Invalid example:
A settle transaction cannot invalidate a deposit because a settle is
only allowed for the closed state and deposits are only allowed for
the open state. In such a case a deposit should never have been sent.
The deposit transaction for an invalid state is a bug and not a
transaction which was invalidated.
|
f9438:m37
|
def is_transaction_expired(transaction, block_number):
|
is_update_expired = (<EOL>isinstance(transaction, ContractSendChannelUpdateTransfer) and<EOL>transaction.expiration < block_number<EOL>)<EOL>if is_update_expired:<EOL><INDENT>return True<EOL><DEDENT>is_secret_register_expired = (<EOL>isinstance(transaction, ContractSendSecretReveal) and<EOL>transaction.expiration < block_number<EOL>)<EOL>if is_secret_register_expired:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>
|
True if transaction cannot be mined because it has expired.
Some transactions are time dependent, e.g. the secret registration must be
done before the lock expiration, and the update transfer must be done
before the settlement window is over. If the current block is higher than
any of these expirations blocks, the transaction is expired and cannot be
successfully executed.
|
f9438:m38
|
def start(self):
|
if self.raiden.stop_event.is_set():<EOL><INDENT>self.raiden.start()<EOL><DEDENT>
|
Start the raiden app.
|
f9441:c0:m2
|
def stop(self):
|
if not self.raiden.stop_event.is_set():<EOL><INDENT>self.raiden.stop()<EOL><DEDENT>
|
Stop the raiden app.
Args:
leave_channels: if True, also close and settle all channels before stopping
|
f9441:c0:m3
|
def search(self, release_name, lang):
|
subtitles = []<EOL>language = babelfish.Language.fromalpha2(lang).name<EOL>payload = {'<STR_LIT:q>': release_name, '<STR_LIT:r>': '<STR_LIT:true>'}<EOL>url = '<STR_LIT>'<EOL>response = requests.get(url, params=payload, headers=self.headers).text<EOL>soup = BS(response, "<STR_LIT>")<EOL>positive = soup.find_all(class_='<STR_LIT>')<EOL>neutral = soup.find_all(class_='<STR_LIT>')<EOL>for node in chain(positive, neutral):<EOL><INDENT>suburl = node.parent['<STR_LIT>']<EOL>quality = node['<STR_LIT:class>'][<NUM_LIT:2>].split('<STR_LIT:->')[<NUM_LIT:0>]<EOL>name = node.parent.findChildren()[<NUM_LIT:1>].text.strip()<EOL>if language.lower() in suburl and '<STR_LIT>' not in name.lower():<EOL><INDENT>subtitle = {}<EOL>subtitle['<STR_LIT>'] = name<EOL>subtitle['<STR_LIT>'] = urljoin(self.base_url, suburl)<EOL>subtitle['<STR_LIT>'] = lang<EOL>subtitle['<STR_LIT>'] = name+quality<EOL>subtitle['<STR_LIT:date>'] = '<STR_LIT>'<EOL>subtitles.append(subtitle)<EOL><DEDENT><DEDENT>return subtitles<EOL>
|
search subtitles from subscene.com
|
f9448:c0:m1
|
def download(self, sub_url):
|
response = requests.get(sub_url, headers=self.headers).text<EOL>soup = BS(response, '<STR_LIT>')<EOL>downlink = self.base_url+soup.select('<STR_LIT>')[<NUM_LIT:0>]['<STR_LIT>']<EOL>data = requests.get(downlink, headers=self.headers)<EOL>z = zipfile.ZipFile(cStringIO.StringIO(data.content))<EOL>srt_files = [f.filename for f in z.filelist<EOL>if f.filename.rsplit('<STR_LIT:.>')[-<NUM_LIT:1>].lower() in ['<STR_LIT>', '<STR_LIT>']]<EOL>z.extract(srt_files[<NUM_LIT:0>], '<STR_LIT>')<EOL>return srt_files[<NUM_LIT:0>]<EOL>
|
download and unzip subtitle archive to a temp location
|
f9448:c0:m2
|
def _dct_from_mro(cls: type, attr_name: str) -> dict:
|
d = {}<EOL>for c in reversed(cls.mro()):<EOL><INDENT>d.update(getattr(c, attr_name, {}))<EOL><DEDENT>return d<EOL>
|
Get a merged dictionary from `cls` bases attribute `attr_name`. MRO defines importance (closest = strongest).
|
f9452:m0
|
def _sorted_items(mapping: typing.Mapping) -> typing.Generator:
|
to_yield = set(mapping)<EOL>while to_yield:<EOL><INDENT>for key, values in mapping.items():<EOL><INDENT>if key not in to_yield or (to_yield - {key} & set(values)): <EOL><INDENT>continue<EOL><DEDENT>yield key, values<EOL>to_yield.remove(key)<EOL><DEDENT><DEDENT>
|
Given a mapping where values are iterables, yield items whose values contained references are not used as
keys first:
Example:
>>> dct = {'two': ('two', 'one', 'foo'), 'one': ('hi', 'six', 'net'), 'six': ('three', 'four'), 'foo': ['bar']}
>>> for k, v in _sorted_items(dct):
... print(k, v)
...
six ('three', 'four')
foo ['bar']
one ('hi', 'six', 'net')
two ('two', 'one', 'foo')
|
f9452:m1
|
def _init_name_core(self, name: str):
|
self.__regex = re.compile(rf'<STR_LIT>')<EOL>self.name = name<EOL>
|
Runs whenever a new instance is initialized or `sep` is set.
|
f9452:c2:m2
|
@property<EOL><INDENT>def sep(self) -> str:<DEDENT>
|
return self._separator<EOL>
|
The string that acts as a separator of all the fields in the name.
|
f9452:c2:m4
|
@property<EOL><INDENT>def name(self) -> str:<DEDENT>
|
return self._name<EOL>
|
This object's solved name.
:raises ValueError: If an invalid string is provided when setting the attribute.
|
f9452:c2:m6
|
def get_pattern_list(self) -> typing.List[str]:
|
return list(self.config)<EOL>
|
Fields / properties names (sorted) to be used when building names. Defaults to the keys of self.config
|
f9452:c2:m9
|
@property<EOL><INDENT>def values(self) -> typing.Dict[str, str]:<DEDENT>
|
return {k: v for k, v in self._items if v is not None}<EOL>
|
The field values of this object's name as a dictionary in the form of {field: value}.
|
f9452:c2:m10
|
@property<EOL><INDENT>def nice_name(self) -> str:<DEDENT>
|
return self._get_nice_name()<EOL>
|
This object's pure name without fields not present in `self.config`.
|
f9452:c2:m11
|
def get_name(self, **values) -> str:
|
if not values and self.name:<EOL><INDENT>return self.name<EOL><DEDENT>if values:<EOL><INDENT>for ck, cvs in _sorted_items(self.compounds):<EOL><INDENT>if ck in cvs and ck in values: <EOL><INDENT>continue<EOL><DEDENT>comp_values = [values.pop(cv, getattr(self, cv)) for cv in cvs]<EOL>if None not in comp_values:<EOL><INDENT>values[ck] = '<STR_LIT>'.join(rf'<STR_LIT>' for v in comp_values)<EOL><DEDENT><DEDENT><DEDENT>return self._get_nice_name(**values)<EOL>
|
Get a new name string from this object's name values.
:param values: Variable keyword arguments where the **key** should refer to a field on this object that will
use the provided **value** to build the new name.
|
f9452:c2:m13
|
@staticmethod<EOL><INDENT>def cast(value: str, name: str = '<STR_LIT>') -> str:<DEDENT>
|
return rf'<STR_LIT>' if name else rf'<STR_LIT>'<EOL>
|
Cast `value` to a grouped regular expression when `name` is provided.
|
f9452:c2:m15
|
@classmethod<EOL><INDENT>def cast_config(cls, config: typing.Mapping[str, str]) -> typing.Dict[str, str]:<DEDENT>
|
return {k: cls.cast(v, k) for k, v in config.items()}<EOL>
|
Cast `config` to grouped regular expressions.
|
f9452:c2:m16
|
def get_path_pattern_list(self) -> list:
|
return []<EOL>
|
Fields / properties names (sorted) to be used when solving `path`
|
f9453:c1:m2
|
@property<EOL><INDENT>def path(self) -> Path:<DEDENT>
|
args = list(self._iter_translated_field_names(self.get_path_pattern_list()))<EOL>args.append(self.get_name())<EOL>return Path(*args)<EOL>
|
A Path for this name object joining field names from `self.get_path_pattern_list` with this object's name
|
f9453:c1:m3
|
@property<EOL><INDENT>def pipe_sep(self) -> str:<DEDENT>
|
return '<STR_LIT:.>'<EOL>
|
The string that acts as a separator of the pipe fields.
|
f9453:c2:m1
|
@property<EOL><INDENT>def pipe_name(self) -> str:<DEDENT>
|
pipe_suffix = self.pipe or rf"<STR_LIT>"<EOL>return rf'<STR_LIT>'<EOL>
|
The pipe name string of this object.
|
f9453:c2:m2
|
def main():
|
Application()<EOL>Gtk.main()<EOL>
|
Helper function. I'm using it in console_entrypoint to easy call program from cli or gui.
|
f9455:m0
|
def __init__(self, icon):
|
self.appicon = icon<EOL>self.icon = Gtk.StatusIcon()<EOL>self.icon.set_from_file(self.appicon)<EOL>self.menu = Gtk.Menu()<EOL>self.icon.connect('<STR_LIT>', self.right_click_event_statusicon)<EOL>
|
Args:
icon (str): path to initial icon that will be shown on system panel
|
f9455:c0:m0
|
def set_refresh(self, timeout, callback, *callback_args):
|
GObject.timeout_add(timeout, callback, *callback_args)<EOL>
|
It is just stub for simplify setting timeout.
Args:
timeout (int): timeout in milliseconds, after which callback will be called
callback (callable): usually, just a function that will be called each time after timeout
*callback_args (any type): arguments that will be passed to callback function
|
f9455:c0:m1
|
def set_icon(self, icon):
|
self.icon.set_from_file(icon)<EOL>
|
Set new icon in system tray.
Args:
icon (str): path to file with new icon
|
f9455:c0:m2
|
def add_menu_item(self, command, title):
|
m_item = Gtk.MenuItem()<EOL>m_item.set_label(title)<EOL>m_item.connect('<STR_LIT>', command)<EOL>self.menu.append(m_item)<EOL>self.menu.show_all()<EOL>
|
Add mouse right click menu item.
Args:
command (callable): function that will be called after left mouse click on title
title (str): label that will be shown in menu
|
f9455:c0:m3
|
def add_seperator(self):
|
m_item = Gtk.SeparatorMenuItem()<EOL>self.menu.append(m_item)<EOL>self.menu.show_all()<EOL>
|
Add separator between labels in menu that called on right mouse click.
|
f9455:c0:m4
|
def right_click_event_statusicon(self, icon, button, time):
|
def pos(menu, aicon):<EOL><INDENT>"""<STR_LIT>"""<EOL>return Gtk.StatusIcon.position_menu(menu, aicon)<EOL><DEDENT>self.menu.popup(None, None, pos, icon, button, time)<EOL>
|
It's just way how popup menu works in GTK. Don't ask me how it works.
|
f9455:c0:m5
|
def check_battery(self):
|
self.charging = False ifsubprocess.getoutput("<STR_LIT>") == '<STR_LIT>'else True<EOL>percent = subprocess.getoutput("<STR_LIT>")<EOL>if not self.charging:<EOL><INDENT>for val in self.dischlist:<EOL><INDENT>if int(percent) <= int(val):<EOL><INDENT>self.indicator.set_icon(self.dischformat.format(value=val))<EOL>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for val in self.chlist:<EOL><INDENT>if int(percent) <= int(val):<EOL><INDENT>self.indicator.set_icon(self.chformat.format(value=val))<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return True<EOL>
|
Implement how we will check battery condition. Now it just trying to check standard battery
in /sys
|
f9455:c1:m1
|
def tooltip_query(self, widget, x, y, keyboard_mode, tooltip):
|
tooltip.set_text(subprocess.getoutput("<STR_LIT>"))<EOL>return True<EOL>
|
Set tooltip which appears when you hover mouse curson onto icon in system panel.
|
f9455:c1:m2
|
def acquire(self, block=True):
|
while True:<EOL><INDENT>if self.redis.set(self.name, self.value, px=self.timeout, nx=True):<EOL><INDENT>return True<EOL><DEDENT>if not block:<EOL><INDENT>return False<EOL><DEDENT>time.sleep(self.sleep)<EOL><DEDENT>
|
Acquire lock. Blocks until acquired if `block` is `True`, otherwise returns `False` if the lock could not be acquired.
|
f9457:c0:m1
|
def refresh(self):
|
keys = [self.name]<EOL>args = [self.value, self.timeout]<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>return self._refresh_script(keys=keys, args=args) == <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>keys_and_args = keys + args<EOL>return self.redis.eval(self.lua_refresh, len(keys), *keys_and_args)<EOL><DEDENT>
|
Refresh an existing lock to prevent it from expiring.
Uses a LUA (EVAL) script to ensure only a lock which we own is being overwritten.
Returns True if refresh succeeded, False if not.
|
f9457:c0:m2
|
def who(self):
|
return self.redis.get(self.name)<EOL>
|
Returns the owner (value) of the lock or `None` if there isn't one.
|
f9457:c0:m3
|
def run(self):
|
log.info("<STR_LIT>", self.lock.who())<EOL>if self.lock.acquire():<EOL><INDENT>log.info("<STR_LIT>", self.lockname)<EOL>while True:<EOL><INDENT>if self.process is None: <EOL><INDENT>self.process = self.spawn(self.command)<EOL>log.info("<STR_LIT>", self.process.pid)<EOL><DEDENT>child_status = self.process.poll()<EOL>if child_status is not None:<EOL><INDENT>log.error("<STR_LIT>", child_status)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if not self.lock.refresh():<EOL><INDENT>who = self.lock.who()<EOL>if who is None:<EOL><INDENT>if self.lock.acquire(block=False):<EOL><INDENT>log.warning("<STR_LIT>")<EOL><DEDENT>else:<EOL><INDENT>log.error("<STR_LIT>", self.lock.who())<EOL>self.cleanup()<EOL>sys.exit(os.EX_UNAVAILABLE)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log.error("<STR_LIT>", self.lock.who())<EOL>self.cleanup()<EOL>sys.exit(os.EX_UNAVAILABLE)<EOL><DEDENT><DEDENT>time.sleep(self.sleep)<EOL><DEDENT><DEDENT>
|
Run process if nobody else is, otherwise wait until we're needed. Never returns.
|
f9457:c1:m1
|
def spawn(self, command):
|
if self.shell:<EOL><INDENT>args = command<EOL><DEDENT>else:<EOL><INDENT>args = shlex.split(command)<EOL><DEDENT>return subprocess.Popen(args, shell=self.shell)<EOL>
|
Spawn process.
|
f9457:c1:m2
|
def cleanup(self):
|
if self.process is None: <EOL><INDENT>return<EOL><DEDENT>if self.process.poll() is None:<EOL><INDENT>log.info("<STR_LIT>", self.process.pid)<EOL>self.process.terminate()<EOL>start = time.clock()<EOL>while time.clock() - start < <NUM_LIT:1.0>:<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL>if self.process.poll() is not None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log.info("<STR_LIT>", self.process.pid)<EOL>self.process.kill()<EOL><DEDENT><DEDENT>assert self.process.poll() is not None<EOL>
|
Clean up, making sure the process is stopped before we pack up and go home.
|
f9457:c1:m3
|
def handle_signal(self, sig, frame):
|
if sig in [signal.SIGINT]:<EOL><INDENT>log.warning("<STR_LIT>")<EOL><DEDENT>if sig in [signal.SIGTERM]:<EOL><INDENT>log.warning("<STR_LIT>")<EOL><DEDENT>self.cleanup()<EOL>sys.exit(-sig)<EOL>
|
Handles signals, surprisingly.
|
f9457:c1:m4
|
def crash(self):
|
self.cleanup()<EOL>
|
Handles unexpected exit, for example because Redis connection failed.
|
f9457:c1:m5
|
def scrub_string(string, replacement='<STR_LIT>'):
|
def before_record_response(response):<EOL><INDENT>response['<STR_LIT:body>']['<STR_LIT:string>'] = response['<STR_LIT:body>']['<STR_LIT:string>'].replace(string, replacement)<EOL>return response<EOL><DEDENT>return before_record_response<EOL>
|
Scrub a string from a VCR response body string
|
f9463:m25
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.