@atomiqlabs/sdk 8.7.7 → 8.9.0

package/dist/intermediaries/apis/IntermediaryAPI.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { FieldTypeEnum, RequestSchemaResult } from "../../http/paramcoders/SchemaVerifier";
+import { FieldTypeEnum, RequestSchema, RequestSchemaResult, RequestSchemaResultPromise } from "../../http/paramcoders/SchemaVerifier";
+import { RequestBody } from "../../http/paramcoders/client/StreamingFetchPromise";
 export type InfoHandlerResponse = {
     envelope: string;
     chains: {
@@ -234,17 +235,27 @@ declare const SpvFromBTCPrepareResponseSchema: {
     readonly callerFeeShare: FieldTypeEnum.BigInt;
     readonly frontingFeeShare: FieldTypeEnum.BigInt;
     readonly executionFeeShare: FieldTypeEnum.BigInt;
+    readonly usedUtxoInputCalculation: FieldTypeEnum.BooleanOptional;
 };
 export type SpvFromBTCPrepareResponseType = RequestSchemaResult<typeof SpvFromBTCPrepareResponseSchema>;
 export type SpvFromBTCPrepare = SwapInit & {
     address: string;
-    amount: bigint;
+    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>;
 };
 declare const SpvFromBTCInitResponseSchema: {
     readonly txId: FieldTypeEnum.String;
@@ -254,7 +265,108 @@ export type SpvFromBTCInit = {
     quoteId: string;
     psbtHex: string;
 };
+export declare enum TrustedInvoiceStatusResponseCodes {
+    EXPIRED = 10001,
+    PAID = 10000,
+    AWAIT_PAYMENT = 10010,
+    PENDING = 10011,
+    TX_SENT = 10012
+}
+export type TrustedInvoiceStatusResponse = {
+    code: TrustedInvoiceStatusResponseCodes.TX_SENT | TrustedInvoiceStatusResponseCodes.PAID;
+    msg: string;
+    data: {
+        txId: string;
+    };
+} | {
+    code: Exclude<TrustedInvoiceStatusResponseCodes, TrustedInvoiceStatusResponseCodes.TX_SENT | TrustedInvoiceStatusResponseCodes.PAID>;
+    msg: string;
+};
+export type TrustedFromBTCLNInit = {
+    address: string;
+    amount: bigint;
+    token: string;
+};
+declare const TrustedFromBTCLNResponseSchema: {
+    readonly pr: FieldTypeEnum.String;
+    readonly swapFee: FieldTypeEnum.BigInt;
+    readonly swapFeeSats: FieldTypeEnum.BigInt;
+    readonly total: FieldTypeEnum.BigInt;
+};
+export type TrustedFromBTCLNResponseType = RequestSchemaResult<typeof TrustedFromBTCLNResponseSchema>;
+export declare enum TrustedAddressStatusResponseCodes {
+    EXPIRED = 10001,
+    PAID = 10000,
+    AWAIT_PAYMENT = 10010,
+    AWAIT_CONFIRMATION = 10011,
+    PENDING = 10013,
+    TX_SENT = 10012,
+    REFUNDED = 10014,
+    DOUBLE_SPENT = 10015,
+    REFUNDABLE = 10016
+}
+export type TrustedAddressStatusResponse = {
+    code: TrustedAddressStatusResponseCodes.TX_SENT | TrustedAddressStatusResponseCodes.PAID;
+    msg: string;
+    data: {
+        adjustedAmount: string;
+        adjustedTotal: string;
+        adjustedFee?: string;
+        adjustedFeeSats?: string;
+        txId: string;
+        scTxId: string;
+    };
+} | {
+    code: TrustedAddressStatusResponseCodes.AWAIT_CONFIRMATION | TrustedAddressStatusResponseCodes.PENDING;
+    msg: string;
+    data: {
+        adjustedAmount: string;
+        adjustedTotal: string;
+        adjustedFee?: string;
+        adjustedFeeSats?: string;
+        txId: string;
+    };
+} | {
+    code: TrustedAddressStatusResponseCodes.REFUNDABLE;
+    msg: string;
+    data: {
+        adjustedAmount: string;
+    };
+} | {
+    code: TrustedAddressStatusResponseCodes.REFUNDED | TrustedAddressStatusResponseCodes.DOUBLE_SPENT;
+    msg: string;
+    data: {
+        txId: string;
+    };
+} | {
+    code: TrustedAddressStatusResponseCodes.AWAIT_PAYMENT | TrustedAddressStatusResponseCodes.EXPIRED;
+    msg: string;
+};
+export type TrustedFromBTCInit = {
+    address: string;
+    amount: bigint;
+    token: string;
+    refundAddress?: string;
+};
+declare const TrustedFromBTCResponseSchema: {
+    readonly paymentHash: FieldTypeEnum.String;
+    readonly sequence: FieldTypeEnum.BigInt;
+    readonly btcAddress: FieldTypeEnum.String;
+    readonly amountSats: FieldTypeEnum.BigInt;
+    readonly swapFeeSats: FieldTypeEnum.BigInt;
+    readonly swapFee: FieldTypeEnum.BigInt;
+    readonly total: FieldTypeEnum.BigInt;
+    readonly intermediaryKey: FieldTypeEnum.String;
+    readonly recommendedFee: FieldTypeEnum.Number;
+    readonly expiresAt: FieldTypeEnum.Number;
+};
+export type TrustedFromBTCResponseType = RequestSchemaResult<typeof TrustedFromBTCResponseSchema>;
 export declare class IntermediaryAPI {
+    requestHeaders?: (type: "GET" | "POST", url: string, body?: any) => Record<string, string>;
+    constructor(requestHeaders?: (type: "GET" | "POST", url: string, body?: any) => Record<string, string>);
+    httpGet<T>(url: string, timeout?: number, abortSignal?: AbortSignal, allowNon200?: boolean): Promise<T>;
+    httpPost<T>(url: string, body: any, timeout?: number, abortSignal?: AbortSignal): Promise<T>;
+    streamingFetchPromise<T extends RequestSchema>(url: string, body: RequestBody, schema: T, timeout?: number, signal?: AbortSignal, streamRequest?: boolean): Promise<RequestSchemaResultPromise<T>>;
     /**
      * Returns the information about a specific intermediary
      *
@@ -265,7 +377,7 @@ export declare class IntermediaryAPI {
      * @throws {RequestError} If non-200 http response code is returned
      * @throws {Error} If the supplied nonce doesn't match the response
      */
-    static getIntermediaryInfo(baseUrl: string, timeout?: number, abortSignal?: AbortSignal): Promise<InfoHandlerResponse>;
+    getIntermediaryInfo(baseUrl: string, timeout?: number, abortSignal?: AbortSignal): Promise<InfoHandlerResponse>;
     /**
      * Returns the information about an outcome of the To BTC swap
      *
@@ -277,7 +389,7 @@ export declare class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static getRefundAuthorization(url: string, paymentHash: string, sequence: bigint, timeout?: number, abortSignal?: AbortSignal): Promise<RefundAuthorizationResponse>;
+    getRefundAuthorization(url: string, paymentHash: string, sequence: bigint, timeout?: number, abortSignal?: AbortSignal): Promise<RefundAuthorizationResponse>;
     /**
      * Returns the information about the payment of the From BTCLN swaps
      *
@@ -288,7 +400,7 @@ export declare class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static getPaymentAuthorization(url: string, paymentHash: string, timeout?: number, abortSignal?: AbortSignal): Promise<PaymentAuthorizationResponse>;
+    getPaymentAuthorization(url: string, paymentHash: string, timeout?: number, abortSignal?: AbortSignal): Promise<PaymentAuthorizationResponse>;
     /**
      * Returns the status of the payment of the From BTCLN swaps
      *
@@ -299,7 +411,7 @@ export declare class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static getInvoiceStatus(url: string, paymentHash: string, timeout?: number, abortSignal?: AbortSignal): Promise<InvoiceStatusResponse>;
+    getInvoiceStatus(url: string, paymentHash: string, timeout?: number, abortSignal?: AbortSignal): Promise<InvoiceStatusResponse>;
     /**
      * Initiate To BTC swap with an intermediary
      *
@@ -312,7 +424,7 @@ export declare class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static initToBTC(chainIdentifier: string, baseUrl: string, init: ToBTCInit, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): {
+    initToBTC(chainIdentifier: string, baseUrl: string, init: ToBTCInit, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): {
         signDataPrefetch: Promise<any>;
         response: Promise<ToBTCResponseType>;
     };
@@ -329,7 +441,7 @@ export declare class IntermediaryAPI {
      *
      * @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): {
+    initFromBTC(chainIdentifier: string, baseUrl: string, depositToken: string, init: FromBTCInit, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): {
         signDataPrefetch: Promise<any>;
         response: Promise<FromBTCResponseType>;
     };
@@ -346,7 +458,7 @@ export declare class IntermediaryAPI {
      *
      * @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): {
+    initFromBTCLN(chainIdentifier: string, baseUrl: string, depositToken: string, init: FromBTCLNInit, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): {
         lnPublicKey: Promise<string | null>;
         response: Promise<FromBTCLNResponseType>;
     };
@@ -362,7 +474,7 @@ export declare class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static initFromBTCLNAuto(chainIdentifier: string, baseUrl: string, init: FromBTCLNAutoInit, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): {
+    initFromBTCLNAuto(chainIdentifier: string, baseUrl: string, init: FromBTCLNAutoInit, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): {
         lnPublicKey: Promise<string | null>;
         response: Promise<FromBTCLNAutoResponseType>;
     };
@@ -378,7 +490,7 @@ export declare class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static initToBTCLN(chainIdentifier: string, baseUrl: string, init: ToBTCLNInit, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): {
+    initToBTCLN(chainIdentifier: string, baseUrl: string, init: ToBTCLNInit, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): {
         signDataPrefetch: Promise<any>;
         response: Promise<ToBTCLNResponseType>;
     };
@@ -393,7 +505,7 @@ export declare class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static initToBTCLNExactIn(baseUrl: string, init: ToBTCLNInitExactIn, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): Promise<ToBTCLNResponseType>;
+    initToBTCLNExactIn(baseUrl: string, init: ToBTCLNInitExactIn, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): Promise<ToBTCLNResponseType>;
     /**
      * Prepare To BTCLN exact in swap with an intermediary
      *
@@ -406,7 +518,7 @@ export declare class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static prepareToBTCLNExactIn(chainIdentifier: string, baseUrl: string, init: ToBTCLNPrepareExactIn, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): {
+    prepareToBTCLNExactIn(chainIdentifier: string, baseUrl: string, init: ToBTCLNPrepareExactIn, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): {
         signDataPrefetch: Promise<any>;
         response: Promise<ToBTCLNPrepareExactInResponseType>;
     };
@@ -422,7 +534,7 @@ export declare class IntermediaryAPI {
      *
      * @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>;
+    prepareSpvFromBTC(chainIdentifier: string, baseUrl: string, init: SpvFromBTCPrepare, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): Promise<SpvFromBTCPrepareResponseType>;
     /**
      * Prepare From BTC swap via new spv vault swaps with an intermediary
      *
@@ -435,6 +547,61 @@ export declare class IntermediaryAPI {
      *
      * @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>;
+    initSpvFromBTC(chainIdentifier: string, url: string, init: SpvFromBTCInit, timeout?: number, abortSignal?: AbortSignal, streamRequest?: boolean): Promise<SpvFromBTCInitResponseType>;
+    /**
+     * Fetches the invoice status from the intermediary node
+     *
+     * @param url Url of the trusted intermediary
+     * @param paymentHash Payment hash of the lightning invoice
+     * @param timeout Timeout in milliseconds
+     * @param abortSignal
+     * @throws {RequestError} if non-200 http response is returned
+     */
+    getTrustedInvoiceStatus(url: string, paymentHash: string, timeout?: number, abortSignal?: AbortSignal): Promise<TrustedInvoiceStatusResponse>;
+    /**
+     * Initiate a trusted swap from BTCLN to SC native currency, retries!
+     *
+     * @param chainIdentifier
+     * @param baseUrl Base url of the trusted swap intermediary
+     * @param init Initialization parameters
+     * @param timeout Timeout in milliseconds for the request
+     * @param abortSignal
+     * @throws {RequestError} If the response is non-200
+     */
+    initTrustedFromBTCLN(chainIdentifier: string, baseUrl: string, init: TrustedFromBTCLNInit, timeout?: number, abortSignal?: AbortSignal): Promise<TrustedFromBTCLNResponseType>;
+    /**
+     * Fetches the address status from the intermediary node
+     *
+     * @param url Url of the trusted intermediary
+     * @param paymentHash Payment hash of the swap
+     * @param sequence Sequence number of the swap
+     * @param timeout Timeout in milliseconds
+     * @param abortSignal
+     * @throws {RequestError} if non-200 http response is returned
+     */
+    getTrustedAddressStatus(url: string, paymentHash: string, sequence: bigint, timeout?: number, abortSignal?: AbortSignal): Promise<TrustedAddressStatusResponse>;
+    /**
+     * Sets the refund address for an on-chain gas swap
+     *
+     * @param url Url of the trusted intermediary
+     * @param paymentHash Payment hash of the swap
+     * @param sequence Sequence number of the swap
+     * @param refundAddress Refund address to set for the swap
+     * @param timeout Timeout in milliseconds
+     * @param abortSignal
+     * @throws {RequestError} if non-200 http response is returned
+     */
+    setTrustedRefundAddress(url: string, paymentHash: string, sequence: bigint, refundAddress: string, timeout?: number, abortSignal?: AbortSignal): Promise<void>;
+    /**
+     * Initiate a trusted swap from BTC to SC native currency, retries!
+     *
+     * @param chainIdentifier
+     * @param baseUrl Base url of the trusted swap intermediary
+     * @param init Initialization parameters
+     * @param timeout Timeout in milliseconds for the request
+     * @param abortSignal
+     * @throws {RequestError} If the response is non-200
+     */
+    initTrustedFromBTC(chainIdentifier: string, baseUrl: string, init: TrustedFromBTCInit, timeout?: number, abortSignal?: AbortSignal): Promise<TrustedFromBTCResponseType>;
 }
 export {};

package/dist/intermediaries/apis/IntermediaryAPI.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntermediaryAPI = exports.InvoiceStatusResponseCodes = exports.PaymentAuthorizationResponseCodes = exports.RefundAuthorizationResponseCodes = void 0;
+exports.IntermediaryAPI = exports.TrustedAddressStatusResponseCodes = exports.TrustedInvoiceStatusResponseCodes = exports.InvoiceStatusResponseCodes = exports.PaymentAuthorizationResponseCodes = exports.RefundAuthorizationResponseCodes = void 0;
 const RequestError_1 = require("../../errors/RequestError");
 const SchemaVerifier_1 = require("../../http/paramcoders/SchemaVerifier");
 const StreamingFetchPromise_1 = require("../../http/paramcoders/client/StreamingFetchPromise");
@@ -123,12 +123,70 @@ const SpvFromBTCPrepareResponseSchema = {
     gasSwapFee: SchemaVerifier_1.FieldTypeEnum.BigInt,
     callerFeeShare: SchemaVerifier_1.FieldTypeEnum.BigInt,
     frontingFeeShare: SchemaVerifier_1.FieldTypeEnum.BigInt,
-    executionFeeShare: SchemaVerifier_1.FieldTypeEnum.BigInt
+    executionFeeShare: SchemaVerifier_1.FieldTypeEnum.BigInt,
+    usedUtxoInputCalculation: SchemaVerifier_1.FieldTypeEnum.BooleanOptional
 };
 const SpvFromBTCInitResponseSchema = {
     txId: SchemaVerifier_1.FieldTypeEnum.String
 };
+/////////////////////////
+///// Trusted from BTCLN
+var TrustedInvoiceStatusResponseCodes;
+(function (TrustedInvoiceStatusResponseCodes) {
+    TrustedInvoiceStatusResponseCodes[TrustedInvoiceStatusResponseCodes["EXPIRED"] = 10001] = "EXPIRED";
+    TrustedInvoiceStatusResponseCodes[TrustedInvoiceStatusResponseCodes["PAID"] = 10000] = "PAID";
+    TrustedInvoiceStatusResponseCodes[TrustedInvoiceStatusResponseCodes["AWAIT_PAYMENT"] = 10010] = "AWAIT_PAYMENT";
+    TrustedInvoiceStatusResponseCodes[TrustedInvoiceStatusResponseCodes["PENDING"] = 10011] = "PENDING";
+    TrustedInvoiceStatusResponseCodes[TrustedInvoiceStatusResponseCodes["TX_SENT"] = 10012] = "TX_SENT";
+})(TrustedInvoiceStatusResponseCodes = exports.TrustedInvoiceStatusResponseCodes || (exports.TrustedInvoiceStatusResponseCodes = {}));
+const TrustedFromBTCLNResponseSchema = {
+    pr: SchemaVerifier_1.FieldTypeEnum.String,
+    swapFee: SchemaVerifier_1.FieldTypeEnum.BigInt,
+    swapFeeSats: SchemaVerifier_1.FieldTypeEnum.BigInt,
+    total: SchemaVerifier_1.FieldTypeEnum.BigInt
+};
+/////////////////////////
+///// Trusted from BTC
+var TrustedAddressStatusResponseCodes;
+(function (TrustedAddressStatusResponseCodes) {
+    TrustedAddressStatusResponseCodes[TrustedAddressStatusResponseCodes["EXPIRED"] = 10001] = "EXPIRED";
+    TrustedAddressStatusResponseCodes[TrustedAddressStatusResponseCodes["PAID"] = 10000] = "PAID";
+    TrustedAddressStatusResponseCodes[TrustedAddressStatusResponseCodes["AWAIT_PAYMENT"] = 10010] = "AWAIT_PAYMENT";
+    TrustedAddressStatusResponseCodes[TrustedAddressStatusResponseCodes["AWAIT_CONFIRMATION"] = 10011] = "AWAIT_CONFIRMATION";
+    TrustedAddressStatusResponseCodes[TrustedAddressStatusResponseCodes["PENDING"] = 10013] = "PENDING";
+    TrustedAddressStatusResponseCodes[TrustedAddressStatusResponseCodes["TX_SENT"] = 10012] = "TX_SENT";
+    TrustedAddressStatusResponseCodes[TrustedAddressStatusResponseCodes["REFUNDED"] = 10014] = "REFUNDED";
+    TrustedAddressStatusResponseCodes[TrustedAddressStatusResponseCodes["DOUBLE_SPENT"] = 10015] = "DOUBLE_SPENT";
+    TrustedAddressStatusResponseCodes[TrustedAddressStatusResponseCodes["REFUNDABLE"] = 10016] = "REFUNDABLE";
+})(TrustedAddressStatusResponseCodes = exports.TrustedAddressStatusResponseCodes || (exports.TrustedAddressStatusResponseCodes = {}));
+const TrustedFromBTCResponseSchema = {
+    paymentHash: SchemaVerifier_1.FieldTypeEnum.String,
+    sequence: SchemaVerifier_1.FieldTypeEnum.BigInt,
+    btcAddress: SchemaVerifier_1.FieldTypeEnum.String,
+    amountSats: SchemaVerifier_1.FieldTypeEnum.BigInt,
+    swapFeeSats: SchemaVerifier_1.FieldTypeEnum.BigInt,
+    swapFee: SchemaVerifier_1.FieldTypeEnum.BigInt,
+    total: SchemaVerifier_1.FieldTypeEnum.BigInt,
+    intermediaryKey: SchemaVerifier_1.FieldTypeEnum.String,
+    recommendedFee: SchemaVerifier_1.FieldTypeEnum.Number,
+    expiresAt: SchemaVerifier_1.FieldTypeEnum.Number
+};
 class IntermediaryAPI {
+    constructor(requestHeaders) {
+        this.requestHeaders = requestHeaders;
+    }
+    httpGet(url, timeout, abortSignal, allowNon200 = false) {
+        const headers = this.requestHeaders == null ? {} : this.requestHeaders("GET", url);
+        return (0, HttpUtils_1.httpGet)(url, timeout, abortSignal, allowNon200, headers);
+    }
+    httpPost(url, body, timeout, abortSignal) {
+        const headers = this.requestHeaders == null ? {} : this.requestHeaders("POST", url, body);
+        return (0, HttpUtils_1.httpPost)(url, body, timeout, abortSignal, headers);
+    }
+    streamingFetchPromise(url, body, schema, timeout, signal, streamRequest) {
+        const headers = this.requestHeaders == null ? {} : this.requestHeaders("POST", url);
+        return (0, StreamingFetchPromise_1.streamingFetchPromise)(url, body, schema, timeout, signal, streamRequest, headers);
+    }
     /**
      * Returns the information about a specific intermediary
      *
@@ -139,14 +197,14 @@ class IntermediaryAPI {
      * @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, timeout, abortSignal) {
+    async getIntermediaryInfo(baseUrl, timeout, abortSignal) {
         const nonce = (0, Utils_1.randomBytes)(32).toString("hex");
         const abortController = (0, Utils_1.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([
-            (0, HttpUtils_1.httpGet)(baseUrl + "/info?nonce=" + nonce, timeout, abortController.signal),
-            (0, HttpUtils_1.httpPost)(baseUrl + "/info", {
+            this.httpGet(baseUrl + "/info?nonce=" + nonce, timeout, abortController.signal),
+            this.httpPost(baseUrl + "/info", {
                 nonce,
             }, timeout, abortController.signal)
         ]);
@@ -167,8 +225,8 @@ class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static async getRefundAuthorization(url, paymentHash, sequence, timeout, abortSignal) {
-        return (0, RetryUtils_1.tryWithRetries)(() => (0, HttpUtils_1.httpGet)(url + "/getRefundAuthorization" +
+    async getRefundAuthorization(url, paymentHash, sequence, timeout, abortSignal) {
+        return (0, RetryUtils_1.tryWithRetries)(() => this.httpGet(url + "/getRefundAuthorization" +
             "?paymentHash=" + encodeURIComponent(paymentHash) +
             "&sequence=" + encodeURIComponent(sequence.toString(10)), timeout, abortSignal), undefined, RequestError_1.RequestError, abortSignal);
     }
@@ -182,8 +240,8 @@ class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static async getPaymentAuthorization(url, paymentHash, timeout, abortSignal) {
-        return (0, RetryUtils_1.tryWithRetries)(() => (0, HttpUtils_1.httpGet)(url + "/getInvoicePaymentAuth" +
+    async getPaymentAuthorization(url, paymentHash, timeout, abortSignal) {
+        return (0, RetryUtils_1.tryWithRetries)(() => this.httpGet(url + "/getInvoicePaymentAuth" +
             "?paymentHash=" + encodeURIComponent(paymentHash), timeout, abortSignal), undefined, RequestError_1.RequestError, abortSignal);
     }
     /**
@@ -196,8 +254,8 @@ class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static async getInvoiceStatus(url, paymentHash, timeout, abortSignal) {
-        return (0, RetryUtils_1.tryWithRetries)(() => (0, HttpUtils_1.httpGet)(url + "/getInvoiceStatus" +
+    async getInvoiceStatus(url, paymentHash, timeout, abortSignal) {
+        return (0, RetryUtils_1.tryWithRetries)(() => this.httpGet(url + "/getInvoiceStatus" +
             "?paymentHash=" + encodeURIComponent(paymentHash), timeout, abortSignal), undefined, RequestError_1.RequestError, abortSignal);
     }
     /**
@@ -212,8 +270,8 @@ class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static initToBTC(chainIdentifier, baseUrl, init, timeout, abortSignal, streamRequest) {
-        const responseBodyPromise = (0, StreamingFetchPromise_1.streamingFetchPromise)(baseUrl + "/tobtc/payInvoice?chain=" + encodeURIComponent(chainIdentifier), {
+    initToBTC(chainIdentifier, baseUrl, init, timeout, abortSignal, streamRequest) {
+        const responseBodyPromise = this.streamingFetchPromise(baseUrl + "/tobtc/payInvoice?chain=" + encodeURIComponent(chainIdentifier), {
             ...init.additionalParams,
             address: init.btcAddress,
             amount: init.amount.toString(10),
@@ -260,8 +318,8 @@ class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static initFromBTC(chainIdentifier, baseUrl, depositToken, init, timeout, abortSignal, streamRequest) {
-        const responseBodyPromise = (0, StreamingFetchPromise_1.streamingFetchPromise)(baseUrl + "/frombtc/getAddress?chain=" + encodeURIComponent(chainIdentifier) + "&depositToken=" + encodeURIComponent(depositToken), {
+    initFromBTC(chainIdentifier, baseUrl, depositToken, init, timeout, abortSignal, streamRequest) {
+        const responseBodyPromise = this.streamingFetchPromise(baseUrl + "/frombtc/getAddress?chain=" + encodeURIComponent(chainIdentifier) + "&depositToken=" + encodeURIComponent(depositToken), {
             ...init.additionalParams,
             address: init.claimer,
             amount: init.amount.toString(10),
@@ -314,8 +372,8 @@ class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static initFromBTCLN(chainIdentifier, baseUrl, depositToken, init, timeout, abortSignal, streamRequest) {
-        const responseBodyPromise = (0, StreamingFetchPromise_1.streamingFetchPromise)(baseUrl + "/frombtcln/createInvoice?chain=" + encodeURIComponent(chainIdentifier) + "&depositToken=" + encodeURIComponent(depositToken), {
+    initFromBTCLN(chainIdentifier, baseUrl, depositToken, init, timeout, abortSignal, streamRequest) {
+        const responseBodyPromise = this.streamingFetchPromise(baseUrl + "/frombtcln/createInvoice?chain=" + encodeURIComponent(chainIdentifier) + "&depositToken=" + encodeURIComponent(depositToken), {
             ...init.additionalParams,
             paymentHash: init.paymentHash.toString("hex"),
             amount: init.amount.toString(),
@@ -360,8 +418,8 @@ class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static initFromBTCLNAuto(chainIdentifier, baseUrl, init, timeout, abortSignal, streamRequest) {
-        const responseBodyPromise = (0, StreamingFetchPromise_1.streamingFetchPromise)(baseUrl + "/frombtcln_auto/createInvoice?chain=" + encodeURIComponent(chainIdentifier), {
+    initFromBTCLNAuto(chainIdentifier, baseUrl, init, timeout, abortSignal, streamRequest) {
+        const responseBodyPromise = this.streamingFetchPromise(baseUrl + "/frombtcln_auto/createInvoice?chain=" + encodeURIComponent(chainIdentifier), {
             ...init.additionalParams,
             paymentHash: init.paymentHash.toString("hex"),
             amount: init.amount.toString(),
@@ -408,8 +466,8 @@ class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static initToBTCLN(chainIdentifier, baseUrl, init, timeout, abortSignal, streamRequest) {
-        const responseBodyPromise = (0, StreamingFetchPromise_1.streamingFetchPromise)(baseUrl + "/tobtcln/payInvoice?chain=" + encodeURIComponent(chainIdentifier), {
+    initToBTCLN(chainIdentifier, baseUrl, init, timeout, abortSignal, streamRequest) {
+        const responseBodyPromise = this.streamingFetchPromise(baseUrl + "/tobtcln/payInvoice?chain=" + encodeURIComponent(chainIdentifier), {
             exactIn: false,
             ...init.additionalParams,
             pr: init.pr,
@@ -453,8 +511,8 @@ class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static async initToBTCLNExactIn(baseUrl, init, timeout, abortSignal, streamRequest) {
-        const responseBody = await (0, StreamingFetchPromise_1.streamingFetchPromise)(baseUrl + "/tobtcln/payInvoiceExactIn", {
+    async initToBTCLNExactIn(baseUrl, init, timeout, abortSignal, streamRequest) {
+        const responseBody = await this.streamingFetchPromise(baseUrl + "/tobtcln/payInvoiceExactIn", {
             ...init.additionalParams,
             pr: init.pr,
             reqId: init.reqId,
@@ -488,8 +546,8 @@ class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static prepareToBTCLNExactIn(chainIdentifier, baseUrl, init, timeout, abortSignal, streamRequest) {
-        const responseBodyPromise = (0, StreamingFetchPromise_1.streamingFetchPromise)(baseUrl + "/tobtcln/payInvoice?chain=" + encodeURIComponent(chainIdentifier), {
+    prepareToBTCLNExactIn(chainIdentifier, baseUrl, init, timeout, abortSignal, streamRequest) {
+        const responseBodyPromise = this.streamingFetchPromise(baseUrl + "/tobtcln/payInvoice?chain=" + encodeURIComponent(chainIdentifier), {
             exactIn: true,
             ...init.additionalParams,
             pr: init.pr,
@@ -533,18 +591,32 @@ class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static prepareSpvFromBTC(chainIdentifier, baseUrl, init, timeout, abortSignal, streamRequest) {
-        const responseBodyPromise = (0, StreamingFetchPromise_1.streamingFetchPromise)(baseUrl + "/frombtc_spv/getQuote?chain=" + encodeURIComponent(chainIdentifier), {
+    prepareSpvFromBTC(chainIdentifier, baseUrl, init, timeout, abortSignal, streamRequest) {
+        //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 = this.streamingFetchPromise(baseUrl + "/frombtc_spv/getQuote?chain=" + encodeURIComponent(chainIdentifier), {
             exactOut: init.exactOut,
             ...init.additionalParams,
             address: init.address,
-            amount: init.amount.toString(10),
+            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
+            stickyAddress: init.stickyAddress,
+            amountUtxos: init.amountUtxos,
+            amountFeeRate: init.amountFeeRate
         }, {
             code: SchemaVerifier_1.FieldTypeEnum.Number,
             msg: SchemaVerifier_1.FieldTypeEnum.String,
@@ -576,8 +648,8 @@ class IntermediaryAPI {
      *
      * @throws {RequestError} If non-200 http response code is returned
      */
-    static initSpvFromBTC(chainIdentifier, url, init, timeout, abortSignal, streamRequest) {
-        const responseBodyPromise = (0, StreamingFetchPromise_1.streamingFetchPromise)(url + "/postQuote?chain=" + encodeURIComponent(chainIdentifier), {
+    initSpvFromBTC(chainIdentifier, url, init, timeout, abortSignal, streamRequest) {
+        const responseBodyPromise = this.streamingFetchPromise(url + "/postQuote?chain=" + encodeURIComponent(chainIdentifier), {
             quoteId: init.quoteId,
             psbtHex: init.psbtHex
         }, {
@@ -599,5 +671,94 @@ class IntermediaryAPI {
             return result;
         });
     }
+    /**
+     * Fetches the invoice status from the intermediary node
+     *
+     * @param url Url of the trusted intermediary
+     * @param paymentHash Payment hash of the lightning invoice
+     * @param timeout Timeout in milliseconds
+     * @param abortSignal
+     * @throws {RequestError} if non-200 http response is returned
+     */
+    async getTrustedInvoiceStatus(url, paymentHash, timeout, abortSignal) {
+        return (0, RetryUtils_1.tryWithRetries)(() => this.httpGet(url + "/getInvoiceStatus?paymentHash=" + encodeURIComponent(paymentHash), timeout, abortSignal), undefined, RequestError_1.RequestError, abortSignal);
+    }
+    /**
+     * Initiate a trusted swap from BTCLN to SC native currency, retries!
+     *
+     * @param chainIdentifier
+     * @param baseUrl Base url of the trusted swap intermediary
+     * @param init Initialization parameters
+     * @param timeout Timeout in milliseconds for the request
+     * @param abortSignal
+     * @throws {RequestError} If the response is non-200
+     */
+    async initTrustedFromBTCLN(chainIdentifier, baseUrl, init, timeout, abortSignal) {
+        const resp = await (0, RetryUtils_1.tryWithRetries)(() => this.httpGet(baseUrl + "/lnforgas/createInvoice" +
+            "?address=" + encodeURIComponent(init.address) +
+            "&amount=" + encodeURIComponent(init.amount.toString(10)) +
+            "&chain=" + encodeURIComponent(chainIdentifier) +
+            "&token=" + encodeURIComponent(init.token), timeout, abortSignal), undefined, RequestError_1.RequestError, abortSignal);
+        if (resp.code !== 10000)
+            throw RequestError_1.RequestError.parse(JSON.stringify(resp), 400);
+        const res = (0, SchemaVerifier_1.verifySchema)(resp.data, TrustedFromBTCLNResponseSchema);
+        if (res == null)
+            throw new Error("Invalid response returned from LP");
+        return res;
+    }
+    /**
+     * Fetches the address status from the intermediary node
+     *
+     * @param url Url of the trusted intermediary
+     * @param paymentHash Payment hash of the swap
+     * @param sequence Sequence number of the swap
+     * @param timeout Timeout in milliseconds
+     * @param abortSignal
+     * @throws {RequestError} if non-200 http response is returned
+     */
+    async getTrustedAddressStatus(url, paymentHash, sequence, timeout, abortSignal) {
+        return (0, RetryUtils_1.tryWithRetries)(() => this.httpGet(url + "/getAddressStatus?paymentHash=" + encodeURIComponent(paymentHash) + "&sequence=" + encodeURIComponent(sequence.toString(10)), timeout, abortSignal), undefined, RequestError_1.RequestError, abortSignal);
+    }
+    /**
+     * Sets the refund address for an on-chain gas swap
+     *
+     * @param url Url of the trusted intermediary
+     * @param paymentHash Payment hash of the swap
+     * @param sequence Sequence number of the swap
+     * @param refundAddress Refund address to set for the swap
+     * @param timeout Timeout in milliseconds
+     * @param abortSignal
+     * @throws {RequestError} if non-200 http response is returned
+     */
+    async setTrustedRefundAddress(url, paymentHash, sequence, refundAddress, timeout, abortSignal) {
+        return (0, RetryUtils_1.tryWithRetries)(() => this.httpGet(url + "/setRefundAddress" +
+            "?paymentHash=" + encodeURIComponent(paymentHash) +
+            "&sequence=" + encodeURIComponent(sequence.toString(10)) +
+            "&refundAddress=" + encodeURIComponent(refundAddress), timeout, abortSignal), undefined, RequestError_1.RequestError, abortSignal);
+    }
+    /**
+     * Initiate a trusted swap from BTC to SC native currency, retries!
+     *
+     * @param chainIdentifier
+     * @param baseUrl Base url of the trusted swap intermediary
+     * @param init Initialization parameters
+     * @param timeout Timeout in milliseconds for the request
+     * @param abortSignal
+     * @throws {RequestError} If the response is non-200
+     */
+    async initTrustedFromBTC(chainIdentifier, baseUrl, init, timeout, abortSignal) {
+        const resp = await (0, RetryUtils_1.tryWithRetries)(() => this.httpGet(baseUrl + "/frombtc_trusted/getAddress?chain=" + encodeURIComponent(chainIdentifier) +
+            "&address=" + encodeURIComponent(init.address) +
+            "&amount=" + encodeURIComponent(init.amount.toString(10)) +
+            (init.refundAddress == null ? "" : "&refundAddress=" + encodeURIComponent(init.refundAddress)) +
+            "&exactIn=true" +
+            "&token=" + encodeURIComponent(init.token), timeout, abortSignal), undefined, RequestError_1.RequestError, abortSignal);
+        if (resp.code !== 10000)
+            throw RequestError_1.RequestError.parse(JSON.stringify(resp), 400);
+        const res = (0, SchemaVerifier_1.verifySchema)(resp.data, TrustedFromBTCResponseSchema);
+        if (res == null)
+            throw new Error("Invalid response returned from LP");
+        return res;
+    }
 }
 exports.IntermediaryAPI = IntermediaryAPI;