Method open

raiden/api/rest.py:613–714

(
        self,
        registry_address: TokenNetworkRegistryAddress,
        partner_address: Address,
        token_address: TokenAddress,
        settle_timeout: BlockTimeout = None,
        reveal_timeout: BlockTimeout = None,
        total_deposit: TokenAmount = None,
    )

        )

    def open(
        self,
        registry_address: TokenNetworkRegistryAddress,
        partner_address: Address,
        token_address: TokenAddress,
        settle_timeout: BlockTimeout = None,
        reveal_timeout: BlockTimeout = None,
        total_deposit: TokenAmount = None,
    ) -> Response:
        log.debug(
            "Opening channel",
            node=self.checksum_address,
            registry_address=to_checksum_address(registry_address),
            partner_address=to_checksum_address(partner_address),
            token_address=to_checksum_address(token_address),
            settle_timeout=settle_timeout,
            reveal_timeout=reveal_timeout,
        )

        confirmed_block_identifier = views.get_confirmed_blockhash(self.raiden_api.raiden)
        try:
            token = self.raiden_api.raiden.proxy_manager.token(
                token_address, block_identifier=confirmed_block_identifier
            )
        except AddressWithoutCode as e:
            return api_error(errors=str(e), status_code=HTTPStatus.CONFLICT)

        balance = token.balance_of(self.raiden_api.raiden.address)

        if total_deposit is not None and total_deposit > balance:
            error_msg = "Not enough balance to deposit. {} Available={} Needed={}".format(
                to_checksum_address(token_address), balance, total_deposit
            )
            return api_error(errors=error_msg, status_code=HTTPStatus.PAYMENT_REQUIRED)

        try:
            self.raiden_api.channel_open(
                registry_address=registry_address,
                token_address=token_address,
                partner_address=partner_address,
                settle_timeout=settle_timeout,
                reveal_timeout=reveal_timeout,
            )
            status_code = HTTPStatus.CREATED
        except DuplicatedChannelError:
            # This is unlikely to happen in the wild, but it does happen in our
            # tests.

            channel_status = channel.get_status(
                self.raiden_api.get_channel(registry_address, token_address, partner_address)
            )

            if not channel_status == ChannelState.STATE_OPENED:
                return api_error(
                    errors="Channel is not in an open state.", status_code=HTTPStatus.CONFLICT
                )

            # The channel is open, just fall-through