@atomiqlabs/sdk 8.3.6 → 8.4.4

package/dist/bitcoin/wallet/BitcoinWallet.d.ts

@@ -5,7 +5,7 @@ import { BTC_NETWORK } from "@scure/btc-signer/utils";
 import { Transaction } from "@scure/btc-signer";
 import { IBitcoinWallet } from "./IBitcoinWallet";
 import { Buffer } from "buffer";
-import { BitcoinRpcWithAddressIndex } from "@atomiqlabs/base";
+import { BitcoinNetwork, BitcoinRpcWithAddressIndex } from "@atomiqlabs/base";
 /**
  * UTXO data structure for Bitcoin wallets
  *
@@ -41,7 +41,7 @@ export declare abstract class BitcoinWallet implements IBitcoinWallet {
     protected readonly network: BTC_NETWORK;
     protected feeMultiplier: number;
     protected feeOverride?: number;
-    constructor(mempoolApi: BitcoinRpcWithAddressIndex<any>, network: BTC_NETWORK, feeMultiplier?: number, feeOverride?: number);
+    constructor(mempoolApi: BitcoinRpcWithAddressIndex<any>, network: BitcoinNetwork | BTC_NETWORK, feeMultiplier?: number, feeOverride?: number);
     /**
      * @inheritDoc
      */
@@ -126,4 +126,5 @@ export declare abstract class BitcoinWallet implements IBitcoinWallet {
         feeRate: number;
         totalFee: number;
     }>;
+    static bitcoinNetworkToObject(network: BitcoinNetwork): BTC_NETWORK;
 }

package/dist/bitcoin/wallet/BitcoinWallet.js

@@ -2,11 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BitcoinWallet = exports.identifyAddressType = void 0;
 const coinselect2_1 = require("../coinselect2");
+const utils_1 = require("@scure/btc-signer/utils");
 const btc_signer_1 = require("@scure/btc-signer");
 const buffer_1 = require("buffer");
 const Utils_1 = require("../../utils/Utils");
 const BitcoinUtils_1 = require("../../utils/BitcoinUtils");
 const Logger_1 = require("../../utils/Logger");
+const base_1 = require("@atomiqlabs/base");
 /**
  * Identifies the address type of a Bitcoin address
  *
@@ -29,6 +31,15 @@ function identifyAddressType(address, network) {
     }
 }
 exports.identifyAddressType = identifyAddressType;
+const btcNetworkMapping = {
+    [base_1.BitcoinNetwork.MAINNET]: utils_1.NETWORK,
+    [base_1.BitcoinNetwork.TESTNET]: utils_1.TEST_NETWORK,
+    [base_1.BitcoinNetwork.TESTNET4]: utils_1.TEST_NETWORK,
+    [base_1.BitcoinNetwork.REGTEST]: {
+        ...utils_1.TEST_NETWORK,
+        bech32: "bcrt"
+    }
+};
 const logger = (0, Logger_1.getLogger)("BitcoinWallet: ");
 /**
  * Abstract base class for Bitcoin wallet implementations, using bitcoin rpc with address index
@@ -39,7 +50,7 @@ const logger = (0, Logger_1.getLogger)("BitcoinWallet: ");
 class BitcoinWallet {
     constructor(mempoolApi, network, feeMultiplier = 1.25, feeOverride) {
         this.rpc = mempoolApi;
-        this.network = network;
+        this.network = typeof (network) === "object" ? network : BitcoinWallet.bitcoinNetworkToObject(network);
         this.feeMultiplier = feeMultiplier;
         this.feeOverride = feeOverride;
     }
@@ -304,5 +315,8 @@ class BitcoinWallet {
             totalFee: coinselectResult.fee
         };
     }
+    static bitcoinNetworkToObject(network) {
+        return btcNetworkMapping[network];
+    }
 }
 exports.BitcoinWallet = BitcoinWallet;

package/dist/bitcoin/wallet/SingleAddressBitcoinWallet.d.ts

@@ -1,8 +1,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import { CoinselectAddressTypes } from "../coinselect2";
 import { BTC_NETWORK } from "@scure/btc-signer/utils";
 import { Transaction } from "@scure/btc-signer";
+import { Buffer } from "buffer";
 import { BitcoinWallet } from "./BitcoinWallet";
-import { BitcoinRpcWithAddressIndex } from "@atomiqlabs/base";
+import { BitcoinNetwork, BitcoinRpcWithAddressIndex } from "@atomiqlabs/base";
 /**
  * Bitcoin wallet implementation deriving a single address from a WIF encoded private key
  *
@@ -13,7 +16,7 @@ export declare class SingleAddressBitcoinWallet extends BitcoinWallet {
     protected readonly pubkey: Uint8Array;
     protected readonly address: string;
     protected readonly addressType: CoinselectAddressTypes;
-    constructor(mempoolApi: BitcoinRpcWithAddressIndex<any>, network: BTC_NETWORK, addressDataOrWIF: string | {
+    constructor(mempoolApi: BitcoinRpcWithAddressIndex<any>, _network: BitcoinNetwork | BTC_NETWORK, addressDataOrWIF: string | {
         address: string;
         publicKey: string;
     }, feeMultiplier?: number, feeOverride?: number);
@@ -75,5 +78,24 @@ export declare class SingleAddressBitcoinWallet extends BitcoinWallet {
      *
      * @returns A WIF encoded bitcoin private key
      */
