@atomiqlabs/sdk 8.8.3 → 8.9.1

package/src/swaps/trusted/ln/LnForGasSwap.ts

@@ -2,9 +2,9 @@ import {decode as bolt11Decode} from "@atomiqlabs/bolt11";
 import {SwapType} from "../../../enums/SwapType";
 import {ChainType} from "@atomiqlabs/base";
 import {LnForGasSwapTypeDefinition, LnForGasWrapper} from "./LnForGasWrapper";
-import {toBigInt} from "../../../utils/Utils";
+import {extendAbortController, toBigInt} from "../../../utils/Utils";
 import {isISwapInit, ISwap, ISwapInit} from "../../ISwap";
-import {InvoiceStatusResponseCodes, TrustedIntermediaryAPI} from "../../../intermediaries/apis/TrustedIntermediaryAPI";
+import {TrustedInvoiceStatusResponseCodes} from "../../../intermediaries/apis/IntermediaryAPI";
 import {Fee} from "../../../types/fees/Fee";
 import {IAddressSwap} from "../../IAddressSwap";
 import {FeeType} from "../../../enums/FeeType";
@@ -13,7 +13,15 @@ import {TokenAmount, toTokenAmount} from "../../../types/TokenAmount";
 import {BitcoinTokens, BtcToken, SCToken} from "../../../types/Token";
 import {getLogger, LoggerType} from "../../../utils/Logger";
 import {timeoutPromise} from "../../../utils/TimeoutUtils";
-import {SwapExecutionAction, SwapExecutionActionLightning} from "../../../types/SwapExecutionAction";
+import {
+    SwapExecutionActionSendToAddress,
+    SwapExecutionActionWait
+} from "../../../types/SwapExecutionAction";
+import {
+    SwapExecutionStepPayment,
+    SwapExecutionStepSettlement
+} from "../../../types/SwapExecutionStep";
+import {SwapStateInfo} from "../../../types/SwapStateInfo";
 
 /**
  * State enum for trusted Lightning gas swaps
@@ -22,38 +30,38 @@ import {SwapExecutionAction, SwapExecutionActionLightning} from "../../../types/
  */
 export enum LnForGasSwapState {
     /**
-     * The swap quote expired without user sending in the lightning network payment
+     * The swap quote expired before the user paid the Lightning invoice
      */
     EXPIRED = -2,
     /**
-     * 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
      */
     FAILED = -1,
     /**
-     * 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
      */
     PR_CREATED = 0,
     /**
-     * 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
      */
     PR_PAID = 1,
     /**
-     * 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
      */
     FINISHED = 2
 }
 
 const LnForGasSwapStateDescription = {
     [LnForGasSwapState.EXPIRED]:
-        "The swap quote expired without user sending in the lightning network payment",
+        "The swap quote expired before the user paid the Lightning invoice",
     [LnForGasSwapState.FAILED]:
-        "The swap has failed after the intermediary already received a lightning network payment on the source",
+        "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 network invoice",
+        "Swap was created, pay the provided Lightning invoice. The invoice will remain held until destination payout succeeds",
     [LnForGasSwapState.PR_PAID]:
-        "User paid the lightning network invoice on the source",
+        "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 intermediary sent funds on the destination chain"
+        "The swap is finished after the destination payout succeeded and the held Lightning invoice was settled"
 }
 
 export type LnForGasSwapInit = ISwapInit & {
@@ -403,46 +411,191 @@ export class LnForGasSwap<T extends ChainType = ChainType> extends ISwap<T, LnFo
     //// Payment
 
     /**
-     * @inheritDoc
+     * @remarks Not supported
      */
-    async txsExecute(): Promise<[SwapExecutionActionLightning]> {
-        if(this._state===LnForGasSwapState.PR_CREATED) {
-            if (!await this._verifyQuoteValid()) throw new Error("Quote already expired or close to expiry!");
-            return [
+    async execute(): Promise<boolean> {
+        throw new Error("Not supported");
+    }
+
+    /**
+     * @internal
+     */
+    protected async _getExecutionStatus() {
+        const state = this._state;
+
+        let lightningPaymentStatus: SwapExecutionStepPayment<"LIGHTNING">["status"] = "inactive";
+        let destinationSettlementStatus: SwapExecutionStepSettlement<T["ChainId"]>["status"] = "inactive";
+        let buildCurrentAction: () => Promise<
+            SwapExecutionActionSendToAddress<true> |
+            SwapExecutionActionWait<"LP"> |
+            undefined
+        > = 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" as const,
-                    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
+                }
+            ] as [
+                SwapExecutionStepPayment<"LIGHTNING">,
+                SwapExecutionStepSettlement<T["ChainId"], never>
+            ],
+            buildCurrentAction,
+            state
+        };
+    }
+
+    /**
+     * @internal
+     * @inheritDoc
+     */
+    _submitExecutionTransactions(): Promise<string[]> {
+        throw new Error("Invalid swap state for transaction submission!");
+    }
+
+    /**
+     * @internal
+     */
+    private async _buildLightningPaymentAction(): Promise<SwapExecutionActionSendToAddress<true>> {
+        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?: number, pollIntervalSeconds?: number, abortSignal?: AbortSignal
+            ) => {
+                const abortController = extendAbortController(
+                    abortSignal, maxWaitTimeSeconds, "Timed out waiting for lightning payment"
+                );
+                let lightningTxId: string | undefined;
+                try {
+                    const success = await this.waitForPayment(
+                        pollIntervalSeconds, abortController.signal,
+                        (txId: string) => {
+                            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()!;
+            }
+        } as SwapExecutionActionSendToAddress<true>;
+    }
 
-        throw new Error("Invalid swap state to obtain execution txns, required PR_CREATED");
+    /**
+     * @internal
+     */
+    private async _buildWaitLpAction(): Promise<SwapExecutionActionWait<"LP">> {
+        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?: number, pollIntervalSeconds?: number, abortSignal?: AbortSignal
+            ) => {
+                const abortController = extendAbortController(
+                    abortSignal, maxWaitTimeSeconds, "Timed out waiting for LP payout"
+                );
+                await this.waitForPayment(pollIntervalSeconds, abortController.signal);
+            }
+        } as SwapExecutionActionWait<"LP">;
     }
 
     /**
-     * @remark Not supported
+     * @inheritDoc
      */
