@atomiqlabs/sdk 8.3.6 → 8.4.4

package/src/swaps/escrow_swaps/tobtc/IToBTCSwap.ts

@@ -23,7 +23,7 @@ import {ppmToPercentage} from "../../../types/fees/PercentagePPM";
 import {TokenAmount, toTokenAmount} from "../../../types/TokenAmount";
 import {BtcToken, SCToken} from "../../../types/Token";
 import {timeoutPromise} from "../../../utils/TimeoutUtils";
-import {SwapExecutionActionCommit} from "../../../types/SwapExecutionAction";
+import {SwapExecutionAction, SwapExecutionActionCommit} from "../../../types/SwapExecutionAction";
 
 export type IToBTCSwapInit<T extends SwapData> = IEscrowSelfInitSwapInit<T> & {
     signatureData?: SignatureData,
@@ -92,6 +92,17 @@ export enum ToBTCSwapState {
     REFUNDABLE = 4
 }
 
+const ToBTCSwapStateDescription = {
+    [ToBTCSwapState.REFUNDED]: "Intermediary (LP) was unable to process the swap and the funds were refunded on the source chain",
+    [ToBTCSwapState.QUOTE_EXPIRED]: "Swap has expired for good and there is no way how it can be executed anymore",
+    [ToBTCSwapState.QUOTE_SOFT_EXPIRED]: "A swap is expired, though there is still a chance that it will be processed",
+    [ToBTCSwapState.CREATED]: "Swap was created, initiate it by creating the swap escrow on the source chain",
+    [ToBTCSwapState.COMMITED]: "Swap escrow was initiated (committed) on the source chain, the intermediary (LP) will now process the swap.",
+    [ToBTCSwapState.SOFT_CLAIMED]: "The intermediary (LP) has processed the transaction and sent out the funds on the destination chain, but hasn't yet settled the escrow on the source chain.",
+    [ToBTCSwapState.CLAIMED]: "Swap was successfully settled by the intermediary (LP) on the source chain",
+    [ToBTCSwapState.REFUNDABLE]: "Intermediary (LP) was unable to process the swap and the swap escrow on the source chain is refundable."
+};
+
 /**
  * Base class for escrow-based Smart chain -> Bitcoin (on-chain & lightning) swaps
  *
@@ -101,6 +112,15 @@ export abstract class IToBTCSwap<
     T extends ChainType = ChainType,
     D extends IToBTCDefinition<T, IToBTCWrapper<T, D>, IToBTCSwap<T, D>> = IToBTCDefinition<T, IToBTCWrapper<T, any>, IToBTCSwap<T, any>>,
 > extends IEscrowSelfInitSwap<T, D, ToBTCSwapState> implements IRefundableSwap<T, D, ToBTCSwapState> {
+
+    /**
+     * @internal
+     */
+    protected readonly swapStateDescription = ToBTCSwapStateDescription;
+    /**
+     * @internal
+     */
+    protected readonly swapStateName = (state: number) => ToBTCSwapState[state];
     /**
      * @internal
      */
@@ -280,6 +300,21 @@ export abstract class IToBTCSwap<
         return this._state===ToBTCSwapState.REFUNDED;
     }
 
+    /**
+     * @inheritDoc
+     */
+    isInProgress(): boolean {
+        return this._state===ToBTCSwapState.COMMITED || this._state===ToBTCSwapState.SOFT_CLAIMED;
+    }
+
+    /**
+     * Returns the time (in UNIX milliseconds) at which the swap expires and the user is able to unilaterally
+     *  refund it with the {@link refund} or {@link txsRefund} function.
+     */
+    getExpiry(): number {
+        return Number(this._data.getExpiry())*1000;
+    }
+
     /**
      * @inheritDoc
      * @internal
@@ -501,6 +536,7 @@ export abstract class IToBTCSwap<
 
     /**
      * @inheritDoc
+     *
      * @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`)
      */
@@ -521,6 +557,32 @@ export abstract class IToBTCSwap<
         ];
     }
 
