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_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)