@atomiqlabs/sdk 8.3.6 → 8.4.3

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

@@ -12,7 +12,7 @@ import { FeeType } from "../../../enums/FeeType";
 import { TokenAmount } from "../../../types/TokenAmount";
 import { BtcToken, SCToken } from "../../../types/Token";
 import { LoggerType } from "../../../utils/Logger";
-import { SwapExecutionActionBitcoin } from "../../../types/SwapExecutionAction";
+import { SwapExecutionAction, SwapExecutionActionBitcoin } from "../../../types/SwapExecutionAction";
 /**
  * State enum for trusted on-chain gas swaps
  *
@@ -32,7 +32,7 @@ export declare enum OnchainForGasSwapState {
      */
     REFUNDED = -1,
     /**
-     * Swap was created
+     * Swap was created, send the BTC to the swap address
      */
     PR_CREATED = 0,
     /**
@@ -61,8 +61,16 @@ export declare function isOnchainForGasSwapInit(obj: any): obj is OnchainForGasS
  *
  * @category Swaps/Trusted Gas Swaps
  */
-export declare class OnchainForGasSwap<T extends ChainType = ChainType> extends ISwap<T, OnchainForGasSwapTypeDefinition<T>> implements IAddressSwap, IBTCWalletSwap {
+export declare class OnchainForGasSwap<T extends ChainType = ChainType> extends ISwap<T, OnchainForGasSwapTypeDefinition<T>, OnchainForGasSwapState> implements IAddressSwap, IBTCWalletSwap {
     protected readonly TYPE: SwapType.TRUSTED_FROM_BTC;
+    /**
+     * @internal
+     */
+    protected readonly swapStateDescription: Record<OnchainForGasSwapState, string>;
+    /**
+     * @internal
+     */
+    protected readonly swapStateName: (state: number) => string;
     /**
      * @internal
      */
@@ -259,6 +267,15 @@ export declare class OnchainForGasSwap<T extends ChainType = ChainType> extends
     }): Promise<[
         SwapExecutionActionBitcoin<"ADDRESS" | "FUNDED_PSBT">
     ]>;
+    /**
+     * @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>[]>;
     /**
      * Queries the intermediary (LP) node for the state of the swap
      *

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

@@ -37,7 +37,7 @@ var OnchainForGasSwapState;
      */
     OnchainForGasSwapState[OnchainForGasSwapState["REFUNDED"] = -1] = "REFUNDED";
     /**
-     * Swap was created
+     * Swap was created, send the BTC to the swap address
      */
     OnchainForGasSwapState[OnchainForGasSwapState["PR_CREATED"] = 0] = "PR_CREATED";
     /**
@@ -49,6 +49,14 @@ var OnchainForGasSwapState;
      */
     OnchainForGasSwapState[OnchainForGasSwapState["REFUNDABLE"] = 2] = "REFUNDABLE";
 })(OnchainForGasSwapState = exports.OnchainForGasSwapState || (exports.OnchainForGasSwapState = {}));
