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)
