@atomiqlabs/sdk 8.6.0 → 8.6.2

package/dist/storage/UnifiedSwapStorage.js

@@ -64,6 +64,7 @@ class UnifiedSwapStorage {
             const value = reviver(rawObj);
             if (value == null)
                 return;
+            value._persisted = true;
             if (!this.noWeakRefMap)
                 this.weakRefCache.set(rawObj.id, new WeakRef(value));
             result.push(value);
@@ -75,37 +76,41 @@ class UnifiedSwapStorage {
      *
      * @param value Swap to save
      */
-    save(value) {
+    async save(value) {
         if (!this.noWeakRefMap)
             this.weakRefCache.set(value.getId(), new WeakRef(value));
-        return this.storage.save(value.serialize());
+        await this.storage.save(value.serialize());
+        value._persisted = true;
     }
     /**
      * Saves multiple swaps to storage in a batch operation
      * @param values Array of swaps to save
      */
-    saveAll(values) {
+    async saveAll(values) {
         if (!this.noWeakRefMap)
             values.forEach(value => this.weakRefCache.set(value.getId(), new WeakRef(value)));
-        return this.storage.saveAll(values.map(obj => obj.serialize()));
+        await this.storage.saveAll(values.map(obj => obj.serialize()));
+        values.forEach(value => value._persisted = true);
     }
     /**
      * Removes a swap from storage
      * @param value Swap to remove
      */
-    remove(value) {
+    async remove(value) {
         if (!this.noWeakRefMap)
             this.weakRefCache.delete(value.getId());
-        return this.storage.remove(value.serialize());
+        await this.storage.remove(value.serialize());
+        value._persisted = false;
     }
     /**
      * Removes multiple swaps from storage in a batch operation
      * @param values Array of swaps to remove
      */
-    removeAll(values) {
+    async removeAll(values) {
         if (!this.noWeakRefMap)
             values.forEach(value => this.weakRefCache.delete(value.getId()));
-        return this.storage.removeAll(values.map(obj => obj.serialize()));
+        await this.storage.removeAll(values.map(obj => obj.serialize()));
+        values.forEach(value => value._persisted = false);
     }
 }
 exports.UnifiedSwapStorage = UnifiedSwapStorage;

package/dist/swapper/Swapper.d.ts

@@ -174,17 +174,6 @@ type MultiChainData<T extends MultiChain> = {
 type CtorMultiChainData<T extends MultiChain> = {
     [chainIdentifier in keyof T]: ChainData<T[chainIdentifier]>;
 };
-type SwapperCtorTokens<T extends MultiChain = MultiChain> = {
-    ticker: string;
-    name: string;
-    chains: {
-        [chainId in ChainIds<T>]?: {
-            address: string;
-            decimals: number;
-            displayDecimals?: number;
-        };
-    };
-}[];
 /**
  * Type extracting chain identifiers from a MultiChain type
  * @category Core
@@ -263,7 +252,7 @@ export declare class Swapper<T extends MultiChain> extends EventEmitter<{
     /**
      * @internal
      */
-    constructor(bitcoinRpc: BitcoinRpcWithAddressIndex<any>, lightningApi: LightningNetworkApi, bitcoinSynchronizer: (btcRelay: BtcRelay<any, any, any>) => RelaySynchronizer<any, any, any>, chainsData: CtorMultiChainData<T>, pricing: ISwapPrice<T>, tokens: SwapperCtorTokens<T>, messenger: Messenger, options?: SwapperOptions);
+    constructor(bitcoinRpc: BitcoinRpcWithAddressIndex<any>, lightningApi: LightningNetworkApi, bitcoinSynchronizer: (btcRelay: BtcRelay<any, any, any>) => RelaySynchronizer<any, any, any>, chainsData: CtorMultiChainData<T>, pricing: ISwapPrice<T>, tokens: SCToken[], messenger: Messenger, options?: SwapperOptions);
     private _init;
     private initPromise?;
     private initialized;

package/dist/swapper/Swapper.js

@@ -82,22 +82,10 @@ class Swapper extends events_1.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) => 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) => {
             this.emit("swapState", swap);
@@ -112,35 +100,42 @@ class Swapper extends events_1.EventEmitter {
             wrappers[SwapType_1.SwapType.TO_BTCLN] = new ToBTCLNWrapper_1.ToBTCLNWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
+                saveUninitializedSwaps: this.options.saveUninitializedSwaps,
             });
             wrappers[SwapType_1.SwapType.TO_BTC] = new ToBTCWrapper_1.ToBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, this._bitcoinRpc, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
+                saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                 bitcoinNetwork: this._btcNetwork
             });
             wrappers[SwapType_1.SwapType.FROM_BTCLN] = new FromBTCLNWrapper_1.FromBTCLNWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, lightningApi, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
+                saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                 unsafeSkipLnNodeCheck: this.bitcoinNetwork === base_1.BitcoinNetwork.TESTNET4 || this.bitcoinNetwork === base_1.BitcoinNetwork.REGTEST
             });
             wrappers[SwapType_1.SwapType.FROM_BTC] = new FromBTCWrapper_1.FromBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, btcRelay, synchronizer, this._bitcoinRpc, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