-    async execute(): Promise<boolean> {
-        throw new Error("Not supported");
+    async getExecutionAction(): Promise<
+        SwapExecutionActionSendToAddress<true> |
+        SwapExecutionActionWait<"LP"> |
+        undefined
+    > {
+        const executionStatus = await this._getExecutionStatus();
+        return executionStatus.buildCurrentAction();
     }
 
     /**
      * @inheritDoc
      */
-    async getCurrentActions(): Promise<SwapExecutionAction<T>[]> {
-        try {
-            return await this.txsExecute();
-        } catch (e) {
-            return [];
-        }
+    async getExecutionStatus(options?: {skipBuildingAction?: boolean}): Promise<{
+        steps: [
+            SwapExecutionStepPayment<"LIGHTNING">,
+            SwapExecutionStepSettlement<T["ChainId"], never>
+        ],
+        currentAction:
+            SwapExecutionActionSendToAddress<true> |
+            SwapExecutionActionWait<"LP"> |
+            undefined,
+        stateInfo: SwapStateInfo<LnForGasSwapState>
+    }> {
+        const executionStatus = await this._getExecutionStatus();
+        return {
+            steps: executionStatus.steps,
+            currentAction: options?.skipBuildingAction ? undefined : await executionStatus.buildCurrentAction(),
+            stateInfo: this._getStateInfo(executionStatus.state)
+        };
+    }
+
+    /**
+     * @inheritDoc
+     */
+    async getExecutionSteps(): Promise<[
+        SwapExecutionStepPayment<"LIGHTNING">,
+        SwapExecutionStepSettlement<T["ChainId"], never>
+    ]> {
+        return (await this._getExecutionStatus()).steps;
     }
 
     /**
@@ -462,12 +615,12 @@ export class LnForGasSwap<T extends ChainType = ChainType> extends ISwap<T, LnFo
         const paymentHash = decodedPR.tagsObject.payment_hash;
         if(paymentHash==null) throw new Error("Invalid swap invoice, payment hash not found!");
 
-        const response = await TrustedIntermediaryAPI.getInvoiceStatus(
+        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 InvoiceStatusResponseCodes.PAID:
+            case TrustedInvoiceStatusResponseCodes.PAID:
                 this.scTxId = response.data.txId;
                 const txStatus = await this.wrapper._chain.getTxIdStatus(this.scTxId);
                 if(txStatus==="success") {
@@ -476,7 +629,7 @@ export class LnForGasSwap<T extends ChainType = ChainType> extends ISwap<T, LnFo
                     return true;
                 }
                 return null;
-            case InvoiceStatusResponseCodes.EXPIRED:
+            case TrustedInvoiceStatusResponseCodes.EXPIRED:
                 if(this._state===LnForGasSwapState.PR_CREATED) {
                     this._state = LnForGasSwapState.EXPIRED;
                 } else {
@@ -484,20 +637,20 @@ export class LnForGasSwap<T extends ChainType = ChainType> extends ISwap<T, LnFo
                 }
                 if(save) await this._saveAndEmit();
                 return false;
-            case InvoiceStatusResponseCodes.TX_SENT:
+            case TrustedInvoiceStatusResponseCodes.TX_SENT:
                 this.scTxId = response.data.txId;
                 if(this._state===LnForGasSwapState.PR_CREATED) {
                     this._state = LnForGasSwapState.PR_PAID;
                     if(save) await this._saveAndEmit();
                 }
                 return null;
-            case InvoiceStatusResponseCodes.PENDING:
+            case TrustedInvoiceStatusResponseCodes.PENDING:
                 if(this._state===LnForGasSwapState.PR_CREATED) {
                     this._state = LnForGasSwapState.PR_PAID;
                     if(save) await this._saveAndEmit();
                 }
                 return null;
-            case InvoiceStatusResponseCodes.AWAIT_PAYMENT:
+            case TrustedInvoiceStatusResponseCodes.AWAIT_PAYMENT:
                 return null;
             default:
                 this._state = LnForGasSwapState.FAILED;
@@ -508,14 +661,17 @@ export class LnForGasSwap<T extends ChainType = ChainType> extends ISwap<T, LnFo
 
     /**
      * 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?: number, abortSignal?: AbortSignal): Promise<boolean> {
-        if(this._state!==LnForGasSwapState.PR_CREATED) throw new Error("Must be in PR_CREATED state!");
+    async waitForPayment(checkIntervalSeconds?: number, abortSignal?: AbortSignal, onPaymentReceived?: (txId: string) => void): Promise<boolean> {
+        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;
@@ -524,9 +680,17 @@ export class LnForGasSwap<T extends ChainType = ChainType> extends ISwap<T, LnFo
 
         while(!abortSignal?.aborted && (this._state===LnForGasSwapState.PR_CREATED || this._state===LnForGasSwapState.PR_PAID)) {
             await this.checkInvoicePaid(true);
+            if((this._state as LnForGasSwapState)===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 timeoutPromise((checkIntervalSeconds ?? 5)*1000, abortSignal);
         }
 
+        if(abortSignal!=null) abortSignal.throwIfAborted();
+
         if(this.isFailed()) throw new Error("Swap failed");
         return !this.isQuoteExpired();
 

package/src/swaps/trusted/ln/LnForGasWrapper.ts

@@ -1,6 +1,5 @@
 import {LnForGasSwap, LnForGasSwapInit, LnForGasSwapState} from "./LnForGasSwap";
 import {ISwapWrapper, SwapTypeDefinition} from "../../ISwapWrapper";
-import {TrustedIntermediaryAPI} from "../../../intermediaries/apis/TrustedIntermediaryAPI";
 import {decode as bolt11Decode} from "@atomiqlabs/bolt11";
 import {IntermediaryError} from "../../../errors/IntermediaryError";
 import {ChainType} from "@atomiqlabs/base";
@@ -50,7 +49,7 @@ export class LnForGasWrapper<T extends ChainType> extends ISwapWrapper<T, LnForG
 
         const token = this._chain.getNativeCurrencyAddress();
 
-        const resp = await TrustedIntermediaryAPI.initTrustedFromBTCLN(this.chainIdentifier, lpUrl, {
+        const resp = await this._lpApi.initTrustedFromBTCLN(this.chainIdentifier, lpUrl, {
             address: recipient,
             amount,
             token

package/src/swaps/trusted/onchain/OnchainForGasSwap.ts

@@ -3,7 +3,7 @@ import {ChainType} from "@atomiqlabs/base";
 import {toBigInt} from "../../../utils/Utils";
 import {parsePsbtTransaction, toOutputScript} from "../../../utils/BitcoinUtils";
 import {isISwapInit, ISwap, ISwapInit} from "../../ISwap";
-import {AddressStatusResponseCodes, TrustedIntermediaryAPI} from "../../../intermediaries/apis/TrustedIntermediaryAPI";
+import {TrustedAddressStatusResponseCodes} from "../../../intermediaries/apis/IntermediaryAPI";
 import {OnchainForGasSwapTypeDefinition, OnchainForGasWrapper} from "./OnchainForGasWrapper";
 import {Fee} from "../../../types/fees/Fee";
 import {IBitcoinWallet, isIBitcoinWallet} from "../../../bitcoin/wallet/IBitcoinWallet";
@@ -23,7 +23,6 @@ import {BitcoinTokens, BtcToken, SCToken} from "../../../types/Token";
 import {getLogger, LoggerType} from "../../../utils/Logger";
 import {timeoutPromise} from "../../../utils/TimeoutUtils";
 import {toBitcoinWallet} from "../../../utils/BitcoinWalletUtils";
-import {SwapExecutionAction, SwapExecutionActionBitcoin} from "../../../types/SwapExecutionAction";
 
 /**
  * State enum for trusted on-chain gas swaps
@@ -562,57 +561,39 @@ export class OnchainForGasSwap<T extends ChainType = ChainType> extends ISwap<T,
      * @param options.bitcoinWallet Optional bitcoin wallet address specification to return a funded PSBT,
      *  if not provided an address is returned instead.
      */
-    async txsExecute(options?: {
+    async getExecutionAction(options?: {
         bitcoinWallet?: MinimalBitcoinWalletInterface
-    }): Promise<[
-        SwapExecutionActionBitcoin<"ADDRESS" | "FUNDED_PSBT">
-    ]> {
-        if(this._state===OnchainForGasSwapState.PR_CREATED) {
-            if(!await this._verifyQuoteValid()) throw new Error("Quote already expired or close to expiry!");
-            return [
-                {
-                    name: "Payment" as const,
-                    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"
-                        }
-                    ]
-                }
-            ];
-        }
+    }): Promise<never> {
+        throw new Error("Not supported");
+    }
 
-        throw new Error("Invalid swap state to obtain execution txns, required PR_CREATED or CLAIM_COMMITED");
+    /**
+     * @inheritDoc
+     */
+    async getExecutionSteps(): Promise<never> {
+        throw new Error("Not supported");
     }
 
     /**
-     * @remark Not supported
+     * @inheritDoc
      */
-    async execute(): Promise<boolean> {
+    async getExecutionStatus(): Promise<never> {
         throw new Error("Not supported");
     }
 
     /**
+     * @internal
      * @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?: {
-        bitcoinWallet?: MinimalBitcoinWalletInterface
-    }): Promise<SwapExecutionAction<T>[]> {
-        try {
-            return await this.txsExecute(options);
-        } catch (e) {
-            return [];
-        }
+    _submitExecutionTransactions(): Promise<string[]> {
+        throw new Error("Not supported");
+    }
+
+    /**
+     * @remarks Not supported
+     */
+    async execute(): Promise<boolean> {
+        throw new Error("Not supported");
     }
 
     //////////////////////////////
@@ -635,20 +616,20 @@ export class OnchainForGasSwap<T extends ChainType = ChainType> extends ISwap<T,
         if(this._state===OnchainForGasSwapState.FINISHED) return false;
         if(this.url==null) return false;
 
-        const response = await TrustedIntermediaryAPI.getAddressStatus(
+        const response = await this.wrapper._lpApi.getTrustedAddressStatus(
             this.url, this.paymentHash, this.sequence, this.wrapper._options.getRequestTimeout
         );
         switch(response.code) {
-            case AddressStatusResponseCodes.AWAIT_PAYMENT:
+            case TrustedAddressStatusResponseCodes.AWAIT_PAYMENT:
                 if(this.txId!=null) {
                     this.txId = undefined;
                     if(save) await this._save();
                     return true;
                 }
                 return false;
-            case AddressStatusResponseCodes.AWAIT_CONFIRMATION:
-            case AddressStatusResponseCodes.PENDING:
-            case AddressStatusResponseCodes.TX_SENT:
+            case TrustedAddressStatusResponseCodes.AWAIT_CONFIRMATION:
+            case TrustedAddressStatusResponseCodes.PENDING:
+            case 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);
@@ -668,7 +649,7 @@ export class OnchainForGasSwap<T extends ChainType = ChainType> extends ISwap<T,
                     return true;
                 }
                 return false;
-            case AddressStatusResponseCodes.PAID:
+            case TrustedAddressStatusResponseCodes.PAID:
                 const txStatus = await this.wrapper._chain.getTxIdStatus(response.data.txId);
                 if(txStatus==="success") {
                     this._state = OnchainForGasSwapState.FINISHED;
@@ -677,16 +658,16 @@ export class OnchainForGasSwap<T extends ChainType = ChainType> extends ISwap<T,
                     return true;
                 }
                 return false;
-            case AddressStatusResponseCodes.EXPIRED:
+            case TrustedAddressStatusResponseCodes.EXPIRED:
                 this._state = OnchainForGasSwapState.EXPIRED;
                 if(save) await this._saveAndEmit();
                 return true;
-            case AddressStatusResponseCodes.REFUNDABLE:
+            case TrustedAddressStatusResponseCodes.REFUNDABLE:
                 if(this._state===OnchainForGasSwapState.REFUNDABLE) return null;
                 this._state = OnchainForGasSwapState.REFUNDABLE;
                 if(save) await this._saveAndEmit();
                 return true;
-            case AddressStatusResponseCodes.REFUNDED:
+            case TrustedAddressStatusResponseCodes.REFUNDED:
                 this._state = OnchainForGasSwapState.REFUNDED;
                 this.refundTxId = response.data.txId;
                 if(save) await this._saveAndEmit();
@@ -710,7 +691,7 @@ export class OnchainForGasSwap<T extends ChainType = ChainType> extends ISwap<T,
             return;
         }
         if(this.url==null) throw new Error("LP URL not known, cannot set refund address!");
-        await TrustedIntermediaryAPI.setRefundAddress(
+        await this.wrapper._lpApi.setTrustedRefundAddress(
             this.url, this.paymentHash, this.sequence, refundAddress, this.wrapper._options.getRequestTimeout
         );
         this.refundAddress = refundAddress;

package/src/swaps/trusted/onchain/OnchainForGasWrapper.ts

@@ -1,5 +1,4 @@
 import {ISwapWrapper, ISwapWrapperOptions, SwapTypeDefinition, WrapperCtorTokens} from "../../ISwapWrapper";
-import {TrustedIntermediaryAPI} from "../../../intermediaries/apis/TrustedIntermediaryAPI";
 import {IntermediaryError} from "../../../errors/IntermediaryError";
 import {BitcoinRpcWithAddressIndex, ChainType} from "@atomiqlabs/base";
 import {OnchainForGasSwap, OnchainForGasSwapInit, OnchainForGasSwapState} from "./OnchainForGasSwap";
@@ -11,6 +10,7 @@ import {UnifiedSwapEventListener} from "../../../events/UnifiedSwapEventListener
 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
@@ -57,6 +57,7 @@ export class OnchainForGasWrapper<T extends ChainType> extends ISwapWrapper<T, O
      * @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
      */
@@ -68,10 +69,11 @@ export class OnchainForGasWrapper<T extends ChainType> extends ISwapWrapper<T, O
         prices: ISwapPrice,
         tokens: WrapperCtorTokens,
         btcRpc: BitcoinRpcWithAddressIndex<any>,
+        lpApi: IntermediaryAPI,
         options: OnchainForGasWrapperOptions,
         events?: EventEmitter<{swapState: [ISwap]}>
     ) {
-        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, events);
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, lpApi, options, events);
         this._btcRpc = btcRpc;
     }
 
@@ -91,7 +93,7 @@ export class OnchainForGasWrapper<T extends ChainType> extends ISwapWrapper<T, O
 
         const token = this._chain.getNativeCurrencyAddress();
 
-        const resp = await TrustedIntermediaryAPI.initTrustedFromBTC(this.chainIdentifier, lpUrl, {
+        const resp = await this._lpApi.initTrustedFromBTC(this.chainIdentifier, lpUrl, {
             address: recipient,
             amount,
             refundAddress,