+    /**
+     * @inheritDoc
+     *
+     * @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.refundSmartChainSigner Optional smart chain signer to use when creating refunds transactions
+     */
+    async getCurrentActions(options?: {
+        skipChecks?: boolean,
+        refundSmartChainSigner?: string | T["Signer"] | T["NativeSigner"]
+    }): Promise<SwapExecutionAction<T>[]> {
+        if(this._state===ToBTCSwapState.CREATED) {
+            try {
+                return await this.txsExecute(options);
+            } catch (e) {}
+        }
+        if(this.isRefundable()) {
+            return [{
+                name: "Refund" as const,
+                description: "Refund the swap after it failed to execute",
+                chain: this.chainIdentifier,
+                txs: await this.txsRefund(options?.refundSmartChainSigner)
+            }];
+        }
+        return [];
+    }
 
     //////////////////////////////
     //// Commit
@@ -777,10 +839,21 @@ export abstract class IToBTCSwap<
      * @throws {SignatureVerificationError} If intermediary returned invalid cooperative refund signature
      * @throws {Error} When state is not refundable
      */
-    async txsRefund(signer?: string): Promise<T["TX"][]> {
+    async txsRefund(_signer?: string | T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]> {
         if(!this.isRefundable()) throw new Error("Must be in REFUNDABLE state or expired!");
 
-        signer ??= this._getInitiator();
+        let signer: string;
+        if(_signer!=null) {
+            if (typeof (_signer) === "string") {
+                signer = _signer;
+            } else if (isAbstractSigner(_signer)) {
+                signer = _signer.getAddress();
+            } else {
+                signer = (await this.wrapper._chain.wrapSigner(_signer)).getAddress();
+            }
+        } else {
+            signer = this._getInitiator();
+        }
 
         if(await this.wrapper._contract.isExpired(this._getInitiator(), this._data)) {
             return await this.wrapper._contract.txsRefund(signer, this._data, true, true);
@@ -1020,4 +1093,4 @@ export abstract class IToBTCSwap<
         }
         return false;
     }
-}
+}

package/src/swaps/spv_swaps/SpvFromBTCSwap.ts

@@ -38,7 +38,7 @@ import {
     serializePriceInfoType
 } from "../../types/PriceInfoType";
 import {toBitcoinWallet} from "../../utils/BitcoinWalletUtils";
-import {SwapExecutionActionBitcoin} from "../../types/SwapExecutionAction";
+import {SwapExecutionAction, SwapExecutionActionBitcoin} from "../../types/SwapExecutionAction";
 
 /**
  * State enum for SPV vault (UTXO-controlled vault) based swaps
@@ -109,6 +109,21 @@ export enum SpvFromBTCSwapState {
     CLAIMED = 6
 }
 
+const SpvFromBTCSwapStateDescription = {
+    [SpvFromBTCSwapState.CLOSED]: "Catastrophic failure has occurred when processing the swap on the smart chain side, this implies a bug in the smart contract code or the user and intermediary deliberately creating a bitcoin transaction with invalid format unparsable by the smart contract.",
+    [SpvFromBTCSwapState.FAILED]: "Some of the bitcoin swap transaction inputs were double-spent, this means the swap has failed and no BTC was sent",
+    [SpvFromBTCSwapState.DECLINED]: "The intermediary (LP) declined to co-sign the submitted PSBT, hence the swap failed",
+    [SpvFromBTCSwapState.QUOTE_EXPIRED]: "Swap has expired for good and there is no way how it can be executed anymore",
+    [SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED]: "A swap is almost expired, and it should be presented to the user as expired, though there is still a chance that it will be processed",
+    [SpvFromBTCSwapState.CREATED]: "Swap was created, get the bitcoin swap PSBT that should be signed by the user's wallet and then submit it back to the SDK.",
+    [SpvFromBTCSwapState.SIGNED]: "Swap bitcoin PSBT was submitted by the client to the SDK",
+    [SpvFromBTCSwapState.POSTED]: "Swap bitcoin PSBT sent to the intermediary (LP), waiting for the intermediary co-sign it and broadcast.",
+    [SpvFromBTCSwapState.BROADCASTED]: "Intermediary (LP) has co-signed and broadcasted the bitcoin transaction.",
+    [SpvFromBTCSwapState.FRONTED]: "Settlement on the destination smart chain was fronted and funds were already received by the user, even before the final settlement.",
+    [SpvFromBTCSwapState.BTC_TX_CONFIRMED]: "Bitcoin transaction confirmed with necessary amount of confirmations, wait for automatic settlement by the watchtower or settle manually.",
+    [SpvFromBTCSwapState.CLAIMED]: "Swap settled on the smart chain and funds received"
+}
+
 export type SpvFromBTCSwapInit = ISwapInit & {
     quoteId: string;
     recipient: string;
@@ -179,6 +194,15 @@ export class SpvFromBTCSwap<T extends ChainType>
     implements IBTCWalletSwap, ISwapWithGasDrop<T>, IClaimableSwap<T, SpvFromBTCTypeDefinition<T>, SpvFromBTCSwapState> {
 
     readonly TYPE: SwapType.SPV_VAULT_FROM_BTC = SwapType.SPV_VAULT_FROM_BTC;
+
+    /**
+     * @internal
+     */
+    protected readonly swapStateDescription = SpvFromBTCSwapStateDescription;
+    /**
+     * @internal
+     */
+    protected readonly swapStateName = (state: number) => SpvFromBTCSwapState[state];
     /**
      * @inheritDoc
      * @internal
@@ -242,6 +266,12 @@ export class SpvFromBTCSwap<T extends ChainType>
      */
     readonly minimumBtcFeeRate: number;
 
