def get_channel_events_raiden(
self,
token_address: typing.TokenAddress,
partner_address: typing.Address = None,
from_block: typing.BlockSpecification = None,
to_block: typing.BlockSpecification = None,
):
log.debug(
'Getting channel internal events',
token_address=to_checksum_address(token_address),
partner_address=optional_address_to_string(partner_address),
from_block=from_block,
to_block=to_block,
)
try:
raiden_service_result = self.raiden_api.get_channel_events_raiden(
token_address,
partner_address,
from_block,
to_block,
)
raiden_service_result = convert_to_serializable(raiden_service_result)
return api_response(result=normalize_events_list(raiden_service_result))
except InvalidAddress as e:
return api_error(str(e), status_code=HTTPStatus.CONFLICT)
def get_channel_events_blockchain(
self,
token_address: typing.TokenAddress,
partner_address: typing.Address = None,
from_block: typing.BlockSpecification = None,
to_block: typing.BlockSpecification = None,
):
log.debug(
'Getting channel blockchain events',
token_address=to_checksum_address(token_address),
partner_address=optional_address_to_string(partner_address),
from_block=from_block,
to_block=to_block,
)
try:
raiden_service_result = self.raiden_api.get_channel_events_blockchain(
token_address,
partner_address,
from_block,
to_block,
)
return api_response(result=normalize_events_list(raiden_service_result))
except (InvalidBlockNumberInput, InvalidAddress) as e:
return api_error(str(e), status_code=HTTPStatus.CONFLICT)
except UnknownTokenAddress as e:
return api_error(str(e), status_code=HTTPStatus.NOT_FOUND)
def get_raiden_events_payment_history_with_timestamps(
self,
token_address: typing.TokenAddress = None,
target_address: typing.Address = None,
limit: int = None,
offset: int = None,
):
log.debug(
'Getting payment history',
node=pex(self.raiden_api.address),
token_address=optional_address_to_string(token_address),
target_address=optional_address_to_string(target_address),
limit=limit,
offset=offset,
)
try:
service_result = self.raiden_api.get_raiden_events_payment_history_with_timestamps(
token_address=token_address,
target_address=target_address,
limit=limit,
offset=offset,
)
except (InvalidNumberInput, InvalidAddress) as e:
return api_error(str(e), status_code=HTTPStatus.CONFLICT)
result = []
for event in service_result:
if isinstance(event.wrapped_event, EventPaymentSentSuccess):
serialized_event = self.sent_success_payment_schema.dump(event)
elif isinstance(event.wrapped_event, EventPaymentSentFailed):
serialized_event = self.failed_payment_schema.dump(event)
elif isinstance(event.wrapped_event, EventPaymentReceivedSuccess):
serialized_event = self.received_success_payment_schema.dump(
event)
else:
log.warning(
'Unexpected event',
node=pex(self.raiden_api.address),
unexpected_event=event.wrapped_event,
)
result.append(serialized_event.data)
return api_response(result=result)
def get_payment_history(
self,
token_address: typing.TokenAddress = None,
target_address: typing.Address = None,
):
log.debug(
'Getting payment history',
token_address=optional_address_to_string(token_address),
target_address=optional_address_to_string(target_address),
)
try:
if token_address is None and target_address is None:
raiden_service_result = self.raiden_api.get_payment_history()
elif target_address is None:
raiden_service_result = self.raiden_api.get_payment_history_for_token(
token_address,
)
else:
raiden_service_result = self.raiden_api.get_payment_history_for_token_and_target(
token_address,
target_address,
)
except (InvalidBlockNumberInput, InvalidAddress) as e:
return api_error(str(e), status_code=HTTPStatus.CONFLICT)
result = []
for block_number, evt in raiden_service_result:
evt.block_number = block_number
name = type(evt).__name__
evt.event = name
if name == 'EventPaymentSentSuccess':
event = self.sent_success_payment_schema.dump(evt)
elif name == 'EventPaymentSentFailed':
event = self.failed_payment_schema.dump(evt)
elif name == 'EventPaymentReceivedSuccess':
event = self.received_success_payment_schema.dump(evt)
else:
log.warning('Unexpected event', unexpected_event=evt)
result.append(event.data)
return api_response(result=result)
def get_channel_list(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress = None,
partner_address: typing.Address = None,
):
log.debug(
"Getting channel list",
node=pex(self.raiden_api.address),
registry_address=to_checksum_address(registry_address),
token_address=optional_address_to_string(token_address),
partner_address=optional_address_to_string(partner_address),
)
raiden_service_result = self.raiden_api.get_channel_list(
registry_address, token_address, partner_address)
assert isinstance(raiden_service_result, list)
result = [
self.channel_schema.dump(channel_schema).data
for channel_schema in raiden_service_result
]
return api_response(result=result)