+const OnchainForGasSwapStateDescription = {
+    [OnchainForGasSwapState.EXPIRED]: "The swap quote expired without user sending in the BTC",
+    [OnchainForGasSwapState.FAILED]: "The swap has failed after the intermediary already received the BTC on the source chain",
+    [OnchainForGasSwapState.REFUNDED]: "Swap was refunded and BTC returned to the user's refund address",
+    [OnchainForGasSwapState.PR_CREATED]: "Swap was created, send the BTC to the swap address",
+    [OnchainForGasSwapState.FINISHED]: "The swap is finished after the intermediary sent funds on the destination chain",
+    [OnchainForGasSwapState.REFUNDABLE]: "Swap is refundable because the intermediary cannot honor the swap request on the destination chain",
+};
 function isOnchainForGasSwapInit(obj) {
     return typeof (obj.paymentHash) === "string" &&
         typeof (obj.sequence) === "bigint" &&
@@ -73,6 +81,14 @@ class OnchainForGasSwap extends ISwap_1.ISwap {
             initOrObj.url += "/frombtc_trusted";
         super(wrapper, initOrObj);
         this.TYPE = SwapType_1.SwapType.TRUSTED_FROM_BTC;
+        /**
+         * @internal
+         */
+        this.swapStateDescription = OnchainForGasSwapStateDescription;
+        /**
+         * @internal
+         */
+        this.swapStateName = (state) => OnchainForGasSwapState[state];
         this.wrapper = wrapper;
         if (isOnchainForGasSwapInit(initOrObj)) {
             this.paymentHash = initOrObj.paymentHash;
@@ -437,6 +453,20 @@ class OnchainForGasSwap extends ISwap_1.ISwap {
         }
         throw new Error("Invalid swap state to obtain execution txns, required PR_CREATED or CLAIM_COMMITED");
     }
+    /**
+     * @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 [];
+        }
+    }
     //////////////////////////////
     //// Payment
     /**

package/dist/types/SwapStateInfo.d.ts

@@ -0,0 +1,5 @@
+export type SwapStateInfo<S extends number> = {
+    state: S;
+    name: string;
+    description: string;
+};

package/dist/types/SwapStateInfo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/sdk",
-  "version": "8.3.6",
+  "version": "8.4.3",
   "description": "atomiq labs SDK for cross-chain swaps between smart chains and bitcoin",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -30,6 +30,8 @@
     "@noble/ciphers": "^1.2.1",
     "@noble/hashes": "^1.7.1",
     "@scure/base": "^1.2.4",
+    "@scure/bip32": "^2.0.1",
+    "@scure/bip39": "^2.0.1",
     "@scure/btc-signer": "1.7.0",
     "buffer": "6.0.3",
     "events": "3.3.0"

package/src/bitcoin/wallet/BitcoinWallet.ts

@@ -1,5 +1,5 @@
 import {coinSelect, maxSendable, CoinselectAddressTypes, CoinselectTxInput} from "../coinselect2";
-import {BTC_NETWORK} from "@scure/btc-signer/utils"
+import {BTC_NETWORK, NETWORK, TEST_NETWORK} from "@scure/btc-signer/utils"
 import {p2wpkh, OutScript, Transaction, p2tr, Address} from "@scure/btc-signer";
 import {IBitcoinWallet} from "./IBitcoinWallet";
 import {Buffer} from "buffer";
@@ -7,7 +7,7 @@ import {randomBytes} from "../../utils/Utils";
 import {toCoinselectAddressType, toOutputScript} from "../../utils/BitcoinUtils";
 import {TransactionInputUpdate} from "@scure/btc-signer/psbt";
 import {getLogger} from "../../utils/Logger";
-import {BitcoinRpcWithAddressIndex} from "@atomiqlabs/base";
+import {BitcoinNetwork, BitcoinRpcWithAddressIndex} from "@atomiqlabs/base";
 
 /**
  * UTXO data structure for Bitcoin wallets
@@ -50,6 +50,16 @@ export function identifyAddressType(address: string, network: BTC_NETWORK): Coin
     }
 }
 
+const btcNetworkMapping = {
+    [BitcoinNetwork.MAINNET]: NETWORK,
+    [BitcoinNetwork.TESTNET]: TEST_NETWORK,
+    [BitcoinNetwork.TESTNET4]: TEST_NETWORK,
+    [BitcoinNetwork.REGTEST]: {
+        ...TEST_NETWORK,
+        bech32: "bcrt"
+    }
+}
+
 const logger = getLogger("BitcoinWallet: ");
 
 /**
@@ -65,9 +75,13 @@ export abstract class BitcoinWallet implements IBitcoinWallet {
     protected feeMultiplier: number;
     protected feeOverride?: number;
 
-    constructor(mempoolApi: BitcoinRpcWithAddressIndex<any>, network: BTC_NETWORK, feeMultiplier: number = 1.25, feeOverride?: number) {
+    constructor(
+        mempoolApi: BitcoinRpcWithAddressIndex<any>,
+        network: BitcoinNetwork | BTC_NETWORK,
+        feeMultiplier: number = 1.25, feeOverride?: number
+    ) {
         this.rpc = mempoolApi;
-        this.network = network;
+        this.network = typeof(network)==="object" ? network : BitcoinWallet.bitcoinNetworkToObject(network);
         this.feeMultiplier = feeMultiplier;
         this.feeOverride = feeOverride;
     }
@@ -407,5 +421,8 @@ export abstract class BitcoinWallet implements IBitcoinWallet {
         totalFee: number
     }>;
 
+    static bitcoinNetworkToObject(network: BitcoinNetwork): BTC_NETWORK {
+        return btcNetworkMapping[network];
+    }
 
 }

package/src/bitcoin/wallet/SingleAddressBitcoinWallet.ts

@@ -1,9 +1,13 @@
 import {CoinselectAddressTypes} from "../coinselect2";
-import {BTC_NETWORK, pubECDSA, randomPrivateKeyBytes} from "@scure/btc-signer/utils"
+import {BTC_NETWORK, NETWORK, pubECDSA, randomPrivateKeyBytes, TEST_NETWORK} from "@scure/btc-signer/utils"
 import {getAddress, Transaction, WIF} from "@scure/btc-signer";
 import {Buffer} from "buffer";
 import {identifyAddressType, BitcoinWallet} from "./BitcoinWallet";
-import {BitcoinRpcWithAddressIndex} from "@atomiqlabs/base";
+import {BitcoinNetwork, BitcoinRpcWithAddressIndex} from "@atomiqlabs/base";
+import {HDKey} from "@scure/bip32";
+import {entropyToMnemonic, generateMnemonic, mnemonicToSeed} from "@scure/bip39";
+import {wordlist} from "@scure/bip39/wordlists/english.js";
+import {sha256} from "@noble/hashes/sha2";
 
 /**
  * Bitcoin wallet implementation deriving a single address from a WIF encoded private key
@@ -19,11 +23,14 @@ export class SingleAddressBitcoinWallet extends BitcoinWallet {
 
     constructor(
         mempoolApi: BitcoinRpcWithAddressIndex<any>,
-        network: BTC_NETWORK,
+        _network: BitcoinNetwork | BTC_NETWORK,
         addressDataOrWIF: string | {address: string, publicKey: string},
         feeMultiplier: number = 1.25,
         feeOverride?: number
     ) {
+        const network = typeof(_network)==="object"
+            ? _network
+            : BitcoinWallet.bitcoinNetworkToObject(_network);
         super(mempoolApi, network, feeMultiplier, feeOverride);
         if(typeof(addressDataOrWIF)==="string") {
             try {
@@ -144,8 +151,56 @@ export class SingleAddressBitcoinWallet extends BitcoinWallet {
      *
      * @returns A WIF encoded bitcoin private key
      */
-    static generateRandomPrivateKey(network?: BTC_NETWORK): string {
-         return WIF(network).encode(randomPrivateKeyBytes());
+    static generateRandomPrivateKey(network?: BitcoinNetwork | BTC_NETWORK): string {
+        const networkObject = network==null || typeof(network)==="object"
+            ? network
+            : BitcoinWallet.bitcoinNetworkToObject(network);
+         return WIF(networkObject).encode(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: Buffer): string {
+        if(entropy.length<16) throw new Error("Requires at least 128-bit entropy (16 bytes)");
+        const entropyHash = Buffer.from(sha256(entropy)).subarray(0, 16);
+        return entropyToMnemonic(entropyHash, wordlist);
+    }
+
+    /**
+     * Generates a random 12-word long mnemonic
+     */
+    static generateRandomMnemonic(): string {
+        return generateMnemonic(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: string,
+        network?: BitcoinNetwork | BTC_NETWORK,
+        derivationPath?: string
+    ): Promise<string> {
+        const networkObject = network==null || typeof(network)==="object"
+            ? network
+            : BitcoinWallet.bitcoinNetworkToObject(network);
+
+        derivationPath = networkObject==null || networkObject.bech32===NETWORK.bech32
+            ? "m/84'/0'/0'/0/0" //Mainnet
+            : "m/84'/1'/0'/0/0"; //Testnet
+        const seed = await mnemonicToSeed(mnemonic);
+        const hdKey = HDKey.fromMasterSeed(seed);
+        const privateKey = hdKey.derive(derivationPath).privateKey;
+        if(privateKey==null) throw new Error("Cannot derive private key from the mnemonic!");
+        return WIF(networkObject).encode(privateKey);
     }
 
 }

package/src/intermediaries/apis/IntermediaryAPI.ts

@@ -226,6 +226,7 @@ export type FromBTCLNResponseType = RequestSchemaResult<typeof FromBTCLNResponse
 
 export type FromBTCLNInit = BaseFromBTCSwapInit & {
     paymentHash: Buffer,
+    description?: string,
     descriptionHash?: Buffer
 }
 
@@ -258,6 +259,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>
@@ -597,6 +599,7 @@ export 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
@@ -658,6 +661,7 @@ export 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,
@@ -937,4 +941,4 @@ export class IntermediaryAPI {
         });
     }
 
-}
+}

