@atomiqlabs/sdk 8.7.7 → 8.8.4

package/src/intermediaries/apis/IntermediaryAPI.ts

@@ -1,947 +1,963 @@
-import {RequestError} from "../../errors/RequestError";
-import {
-    FieldTypeEnum,
-    RequestSchemaResult,
-    verifySchema
-} from "../../http/paramcoders/SchemaVerifier";
-import {streamingFetchPromise} from "../../http/paramcoders/client/StreamingFetchPromise";
-import {extendAbortController, randomBytes} from "../../utils/Utils";
-import {httpGet, httpPost} from "../../http/HttpUtils";
-import {tryWithRetries} from "../../utils/RetryUtils";
-
-export type InfoHandlerResponse = {
-    envelope: string,
-    chains: {
-        [chainIdentifier: string]: {
-            address: string,
-            signature: string,
-            contractVersion?: string,
-        }
-    }
-};
-
-export enum RefundAuthorizationResponseCodes {
-    EXPIRED=20010,
-    REFUND_DATA=20000,
-    NOT_FOUND=20007,
-    PENDING=20008,
-    PAID=20006
-}
-
-export enum PaymentAuthorizationResponseCodes {
-    AUTH_DATA=10000,
-    EXPIRED=10001,
-    PAID=10002,
-    PENDING=10003,
-    ALREADY_COMMITTED=10004
-}
-
-export enum InvoiceStatusResponseCodes {
-    PAID=10000,
-    EXPIRED=10001,
-    SETTLED=10002,
-    PENDING=10003
-}
-
-export type RefundAuthorizationResponse = {
-    code: RefundAuthorizationResponseCodes.PAID,
-    msg: string,
-    data: {
-        secret?: string,
-        txId?: string
-    }
-} | {
-    code: RefundAuthorizationResponseCodes.REFUND_DATA,
-    msg: string,
-    data: {
-        address: string,
-        prefix: string,
-        timeout: string,
-        signature: string
-    }
-} | {
-    code: Exclude<RefundAuthorizationResponseCodes, RefundAuthorizationResponseCodes.PAID | RefundAuthorizationResponseCodes.REFUND_DATA>,
-    msg: string
-};
-
-export type PaymentAuthorizationResponse = {
-    code: PaymentAuthorizationResponseCodes.AUTH_DATA,
-    msg: string,
-    data: {
-        address: string,
-        data: any,
-        nonce: number,
-        prefix: string,
-        timeout: string,
-        signature: string
-    }
-} | {
-    code: Exclude<PaymentAuthorizationResponseCodes, PaymentAuthorizationResponseCodes.AUTH_DATA>,
-    msg: string
-};
-
-export type InvoiceStatusResponse = {
-    code: Exclude<InvoiceStatusResponseCodes, InvoiceStatusResponseCodes.PAID>,
-    msg: string
-} | {
-    code: InvoiceStatusResponseCodes.PAID,
-    msg: string,
-    data: {
-        data: any
-    }
-}
-
-const SwapResponseSchema = {
-    data: FieldTypeEnum.Any,
-
-    prefix: FieldTypeEnum.String,
-    timeout: FieldTypeEnum.String,
-    signature: FieldTypeEnum.String
-} as const;
-
-export type SwapInit = {
-    token: string,
-    additionalParams?: { [name: string]: any }
-}
-
-export type BaseFromBTCSwapInit = SwapInit & {
-    claimer: string,
-    amount: bigint,
-    exactOut: boolean,
-    feeRate: Promise<string>
-};
-
-export type BaseToBTCSwapInit = SwapInit & {
-    offerer: string
-};
-
-/////////////////////////
-///// To BTC
-
-const ToBTCResponseSchema = {
-    amount: FieldTypeEnum.BigInt,
-    address: FieldTypeEnum.String,
-    satsPervByte: FieldTypeEnum.BigInt,
-    networkFee: FieldTypeEnum.BigInt,
-    swapFee: FieldTypeEnum.BigInt,
-    totalFee: FieldTypeEnum.BigInt,
-    total: FieldTypeEnum.BigInt,
-    minRequiredExpiry: FieldTypeEnum.BigInt,
-    ...SwapResponseSchema
-} as const;
-
-export type ToBTCResponseType = RequestSchemaResult<typeof ToBTCResponseSchema>;
-
-export type ToBTCInit = BaseToBTCSwapInit & {
-    btcAddress: string,
-    exactIn: boolean,
-    amount: bigint,
-    confirmationTarget: number,
-    confirmations: number,
-    nonce: bigint,
-    feeRate: Promise<string>
-}
-
-/////////////////////////
-///// To BTCLN
-
-const ToBTCLNResponseSchema = {
-    maxFee: FieldTypeEnum.BigInt,
-    swapFee: FieldTypeEnum.BigInt,
-    total: FieldTypeEnum.BigInt,
-    confidence: FieldTypeEnum.Number,
-    address: FieldTypeEnum.String,
-
-    routingFeeSats: FieldTypeEnum.BigInt,
-    ...SwapResponseSchema
-} as const;
-
-export type ToBTCLNResponseType = RequestSchemaResult<typeof ToBTCLNResponseSchema>;
-
-export type ToBTCLNInit = BaseToBTCSwapInit & {
-    pr: string,
-    maxFee: bigint,
-    expiryTimestamp: bigint,
-    feeRate: Promise<string>
-};
-
-const ToBTCLNPrepareExactInSchema = {
-    amount: FieldTypeEnum.BigInt,
-    reqId: FieldTypeEnum.String
-} as const;
-
-export type ToBTCLNPrepareExactInResponseType = RequestSchemaResult<typeof ToBTCLNPrepareExactInSchema>;
-
-export type ToBTCLNPrepareExactIn = BaseToBTCSwapInit & {
-    pr: string,
-    amount: bigint,
-    maxFee: bigint,
-    expiryTimestamp: bigint
-}
-
-export type ToBTCLNInitExactIn = {
-    pr: string,
-    reqId: string,
-    feeRate: Promise<string>,
-    additionalParams?: { [name: string]: any }
-}
-
-/////////////////////////
-///// From BTC
-
-const FromBTCResponseSchema = {
-    amount: FieldTypeEnum.BigInt,
-    btcAddress: FieldTypeEnum.String,
-    address: FieldTypeEnum.String,
-    swapFee: FieldTypeEnum.BigInt,
-    total: FieldTypeEnum.BigInt,
-    confirmations: FieldTypeEnum.Number,
-    ...SwapResponseSchema
-} as const;
-
-export type FromBTCResponseType = RequestSchemaResult<typeof FromBTCResponseSchema>;
-
-export type FromBTCInit = BaseFromBTCSwapInit & {
-    sequence: bigint,
-    claimerBounty: Promise<{
-        feePerBlock: bigint,
-        safetyFactor: bigint,
-        startTimestamp: bigint,
-        addBlock: bigint,
-        addFee: bigint
-    }>
-}
-
-/////////////////////////
-///// From BTCLN
-
-const FromBTCLNResponseSchema = {
-    pr: FieldTypeEnum.String,
-    swapFee: FieldTypeEnum.BigInt,
-    total: FieldTypeEnum.BigInt,
-    intermediaryKey: FieldTypeEnum.String,
-    securityDeposit: FieldTypeEnum.BigInt
-} as const;
-
-export type FromBTCLNResponseType = RequestSchemaResult<typeof FromBTCLNResponseSchema>;
-
-export type FromBTCLNInit = BaseFromBTCSwapInit & {
-    paymentHash: Buffer,
-    description?: string,
-    descriptionHash?: Buffer
-}
-
-/////////////////////////
-///// From BTCLN Auto
-
-const FromBTCLNAutoResponseSchema = {
-    intermediaryKey: FieldTypeEnum.String,
-    pr: FieldTypeEnum.String,
-
-    btcAmountSwap: FieldTypeEnum.BigInt,
-    btcAmountGas: FieldTypeEnum.BigInt,
-
-    total: FieldTypeEnum.BigInt,
-    totalGas: FieldTypeEnum.BigInt,
-
-    totalFeeBtc: FieldTypeEnum.BigInt,
-
-    swapFeeBtc: FieldTypeEnum.BigInt,
-    swapFee: FieldTypeEnum.BigInt,
-
-    gasSwapFeeBtc: FieldTypeEnum.BigInt,
-    gasSwapFee: FieldTypeEnum.BigInt,
-
-    claimerBounty: FieldTypeEnum.BigInt
-} as const;
-
-export type FromBTCLNAutoResponseType = RequestSchemaResult<typeof FromBTCLNAutoResponseSchema>;
-
-export type FromBTCLNAutoInit = Omit<BaseFromBTCSwapInit, "feeRate"> & {
-    paymentHash: Buffer,
-    gasToken: string,
-    description?: string,
-    descriptionHash?: Buffer,
-    gasAmount?: bigint,
-    claimerBounty?: Promise<bigint>
-}
-
-/////////////////////////
-///// Spv vault from BTC
-
-const SpvFromBTCPrepareResponseSchema = {
-    quoteId: FieldTypeEnum.String,
-    expiry: FieldTypeEnum.Number,
-
-    address: FieldTypeEnum.String,
-    vaultId: FieldTypeEnum.BigInt,
-
-    vaultBtcAddress: FieldTypeEnum.String,
-    btcAddress: FieldTypeEnum.String,
-    btcUtxo: FieldTypeEnum.String,
-    btcFeeRate: FieldTypeEnum.Number,
-
-    btcAmount: FieldTypeEnum.BigInt,
-    btcAmountSwap: FieldTypeEnum.BigInt,
-    btcAmountGas: FieldTypeEnum.BigInt,
-
-    total: FieldTypeEnum.BigInt,
-    totalGas: FieldTypeEnum.BigInt,
-
-    totalFeeBtc: FieldTypeEnum.BigInt,
-
-    swapFeeBtc: FieldTypeEnum.BigInt,
-    swapFee: FieldTypeEnum.BigInt,
-
-    gasSwapFeeBtc: FieldTypeEnum.BigInt,
-    gasSwapFee: FieldTypeEnum.BigInt,
-
-    callerFeeShare: FieldTypeEnum.BigInt,
-    frontingFeeShare: FieldTypeEnum.BigInt,
-    executionFeeShare: FieldTypeEnum.BigInt
-} as const;
-
-export type SpvFromBTCPrepareResponseType = RequestSchemaResult<typeof SpvFromBTCPrepareResponseSchema>;
-
-export type SpvFromBTCPrepare = SwapInit & {
-    address: string,
-    amount: bigint,
-    gasAmount: bigint,
-    gasToken: string,
-    exactOut: boolean,
-    callerFeeRate: Promise<bigint>,
-    frontingFeeRate: bigint,
-    stickyAddress?: boolean
-}
-
-const SpvFromBTCInitResponseSchema = {
-    txId: FieldTypeEnum.String
-} as const;
-
-export type SpvFromBTCInitResponseType = RequestSchemaResult<typeof SpvFromBTCInitResponseSchema>;
-
-export type SpvFromBTCInit = {
-    quoteId: string,
-    psbtHex: string
-}
-
-export class IntermediaryAPI {
-
-    /**
-     * Returns the information about a specific intermediary
-     *
-     * @param baseUrl Base URL of the intermediary
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     * @throws {Error} If the supplied nonce doesn't match the response
-     */
-    static async getIntermediaryInfo(
-        baseUrl: string,
-        timeout?: number,
-        abortSignal?: AbortSignal
-    ): Promise<InfoHandlerResponse> {
-        const nonce = randomBytes(32).toString("hex");
-
-        const abortController = extendAbortController(abortSignal);
-
-        //We don't know whether the node supports only POST or also has GET info support enabled
-        // here we try both, and abort when the first one returns (which should be GET)
-        const response = await Promise.any([
-            httpGet<InfoHandlerResponse>(baseUrl+"/info?nonce="+nonce, timeout, abortController.signal),
-            httpPost<InfoHandlerResponse>(baseUrl+"/info", {
-                nonce,
-            }, timeout, abortController.signal)
-        ]);
-        abortController.abort();
-
-        const info = JSON.parse(response.envelope);
-        if(nonce!==info.nonce) throw new Error("Invalid response - nonce");
-
-        return response;
-    }
-
-    /**
-     * Returns the information about an outcome of the To BTC swap
-     *
-     * @param url URL of the intermediary
-     * @param paymentHash Payment hash of the swap
-     * @param sequence Swap's sequence number
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     */
-    static async getRefundAuthorization(
-        url: string,
-        paymentHash: string,
-        sequence: bigint,
-        timeout?: number,
-        abortSignal?: AbortSignal
-    ): Promise<RefundAuthorizationResponse> {
-        return tryWithRetries(() => httpGet<RefundAuthorizationResponse>(
-            url + "/getRefundAuthorization"+
-                "?paymentHash=" + encodeURIComponent(paymentHash) +
-                "&sequence=" + encodeURIComponent(sequence.toString(10)),
-            timeout,
-            abortSignal
-        ), undefined, RequestError, abortSignal);
-    }
-
-    /**
-     * Returns the information about the payment of the From BTCLN swaps
-     *
-     * @param url URL of the intermediary
-     * @param paymentHash Payment hash of the swap
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     */
-    static async getPaymentAuthorization(
-        url: string,
-        paymentHash: string,
-        timeout?: number,
-        abortSignal?: AbortSignal
-    ): Promise<PaymentAuthorizationResponse> {
-        return tryWithRetries(() => httpGet<PaymentAuthorizationResponse>(
-            url+"/getInvoicePaymentAuth"+
-                "?paymentHash="+encodeURIComponent(paymentHash),
-            timeout,
-            abortSignal
-        ), undefined, RequestError, abortSignal);
-    }
-
-    /**
-     * Returns the status of the payment of the From BTCLN swaps
-     *
-     * @param url URL of the intermediary
-     * @param paymentHash Payment hash of the swap
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     */
-    static async getInvoiceStatus(
-        url: string,
-        paymentHash: string,
-        timeout?: number,
-        abortSignal?: AbortSignal
-    ): Promise<InvoiceStatusResponse> {
-        return tryWithRetries(() => httpGet<InvoiceStatusResponse>(
-            url+"/getInvoiceStatus"+
-            "?paymentHash="+encodeURIComponent(paymentHash),
-            timeout,
-            abortSignal
-        ), undefined, RequestError, abortSignal);
-    }
-
-    /**
-     * Initiate To BTC swap with an intermediary
-     *
-     * @param chainIdentifier
-     * @param baseUrl Base URL of the intermediary
-     * @param init Swap initialization parameters
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     */
-    static initToBTC(
-        chainIdentifier: string,
-        baseUrl: string,
-        init: ToBTCInit,
-        timeout?: number,
-        abortSignal?: AbortSignal,
-        streamRequest?: boolean
-    ): {
-        signDataPrefetch: Promise<any>,
-        response: Promise<ToBTCResponseType>
-    } {
-        const responseBodyPromise = streamingFetchPromise(baseUrl+"/tobtc/payInvoice?chain="+encodeURIComponent(chainIdentifier), {
-            ...init.additionalParams,
-            address: init.btcAddress,
-            amount: init.amount.toString(10),
-            exactIn: init.exactIn,
-            confirmationTarget: init.confirmationTarget,
-            confirmations: init.confirmations,
-            nonce: init.nonce.toString(10),
-            token: init.token,
-            offerer: init.offerer,
-            feeRate: init.feeRate
-        }, {
-            code: FieldTypeEnum.Number,
-            msg: FieldTypeEnum.String,
-            data: FieldTypeEnum.AnyOptional,
-            signDataPrefetch: FieldTypeEnum.AnyOptional
-        }, timeout, abortSignal, streamRequest);
-
-        return {
-            signDataPrefetch: responseBodyPromise.then(responseBody => responseBody.signDataPrefetch),
-            response: responseBodyPromise.then((responseBody) => Promise.all([
-                responseBody.code,
-                responseBody.msg,
-                responseBody.data,
-            ])).then(([code, msg, data]) => {
-                if(code!==20000) {
-                    throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
-                }
-                const result = verifySchema(data, ToBTCResponseSchema);
-                if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
-                return result;
-            })
-        };
-    }
-
-    /**
-     * Initiate From BTC swap with an intermediary
-     *
-     * @param chainIdentifier
-     * @param baseUrl Base URL of the intermediary
-     * @param depositToken
-     * @param init Swap initialization parameters
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     */
-    static initFromBTC(
-        chainIdentifier: string,
-        baseUrl: string,
-        depositToken: string,
-        init: FromBTCInit,
-        timeout?: number,
-        abortSignal?: AbortSignal,
-        streamRequest?: boolean
-    ): {
-        signDataPrefetch: Promise<any>,
-        response: Promise<FromBTCResponseType>
-    } {
-        const responseBodyPromise = streamingFetchPromise(
-            baseUrl+"/frombtc/getAddress?chain="+encodeURIComponent(chainIdentifier)+"&depositToken="+encodeURIComponent(depositToken),
-            {
-                ...init.additionalParams,
-                address: init.claimer,
-                amount: init.amount.toString(10),
-                token: init.token,
-
-                exactOut: init.exactOut,
-                sequence: init.sequence.toString(10),
-
-                claimerBounty: init.claimerBounty.then(claimerBounty => {
-                    return {
-                        feePerBlock: claimerBounty.feePerBlock.toString(10),
-                        safetyFactor: claimerBounty.safetyFactor.toString(10),
-                        startTimestamp: claimerBounty.startTimestamp.toString(10),
-                        addBlock: claimerBounty.addBlock.toString(10),
-                        addFee: claimerBounty.addFee.toString(10)
-                    }
-                }),
-                feeRate: init.feeRate
-            },
-            {
-                code: FieldTypeEnum.Number,
-                msg: FieldTypeEnum.String,
-                data: FieldTypeEnum.AnyOptional,
-                signDataPrefetch: FieldTypeEnum.AnyOptional
-            },
-            timeout, abortSignal, streamRequest
-        );
-
-        return {
-            signDataPrefetch: responseBodyPromise.then(responseBody => responseBody.signDataPrefetch),
-            response: responseBodyPromise.then((responseBody) => Promise.all([
-                responseBody.code,
-                responseBody.msg,
-                responseBody.data,
-            ])).then(([code, msg, data]) => {
-                if(code!==20000) {
-                    throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
-                }
-                const result = verifySchema(data, FromBTCResponseSchema);
-                if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
-                return result;
-            })
-        };
-    }
-
-    /**
-     * Initiate From BTCLN swap with an intermediary
-     *
-     * @param chainIdentifier
-     * @param baseUrl Base URL of the intermediary
-     * @param depositToken
-     * @param init Swap initialization parameters
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     */
-    static initFromBTCLN(
-        chainIdentifier: string,
-        baseUrl: string,
-        depositToken: string,
-        init: FromBTCLNInit,
-        timeout?: number,
-        abortSignal?: AbortSignal,
-        streamRequest?: boolean
-    ): {
-        lnPublicKey: Promise<string | null>,
-        response: Promise<FromBTCLNResponseType>
-    } {
-        const responseBodyPromise = streamingFetchPromise(
-            baseUrl+"/frombtcln/createInvoice?chain="+encodeURIComponent(chainIdentifier)+"&depositToken="+encodeURIComponent(depositToken),
-            {
-                ...init.additionalParams,
-                paymentHash: init.paymentHash.toString("hex"),
-                amount: init.amount.toString(),
-                address: init.claimer,
-                token: init.token,
-                description: init.description ?? null,
-                descriptionHash: init.descriptionHash==null ? null : init.descriptionHash.toString("hex"),
-                exactOut: init.exactOut,
-                feeRate: init.feeRate
-            },
-            {
-                code: FieldTypeEnum.Number,
-                msg: FieldTypeEnum.String,
-                data: FieldTypeEnum.AnyOptional,
-                lnPublicKey: FieldTypeEnum.StringOptional
-            },
-            timeout, abortSignal, streamRequest
-        );
-
-        return {
-            lnPublicKey: responseBodyPromise.then(responseBody => responseBody.lnPublicKey),
-            response: responseBodyPromise.then((responseBody) => Promise.all([
-                responseBody.code,
-                responseBody.msg,
-                responseBody.data,
-            ])).then(([code, msg, data]) => {
-                if(code!==20000) {
-                    throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
-                }
-                const result = verifySchema(data, FromBTCLNResponseSchema);
-                if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
-                return result;
-            })
-        };
-    }
-
-    /**
-     * Initiate From BTCLN swap with auto-initilization by an intermediary
-     *
-     * @param chainIdentifier
-     * @param baseUrl Base URL of the intermediary
-     * @param init Swap initialization parameters
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     */
-    static initFromBTCLNAuto(
-        chainIdentifier: string,
-        baseUrl: string,
-        init: FromBTCLNAutoInit,
-        timeout?: number,
-        abortSignal?: AbortSignal,
-        streamRequest?: boolean
-    ): {
-        lnPublicKey: Promise<string | null>,
-        response: Promise<FromBTCLNAutoResponseType>
-    } {
-        const responseBodyPromise = streamingFetchPromise(
-            baseUrl+"/frombtcln_auto/createInvoice?chain="+encodeURIComponent(chainIdentifier),
-            {
-                ...init.additionalParams,
-                paymentHash: init.paymentHash.toString("hex"),
-                amount: init.amount.toString(),
-                address: init.claimer,
-                token: init.token,
-                description: init.description ?? null,
-                descriptionHash: init.descriptionHash==null ? null : init.descriptionHash.toString("hex"),
-                exactOut: init.exactOut,
-                gasToken: init.gasToken,
-                gasAmount: init.gasAmount?.toString(10) ?? "0",
-                claimerBounty: init.claimerBounty?.then(val => val.toString(10)) ?? "0"
-            },
-            {
-                code: FieldTypeEnum.Number,
-                msg: FieldTypeEnum.String,
-                data: FieldTypeEnum.AnyOptional,
-                lnPublicKey: FieldTypeEnum.StringOptional
-            },
-            timeout, abortSignal, streamRequest
-        );
-
-        return {
-            lnPublicKey: responseBodyPromise.then(responseBody => responseBody.lnPublicKey),
-            response: responseBodyPromise.then((responseBody) => Promise.all([
-                responseBody.code,
-                responseBody.msg,
-                responseBody.data,
-            ])).then(([code, msg, data]) => {
-                if(code!==20000) {
-                    throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
-                }
-                const result = verifySchema(data, FromBTCLNAutoResponseSchema);
-                if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
-                return result;
-            })
-        };
-    }
-
-    /**
-     * Initiate To BTCLN swap with an intermediary
-     *
-     * @param chainIdentifier
-     * @param baseUrl Base URL of the intermediary
-     * @param init Swap initialization parameters
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     */
-    static initToBTCLN(
-        chainIdentifier: string,
-        baseUrl: string,
-        init: ToBTCLNInit,
-        timeout?: number,
-        abortSignal?: AbortSignal,
-        streamRequest?: boolean
-    ): {
-        signDataPrefetch: Promise<any>,
-        response: Promise<ToBTCLNResponseType>
-    } {
-        const responseBodyPromise = streamingFetchPromise(baseUrl+"/tobtcln/payInvoice?chain="+encodeURIComponent(chainIdentifier), {
-            exactIn: false,
-            ...init.additionalParams,
-            pr: init.pr,
-            maxFee: init.maxFee.toString(10),
-            expiryTimestamp: init.expiryTimestamp.toString(10),
-            token: init.token,
-            offerer: init.offerer,
-            feeRate: init.feeRate,
-            amount: null
-        }, {
-            code: FieldTypeEnum.Number,
-            msg: FieldTypeEnum.String,
-            data: FieldTypeEnum.AnyOptional,
-            signDataPrefetch: FieldTypeEnum.AnyOptional
-        }, timeout, abortSignal, streamRequest);
-
-        return {
-            signDataPrefetch: responseBodyPromise.then(responseBody => responseBody.signDataPrefetch),
-            response: responseBodyPromise.then((responseBody) => Promise.all([
-                responseBody.code,
-                responseBody.msg,
-                responseBody.data,
-            ])).then(([code, msg, data]) => {
-                if(code!==20000) {
-                    throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
-                }
-                const result = verifySchema(data, ToBTCLNResponseSchema);
-                if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
-                return result;
-            })
-        };
-    }
-
-    /**
-     * Initiate To BTCLN exact in swap with an intermediary
-     *
-     * @param baseUrl Base URL of the intermediary
-     * @param init Swap initialization parameters
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     */
-    static async initToBTCLNExactIn(
-        baseUrl: string,
-        init: ToBTCLNInitExactIn,
-        timeout?: number,
-        abortSignal?: AbortSignal,
-        streamRequest?: boolean
-    ): Promise<ToBTCLNResponseType> {
-        const responseBody = await streamingFetchPromise(baseUrl+"/tobtcln/payInvoiceExactIn", {
-            ...init.additionalParams,
-            pr: init.pr,
-            reqId: init.reqId,
-            feeRate: init.feeRate
-        }, {
-            code: FieldTypeEnum.Number,
-            msg: FieldTypeEnum.String,
-            data: FieldTypeEnum.AnyOptional
-        }, timeout, abortSignal, streamRequest);
-
-        const [code, msg, data] = await Promise.all([
-            responseBody.code,
-            responseBody.msg,
-            responseBody.data,
-        ])
-
-        if(code!==20000) throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
-        const result = verifySchema(data, ToBTCLNResponseSchema);
-        if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
-        return result;
-    }
-
-    /**
-     * Prepare To BTCLN exact in swap with an intermediary
-     *
-     * @param chainIdentifier
-     * @param baseUrl Base URL of the intermediary
-     * @param init Swap initialization parameters
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     */
-    static prepareToBTCLNExactIn(
-        chainIdentifier: string,
-        baseUrl: string,
-        init: ToBTCLNPrepareExactIn,
-        timeout?: number,
-        abortSignal?: AbortSignal,
-        streamRequest?: boolean
-    ): {
-        signDataPrefetch: Promise<any>,
-        response: Promise<ToBTCLNPrepareExactInResponseType>
-    } {
-        const responseBodyPromise = streamingFetchPromise(baseUrl+"/tobtcln/payInvoice?chain="+encodeURIComponent(chainIdentifier), {
-            exactIn: true,
-            ...init.additionalParams,
-            pr: init.pr,
-            maxFee: init.maxFee.toString(10),
-            expiryTimestamp: init.expiryTimestamp.toString(10),
-            token: init.token,
-            offerer: init.offerer,
-            amount: init.amount.toString(10)
-        }, {
-            code: FieldTypeEnum.Number,
-            msg: FieldTypeEnum.String,
-            data: FieldTypeEnum.AnyOptional,
-            signDataPrefetch: FieldTypeEnum.AnyOptional
-        }, timeout, abortSignal, streamRequest);
-
-        return {
-            signDataPrefetch: responseBodyPromise.then(responseBody => responseBody.signDataPrefetch),
-            response: responseBodyPromise.then((responseBody) => Promise.all([
-                responseBody.code,
-                responseBody.msg,
-                responseBody.data,
-            ])).then(([code, msg, data]) => {
-                if(code!==20000) {
-                    throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
-                }
-                const result = verifySchema(data, ToBTCLNPrepareExactInSchema);
-                if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
-                return result;
-            })
-        };
-    }
-
-    /**
-     * Prepare From BTC swap via new spv vault swaps with an intermediary
-     *
-     * @param chainIdentifier
-     * @param baseUrl Base URL of the intermediary
-     * @param init Swap initialization parameters
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     */
-    static prepareSpvFromBTC(
-        chainIdentifier: string,
-        baseUrl: string,
-        init: SpvFromBTCPrepare,
-        timeout?: number,
-        abortSignal?: AbortSignal,
-        streamRequest?: boolean
-    ): Promise<SpvFromBTCPrepareResponseType> {
-        const responseBodyPromise = streamingFetchPromise(baseUrl+"/frombtc_spv/getQuote?chain="+encodeURIComponent(chainIdentifier), {
-            exactOut: init.exactOut,
-            ...init.additionalParams,
-            address: init.address,
-            amount: init.amount.toString(10),
-            token: init.token,
-            gasAmount: init.gasAmount.toString(10),
-            gasToken: init.gasToken,
-            frontingFeeRate: init.frontingFeeRate.toString(10),
-            callerFeeRate: init.callerFeeRate.then(val => val.toString(10)),
-            stickyAddress: init.stickyAddress
-        }, {
-            code: FieldTypeEnum.Number,
-            msg: FieldTypeEnum.String,
-            data: FieldTypeEnum.AnyOptional
-        }, timeout, abortSignal, streamRequest);
-
-        return responseBodyPromise.then((responseBody) => Promise.all([
-            responseBody.code,
-            responseBody.msg,
-            responseBody.data,
-        ])).then(([code, msg, data]) => {
-            if(code!==20000) {
-                throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
-            }
-            const result = verifySchema(data, SpvFromBTCPrepareResponseSchema);
-            if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
-            return result;
-        });
-    }
-
-    /**
-     * Prepare From BTC swap via new spv vault swaps with an intermediary
-     *
-     * @param chainIdentifier
-     * @param url
-     * @param init Swap initialization parameters
-     * @param timeout Timeout in milliseconds for the HTTP request
-     * @param abortSignal
-     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
-     *
-     * @throws {RequestError} If non-200 http response code is returned
-     */
-    static initSpvFromBTC(
-        chainIdentifier: string,
-        url: string,
-        init: SpvFromBTCInit,
-        timeout?: number,
-        abortSignal?: AbortSignal,
-        streamRequest?: boolean
-    ): Promise<SpvFromBTCInitResponseType> {
-        const responseBodyPromise = streamingFetchPromise(url+"/postQuote?chain="+encodeURIComponent(chainIdentifier), {
-            quoteId: init.quoteId,
-            psbtHex: init.psbtHex
-        }, {
-            code: FieldTypeEnum.Number,
-            msg: FieldTypeEnum.String,
-            data: FieldTypeEnum.AnyOptional
-        }, timeout, abortSignal, streamRequest);
-
-        return responseBodyPromise.then((responseBody) => Promise.all([
-            responseBody.code,
-            responseBody.msg,
-            responseBody.data,
-        ])).then(([code, msg, data]) => {
-            if(code!==20000) {
-                throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
-            }
-            const result = verifySchema(data, SpvFromBTCInitResponseSchema);
-            if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
-            return result;
-        });
-    }
-
-}
+import {RequestError} from "../../errors/RequestError";
+import {
+    FieldTypeEnum,
+    RequestSchemaResult,
+    verifySchema
+} from "../../http/paramcoders/SchemaVerifier";
+import {streamingFetchPromise} from "../../http/paramcoders/client/StreamingFetchPromise";
+import {extendAbortController, randomBytes} from "../../utils/Utils";
+import {httpGet, httpPost} from "../../http/HttpUtils";
+import {tryWithRetries} from "../../utils/RetryUtils";
+
+export type InfoHandlerResponse = {
+    envelope: string,
+    chains: {
+        [chainIdentifier: string]: {
+            address: string,
+            signature: string,
+            contractVersion?: string,
+        }
+    }
+};
+
+export enum RefundAuthorizationResponseCodes {
+    EXPIRED=20010,
+    REFUND_DATA=20000,
+    NOT_FOUND=20007,
+    PENDING=20008,
+    PAID=20006
+}
+
+export enum PaymentAuthorizationResponseCodes {
+    AUTH_DATA=10000,
+    EXPIRED=10001,
+    PAID=10002,
+    PENDING=10003,
+    ALREADY_COMMITTED=10004
+}
+
+export enum InvoiceStatusResponseCodes {
+    PAID=10000,
+    EXPIRED=10001,
+    SETTLED=10002,
+    PENDING=10003
+}
+
+export type RefundAuthorizationResponse = {
+    code: RefundAuthorizationResponseCodes.PAID,
+    msg: string,
+    data: {
+        secret?: string,
+        txId?: string
+    }
+} | {
+    code: RefundAuthorizationResponseCodes.REFUND_DATA,
+    msg: string,
+    data: {
+        address: string,
+        prefix: string,
+        timeout: string,
+        signature: string
+    }
+} | {
+    code: Exclude<RefundAuthorizationResponseCodes, RefundAuthorizationResponseCodes.PAID | RefundAuthorizationResponseCodes.REFUND_DATA>,
+    msg: string
+};
+
+export type PaymentAuthorizationResponse = {
+    code: PaymentAuthorizationResponseCodes.AUTH_DATA,
+    msg: string,
+    data: {
+        address: string,
+        data: any,
+        nonce: number,
+        prefix: string,
+        timeout: string,
+        signature: string
+    }
+} | {
+    code: Exclude<PaymentAuthorizationResponseCodes, PaymentAuthorizationResponseCodes.AUTH_DATA>,
+    msg: string
+};
+
+export type InvoiceStatusResponse = {
+    code: Exclude<InvoiceStatusResponseCodes, InvoiceStatusResponseCodes.PAID>,
+    msg: string
+} | {
+    code: InvoiceStatusResponseCodes.PAID,
+    msg: string,
+    data: {
+        data: any
+    }
+}
+
+const SwapResponseSchema = {
+    data: FieldTypeEnum.Any,
+
+    prefix: FieldTypeEnum.String,
+    timeout: FieldTypeEnum.String,
+    signature: FieldTypeEnum.String
+} as const;
+
+export type SwapInit = {
+    token: string,
+    additionalParams?: { [name: string]: any }
+}
+
+export type BaseFromBTCSwapInit = SwapInit & {
+    claimer: string,
+    amount: bigint,
+    exactOut: boolean,
+    feeRate: Promise<string>
+};
+
+export type BaseToBTCSwapInit = SwapInit & {
+    offerer: string
+};
+
+/////////////////////////
+///// To BTC
+
+const ToBTCResponseSchema = {
+    amount: FieldTypeEnum.BigInt,
+    address: FieldTypeEnum.String,
+    satsPervByte: FieldTypeEnum.BigInt,
+    networkFee: FieldTypeEnum.BigInt,
+    swapFee: FieldTypeEnum.BigInt,
+    totalFee: FieldTypeEnum.BigInt,
+    total: FieldTypeEnum.BigInt,
+    minRequiredExpiry: FieldTypeEnum.BigInt,
+    ...SwapResponseSchema
+} as const;
+
+export type ToBTCResponseType = RequestSchemaResult<typeof ToBTCResponseSchema>;
+
+export type ToBTCInit = BaseToBTCSwapInit & {
+    btcAddress: string,
+    exactIn: boolean,
+    amount: bigint,
+    confirmationTarget: number,
+    confirmations: number,
+    nonce: bigint,
+    feeRate: Promise<string>
+}
+
+/////////////////////////
+///// To BTCLN
+
+const ToBTCLNResponseSchema = {
+    maxFee: FieldTypeEnum.BigInt,
+    swapFee: FieldTypeEnum.BigInt,
+    total: FieldTypeEnum.BigInt,
+    confidence: FieldTypeEnum.Number,
+    address: FieldTypeEnum.String,
+
+    routingFeeSats: FieldTypeEnum.BigInt,
+    ...SwapResponseSchema
+} as const;
+
+export type ToBTCLNResponseType = RequestSchemaResult<typeof ToBTCLNResponseSchema>;
+
+export type ToBTCLNInit = BaseToBTCSwapInit & {
+    pr: string,
+    maxFee: bigint,
+    expiryTimestamp: bigint,
+    feeRate: Promise<string>
+};
+
+const ToBTCLNPrepareExactInSchema = {
+    amount: FieldTypeEnum.BigInt,
+    reqId: FieldTypeEnum.String
+} as const;
+
+export type ToBTCLNPrepareExactInResponseType = RequestSchemaResult<typeof ToBTCLNPrepareExactInSchema>;
+
+export type ToBTCLNPrepareExactIn = BaseToBTCSwapInit & {
+    pr: string,
+    amount: bigint,
+    maxFee: bigint,
+    expiryTimestamp: bigint
+}
+
+export type ToBTCLNInitExactIn = {
+    pr: string,
+    reqId: string,
+    feeRate: Promise<string>,
+    additionalParams?: { [name: string]: any }
+}
+
+/////////////////////////
+///// From BTC
+
+const FromBTCResponseSchema = {
+    amount: FieldTypeEnum.BigInt,
+    btcAddress: FieldTypeEnum.String,
+    address: FieldTypeEnum.String,
+    swapFee: FieldTypeEnum.BigInt,
+    total: FieldTypeEnum.BigInt,
+    confirmations: FieldTypeEnum.Number,
+    ...SwapResponseSchema
+} as const;
+
+export type FromBTCResponseType = RequestSchemaResult<typeof FromBTCResponseSchema>;
+
+export type FromBTCInit = BaseFromBTCSwapInit & {
+    sequence: bigint,
+    claimerBounty: Promise<{
+        feePerBlock: bigint,
+        safetyFactor: bigint,
+        startTimestamp: bigint,
+        addBlock: bigint,
+        addFee: bigint
+    }>
+}
+
+/////////////////////////
+///// From BTCLN
+
+const FromBTCLNResponseSchema = {
+    pr: FieldTypeEnum.String,
+    swapFee: FieldTypeEnum.BigInt,
+    total: FieldTypeEnum.BigInt,
+    intermediaryKey: FieldTypeEnum.String,
+    securityDeposit: FieldTypeEnum.BigInt
+} as const;
+
+export type FromBTCLNResponseType = RequestSchemaResult<typeof FromBTCLNResponseSchema>;
+
+export type FromBTCLNInit = BaseFromBTCSwapInit & {
+    paymentHash: Buffer,
+    description?: string,
+    descriptionHash?: Buffer
+}
+
+/////////////////////////
+///// From BTCLN Auto
+
+const FromBTCLNAutoResponseSchema = {
+    intermediaryKey: FieldTypeEnum.String,
+    pr: FieldTypeEnum.String,
+
+    btcAmountSwap: FieldTypeEnum.BigInt,
+    btcAmountGas: FieldTypeEnum.BigInt,
+
+    total: FieldTypeEnum.BigInt,
+    totalGas: FieldTypeEnum.BigInt,
+
+    totalFeeBtc: FieldTypeEnum.BigInt,
+
+    swapFeeBtc: FieldTypeEnum.BigInt,
+    swapFee: FieldTypeEnum.BigInt,
+
+    gasSwapFeeBtc: FieldTypeEnum.BigInt,
+    gasSwapFee: FieldTypeEnum.BigInt,
+
+    claimerBounty: FieldTypeEnum.BigInt
+} as const;
+
+export type FromBTCLNAutoResponseType = RequestSchemaResult<typeof FromBTCLNAutoResponseSchema>;
+
+export type FromBTCLNAutoInit = Omit<BaseFromBTCSwapInit, "feeRate"> & {
+    paymentHash: Buffer,
+    gasToken: string,
+    description?: string,
+    descriptionHash?: Buffer,
+    gasAmount?: bigint,
+    claimerBounty?: Promise<bigint>
+}
+
+/////////////////////////
+///// Spv vault from BTC
+
+const SpvFromBTCPrepareResponseSchema = {
+    quoteId: FieldTypeEnum.String,
+    expiry: FieldTypeEnum.Number,
+
+    address: FieldTypeEnum.String,
+    vaultId: FieldTypeEnum.BigInt,
+
+    vaultBtcAddress: FieldTypeEnum.String,
+    btcAddress: FieldTypeEnum.String,
+    btcUtxo: FieldTypeEnum.String,
+    btcFeeRate: FieldTypeEnum.Number,
+
+    btcAmount: FieldTypeEnum.BigInt,
+    btcAmountSwap: FieldTypeEnum.BigInt,
+    btcAmountGas: FieldTypeEnum.BigInt,
+
+    total: FieldTypeEnum.BigInt,
+    totalGas: FieldTypeEnum.BigInt,
+
+    totalFeeBtc: FieldTypeEnum.BigInt,
+
+    swapFeeBtc: FieldTypeEnum.BigInt,
+    swapFee: FieldTypeEnum.BigInt,
+
+    gasSwapFeeBtc: FieldTypeEnum.BigInt,
+    gasSwapFee: FieldTypeEnum.BigInt,
+
+    callerFeeShare: FieldTypeEnum.BigInt,
+    frontingFeeShare: FieldTypeEnum.BigInt,
+    executionFeeShare: FieldTypeEnum.BigInt,
+
+    usedUtxoInputCalculation: FieldTypeEnum.BooleanOptional
+} as const;
+
+export type SpvFromBTCPrepareResponseType = RequestSchemaResult<typeof SpvFromBTCPrepareResponseSchema>;
+
+export type SpvFromBTCPrepare = SwapInit & {
+    address: string,
+    amount: Promise<bigint>,
+    gasAmount: bigint,
+    gasToken: string,
+    exactOut: boolean,
+    callerFeeRate: Promise<bigint>,
+    frontingFeeRate: bigint,
+    stickyAddress?: boolean,
+    amountUtxos?: Promise<{ value: number, vSize: number, cpfp?: { effectiveVSize: number, effectiveFeeRate: number }}[] | undefined>,
+    amountFeeRate?: Promise<number | undefined>
+}
+
+const SpvFromBTCInitResponseSchema = {
+    txId: FieldTypeEnum.String
+} as const;
+
+export type SpvFromBTCInitResponseType = RequestSchemaResult<typeof SpvFromBTCInitResponseSchema>;
+
+export type SpvFromBTCInit = {
+    quoteId: string,
+    psbtHex: string
+}
+
+export class IntermediaryAPI {
+
+    /**
+     * Returns the information about a specific intermediary
+     *
+     * @param baseUrl Base URL of the intermediary
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     * @throws {Error} If the supplied nonce doesn't match the response
+     */
+    static async getIntermediaryInfo(
+        baseUrl: string,
+        timeout?: number,
+        abortSignal?: AbortSignal
+    ): Promise<InfoHandlerResponse> {
+        const nonce = randomBytes(32).toString("hex");
+
+        const abortController = extendAbortController(abortSignal);
+
+        //We don't know whether the node supports only POST or also has GET info support enabled
+        // here we try both, and abort when the first one returns (which should be GET)
+        const response = await Promise.any([
+            httpGet<InfoHandlerResponse>(baseUrl+"/info?nonce="+nonce, timeout, abortController.signal),
+            httpPost<InfoHandlerResponse>(baseUrl+"/info", {
+                nonce,
+            }, timeout, abortController.signal)
+        ]);
+        abortController.abort();
+
+        const info = JSON.parse(response.envelope);
+        if(nonce!==info.nonce) throw new Error("Invalid response - nonce");
+
+        return response;
+    }
+
+    /**
+     * Returns the information about an outcome of the To BTC swap
+     *
+     * @param url URL of the intermediary
+     * @param paymentHash Payment hash of the swap
+     * @param sequence Swap's sequence number
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     */
+    static async getRefundAuthorization(
+        url: string,
+        paymentHash: string,
+        sequence: bigint,
+        timeout?: number,
+        abortSignal?: AbortSignal
+    ): Promise<RefundAuthorizationResponse> {
+        return tryWithRetries(() => httpGet<RefundAuthorizationResponse>(
+            url + "/getRefundAuthorization"+
+                "?paymentHash=" + encodeURIComponent(paymentHash) +
+                "&sequence=" + encodeURIComponent(sequence.toString(10)),
+            timeout,
+            abortSignal
+        ), undefined, RequestError, abortSignal);
+    }
+
+    /**
+     * Returns the information about the payment of the From BTCLN swaps
+     *
+     * @param url URL of the intermediary
+     * @param paymentHash Payment hash of the swap
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     */
+    static async getPaymentAuthorization(
+        url: string,
+        paymentHash: string,
+        timeout?: number,
+        abortSignal?: AbortSignal
+    ): Promise<PaymentAuthorizationResponse> {
+        return tryWithRetries(() => httpGet<PaymentAuthorizationResponse>(
+            url+"/getInvoicePaymentAuth"+
+                "?paymentHash="+encodeURIComponent(paymentHash),
+            timeout,
+            abortSignal
+        ), undefined, RequestError, abortSignal);
+    }
+
+    /**
+     * Returns the status of the payment of the From BTCLN swaps
+     *
+     * @param url URL of the intermediary
+     * @param paymentHash Payment hash of the swap
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     */
+    static async getInvoiceStatus(
+        url: string,
+        paymentHash: string,
+        timeout?: number,
+        abortSignal?: AbortSignal
+    ): Promise<InvoiceStatusResponse> {
+        return tryWithRetries(() => httpGet<InvoiceStatusResponse>(
+            url+"/getInvoiceStatus"+
+            "?paymentHash="+encodeURIComponent(paymentHash),
+            timeout,
+            abortSignal
+        ), undefined, RequestError, abortSignal);
+    }
+
+    /**
+     * Initiate To BTC swap with an intermediary
+     *
+     * @param chainIdentifier
+     * @param baseUrl Base URL of the intermediary
+     * @param init Swap initialization parameters
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     */
+    static initToBTC(
+        chainIdentifier: string,
+        baseUrl: string,
+        init: ToBTCInit,
+        timeout?: number,
+        abortSignal?: AbortSignal,
+        streamRequest?: boolean
+    ): {
+        signDataPrefetch: Promise<any>,
+        response: Promise<ToBTCResponseType>
+    } {
+        const responseBodyPromise = streamingFetchPromise(baseUrl+"/tobtc/payInvoice?chain="+encodeURIComponent(chainIdentifier), {
+            ...init.additionalParams,
+            address: init.btcAddress,
+            amount: init.amount.toString(10),
+            exactIn: init.exactIn,
+            confirmationTarget: init.confirmationTarget,
+            confirmations: init.confirmations,
+            nonce: init.nonce.toString(10),
+            token: init.token,
+            offerer: init.offerer,
+            feeRate: init.feeRate
+        }, {
+            code: FieldTypeEnum.Number,
+            msg: FieldTypeEnum.String,
+            data: FieldTypeEnum.AnyOptional,
+            signDataPrefetch: FieldTypeEnum.AnyOptional
+        }, timeout, abortSignal, streamRequest);
+
+        return {
+            signDataPrefetch: responseBodyPromise.then(responseBody => responseBody.signDataPrefetch),
+            response: responseBodyPromise.then((responseBody) => Promise.all([
+                responseBody.code,
+                responseBody.msg,
+                responseBody.data,
+            ])).then(([code, msg, data]) => {
+                if(code!==20000) {
+                    throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
+                }
+                const result = verifySchema(data, ToBTCResponseSchema);
+                if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
+                return result;
+            })
+        };
+    }
+
+    /**
+     * Initiate From BTC swap with an intermediary
+     *
+     * @param chainIdentifier
+     * @param baseUrl Base URL of the intermediary
+     * @param depositToken
+     * @param init Swap initialization parameters
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     */
+    static initFromBTC(
+        chainIdentifier: string,
+        baseUrl: string,
+        depositToken: string,
+        init: FromBTCInit,
+        timeout?: number,
+        abortSignal?: AbortSignal,
+        streamRequest?: boolean
+    ): {
+        signDataPrefetch: Promise<any>,
+        response: Promise<FromBTCResponseType>
+    } {
+        const responseBodyPromise = streamingFetchPromise(
+            baseUrl+"/frombtc/getAddress?chain="+encodeURIComponent(chainIdentifier)+"&depositToken="+encodeURIComponent(depositToken),
+            {
+                ...init.additionalParams,
+                address: init.claimer,
+                amount: init.amount.toString(10),
+                token: init.token,
+
+                exactOut: init.exactOut,
+                sequence: init.sequence.toString(10),
+
+                claimerBounty: init.claimerBounty.then(claimerBounty => {
+                    return {
+                        feePerBlock: claimerBounty.feePerBlock.toString(10),
+                        safetyFactor: claimerBounty.safetyFactor.toString(10),
+                        startTimestamp: claimerBounty.startTimestamp.toString(10),
+                        addBlock: claimerBounty.addBlock.toString(10),
+                        addFee: claimerBounty.addFee.toString(10)
+                    }
+                }),
+                feeRate: init.feeRate
+            },
+            {
+                code: FieldTypeEnum.Number,
+                msg: FieldTypeEnum.String,
+                data: FieldTypeEnum.AnyOptional,
+                signDataPrefetch: FieldTypeEnum.AnyOptional
+            },
+            timeout, abortSignal, streamRequest
+        );
+
+        return {
+            signDataPrefetch: responseBodyPromise.then(responseBody => responseBody.signDataPrefetch),
+            response: responseBodyPromise.then((responseBody) => Promise.all([
+                responseBody.code,
+                responseBody.msg,
+                responseBody.data,
+            ])).then(([code, msg, data]) => {
+                if(code!==20000) {
+                    throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
+                }
+                const result = verifySchema(data, FromBTCResponseSchema);
+                if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
+                return result;
+            })
+        };
+    }
+
+    /**
+     * Initiate From BTCLN swap with an intermediary
+     *
+     * @param chainIdentifier
+     * @param baseUrl Base URL of the intermediary
+     * @param depositToken
+     * @param init Swap initialization parameters
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     */
+    static initFromBTCLN(
+        chainIdentifier: string,
+        baseUrl: string,
+        depositToken: string,
+        init: FromBTCLNInit,
+        timeout?: number,
+        abortSignal?: AbortSignal,
+        streamRequest?: boolean
+    ): {
+        lnPublicKey: Promise<string | null>,
+        response: Promise<FromBTCLNResponseType>
+    } {
+        const responseBodyPromise = streamingFetchPromise(
+            baseUrl+"/frombtcln/createInvoice?chain="+encodeURIComponent(chainIdentifier)+"&depositToken="+encodeURIComponent(depositToken),
+            {
+                ...init.additionalParams,
+                paymentHash: init.paymentHash.toString("hex"),
+                amount: init.amount.toString(),
+                address: init.claimer,
+                token: init.token,
+                description: init.description ?? null,
+                descriptionHash: init.descriptionHash==null ? null : init.descriptionHash.toString("hex"),
+                exactOut: init.exactOut,
+                feeRate: init.feeRate
+            },
+            {
+                code: FieldTypeEnum.Number,
+                msg: FieldTypeEnum.String,
+                data: FieldTypeEnum.AnyOptional,
+                lnPublicKey: FieldTypeEnum.StringOptional
+            },
+            timeout, abortSignal, streamRequest
+        );
+
+        return {
+            lnPublicKey: responseBodyPromise.then(responseBody => responseBody.lnPublicKey),
+            response: responseBodyPromise.then((responseBody) => Promise.all([
+                responseBody.code,
+                responseBody.msg,
+                responseBody.data,
+            ])).then(([code, msg, data]) => {
+                if(code!==20000) {
+                    throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
+                }
+                const result = verifySchema(data, FromBTCLNResponseSchema);
+                if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
+                return result;
+            })
+        };
+    }
+
+    /**
+     * Initiate From BTCLN swap with auto-initilization by an intermediary
+     *
+     * @param chainIdentifier
+     * @param baseUrl Base URL of the intermediary
+     * @param init Swap initialization parameters
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     */
+    static initFromBTCLNAuto(
+        chainIdentifier: string,
+        baseUrl: string,
+        init: FromBTCLNAutoInit,
+        timeout?: number,
+        abortSignal?: AbortSignal,
+        streamRequest?: boolean
+    ): {
+        lnPublicKey: Promise<string | null>,
+        response: Promise<FromBTCLNAutoResponseType>
+    } {
+        const responseBodyPromise = streamingFetchPromise(
+            baseUrl+"/frombtcln_auto/createInvoice?chain="+encodeURIComponent(chainIdentifier),
+            {
+                ...init.additionalParams,
+                paymentHash: init.paymentHash.toString("hex"),
+                amount: init.amount.toString(),
+                address: init.claimer,
+                token: init.token,
+                description: init.description ?? null,
+                descriptionHash: init.descriptionHash==null ? null : init.descriptionHash.toString("hex"),
+                exactOut: init.exactOut,
+                gasToken: init.gasToken,
+                gasAmount: init.gasAmount?.toString(10) ?? "0",
+                claimerBounty: init.claimerBounty?.then(val => val.toString(10)) ?? "0"
+            },
+            {
+                code: FieldTypeEnum.Number,
+                msg: FieldTypeEnum.String,
+                data: FieldTypeEnum.AnyOptional,
+                lnPublicKey: FieldTypeEnum.StringOptional
+            },
+            timeout, abortSignal, streamRequest
+        );
+
+        return {
+            lnPublicKey: responseBodyPromise.then(responseBody => responseBody.lnPublicKey),
+            response: responseBodyPromise.then((responseBody) => Promise.all([
+                responseBody.code,
+                responseBody.msg,
+                responseBody.data,
+            ])).then(([code, msg, data]) => {
+                if(code!==20000) {
+                    throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
+                }
+                const result = verifySchema(data, FromBTCLNAutoResponseSchema);
+                if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
+                return result;
+            })
+        };
+    }
+
+    /**
+     * Initiate To BTCLN swap with an intermediary
+     *
+     * @param chainIdentifier
+     * @param baseUrl Base URL of the intermediary
+     * @param init Swap initialization parameters
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     */
+    static initToBTCLN(
+        chainIdentifier: string,
+        baseUrl: string,
+        init: ToBTCLNInit,
+        timeout?: number,
+        abortSignal?: AbortSignal,
+        streamRequest?: boolean
+    ): {
+        signDataPrefetch: Promise<any>,
+        response: Promise<ToBTCLNResponseType>
+    } {
+        const responseBodyPromise = streamingFetchPromise(baseUrl+"/tobtcln/payInvoice?chain="+encodeURIComponent(chainIdentifier), {
+            exactIn: false,
+            ...init.additionalParams,
+            pr: init.pr,
+            maxFee: init.maxFee.toString(10),
+            expiryTimestamp: init.expiryTimestamp.toString(10),
+            token: init.token,
+            offerer: init.offerer,
+            feeRate: init.feeRate,
+            amount: null
+        }, {
+            code: FieldTypeEnum.Number,
+            msg: FieldTypeEnum.String,
+            data: FieldTypeEnum.AnyOptional,
+            signDataPrefetch: FieldTypeEnum.AnyOptional
+        }, timeout, abortSignal, streamRequest);
+
+        return {
+            signDataPrefetch: responseBodyPromise.then(responseBody => responseBody.signDataPrefetch),
+            response: responseBodyPromise.then((responseBody) => Promise.all([
+                responseBody.code,
+                responseBody.msg,
+                responseBody.data,
+            ])).then(([code, msg, data]) => {
+                if(code!==20000) {
+                    throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
+                }
+                const result = verifySchema(data, ToBTCLNResponseSchema);
+                if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
+                return result;
+            })
+        };
+    }
+
+    /**
+     * Initiate To BTCLN exact in swap with an intermediary
+     *
+     * @param baseUrl Base URL of the intermediary
+     * @param init Swap initialization parameters
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     */
+    static async initToBTCLNExactIn(
+        baseUrl: string,
+        init: ToBTCLNInitExactIn,
+        timeout?: number,
+        abortSignal?: AbortSignal,
+        streamRequest?: boolean
+    ): Promise<ToBTCLNResponseType> {
+        const responseBody = await streamingFetchPromise(baseUrl+"/tobtcln/payInvoiceExactIn", {
+            ...init.additionalParams,
+            pr: init.pr,
+            reqId: init.reqId,
+            feeRate: init.feeRate
+        }, {
+            code: FieldTypeEnum.Number,
+            msg: FieldTypeEnum.String,
+            data: FieldTypeEnum.AnyOptional
+        }, timeout, abortSignal, streamRequest);
+
+        const [code, msg, data] = await Promise.all([
+            responseBody.code,
+            responseBody.msg,
+            responseBody.data,
+        ])
+
+        if(code!==20000) throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
+        const result = verifySchema(data, ToBTCLNResponseSchema);
+        if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
+        return result;
+    }
+
+    /**
+     * Prepare To BTCLN exact in swap with an intermediary
+     *
+     * @param chainIdentifier
+     * @param baseUrl Base URL of the intermediary
+     * @param init Swap initialization parameters
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     */
+    static prepareToBTCLNExactIn(
+        chainIdentifier: string,
+        baseUrl: string,
+        init: ToBTCLNPrepareExactIn,
+        timeout?: number,
+        abortSignal?: AbortSignal,
+        streamRequest?: boolean
+    ): {
+        signDataPrefetch: Promise<any>,
+        response: Promise<ToBTCLNPrepareExactInResponseType>
+    } {
+        const responseBodyPromise = streamingFetchPromise(baseUrl+"/tobtcln/payInvoice?chain="+encodeURIComponent(chainIdentifier), {
+            exactIn: true,
+            ...init.additionalParams,
+            pr: init.pr,
+            maxFee: init.maxFee.toString(10),
+            expiryTimestamp: init.expiryTimestamp.toString(10),
+            token: init.token,
+            offerer: init.offerer,
+            amount: init.amount.toString(10)
+        }, {
+            code: FieldTypeEnum.Number,
+            msg: FieldTypeEnum.String,
+            data: FieldTypeEnum.AnyOptional,
+            signDataPrefetch: FieldTypeEnum.AnyOptional
+        }, timeout, abortSignal, streamRequest);
+
+        return {
+            signDataPrefetch: responseBodyPromise.then(responseBody => responseBody.signDataPrefetch),
+            response: responseBodyPromise.then((responseBody) => Promise.all([
+                responseBody.code,
+                responseBody.msg,
+                responseBody.data,
+            ])).then(([code, msg, data]) => {
+                if(code!==20000) {
+                    throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
+                }
+                const result = verifySchema(data, ToBTCLNPrepareExactInSchema);
+                if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
+                return result;
+            })
+        };
+    }
+
+    /**
+     * Prepare From BTC swap via new spv vault swaps with an intermediary
+     *
+     * @param chainIdentifier
+     * @param baseUrl Base URL of the intermediary
+     * @param init Swap initialization parameters
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     */
+    static prepareSpvFromBTC(
+        chainIdentifier: string,
+        baseUrl: string,
+        init: SpvFromBTCPrepare,
+        timeout?: number,
+        abortSignal?: AbortSignal,
+        streamRequest?: boolean
+    ): Promise<SpvFromBTCPrepareResponseType> {
+        //We need to make sure we only send the amount parameter after the amountUtxos and amountFeeRate resolve
+        // this is needed, because in the LP code to maintain backwards compatibility the amountUtxos and amountFeeRate
+        // params are checked immediately after the amount param (and other params) are received, if amount were sent
+        // first without the amountUtxos or amountFeeRate populated these fields would've been skipped altogether
+        const amountPromise = (async () => {
+            if(init.amountUtxos!=null) await init.amountUtxos;
+            if(init.amountFeeRate!=null) await init.amountFeeRate;
+            const amount = await init.amount;
+            return amount.toString(10);
+        })();
+        const responseBodyPromise = streamingFetchPromise(baseUrl+"/frombtc_spv/getQuote?chain="+encodeURIComponent(chainIdentifier), {
+            exactOut: init.exactOut,
+            ...init.additionalParams,
+            address: init.address,
+            amount: amountPromise,
+            token: init.token,
+            gasAmount: init.gasAmount.toString(10),
+            gasToken: init.gasToken,
+            frontingFeeRate: init.frontingFeeRate.toString(10),
+            callerFeeRate: init.callerFeeRate.then(val => val.toString(10)),
+            stickyAddress: init.stickyAddress,
+            amountUtxos: init.amountUtxos,
+            amountFeeRate: init.amountFeeRate
+        }, {
+            code: FieldTypeEnum.Number,
+            msg: FieldTypeEnum.String,
+            data: FieldTypeEnum.AnyOptional
+        }, timeout, abortSignal, streamRequest);
+
+        return responseBodyPromise.then((responseBody) => Promise.all([
+            responseBody.code,
+            responseBody.msg,
+            responseBody.data,
+        ])).then(([code, msg, data]) => {
+            if(code!==20000) {
+                throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
+            }
+            const result = verifySchema(data, SpvFromBTCPrepareResponseSchema);
+            if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
+            return result;
+        });
+    }
+
+    /**
+     * Prepare From BTC swap via new spv vault swaps with an intermediary
+     *
+     * @param chainIdentifier
+     * @param url
+     * @param init Swap initialization parameters
+     * @param timeout Timeout in milliseconds for the HTTP request
+     * @param abortSignal
+     * @param streamRequest Whether to force streaming (or not streaming) the request, default is autodetect
+     *
+     * @throws {RequestError} If non-200 http response code is returned
+     */
+    static initSpvFromBTC(
+        chainIdentifier: string,
+        url: string,
+        init: SpvFromBTCInit,
+        timeout?: number,
+        abortSignal?: AbortSignal,
+        streamRequest?: boolean
+    ): Promise<SpvFromBTCInitResponseType> {
+        const responseBodyPromise = streamingFetchPromise(url+"/postQuote?chain="+encodeURIComponent(chainIdentifier), {
+            quoteId: init.quoteId,
+            psbtHex: init.psbtHex
+        }, {
+            code: FieldTypeEnum.Number,
+            msg: FieldTypeEnum.String,
+            data: FieldTypeEnum.AnyOptional
+        }, timeout, abortSignal, streamRequest);
+
+        return responseBodyPromise.then((responseBody) => Promise.all([
+            responseBody.code,
+            responseBody.msg,
+            responseBody.data,
+        ])).then(([code, msg, data]) => {
+            if(code!==20000) {
+                throw RequestError.parse(JSON.stringify({code, msg, data}), 400);
+            }
+            const result = verifySchema(data, SpvFromBTCInitResponseSchema);
+            if(result==null) throw new RequestError("Cannot parse the response with the expected schema", 200);
+            return result;
+        });
+    }
+
+}