+    /**
+     * Time at which the SDK realized the bitcoin transaction was confirmed
+     * @private
+     */
+    private btcTxConfirmedAt?: number;
+
     constructor(wrapper: SpvFromBTCWrapper<T>, init: SpvFromBTCSwapInit);
     constructor(wrapper: SpvFromBTCWrapper<T>, obj: any);
     constructor(wrapper: SpvFromBTCWrapper<T>, initOrObject: SpvFromBTCSwapInit | any) {
@@ -306,6 +336,7 @@ export class SpvFromBTCSwap<T extends ChainType>
             this._claimTxId = initOrObject.claimTxId;
             this._frontTxId = initOrObject.frontTxId;
             this.gasPricingInfo = deserializePriceInfoType(initOrObject.gasPricingInfo);
+            this.btcTxConfirmedAt = initOrObject.btcTxConfirmedAt;
             if(initOrObject.data!=null) this._data = new this.wrapper._spvWithdrawalDataDeserializer(initOrObject.data);
         }
         this.tryCalculateSwapFee();
@@ -475,6 +506,15 @@ export class SpvFromBTCSwap<T extends ChainType>
         return this._state===SpvFromBTCSwapState.FAILED || this._state===SpvFromBTCSwapState.DECLINED || this._state===SpvFromBTCSwapState.CLOSED;
     }
 
+    /**
+     * @inheritDoc
+     */
+    isInProgress(): boolean {
+        return this._state===SpvFromBTCSwapState.POSTED ||
+            this._state===SpvFromBTCSwapState.BROADCASTED ||
+            this._state===SpvFromBTCSwapState.BTC_TX_CONFIRMED;
+    }
+
     /**
      * @inheritDoc
      */
