def handle_channel_new(raiden: RaidenService, event: Event):
data = event.event_data
block_number = data['block_number']
args = data['args']
token_network_identifier = event.originating_contract
transaction_hash = event.event_data['transaction_hash']
channel_identifier = args['channel_identifier']
participant1 = args['participant1']
participant2 = args['participant2']
is_participant = raiden.address in (participant1, participant2)
# Raiden node is participant
if is_participant:
channel_proxy = raiden.chain.payment_channel(
token_network_identifier,
channel_identifier,
)
token_address = channel_proxy.token_address()
channel_state = get_channel_state(
token_address,
raiden.default_registry.address,
token_network_identifier,
raiden.config['reveal_timeout'],
channel_proxy,
block_number,
)
new_channel = ContractReceiveChannelNew(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_state=channel_state,
block_number=block_number,
)
raiden.handle_state_change(new_channel)
partner_address = channel_state.partner_state.address
if ConnectionManager.BOOTSTRAP_ADDR != partner_address:
raiden.start_health_check_for(partner_address)
# Raiden node is not participant of channel
else:
new_route = ContractReceiveRouteNew(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
participant1=participant1,
participant2=participant2,
block_number=block_number,
)
raiden.handle_state_change(new_route)
# A new channel is available, run the connection manager in case more
# connections are needed
connection_manager = raiden.connection_manager_for_token_network(
token_network_identifier)
retry_connect = gevent.spawn(connection_manager.retry_connect)
raiden.add_pending_greenlet(retry_connect)
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)