package/src/swapper/Swapper.ts

@@ -1185,6 +1185,7 @@ export 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
      */
     async createFromBTCLNSwapViaLNURL<ChainIdentifier extends ChainIds<T>>(
         chainIdentifier: ChainIdentifier,
@@ -1193,7 +1194,8 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
         lnurl: string | LNURLWithdraw,
         amount: bigint,
         exactOut: boolean = false,
-        additionalParams: Record<string, any> | undefined = this.options.defaultAdditionalParameters
+        additionalParams: Record<string, any> | undefined = this.options.defaultAdditionalParameters,
+        options?: FromBTCLNOptions
     ): Promise<FromBTCLNSwap<T[ChainIdentifier]>> {
         if(this._chains[chainIdentifier]==null) throw new Error("Invalid chain identifier! Unknown chain: "+chainIdentifier);
         if(typeof(lnurl)==="string" && !this.Utils.isValidLNURL(lnurl)) throw new Error("Invalid LNURL-withdraw link");
@@ -1211,6 +1213,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 typeof(lnurl)==="string" ? (lnurl.startsWith("lightning:") ? lnurl.substring(10): lnurl) : lnurl.params,
                 amountData,
                 candidates,
+                options,
                 additionalParams,
                 abortSignal
             ),
@@ -1477,7 +1480,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                         if(typeof(src)!=="string" && !isLNURLWithdraw(src)) throw new Error("LNURL must be a string or LNURLWithdraw object!");
                         return this.supportsSwapType(dstToken.chainId, SwapType.FROM_BTCLN_AUTO) ?
                             this.createFromBTCLNSwapNewViaLNURL(dstToken.chainId, dst, dstToken.address, src, amount, !exactIn, undefined, options as any) :
