def patch_channel(self, channel_address, balance=None, state=None): if balance is not None and state is not None: return make_response( 'Can not update balance and change channel state at the same time', httplib.CONFLICT, ) elif balance is None and state is None: return make_response( 'Nothing to do. Should either provide \'balance\' or \'state\' argument', httplib.BAD_REQUEST, ) # find the channel channel = self.raiden_api.get_channel(channel_address) current_state = channel.state # if we patch with `balance` it's a deposit if balance is not None: if current_state != CHANNEL_STATE_OPENED: return make_response( "Can't deposit on a closed channel", httplib.CONFLICT, ) raiden_service_result = self.raiden_api.deposit( channel.token_address, channel.partner_address, balance) result = self.channel_schema.dump( channel_to_api_dict(raiden_service_result)) return jsonify(result.data) if state == CHANNEL_STATE_CLOSED: if current_state != CHANNEL_STATE_OPENED: return make_response( httplib.CONFLICT, 'Attempted to close an already closed channel') raiden_service_result = self.raiden_api.close( channel.token_address, channel.partner_address) result = self.channel_schema.dump( channel_to_api_dict(raiden_service_result)) return jsonify(result.data) if state == CHANNEL_STATE_SETTLED: if current_state == CHANNEL_STATE_SETTLED or current_state == CHANNEL_STATE_OPENED: return make_response( 'Attempted to settle a channel at its {} state'.format( current_state), httplib.CONFLICT, ) raiden_service_result = self.raiden_api.settle( channel.token_address, channel.partner_address) result = self.channel_schema.dump( channel_to_api_dict(raiden_service_result)) return jsonify(result.data) # should never happen, channel_state is validated in the schema return make_response( 'Provided invalid channel state {}'.format(state), httplib.BAD_REQUEST, )
def open(self, partner_address, token_address, settle_timeout=None, reveal_timeout=None, balance=None): try: raiden_service_result = self.raiden_api.open( 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: raiden_service_result = self.raiden_api.deposit( 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) result = self.channel_schema.dump( channel_to_api_dict(raiden_service_result)) return api_response(result=result.data, status_code=HTTPStatus.CREATED)
def open(self, token_address, partner_address, settle_timeout=None, reveal_timeout=None): """ Open a channel with the peer at `partner_address` with the given `token_address`. """ if reveal_timeout is None: reveal_timeout = self.raiden.config['reveal_timeout'] if settle_timeout is None: settle_timeout = self.raiden.config['settle_timeout'] if settle_timeout < self.raiden.config['settle_timeout']: raise ValueError( 'Configured minimum `settle_timeout` is {} blocks.'.format( self.raiden.config['settle_timeout'])) channel_manager = self.raiden.chain.manager_by_token( token_address.decode('hex')) token_manager = self.raiden.get_manager_by_token_address( token_address.decode('hex')) netcontract_address = channel_manager.new_netting_channel( self.raiden.address, partner_address.decode('hex'), settle_timeout, ) netting_channel = self.raiden.chain.netting_channel( netcontract_address) token_manager.register_channel(netting_channel, reveal_timeout) channel = token_manager.get_channel_by_contract_address( netcontract_address) return channel_to_api_dict(channel)
def open(self, partner_address, token_address, settle_timeout, balance=None): try: raiden_service_result = self.raiden_api.open( token_address, partner_address, settle_timeout ) except (InvalidAddress, InvalidSettleTimeout, SamePeerAddress) as e: return make_response(str(e), httplib.CONFLICT) if balance: # make initial deposit try: raiden_service_result = self.raiden_api.deposit( token_address, partner_address, balance ) except EthNodeCommunicationError as e: return make_response(str(e), httplib.REQUEST_TIMEOUT) except InsufficientFunds as e: return make_response(str(e), httplib.PAYMENT_REQUIRED) result = self.channel_schema.dump(channel_to_api_dict(raiden_service_result)) return jsonify_with_response(data=result.data, status_code=httplib.CREATED)
def settle(self, token_address, partner_address): """ Settle a closed channel with `partner_address` for the given `token_address`. """ token_address_bin = safe_address_decode(token_address) partner_address_bin = safe_address_decode(partner_address) if not isaddress( token_address_bin) or token_address_bin not in self.tokens: raise InvalidAddress('token address is not valid.') if not isaddress(partner_address_bin): raise InvalidAddress('partner_address is not valid.') manager = self.raiden.get_manager_by_token_address(token_address_bin) channel = manager.get_channel_by_partner_address(partner_address_bin) if channel.isopen: raise InvalidState('channel is still open.') netting_channel = channel.external_state.netting_channel if (self.raiden.chain.block_number() <= (channel.external_state.closed_block + netting_channel.detail(self.raiden.address)['settle_timeout'])): raise InvalidState('settlement period is not yet over.') netting_channel.settle() return channel_to_api_dict(channel)
def close(self, token_address, partner_address): """ Close a channel opened with `partner_address` for the given `token_address`. """ token_address_bin = safe_address_decode(token_address) partner_address_bin = safe_address_decode(partner_address) if not isaddress( token_address_bin) or token_address_bin not in self.tokens: raise InvalidAddress('token address is not valid.') if not isaddress(partner_address_bin): raise InvalidAddress('partner_address is not valid.') manager = self.raiden.get_manager_by_token_address(token_address_bin) channel = manager.get_channel_by_partner_address(partner_address_bin) first_transfer = None if channel.received_transfers: first_transfer = channel.received_transfers[-1] netting_channel = channel.external_state.netting_channel netting_channel.close( self.raiden.address, first_transfer, ) return channel_to_api_dict(channel)
def deposit(self, token_address, partner_address, amount): """ Deposit `amount` in the channel with the peer at `partner_address` and the given `token_address` in order to be able to do transfers. """ token_manager = self.raiden.get_manager_by_token_address( token_address.decode('hex')) channel = token_manager.get_channel_by_partner_address( partner_address.decode('hex')) netcontract_address = channel.channel_address assert len(netcontract_address) # Obtain a reference to the token and approve the amount for funding token = self.raiden.chain.token(token_address.decode('hex')) balance = token.balance_of(self.raiden.address.encode('hex')) if not balance >= amount: msg = "Not enough balance for token'{}' [{}]: have={}, need={}".format( token.proxy.name(), token_address, balance, amount) raise InsufficientFunds(msg) token.approve(netcontract_address, amount) # Obtain the netting channel and fund it by depositing the amount netting_channel = self.raiden.chain.netting_channel( netcontract_address) netting_channel.deposit(self.raiden.address, amount) return channel_to_api_dict(channel)
def deposit(self, token_address, partner_address, amount): raiden_service_result = self.raiden_api.deposit( token_address, partner_address, amount) result = self.channel_schema.dump( channel_to_api_dict(raiden_service_result)) return jsonify(result.data)
def close(self, token_address, partner_address): raiden_service_result = self.raiden_api.close(token_address, partner_address) result = self.channel_schema.dump( channel_to_api_dict(raiden_service_result)) return jsonify(result.data)
def close(self, token_address, partner_address): raiden_service_result = self.raiden_api.close( token_address, partner_address ) result = self.channel_schema.dump(channel_to_api_dict(raiden_service_result)) return api_response(result=result.data)
def test_channel_to_api_dict(): channel_address = b'\x00' * 20 token_address = b'\x01' * 20 our_address = b'\x02' * 20 partner_address = b'\x03' * 20 reveal_timeout = 10 settle_timeout = 50 opened_block = 900 our_balance = 13 partner_balance = 21 our_state = ChannelEndState( our_address, our_balance, None, EMPTY_MERKLE_TREE, ) partner_state = ChannelEndState( partner_address, partner_balance, None, EMPTY_MERKLE_TREE, ) # mock external state to provide the channel address class NettingChannel(object): address = channel_address class ExternalState(object): def __init__(self, opened_block): self.netting_channel = NettingChannel() self.settled_block = 0 self.closed_block = 0 self.opened_block = opened_block channel = Channel( our_state, partner_state, ExternalState(opened_block), token_address, reveal_timeout, settle_timeout, ) result = channel_to_api_dict(channel) expected_result = { 'channel_address': channel_address, 'token_address': token_address, 'partner_address': partner_address, 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'balance': our_balance, 'state': CHANNEL_STATE_OPENED } assert result == expected_result
def test_channel_to_api_dict(): channel_address = b'\x00' * 20 token_address = b'\x01' * 20 our_address = b'\x02' * 20 partner_address = b'\x03' * 20 reveal_timeout = 10 settle_timeout = 50 opened_block = 900 our_balance = 13 partner_balance = 21 our_state = ChannelEndState( our_address, our_balance, None, EMPTY_MERKLE_TREE, ) partner_state = ChannelEndState( partner_address, partner_balance, None, EMPTY_MERKLE_TREE, ) # mock external state to provide the channel address class NettingChannel: address = channel_address class ExternalState: def __init__(self, opened_block): self.netting_channel = NettingChannel() self.settled_block = 0 self.closed_block = 0 self.opened_block = opened_block channel = Channel( our_state, partner_state, ExternalState(opened_block), token_address, reveal_timeout, settle_timeout, ) result = channel_to_api_dict(channel) expected_result = { 'channel_address': channel_address, 'token_address': token_address, 'partner_address': partner_address, 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'balance': our_balance, 'state': CHANNEL_STATE_OPENED } assert result == expected_result
def deposit(self, token_address, partner_address, amount): try: raiden_service_result = self.raiden_api.deposit( token_address, partner_address, amount) except EthNodeCommunicationError as e: return make_response(str(e), httplib.REQUEST_TIMEOUT) result = self.channel_schema.dump( channel_to_api_dict(raiden_service_result)) return jsonify(result.data)
def _close(self, channel): if channel.state != CHANNEL_STATE_OPENED: return api_error( errors='Attempted to close an already closed channel', status_code=HTTPStatus.CONFLICT, ) raiden_service_result = self.raiden_api.close(channel.token_address, channel.partner_address) result = self.channel_schema.dump( channel_to_api_dict(raiden_service_result)) return api_response(result=result.data)
def _close(self, channel): if channel.state != CHANNEL_STATE_OPENED: return api_error( errors='Attempted to close an already closed channel', status_code=HTTPStatus.CONFLICT, ) raiden_service_result = self.raiden_api.close( channel.token_address, channel.partner_address ) result = self.channel_schema.dump(channel_to_api_dict(raiden_service_result)) return api_response(result=result.data)
def deposit(self, token_address, partner_address, amount): try: raiden_service_result = self.raiden_api.deposit( token_address, partner_address, amount) 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( channel_to_api_dict(raiden_service_result)) return api_response(result=result.data)
def test_channel_to_api_dict(raiden_network, tokens_addresses, settle_timeout): app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking channel0 = channel(app0, app1, tokens_addresses[0]) netting_address = channel0.external_state.netting_channel.address netting_channel = app0.raiden.chain.netting_channel(netting_address) result = channel_to_api_dict(channel0) expected_result = { "channel_address": bytes_to_hexstr(netting_channel.address), "token_address": bytes_to_hexstr(channel0.token_address), "partner_address": bytes_to_hexstr(app1.raiden.address), "settle_timeout": settle_timeout, "balance": channel0.contract_balance, "state": "open" } assert result == expected_result
def open(self, partner_address, token_address, settle_timeout, balance=None): raiden_service_result = self.raiden_api.open(token_address, partner_address, settle_timeout) if balance: # make initial deposit raiden_service_result = self.raiden_api.deposit( token_address, partner_address, balance) result = self.channel_schema.dump( channel_to_api_dict(raiden_service_result)) return jsonify(result.data)
def test_channel_to_api_dict(raiden_network, token_addresses, settle_timeout): app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking channel0 = channel(app0, app1, token_addresses[0]) netting_address = channel0.external_state.netting_channel.address netting_channel = app0.raiden.chain.netting_channel(netting_address) result = channel_to_api_dict(channel0) expected_result = { 'channel_address': netting_channel.address, 'token_address': channel0.token_address, 'partner_address': app1.raiden.address, 'settle_timeout': settle_timeout, 'balance': channel0.contract_balance, 'state': CHANNEL_STATE_OPENED } assert result == expected_result
def _deposit(self, channel, balance): if channel.state != CHANNEL_STATE_OPENED: return api_error( errors="Can't deposit on a closed channel", status_code=HTTPStatus.CONFLICT, ) try: raiden_service_result = self.raiden_api.deposit( channel.token_address, channel.partner_address, balance) except InsufficientFunds as e: return api_error(errors=str(e), status_code=HTTPStatus.PAYMENT_REQUIRED) result = self.channel_schema.dump( channel_to_api_dict(raiden_service_result)) return api_response(result=result.data)
def open( self, partner_address, token_address, settle_timeout=None, reveal_timeout=None, balance=None): try: raiden_service_result = self.raiden_api.open( 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: raiden_service_result = self.raiden_api.deposit( 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 ) result = self.channel_schema.dump(channel_to_api_dict(raiden_service_result)) return api_response( result=result.data, status_code=HTTPStatus.CREATED )
def _settle(self, channel): if channel.state != CHANNEL_STATE_CLOSED: return api_error( errors='Attempted to settle a channel at its {} state'.format( channel.state, ), status_code=HTTPStatus.CONFLICT, ) try: raiden_service_result = self.raiden_api.settle( channel.token_address, channel.partner_address) except InvalidState: return api_error( errors='Settlement period is not yet over', status_code=HTTPStatus.CONFLICT, ) result = self.channel_schema.dump( channel_to_api_dict(raiden_service_result)) return api_response(result=result.data)
def deposit(self, token_address, partner_address, amount): try: raiden_service_result = self.raiden_api.deposit( token_address, partner_address, amount ) 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(channel_to_api_dict(raiden_service_result)) return api_response(result=result.data)
def open(self, partner_address, token_address, settle_timeout, balance=None): try: raiden_service_result = self.raiden_api.open( token_address, partner_address, settle_timeout ) except (InvalidAddress, InvalidSettleTimeout) as e: return make_response(str(e), httplib.CONFLICT) if balance: # make initial deposit raiden_service_result = self.raiden_api.deposit( token_address, partner_address, balance ) result = self.channel_schema.dump(channel_to_api_dict(raiden_service_result)) return jsonify_with_response(data=result.data, status_code=httplib.CREATED)
def _deposit(self, channel, balance): if channel.state != CHANNEL_STATE_OPENED: return api_error( errors="Can't deposit on a closed channel", status_code=HTTPStatus.CONFLICT, ) try: raiden_service_result = self.raiden_api.deposit( channel.token_address, channel.partner_address, balance ) except InsufficientFunds as e: return api_error( errors=str(e), status_code=HTTPStatus.PAYMENT_REQUIRED ) result = self.channel_schema.dump(channel_to_api_dict(raiden_service_result)) return api_response(result=result.data)
def _settle(self, channel): if channel.state != CHANNEL_STATE_CLOSED: return api_error( errors='Attempted to settle a channel at its {} state'.format( channel.state, ), status_code=HTTPStatus.CONFLICT, ) try: raiden_service_result = self.raiden_api.settle( channel.token_address, channel.partner_address ) except InvalidState: return api_error( errors='Settlement period is not yet over', status_code=HTTPStatus.CONFLICT, ) result = self.channel_schema.dump(channel_to_api_dict(raiden_service_result)) return api_response(result=result.data)
def patch_channel(self, channel_address, balance=None, state=None): if balance is not None and state is not None: return api_error( errors='Can not update balance and change channel state at the same time', status_code=httplib.CONFLICT, ) elif balance is None and state is None: return api_error( errors="Nothing to do. Should either provide 'balance' or 'state' argument", status_code=httplib.BAD_REQUEST, ) # find the channel try: channel = self.raiden_api.get_channel(channel_address) except ChannelNotFound: return api_error( errors="Requested channel {} not found".format( address_encoder(channel_address) ), status_code=httplib.CONFLICT ) current_state = channel.state # if we patch with `balance` it's a deposit if balance is not None: if current_state != CHANNEL_STATE_OPENED: return api_error( errors="Can't deposit on a closed channel", status_code=httplib.CONFLICT, ) try: raiden_service_result = self.raiden_api.deposit( channel.token_address, channel.partner_address, balance ) except InsufficientFunds as e: return api_error( errors=str(e), status_code=httplib.PAYMENT_REQUIRED ) result = self.channel_schema.dump(channel_to_api_dict(raiden_service_result)) return api_response(result=result.data) if state == CHANNEL_STATE_CLOSED: if current_state != CHANNEL_STATE_OPENED: return api_error( errors='Attempted to close an already closed channel', status_code=httplib.CONFLICT, ) raiden_service_result = self.raiden_api.close( channel.token_address, channel.partner_address ) result = self.channel_schema.dump(channel_to_api_dict(raiden_service_result)) return api_response(result=result.data) if state == CHANNEL_STATE_SETTLED: if current_state != CHANNEL_STATE_CLOSED: return api_error( errors='Attempted to settle a channel at its ' '{} state'.format(current_state), status_code=httplib.CONFLICT, ) try: raiden_service_result = self.raiden_api.settle( channel.token_address, channel.partner_address ) except InvalidState: return api_error( errors='Settlement period is not yet over', status_code=httplib.CONFLICT, ) else: result = self.channel_schema.dump(channel_to_api_dict(raiden_service_result)) return api_response(result=result.data) # should never happen, channel_state is validated in the schema return api_error( errors='Provided invalid channel state {}'.format(state), status_code=httplib.BAD_REQUEST, )
def get_channel(self, channel_address): channel = self.raiden_api.get_channel(channel_address) result = self.channel_schema.dump(channel_to_api_dict(channel)) return api_response(result=result.data)
def get_channel(self, channel_address): channel = self.raiden_api.get_channel(channel_address) result = self.channel_schema.dump(channel_to_api_dict(channel)) return jsonify(result.data)
def get_channel(self, channel_address): channel = self.raiden_api.get_channel(channel_address) return self.channel_schema.dumps(channel_to_api_dict(channel))