-    static generateRandomPrivateKey(network?: BTC_NETWORK): string;
+    static generateRandomPrivateKey(network?: BitcoinNetwork | BTC_NETWORK): string;
+    /**
+     * Generates a 12-word long mnemonic from any entropy source with 128-bits or more, the entropy is first hashed
+     *  using sha256, and the first 16 bytes of the hash are used to generate the mnemonic
+     *
+     * @param entropy Entropy to use for generating the mnemonic
+     */
+    static mnemonicFromEntropy(entropy: Buffer): string;
+    /**
+     * Generates a random 12-word long mnemonic
+     */
+    static generateRandomMnemonic(): string;
+    /**
+     * Generates a WIF private key from mnemonic phrase
+     *
+     * @param mnemonic Mnemonic to generate the WIF key from
+     * @param network Optional bitcoin network to generate the WIF for
+     * @param derivationPath Optional custom derivation path to use for deriving the wallet
+     */
+    static mnemonicToPrivateKey(mnemonic: string, network?: BitcoinNetwork | BTC_NETWORK, derivationPath?: string): Promise<string>;
 }

package/dist/bitcoin/wallet/SingleAddressBitcoinWallet.js

@@ -5,13 +5,20 @@ const utils_1 = require("@scure/btc-signer/utils");
 const btc_signer_1 = require("@scure/btc-signer");
 const buffer_1 = require("buffer");
 const BitcoinWallet_1 = require("./BitcoinWallet");
