def handle_channel_closed(raiden: RaidenService, event: Event):
token_network_identifier = event.originating_contract
data = event.event_data
block_number = data['block_number']
args = data['args']
channel_identifier = args['channel_identifier']
transaction_hash = data['transaction_hash']
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
# The from address is included in the ChannelClosed event as the
# closing_participant field
channel_closed = ContractReceiveChannelClosed(
transaction_hash=transaction_hash,
transaction_from=args['closing_participant'],
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
block_number=block_number,
)
raiden.handle_state_change(channel_closed)
else:
# This is a channel close event of a channel we're not a participant of
route_closed = ContractReceiveRouteClosed(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
block_number=block_number,
)
raiden.handle_state_change(route_closed)
def handle_channel_closed(raiden, event, current_block_number):
token_network_identifier = event.originating_contract
data = event.event_data
channel_identifier = data['channel_identifier']
transaction_hash = data['transactionHash']
assert transaction_hash, 'A mined transaction must have the hash field'
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
# The from address is included in the ChannelClosed event as the
# closing_participant field
channel_closed = ContractReceiveChannelClosed(
transaction_hash=transaction_hash,
transaction_from=data['closing_participant'],
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
closed_block_number=data['block_number'],
)
raiden.handle_state_change(channel_closed, current_block_number)
else:
# This is a channel close event of a channel we're not a participant of
channel_closed = ContractReceiveRouteClosed(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
)
raiden.handle_state_change(channel_closed, current_block_number)
def handle_channel_closed(raiden, event: Event):
token_network_identifier = event.originating_contract
data = event.event_data
channel_identifier = data['channel_identifier']
transaction_hash = data['transactionHash']
assert transaction_hash, 'A mined transaction must have the hash field'
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
# The from address is included in the ChannelClosed event as the
# closing_participant field
channel_closed = ContractReceiveChannelClosed(
transaction_hash=transaction_hash,
transaction_from=data['closing_participant'],
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
block_number=data['block_number'],
)
raiden.handle_state_change(channel_closed)
else:
# This is a channel close event of a channel we're not a participant of
channel_closed = ContractReceiveRouteClosed(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
block_number=data['block_number'],
)
raiden.handle_state_change(channel_closed)
def handle_channel_update_transfer(raiden: 'RaidenService', event: Event):
token_network_identifier = event.originating_contract
data = event.event_data
args = data['args']
channel_identifier = args['channel_identifier']
transaction_hash = data['transaction_hash']
block_number = data['block_number']
block_hash = data['block_hash']
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
channel_transfer_updated = ContractReceiveUpdateTransfer(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
nonce=args['nonce'],
block_number=block_number,
block_hash=block_hash,
)
raiden.handle_and_track_state_change(channel_transfer_updated)
def subdispatch_targettask(
node_state,
state_change,
token_network_identifier,
token_address,
channel_identifier,
secrethash,
):
block_number = node_state.block_number
sub_task = node_state.payment_mapping.secrethashes_to_task.get(secrethash)
if not sub_task:
is_valid_subtask = True
target_state = None
elif sub_task and isinstance(sub_task, PaymentMappingState.TargetTask):
is_valid_subtask = (token_network_identifier
== sub_task.token_network_identifier
and token_address == sub_task.token_address)
target_state = sub_task.target_state
else:
is_valid_subtask = False
events = list()
channel_state = None
if is_valid_subtask:
channel_state = views.get_channelstate_by_token_network_identifier(
node_state,
token_network_identifier,
channel_identifier,
)
if channel_state:
pseudo_random_generator = node_state.pseudo_random_generator
iteration = target.state_transition(
target_state,
state_change,
channel_state,
pseudo_random_generator,
block_number,
)
events = iteration.events
if iteration.new_state:
sub_task = PaymentMappingState.TargetTask(
token_network_identifier,
channel_identifier,
iteration.new_state,
)
node_state.payment_mapping.secrethashes_to_task[
secrethash] = sub_task
elif secrethash in node_state.payment_mapping.secrethashes_to_task:
del node_state.payment_mapping.secrethashes_to_task[secrethash]
return TransitionResult(node_state, events)
def subdispatch_targettask(
chain_state: ChainState,
state_change: StateChange,
token_network_identifier: TokenNetworkID,
channel_identifier: ChannelID,
secrethash: SecretHash,
) -> TransitionResult:
block_number = chain_state.block_number
sub_task = chain_state.payment_mapping.secrethashes_to_task.get(secrethash)
if not sub_task:
is_valid_subtask = True
target_state = None
elif sub_task and isinstance(sub_task, TargetTask):
is_valid_subtask = (
token_network_identifier == sub_task.token_network_identifier
)
target_state = sub_task.target_state
else:
is_valid_subtask = False
events = list()
channel_state = None
if is_valid_subtask:
channel_state = views.get_channelstate_by_token_network_identifier(
chain_state,
token_network_identifier,
channel_identifier,
)
if channel_state:
pseudo_random_generator = chain_state.pseudo_random_generator
iteration = target.state_transition(
target_state,
state_change,
channel_state,
pseudo_random_generator,
block_number,
)
events = iteration.events
if iteration.new_state:
sub_task = TargetTask(
token_network_identifier,
channel_identifier,
iteration.new_state,
)
chain_state.payment_mapping.secrethashes_to_task[secrethash] = sub_task
elif secrethash in chain_state.payment_mapping.secrethashes_to_task:
del chain_state.payment_mapping.secrethashes_to_task[secrethash]
return TransitionResult(chain_state, events)
def subdispatch_targettask(
chain_state: ChainState,
state_change: StateChange,
token_network_identifier: typing.TokenNetworkID,
channel_identifier: typing.ChannelID,
secrethash: typing.SecretHash,
) -> TransitionResult:
block_number = chain_state.block_number
sub_task = chain_state.payment_mapping.secrethashes_to_task.get(secrethash)
if not sub_task:
is_valid_subtask = True
target_state = None
elif sub_task and isinstance(sub_task, TargetTask):
is_valid_subtask = (
token_network_identifier == sub_task.token_network_identifier
)
target_state = sub_task.target_state
else:
is_valid_subtask = False
events = list()
channel_state = None
if is_valid_subtask:
channel_state = views.get_channelstate_by_token_network_identifier(
chain_state,
token_network_identifier,
channel_identifier,
)
if channel_state:
pseudo_random_generator = chain_state.pseudo_random_generator
iteration = target.state_transition(
target_state,
state_change,
channel_state,
pseudo_random_generator,
block_number,
)
events = iteration.events
if iteration.new_state:
sub_task = TargetTask(
token_network_identifier,
channel_identifier,
iteration.new_state,
)
chain_state.payment_mapping.secrethashes_to_task[secrethash] = sub_task
elif secrethash in chain_state.payment_mapping.secrethashes_to_task:
del chain_state.payment_mapping.secrethashes_to_task[secrethash]
return TransitionResult(chain_state, events)
def handle_channel_new_balance(raiden: RaidenService, event: Event):
data = event.event_data
args = data['args']
block_number = data['block_number']
channel_identifier = args['channel_identifier']
token_network_identifier = event.originating_contract
participant_address = args['participant']
total_deposit = args['total_deposit']
transaction_hash = data['transaction_hash']
previous_channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
# Channels will only be registered if this node is a participant
is_participant = previous_channel_state is not None
if is_participant:
assert previous_channel_state is not None
previous_balance = previous_channel_state.our_state.contract_balance
balance_was_zero = previous_balance == 0
deposit_transaction = TransactionChannelNewBalance(
participant_address,
total_deposit,
block_number,
)
newbalance_statechange = ContractReceiveChannelNewBalance(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
deposit_transaction=deposit_transaction,
block_number=block_number,
)
raiden.handle_state_change(newbalance_statechange)
if balance_was_zero and participant_address != raiden.address:
connection_manager = raiden.connection_manager_for_token_network(
token_network_identifier, )
join_channel = gevent.spawn(
connection_manager.join_channel,
participant_address,
total_deposit,
)
raiden.add_pending_greenlet(join_channel)
def handle_channel_new_balance(raiden, event: Event):
data = event.event_data
channel_identifier = data['channel_identifier']
token_network_identifier = event.originating_contract
participant_address = data['participant']
total_deposit = data['args']['total_deposit']
deposit_block_number = data['block_number']
transaction_hash = data['transactionHash']
assert transaction_hash, 'A mined transaction must have the hash field'
previous_channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
# Channels will only be registered if this node is a participant
is_participant = previous_channel_state is not None
if is_participant:
previous_balance = previous_channel_state.our_state.contract_balance
balance_was_zero = previous_balance == 0
deposit_transaction = TransactionChannelNewBalance(
participant_address,
total_deposit,
deposit_block_number,
)
newbalance_statechange = ContractReceiveChannelNewBalance(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
deposit_transaction=deposit_transaction,
block_number=data['block_number'],
)
raiden.handle_state_change(newbalance_statechange)
if balance_was_zero and participant_address != raiden.address:
connection_manager = raiden.connection_manager_for_token_network(
token_network_identifier,
)
join_channel = gevent.spawn(
connection_manager.join_channel,
participant_address,
total_deposit,
)
raiden.add_pending_greenlet(join_channel)
def handle_channel_new_balance(raiden, event, current_block_number):
data = event.event_data
channel_identifier = data['channel_identifier']
token_network_identifier = event.originating_contract
participant_address = data['participant']
total_deposit = data['args']['total_deposit']
deposit_block_number = data['block_number']
previous_channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
# Channels will only be registered if this node is a participant
is_participant = previous_channel_state is not None
if is_participant:
previous_balance = previous_channel_state.our_state.contract_balance
balance_was_zero = previous_balance == 0
deposit_transaction = TransactionChannelNewBalance(
participant_address,
total_deposit,
deposit_block_number,
)
from_address = raiden.chain.client.get_transaction_from(
event.event_data['transactionHash'], )
assert from_address, 'A mined transaction must have the from field'
newbalance_statechange = ContractReceiveChannelNewBalance(
from_address,
token_network_identifier,
channel_identifier,
deposit_transaction,
)
raiden.handle_state_change(newbalance_statechange,
current_block_number)
if balance_was_zero and participant_address != raiden.address:
connection_manager = raiden.connection_manager_for_token_network(
token_network_identifier, )
gevent.spawn(
connection_manager.join_channel,
participant_address,
total_deposit,
)
def handle_channel_settled(raiden, event, current_block_number):
data = event.event_data
token_network_identifier = event.originating_contract
channel_identifier = event.event_data['channel_identifier']
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
channel_settled = ContractReceiveChannelSettled(
token_network_identifier,
channel_identifier,
data['block_number'],
)
raiden.handle_state_change(channel_settled, current_block_number)
def handle_contract_receive_channel_closed(
chain_state: ChainState,
state_change: StateChange,
) -> TransitionResult:
# cleanup queue for channel
channel_state = views.get_channelstate_by_token_network_identifier(
chain_state=chain_state,
token_network_id=state_change.token_network_identifier,
channel_id=state_change.channel_identifier,
)
if channel_state:
queue_id = QueueIdentifier(
recipient=channel_state.partner_state.address,
channel_identifier=state_change.channel_identifier,
)
if queue_id in chain_state.queueids_to_queues:
chain_state.queueids_to_queues.pop(queue_id)
return handle_token_network_action(chain_state=chain_state, state_change=state_change)
def handle_contract_receive_channel_closed(
chain_state: ChainState,
state_change: StateChange,
) -> TransitionResult:
# cleanup queue for channel
channel_state = views.get_channelstate_by_token_network_identifier(
chain_state=chain_state,
token_network_id=state_change.token_network_identifier,
channel_id=state_change.channel_identifier,
)
if channel_state:
queue_id = QueueIdentifier(
recipient=channel_state.partner_state.address,
channel_identifier=state_change.channel_identifier,
)
if queue_id in chain_state.queueids_to_queues:
chain_state.queueids_to_queues.pop(queue_id)
return handle_token_network_action(chain_state=chain_state, state_change=state_change)
def handle_channel_closed(raiden, event, current_block_number):
token_network_identifier = event.originating_contract
data = event.event_data
channel_identifier = data['channel_identifier']
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
# The from address is included in the ChannelClosed event as the
# closing_participant field
channel_closed = ContractReceiveChannelClosed(
data['closing_participant'],
token_network_identifier,
channel_identifier,
data['block_number'],
)
raiden.handle_state_change(channel_closed, current_block_number)
def handle_channel_update_transfer(raiden, event):
token_network_identifier = event.originating_contract
data = event.event_data
channel_identifier = data['channel_identifier']
transaction_hash = data['transactionHash']
assert transaction_hash, 'A mined transaction must have the hash field'
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
channel_transfer_updated = ContractReceiveUpdateTransfer(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
nonce=data['args']['nonce'],
)
raiden.handle_state_change(channel_transfer_updated)
def handle_channel_settled(raiden: RaidenService, event: Event):
data = event.event_data
token_network_identifier = event.originating_contract
channel_identifier = data['args']['channel_identifier']
transaction_hash = data['transaction_hash']
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
channel_settled = ContractReceiveChannelSettled(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
block_number=data['block_number'],
)
raiden.handle_state_change(channel_settled)
def handle_channel_settled(raiden, event, current_block_number):
data = event.event_data
token_network_identifier = event.originating_contract
channel_identifier = event.event_data['channel_identifier']
transaction_hash = data['transactionHash']
assert transaction_hash, 'A mined transaction must have the hash field'
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
channel_settled = ContractReceiveChannelSettled(
transaction_hash,
token_network_identifier,
channel_identifier,
data['block_number'],
)
raiden.handle_state_change(channel_settled, current_block_number)
def handle_channel_update_transfer(raiden, event: Event):
token_network_identifier = event.originating_contract
data = event.event_data
channel_identifier = data['channel_identifier']
transaction_hash = data['transactionHash']
assert transaction_hash, 'A mined transaction must have the hash field'
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
channel_transfer_updated = ContractReceiveUpdateTransfer(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
nonce=data['args']['nonce'],
block_number=data['block_number'],
)
raiden.handle_state_change(channel_transfer_updated)
def handle_channel_settled(raiden, event: Event):
data = event.event_data
token_network_identifier = event.originating_contract
channel_identifier = event.event_data['channel_identifier']
transaction_hash = data['transactionHash']
assert transaction_hash, 'A mined transaction must have the hash field'
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
channel_settled = ContractReceiveChannelSettled(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
block_number=data['block_number'],
)
raiden.handle_state_change(channel_settled)
def handle_channel_settled(raiden, event, current_block_number):
data = event.event_data
token_network_identifier = event.originating_contract
channel_identifier = event.event_data['channel_identifier']
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
from_address = raiden.chain.client.get_transaction_from(
event.event_data['transactionHash'], )
assert from_address, 'A mined transaction must have the from field'
channel_settled = ContractReceiveChannelSettled(
from_address,
token_network_identifier,
channel_identifier,
data['block_number'],
)
raiden.handle_state_change(channel_settled, current_block_number)
def subdispatch_to_paymenttask(node_state, state_change, secrethash):
block_number = node_state.block_number
sub_task = node_state.payment_mapping.secrethashes_to_task.get(secrethash)
events = list()
sub_iteration = None
if sub_task:
pseudo_random_generator = node_state.pseudo_random_generator
if isinstance(sub_task, PaymentMappingState.InitiatorTask):
token_network_identifier = sub_task.token_network_identifier
token_network_state = views.get_token_network_by_identifier(
node_state,
token_network_identifier,
)
if token_network_state:
sub_iteration = initiator_manager.state_transition(
sub_task.manager_state,
state_change,
token_network_state.channelidentifiers_to_channels,
pseudo_random_generator,
block_number,
)
events = sub_iteration.events
elif isinstance(sub_task, PaymentMappingState.MediatorTask):
token_network_identifier = sub_task.token_network_identifier
token_network_state = views.get_token_network_by_identifier(
node_state,
token_network_identifier,
)
if token_network_state:
sub_iteration = mediator.state_transition(
sub_task.mediator_state,
state_change,
token_network_state.channelidentifiers_to_channels,
pseudo_random_generator,
block_number,
)
events = sub_iteration.events
elif isinstance(sub_task, PaymentMappingState.TargetTask):
token_network_identifier = sub_task.token_network_identifier
channel_identifier = sub_task.channel_identifier
token_network_state = views.get_token_network_by_identifier(
node_state,
token_network_identifier,
)
channel_state = views.get_channelstate_by_token_network_identifier(
node_state,
token_network_identifier,
channel_identifier,
)
if channel_state:
sub_iteration = target.state_transition(
sub_task.target_state,
state_change,
channel_state,
pseudo_random_generator,
block_number,
)
events = sub_iteration.events
if sub_iteration and sub_iteration.new_state is None:
del node_state.payment_mapping.secrethashes_to_task[secrethash]
return TransitionResult(node_state, events)
def subdispatch_to_paymenttask(
chain_state: ChainState,
state_change: StateChange,
secrethash: SecretHash,
) -> TransitionResult:
block_number = chain_state.block_number
sub_task = chain_state.payment_mapping.secrethashes_to_task.get(secrethash)
events = list()
sub_iteration = None
if sub_task:
pseudo_random_generator = chain_state.pseudo_random_generator
if isinstance(sub_task, InitiatorTask):
token_network_identifier = sub_task.token_network_identifier
token_network_state = views.get_token_network_by_identifier(
chain_state,
token_network_identifier,
)
if token_network_state:
sub_iteration = initiator_manager.state_transition(
sub_task.manager_state,
state_change,
token_network_state.channelidentifiers_to_channels,
pseudo_random_generator,
block_number,
)
events = sub_iteration.events
elif isinstance(sub_task, MediatorTask):
token_network_identifier = sub_task.token_network_identifier
token_network_state = views.get_token_network_by_identifier(
chain_state,
token_network_identifier,
)
if token_network_state:
sub_iteration = mediator.state_transition(
sub_task.mediator_state,
state_change,
token_network_state.channelidentifiers_to_channels,
pseudo_random_generator,
block_number,
)
events = sub_iteration.events
elif isinstance(sub_task, TargetTask):
token_network_identifier = sub_task.token_network_identifier
channel_identifier = sub_task.channel_identifier
channel_state = views.get_channelstate_by_token_network_identifier(
chain_state,
token_network_identifier,
channel_identifier,
)
if channel_state:
sub_iteration = target.state_transition(
sub_task.target_state,
state_change,
channel_state,
pseudo_random_generator,
block_number,
)
events = sub_iteration.events
if sub_iteration and sub_iteration.new_state is None:
del chain_state.payment_mapping.secrethashes_to_task[secrethash]
return TransitionResult(chain_state, events)
def subdispatch_to_paymenttask(
chain_state: ChainState,
state_change: StateChange,
secrethash: SecretHash,
) -> TransitionResult[ChainState]:
block_number = chain_state.block_number
block_hash = chain_state.block_hash
sub_task = chain_state.payment_mapping.secrethashes_to_task.get(secrethash)
events: List[Event] = list()
sub_iteration = None
if sub_task:
pseudo_random_generator = chain_state.pseudo_random_generator
if isinstance(sub_task, InitiatorTask):
token_network_identifier = sub_task.token_network_identifier
token_network_state = views.get_token_network_by_identifier(
chain_state,
token_network_identifier,
)
if token_network_state:
sub_iteration = initiator_manager.state_transition(
sub_task.manager_state,
state_change,
token_network_state.channelidentifiers_to_channels,
pseudo_random_generator,
block_number,
)
events = sub_iteration.events
elif isinstance(sub_task, MediatorTask):
token_network_identifier = sub_task.token_network_identifier
token_network_state = views.get_token_network_by_identifier(
chain_state,
token_network_identifier,
)
if token_network_state:
channelids_to_channels = token_network_state.channelidentifiers_to_channels
sub_iteration = mediator.state_transition(
mediator_state=sub_task.mediator_state,
state_change=state_change,
channelidentifiers_to_channels=channelids_to_channels,
nodeaddresses_to_networkstates=chain_state.
nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=block_number,
block_hash=block_hash,
)
events = sub_iteration.events
elif isinstance(sub_task, TargetTask):
token_network_identifier = sub_task.token_network_identifier
channel_identifier = sub_task.channel_identifier
channel_state = views.get_channelstate_by_token_network_identifier(
chain_state,
token_network_identifier,
channel_identifier,
)
if channel_state:
sub_iteration = target.state_transition(
sub_task.target_state,
state_change,
channel_state,
pseudo_random_generator,
block_number,
)
events = sub_iteration.events
if sub_iteration and sub_iteration.new_state is None:
del chain_state.payment_mapping.secrethashes_to_task[secrethash]
return TransitionResult(chain_state, events)