-                            this.createFromBTCLNSwapViaLNURL(dstToken.chainId, dst, dstToken.address, src, amount, !exactIn);
+                            this.createFromBTCLNSwapViaLNURL(dstToken.chainId, dst, dstToken.address, src, amount, !exactIn, undefined, options as any);
                     } else {
                         return this.supportsSwapType(dstToken.chainId, SwapType.FROM_BTCLN_AUTO) ?
                             this.createFromBTCLNSwapNew(dstToken.chainId, dst, dstToken.address, amount, !exactIn, undefined, options as any):

package/src/swaps/ISwap.ts

@@ -12,6 +12,7 @@ import {isSCToken, Token} from "../types/Token";
 import {SwapExecutionAction} from "../types/SwapExecutionAction";
 import {LoggerType} from "../utils/Logger";
 import {isPriceInfoType, PriceInfoType} from "../types/PriceInfoType";
+import {SwapStateInfo} from "../types/SwapStateInfo";
 
 /**
  * Initialization data for creating a swap
@@ -57,6 +58,17 @@ export abstract class ISwap<
      * 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
@@ -486,6 +498,23 @@ export abstract class ISwap<
         return this._state;
     }
 
+    /**
+     * Returns the current state of the swap along with the human-readable description of the state
+     */
+    public getStateInfo(): SwapStateInfo<S> {
+        return {
+            state: this._state,
+            name: this.swapStateName(this._state),
+            description: this.swapStateDescription[this._state]
+        }
+    }
+
+    /**
+     * 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.
+     */
+    public abstract getCurrentActions(): Promise<SwapExecutionAction<T>[]>;
+
     //////////////////////////////
     //// Amounts & fees
 

package/src/swaps/escrow_swaps/IEscrowSwap.ts

@@ -131,6 +131,26 @@ export abstract class IEscrowSwap<
         return this.getIdentifierHashString();
     }
 
