def handle_message_revealsecret(raiden: RaidenService, message: RevealSecret): state_change = ReceiveSecretReveal( message.secret, message.sender, ) raiden.handle_and_track_state_change(state_change)
def handle_message_unlock(raiden: RaidenService, message: Unlock): balance_proof = balanceproof_from_envelope(message) state_change = ReceiveUnlock( message_identifier=message.message_identifier, secret=message.secret, balance_proof=balance_proof, ) raiden.handle_and_track_state_change(state_change)
def handle_message_lockexpired(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_and_track_state_change(state_change)
def handle_message_delivered(cls, raiden: RaidenService, message: Delivered, is_light_client: bool = False) -> None: delivered = ReceiveDelivered(message.sender, message.delivered_message_identifier) raiden.handle_and_track_state_change(delivered) if is_light_client: LightClientMessageHandler.store_lc_delivered(message, raiden.wal)
def handle_message_processed(cls, raiden: RaidenService, message: Processed, is_light_client: bool = False) -> None: processed = ReceiveProcessed(message.sender, message.message_identifier) raiden.handle_and_track_state_change(processed) if is_light_client: LightClientMessageHandler.store_lc_processed(message, raiden.wal)
def handle_message_secretrequest(raiden: RaidenService, message: SecretRequest): secret_request = ReceiveSecretRequest( message.payment_identifier, message.amount, message.expiration, message.secrethash, message.sender, ) raiden.handle_and_track_state_change(secret_request)
def handle_message_revealsecret(raiden: RaidenService, message: RevealSecret, is_light_client=False) -> None: if is_light_client: state_change = ReceiveSecretRevealLight(message.secret, message.sender, message) raiden.handle_and_track_state_change(state_change) else: state_change = ReceiveSecretReveal(message.secret, message.sender) raiden.handle_and_track_state_change(state_change)
def handle_message_secretrequest(raiden: RaidenService, message: SecretRequest, is_light_client: bool = False) -> None: if is_light_client: secret_request_light = ReceiveSecretRequestLight( message.payment_identifier, message.amount, message.expiration, message.secrethash, message.sender, message) raiden.handle_and_track_state_change(secret_request_light) else: secret_request = ReceiveSecretRequest( message.payment_identifier, message.amount, message.expiration, message.secrethash, message.sender, ) raiden.handle_and_track_state_change(secret_request)
def handle_message_unlock(raiden: RaidenService, message: Unlock, is_light_client=False) -> None: balance_proof = balanceproof_from_envelope(message) if is_light_client: state_change = ReceiveUnlockLight( message_identifier=message.message_identifier, secret=message.secret, balance_proof=balance_proof, signed_unlock=message) raiden.handle_and_track_state_change(state_change) else: state_change = ReceiveUnlock( message_identifier=message.message_identifier, secret=message.secret, balance_proof=balance_proof, ) raiden.handle_and_track_state_change(state_change)
def handle_message_refundtransfer(raiden: RaidenService, message: RefundTransfer) -> None: token_network_address = message.token_network_address from_transfer = lockedtransfersigned_from_message(message) chain_state = views.state_from_raiden(raiden) # FIXME: Shouldn't request routes here routes, _ = get_best_routes( chain_state=chain_state, token_network_id=TokenNetworkID(token_network_address), one_to_n_address=raiden.default_one_to_n_address, from_address=InitiatorAddress(raiden.address), to_address=from_transfer.target, amount=PaymentAmount( from_transfer.lock.amount), # FIXME: mypy; deprecated by #3863 previous_address=message.sender, config=raiden.config, privkey=raiden.privkey, ) role = views.get_transfer_role( chain_state=chain_state, secrethash=from_transfer.lock.secrethash) state_change: StateChange if role == "initiator": old_secret = views.get_transfer_secret( chain_state, from_transfer.lock.secrethash) # We currently don't allow multi routes if the initiator does not # hold the secret. In such case we remove all other possible routes # which allow the API call to return with with an error message. if old_secret == EMPTY_SECRET: routes = list() secret = random_secret() state_change = ReceiveTransferRefundCancelRoute( routes=routes, transfer=from_transfer, secret=secret) else: state_change = ReceiveTransferRefund(transfer=from_transfer, routes=routes) raiden.handle_and_track_state_change(state_change)
def reveal_secret_with_resolver( raiden: RaidenService, secret_request_event: SendSecretRequest) -> bool: if "resolver_endpoint" not in raiden.config: return False assert isinstance(raiden.wal, WriteAheadLog), "RaidenService has not been started" current_state = raiden.wal.state_manager.current_state task = current_state.payment_mapping.secrethashes_to_task[ secret_request_event.secrethash] token = task.target_state.transfer.token request = { "token": to_hex(token), "secrethash": to_hex(secret_request_event.secrethash), "amount": secret_request_event.amount, "payment_identifier": secret_request_event.payment_identifier, "payment_sender": to_hex(secret_request_event.recipient), "expiration": secret_request_event.expiration, "payment_recipient": to_hex(raiden.address), "reveal_timeout": raiden.config["reveal_timeout"], "settle_timeout": raiden.config["settle_timeout"], } try: response = requests.post(raiden.config["resolver_endpoint"], json=request) except requests.exceptions.RequestException: return False if response is None or response.status_code != HTTPStatus.OK: return False state_change = ReceiveSecretReveal( to_bytes(hexstr=response.json()["secret"]), secret_request_event.recipient) raiden.handle_and_track_state_change(state_change) return True
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=chain_state, token_network_id=TokenNetworkID(token_network_address), from_address=InitiatorAddress(raiden.address), to_address=from_transfer.target, amount=from_transfer.lock.amount, previous_address=message.sender, config=raiden.config, privkey=raiden.privkey, ) role = views.get_transfer_role( chain_state, from_transfer.lock.secrethash, ) state_change: StateChange 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_and_track_state_change(state_change)
def handle_message_delivered(raiden: RaidenService, message: Delivered): delivered = ReceiveDelivered(message.sender, message.delivered_message_identifier) raiden.handle_and_track_state_change(delivered)
def handle_message_processed(raiden: RaidenService, message: Processed): processed = ReceiveProcessed(message.sender, message.message_identifier) raiden.handle_and_track_state_change(processed)