@atomiqlabs/sdk 8.7.7 → 8.9.0

package/dist/swaps/trusted/ln/LnForGasSwap.js

@@ -5,7 +5,7 @@ const bolt11_1 = require("@atomiqlabs/bolt11");
 const SwapType_1 = require("../../../enums/SwapType");
 const Utils_1 = require("../../../utils/Utils");
 const ISwap_1 = require("../../ISwap");
-const TrustedIntermediaryAPI_1 = require("../../../intermediaries/apis/TrustedIntermediaryAPI");
+const IntermediaryAPI_1 = require("../../../intermediaries/apis/IntermediaryAPI");
 const FeeType_1 = require("../../../enums/FeeType");
 const PercentagePPM_1 = require("../../../types/fees/PercentagePPM");
 const TokenAmount_1 = require("../../../types/TokenAmount");
@@ -20,32 +20,32 @@ const TimeoutUtils_1 = require("../../../utils/TimeoutUtils");
 var LnForGasSwapState;
 (function (LnForGasSwapState) {
     /**
-     * The swap quote expired without user sending in the lightning network payment
+     * The swap quote expired before the user paid the Lightning invoice
      */
     LnForGasSwapState[LnForGasSwapState["EXPIRED"] = -2] = "EXPIRED";
     /**
-     * The swap has failed after the intermediary already received a lightning network payment on the source
+     * The swap has failed before the destination payout completed, and the held Lightning invoice was released
      */
     LnForGasSwapState[LnForGasSwapState["FAILED"] = -1] = "FAILED";
     /**
-     * Swap was created, pay the provided lightning network invoice
+     * Swap was created, pay the provided Lightning invoice which will remain held until destination payout succeeds
      */
     LnForGasSwapState[LnForGasSwapState["PR_CREATED"] = 0] = "PR_CREATED";
     /**
-     * User paid the lightning network invoice on the source
+     * The Lightning invoice was paid and is currently held until the user receives the destination funds
      */
     LnForGasSwapState[LnForGasSwapState["PR_PAID"] = 1] = "PR_PAID";
     /**
-     * The swap is finished after the intermediary sent funds on the destination chain
+     * The swap is finished after the destination payout succeeded and the held Lightning invoice was settled
      */
     LnForGasSwapState[LnForGasSwapState["FINISHED"] = 2] = "FINISHED";
 })(LnForGasSwapState = exports.LnForGasSwapState || (exports.LnForGasSwapState = {}));
 const LnForGasSwapStateDescription = {
-    [LnForGasSwapState.EXPIRED]: "The swap quote expired without user sending in the lightning network payment",
-    [LnForGasSwapState.FAILED]: "The swap has failed after the intermediary already received a lightning network payment on the source",
-    [LnForGasSwapState.PR_CREATED]: "Swap was created, pay the provided lightning network invoice",
-    [LnForGasSwapState.PR_PAID]: "User paid the lightning network invoice on the source",
-    [LnForGasSwapState.FINISHED]: "The swap is finished after the intermediary sent funds on the destination chain"
+    [LnForGasSwapState.EXPIRED]: "The swap quote expired before the user paid the Lightning invoice",
+    [LnForGasSwapState.FAILED]: "The swap failed before destination payout completed, and the held Lightning invoice was released back to the user",
+    [LnForGasSwapState.PR_CREATED]: "Swap was created, pay the provided Lightning invoice. The invoice will remain held until destination payout succeeds",
+    [LnForGasSwapState.PR_PAID]: "The Lightning invoice was paid and is currently held. It will only settle once the user receives the destination funds",
+    [LnForGasSwapState.FINISHED]: "The swap is finished after the destination payout succeeded and the held Lightning invoice was settled"
 };
 function isLnForGasSwapInit(obj) {
     return typeof (obj.pr) === "string" &&
@@ -330,45 +330,149 @@ class LnForGasSwap extends ISwap_1.ISwap {
     //////////////////////////////
     //// Payment
     /**
-     * @inheritDoc
+     * @remarks Not supported
      */
-    async txsExecute() {
-        if (this._state === LnForGasSwapState.PR_CREATED) {
-            if (!await this._verifyQuoteValid())
-                throw new Error("Quote already expired or close to expiry!");
-            return [
+    async execute() {
+        throw new Error("Not supported");
+    }
+    /**
+     * @internal
+     */
+    async _getExecutionStatus() {
+        const state = this._state;
+        let lightningPaymentStatus = "inactive";
+        let destinationSettlementStatus = "inactive";
+        let buildCurrentAction = async () => undefined;
+        switch (state) {
+            case LnForGasSwapState.PR_CREATED: {
+                const quoteValid = await this._verifyQuoteValid();
+                lightningPaymentStatus = quoteValid ? "awaiting" : "soft_expired";
+                if (quoteValid) {
+                    buildCurrentAction = this._buildLightningPaymentAction.bind(this);
+                }
+                break;
+            }
+            case LnForGasSwapState.EXPIRED:
+                lightningPaymentStatus = "expired";
+                break;
+            case LnForGasSwapState.PR_PAID:
+                lightningPaymentStatus = "received";
+                destinationSettlementStatus = "waiting_lp";
+                buildCurrentAction = this._buildWaitLpAction.bind(this);
+                break;
+            case LnForGasSwapState.FAILED:
+                lightningPaymentStatus = "expired";
+                destinationSettlementStatus = "expired";
+                break;
+            case LnForGasSwapState.FINISHED:
+                lightningPaymentStatus = "confirmed";
+                destinationSettlementStatus = "settled";
+                break;
+        }
+        return {
+            steps: [
                 {
-                    name: "Payment",
-                    description: "Initiates the swap by paying up the lightning network invoice",
+                    type: "Payment",
+                    side: "source",
                     chain: "LIGHTNING",
-                    txs: [
-                        {
-                            type: "BOLT11_PAYMENT_REQUEST",
-                            address: this.pr,
-                            hyperlink: this.getHyperlink()
-                        }
-                    ]
+                    title: "Lightning payment",
+                    description: "Pay the Lightning network invoice to initiate the swap",
+                    status: lightningPaymentStatus
+                },
+                {
+                    type: "Settlement",
+                    side: "destination",
+                    chain: this.chainIdentifier,
+                    title: "Destination payout",
+                    description: "Wait for the intermediary to send the gas tokens on the destination smart chain",
+                    status: destinationSettlementStatus
                 }
-            ];
-        }
-        throw new Error("Invalid swap state to obtain execution txns, required PR_CREATED");
+            ],
+            buildCurrentAction,
+            state
+        };
     }
     /**
-     * @remark Not supported
+     * @internal
+     * @inheritDoc
      */
-    async execute() {
-        throw new Error("Not supported");
+    _submitExecutionTransactions() {
+        throw new Error("Invalid swap state for transaction submission!");
+    }
+    /**
+     * @internal
+     */
+    async _buildLightningPaymentAction() {
+        return {
+            type: "SendToAddress",
+            name: "Deposit on Lightning",
+            description: "Pay the lightning network invoice to initiate the swap",
+            chain: "LIGHTNING",
+            txs: [{
+                    type: "BOLT11_PAYMENT_REQUEST",
+                    address: this.pr,
+                    hyperlink: this.getHyperlink(),
+                    amount: this.getInput()
+                }],
+            waitForTransactions: async (maxWaitTimeSeconds, pollIntervalSeconds, abortSignal) => {
+                const abortController = (0, Utils_1.extendAbortController)(abortSignal, maxWaitTimeSeconds, "Timed out waiting for lightning payment");
+                let lightningTxId;
+                try {
+                    const success = await this.waitForPayment(pollIntervalSeconds, abortController.signal, (txId) => {
+                        lightningTxId = txId;
+                        abortController.abort();
+                    });
+                    if (!success)
+                        throw new Error("Quote expired while waiting for lightning payment");
+                }
+                catch (e) {
+                    if (lightningTxId != null)
+                        return lightningTxId;
+                    throw e;
+                }
+                return this.getInputTxId();
+            }
+        };
+    }
+    /**
+     * @internal
+     */
+    async _buildWaitLpAction() {
+        return {
+            type: "Wait",
+            name: "Awaiting LP payout",
+            description: "Wait for the intermediary to send the gas tokens on the destination smart chain",
+            pollTimeSeconds: 5,
+            expectedTimeSeconds: 10,
+            wait: async (maxWaitTimeSeconds, pollIntervalSeconds, abortSignal) => {
+                const abortController = (0, Utils_1.extendAbortController)(abortSignal, maxWaitTimeSeconds, "Timed out waiting for LP payout");
+                await this.waitForPayment(pollIntervalSeconds, abortController.signal);
+            }
+        };
     }
     /**
      * @inheritDoc
      */
-    async getCurrentActions() {
-        try {
-            return await this.txsExecute();
-        }
-        catch (e) {
-            return [];
-        }
+    async getExecutionAction() {
+        const executionStatus = await this._getExecutionStatus();
+        return executionStatus.buildCurrentAction();
+    }
+    /**
+     * @inheritDoc
+     */
+    async getExecutionStatus(options) {
+        const executionStatus = await this._getExecutionStatus();
+        return {
+            steps: executionStatus.steps,
+            currentAction: options?.skipBuildingAction ? undefined : await executionStatus.buildCurrentAction(),
+            stateInfo: this._getStateInfo(executionStatus.state)
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    async getExecutionSteps() {
+        return (await this._getExecutionStatus()).steps;
     }
     /**
      * Queries the intermediary (LP) node for the state of the swap
@@ -389,10 +493,10 @@ class LnForGasSwap extends ISwap_1.ISwap {
         const paymentHash = decodedPR.tagsObject.payment_hash;
         if (paymentHash == null)
             throw new Error("Invalid swap invoice, payment hash not found!");
-        const response = await TrustedIntermediaryAPI_1.TrustedIntermediaryAPI.getInvoiceStatus(this.url, paymentHash, this.wrapper._options.getRequestTimeout);
+        const response = await this.wrapper._lpApi.getTrustedInvoiceStatus(this.url, paymentHash, this.wrapper._options.getRequestTimeout);
         this.logger.debug("checkInvoicePaid(): LP response: ", response);
         switch (response.code) {
-            case TrustedIntermediaryAPI_1.InvoiceStatusResponseCodes.PAID:
+            case IntermediaryAPI_1.TrustedInvoiceStatusResponseCodes.PAID:
                 this.scTxId = response.data.txId;
                 const txStatus = await this.wrapper._chain.getTxIdStatus(this.scTxId);
                 if (txStatus === "success") {
@@ -402,7 +506,7 @@ class LnForGasSwap extends ISwap_1.ISwap {
                     return true;
                 }
                 return null;
-            case TrustedIntermediaryAPI_1.InvoiceStatusResponseCodes.EXPIRED:
+            case IntermediaryAPI_1.TrustedInvoiceStatusResponseCodes.EXPIRED:
                 if (this._state === LnForGasSwapState.PR_CREATED) {
                     this._state = LnForGasSwapState.EXPIRED;
                 }
@@ -412,7 +516,7 @@ class LnForGasSwap extends ISwap_1.ISwap {
                 if (save)
                     await this._saveAndEmit();
                 return false;
-            case TrustedIntermediaryAPI_1.InvoiceStatusResponseCodes.TX_SENT:
+            case IntermediaryAPI_1.TrustedInvoiceStatusResponseCodes.TX_SENT:
                 this.scTxId = response.data.txId;
                 if (this._state === LnForGasSwapState.PR_CREATED) {
                     this._state = LnForGasSwapState.PR_PAID;
@@ -420,14 +524,14 @@ class LnForGasSwap extends ISwap_1.ISwap {
                         await this._saveAndEmit();
                 }
                 return null;
-            case TrustedIntermediaryAPI_1.InvoiceStatusResponseCodes.PENDING:
+            case IntermediaryAPI_1.TrustedInvoiceStatusResponseCodes.PENDING:
                 if (this._state === LnForGasSwapState.PR_CREATED) {
                     this._state = LnForGasSwapState.PR_PAID;
                     if (save)
                         await this._saveAndEmit();
                 }
                 return null;
-            case TrustedIntermediaryAPI_1.InvoiceStatusResponseCodes.AWAIT_PAYMENT:
+            case IntermediaryAPI_1.TrustedInvoiceStatusResponseCodes.AWAIT_PAYMENT:
                 return null;
             default:
                 this._state = LnForGasSwapState.FAILED;
@@ -438,24 +542,34 @@ class LnForGasSwap extends ISwap_1.ISwap {
     }
     /**
      * A blocking promise resolving when payment was received by the intermediary and client can continue,
-     *  rejecting in case of failure. The swap must be in {@link LnForGasSwapState.PR_CREATED} state!
+     *  rejecting in case of failure. The swap must be in {@link LnForGasSwapState.PR_CREATED} or
+     *  {@link LnForGasSwapState.PR_PAID} state!
      *
      * @param checkIntervalSeconds How often to poll the intermediary for answer (default 5 seconds)
      * @param abortSignal Abort signal
+     * @param onPaymentReceived Callback as for when the LP reports having received the ln payment
      * @throws {Error} When in invalid state (not PR_CREATED)
      */
-    async waitForPayment(checkIntervalSeconds, abortSignal) {
-        if (this._state !== LnForGasSwapState.PR_CREATED)
-            throw new Error("Must be in PR_CREATED state!");
+    async waitForPayment(checkIntervalSeconds, abortSignal, onPaymentReceived) {
+        if (this._state !== LnForGasSwapState.PR_CREATED && this._state !== LnForGasSwapState.PR_PAID)
+            throw new Error("Must be in PR_CREATED or PR_PAID state!");
         if (!this.initiated) {
             this.initiated = true;
             await this._saveAndEmit();
         }
         while (!abortSignal?.aborted && (this._state === LnForGasSwapState.PR_CREATED || this._state === LnForGasSwapState.PR_PAID)) {
             await this.checkInvoicePaid(true);
+            if (this._state === LnForGasSwapState.PR_PAID) {
+                if (onPaymentReceived != null) {
+                    onPaymentReceived(this.getInputTxId());
+                    onPaymentReceived = undefined; // Set to null so it only triggers once
+                }
+            }
             if (this._state === LnForGasSwapState.PR_CREATED || this._state === LnForGasSwapState.PR_PAID)
                 await (0, TimeoutUtils_1.timeoutPromise)((checkIntervalSeconds ?? 5) * 1000, abortSignal);
         }
+        if (abortSignal != null)
+            abortSignal.throwIfAborted();
         if (this.isFailed())
             throw new Error("Swap failed");
         return !this.isQuoteExpired();

package/dist/swaps/trusted/ln/LnForGasWrapper.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LnForGasWrapper = void 0;
 const LnForGasSwap_1 = require("./LnForGasSwap");
 const ISwapWrapper_1 = require("../../ISwapWrapper");
-const TrustedIntermediaryAPI_1 = require("../../../intermediaries/apis/TrustedIntermediaryAPI");
 const bolt11_1 = require("@atomiqlabs/bolt11");
 const IntermediaryError_1 = require("../../../errors/IntermediaryError");
 const SwapType_1 = require("../../../enums/SwapType");
@@ -47,7 +46,7 @@ class LnForGasWrapper extends ISwapWrapper_1.ISwapWrapper {
             throw new Error("Not initialized, call init() first!");
         const lpUrl = typeof (lpOrUrl) === "string" ? lpOrUrl : lpOrUrl.url;
         const token = this._chain.getNativeCurrencyAddress();
-        const resp = await TrustedIntermediaryAPI_1.TrustedIntermediaryAPI.initTrustedFromBTCLN(this.chainIdentifier, lpUrl, {
+        const resp = await this._lpApi.initTrustedFromBTCLN(this.chainIdentifier, lpUrl, {
             address: recipient,
             amount,
             token

package/dist/swaps/trusted/onchain/OnchainForGasSwap.d.ts

@@ -12,7 +12,6 @@ import { FeeType } from "../../../enums/FeeType";
 import { TokenAmount } from "../../../types/TokenAmount";
 import { BtcToken, SCToken } from "../../../types/Token";
 import { LoggerType } from "../../../utils/Logger";
-import { SwapExecutionAction, SwapExecutionActionBitcoin } from "../../../types/SwapExecutionAction";
 /**
  * State enum for trusted on-chain gas swaps
  *
@@ -266,24 +265,26 @@ export declare class OnchainForGasSwap<T extends ChainType = ChainType> extends
      * @param options.bitcoinWallet Optional bitcoin wallet address specification to return a funded PSBT,
      *  if not provided an address is returned instead.
      */
-    txsExecute(options?: {
+    getExecutionAction(options?: {
         bitcoinWallet?: MinimalBitcoinWalletInterface;
-    }): Promise<[
-        SwapExecutionActionBitcoin<"ADDRESS" | "FUNDED_PSBT">
-    ]>;
+    }): Promise<never>;
     /**
-     * @remark Not supported
+     * @inheritDoc
      */
-    execute(): Promise<boolean>;
+    getExecutionSteps(): Promise<never>;
     /**
      * @inheritDoc
-     *
-     * @param options.bitcoinWallet Optional bitcoin wallet address specification to return a funded PSBT,
-     *  if not provided an address is returned instead.
      */
-    getCurrentActions(options?: {
-        bitcoinWallet?: MinimalBitcoinWalletInterface;
-    }): Promise<SwapExecutionAction<T>[]>;
+    getExecutionStatus(): Promise<never>;
+    /**
+     * @internal
+     * @inheritDoc
+     */
+    _submitExecutionTransactions(): Promise<string[]>;
+    /**
+     * @remarks Not supported
+     */
+    execute(): Promise<boolean>;
     /**
      * Queries the intermediary (LP) node for the state of the swap
      *

package/dist/swaps/trusted/onchain/OnchainForGasSwap.js

@@ -5,7 +5,7 @@ const SwapType_1 = require("../../../enums/SwapType");
 const Utils_1 = require("../../../utils/Utils");
 const BitcoinUtils_1 = require("../../../utils/BitcoinUtils");
 const ISwap_1 = require("../../ISwap");
-const TrustedIntermediaryAPI_1 = require("../../../intermediaries/apis/TrustedIntermediaryAPI");
+const IntermediaryAPI_1 = require("../../../intermediaries/apis/IntermediaryAPI");
 const IBitcoinWallet_1 = require("../../../bitcoin/wallet/IBitcoinWallet");
 const btc_signer_1 = require("@scure/btc-signer");
 const SingleAddressBitcoinWallet_1 = require("../../../bitcoin/wallet/SingleAddressBitcoinWallet");
@@ -435,50 +435,33 @@ class OnchainForGasSwap extends ISwap_1.ISwap {
      * @param options.bitcoinWallet Optional bitcoin wallet address specification to return a funded PSBT,
      *  if not provided an address is returned instead.
      */
-    async txsExecute(options) {
-        if (this._state === OnchainForGasSwapState.PR_CREATED) {
-            if (!await this._verifyQuoteValid())
-                throw new Error("Quote already expired or close to expiry!");
-            return [
-                {
-                    name: "Payment",
-                    description: "Send funds to the bitcoin swap address",
-                    chain: "BITCOIN",
-                    txs: [
-                        options?.bitcoinWallet == null ? {
-                            address: this.address,
-                            amount: Number(this.inputAmount),
-                            hyperlink: this.getHyperlink(),
-                            type: "ADDRESS"
-                        } : {
-                            ...await this.getFundedPsbt(options.bitcoinWallet),
-                            type: "FUNDED_PSBT"
-                        }
-                    ]
-                }
-            ];
-        }
-        throw new Error("Invalid swap state to obtain execution txns, required PR_CREATED or CLAIM_COMMITED");
+    async getExecutionAction(options) {
+        throw new Error("Not supported");
     }
     /**
-     * @remark Not supported
+     * @inheritDoc
      */
-    async execute() {
+    async getExecutionSteps() {
         throw new Error("Not supported");
     }
     /**
      * @inheritDoc
-     *
-     * @param options.bitcoinWallet Optional bitcoin wallet address specification to return a funded PSBT,
-     *  if not provided an address is returned instead.
      */
-    async getCurrentActions(options) {
-        try {
-            return await this.txsExecute(options);
-        }
-        catch (e) {
-            return [];
-        }
+    async getExecutionStatus() {
+        throw new Error("Not supported");
+    }
+    /**
+     * @internal
+     * @inheritDoc
+     */
+    _submitExecutionTransactions() {
+        throw new Error("Not supported");
+    }
+    /**
+     * @remarks Not supported
+     */
+    async execute() {
+        throw new Error("Not supported");
     }
     //////////////////////////////
     //// Payment
@@ -499,9 +482,9 @@ class OnchainForGasSwap extends ISwap_1.ISwap {
             return false;
         if (this.url == null)
             return false;
-        const response = await TrustedIntermediaryAPI_1.TrustedIntermediaryAPI.getAddressStatus(this.url, this.paymentHash, this.sequence, this.wrapper._options.getRequestTimeout);
+        const response = await this.wrapper._lpApi.getTrustedAddressStatus(this.url, this.paymentHash, this.sequence, this.wrapper._options.getRequestTimeout);
         switch (response.code) {
-            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.AWAIT_PAYMENT:
+            case IntermediaryAPI_1.TrustedAddressStatusResponseCodes.AWAIT_PAYMENT:
                 if (this.txId != null) {
                     this.txId = undefined;
                     if (save)
@@ -509,9 +492,9 @@ class OnchainForGasSwap extends ISwap_1.ISwap {
                     return true;
                 }
                 return false;
-            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.AWAIT_CONFIRMATION:
-            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.PENDING:
-            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.TX_SENT:
+            case IntermediaryAPI_1.TrustedAddressStatusResponseCodes.AWAIT_CONFIRMATION:
+            case IntermediaryAPI_1.TrustedAddressStatusResponseCodes.PENDING:
+            case IntermediaryAPI_1.TrustedAddressStatusResponseCodes.TX_SENT:
                 const inputAmount = BigInt(response.data.adjustedAmount);
                 const outputAmount = BigInt(response.data.adjustedTotal);
                 const adjustedFee = response.data.adjustedFee == null ? null : BigInt(response.data.adjustedFee);
@@ -532,7 +515,7 @@ class OnchainForGasSwap extends ISwap_1.ISwap {
                     return true;
                 }
                 return false;
-            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.PAID:
+            case IntermediaryAPI_1.TrustedAddressStatusResponseCodes.PAID:
                 const txStatus = await this.wrapper._chain.getTxIdStatus(response.data.txId);
                 if (txStatus === "success") {
                     this._state = OnchainForGasSwapState.FINISHED;
@@ -542,19 +525,19 @@ class OnchainForGasSwap extends ISwap_1.ISwap {
                     return true;
                 }
                 return false;
-            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.EXPIRED:
+            case IntermediaryAPI_1.TrustedAddressStatusResponseCodes.EXPIRED:
                 this._state = OnchainForGasSwapState.EXPIRED;
                 if (save)
                     await this._saveAndEmit();
                 return true;
-            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.REFUNDABLE:
+            case IntermediaryAPI_1.TrustedAddressStatusResponseCodes.REFUNDABLE:
                 if (this._state === OnchainForGasSwapState.REFUNDABLE)
                     return null;
                 this._state = OnchainForGasSwapState.REFUNDABLE;
                 if (save)
                     await this._saveAndEmit();
                 return true;
-            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.REFUNDED:
+            case IntermediaryAPI_1.TrustedAddressStatusResponseCodes.REFUNDED:
                 this._state = OnchainForGasSwapState.REFUNDED;
                 this.refundTxId = response.data.txId;
                 if (save)
@@ -581,7 +564,7 @@ class OnchainForGasSwap extends ISwap_1.ISwap {
         }
         if (this.url == null)
             throw new Error("LP URL not known, cannot set refund address!");
-        await TrustedIntermediaryAPI_1.TrustedIntermediaryAPI.setRefundAddress(this.url, this.paymentHash, this.sequence, refundAddress, this.wrapper._options.getRequestTimeout);
+        await this.wrapper._lpApi.setTrustedRefundAddress(this.url, this.paymentHash, this.sequence, refundAddress, this.wrapper._options.getRequestTimeout);
         this.refundAddress = refundAddress;
     }
     /**

package/dist/swaps/trusted/onchain/OnchainForGasWrapper.d.ts

@@ -10,6 +10,7 @@ import { UnifiedSwapEventListener } from "../../../events/UnifiedSwapEventListen
 import { UnifiedSwapStorage } from "../../../storage/UnifiedSwapStorage";
 import { ISwap } from "../../ISwap";
 import { BTC_NETWORK } from "@scure/btc-signer/utils";
+import { IntermediaryAPI } from "../../../intermediaries/apis/IntermediaryAPI";
 export type OnchainForGasWrapperOptions = ISwapWrapperOptions & {
     bitcoinNetwork: BTC_NETWORK;
 };
@@ -50,10 +51,11 @@ export declare class OnchainForGasWrapper<T extends ChainType> extends ISwapWrap
      * @param prices Pricing to use
      * @param tokens
      * @param btcRpc Bitcoin RPC which also supports getting transactions by txoHash
+     * @param lpApi
      * @param options
      * @param events Instance to use for emitting events
      */
-    constructor(chainIdentifier: string, unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], prices: ISwapPrice, tokens: WrapperCtorTokens, btcRpc: BitcoinRpcWithAddressIndex<any>, options: OnchainForGasWrapperOptions, events?: EventEmitter<{
+    constructor(chainIdentifier: string, unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], prices: ISwapPrice, tokens: WrapperCtorTokens, btcRpc: BitcoinRpcWithAddressIndex<any>, lpApi: IntermediaryAPI, options: OnchainForGasWrapperOptions, events?: EventEmitter<{
         swapState: [ISwap];
     }>);
     /**

package/dist/swaps/trusted/onchain/OnchainForGasWrapper.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnchainForGasWrapper = void 0;
 const ISwapWrapper_1 = require("../../ISwapWrapper");
-const TrustedIntermediaryAPI_1 = require("../../../intermediaries/apis/TrustedIntermediaryAPI");
 const IntermediaryError_1 = require("../../../errors/IntermediaryError");
 const OnchainForGasSwap_1 = require("./OnchainForGasSwap");
 const SwapType_1 = require("../../../enums/SwapType");
@@ -21,11 +20,12 @@ class OnchainForGasWrapper extends ISwapWrapper_1.ISwapWrapper {
      * @param prices Pricing to use
      * @param tokens
      * @param btcRpc Bitcoin RPC which also supports getting transactions by txoHash
+     * @param lpApi
      * @param options
      * @param events Instance to use for emitting events
      */
-    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, btcRpc, options, events) {
-        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, events);
+    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, btcRpc, lpApi, options, events) {
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, lpApi, options, events);
         this.TYPE = SwapType_1.SwapType.TRUSTED_FROM_BTC;
         /**
          * @internal
@@ -59,7 +59,7 @@ class OnchainForGasWrapper extends ISwapWrapper_1.ISwapWrapper {
             throw new Error("Not initialized, call init() first!");
         const lpUrl = typeof (lpOrUrl) === "string" ? lpOrUrl : lpOrUrl.url;
         const token = this._chain.getNativeCurrencyAddress();
-        const resp = await TrustedIntermediaryAPI_1.TrustedIntermediaryAPI.initTrustedFromBTC(this.chainIdentifier, lpUrl, {
+        const resp = await this._lpApi.initTrustedFromBTC(this.chainIdentifier, lpUrl, {
             address: recipient,
             amount,
             refundAddress,