@atomiqlabs/sdk 8.5.0 → 8.6.2

package/src/swapper/Swapper.ts

@@ -152,9 +152,15 @@ export type SwapperOptions = {
      */
     dontFetchLPs?: boolean,
     /**
-     * By setting this flag the SDK persists all created swaps. By default, the SDK only saves and persists swaps that
-     *  are considered initiated, i.e. when `commit()`, `execute()` or `waitTillPayment` is called (or their respective
-     *  txs... prefixed variations).
+     * Defaults to `true`, this means every swap regardless of it being initiated (i.e. when `commit()`, `execute()` or
+     *  `waitTillPayment` is called) is saved to the persistent storage. This is a reasonable default for when you
+     *  want to only create a swap, and then later on retrieve it with the `swapper.getSwapById()` function.
+     *
+     * Setting this to `false` means the SDK only saves and persists swaps that are considered initiated, i.e. when
+     *  `commit()`, `execute()` or `waitTillPayment` is called (or their respective txs... prefixed variations). This
+     *  might save calls to the persistent storage for swaps that are never initiated. This is useful in e.g.
+     *  frontend implementations where the frontend holds the swap object reference until it is initiated anyway, not
+     *  necessitating the saving of the swap data to the persistent storage until it is actually initiated.
      */
     saveUninitializedSwaps?: boolean,
     /**
@@ -310,7 +316,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
         bitcoinSynchronizer: (btcRelay: BtcRelay<any, any, any>) => RelaySynchronizer<any, any, any>,
         chainsData: CtorMultiChainData<T>,
         pricing: ISwapPrice<T>,
-        tokens: SwapperCtorTokens<T>,
+        tokens: SCToken[],
         messenger: Messenger,
         options?: SwapperOptions
     ) {
@@ -318,6 +324,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
         const storagePrefix = options?.storagePrefix ?? "atomiq-";
 
         options ??= {};
+        options.saveUninitializedSwaps ??= true;
         options.bitcoinNetwork = options.bitcoinNetwork==null ? BitcoinNetwork.TESTNET : options.bitcoinNetwork;
         const swapStorage = options.swapStorage ??= (name: string) => new IndexedDBUnifiedStorage(name);
 
@@ -340,22 +347,10 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
         this._tokens = {};
         this._tokensByTicker = {};
         for(let tokenData of tokens) {
-            for(let chainId in tokenData.chains) {
-                const chainData = tokenData.chains[chainId]!;
-                this._tokens[chainId] ??= {};
-                this._tokensByTicker[chainId] ??= {};
-                this._tokens[chainId][chainData.address] = this._tokensByTicker[chainId][tokenData.ticker] = {
-                    chain: "SC",
-                    chainId,
-                    ticker: tokenData.ticker,
-                    name: tokenData.name,
-                    decimals: chainData.decimals,
-                    displayDecimals: chainData.displayDecimals,
-                    address: chainData.address,
-                    equals: (other: Token) => other.chainId===chainId && other.ticker===tokenData.ticker && other.address===chainData.address,
-                    toString: () => `${chainId}-${tokenData.ticker}`
-                }
-            }
+            const chainId = tokenData.chainId;
+            this._tokens[chainId] ??= {};
+            this._tokensByTicker[chainId] ??= {};
+            this._tokens[chainId][tokenData.address] = this._tokensByTicker[chainId][tokenData.ticker] = tokenData;
         }
 
         this.swapStateListener = (swap: ISwap) => {
@@ -388,6 +383,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 {
                     getRequestTimeout: this.options.getRequestTimeout,
                     postRequestTimeout: this.options.postRequestTimeout,
+                    saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                 }
             );
             wrappers[SwapType.TO_BTC] = new ToBTCWrapper<T[InputKey]>(
@@ -403,6 +399,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 {
                     getRequestTimeout: this.options.getRequestTimeout,
                     postRequestTimeout: this.options.postRequestTimeout,
+                    saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                     bitcoinNetwork: this._btcNetwork
                 }
             );
@@ -419,6 +416,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 {
                     getRequestTimeout: this.options.getRequestTimeout,
                     postRequestTimeout: this.options.postRequestTimeout,
+                    saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                     unsafeSkipLnNodeCheck: this.bitcoinNetwork===BitcoinNetwork.TESTNET4 || this.bitcoinNetwork===BitcoinNetwork.REGTEST
                 }
             );
@@ -437,6 +435,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 {
                     getRequestTimeout: this.options.getRequestTimeout,
                     postRequestTimeout: this.options.postRequestTimeout,
+                    saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                     bitcoinNetwork: this._btcNetwork
                 }
             );
@@ -449,7 +448,8 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 this._tokens[chainId],
                 {
                     getRequestTimeout: this.options.getRequestTimeout,
-                    postRequestTimeout: this.options.postRequestTimeout
+                    postRequestTimeout: this.options.postRequestTimeout,
+                    saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                 }
             );
             wrappers[SwapType.TRUSTED_FROM_BTC] = new OnchainForGasWrapper<T[InputKey]>(
@@ -463,6 +463,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                 {
                     getRequestTimeout: this.options.getRequestTimeout,
                     postRequestTimeout: this.options.postRequestTimeout,
+                    saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                     bitcoinNetwork: this._btcNetwork
                 }
             );
@@ -483,6 +484,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                     {
                         getRequestTimeout: this.options.getRequestTimeout,
                         postRequestTimeout: this.options.postRequestTimeout,
+                        saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                         bitcoinNetwork: this._btcNetwork
                     }
                 );
@@ -503,6 +505,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                     {
                         getRequestTimeout: this.options.getRequestTimeout,
                         postRequestTimeout: this.options.postRequestTimeout,
+                        saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                         unsafeSkipLnNodeCheck: this.bitcoinNetwork===BitcoinNetwork.TESTNET4 || this.bitcoinNetwork===BitcoinNetwork.REGTEST
                     }
                 );
@@ -652,7 +655,10 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
      */
     async init(): Promise<void> {
         if(this.initialized) return;
-        if(this.initPromise!=null) await this.initPromise;
+        if(this.initPromise!=null) {
+            await this.initPromise;
+            return;
+        }
 
         try {
             const promise = this._init();
@@ -849,10 +855,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
             if(swapLimitsChanged) this.emit("swapLimitsChanged");
 
             const quote = quotes[0].quote;
-            if(this.options.saveUninitializedSwaps) {
-                quote._setInitiated();
-                await quote._save();
-            }
+            await quote._save();
             return quote;
         } catch (e) {
             if(swapLimitsChanged) this.emit("swapLimitsChanged");
@@ -1327,13 +1330,15 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
      * @param trustedIntermediaryOrUrl  URL or Intermediary object of the trusted intermediary to use, otherwise uses default
      * @throws {Error} If no trusted intermediary specified
      */
-    createTrustedLNForGasSwap<C extends ChainIds<T>>(chainIdentifier: C, recipient: string, amount: bigint, trustedIntermediaryOrUrl?: Intermediary | string): Promise<LnForGasSwap<T[C]>> {
+    async createTrustedLNForGasSwap<C extends ChainIds<T>>(chainIdentifier: C, recipient: string, amount: bigint, trustedIntermediaryOrUrl?: Intermediary | string): Promise<LnForGasSwap<T[C]>> {
         if(this._chains[chainIdentifier]==null) throw new Error("Invalid chain identifier! Unknown chain: "+chainIdentifier);
         if(!this._chains[chainIdentifier].chainInterface.isValidAddress(recipient, true)) throw new Error("Invalid "+chainIdentifier+" address");
         recipient = this._chains[chainIdentifier].chainInterface.normalizeAddress(recipient);
         const useUrl = trustedIntermediaryOrUrl ?? this.defaultTrustedIntermediary ?? this.options.defaultTrustedIntermediaryUrl;
         if(useUrl==null) throw new Error("No trusted intermediary specified!");
-        return this._chains[chainIdentifier as C].wrappers[SwapType.TRUSTED_FROM_BTCLN].create(recipient, amount, useUrl);
+        const swap = await this._chains[chainIdentifier as C].wrappers[SwapType.TRUSTED_FROM_BTCLN].create(recipient, amount, useUrl);
+        await swap._save();
+        return swap;
     }
 
     /**
@@ -1346,7 +1351,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
      * @param trustedIntermediaryOrUrl URL or Intermediary object of the trusted intermediary to use, otherwise uses default
      * @throws {Error} If no trusted intermediary specified
      */
-    createTrustedOnchainForGasSwap<C extends ChainIds<T>>(
+    async createTrustedOnchainForGasSwap<C extends ChainIds<T>>(
         chainIdentifier: C, recipient: string,
         amount: bigint, refundAddress?: string,
         trustedIntermediaryOrUrl?: Intermediary | string
@@ -1356,7 +1361,9 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
         recipient = this._chains[chainIdentifier].chainInterface.normalizeAddress(recipient);
         const useUrl = trustedIntermediaryOrUrl ?? this.defaultTrustedIntermediary ?? this.options.defaultTrustedIntermediaryUrl;
         if(useUrl==null) throw new Error("No trusted intermediary specified!");
-        return this._chains[chainIdentifier as C].wrappers[SwapType.TRUSTED_FROM_BTC].create(recipient, amount, useUrl, refundAddress);
+        const swap = await this._chains[chainIdentifier as C].wrappers[SwapType.TRUSTED_FROM_BTC].create(recipient, amount, useUrl, refundAddress);
+        await swap._save();
+        return swap;
     }
 
     /**

package/src/swapper/SwapperFactory.ts

@@ -9,7 +9,7 @@ import {SmartChainAssets, SmartChainAssetTickers} from "../SmartChainAssets";
 import {NostrMessenger} from "@atomiqlabs/messenger-nostr";
 import {Swapper, SwapperOptions} from "./Swapper";
 import {CustomPriceProvider} from "../prices/providers/CustomPriceProvider";
-import {BitcoinTokens, BtcToken, SCToken} from "../types/Token";
+import {BitcoinTokens, BtcToken, SCToken, Token} from "../types/Token";
 import {SwapType} from "../enums/SwapType";
 import {SwapTypeMapping} from "../utils/SwapUtils";
 import {RedundantSwapPrice, RedundantSwapPriceAssets} from "../prices/RedundantSwapPrice";
@@ -191,6 +191,8 @@ export class SwapperFactory<T extends readonly ChainInitializer<any, ChainType,
      */
     TokenResolver: TypedTokenResolvers<T> = {} as any;
 
+    private smartChainTokens: SCToken[] = [];
+
     constructor(readonly initializers: T) {
         this.initializers = initializers;
         initializers.forEach(initializer => {
@@ -200,15 +202,19 @@ export class SwapperFactory<T extends readonly ChainInitializer<any, ChainType,
 
             for(let ticker in initializer.tokens) {
                 const assetData = initializer.tokens[ticker] as any;
-                tokens[ticker] = addressMap[assetData.address] = {
+                const token: SCToken = {
                     chain: "SC",
                     chainId: initializer.chainId,
-                    address: assetData.address,
+                    ticker,
                     name: SmartChainAssets[ticker as SmartChainAssetTickers]?.name ?? ticker,
                     decimals: assetData.decimals,
                     displayDecimals: assetData.displayDecimals,
-                    ticker
-                } as any;
+                    address: assetData.address,
+                    equals: (other: Token) => other.chainId===initializer.chainId && other.ticker===ticker && other.address===assetData.address,
+                    toString: () => `${initializer.chainId}-${ticker}`
+                };
+                this.smartChainTokens.push(token);
+                tokens[ticker] = addressMap[assetData.address] = token;
             }
 
             this.TokenResolver[initializer.chainId as keyof TypedTokenResolvers<T>] = {
@@ -280,7 +286,7 @@ export class SwapperFactory<T extends readonly ChainInitializer<any, ChainType,
             (btcRelay: BtcRelay<any, any, any>) => new MempoolBtcRelaySynchronizer(btcRelay, bitcoinRpc),
             chains as any,
             swapPricing,
-            pricingAssets,
+            this.smartChainTokens,
             options.messenger,
             options
         );

package/src/swaps/ISwap.ts

@@ -132,6 +132,14 @@ export abstract class ISwap<
      * @internal
      */
     _randomNonce: string;
+    /**
+     * Whether the swap is saved in the persistent storage or not.
+     *
+     * @remarks This field itself is not persisted but is instead derived during runtime
+     *
+     * @internal
+     */
+    _persisted: boolean = false;
 
 
     /**
@@ -229,9 +237,9 @@ export abstract class ISwap<
         //TODO: This doesn't hold strong reference to the swap, hence if no other strong reference to the
         // swap exists, it will just never resolve!
         return new Promise((resolve, reject) => {
-            let listener: (swap: D["Swap"]) => void;
-            listener = (swap) => {
-                if(type==="eq" ? swap._state===targetState : type==="gte" ? swap._state>=targetState : swap._state!=targetState) {
+            let listener: () => void;
+            listener = () => {
+                if(type==="eq" ? this._state===targetState : type==="gte" ? this._state>=targetState : this._state!=targetState) {
                     resolve();
                     this.events.removeListener("swapState", listener);
                 }

package/src/swaps/ISwapWrapper.ts

@@ -13,6 +13,9 @@ import {PriceInfoType} from "../types/PriceInfoType";
 import {fromHumanReadableString} from "../utils/TokenUtils";
 import {UserError} from "../errors/UserError";
 
+export const DEFAULT_MAX_PARALLEL_SWAP_TICKS = 50;
+export const DEFAULT_MAX_PARALLEL_SWAP_SYNCS = 50;
+
 /**
  * Options for swap wrapper configuration
  *
@@ -20,7 +23,19 @@ import {UserError} from "../errors/UserError";
  */
 export type ISwapWrapperOptions = {
     getRequestTimeout?: number,
-    postRequestTimeout?: number
+    postRequestTimeout?: number,
+    /**
+     * How many swaps to call `_tick()` for in parallel
+     */
+    maxParallelSwapTicks?: number,
+    /**
+     * How many swaps to call `_sync()` for in parallel
+     */
+    maxParallelSwapSyncs?: number,
+    /**
+     * Whether to save swaps that are not initialized into the persistent storage
+     */
+    saveUninitializedSwaps?: boolean
 };
 
 /**
@@ -101,6 +116,11 @@ export abstract class ISwapWrapper<
      * @internal
      */
     protected tickInterval?: NodeJS.Timeout;
+    /**
+     * An internal abort controller for the running tick handler
+     * @internal
+     */
+    protected tickAbortController?: AbortController;
 
 
     /**
@@ -152,6 +172,11 @@ export abstract class ISwapWrapper<
         options: O,
         events?: EventEmitter<{swapState: [ISwap]}>
     ) {
+        if(options?.maxParallelSwapTicks!=null && options.maxParallelSwapTicks < 1)
+            throw new Error("maxParallelSwapTicks must be at least 1!");
+        if(options?.maxParallelSwapSyncs!=null && options.maxParallelSwapSyncs < 1)
+            throw new Error("maxParallelSwapSyncs must be at least 1!");
+
         this.unifiedStorage = unifiedStorage;
         this.unifiedChainEvents = unifiedChainEvents;
 
@@ -274,9 +299,20 @@ export abstract class ISwapWrapper<
      */
     protected startTickInterval(): void {
         if(this.tickSwapState==null || this.tickSwapState.length===0) return;
-        this.tickInterval = setInterval(() => {
-            this.tick();
-        }, 1000);
+        if(this.tickAbortController!=null) this.tickAbortController.abort("New tick interval has been started!");
+        const abortController = this.tickAbortController = new AbortController();
+        let run: () => Promise<void>;
+        run = async () => {
+            if(!this.isInitialized) return;
+            await this.tick(undefined, abortController.signal).catch(e => {
+                if(abortController.signal.aborted) return;
+                this.logger.warn("startTickInterval(): Tick on swaps failed, error: ", e);
+            });
+            if(abortController.signal.aborted) return;
+            if(!this.isInitialized) return;
+            this.tickInterval = setTimeout(run, 1000);
+        }
+        run();
     }
 
     /**
@@ -343,11 +379,11 @@ export abstract class ISwapWrapper<
 
         if(this.processEvent!=null) this.unifiedChainEvents.registerListener(this.TYPE, this.processEvent.bind(this), this._swapDeserializer.bind(null, this));
 
+        this.isInitialized = true;
+
         if(!noTimers) this.startTickInterval();
 
         // this.logger.info("init(): Swap wrapper initialized");
-
-        this.isInitialized = true;
     }
 
     /**
@@ -357,12 +393,21 @@ export abstract class ISwapWrapper<
         this.isInitialized = false;
         this.unifiedChainEvents.unregisterListener(this.TYPE);
         this.logger.info("stop(): Swap wrapper stopped");
-        if(this.tickInterval!=null) clearInterval(this.tickInterval);
+        if(this.tickInterval!=null) {
+            clearTimeout(this.tickInterval);
+            delete this.tickInterval;
+        }
+        if(this.tickAbortController!=null) {
+            this.tickAbortController.abort("Wrapper instance stopped!");
+            delete this.tickAbortController;
+        }
     }
 
     /**
      * Runs checks on all the known pending swaps, syncing their state from on-chain data
      *
+     * @remarks Doesn't work properly if you pass non-persisted swaps
+     *
      * @param pastSwaps Optional array of past swaps to check, otherwise all relevant swaps will be fetched
      *  from the persistent storage
      * @param noSave Whether to skip saving the swap changes in the persistent storage
@@ -373,18 +418,25 @@ export abstract class ISwapWrapper<
             (val: any) => new this._swapDeserializer(this, val)
         );
 
-        const {removeSwaps, changedSwaps} = await this._checkPastSwaps(pastSwaps);
-
-        if (!noSave) {
-            await this.unifiedStorage.removeAll(removeSwaps);
-            await this.unifiedStorage.saveAll(changedSwaps);
-            changedSwaps.forEach(swap => swap._emitEvent());
-            removeSwaps.forEach(swap => swap._emitEvent());
+        const maxParallelSyncs = this._options.maxParallelSwapSyncs ?? DEFAULT_MAX_PARALLEL_SWAP_SYNCS;
+
+        const totalRemoveSwaps: D["Swap"][] = [];
+        const totalChangedSwaps: D["Swap"][] = [];
+        for(let i=0; i<pastSwaps.length; i+=maxParallelSyncs) {
+            const {removeSwaps, changedSwaps} = await this._checkPastSwaps(pastSwaps.slice(i, i+maxParallelSyncs));
+            if (!noSave) {
+                await this.unifiedStorage.removeAll(removeSwaps);
+                await this.unifiedStorage.saveAll(changedSwaps);
+                changedSwaps.forEach(swap => swap._emitEvent());
+                removeSwaps.forEach(swap => swap._emitEvent());
+            }
+            totalRemoveSwaps.push(...removeSwaps);
+            totalChangedSwaps.push(...changedSwaps);
         }
 
         return {
-            removeSwaps,
-            changedSwaps
+            removeSwaps: totalRemoveSwaps,
+            changedSwaps: totalChangedSwaps
         }
     }
 
@@ -393,21 +445,43 @@ export abstract class ISwapWrapper<
      *
      * @param swaps Optional array of swaps to invoke `_tick()` on, otherwise all relevant swaps will be fetched
      *  from the persistent storage
+     * @param abortSignal Abort signal
      */
-    public async tick(swaps?: D["Swap"][]): Promise<void> {
+    public async tick(swaps?: D["Swap"][], abortSignal?: AbortSignal): Promise<void> {
         if(swaps==null) swaps = await this.unifiedStorage.query<D["Swap"]>(
             [[{key: "type", value: this.TYPE}, {key: "state", value: this.tickSwapState}]],
             (val: any) => new this._swapDeserializer(this, val)
         );
+        abortSignal?.throwIfAborted();
 
+        const parallelTicks = this._options.maxParallelSwapTicks ?? DEFAULT_MAX_PARALLEL_SWAP_TICKS;
+
+        let promises: Promise<any>[] = [];
         for(let pendingSwap of this.pendingSwaps.values()) {
             const value = pendingSwap.deref();
-            if(value != null) value._tick(true);
+            if(value != null) promises.push(value._tick(true).catch(e => {
+                this.logger.warn(`tick(): Error ticking swap ${value.getId()}: `, e);
+            }));
+            if(promises.length >= parallelTicks) {
+                await Promise.all(promises);
+                abortSignal?.throwIfAborted();
+                promises = [];
+            }
         }
 
-        swaps.forEach(value => {
-            value._tick(true)
-        });
+        for(let value of swaps) {
+            promises.push(value._tick(true).catch(e => {
+                this.logger.warn(`tick(): Error ticking swap ${value.getId()}: `, e);
+            }));
+            if(promises.length >= parallelTicks) {
+                await Promise.all(promises);
+                abortSignal?.throwIfAborted();
+                promises = [];
+            }
+        }
+
+        if(promises.length>0) await Promise.all(promises);
+        abortSignal?.throwIfAborted();
     }
 
     /**
@@ -426,12 +500,14 @@ export abstract class ISwapWrapper<
      * @internal
      */
     _saveSwapData(swap: D["Swap"]): Promise<void> {
-        if(!swap.isInitiated()) {
-            this.logger.debug("saveSwapData(): Swap "+swap.getId()+" not initiated, saving to pending swaps");
-            this.pendingSwaps.set(swap.getId(), new WeakRef<D["Swap"]>(swap));
-            return Promise.resolve();
-        } else {
-            this.pendingSwaps.delete(swap.getId());
+        if(!this._options.saveUninitializedSwaps) {
+            if(!swap.isInitiated()) {
+                this.logger.debug("saveSwapData(): Swap "+swap.getId()+" not initiated, saving to pending swaps");
+                this.pendingSwaps.set(swap.getId(), new WeakRef<D["Swap"]>(swap));
+                return Promise.resolve();
+            } else {
+                this.pendingSwaps.delete(swap.getId());
+            }
         }
         return this.unifiedStorage.save(swap);
     }
@@ -445,7 +521,7 @@ export abstract class ISwapWrapper<
      */
     _removeSwapData(swap: D["Swap"]): Promise<void> {
         this.pendingSwaps.delete(swap.getId());
-        if(!swap.isInitiated()) return Promise.resolve();
+        if(!swap._persisted) return Promise.resolve();
         return this.unifiedStorage.remove(swap);
     }
 

package/src/swaps/escrow_swaps/IEscrowSwapWrapper.ts

@@ -66,7 +66,11 @@ export abstract class IEscrowSwapWrapper<
      * @internal
      */
     protected preFetchSignData(signDataPrefetch: Promise<any | null>): Promise<T["PreFetchVerification"] | undefined> {
-        if(this._contract.preFetchForInitSignatureVerification==null) return Promise.resolve(undefined);
+        if(this._contract.preFetchForInitSignatureVerification==null) {
+            // Catch promise rejections, should they happen
+            signDataPrefetch.catch(() => {});
+            return Promise.resolve(undefined);
+        }
         return signDataPrefetch.then(obj => {
             if(obj==null) return undefined;
             return this._contract.preFetchForInitSignatureVerification!(obj);

package/src/swaps/escrow_swaps/frombtc/IFromBTCSelfInitSwap.ts

@@ -71,7 +71,7 @@ export abstract class IFromBTCSelfInitSwap<
      * Returns if the swap can be committed
      * @internal
      */
-    protected abstract canCommit(): boolean;
+    protected abstract canCommit(skipQuoteExpiryChecks?: boolean): boolean;
 
     /**
      * @inheritDoc
@@ -239,7 +239,7 @@ export abstract class IFromBTCSelfInitSwap<
      * @throws {Error} When in invalid state to commit the swap
      */
     async txsCommit(skipChecks?: boolean): Promise<T["TX"][]> {
-        if(!this.canCommit()) throw new Error("Must be in CREATED state!");
+        if(!this.canCommit(skipChecks)) throw new Error("Must be in CREATED state!");
         if(this._data==null || this.signatureData==null) throw new Error("data or signature data is null, invalid state?");
 
         if(!this.initiated) {
@@ -285,7 +285,7 @@ export abstract class IFromBTCSelfInitSwap<
     /**
      * @inheritDoc
      */
-    abstract txsClaim(signer?: T["Signer"]): Promise<T["TX"][]>;
+    abstract txsClaim(signer?: string | T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
 
     /**
      * @inheritDoc

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

@@ -282,8 +282,8 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
      * @inheritDoc
      * @internal
      */
-    protected canCommit(): boolean {
-        return this._state===FromBTCLNSwapState.PR_PAID;
+    protected canCommit(skipQuoteExpiryChecks?: boolean): boolean {
+        return this._state===FromBTCLNSwapState.PR_PAID || (!!skipQuoteExpiryChecks && this._state===FromBTCLNSwapState.QUOTE_SOFT_EXPIRED);
     }
 
     /**
@@ -899,7 +899,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
         );
 
         this._commitTxId = result[result.length-1];
-        if(this._state===FromBTCLNSwapState.PR_PAID || this._state===FromBTCLNSwapState.QUOTE_SOFT_EXPIRED) {
+        if(this._state===FromBTCLNSwapState.PR_PAID || this._state===FromBTCLNSwapState.QUOTE_SOFT_EXPIRED || this._state===FromBTCLNSwapState.QUOTE_EXPIRED) {
             await this._saveAndEmit(FromBTCLNSwapState.CLAIM_COMMITED);
         }
         return this._commitTxId;
@@ -953,7 +953,18 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
      *
      * @internal
      */
-    private async _txsClaim(_signer?: T["Signer"] | T["NativeSigner"], secret?: string): Promise<T["TX"][]> {
+    private async _txsClaim(_signer?: string | T["Signer"] | T["NativeSigner"], secret?: string): Promise<T["TX"][]> {
+        let address: string | undefined = undefined;
+        if(_signer!=null) {
+            if (typeof (_signer) === "string") {
+                address = _signer;
+            } else if (isAbstractSigner(_signer)) {
+                address = _signer.getAddress();
+            } else {
+                address = (await this.wrapper._chain.wrapSigner(_signer)).getAddress();
+            }
+        }
+
         if(this._data==null) throw new Error("Unknown data, wrong state?");
         const useSecret = secret ?? this.secret;
         if(useSecret==null)
@@ -962,9 +973,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
             throw new Error("Invalid swap secret pre-image provided!");
 
         return this.wrapper._contract.txsClaimWithSecret(
-            _signer==null ?
-                this._getInitiator() :
-                (isAbstractSigner(_signer) ? _signer : await this.wrapper._chain.wrapSigner(_signer)),
+            address ?? this._getInitiator(),
             this._data, useSecret, true, true
         );
     }
@@ -978,7 +987,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
      *
      * @throws {Error} If in invalid state (must be {@link FromBTCLNSwapState.CLAIM_COMMITED})
      */
-    async txsClaim(_signer?: T["Signer"] | T["NativeSigner"], secret?: string): Promise<T["TX"][]> {
+    async txsClaim(_signer?: string | T["Signer"] | T["NativeSigner"], secret?: string): Promise<T["TX"][]> {
         if(this._state!==FromBTCLNSwapState.CLAIM_COMMITED) throw new Error("Must be in CLAIM_COMMITED state!");
         return this._txsClaim(_signer, secret);
     }

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

@@ -4,7 +4,7 @@ import {
     ChainSwapType,
     ChainType,
     ClaimEvent,
-    InitializeEvent, LightningNetworkApi,
+    InitializeEvent, LightningNetworkApi, LNNodeLiquidity,
     RefundEvent, SwapCommitState, SwapCommitStateType
 } from "@atomiqlabs/base";
 import {Intermediary} from "../../../../intermediaries/Intermediary";
@@ -137,6 +137,7 @@ export class FromBTCLNWrapper<
         super(
             chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer, lnApi,
             {
+                ...options,
                 safetyFactor: options?.safetyFactor ?? 2,
                 bitcoinBlocktime: options?.bitcoinBlocktime ?? 10*60,
                 unsafeSkipLnNodeCheck: options?.unsafeSkipLnNodeCheck ?? false
@@ -317,8 +318,13 @@ export class FromBTCLNWrapper<
                             this._options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined
                         );
 
+                        let lnCapacityPromise: Promise<LNNodeLiquidity | null> | undefined;
+                        if(!_options.unsafeSkipLnNodeCheck) {
+                            lnCapacityPromise = this.preFetchLnCapacity(lnPublicKey);
+                        } else lnPublicKey.catch(() => {});
+
                         return {
-                            lnCapacityPromise: _options.unsafeSkipLnNodeCheck ? null : this.preFetchLnCapacity(lnPublicKey),
+                            lnCapacityPromise,
                             resp: await response
                         };
                     }, undefined, RequestError, abortController.signal);
@@ -356,7 +362,6 @@ export class FromBTCLNWrapper<
                             secret: secret?.toString("hex"),
                             exactIn: amountData.exactIn ?? true
                         } as FromBTCLNSwapInit<T["Data"]>);
-                        await quote._save();
                         return quote;
                     } catch (e) {
                         abortController.abort(e);