@atomiqlabs/sdk 8.6.0 → 8.6.3

package/dist/http/paramcoders/ParamDecoder.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParamDecoder = void 0;
 const buffer_1 = require("buffer");
+function ensureBuffer(input) {
+    if (input instanceof buffer_1.Buffer)
+        return input;
+    return buffer_1.Buffer.from(input);
+}
 class ParamDecoder {
     constructor() {
         this.frameData = [];
@@ -48,8 +53,8 @@ class ParamDecoder {
                     leavesBuffer = null;
                 }
                 else {
-                    this.frameHeader = leavesBuffer.subarray(0, 4);
-                    leavesBuffer = leavesBuffer.subarray(4);
+                    this.frameHeader = ensureBuffer(leavesBuffer.subarray(0, 4));
+                    leavesBuffer = ensureBuffer(leavesBuffer.subarray(4));
                 }
             }
             else if (this.frameHeader.length < 4) {
@@ -60,14 +65,14 @@ class ParamDecoder {
                 }
                 else {
                     this.frameHeader = buffer_1.Buffer.concat([this.frameHeader, leavesBuffer.subarray(0, requiredLen)]);
-                    leavesBuffer = leavesBuffer.subarray(requiredLen);
+                    leavesBuffer = ensureBuffer(leavesBuffer.subarray(requiredLen));
                 }
             }
             if (leavesBuffer == null)
                 continue;
             if (this.frameHeader == null || this.frameHeader.length < 4)
                 continue;
-            const frameLength = this.frameHeader.readUint32LE();
+            const frameLength = this.frameHeader.readUint32LE != null ? this.frameHeader.readUint32LE() : this.frameHeader.readUInt32LE();
             const requiredLen = frameLength - this.frameDataLength;
             if (leavesBuffer.length <= requiredLen) {
                 this.frameData.push(leavesBuffer);

package/dist/http/paramcoders/ParamEncoder.js

@@ -15,7 +15,12 @@ class ParamEncoder {
     writeParams(data) {
         const serialized = buffer_1.Buffer.from(JSON.stringify(data));
         const frameLengthBuffer = buffer_1.Buffer.alloc(4);
-        frameLengthBuffer.writeUint32LE(serialized.length);
+        if (frameLengthBuffer.writeUint32LE != null) {
+            frameLengthBuffer.writeUint32LE(serialized.length);
+        }
+        else {
+            frameLengthBuffer.writeUInt32LE(serialized.length);
+        }
         return this.writeFN(buffer_1.Buffer.concat([
             frameLengthBuffer,
             serialized

package/dist/intermediaries/IntermediaryDiscovery.js

@@ -129,7 +129,7 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
      * @param abortSignal
      */
     async getNodeInfo(url, abortSignal) {
-        const response = await (0, RetryUtils_1.tryWithRetries)(() => IntermediaryAPI_1.IntermediaryAPI.getIntermediaryInfo(url, this.httpRequestTimeout, abortSignal), { maxRetries: 3, delay: 100, exponential: true }, undefined, abortSignal);
+        const response = await (0, RetryUtils_1.tryWithRetries)(() => IntermediaryAPI_1.IntermediaryAPI.getIntermediaryInfo(url, this.httpRequestTimeout, abortSignal), { maxRetries: 3, delay: 100, exponential: true }, undefined, abortSignal, "debug");
         abortSignal?.throwIfAborted();
         const promises = [];
         const addresses = {};
@@ -142,7 +142,7 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
                         addresses[chain] = address;
                     }
                     catch (e) {
-                        logger.warn("Failed to verify " + chain + " signature for intermediary: " + url);
+                        logger.warn("getNodeInfo(): Failed to verify " + chain + " signature for intermediary: " + url);
                     }
                 })());
             }
@@ -191,7 +191,8 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
             return new Intermediary_1.Intermediary(url, nodeInfo.addresses, services);
         }
         catch (e) {
-            logger.warn("fetchIntermediaries(): Error contacting intermediary " + url + ": ", e);
+            logger.warn("fetchIntermediaries(): Intermediary " + url + ` is unreachable due to ${e.name ?? e.message} error, skipping...`);
+            logger.debug("fetchIntermediaries(): Error contacting intermediary " + url + ": ", e);
             return null;
         }
     }

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
                 });
             }
@@ -186,7 +182,7 @@ class Swapper extends events_1.EventEmitter {
         });
     }
     async _init() {
-        this.logger.debug("init(): Initializing swapper, sdk-lib version 16.1.3");
+        this.logger.debug("init(): Initializing swapper...");
         const abortController = new AbortController();
         const promises = [];
         let automaticClockDriftCorrectionPromise = undefined;
@@ -222,7 +218,11 @@ class Swapper extends events_1.EventEmitter {
         const chainPromises = [];
         for (let chainIdentifier in this._chains) {
             chainPromises.push((async () => {
-                const { swapContract, unifiedChainEvents, unifiedSwapStorage, wrappers, reviver } = this._chains[chainIdentifier];
+                const { chainInterface, swapContract, unifiedChainEvents, unifiedSwapStorage, wrappers, reviver } = this._chains[chainIdentifier];
+                const _chainInterface = chainInterface;
+                if (_chainInterface.verifyNetwork != null) {
+                    await _chainInterface.verifyNetwork(this.bitcoinNetwork);
+                }
                 await swapContract.start();
                 this.logger.debug("init(): Intialized swap contract: " + chainIdentifier);
                 await unifiedSwapStorage.init();
@@ -268,8 +268,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 +448,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 +731,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 +740,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 +754,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 +763,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