+                saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                 bitcoinNetwork: this._btcNetwork
             });
             wrappers[SwapType_1.SwapType.TRUSTED_FROM_BTCLN] = new LnForGasWrapper_1.LnForGasWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, pricing, this._tokens[chainId], {
                 getRequestTimeout: this.options.getRequestTimeout,
-                postRequestTimeout: this.options.postRequestTimeout
+                postRequestTimeout: this.options.postRequestTimeout,
+                saveUninitializedSwaps: this.options.saveUninitializedSwaps,
             });
             wrappers[SwapType_1.SwapType.TRUSTED_FROM_BTC] = new OnchainForGasWrapper_1.OnchainForGasWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, pricing, this._tokens[chainId], bitcoinRpc, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
+                saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                 bitcoinNetwork: this._btcNetwork
             });
             if (spvVaultContract != null) {
                 wrappers[SwapType_1.SwapType.SPV_VAULT_FROM_BTC] = new SpvFromBTCWrapper_1.SpvFromBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, spvVaultContract, pricing, this._tokens[chainId], spvVaultWithdrawalDataConstructor, btcRelay, synchronizer, bitcoinRpc, {
                     getRequestTimeout: this.options.getRequestTimeout,
                     postRequestTimeout: this.options.postRequestTimeout,
+                    saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                     bitcoinNetwork: this._btcNetwork
                 });
             }
@@ -148,6 +143,7 @@ class Swapper extends events_1.EventEmitter {
                 wrappers[SwapType_1.SwapType.FROM_BTCLN_AUTO] = new FromBTCLNAutoWrapper_1.FromBTCLNAutoWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, lightningApi, this.messenger, {
                     getRequestTimeout: this.options.getRequestTimeout,
                     postRequestTimeout: this.options.postRequestTimeout,
+                    saveUninitializedSwaps: this.options.saveUninitializedSwaps,
                     unsafeSkipLnNodeCheck: this.bitcoinNetwork === base_1.BitcoinNetwork.TESTNET4 || this.bitcoinNetwork === base_1.BitcoinNetwork.REGTEST
                 });
             }
