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)