@atomiqlabs/sdk 8.8.3 → 8.9.1

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,

package/dist/types/SwapExecutionAction.d.ts

@@ -1,88 +1,195 @@
 import { ChainType } from "@atomiqlabs/base";
 import { Transaction } from "@scure/btc-signer";
+import { TokenAmount } from "./TokenAmount";
+import { BtcToken } from "./Token";
 /**
- * Swap execution action requiring a payment of the provided bolt11 lightning network invoice
+ * Swap execution action requiring the user to send assets to a specific LIGHTNING invoice or BITCOIN
+ *  on-chain address
  *
  * @category Swap Actions
  */
-export type SwapExecutionActionLightning = {
-    name: "Payment";
+export type SwapExecutionActionSendToAddress<Lightning extends boolean = boolean> = {
+    type: "SendToAddress";
+    /**
+     * Human-readable name of the action
+     */
+    name: Lightning extends true ? "Deposit on Lightning" : "Deposit on Bitcoin";
+    /**
+     * Human-readable description of the action
+     */
     description: string;
-    chain: "LIGHTNING";
+    /**
+     * Chain on which the payment is expected, either `LIGHTNING` or `BITCOIN` for on-chain
+     */
+    chain: Lightning extends true ? "LIGHTNING" : "BITCOIN";
+    /**
+     * An array of payments that should be made to different addresses, usually only a single address is returned
+     */
     txs: {
-        type: "BOLT11_PAYMENT_REQUEST";
+        type: Lightning extends true ? "BOLT11_PAYMENT_REQUEST" : "BITCOIN_ADDRESS";
         address: string;
         hyperlink: string;
+        amount: TokenAmount<BtcToken<Lightning>, true>;
     }[];
+    /**
+     * Waits till the transaction is received, doesn't wait for the actual confirmation!
+     *
+     * @returns A transaction ID of the received transaction
+     */
+    waitForTransactions: (maxWaitTimeSeconds?: number, pollIntervalSeconds?: number, abortSignal?: AbortSignal) => Promise<string>;
 };
 /**
- * Swap execution action on on-chain Bitcoin, has following types:
- * - `"ADDRESS"` - Destination bitcoin address and BTC amount to be sent
+ * Type guard for {@link SwapExecutionActionSendToAddress}
+ *
+ * @category Swap Actions
+ */
+export declare function isSwapExecutionActionSendToAddress<Lightning extends boolean = boolean>(obj: any, lightning?: Lightning): obj is SwapExecutionActionSendToAddress<Lightning>;
+/**
+ * Swap execution action requiring the user to sign the provided PSBT and then submit it back via the provided
+ *  `submitPsbt()` function, has two variations:
  * - `"FUNDED_PSBT"` - A ready to sign PSBT with the inputs populated from the provided bitcoin wallet address
  * - `"RAW_PSBT"` - Raw PSBT without the inputs, the implementor needs to add the input UTXOs before signing
- *  the transaction
+ *  the transaction (also make sure to set the `nSequence` field of the 2nd input, index 1, to the provided
+ *  `in1sequence` value)
  *
  * @category Swap Actions
  */
-export type SwapExecutionActionBitcoin<T extends "ADDRESS" | "FUNDED_PSBT" | "RAW_PSBT" = "ADDRESS" | "FUNDED_PSBT" | "RAW_PSBT"> = {
-    name: "Payment";
+export type SwapExecutionActionSignPSBT<T extends "FUNDED_PSBT" | "RAW_PSBT" = "FUNDED_PSBT" | "RAW_PSBT"> = {
+    type: "SignPSBT";
+    /**
+     * Human-readable name of the action
+     */
+    name: "Deposit on Bitcoin";
+    /**
+     * Human-readable description of the action
+     */
     description: string;
+    /**
+     * Chain is always bitcoin
+     */
     chain: "BITCOIN";
-    txs: (T extends "ADDRESS" ? {
-        type: "ADDRESS";
-        amount: number;
-        address: string;
-        hyperlink: string;
-    } : T extends "FUNDED_PSBT" ? {
+    /**
+     * An array of PSBTs that need to be signed, usually contains only a single PSBT
+     */
+    txs: T extends "FUNDED_PSBT" ? {
         type: "FUNDED_PSBT";
         psbt: Transaction;
         psbtHex: string;
         psbtBase64: string;
         signInputs: number[];
-    } : {
+        feeRate: number;
+    }[] : {
         type: "RAW_PSBT";
         psbt: Transaction;
         psbtHex: string;
         psbtBase64: string;
         in1sequence: number;
-    })[];
+        feeRate: number;
+    }[];
+    /**
+     * Submit a signed PSBT, accepts hexadecimal, base64 and `@scure/btc-signer` {@link Transaction} object.
+     *
+     * @returns An array of transaction IDs of the submitted Bitcoin transactions
+     */
+    submitPsbt: (signedPsbt: string | Transaction | (string | Transaction)[], idempotent?: boolean) => Promise<string[]>;
 };
 /**
- * Swap execution action for committing (initiating) the escrow on the smart chain side
+ * Type guard for {@link SwapExecutionActionSignPSBT}
  *
  * @category Swap Actions
  */
-export type SwapExecutionActionCommit<T extends ChainType> = {
-    name: "Commit";
-    description: string;
-    chain: T["ChainId"];
-    txs: T["TX"][];
-};
+export declare function isSwapExecutionActionSignPSBT<T extends "FUNDED_PSBT" | "RAW_PSBT" = "FUNDED_PSBT" | "RAW_PSBT">(obj: any, psbtType?: T): obj is SwapExecutionActionSignPSBT<T>;
 /**
- * Swap execution action for claiming (settling) the swap on the smart chain side
+ * Swap execution action requiring the user to sign the provided smart chain transactions, these can then
+ *  be either broadcasted manually, or sent via the provided `submitTransactions()` function
  *
  * @category Swap Actions
  */
-export type SwapExecutionActionClaim<T extends ChainType> = {
-    name: "Claim";
+export type SwapExecutionActionSignSmartChainTx<T extends ChainType = ChainType> = {
+    type: "SignSmartChainTransaction";
+    /**
+     * Human-readable name of the action
+     */
+    name: "Initiate swap" | "Settle manually" | "Refund";
+    /**
+     * Human-readable description of the action
+     */
     description: string;
+    /**
+     * Chain identifier of the smart chain on which the corresponding transactions should be signed
+     */
     chain: T["ChainId"];
+    /**
+     * Smart chain transactions that should be signed and either broadcasted manually or submitted back
+     *  to the provided `submitTransactions()` function
+     */
     txs: T["TX"][];
+    /**
+     * Submits the signed transactions and waits for their confirmation
+     *
+     * @remarks This might not do any validation on the submitted transactions, so returned txids are informational
+     *  only and may not be persisted immediately. The swap may wait for an authoritative state transition before
+     *  considering the submitted transactions accepted.
+     *
+     *  Make sure to only submit valid signed transactions obtained from this action object, and pass an AbortSignal
+     *  if you need a timeout, otherwise this call can wait indefinitely when invalid transactions are submitted.
+     */
+    submitTransactions: (txs: (T["SignedTXType"] | string)[], abortSignal?: AbortSignal, idempotent?: boolean) => Promise<string[]>;
+    /**
+     * The address of the signer that has to sign the transactions
+     */
+    requiredSigner: string;
 };
 /**
- * Swap execution action for refunding the swap on the smart chain side after it fails
+ * Type guard for {@link SwapExecutionActionSignSmartChainTx}
  *
  * @category Swap Actions
  */
-export type SwapExecutionActionRefund<T extends ChainType> = {
-    name: "Refund";
+export declare function isSwapExecutionActionSignSmartChainTx<T extends ChainType = ChainType>(obj: any, chainIdentifier?: T["ChainId"] | T["ChainId"][]): obj is SwapExecutionActionSignSmartChainTx<T>;
+/**
+ * Swap action indicating that the user should wait for either LP to process the swap, automatic settlement to happen or
+ *  until the Bitcoin transaction gets enough confirmations
+ *
+ * @category Swap Actions
+ */
+export type SwapExecutionActionWait<T extends "LP" | "SETTLEMENT" | "BITCOIN_CONFS" = "LP" | "SETTLEMENT" | "BITCOIN_CONFS"> = {
+    type: "Wait";
+    /**
+     * Human-readable name of the action
+     */
+    name: T extends "LP" ? "Awaiting LP payout" : T extends "SETTLEMENT" ? "Automatic settlement" : "Bitcoin confirmations";
+    /**
+     * Human-readable description of the action
+     */
     description: string;
-    chain: T["ChainId"];
-    txs: T["TX"][];
+    /**
+     * Allows you to await till this action resolves
+     *
+     * @param maxWaitTimeSeconds Maximum time in seconds to wait for
+     * @param pollIntervalSeconds How often to poll for the state change (default 5 seconds)
+     * @param abortSignal AbortSignal to abort the wait
+     * @param btcConfirmationsCallback Optional callback when awaiting bitcoin confirmations, gets called when
+     *  number of bitcoin confirmations change
+     */
+    wait: T extends "BITCOIN_CONFS" ? (maxWaitTimeSeconds?: number, pollIntervalSeconds?: number, abortSignal?: AbortSignal, btcConfirmationsCallback?: (txId?: string, confirmations?: number, targetConfirmations?: number, txEtaMs?: number) => void) => Promise<void> : (maxWaitTimeSeconds?: number, pollIntervalSeconds?: number, abortSignal?: AbortSignal) => Promise<void>;
+    /**
+     * Expected time in seconds for this action to take
+     */
+    expectedTimeSeconds: number;
+    /**
+     * Recommended time interval in seconds after which you should re-check the current action
+     */
+    pollTimeSeconds: number;
 };
+/**
+ * Type guard for {@link SwapExecutionActionWait}
+ *
+ * @category Swap Actions
+ */
+export declare function isSwapExecutionActionWait<T extends "LP" | "SETTLEMENT" | "BITCOIN_CONFS" = "LP" | "SETTLEMENT" | "BITCOIN_CONFS">(obj: any, waitType?: T): obj is SwapExecutionActionWait<T>;
 /**
  * Swap execution action, a single step in the swapping process
  *
  * @category Swap Actions
  */
-export type SwapExecutionAction<T extends ChainType> = SwapExecutionActionLightning | SwapExecutionActionBitcoin | SwapExecutionActionCommit<T> | SwapExecutionActionClaim<T> | SwapExecutionActionRefund<T>;
+export type SwapExecutionAction = SwapExecutionActionSendToAddress | SwapExecutionActionSignPSBT | SwapExecutionActionSignSmartChainTx | SwapExecutionActionWait;

package/dist/types/SwapExecutionAction.js

@@ -1,2 +1,106 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSwapExecutionActionWait = exports.isSwapExecutionActionSignSmartChainTx = exports.isSwapExecutionActionSignPSBT = exports.isSwapExecutionActionSendToAddress = void 0;
+const btc_signer_1 = require("@scure/btc-signer");
+const TokenAmount_1 = require("./TokenAmount");
+const Token_1 = require("./Token");
+const swapExecutionActionWaitNames = {
+    LP: "Awaiting LP payout",
+    SETTLEMENT: "Automatic settlement",
+    BITCOIN_CONFS: "Bitcoin confirmations"
+};
+function isSwapExecutionActionPsbtTx(obj, type) {
+    const resolvedType = type ?? obj?.type;
+    if (obj == null || typeof (obj) !== "object")
+        return false;
+    if (resolvedType !== "FUNDED_PSBT" && resolvedType !== "RAW_PSBT")
+        return false;
+    return obj.type === resolvedType &&
+        obj.psbt instanceof btc_signer_1.Transaction &&
+        typeof (obj.psbtHex) === "string" &&
+        typeof (obj.psbtBase64) === "string" &&
+        (resolvedType === "FUNDED_PSBT"
+            ? Array.isArray(obj.signInputs) && obj.signInputs.every((input) => typeof (input) === "number")
+            : typeof (obj.in1sequence) === "number");
+}
+/**
+ * Type guard for {@link SwapExecutionActionSendToAddress}
+ *
+ * @category Swap Actions
+ */
+function isSwapExecutionActionSendToAddress(obj, lightning) {
+    const resolvedLightning = lightning ?? (obj?.chain === "LIGHTNING");
+    return obj != null &&
+        typeof (obj) === "object" &&
+        obj.type === "SendToAddress" &&
+        obj.name === (resolvedLightning ? "Deposit on Lightning" : "Deposit on Bitcoin") &&
+        typeof (obj.description) === "string" &&
+        obj.chain === (resolvedLightning ? "LIGHTNING" : "BITCOIN") &&
+        Array.isArray(obj.txs) &&
+        obj.txs.every((tx) => tx != null &&
+            typeof (tx) === "object" &&
+            tx.type === (resolvedLightning ? "BOLT11_PAYMENT_REQUEST" : "BITCOIN_ADDRESS") &&
+            typeof (tx.address) === "string" &&
+            typeof (tx.hyperlink) === "string" &&
+            (0, TokenAmount_1.isTokenAmount)(tx.amount, resolvedLightning ? Token_1.BitcoinTokens.BTCLN : Token_1.BitcoinTokens.BTC, true)) &&
+        typeof (obj.waitForTransactions) === "function";
+}
+exports.isSwapExecutionActionSendToAddress = isSwapExecutionActionSendToAddress;
+/**
+ * Type guard for {@link SwapExecutionActionSignPSBT}
+ *
+ * @category Swap Actions
+ */
+function isSwapExecutionActionSignPSBT(obj, psbtType) {
+    const resolvedPsbtType = psbtType ?? obj?.txs?.[0]?.type;
+    return obj != null &&
+        typeof (obj) === "object" &&
+        obj.type === "SignPSBT" &&
+        obj.name === "Deposit on Bitcoin" &&
+        typeof (obj.description) === "string" &&
+        obj.chain === "BITCOIN" &&
+        Array.isArray(obj.txs) &&
+        obj.txs.every((tx) => isSwapExecutionActionPsbtTx(tx, resolvedPsbtType)) &&
+        typeof (obj.submitPsbt) === "function";
+}
+exports.isSwapExecutionActionSignPSBT = isSwapExecutionActionSignPSBT;
+/**
+ * Type guard for {@link SwapExecutionActionSignSmartChainTx}
+ *
+ * @category Swap Actions
+ */
+function isSwapExecutionActionSignSmartChainTx(obj, chainIdentifier) {
+    const allowedChains = chainIdentifier == null ? null : Array.isArray(chainIdentifier) ? chainIdentifier : [chainIdentifier];
+    return obj != null &&
+        typeof (obj) === "object" &&
+        obj.type === "SignSmartChainTransaction" &&
+        (obj.name === "Initiate swap" ||
+            obj.name === "Settle manually" ||
+            obj.name === "Refund") &&
+        typeof (obj.description) === "string" &&
+        typeof (obj.chain) === "string" &&
+        (allowedChains == null || allowedChains.includes(obj.chain)) &&
+        Array.isArray(obj.txs) &&
+        typeof (obj.submitTransactions) === "function" &&
+        typeof (obj.requiredSigner) === "string";
+}
+exports.isSwapExecutionActionSignSmartChainTx = isSwapExecutionActionSignSmartChainTx;
+/**
+ * Type guard for {@link SwapExecutionActionWait}
+ *
+ * @category Swap Actions
+ */
+function isSwapExecutionActionWait(obj, waitType) {
+    const resolvedWaitType = waitType ??
+        Object.keys(swapExecutionActionWaitNames).find(key => swapExecutionActionWaitNames[key] === obj?.name);
+    return obj != null &&
+        typeof (obj) === "object" &&
+        obj.type === "Wait" &&
+        resolvedWaitType != null &&
+        obj.name === swapExecutionActionWaitNames[resolvedWaitType] &&
+        typeof (obj.description) === "string" &&
+        typeof (obj.wait) === "function" &&
+        typeof (obj.expectedTimeSeconds) === "number" &&
+        typeof (obj.pollTimeSeconds) === "number";
+}
+exports.isSwapExecutionActionWait = isSwapExecutionActionWait;