@@ -268,8 +264,10 @@ class Swapper extends events_1.EventEmitter {
     async init() {
         if (this.initialized)
             return;
-        if (this.initPromise != null)
+        if (this.initPromise != null) {
             await this.initPromise;
+            return;
+        }
         try {
             const promise = this._init();
             this.initPromise = promise;
@@ -446,10 +444,7 @@ class Swapper extends events_1.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) {
@@ -732,7 +727,7 @@ class Swapper extends events_1.EventEmitter {
      * @param trustedIntermediaryOrUrl  URL or Intermediary object of the trusted intermediary to use, otherwise uses default
      * @throws {Error} If no trusted intermediary specified
      */
-    createTrustedLNForGasSwap(chainIdentifier, recipient, amount, trustedIntermediaryOrUrl) {
+    async createTrustedLNForGasSwap(chainIdentifier, recipient, amount, trustedIntermediaryOrUrl) {
         if (this._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
         if (!this._chains[chainIdentifier].chainInterface.isValidAddress(recipient, true))
@@ -741,7 +736,9 @@ class Swapper extends events_1.EventEmitter {
         const useUrl = trustedIntermediaryOrUrl ?? this.defaultTrustedIntermediary ?? this.options.defaultTrustedIntermediaryUrl;
         if (useUrl == null)
             throw new Error("No trusted intermediary specified!");
-        return this._chains[chainIdentifier].wrappers[SwapType_1.SwapType.TRUSTED_FROM_BTCLN].create(recipient, amount, useUrl);
+        const swap = await this._chains[chainIdentifier].wrappers[SwapType_1.SwapType.TRUSTED_FROM_BTCLN].create(recipient, amount, useUrl);
+        await swap._save();
+        return swap;
     }
     /**
      * Creates a trusted Bitcoin -> Smart chain ({@link SwapType.TRUSTED_FROM_BTC}) gas swap
@@ -753,7 +750,7 @@ class Swapper extends events_1.EventEmitter {
      * @param trustedIntermediaryOrUrl URL or Intermediary object of the trusted intermediary to use, otherwise uses default
      * @throws {Error} If no trusted intermediary specified
      */
-    createTrustedOnchainForGasSwap(chainIdentifier, recipient, amount, refundAddress, trustedIntermediaryOrUrl) {
+    async createTrustedOnchainForGasSwap(chainIdentifier, recipient, amount, refundAddress, trustedIntermediaryOrUrl) {
         if (this._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
         if (!this._chains[chainIdentifier].chainInterface.isValidAddress(recipient, true))
@@ -762,7 +759,9 @@ class Swapper extends events_1.EventEmitter {
         const useUrl = trustedIntermediaryOrUrl ?? this.defaultTrustedIntermediary ?? this.options.defaultTrustedIntermediaryUrl;
         if (useUrl == null)
             throw new Error("No trusted intermediary specified!");
-        return this._chains[chainIdentifier].wrappers[SwapType_1.SwapType.TRUSTED_FROM_BTC].create(recipient, amount, useUrl, refundAddress);
+        const swap = await this._chains[chainIdentifier].wrappers[SwapType_1.SwapType.TRUSTED_FROM_BTC].create(recipient, amount, useUrl, refundAddress);
+        await swap._save();
+        return swap;
     }
     /**
      * Creates a swap from srcToken to dstToken, of a specific token amount, either specifying input amount (exactIn=true)

package/dist/swapper/SwapperFactory.d.ts

@@ -113,6 +113,7 @@ export declare class SwapperFactory<T extends readonly ChainInitializer<any, Cha
      * Token resolvers for various smart chains supported by the SDK, allow fetching tokens based on their addresses
      */
     TokenResolver: TypedTokenResolvers<T>;
+    private smartChainTokens;
     constructor(initializers: T);
     /**
      * Returns a new swapper instance with the passed options.

package/dist/swapper/SwapperFactory.js

@@ -64,21 +64,26 @@ class SwapperFactory {
          * Token resolvers for various smart chains supported by the SDK, allow fetching tokens based on their addresses
          */
         this.TokenResolver = {};
+        this.smartChainTokens = [];
         this.initializers = initializers;
         initializers.forEach(initializer => {
             const addressMap = {};
             const tokens = (this.Tokens[initializer.chainId] = {});
             for (let ticker in initializer.tokens) {
                 const assetData = initializer.tokens[ticker];
-                tokens[ticker] = addressMap[assetData.address] = {
+                const token = {
                     chain: "SC",
                     chainId: initializer.chainId,
-                    address: assetData.address,
+                    ticker,
                     name: SmartChainAssets_1.SmartChainAssets[ticker]?.name ?? ticker,
                     decimals: assetData.decimals,
                     displayDecimals: assetData.displayDecimals,
-                    ticker
+                    address: assetData.address,
+                    equals: (other) => 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] = {
                 getToken: (address) => addressMap[address]
@@ -140,7 +145,7 @@ class SwapperFactory {
                 };
             }), options.getPriceFn)) :
             RedundantSwapPrice_1.RedundantSwapPrice.createFromTokenMap(options.pricingFeeDifferencePPM ?? 10000n, pricingAssets);
-        return new Swapper_1.Swapper(bitcoinRpc, bitcoinRpc, (btcRelay) => new btc_mempool_1.MempoolBtcRelaySynchronizer(btcRelay, bitcoinRpc), chains, swapPricing, pricingAssets, options.messenger, options);
+        return new Swapper_1.Swapper(bitcoinRpc, bitcoinRpc, (btcRelay) => new btc_mempool_1.MempoolBtcRelaySynchronizer(btcRelay, bitcoinRpc), chains, swapPricing, this.smartChainTokens, options.messenger, options);
     }
     /**
      * Returns a new and already initialized swapper instance with the passed options. There is no need

package/dist/swaps/ISwap.d.ts

@@ -111,6 +111,14 @@ export declare abstract class ISwap<T extends ChainType = ChainType, D extends S
      * @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;
     /**
      * Event emitter emitting `"swapState"` event when swap's state changes
      */

package/dist/swaps/ISwap.js

@@ -49,6 +49,14 @@ class ISwap {
          * @internal
          */
         this._state = 0;
+        /**
+         * 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
+         */
+        this._persisted = false;
         /**
          * Event emitter emitting `"swapState"` event when swap's state changes
          */

package/dist/swaps/ISwapWrapper.d.ts

@@ -9,6 +9,8 @@ import { SwapType } from "../enums/SwapType";
 import { UnifiedSwapStorage } from "../storage/UnifiedSwapStorage";
 import { SCToken } from "../types/Token";
 import { PriceInfoType } from "../types/PriceInfoType";
+export declare const DEFAULT_MAX_PARALLEL_SWAP_TICKS = 50;
+export declare const DEFAULT_MAX_PARALLEL_SWAP_SYNCS = 50;
 /**
  * Options for swap wrapper configuration
  *
@@ -17,6 +19,18 @@ import { PriceInfoType } from "../types/PriceInfoType";
 export type ISwapWrapperOptions = {
     getRequestTimeout?: 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;
 };
 /**
  * Token configuration for wrapper constructors
@@ -86,6 +100,11 @@ export declare abstract class ISwapWrapper<T extends ChainType, D extends SwapTy
      * @internal
      */
     protected tickInterval?: NodeJS.Timeout;
+    /**
+     * An internal abort controller for the running tick handler
+     * @internal
+     */
+    protected tickAbortController?: AbortController;
     /**
      * States of the swaps in pending (non-final state), these are checked automatically on initial swap synchronization
      * @internal
@@ -215,6 +234,8 @@ export declare abstract class ISwapWrapper<T extends ChainType, D extends SwapTy
     /**
      * 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
@@ -228,8 +249,9 @@ export declare abstract class ISwapWrapper<T extends ChainType, D extends SwapTy
      *
      * @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
      */
-    tick(swaps?: D["Swap"][]): Promise<void>;
+    tick(swaps?: D["Swap"][], abortSignal?: AbortSignal): Promise<void>;
     /**
      * Returns the smart chain's native token used to pay for fees
      * @internal

package/dist/swaps/ISwapWrapper.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ISwapWrapper = void 0;
+exports.ISwapWrapper = exports.DEFAULT_MAX_PARALLEL_SWAP_SYNCS = exports.DEFAULT_MAX_PARALLEL_SWAP_TICKS = void 0;
 const events_1 = require("events");
 const IntermediaryError_1 = require("../errors/IntermediaryError");
 const Logger_1 = require("../utils/Logger");
 const TokenUtils_1 = require("../utils/TokenUtils");
 const UserError_1 = require("../errors/UserError");
+exports.DEFAULT_MAX_PARALLEL_SWAP_TICKS = 50;
+exports.DEFAULT_MAX_PARALLEL_SWAP_SYNCS = 50;
 /**
  * Base abstract class for swap handler implementations
  *
@@ -29,6 +31,10 @@ class ISwapWrapper {
          * @internal
          */
         this.isInitialized = false;
+        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;
         this.chainIdentifier = chainIdentifier;
@@ -128,9 +134,25 @@ class ISwapWrapper {
     startTickInterval() {
         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;
+        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();
     }
     /**
      * Runs checks on passed swaps, syncing their state from on-chain data
@@ -186,10 +208,10 @@ 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;
     }
     /**
      * Un-subscribes from event listeners on the smart chain, terminates the tick interval and stops this wrapper
@@ -198,12 +220,20 @@ 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
@@ -211,16 +241,23 @@ class ISwapWrapper {
     async checkPastSwaps(pastSwaps, noSave) {
         if (pastSwaps == null)
             pastSwaps = await this.unifiedStorage.query([[{ key: "type", value: this.TYPE }, { key: "state", value: this._pendingSwapStates }]], (val) => 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 ?? exports.DEFAULT_MAX_PARALLEL_SWAP_SYNCS;
+        const totalRemoveSwaps = [];
+        const totalChangedSwaps = [];
+        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
         };
     }
     /**
@@ -228,18 +265,39 @@ 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
      */
-    async tick(swaps) {
+    async tick(swaps, abortSignal) {
         if (swaps == null)
             swaps = await this.unifiedStorage.query([[{ key: "type", value: this.TYPE }, { key: "state", value: this.tickSwapState }]], (val) => new this._swapDeserializer(this, val));
+        abortSignal?.throwIfAborted();
+        const parallelTicks = this._options.maxParallelSwapTicks ?? exports.DEFAULT_MAX_PARALLEL_SWAP_TICKS;
+        let promises = [];
         for (let pendingSwap of this.pendingSwaps.values()) {
             const value = pendingSwap.deref();
             if (value != null)
-                value._tick(true);
+                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();
     }
     /**
      * Returns the smart chain's native token used to pay for fees
@@ -256,13 +314,15 @@ class ISwapWrapper {
      * @internal
      */
     _saveSwapData(swap) {
-        if (!swap.isInitiated()) {
-            this.logger.debug("saveSwapData(): Swap " + swap.getId() + " not initiated, saving to pending swaps");
-            this.pendingSwaps.set(swap.getId(), new WeakRef(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(swap));
+                return Promise.resolve();
+            }
+            else {
+                this.pendingSwaps.delete(swap.getId());
+            }
         }
         return this.unifiedStorage.save(swap);
     }
@@ -275,7 +335,7 @@ class ISwapWrapper {
      */
     _removeSwapData(swap) {
         this.pendingSwaps.delete(swap.getId());
-        if (!swap.isInitiated())
+        if (!swap._persisted)
             return Promise.resolve();
         return this.unifiedStorage.remove(swap);
     }

package/dist/swaps/escrow_swaps/IEscrowSwapWrapper.js

@@ -23,8 +23,11 @@ class IEscrowSwapWrapper extends ISwapWrapper_1.ISwapWrapper {
      * @internal
      */
     preFetchSignData(signDataPrefetch) {
-        if (this._contract.preFetchForInitSignatureVerification == null)
+        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;

package/dist/swaps/escrow_swaps/frombtc/IFromBTCSelfInitSwap.d.ts

@@ -42,7 +42,7 @@ export declare abstract class IFromBTCSelfInitSwap<T extends ChainType = ChainTy
      * Returns if the swap can be committed
      * @internal
      */
-    protected abstract canCommit(): boolean;
+    protected abstract canCommit(skipQuoteExpiryChecks?: boolean): boolean;
     /**
      * @inheritDoc
      * @internal
@@ -150,7 +150,7 @@ export declare abstract class IFromBTCSelfInitSwap<T extends ChainType = ChainTy
     /**
      * @inheritDoc
      */
-    abstract txsClaim(signer?: T["Signer"]): Promise<T["TX"][]>;
+    abstract txsClaim(signer?: string | T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
     /**
      * @inheritDoc
      */

package/dist/swaps/escrow_swaps/frombtc/IFromBTCSelfInitSwap.js

@@ -166,7 +166,7 @@ class IFromBTCSelfInitSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
      * @throws {Error} When in invalid state to commit the swap
      */
     async txsCommit(skipChecks) {
-        if (!this.canCommit())
+        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?");

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

@@ -152,7 +152,7 @@ export declare class FromBTCLNSwap<T extends ChainType = ChainType> extends IFro
      * @inheritDoc
      * @internal
      */
-    protected canCommit(): boolean;
+    protected canCommit(skipQuoteExpiryChecks?: boolean): boolean;
     /**
      * @inheritDoc
      */
@@ -400,7 +400,7 @@ export declare class FromBTCLNSwap<T extends ChainType = ChainType> extends IFro
      *
      * @throws {Error} If in invalid state (must be {@link FromBTCLNSwapState.CLAIM_COMMITED})
      */
-    txsClaim(_signer?: T["Signer"] | T["NativeSigner"], secret?: string): Promise<T["TX"][]>;
+    txsClaim(_signer?: string | T["Signer"] | T["NativeSigner"], secret?: string): Promise<T["TX"][]>;
     /**
      * @inheritDoc
      *