+    /**
+     * Returns the smart chain transaction ID of the tx that initiated the escrow
+     */
+    getEscrowInitTxId(): string | undefined {
+        return this._commitTxId;
+    }
+
+    /**
+     * Returns the smart chain transaction ID of the tx that claimed (settled) the escrow
+     */
+    getEscrowClaimTxId(): string | undefined {
+        return this._claimTxId;
+    }
+
+    /**
+     * Returns the smart chain transaction ID of the tx that refunded the escrow
+     */
+    getEscrowRefundTxId(): string | undefined {
+        return this._refundTxId;
+    }
 
     //////////////////////////////
     //// Watchdogs

package/src/swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap.ts

@@ -31,6 +31,7 @@ import {getLogger, LoggerType} from "../../../../utils/Logger";
 import {timeoutPromise} from "../../../../utils/TimeoutUtils";
 import {isLNURLWithdraw, LNURLWithdraw, LNURLWithdrawParamsWithUrl} from "../../../../types/lnurl/LNURLWithdraw";
 import {sha256} from "@noble/hashes/sha2";
+import {SwapExecutionAction} from "../../../../types/SwapExecutionAction";
 
 /**
  * State enum for legacy Lightning -> Smart chain swaps
@@ -80,6 +81,17 @@ export enum FromBTCLNSwapState {
     CLAIM_CLAIMED = 3
 }
 
+const FromBTCLNSwapStateDescription = {
+    [FromBTCLNSwapState.FAILED]: "Swap has failed as the user didn't settle the HTLC on the destination before expiration",
+    [FromBTCLNSwapState.QUOTE_EXPIRED]: "Swap has expired for good and there is no way how it can be executed anymore",
+    [FromBTCLNSwapState.QUOTE_SOFT_EXPIRED]: "Swap is expired, though there is still a chance that it will be processed",
+    [FromBTCLNSwapState.EXPIRED]: "Swap HTLC on the destination chain has expired, it is not safe anymore to settle (claim) the swap on the destination smart chain.",
+    [FromBTCLNSwapState.PR_CREATED]: "Swap quote was created, pay the bolt11 lightning network invoice to initiate the swap, then use the wait till the lightning network payment is received by the intermediary (LP)",
+    [FromBTCLNSwapState.PR_PAID]: "Lightning network payment has been received by the intermediary (LP), the user can now settle the swap on the destination smart chain side.",
+    [FromBTCLNSwapState.CLAIM_COMMITED]: "Swap escrow HTLC has been created on the destination chain. Continue by claiming it.",
+    [FromBTCLNSwapState.CLAIM_CLAIMED]: "Swap successfully settled and funds received on the destination chain"
+};
+
 export type FromBTCLNSwapInit<T extends SwapData> = IEscrowSelfInitSwapInit<T> & {
     pr?: string,
     secret?: string,
@@ -109,6 +121,14 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
     implements IAddressSwap, IClaimableSwap<T, FromBTCLNDefinition<T>, FromBTCLNSwapState> {
 
     protected readonly TYPE = SwapType.FROM_BTCLN;
+    /**
+     * @internal
+     */
+    protected readonly swapStateName = (state: number) => FromBTCLNSwapState[state];
+    /**
+     * @internal
+     */
+    protected readonly swapStateDescription = FromBTCLNSwapStateDescription;
     /**
      * @internal
      */
@@ -468,6 +488,25 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
         return this.getSwapData().getClaimHash()===claimHash;
     }
 