@@ -1033,12 +1073,14 @@ export class SpvFromBTCSwap<T extends ChainType>
     /**
      * @inheritDoc
      *
+     * @param options.bitcoinFeeRate Optional fee rate to use for the created Bitcoin transaction
      * @param options.bitcoinWallet Optional bitcoin wallet address specification to return a funded PSBT,
      *  if not provided a raw PSBT is returned instead which necessitates the implementor to manually add
      *  inputs to the bitcoin transaction and **set the nSequence field of the 2nd input** (input 1 -
      *  indexing from 0) to the value returned in `in1sequence`
      */
     async txsExecute(options?: {
+        bitcoinFeeRate?: number,
         bitcoinWallet?: MinimalBitcoinWalletInterface,
     }): Promise<[
         SwapExecutionActionBitcoin<"RAW_PSBT" | "FUNDED_PSBT">
@@ -1053,7 +1095,7 @@ export class SpvFromBTCSwap<T extends ChainType>
                     txs: [
                         options?.bitcoinWallet==null
                             ? {...await this.getPsbt(), type: "RAW_PSBT"}
-                            : {...await this.getFundedPsbt(options.bitcoinWallet), type: "FUNDED_PSBT"}
+                            : {...await this.getFundedPsbt(options.bitcoinWallet, options?.bitcoinFeeRate), type: "FUNDED_PSBT"}
                     ]
                 }
             ];
@@ -1063,6 +1105,47 @@ export class SpvFromBTCSwap<T extends ChainType>
     }
 
 
+    /**
+     * @inheritDoc
+     *
+     * @param options.bitcoinFeeRate Optional fee rate to use for the created Bitcoin transaction
+     * @param options.bitcoinWallet Optional bitcoin wallet address specification to return a funded PSBT,
+     *  if not provided a raw PSBT is returned instead which necessitates the implementor to manually add
+     *  inputs to the bitcoin transaction and **set the nSequence field of the 2nd input** (input 1 -
+     *  indexing from 0) to the value returned in `in1sequence`
+     * @param options.manualSettlementSmartChainSigner Optional smart chain signer to create a manual claim (settlement) transaction
+     * @param options.maxWaitTillAutomaticSettlementSeconds Maximum time to wait for an automatic settlement after
+     *  the bitcoin transaction is confirmed (defaults to 60 seconds)
+     */
+    async getCurrentActions(options?: {
+        bitcoinFeeRate?: number,
+        bitcoinWallet?: MinimalBitcoinWalletInterface,
+        manualSettlementSmartChainSigner?: string | T["Signer"] | T["NativeSigner"],
+        maxWaitTillAutomaticSettlementSeconds?: number
+    }): Promise<SwapExecutionAction<T>[]> {
+        if(this._state===SpvFromBTCSwapState.CREATED) {
+            try {
+                return await this.txsExecute(options);
+            } catch (e) {}
+        }
+        if(this._state===SpvFromBTCSwapState.BTC_TX_CONFIRMED) {
+            if(
+                this.btcTxConfirmedAt==null ||
+                options?.maxWaitTillAutomaticSettlementSeconds===0 ||
+                (Date.now() - this.btcTxConfirmedAt) > (options?.maxWaitTillAutomaticSettlementSeconds ?? 60)*1000
+            ) {
+                return [{
+                    name: "Claim" as const,
+                    description: "Manually settle (claim) the swap on the destination smart chain",
+                    chain: this.chainIdentifier,
+                    txs: await this.txsClaim(options?.manualSettlementSmartChainSigner)
+                }];
+            }
+        }
+        return [];
+    }
+
+
     //////////////////////////////
     //// Bitcoin tx listener
 
@@ -1139,6 +1222,7 @@ export class SpvFromBTCSwap<T extends ChainType>
             (this._state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.FRONTED &&
             (this._state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.CLAIMED
         ) {
+            this.btcTxConfirmedAt ??= Date.now();
             this._state = SpvFromBTCSwapState.BTC_TX_CONFIRMED;
             save = true;
         }
@@ -1378,7 +1462,7 @@ export class SpvFromBTCSwap<T extends ChainType>
                 (this._state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.CLAIMED
             ) {
                 this._claimTxId = res.txId;
-                await this._saveAndEmit(SpvFromBTCSwapState.FRONTED);
+                await this._saveAndEmit(SpvFromBTCSwapState.CLAIMED);
             }
         }
         if(res.type===SpvWithdrawalStateType.CLOSED) {
@@ -1449,7 +1533,8 @@ export class SpvFromBTCSwap<T extends ChainType>
             senderAddress: this._senderAddress,
             claimTxId: this._claimTxId,
             frontTxId: this._frontTxId,
-            data: this._data?.serialize()
+            data: this._data?.serialize(),
+            btcTxConfirmedAt: this.btcTxConfirmedAt
         };
     }
 
