@atomiqlabs/sdk 8.8.3 → 8.9.0

package/dist/swaps/spv_swaps/SpvFromBTCWrapper.js

@@ -9,7 +9,6 @@ const SwapType_1 = require("../../enums/SwapType");
 const Intermediary_1 = require("../../intermediaries/Intermediary");
 const Utils_1 = require("../../utils/Utils");
 const BitcoinUtils_1 = require("../../utils/BitcoinUtils");
-const IntermediaryAPI_1 = require("../../intermediaries/apis/IntermediaryAPI");
 const RequestError_1 = require("../../errors/RequestError");
 const IntermediaryError_1 = require("../../errors/IntermediaryError");
 const btc_signer_1 = require("@scure/btc-signer");
@@ -37,11 +36,12 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
      * @param versionedContracts
      * @param versionedSynchronizer
      * @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, versionedContracts, versionedSynchronizer, btcRpc, options, events) {
-        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, {
+    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, versionedContracts, versionedSynchronizer, btcRpc, lpApi, options, events) {
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, lpApi, {
             ...options,
             bitcoinNetwork: options?.bitcoinNetwork ?? utils_1.TEST_NETWORK,
             maxConfirmations: options?.maxConfirmations ?? 6,
@@ -602,7 +602,7 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
                     const callerFeeRatePromise = this.computeCallerFeeShare(amountPromise, callerFeePrefetchPromise[version], amountData, _options, pricePrefetchPromise, gasTokenPricePrefetchPromise, abortController.signal);
                     try {
                         const resp = await (0, RetryUtils_1.tryWithRetries)(async (retryCount) => {
-                            return await IntermediaryAPI_1.IntermediaryAPI.prepareSpvFromBTC(this.chainIdentifier, lp.url, {
+                            return await this._lpApi.prepareSpvFromBTC(this.chainIdentifier, lp.url, {
                                 address: recipient,
                                 amount: (0, Utils_1.throwIfUndefined)(amountPromise, "Failed to compute swap amount"),
                                 token: amountData.token.toString(),
@@ -670,7 +670,7 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
                             callerFeeShare: resp.callerFeeShare,
                             frontingFeeShare: resp.frontingFeeShare,
                             executionFeeShare: resp.executionFeeShare,
-                            genesisSmartChainBlockHeight: await (0, Utils_1.throwIfUndefined)(finalizedBlockHeightPrefetchPromise, "Finalize block height promise failed!"),
+                            genesisSmartChainBlockHeight: await (0, Utils_1.throwIfUndefined)(finalizedBlockHeightPrefetchPromise, "Network finalized blockheight pre-fetch failed!"),
                             contractVersion: version
                         };
                         const quote = new SpvFromBTCSwap_1.SpvFromBTCSwap(this, swapInit);

package/dist/swaps/trusted/ln/LnForGasSwap.d.ts

@@ -8,7 +8,9 @@ import { FeeType } from "../../../enums/FeeType";
 import { TokenAmount } from "../../../types/TokenAmount";
 import { BtcToken, SCToken } from "../../../types/Token";
 import { LoggerType } from "../../../utils/Logger";
-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
  *
@@ -16,23 +18,23 @@ import { SwapExecutionAction, SwapExecutionActionLightning } from "../../../type
  */
 export declare 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
 }
@@ -210,17 +212,54 @@ export declare class LnForGasSwap<T extends ChainType = ChainType> extends ISwap
         fee: Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>>;
     }];
     /**
+     * @remarks Not supported
+     */
+    execute(): Promise<boolean>;
+    /**
+     * @internal
+     */
+    protected _getExecutionStatus(): Promise<{
+        steps: [SwapExecutionStepPayment<"LIGHTNING">, SwapExecutionStepSettlement<T["ChainId"], never>];
+        buildCurrentAction: () => Promise<SwapExecutionActionSendToAddress<true> | SwapExecutionActionWait<"LP"> | undefined>;
+        state: LnForGasSwapState;
+    }>;
+    /**
+     * @internal
      * @inheritDoc
      */
-    txsExecute(): Promise<[SwapExecutionActionLightning]>;
+    _submitExecutionTransactions(): Promise<string[]>;
     /**
-     * @remark Not supported
+     * @internal
      */
-    execute(): Promise<boolean>;
+    private _buildLightningPaymentAction;
+    /**
+     * @internal
+     */
+    private _buildWaitLpAction;
+    /**
+     * @inheritDoc
+     */
+    getExecutionAction(): Promise<SwapExecutionActionSendToAddress<true> | SwapExecutionActionWait<"LP"> | undefined>;
+    /**
+     * @inheritDoc
+     */
+    getExecutionStatus(options?: {
+        skipBuildingAction?: boolean;
+    }): Promise<{
+        steps: [
+            SwapExecutionStepPayment<"LIGHTNING">,
+            SwapExecutionStepSettlement<T["ChainId"], never>
+        ];
+        currentAction: SwapExecutionActionSendToAddress<true> | SwapExecutionActionWait<"LP"> | undefined;
+        stateInfo: SwapStateInfo<LnForGasSwapState>;
+    }>;
     /**
      * @inheritDoc
      */
-    getCurrentActions(): Promise<SwapExecutionAction<T>[]>;
+    getExecutionSteps(): Promise<[
+        SwapExecutionStepPayment<"LIGHTNING">,
+        SwapExecutionStepSettlement<T["ChainId"], never>
+    ]>;
     /**
      * Queries the intermediary (LP) node for the state of the swap
      *
@@ -232,13 +271,15 @@ export declare class LnForGasSwap<T extends ChainType = ChainType> extends ISwap
     protected checkInvoicePaid(save?: boolean): Promise<boolean | null>;
     /**
      * 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)
      */
-    waitForPayment(checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
+    waitForPayment(checkIntervalSeconds?: number, abortSignal?: AbortSignal, onPaymentReceived?: (txId: string) => void): Promise<boolean>;
     /**
      * @inheritDoc
      */

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
      *