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_message_refundtransfer(raiden: RaidenService, message: RefundTransfer):
token_network_address = message.token_network_address
from_transfer = lockedtransfersigned_from_message(message)
chain_state = views.state_from_raiden(raiden)
routes = get_best_routes(
chain_state,
token_network_address,
raiden.address,
from_transfer.target,
from_transfer.lock.amount,
message.sender,
)
role = views.get_transfer_role(
chain_state,
from_transfer.lock.secrethash,
)
if role == 'initiator':
secret = random_secret()
state_change = ReceiveTransferRefundCancelRoute(
message.sender,
routes,
from_transfer,
secret,
)
else:
state_change = ReceiveTransferRefund(
message.sender,
from_transfer,
routes,
)
raiden.handle_state_change(state_change)
def handle_tokennetwork_new(raiden: RaidenService, event: Event):
""" Handles a `TokenNetworkCreated` event. """
data = event.event_data
args = data['args']
block_number = data['block_number']
token_network_address = args['token_network_address']
token_address = typing.TokenAddress(args['token_address'])
token_network_proxy = raiden.chain.token_network(token_network_address)
raiden.blockchain_events.add_token_network_listener(
token_network_proxy=token_network_proxy,
contract_manager=raiden.contract_manager,
from_block=block_number,
)
token_network_state = TokenNetworkState(
token_network_address,
token_address,
)
transaction_hash = event.event_data['transaction_hash']
new_token_network = ContractReceiveNewTokenNetwork(
transaction_hash=transaction_hash,
payment_network_identifier=event.originating_contract,
token_network=token_network_state,
block_number=block_number,
)
raiden.handle_state_change(new_token_network)
def handle_message_revealsecret(self, raiden: RaidenService,
message: RevealSecret):
state_change = ReceiveSecretReveal(
message.secret,
message.sender,
)
raiden.handle_state_change(state_change)
def handle_message_refundtransfer(self, raiden: RaidenService,
message: RefundTransfer):
token_network_address = message.token_network_address
from_transfer = lockedtransfersigned_from_message(message)
chain_state = views.state_from_raiden(raiden)
routes = get_best_routes(
chain_state,
token_network_address,
raiden.address,
from_transfer.target,
from_transfer.lock.amount,
message.sender,
)
role = views.get_transfer_role(
chain_state,
from_transfer.lock.secrethash,
)
if role == 'initiator':
secret = random_secret()
state_change = ReceiveTransferRefundCancelRoute(
routes=routes,
transfer=from_transfer,
secret=secret,
)
else:
state_change = ReceiveTransferRefund(
transfer=from_transfer,
routes=routes,
)
raiden.handle_state_change(state_change)
def handle_message_secret(raiden: RaidenService, message: Secret):
balance_proof = balanceproof_from_envelope(message)
state_change = ReceiveUnlock(
message_identifier=message.message_identifier,
secret=message.secret,
balance_proof=balance_proof,
)
raiden.handle_state_change(state_change)
def handle_message_secret(self, raiden: RaidenService, message: Secret):
balance_proof = balanceproof_from_envelope(message)
state_change = ReceiveUnlock(
message_identifier=message.message_identifier,
secret=message.secret,
balance_proof=balance_proof,
)
raiden.handle_state_change(state_change)
def handle_message_secretrequest(raiden: RaidenService, message: SecretRequest):
secret_request = ReceiveSecretRequest(
message.payment_identifier,
message.amount,
message.secrethash,
message.sender,
)
raiden.handle_state_change(secret_request)
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_message_lockexpired(self, raiden: RaidenService,
message: LockExpired):
balance_proof = balanceproof_from_envelope(message)
state_change = ReceiveLockExpired(
balance_proof=balance_proof,
secrethash=message.secrethash,
message_identifier=message.message_identifier,
)
raiden.handle_state_change(state_change)
def handle_message_secretrequest(raiden: RaidenService,
message: SecretRequest):
secret_request = ReceiveSecretRequest(
message.payment_identifier,
message.amount,
message.secrethash,
message.sender,
)
raiden.handle_state_change(secret_request)
def handle_message_directtransfer(raiden: RaidenService, message: DirectTransfer):
token_network_identifier = message.token_network_address
balance_proof = balanceproof_from_envelope(message)
direct_transfer = ReceiveTransferDirect(
token_network_identifier,
message.message_identifier,
message.payment_identifier,
balance_proof,
)
raiden.handle_state_change(direct_transfer)
def handle_message_directtransfer(self, raiden: RaidenService,
message: DirectTransfer):
token_network_identifier = message.token_network_address
balance_proof = balanceproof_from_envelope(message)
direct_transfer = ReceiveTransferDirect(
token_network_identifier,
message.message_identifier,
message.payment_identifier,
balance_proof,
)
raiden.handle_state_change(direct_transfer)
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_secret_revealed(raiden: RaidenService, event: Event):
secret_registry_address = event.originating_contract
data = event.event_data
args = data['args']
transaction_hash = data['transaction_hash']
registeredsecret_state_change = ContractReceiveSecretReveal(
transaction_hash=transaction_hash,
secret_registry_address=secret_registry_address,
secrethash=args['secrethash'],
secret=args['secret'],
block_number=data['block_number'],
)
raiden.handle_state_change(registeredsecret_state_change)
def handle_channel_batch_unlock(raiden: RaidenService, event: Event):
token_network_identifier = event.originating_contract
data = event.event_data
args = data['args']
transaction_hash = data['transaction_hash']
unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
participant=args['participant'],
partner=args['partner'],
locksroot=args['locksroot'],
unlocked_amount=args['unlocked_amount'],
returned_tokens=args['returned_tokens'],
block_number=data['block_number'],
)
raiden.handle_state_change(unlock_state_change)
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_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']
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=data['block_number'],
)
raiden.handle_state_change(channel_transfer_updated)
def handle_message_delivered(self, raiden: RaidenService,
message: Delivered):
delivered = ReceiveDelivered(message.sender,
message.delivered_message_identifier)
raiden.handle_state_change(delivered)
def handle_message_processed(self, raiden: RaidenService,
message: Processed):
processed = ReceiveProcessed(message.sender,
message.message_identifier)
raiden.handle_state_change(processed)
def handle_message_revealsecret(raiden: RaidenService, message: RevealSecret):
state_change = ReceiveSecretReveal(
message.secret,
message.sender,
)
raiden.handle_state_change(state_change)
def handle_message_processed(raiden: RaidenService, message: Processed):
processed = ReceiveProcessed(message.message_identifier)
raiden.handle_state_change(processed)
