def _close(self, registry_address, channel_state):
if channel.get_status(channel_state) != CHANNEL_STATE_OPENED:
return api_error(
errors='Attempted to close an already closed channel',
status_code=HTTPStatus.CONFLICT,
)
try:
self.raiden_api.channel_close(
registry_address,
channel_state.token_address,
channel_state.partner_state.address,
)
except ChannelBusyError as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.CONFLICT,
)
updated_channel_state = self.raiden_api.get_channel(
registry_address,
channel_state.identifier,
)
result = self.channel_schema.dump(
channelstate_to_api_dict(updated_channel_state))
return api_response(result=checksummed_response_dict(result.data))
def open(
self,
registry_address,
partner_address,
token_address,
settle_timeout=None,
reveal_timeout=None,
balance=None,
):
try:
self.raiden_api.channel_open(
registry_address,
token_address,
partner_address,
settle_timeout,
reveal_timeout,
)
except (InvalidAddress, InvalidSettleTimeout, SamePeerAddress,
AddressWithoutCode, NoTokenManager,
DuplicatedChannelError) as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.CONFLICT,
)
if balance:
# make initial deposit
try:
self.raiden_api.channel_deposit(
registry_address,
token_address,
partner_address,
balance,
)
except EthNodeCommunicationError as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.REQUEST_TIMEOUT,
)
except InsufficientFunds as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.PAYMENT_REQUIRED,
)
channel_state = views.get_channelstate_for(
views.state_from_raiden(self.raiden_api.raiden),
registry_address,
token_address,
partner_address,
)
result = self.channel_schema.dump(
channelstate_to_api_dict(channel_state))
return api_response(
result=checksummed_response_dict(result.data),
status_code=HTTPStatus.CREATED,
)
def _deposit(self, registry_address, channel_state, balance):
if channel.get_status(channel_state) != CHANNEL_STATE_OPENED:
return api_error(
errors="Can't deposit on a closed channel",
status_code=HTTPStatus.CONFLICT,
)
try:
self.raiden_api.channel_deposit(
registry_address,
channel_state.token_address,
channel_state.partner_state.address,
balance,
)
except ChannelBusyError as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.CONFLICT,
)
except InsufficientFunds as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.PAYMENT_REQUIRED,
)
updated_channel_state = self.raiden_api.get_channel(
registry_address,
channel_state.identifier,
)
result = self.channel_schema.dump(
channelstate_to_api_dict(updated_channel_state))
return api_response(result=checksummed_response_dict(result.data))
def deposit(self, registry_address, token_address, partner_address,
amount):
try:
raiden_service_result = self.raiden_api.channel_deposit(
registry_address,
token_address,
partner_address,
amount,
)
except ChannelBusyError as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.CONFLICT,
)
except EthNodeCommunicationError as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.REQUEST_TIMEOUT,
)
except InsufficientFunds as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.PAYMENT_REQUIRED,
)
result = self.channel_schema.dump(
channelstate_to_api_dict(raiden_service_result))
return api_response(result=checksummed_response_dict(result.data))
def close(self, token_address, partner_address):
raiden_service_result = self.raiden_api.channel_close(
token_address, partner_address)
result = self.channel_schema.dump(
channelstate_to_api_dict(raiden_service_result))
return api_response(result=result.data)
def close(self, token_address, partner_address):
try:
raiden_service_result = self.raiden_api.channel_close(
token_address, partner_address)
except ChannelBusyError as e:
return api_error(errors=str(e), status_code=HTTPStatus.CONFLICT)
result = self.channel_schema.dump(
channelstate_to_api_dict(raiden_service_result))
return api_response(result=result.data)
def _close(self, channel_state):
if channel.get_status(channel_state) != CHANNEL_STATE_OPENED:
return api_error(
errors='Attempted to close an already closed channel',
status_code=HTTPStatus.CONFLICT,
)
self.raiden_api.channel_close(channel_state.token_address,
channel_state.partner_state.address)
updated_channel_state = self.raiden_api.get_channel(
channel_state.identifier)
result = self.channel_schema.dump(
channelstate_to_api_dict(updated_channel_state))
return api_response(result=result.data)
def get_channel(self, registry_address, token_address, partner_address):
try:
channel_state = self.raiden_api.get_channel(
registry_address=registry_address,
token_address=token_address,
partner_address=partner_address,
)
result = self.channel_schema.dump(
channelstate_to_api_dict(channel_state))
return api_response(result=checksummed_response_dict(result.data))
except ChannelNotFound as e:
return api_error(
errors=str(e),
status_code=HTTPStatus.NOT_FOUND,
)
def get_channel(self, registry_address, channel_address):
channel_state = self.raiden_api.get_channel(registry_address,
channel_address)
result = self.channel_schema.dump(
channelstate_to_api_dict(channel_state))
return api_response(result=checksummed_response_dict(result.data))
def get_channel(self, channel_address):
channel_state = self.raiden_api.get_channel(channel_address)
result = self.channel_schema.dump(
channelstate_to_api_dict(channel_state))
return api_response(result=result.data)