+    /**
+     * 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) {
+        if(!this.isValidSecretPreimage(secret)) throw new Error("Invalid secret preimage provided, hash doesn't match!");
+        this.secret = secret;
+    }
+
+    /**
+     * Returns whether the secret preimage for this swap is known
+     */
+    hasSecretPreimage(): boolean {
+        return this.secret != null;
+    }
+
 
     //////////////////////////////
     //// Execution
@@ -482,7 +521,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
      *  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
      */
     async execute(
@@ -496,10 +535,10 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
         },
         options?: {
             abortSignal?: AbortSignal,
+            secret?: string,
             lightningTxCheckIntervalSeconds?: number,
             delayBetweenCommitAndClaimSeconds?: number
-        },
-        secret?: string
+        }
     ): Promise<void> {
         if(this._state===FromBTCLNSwapState.FAILED) throw new Error("Swap failed!");
         if(this._state===FromBTCLNSwapState.EXPIRED) throw new Error("Swap HTLC expired!");
@@ -530,14 +569,14 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
 
         if(this._state===FromBTCLNSwapState.PR_PAID || this._state===FromBTCLNSwapState.CLAIM_COMMITED) {
             if(this.canCommitAndClaimInOneShot()) {
-                await this.commitAndClaim(dstSigner, options?.abortSignal, undefined, callbacks?.onDestinationCommitSent, callbacks?.onDestinationClaimSent, secret);
+                await this.commitAndClaim(dstSigner, options?.abortSignal, undefined, callbacks?.onDestinationCommitSent, callbacks?.onDestinationClaimSent, options?.secret);
             } else {
                 if(this._state===FromBTCLNSwapState.PR_PAID) {
                     await this.commit(dstSigner, options?.abortSignal, undefined, callbacks?.onDestinationCommitSent);
                     if(options?.delayBetweenCommitAndClaimSeconds!=null) await timeoutPromise(options.delayBetweenCommitAndClaimSeconds * 1000, options?.abortSignal);
                 }
                 if(this._state===FromBTCLNSwapState.CLAIM_COMMITED) {
-                    await this.claim(dstSigner, options?.abortSignal, callbacks?.onDestinationClaimSent, secret);
+                    await this.claim(dstSigner, options?.abortSignal, callbacks?.onDestinationClaimSent, options?.secret);
                 }
             }
         }
@@ -555,10 +594,13 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
      * @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
      */
-    async txsExecute(options?: { skipChecks?: boolean }, secret?: string) {
+    async txsExecute(options?: {
+        skipChecks?: boolean,
+        secret?: string
+    }) {
         if(this._state===FromBTCLNSwapState.PR_CREATED) {
             if(!await this._verifyQuoteValid()) throw new Error("Quote already expired or close to expiry!");
             return [
@@ -580,7 +622,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
         if(this._state===FromBTCLNSwapState.PR_PAID) {
             if(!await this._verifyQuoteValid()) throw new Error("Quote already expired or close to expiry!");
             const txsCommit = await this.txsCommit(options?.skipChecks);
-            const txsClaim = await this._txsClaim(undefined, secret);
+            const txsClaim = await this._txsClaim(undefined, options?.secret);
             return [
                 {
                     name: "Commit" as const,
@@ -598,7 +640,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
         }
 
         if(this._state===FromBTCLNSwapState.CLAIM_COMMITED) {
-            const txsClaim = await this.txsClaim(undefined, secret);
+            const txsClaim = await this.txsClaim(undefined, options?.secret);
             return [
                 {
                     name: "Claim" as const,
@@ -612,6 +654,27 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
         throw new Error("Invalid swap state to obtain execution txns, required PR_CREATED, PR_PAID or CLAIM_COMMITED");
     }
 
+    /**
+     * @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
+     */
+    async getCurrentActions(options?: {
+        skipChecks?: boolean,
+        secret?: string
+    }): Promise<SwapExecutionAction<T>[]> {
+        try {
+            return await this.txsExecute(options);
+        } catch (e) {
+            return [];
+        }
+    }
+
 
     //////////////////////////////
     //// Payment
@@ -1387,4 +1450,4 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
         }
     }
 
-}
+}