@@ -1514,6 +1599,7 @@ export class SpvFromBTCSwap<T extends ChainType>
                     this._state!==SpvFromBTCSwapState.FRONTED &&
                     this._state!==SpvFromBTCSwapState.CLAIMED
                 ) {
+                    this.btcTxConfirmedAt ??= Date.now();
                     this._state = SpvFromBTCSwapState.BTC_TX_CONFIRMED;
                     needsSave = true;
                 }

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

@@ -13,7 +13,7 @@ import {TokenAmount, toTokenAmount} from "../../../types/TokenAmount";
 import {BitcoinTokens, BtcToken, SCToken} from "../../../types/Token";
 import {getLogger, LoggerType} from "../../../utils/Logger";
 import {timeoutPromise} from "../../../utils/TimeoutUtils";
-import {SwapExecutionActionLightning} from "../../../types/SwapExecutionAction";
+import {SwapExecutionAction, SwapExecutionActionLightning} from "../../../types/SwapExecutionAction";
 
 /**
  * State enum for trusted Lightning gas swaps
@@ -30,7 +30,7 @@ export enum LnForGasSwapState {
      */
     FAILED = -1,
     /**
-     * Swap was created
+     * Swap was created, pay the provided lightning network invoice
      */
     PR_CREATED = 0,
     /**
@@ -43,6 +43,19 @@ export enum LnForGasSwapState {
     FINISHED = 2
 }
 
+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"
+}
+
 export type LnForGasSwapInit = ISwapInit & {
     pr: string;
     outputAmount: bigint;
@@ -66,6 +79,16 @@ export function isLnForGasSwapInit(obj: any): obj is LnForGasSwapInit {
  */
 export class LnForGasSwap<T extends ChainType = ChainType> extends ISwap<T, LnForGasSwapTypeDefinition<T>, LnForGasSwapState> implements IAddressSwap {
     protected readonly TYPE: SwapType.TRUSTED_FROM_BTCLN = SwapType.TRUSTED_FROM_BTCLN;
+
+    /**
+     * @internal
+     */
+    protected readonly swapStateDescription = LnForGasSwapStateDescription;
+    /**
+     * @internal
+     */
+    protected readonly swapStateName = (state: number) => LnForGasSwapState[state];
+
     /**
      * @internal
      */
@@ -249,6 +272,13 @@ export class LnForGasSwap<T extends ChainType = ChainType> extends ISwap<T, LnFo
         return this._state===LnForGasSwapState.FINISHED;
     }
 
+    /**
+     * @inheritDoc
+     */
+    isInProgress(): boolean {
+        return (this._state===LnForGasSwapState.PR_CREATED && this.initiated) || this._state===LnForGasSwapState.PR_PAID;
+    }
+
     /**
      * @inheritDoc
      * @internal
@@ -397,6 +427,24 @@ export class LnForGasSwap<T extends ChainType = ChainType> extends ISwap<T, LnFo
         throw new Error("Invalid swap state to obtain execution txns, required PR_CREATED");
     }
 
+    /**
+     * @remark Not supported
+     */
+    async execute(): Promise<boolean> {
+        throw new Error("Not supported");
+    }
+
+    /**
+     * @inheritDoc
+     */
+    async getCurrentActions(): Promise<SwapExecutionAction<T>[]> {
+        try {
+            return await this.txsExecute();
+        } catch (e) {
+            return [];
+        }
+    }
+
     /**
      * Queries the intermediary (LP) node for the state of the swap
      *
@@ -538,4 +586,4 @@ export class LnForGasSwap<T extends ChainType = ChainType> extends ISwap<T, LnFo
         return Promise.resolve(false);
     }
 
-}
+}

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

@@ -23,7 +23,7 @@ import {BitcoinTokens, BtcToken, SCToken} from "../../../types/Token";
 import {getLogger, LoggerType} from "../../../utils/Logger";
 import {timeoutPromise} from "../../../utils/TimeoutUtils";
 import {toBitcoinWallet} from "../../../utils/BitcoinWalletUtils";
-import {SwapExecutionActionBitcoin} from "../../../types/SwapExecutionAction";
+import {SwapExecutionAction, SwapExecutionActionBitcoin} from "../../../types/SwapExecutionAction";
 
 /**
  * State enum for trusted on-chain gas swaps
@@ -44,7 +44,7 @@ export enum OnchainForGasSwapState {
      */
     REFUNDED = -1,
     /**
-     * Swap was created
+     * Swap was created, send the BTC to the swap address
      */
     PR_CREATED = 0,
     /**
@@ -57,6 +57,21 @@ export enum OnchainForGasSwapState {
     REFUNDABLE = 2
 }
 
+const OnchainForGasSwapStateDescription: Record<OnchainForGasSwapState, string> = {
+    [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",
+};
+
 export type OnchainForGasSwapInit = ISwapInit & {
     paymentHash: string;
     sequence: bigint;
@@ -86,8 +101,18 @@ export function isOnchainForGasSwapInit(obj: any): obj is OnchainForGasSwapInit
  *
  * @category Swaps/Trusted Gas Swaps
  */
