@atomiqlabs/sdk 8.1.8 → 8.3.5

package/dist/swaps/ISwapWrapper.d.ts

@@ -12,7 +12,8 @@ import { SCToken } from "../types/Token";
 import { PriceInfoType } from "../types/PriceInfoType";
 /**
  * Options for swap wrapper configuration
- * @category Swaps
+ *
+ * @category Swaps/Base
  */
 export type ISwapWrapperOptions = {
     getRequestTimeout?: number;
@@ -20,7 +21,8 @@ export type ISwapWrapperOptions = {
 };
 /**
  * Token configuration for wrapper constructors
- * @category Swaps
+ *
+ * @category Swaps/Base
  */
 export type WrapperCtorTokens<T extends MultiChain = MultiChain> = {
     ticker: string;
@@ -35,55 +37,111 @@ export type WrapperCtorTokens<T extends MultiChain = MultiChain> = {
 }[];
 /**
  * Type definition linking wrapper and swap types
- * @category Swaps
+ *
+ * @category Swaps/Base
  */
 export type SwapTypeDefinition<T extends ChainType, W extends ISwapWrapper<T, any>, S extends ISwap<T>> = {
     Wrapper: W;
     Swap: S;
 };
 /**
- * Base abstract class for swap wrapper implementations
- * @category Swaps
+ * Base abstract class for swap handler implementations
+ *
+ * @category Swaps/Base
  */
 export declare abstract class ISwapWrapper<T extends ChainType, D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, ISwap<T, D>>, O extends ISwapWrapperOptions = ISwapWrapperOptions> {
+    /**
+     * Swap type
+     */
     abstract readonly TYPE: SwapType;
+    /**
+     * Function for deserializing swaps
+     * @internal
+     */
+    abstract readonly _swapDeserializer: new (wrapper: D["Wrapper"], data: any) => D["Swap"];
+    /**
+     * Logger instance
+     * @internal
+     */
     protected readonly logger: import("../utils/Logger").LoggerType;
-    abstract readonly swapDeserializer: new (wrapper: D["Wrapper"], data: any) => D["Swap"];
-    readonly unifiedStorage: UnifiedSwapStorage<T>;
-    readonly unifiedChainEvents: UnifiedSwapEventListener<T>;
+    /**
+     * Persistent storage backend for the swaps
+     * @internal
+     */
+    protected readonly unifiedStorage: UnifiedSwapStorage<T>;
+    /**
+     * Smart chain events listener for listening to and parsing of on-chain events
+     * @internal
+     */
+    protected readonly unifiedChainEvents: UnifiedSwapEventListener<T>;
+    /**
+     * States of the swaps where {@link ISwap._tick} should be called every second
+     * @internal
+     */
+    protected readonly tickSwapState?: Array<D["Swap"]["_state"]>;
+    /**
+     * In-memory mapping of pending (not initiated) swaps, utilizing weak references to automatically
+     *  free memory when swaps are dereferenced in not initiated state
+     * @internal
+     */
+    protected readonly pendingSwaps: Map<string, WeakRef<D["Swap"]>>;
+    /**
+     * Whether this wrapper is initialized (have to call {@link init} to initialize a wrapper)
+     * @internal
+     */
+    protected isInitialized: boolean;
+    /**
+     * An interval for calling tick functions on the underlying swaps
+     * @internal
+     */
+    protected tickInterval?: NodeJS.Timeout;
+    /**
+     * States of the swaps in pending (non-final state), these are checked automatically on initial swap synchronization
+     * @internal
+     */
+    abstract readonly _pendingSwapStates: Array<D["Swap"]["_state"]>;
+    /**
+     * Chain interface of the underlying smart chain
+     * @internal
+     */
+    readonly _chain: T["ChainInterface"];
+    /**
+     * Pricing API
+     * @internal
+     */
+    readonly _prices: ISwapPrice;
+    /**
+     * Wrapper options
+     * @internal
+     */
+    readonly _options: O;
+    /**
+     * Tokens indexed by their token address
+     * @internal
+     */
+    readonly _tokens: {
+        [tokenAddress: string]: SCToken<T["ChainId"]>;
+    };
+    /**
+     * Chain identifier string of this wrapper
+     */
     readonly chainIdentifier: T["ChainId"];
-    readonly chain: T["ChainInterface"];
-    readonly prices: ISwapPrice;
+    /**
+     * Event emitter emitting `"swapState"` event when swap's state changes
+     */
     readonly events: EventEmitter<{
         swapState: [D["Swap"]];
     }>;
-    readonly options: O;
-    readonly tokens: {
-        [tokenAddress: string]: SCToken<T["ChainId"]>;
-    };
-    readonly pendingSwaps: Map<string, WeakRef<D["Swap"]>>;
-    isInitialized: boolean;
-    tickInterval?: NodeJS.Timeout;
-    /**
-     * @param chainIdentifier
-     * @param unifiedStorage
-     * @param unifiedChainEvents
-     * @param chain
-     * @param prices Swap pricing handler
-     * @param tokens Chain specific token data
-     * @param options
-     * @param events Instance to use for emitting events
-     */
     constructor(chainIdentifier: T["ChainId"], unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], prices: ISwapPrice, tokens: WrapperCtorTokens, options: O, events?: EventEmitter<{
         swapState: [ISwap];
     }>);
     /**
      * Pre-fetches swap price for a given swap
      *
-     * @param amountData
-     * @param abortSignal
-     * @protected
+     * @param amountData Amount data
+     * @param abortSignal Abort signal
      * @returns Price of the token in uSats (micro sats)
+     * @internal
      */
     protected preFetchPrice(amountData: {
         token: string;
@@ -91,25 +149,26 @@ export declare abstract class ISwapWrapper<T extends ChainType, D extends SwapTy
     /**
      * Pre-fetches bitcoin's USD price
      *
-     * @param abortSignal
-     * @protected
+     * @param abortSignal Abort signal
+     * @internal
      */
     protected preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number | undefined>;
     /**
-     * Verifies returned  price for swaps
+     * Verifies returned price for swaps
      *
      * @param lpServiceData Service data for the service in question (TO_BTCLN, TO_BTC, etc.) of the given intermediary
-     * @param send Whether this is a send (SOL -> SC) or receive (BTC -> SC) swap
+     * @param send Whether this is a send (Smart chain -> Bitcoin) or receive (Bitcoin -> Smart chain) swap
      * @param amountSats Amount in BTC
      * @param amountToken Amount in token
      * @param token Token used in the swap
      * @param feeData Fee data as returned by the intermediary
-     * @param pricePrefetchPromise Price pre-fetch promise
-     * @param usdPricePrefetchPromise
-     * @param abortSignal
-     * @protected
+     * @param pricePrefetchPromise Optional price pre-fetch promise
+     * @param usdPricePrefetchPromise Optiona USD price pre-fetch promise
+     * @param abortSignal Abort signal
      * @returns Price info object
      * @throws {IntermediaryError} if the calculated fee is too high
+     *
+     * @internal
      */
     protected verifyReturnedPrice(lpServiceData: {
         swapBaseFee: number;
@@ -117,37 +176,87 @@ export declare abstract class ISwapWrapper<T extends ChainType, D extends SwapTy
     }, send: boolean, amountSats: bigint, amountToken: bigint, token: string, feeData: {
         networkFee?: bigint;
     }, pricePrefetchPromise?: Promise<bigint | undefined>, usdPricePrefetchPromise?: Promise<number | undefined>, abortSignal?: AbortSignal): Promise<PriceInfoType>;
-    abstract readonly pendingSwapStates: Array<D["Swap"]["state"]>;
-    abstract readonly tickSwapState?: Array<D["Swap"]["state"]>;
     /**
-     * Processes a single SC on-chain event
-     * @private
-     * @param event
-     * @param swap
+     * Processes a single smart chain on-chain event
+     *
+     * @param event Smart chain event to process
+     * @param swap A swap related to the event
+     * @internal
      */
     protected abstract processEvent?(event: ChainEvent<T["Data"]>, swap: D["Swap"]): Promise<void>;
     /**
-     * Initializes the swap wrapper, needs to be called before any other action can be taken
+     * Starts the interval calling the {@link ISwap._tick} on all the known swaps in tick-enabled states
+     * @internal
      */
-    init(noTimers?: boolean, noCheckPastSwaps?: boolean): Promise<void>;
     protected startTickInterval(): void;
+    /**
+     * Runs checks on passed swaps, syncing their state from on-chain data
+     *
+     * @param pastSwaps Swaps to check
+     * @internal
+     */
     protected _checkPastSwaps(pastSwaps: D["Swap"][]): Promise<{
         changedSwaps: D["Swap"][];
         removeSwaps: D["Swap"][];
     }>;
+    /**
+     * Initializes the swap wrapper, needs to be called before any other action can be taken
+     *
+     * @param noTimers Whether to skip scheduling a tick timer for the swaps, if the tick timer is not initiated
+     *  the swap states depending on e.g. expiry can be out of sync with the actual expiration of the swap
+     * @param noCheckPastSwaps Whether to skip checking past swaps on initialization (by default all pending swaps
+     *  are re-checked on init, and their state is synchronized from the on-chain data)
+     */
+    init(noTimers?: boolean, noCheckPastSwaps?: boolean): Promise<void>;
+    /**
+     * Un-subscribes from event listeners on the smart chain, terminates the tick interval and stops this wrapper
+     */
+    stop(): Promise<void>;
+    /**
+     * Runs checks on all the known pending swaps, syncing their state from on-chain data
+     *
+     * @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
+     */
     checkPastSwaps(pastSwaps?: D["Swap"][], noSave?: boolean): Promise<{
         removeSwaps: D["Swap"][];
         changedSwaps: D["Swap"][];
     }>;
-    tick(swaps?: D["Swap"][]): Promise<void>;
-    saveSwapData(swap: D["Swap"]): Promise<void>;
-    removeSwapData(swap: D["Swap"]): Promise<void>;
     /**
-     * Un-subscribes from event listeners on Solana
+     * Invokes {@link ISwap._tick} on all the known swaps
+     *
+     * @param swaps Optional array of swaps to invoke `_tick()` on, otherwise all relevant swaps will be fetched
+     *  from the persistent storage
      */
-    stop(): Promise<void>;
+    tick(swaps?: D["Swap"][]): Promise<void>;
     /**
      * Returns the smart chain's native token used to pay for fees
+     * @internal
+     */
+    _getNativeToken(): SCToken<T["ChainId"]>;
+    /**
+     * Saves the swap, if it is not initiated it is only saved to pending swaps
+     *
+     * @param swap Swap to save
+     *
+     * @internal
+     */
+    _saveSwapData(swap: D["Swap"]): Promise<void>;
+    /**
+     * Removes the swap from the persistent storage and pending swaps
+     *
+     * @param swap Swap to remove
+     *
+     * @internal
+     */
+    _removeSwapData(swap: D["Swap"]): Promise<void>;
+    /**
+     * Retrieves a swap by its ID from the pending swap mapping
+     *
+     * @param id
+     *
+     * @internal
      */
-    getNativeToken(): SCToken<T["ChainId"]>;
+    _getPendingSwap(id: string): D["Swap"] | null;
 }

package/dist/swaps/ISwapWrapper.js

@@ -5,37 +5,41 @@ const events_1 = require("events");
 const IntermediaryError_1 = require("../errors/IntermediaryError");
 const Logger_1 = require("../utils/Logger");
 /**
- * Base abstract class for swap wrapper implementations
- * @category Swaps
+ * Base abstract class for swap handler implementations
+ *
+ * @category Swaps/Base
  */
 class ISwapWrapper {
-    /**
-     * @param chainIdentifier
-     * @param unifiedStorage
-     * @param unifiedChainEvents
-     * @param chain
-     * @param prices Swap pricing handler
-     * @param tokens Chain specific token data
-     * @param options
-     * @param events Instance to use for emitting events
-     */
     constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, events) {
+        /**
+         * Logger instance
+         * @internal
+         */
         this.logger = (0, Logger_1.getLogger)(this.constructor.name + ": ");
+        /**
+         * In-memory mapping of pending (not initiated) swaps, utilizing weak references to automatically
+         *  free memory when swaps are dereferenced in not initiated state
+         * @internal
+         */
         this.pendingSwaps = new Map();
+        /**
+         * Whether this wrapper is initialized (have to call {@link init} to initialize a wrapper)
+         * @internal
+         */
         this.isInitialized = false;
         this.unifiedStorage = unifiedStorage;
         this.unifiedChainEvents = unifiedChainEvents;
         this.chainIdentifier = chainIdentifier;
-        this.chain = chain;
-        this.prices = prices;
+        this._chain = chain;
+        this._prices = prices;
         this.events = events || new events_1.EventEmitter();
-        this.options = options;
-        this.tokens = {};
+        this._options = options;
+        this._tokens = {};
         for (let tokenData of tokens) {
             const chainData = tokenData.chains[chainIdentifier];
             if (chainData == null)
                 continue;
-            this.tokens[chainData.address] = {
+            this._tokens[chainData.address] = {
                 chain: "SC",
                 chainId: this.chainIdentifier,
                 address: chainData.address,
@@ -49,13 +53,13 @@ class ISwapWrapper {
     /**
      * Pre-fetches swap price for a given swap
      *
-     * @param amountData
-     * @param abortSignal
-     * @protected
+     * @param amountData Amount data
+     * @param abortSignal Abort signal
      * @returns Price of the token in uSats (micro sats)
+     * @internal
      */
     preFetchPrice(amountData, abortSignal) {
-        return this.prices.preFetchPrice(this.chainIdentifier, amountData.token, abortSignal).catch(e => {
+        return this._prices.preFetchPrice(this.chainIdentifier, amountData.token, abortSignal).catch(e => {
             this.logger.error("preFetchPrice.token(): Error: ", e);
             return undefined;
         });
@@ -63,30 +67,31 @@ class ISwapWrapper {
     /**
      * Pre-fetches bitcoin's USD price
      *
-     * @param abortSignal
-     * @protected
+     * @param abortSignal Abort signal
+     * @internal
      */
     preFetchUsdPrice(abortSignal) {
-        return this.prices.preFetchUsdPrice(abortSignal).catch(e => {
+        return this._prices.preFetchUsdPrice(abortSignal).catch(e => {
             this.logger.error("preFetchPrice.usd(): Error: ", e);
             return undefined;
         });
     }
     /**
-     * Verifies returned  price for swaps
+     * Verifies returned price for swaps
      *
      * @param lpServiceData Service data for the service in question (TO_BTCLN, TO_BTC, etc.) of the given intermediary
-     * @param send Whether this is a send (SOL -> SC) or receive (BTC -> SC) swap
+     * @param send Whether this is a send (Smart chain -> Bitcoin) or receive (Bitcoin -> Smart chain) swap
      * @param amountSats Amount in BTC
      * @param amountToken Amount in token
      * @param token Token used in the swap
      * @param feeData Fee data as returned by the intermediary
-     * @param pricePrefetchPromise Price pre-fetch promise
-     * @param usdPricePrefetchPromise
-     * @param abortSignal
-     * @protected
+     * @param pricePrefetchPromise Optional price pre-fetch promise
+     * @param usdPricePrefetchPromise Optiona USD price pre-fetch promise
+     * @param abortSignal Abort signal
      * @returns Price info object
      * @throws {IntermediaryError} if the calculated fee is too high
+     *
+     * @internal
      */
     async verifyReturnedPrice(lpServiceData, send, amountSats, amountToken, token, feeData, pricePrefetchPromise = Promise.resolve(undefined), usdPricePrefetchPromise = Promise.resolve(undefined), abortSignal) {
         const swapBaseFee = BigInt(lpServiceData.swapBaseFee);
@@ -95,12 +100,12 @@ class ISwapWrapper {
             amountToken = amountToken - feeData.networkFee;
         const [isValidAmount, usdPrice] = await Promise.all([
             send ?
-                this.prices.isValidAmountSend(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise) :
-                this.prices.isValidAmountReceive(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise),
+                this._prices.isValidAmountSend(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise) :
+                this._prices.isValidAmountReceive(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise),
             usdPricePrefetchPromise.then(value => {
                 if (value != null)
                     return value;
-                return this.prices.preFetchUsdPrice(abortSignal);
+                return this._prices.preFetchUsdPrice(abortSignal);
             })
         ]);
         if (!isValidAmount.isValid)
@@ -108,8 +113,45 @@ class ISwapWrapper {
         isValidAmount.realPriceUsdPerBitcoin = usdPrice;
         return isValidAmount;
     }
+    /**
+     * Starts the interval calling the {@link ISwap._tick} on all the known swaps in tick-enabled states
+     * @internal
+     */
+    startTickInterval() {
+        if (this.tickSwapState == null || this.tickSwapState.length === 0)
+            return;
+        this.tickInterval = setInterval(() => {
+            this.tick();
+        }, 1000);
+    }
+    /**
+     * Runs checks on passed swaps, syncing their state from on-chain data
+     *
+     * @param pastSwaps Swaps to check
+     * @internal
+     */
+    async _checkPastSwaps(pastSwaps) {
+        const changedSwaps = [];
+        const removeSwaps = [];
+        await Promise.all(pastSwaps.map((swap) => swap._sync(false).then(changed => {
+            if (swap.isQuoteExpired()) {
+                removeSwaps.push(swap);
+                this.logger.debug("_checkPastSwaps(): Removing expired swap: " + swap.getId());
+            }
+            else {
+                if (changed)
+                    changedSwaps.push(swap);
+            }
+        }).catch(e => this.logger.error("_checkPastSwaps(): Error when checking swap " + swap.getId() + ": ", e))));
+        return { changedSwaps, removeSwaps };
+    }
     /**
      * Initializes the swap wrapper, needs to be called before any other action can be taken
+     *
+     * @param noTimers Whether to skip scheduling a tick timer for the swaps, if the tick timer is not initiated
+     *  the swap states depending on e.g. expiry can be out of sync with the actual expiration of the swap
+     * @param noCheckPastSwaps Whether to skip checking past swaps on initialization (by default all pending swaps
+     *  are re-checked on init, and their state is synchronized from the on-chain data)
      */
     async init(noTimers = false, noCheckPastSwaps = false) {
         if (this.isInitialized)
@@ -123,7 +165,7 @@ class ISwapWrapper {
                 return Promise.resolve();
             };
             if (this.processEvent != null)
-                this.unifiedChainEvents.registerListener(this.TYPE, initListener, this.swapDeserializer.bind(null, this));
+                this.unifiedChainEvents.registerListener(this.TYPE, initListener, this._swapDeserializer.bind(null, this));
             await this.checkPastSwaps();
             if (this.processEvent != null) {
                 //Process accumulated event queue
@@ -135,37 +177,32 @@ class ISwapWrapper {
             }
         }
         if (this.processEvent != null)
-            this.unifiedChainEvents.registerListener(this.TYPE, this.processEvent.bind(this), this.swapDeserializer.bind(null, this));
+            this.unifiedChainEvents.registerListener(this.TYPE, this.processEvent.bind(this), this._swapDeserializer.bind(null, this));
         if (!noTimers)
             this.startTickInterval();
         // this.logger.info("init(): Swap wrapper initialized");
         this.isInitialized = true;
     }
-    startTickInterval() {
-        if (this.tickSwapState == null || this.tickSwapState.length === 0)
-            return;
-        this.tickInterval = setInterval(() => {
-            this.tick();
-        }, 1000);
-    }
-    async _checkPastSwaps(pastSwaps) {
-        const changedSwaps = [];
-        const removeSwaps = [];
-        await Promise.all(pastSwaps.map((swap) => swap._sync(false).then(changed => {
-            if (swap.isQuoteExpired()) {
-                removeSwaps.push(swap);
-                this.logger.debug("_checkPastSwaps(): Removing expired swap: " + swap.getId());
-            }
-            else {
-                if (changed)
-                    changedSwaps.push(swap);
-            }
-        }).catch(e => this.logger.error("_checkPastSwaps(): Error when checking swap " + swap.getId() + ": ", e))));
-        return { changedSwaps, removeSwaps };
+    /**
+     * Un-subscribes from event listeners on the smart chain, terminates the tick interval and stops this wrapper
+     */
+    async stop() {
+        this.isInitialized = false;
+        this.unifiedChainEvents.unregisterListener(this.TYPE);
+        this.logger.info("stop(): Swap wrapper stopped");
+        if (this.tickInterval != null)
+            clearInterval(this.tickInterval);
     }
+    /**
+     * Runs checks on all the known pending swaps, syncing their state from on-chain data
+     *
+     * @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
+     */
     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));
+            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);
@@ -178,9 +215,15 @@ class ISwapWrapper {
             changedSwaps
         };
     }
+    /**
+     * Invokes {@link ISwap._tick} on all the known swaps
+     *
+     * @param swaps Optional array of swaps to invoke `_tick()` on, otherwise all relevant swaps will be fetched
+     *  from the persistent storage
+     */
     async tick(swaps) {
         if (swaps == null)
-            swaps = await this.unifiedStorage.query([[{ key: "type", value: this.TYPE }, { key: "state", value: this.tickSwapState }]], (val) => new this.swapDeserializer(this, val));
+            swaps = await this.unifiedStorage.query([[{ key: "type", value: this.TYPE }, { key: "state", value: this.tickSwapState }]], (val) => new this._swapDeserializer(this, val));
         for (let pendingSwap of this.pendingSwaps.values()) {
             const value = pendingSwap.deref();
             if (value != null)
@@ -190,7 +233,21 @@ class ISwapWrapper {
             value._tick(true);
         });
     }
-    saveSwapData(swap) {
+    /**
+     * Returns the smart chain's native token used to pay for fees
+     * @internal
+     */
+    _getNativeToken() {
+        return this._tokens[this._chain.getNativeCurrencyAddress()];
+    }
+    /**
+     * Saves the swap, if it is not initiated it is only saved to pending swaps
+     *
+     * @param swap Swap to save
+     *
+     * @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));
@@ -201,27 +258,28 @@ class ISwapWrapper {
         }
         return this.unifiedStorage.save(swap);
     }
-    removeSwapData(swap) {
+    /**
+     * Removes the swap from the persistent storage and pending swaps
+     *
+     * @param swap Swap to remove
+     *
+     * @internal
+     */
+    _removeSwapData(swap) {
         this.pendingSwaps.delete(swap.getId());
         if (!swap.isInitiated())
             return Promise.resolve();
         return this.unifiedStorage.remove(swap);
     }
     /**
-     * Un-subscribes from event listeners on Solana
-     */
-    async stop() {
-        this.isInitialized = false;
-        this.unifiedChainEvents.unregisterListener(this.TYPE);
-        this.logger.info("stop(): Swap wrapper stopped");
-        if (this.tickInterval != null)
-            clearInterval(this.tickInterval);
-    }
-    /**
-     * Returns the smart chain's native token used to pay for fees
+     * Retrieves a swap by its ID from the pending swap mapping
+     *
+     * @param id
+     *
+     * @internal
      */
-    getNativeToken() {
-        return this.tokens[this.chain.getNativeCurrencyAddress()];
+    _getPendingSwap(id) {
+        return this.pendingSwaps.get(id)?.deref() ?? null;
     }
 }
 exports.ISwapWrapper = ISwapWrapper;