+const bip32_1 = require("@scure/bip32");
+const bip39_1 = require("@scure/bip39");
+const english_js_1 = require("@scure/bip39/wordlists/english.js");
+const sha2_1 = require("@noble/hashes/sha2");
 /**
  * Bitcoin wallet implementation deriving a single address from a WIF encoded private key
  *
  * @category Bitcoin
  */
 class SingleAddressBitcoinWallet extends BitcoinWallet_1.BitcoinWallet {
-    constructor(mempoolApi, network, addressDataOrWIF, feeMultiplier = 1.25, feeOverride) {
+    constructor(mempoolApi, _network, addressDataOrWIF, feeMultiplier = 1.25, feeOverride) {
+        const network = typeof (_network) === "object"
+            ? _network
+            : BitcoinWallet_1.BitcoinWallet.bitcoinNetworkToObject(_network);
         super(mempoolApi, network, feeMultiplier, feeOverride);
         if (typeof (addressDataOrWIF) === "string") {
             try {
@@ -121,7 +128,49 @@ class SingleAddressBitcoinWallet extends BitcoinWallet_1.BitcoinWallet {
      * @returns A WIF encoded bitcoin private key
      */
     static generateRandomPrivateKey(network) {
-        return (0, btc_signer_1.WIF)(network).encode((0, utils_1.randomPrivateKeyBytes)());
+        const networkObject = network == null || typeof (network) === "object"
+            ? network
+            : BitcoinWallet_1.BitcoinWallet.bitcoinNetworkToObject(network);
+        return (0, btc_signer_1.WIF)(networkObject).encode((0, utils_1.randomPrivateKeyBytes)());
+    }
+    /**
+     * Generates a 12-word long mnemonic from any entropy source with 128-bits or more, the entropy is first hashed
+     *  using sha256, and the first 16 bytes of the hash are used to generate the mnemonic
+     *
+     * @param entropy Entropy to use for generating the mnemonic
+     */
+    static mnemonicFromEntropy(entropy) {
+        if (entropy.length < 16)
+            throw new Error("Requires at least 128-bit entropy (16 bytes)");
+        const entropyHash = buffer_1.Buffer.from((0, sha2_1.sha256)(entropy)).subarray(0, 16);
+        return (0, bip39_1.entropyToMnemonic)(entropyHash, english_js_1.wordlist);
+    }
+    /**
+     * Generates a random 12-word long mnemonic
+     */
+    static generateRandomMnemonic() {
+        return (0, bip39_1.generateMnemonic)(english_js_1.wordlist, 128);
+    }
+    /**
+     * Generates a WIF private key from mnemonic phrase
+     *
+     * @param mnemonic Mnemonic to generate the WIF key from
+     * @param network Optional bitcoin network to generate the WIF for
+     * @param derivationPath Optional custom derivation path to use for deriving the wallet
+     */
+    static async mnemonicToPrivateKey(mnemonic, network, derivationPath) {
+        const networkObject = network == null || typeof (network) === "object"
+            ? network
+            : BitcoinWallet_1.BitcoinWallet.bitcoinNetworkToObject(network);
+        derivationPath = networkObject == null || networkObject.bech32 === utils_1.NETWORK.bech32
+            ? "m/84'/0'/0'/0/0" //Mainnet
+            : "m/84'/1'/0'/0/0"; //Testnet
+        const seed = await (0, bip39_1.mnemonicToSeed)(mnemonic);
+        const hdKey = bip32_1.HDKey.fromMasterSeed(seed);
+        const privateKey = hdKey.derive(derivationPath).privateKey;
+        if (privateKey == null)
+            throw new Error("Cannot derive private key from the mnemonic!");
+        return (0, btc_signer_1.WIF)(networkObject).encode(privateKey);
     }
 }
 exports.SingleAddressBitcoinWallet = SingleAddressBitcoinWallet;

package/dist/index.d.ts

@@ -73,6 +73,7 @@ export * from "./types/lnurl/LNURLWithdraw";
 export * from "./types/wallets/MinimalBitcoinWalletInterface";
 export * from "./types/wallets/MinimalLightningNetworkWalletInterface";
 export * from "./types/wallets/LightningInvoiceCreateService";
+export * from "./types/SwapStateInfo";
 export * from "./types/AmountData";
 export * from "./types/CustomPriceFunction";
 export * from "./types/SwapExecutionAction";

package/dist/index.js

@@ -146,6 +146,7 @@ __exportStar(require("./types/lnurl/LNURLWithdraw"), exports);
 __exportStar(require("./types/wallets/MinimalBitcoinWalletInterface"), exports);
 __exportStar(require("./types/wallets/MinimalLightningNetworkWalletInterface"), exports);
 __exportStar(require("./types/wallets/LightningInvoiceCreateService"), exports);
+__exportStar(require("./types/SwapStateInfo"), exports);
 __exportStar(require("./types/AmountData"), exports);
 __exportStar(require("./types/CustomPriceFunction"), exports);
 __exportStar(require("./types/SwapExecutionAction"), exports);

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

@@ -185,6 +185,7 @@ declare const FromBTCLNResponseSchema: {
 export type FromBTCLNResponseType = RequestSchemaResult<typeof FromBTCLNResponseSchema>;
 export type FromBTCLNInit = BaseFromBTCSwapInit & {
     paymentHash: Buffer;
+    description?: string;
     descriptionHash?: Buffer;
 };
 declare const FromBTCLNAutoResponseSchema: {
@@ -205,6 +206,7 @@ export type FromBTCLNAutoResponseType = RequestSchemaResult<typeof FromBTCLNAuto
 export type FromBTCLNAutoInit = Omit<BaseFromBTCSwapInit, "feeRate"> & {
     paymentHash: Buffer;
     gasToken: string;
+    description?: string;
     descriptionHash?: Buffer;
     gasAmount?: bigint;
     claimerBounty?: Promise<bigint>;

package/dist/intermediaries/apis/IntermediaryAPI.js

@@ -321,6 +321,7 @@ class IntermediaryAPI {
             amount: init.amount.toString(),
             address: init.claimer,
             token: init.token,
+            description: init.description ?? null,
             descriptionHash: init.descriptionHash == null ? null : init.descriptionHash.toString("hex"),
             exactOut: init.exactOut,
             feeRate: init.feeRate
@@ -366,6 +367,7 @@ class IntermediaryAPI {
             amount: init.amount.toString(),
             address: init.claimer,
             token: init.token,
+            description: init.description ?? null,
             descriptionHash: init.descriptionHash == null ? null : init.descriptionHash.toString("hex"),
             exactOut: init.exactOut,
             gasToken: init.gasToken,

package/dist/swapper/Swapper.d.ts

@@ -371,8 +371,9 @@ export declare class Swapper<T extends MultiChain> extends EventEmitter<{
      * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
      * @param exactOut Whether to use a exact out instead of exact in
      * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
      */
-    createFromBTCLNSwapViaLNURL<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, lnurl: string | LNURLWithdraw, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined): Promise<FromBTCLNSwap<T[ChainIdentifier]>>;
+    createFromBTCLNSwapViaLNURL<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, lnurl: string | LNURLWithdraw, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: FromBTCLNOptions): Promise<FromBTCLNSwap<T[ChainIdentifier]>>;
     /**
      * Creates Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN_AUTO}) swap
      *

package/dist/swapper/Swapper.js

@@ -660,8 +660,9 @@ class Swapper extends events_1.EventEmitter {
      * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
      * @param exactOut Whether to use a exact out instead of exact in
      * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
      */
-    async createFromBTCLNSwapViaLNURL(chainIdentifier, recipient, tokenAddress, lnurl, amount, exactOut = false, additionalParams = this.options.defaultAdditionalParameters) {
+    async createFromBTCLNSwapViaLNURL(chainIdentifier, recipient, tokenAddress, lnurl, amount, exactOut = false, additionalParams = this.options.defaultAdditionalParameters, options) {
         if (this._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
         if (typeof (lnurl) === "string" && !this.Utils.isValidLNURL(lnurl))
@@ -674,7 +675,7 @@ class Swapper extends events_1.EventEmitter {
             token: tokenAddress,
             exactIn: !exactOut
         };
-        return this.createSwap(chainIdentifier, (candidates, abortSignal, chain) => chain.wrappers[SwapType_1.SwapType.FROM_BTCLN].createViaLNURL(recipient, typeof (lnurl) === "string" ? (lnurl.startsWith("lightning:") ? lnurl.substring(10) : lnurl) : lnurl.params, amountData, candidates, additionalParams, abortSignal), amountData, SwapType_1.SwapType.FROM_BTCLN);
+        return this.createSwap(chainIdentifier, (candidates, abortSignal, chain) => chain.wrappers[SwapType_1.SwapType.FROM_BTCLN].createViaLNURL(recipient, typeof (lnurl) === "string" ? (lnurl.startsWith("lightning:") ? lnurl.substring(10) : lnurl) : lnurl.params, amountData, candidates, options, additionalParams, abortSignal), amountData, SwapType_1.SwapType.FROM_BTCLN);
     }
     /**
      * Creates Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN_AUTO}) swap
@@ -821,7 +822,7 @@ class Swapper extends events_1.EventEmitter {
                             throw new Error("LNURL must be a string or LNURLWithdraw object!");
                         return this.supportsSwapType(dstToken.chainId, SwapType_1.SwapType.FROM_BTCLN_AUTO) ?
                             this.createFromBTCLNSwapNewViaLNURL(dstToken.chainId, dst, dstToken.address, src, amount, !exactIn, undefined, options) :
-                            this.createFromBTCLNSwapViaLNURL(dstToken.chainId, dst, dstToken.address, src, amount, !exactIn);
+                            this.createFromBTCLNSwapViaLNURL(dstToken.chainId, dst, dstToken.address, src, amount, !exactIn, undefined, options);
                     }
                     else {
                         return this.supportsSwapType(dstToken.chainId, SwapType_1.SwapType.FROM_BTCLN_AUTO) ?

package/dist/swaps/ISwap.d.ts

@@ -12,6 +12,7 @@ import { Token } from "../types/Token";
 import { SwapExecutionAction } from "../types/SwapExecutionAction";
 import { LoggerType } from "../utils/Logger";
 import { PriceInfoType } from "../types/PriceInfoType";
+import { SwapStateInfo } from "../types/SwapStateInfo";
 /**
  * Initialization data for creating a swap
  *
@@ -41,6 +42,16 @@ export declare abstract class ISwap<T extends ChainType = ChainType, D extends S
      * Swap type
      */
     protected readonly abstract TYPE: SwapType;
+    /**
+     * Description for the states
+     * @internal
+     */
+    protected readonly abstract swapStateDescription: Record<S, string>;
+    /**
+     * Name of the states
+     * @internal
+     */
+    protected readonly abstract swapStateName: (state: number) => string;
     /**
      * Swap logger
      * @internal
@@ -145,6 +156,16 @@ export declare abstract class ISwap<T extends ChainType = ChainType, D extends S
      * @param options Additional options for executing the swap
      */
     abstract txsExecute(options?: any): Promise<SwapExecutionAction<T>[]>;
+    /**
+     * Executes the swap with the provided wallet, the exact arguments for this functions differ for various swap
+     *  types. Check the `execute()` function signature in the respective swap class to see the required arguments.
+     *
+     * @param args Execution arguments, usually contains a source wallet object, callbacks and options, for exact
+     *  syntax check the respective swap class.
+     *
+     * @returns Whether a swap was successfully executed or not, if it wasn't the user can refund or claim manually
+     */
+    abstract execute(...args: any[]): Promise<boolean>;
     /**
      * This attempts to populate missing fields in the pricing info based on the swap amounts
      *
@@ -246,6 +267,10 @@ export declare abstract class ISwap<T extends ChainType = ChainType, D extends S
      * Returns whether the swap failed (e.g. was refunded)
      */
     abstract isFailed(): boolean;
+    /**
+     * Returns whether the swap is currently being processed
+     */
+    abstract isInProgress(): boolean;
     /**
      * Whether a swap was initialized, a swap is considered initialized on first interaction with it, i.e.
      *  calling commit() on a Smart chain -> Bitcoin swaps, calling waitForPayment() or similar on the other
@@ -269,6 +294,15 @@ export declare abstract class ISwap<T extends ChainType = ChainType, D extends S
      * Returns the current state of the swap
      */
     getState(): S;
+    /**
+     * Returns the current state of the swap along with the human-readable description of the state
+     */
+    getStateInfo(): SwapStateInfo<S>;
+    /**
+     * Returns a state-dependent set of actions for the user to execute, or empty array if there is currently
+     *  no action required from the user to execute.
+     */
+    abstract getCurrentActions(): Promise<SwapExecutionAction<T>[]>;
     /**
      * Returns output amount of the swap, user receives this much
      */

package/dist/swaps/ISwap.js

@@ -248,6 +248,16 @@ class ISwap {
     getState() {
         return this._state;
     }
+    /**
+     * Returns the current state of the swap along with the human-readable description of the state
+     */
+    getStateInfo() {
+        return {
+            state: this._state,
+            name: this.swapStateName(this._state),
+            description: this.swapStateDescription[this._state]
+        };
+    }
     //////////////////////////////
     //// Storage
     /**

package/dist/swaps/escrow_swaps/IEscrowSwap.d.ts

@@ -70,6 +70,18 @@ export declare abstract class IEscrowSwap<T extends ChainType = ChainType, D ext
      * @inheritDoc
      */
     getId(): string;
+    /**
+     * Returns the smart chain transaction ID of the tx that initiated the escrow
+     */
+    getEscrowInitTxId(): string | undefined;
+    /**
+     * Returns the smart chain transaction ID of the tx that claimed (settled) the escrow
+     */
+    getEscrowClaimTxId(): string | undefined;
+    /**
+     * Returns the smart chain transaction ID of the tx that refunded the escrow
+     */
+    getEscrowRefundTxId(): string | undefined;
     /**
      * Periodically checks the chain to see whether the swap is committed
      *

package/dist/swaps/escrow_swaps/IEscrowSwap.js

@@ -79,6 +79,24 @@ class IEscrowSwap extends ISwap_1.ISwap {
     getId() {
         return this.getIdentifierHashString();
     }
+    /**
+     * Returns the smart chain transaction ID of the tx that initiated the escrow
+     */
+    getEscrowInitTxId() {
+        return this._commitTxId;
+    }
+    /**
+     * Returns the smart chain transaction ID of the tx that claimed (settled) the escrow
+     */
+    getEscrowClaimTxId() {
+        return this._claimTxId;
+    }
+    /**
+     * Returns the smart chain transaction ID of the tx that refunded the escrow
+     */
+    getEscrowRefundTxId() {
+        return this._refundTxId;
+    }
     //////////////////////////////
     //// Watchdogs
     /**

package/dist/swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap.d.ts

@@ -13,6 +13,7 @@ import { TokenAmount } from "../../../../types/TokenAmount";
 import { BtcToken, SCToken } from "../../../../types/Token";
 import { LoggerType } from "../../../../utils/Logger";
 import { LNURLWithdraw } from "../../../../types/lnurl/LNURLWithdraw";
+import { SwapExecutionAction } from "../../../../types/SwapExecutionAction";
 /**
  * State enum for legacy Lightning -> Smart chain swaps
  * @category Swaps/Legacy/Lightning → Smart chain
@@ -77,6 +78,23 @@ export declare function isFromBTCLNSwapInit<T extends SwapData>(obj: any): obj i
  */
 export declare class FromBTCLNSwap<T extends ChainType = ChainType> extends IFromBTCSelfInitSwap<T, FromBTCLNDefinition<T>, FromBTCLNSwapState> implements IAddressSwap, IClaimableSwap<T, FromBTCLNDefinition<T>, FromBTCLNSwapState> {
     protected readonly TYPE = SwapType.FROM_BTCLN;
+    /**
+     * @internal
+     */
+    protected readonly swapStateName: (state: number) => string;
+    /**
+     * @internal
+     */
+    protected readonly swapStateDescription: {
+        [-4]: string;
+        [-3]: string;
+        [-2]: string;
+        [-1]: string;
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+    };
     /**
      * @internal
      */
@@ -190,6 +208,10 @@ export declare class FromBTCLNSwap<T extends ChainType = ChainType> extends IFro
      * @inheritDoc
      */
     isFailed(): boolean;
+    /**
+     * @inheritDoc
+     */
+    isInProgress(): boolean;
     /**
      * @inheritDoc
      */
@@ -229,6 +251,18 @@ export declare class FromBTCLNSwap<T extends ChainType = ChainType> extends IFro
         required: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>;
     }>;
     private isValidSecretPreimage;
+    /**
+     * Sets the secret preimage for the swap, in case it is not known already
+     *
+     * @param secret Secret preimage that matches the expected payment hash
+     *
+     * @throws {Error} If an invalid secret preimage is provided
+     */
+    setSecretPreimage(secret: string): void;
+    /**
+     * Returns whether the secret preimage for this swap is known
+     */
+    hasSecretPreimage(): boolean;
     /**
      * Executes the swap with the provided bitcoin lightning network wallet or LNURL
      *
@@ -239,7 +273,7 @@ export declare class FromBTCLNSwap<T extends ChainType = ChainType> extends IFro
      *  link, wallet is not required and the LN invoice can be paid externally as well (just pass null or undefined here)
      * @param callbacks Callbacks to track the progress of the swap
      * @param options Optional options for the swap like feeRate, AbortSignal, and timeouts/intervals
-     * @param secret A swap secret to use for the claim transaction, generally only needed if the swap
+     * @param options.secret A swap secret to use for the claim transaction, generally only needed if the swap
      *  was recovered from on-chain data, or the pre-image was generated outside the SDK
      */
     execute(dstSigner: T["Signer"] | T["NativeSigner"], walletOrLnurlWithdraw?: MinimalLightningNetworkWalletInterface | LNURLWithdraw | string | null | undefined, callbacks?: {
@@ -249,9 +283,10 @@ export declare class FromBTCLNSwap<T extends ChainType = ChainType> extends IFro
         onSwapSettled?: (destinationTxId: string) => void;
     }, options?: {
         abortSignal?: AbortSignal;
+        secret?: string;
         lightningTxCheckIntervalSeconds?: number;
         delayBetweenCommitAndClaimSeconds?: number;
-    }, secret?: string): Promise<void>;
+    }): Promise<boolean>;
     /**
      * @inheritDoc
      *
@@ -259,12 +294,13 @@ export declare class FromBTCLNSwap<T extends ChainType = ChainType> extends IFro
      * @param options.skipChecks Skip checks like making sure init signature is still valid and swap
      *  wasn't commited yet (this is handled on swap creation, if you commit right after quoting, you
      *  can use `skipChecks=true`)
-     * @param secret A swap secret to use for the claim transaction, generally only needed if the swap
+     * @param options.secret A swap secret to use for the claim transaction, generally only needed if the swap
      *  was recovered from on-chain data, or the pre-image was generated outside the SDK
      */
     txsExecute(options?: {
         skipChecks?: boolean;
-    }, secret?: string): Promise<{
+        secret?: string;
+    }): Promise<{
         name: "Payment";
         description: string;
         chain: "LIGHTNING";
@@ -284,6 +320,20 @@ export declare class FromBTCLNSwap<T extends ChainType = ChainType> extends IFro
         chain: T["ChainId"];
         txs: T["TX"][];
     })[]>;
+    /**
+     * @inheritDoc
+     *
+     * @param options
+     * @param options.skipChecks Skip checks like making sure init signature is still valid and swap
+     *  wasn't commited yet (this is handled on swap creation, if you commit right after quoting, you
+     *  can use `skipChecks=true`)
+     * @param options.secret A swap secret to use for the claim transaction, generally only needed if the swap
+     *  was recovered from on-chain data, or the pre-image was generated outside the SDK
+     */
+    getCurrentActions(options?: {
+        skipChecks?: boolean;
+        secret?: string;
+    }): Promise<SwapExecutionAction<T>[]>;
     /**
      * Checks whether the LP received the LN payment and we can continue by committing & claiming the HTLC on-chain
      *