-export class OnchainForGasSwap<T extends ChainType = ChainType> extends ISwap<T, OnchainForGasSwapTypeDefinition<T>> implements IAddressSwap, IBTCWalletSwap {
+export class OnchainForGasSwap<T extends ChainType = ChainType> extends ISwap<T, OnchainForGasSwapTypeDefinition<T>, OnchainForGasSwapState> implements IAddressSwap, IBTCWalletSwap {
     protected readonly TYPE: SwapType.TRUSTED_FROM_BTC = SwapType.TRUSTED_FROM_BTC;
+
+    /**
+     * @internal
+     */
+    protected readonly swapStateDescription = OnchainForGasSwapStateDescription;
+    /**
+     * @internal
+     */
+    protected readonly swapStateName = (state: number) => OnchainForGasSwapState[state];
+
     /**
      * @internal
      */
@@ -289,6 +314,14 @@ export class OnchainForGasSwap<T extends ChainType = ChainType> extends ISwap<T,
         return this._state===OnchainForGasSwapState.FINISHED;
     }
 
+    /**
+     * @inheritDoc
+     */
+    isInProgress(): boolean {
+        return (this._state===OnchainForGasSwapState.PR_CREATED && this.txId!=null) ||
+            (this._state===OnchainForGasSwapState.REFUNDABLE && this.refundAddress!=null);
+    }
+
     /**
      * @inheritDoc
      * @internal
@@ -559,6 +592,28 @@ export class OnchainForGasSwap<T extends ChainType = ChainType> extends ISwap<T,
         throw new Error("Invalid swap state to obtain execution txns, required PR_CREATED or CLAIM_COMMITED");
     }
 
+    /**
+     * @remark Not supported
+     */
+    async execute(): Promise<boolean> {
+        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?: {
+        bitcoinWallet?: MinimalBitcoinWalletInterface
+    }): Promise<SwapExecutionAction<T>[]> {
+        try {
+            return await this.txsExecute(options);
+        } catch (e) {
+            return [];
+        }
+    }
 
     //////////////////////////////
     //// Payment

package/src/types/SwapStateInfo.ts

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

package/src/types/lnurl/LNURLPay.ts

@@ -51,7 +51,6 @@ export function isLNURLPayParams(obj: any): obj is LNURLPayParams {
  * Type guard for {@link LNURLPay}
  *
  * @category Lightning
- * @internal
  */
 export function isLNURLPay(value: any): value is LNURLPay {
     return (

package/src/types/lnurl/LNURLWithdraw.ts

@@ -38,7 +38,6 @@ export type LNURLWithdraw = {
  * Type guard for {@link LNURLWithdraw}
  *
  * @category Lightning
- * @internal
  */
 export function isLNURLWithdraw(value: any): value is LNURLWithdraw {
     return (