@atomiqlabs/sdk 8.1.7 → 8.3.1

package/dist/prices/providers/CustomPriceProvider.js

@@ -4,18 +4,29 @@ exports.CustomPriceProvider = void 0;
 const IPriceProvider_1 = require("../abstract/IPriceProvider");
 /**
  * Price provider using custom pricing function
+ *
  * @category Pricing and LPs
  */
 class CustomPriceProvider extends IPriceProvider_1.IPriceProvider {
+    /**
+     * @param coinsMap Mapping of token tickers to token addresses
+     * @param getUsdPriceFn Pricing function, used to retrieve USD prices of the tokens
+     */
     constructor(coinsMap, getUsdPriceFn) {
         super(coinsMap);
         this.getUsdPriceFn = getUsdPriceFn;
     }
+    /**
+     * @inheritDoc
+     */
     async fetchPrice(token, abortSignal) {
         const [btcPrice, tokenPrice] = await this.getUsdPriceFn(["BTC", token.coinId], abortSignal);
         const priceInBtc = tokenPrice / btcPrice;
         return BigInt(Math.floor(priceInBtc * 100000000 * 1000000));
     }
+    /**
+     * @inheritDoc
+     */
     async fetchUsdPrice(abortSignal) {
         const [btcPrice] = await this.getUsdPriceFn(["BTC"], abortSignal);
         return btcPrice / 100000000;

package/dist/prices/providers/KrakenPriceProvider.d.ts

@@ -23,7 +23,16 @@ export type KrakenResponse = {
  */
 export declare class KrakenPriceProvider<T extends MultiChain> extends ExchangePriceProvider<T> {
     constructor(coinsMap: CtorCoinTypes<T>, url?: string, httpRequestTimeout?: number);
+    /**
+     * @inheritDoc
+     */
     protected fetchPair(pair: string, abortSignal?: AbortSignal): Promise<number>;
+    /**
+     * @inheritDoc
+     */
     protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+    /**
+     * @inheritDoc
+     */
     protected fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
 }

package/dist/prices/providers/KrakenPriceProvider.js

@@ -11,14 +11,23 @@ class KrakenPriceProvider extends ExchangePriceProvider_1.ExchangePriceProvider
     constructor(coinsMap, url = "https://api.kraken.com/0", httpRequestTimeout) {
         super(coinsMap, url, httpRequestTimeout);
     }
+    /**
+     * @inheritDoc
+     */
     async fetchPair(pair, abortSignal) {
         const response = await (0, HttpUtils_1.httpGet)(this.url + "/public/Ticker?pair=" + pair, this.httpRequestTimeout, abortSignal);
         return parseFloat(response.result[pair].c[0]);
     }
+    /**
+     * @inheritDoc
+     */
     async fetchUsdPrice(abortSignal) {
         const response = await (0, HttpUtils_1.httpGet)(this.url + "/public/Ticker?pair=XBTUSDC", this.httpRequestTimeout, abortSignal);
         return parseFloat(response.result["XBTUSDC"].c[0]) / 100000000;
     }
+    /**
+     * @inheritDoc
+     */
     async fetchPrice(token, abortSignal) {
         const pairs = token.coinId.split(";");
         const response = await (0, HttpUtils_1.httpGet)(this.url + "/public/Ticker?pair=" + pairs.map(val => val.startsWith("!") ? val.substring(1) : val).join(","), this.httpRequestTimeout, abortSignal);

package/dist/prices/providers/OKXPriceProvider.d.ts

@@ -23,6 +23,12 @@ export type OKXResponse = {
  */
 export declare class OKXPriceProvider<T extends MultiChain> extends ExchangePriceProvider<T> {
     constructor(coinsMap: CtorCoinTypes<T>, url?: string, httpRequestTimeout?: number);
+    /**
+     * @inheritDoc
+     */
     fetchPair(pair: string, abortSignal?: AbortSignal): Promise<number>;
+    /**
+     * @inheritDoc
+     */
     protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
 }

package/dist/prices/providers/OKXPriceProvider.js

@@ -11,10 +11,16 @@ class OKXPriceProvider extends ExchangePriceProvider_1.ExchangePriceProvider {
     constructor(coinsMap, url = "https://www.okx.com/api/v5", httpRequestTimeout) {
         super(coinsMap, url, httpRequestTimeout);
     }
+    /**
+     * @inheritDoc
+     */
     async fetchPair(pair, abortSignal) {
         const response = await (0, HttpUtils_1.httpGet)(this.url + "/market/index-tickers?instId=" + pair, this.httpRequestTimeout, abortSignal);
         return parseFloat(response.data[0].idxPx);
     }
+    /**
+     * @inheritDoc
+     */
     async fetchUsdPrice(abortSignal) {
         const response = await (0, HttpUtils_1.httpGet)(this.url + "/market/index-tickers?instId=BTC-USD", this.httpRequestTimeout, abortSignal);
         return parseFloat(response.data[0].idxPx) / 100000000;

package/dist/prices/providers/abstract/ExchangePriceProvider.d.ts

@@ -10,5 +10,8 @@ export declare abstract class ExchangePriceProvider<T extends MultiChain> extend
      * @protected
      */
     protected abstract fetchPair(pair: string, abortSignal?: AbortSignal): Promise<number>;
+    /**
+     * @inheritDoc
+     */
     protected fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
 }

package/dist/prices/providers/abstract/ExchangePriceProvider.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExchangePriceProvider = void 0;
 const HttpPriceProvider_1 = require("./HttpPriceProvider");
 class ExchangePriceProvider extends HttpPriceProvider_1.HttpPriceProvider {
+    /**
+     * @inheritDoc
+     */
     async fetchPrice(token, abortSignal) {
         const pairs = token.coinId.split(";");
         const prices = await Promise.all(pairs.map(pair => {

package/dist/storage/IUnifiedStorage.d.ts

@@ -1,13 +1,21 @@
 /**
- * Query parameters for storage operations
+ * Params for querying the storage
+ *
  * @category Storage
  */
 export type QueryParams = {
+    /**
+     * Key that should be matched
+     */
     key: string;
+    /**
+     * A value that the key needs to have, if an array is passed, the conditions are `OR`-ed
+     */
     value: any | any[];
 };
 /**
- * Base type for stored objects
+ * Base type for stored objects, every storage object MUST have an `id` field
+ *
  * @category Storage
  */
 export type UnifiedStoredObject = {
@@ -15,6 +23,7 @@ export type UnifiedStoredObject = {
 } & any;
 /**
  * Defines simple indexes (for queries that use a single key)
+ *
  * @category Storage
  */
 export type UnifiedStorageIndexes = readonly {
@@ -25,6 +34,7 @@ export type UnifiedStorageIndexes = readonly {
 }[];
 /**
  * Defines composite indexes (for queries that use multiple keys)
+ *
  * @category Storage
  */
 export type UnifiedStorageCompositeIndexes = readonly {
@@ -32,12 +42,14 @@ export type UnifiedStorageCompositeIndexes = readonly {
     unique: boolean;
 }[];
 /**
- * Interface for unified storage implementations
+ * Interface for a generic unified storage implementations
+ *
  * @category Storage
  */
 export interface IUnifiedStorage<I extends UnifiedStorageIndexes, C extends UnifiedStorageCompositeIndexes> {
     /**
      * Initializes the storage with given indexes and composite indexes
+     *
      * @param indexes
      * @param compositeIndexes
      */
@@ -52,22 +64,22 @@ export interface IUnifiedStorage<I extends UnifiedStorageIndexes, C extends Unif
     query(params: Array<Array<QueryParams>>): Promise<Array<UnifiedStoredObject>>;
     /**
      * Saves an object to storage, updating indexes as needed
-     * @param value - Object to save (must have an id property)
+     * @param value Object to save (must have an id property)
      */
     save(value: UnifiedStoredObject): Promise<void>;
     /**
      * Saves multiple objects to storage in a batch operation
-     * @param value - Array of objects to save
+     * @param value Array of objects to save
      */
     saveAll(value: UnifiedStoredObject[]): Promise<void>;
     /**
      * Removes an object from storage
-     * @param value - Object to remove (must have an id property)
+     * @param value Object to remove (must have an id property)
      */
     remove(value: UnifiedStoredObject): Promise<void>;
     /**
      * Removes multiple objects from storage in a batch operation
-     * @param value - Array of objects to remove
+     * @param value Array of objects to remove
      */
     removeAll(value: UnifiedStoredObject[]): Promise<void>;
 }

package/dist/storage/UnifiedSwapStorage.d.ts

@@ -33,7 +33,8 @@ declare const indexes: readonly [{
     readonly nullable: true;
 }];
 /**
- * Index types for swap storage
+ * Simple index types for SDK swap storage
+ *
  * @category Storage
  */
 export type UnifiedSwapStorageIndexes = typeof indexes;
@@ -51,19 +52,31 @@ declare const compositeIndexes: readonly [{
     readonly unique: false;
 }];
 /**
- * Composite index types for swap storage
+ * Composite index types for SDK swap storage
+ *
  * @category Storage
  */
 export type UnifiedSwapStorageCompositeIndexes = typeof compositeIndexes;
 /**
- * Unified swap persistence layer with caching
+ * Unified swap persistence layer for the SDK utilizing an underlying {@link IUnifiedStorage} instance
+ *  with optional in-memory caching via weak refs {@link WeakRef}
+ *
  * @category Storage
  */
 export declare class UnifiedSwapStorage<T extends ChainType> {
     readonly storage: IUnifiedStorage<UnifiedSwapStorageIndexes, UnifiedSwapStorageCompositeIndexes>;
     readonly weakRefCache: Map<string, WeakRef<ISwap<T>>>;
     readonly noWeakRefMap?: boolean;
+    /**
+     * @param storage Underlying storage persistence layer
+     * @param noWeakRefMap Whether to disable caching of the swap objects in the weak ref map, this
+     *  should be set when you need multiple different clients accessing the same swap database (such
+     *  as when running the SDK in a serverless environment like AWS or Azure)
+     */
     constructor(storage: IUnifiedStorage<UnifiedSwapStorageIndexes, UnifiedSwapStorageCompositeIndexes>, noWeakRefMap?: boolean);
+    /**
+     * Initializes the underlying storage
+     */
     init(): Promise<void>;
     /**
      * Params are specified in the following way:
@@ -74,9 +87,26 @@ export declare class UnifiedSwapStorage<T extends ChainType> {
      * @param reviver
      */
     query<S extends ISwap<T>>(params: Array<Array<QueryParams>>, reviver: (obj: any) => S | null | undefined): Promise<Array<S>>;
+    /**
+     * Saves the swap to storage, updating indexes as needed
+     *
+     * @param value Swap to save
+     */
     save<S extends ISwap<T>>(value: S): Promise<void>;
+    /**
+     * Saves multiple swaps to storage in a batch operation
+     * @param values Array of swaps to save
+     */
     saveAll<S extends ISwap<T>>(values: S[]): Promise<void>;
+    /**
+     * Removes a swap from storage
+     * @param value Swap to remove
+     */
     remove<S extends ISwap<T>>(value: S): Promise<void>;
+    /**
+     * Removes multiple swaps from storage in a batch operation
+     * @param values Array of swaps to remove
+     */
     removeAll<S extends ISwap<T>>(values: S[]): Promise<void>;
 }
 export {};

package/dist/storage/UnifiedSwapStorage.js

@@ -18,15 +18,26 @@ const compositeIndexes = [
     { keys: ["type", "initiator", "state"], unique: false }
 ];
 /**
- * Unified swap persistence layer with caching
+ * Unified swap persistence layer for the SDK utilizing an underlying {@link IUnifiedStorage} instance
+ *  with optional in-memory caching via weak refs {@link WeakRef}
+ *
  * @category Storage
  */
 class UnifiedSwapStorage {
+    /**
+     * @param storage Underlying storage persistence layer
+     * @param noWeakRefMap Whether to disable caching of the swap objects in the weak ref map, this
+     *  should be set when you need multiple different clients accessing the same swap database (such
+     *  as when running the SDK in a serverless environment like AWS or Azure)
+     */
     constructor(storage, noWeakRefMap) {
         this.weakRefCache = new Map();
         this.storage = storage;
         this.noWeakRefMap = noWeakRefMap;
     }
+    /**
+     * Initializes the underlying storage
+     */
     init() {
         return this.storage.init(indexes, compositeIndexes);
     }
@@ -59,21 +70,38 @@ class UnifiedSwapStorage {
         });
         return result;
     }
+    /**
+     * Saves the swap to storage, updating indexes as needed
+     *
+     * @param value Swap to save
+     */
     save(value) {
         if (!this.noWeakRefMap)
             this.weakRefCache.set(value.getId(), new WeakRef(value));
         return this.storage.save(value.serialize());
     }
+    /**
+     * Saves multiple swaps to storage in a batch operation
+     * @param values Array of swaps to save
+     */
     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()));
     }
+    /**
+     * Removes a swap from storage
+     * @param value Swap to remove
+     */
     remove(value) {
         if (!this.noWeakRefMap)
             this.weakRefCache.delete(value.getId());
         return this.storage.remove(value.serialize());
     }
+    /**
+     * Removes multiple swaps from storage in a batch operation
+     * @param values Array of swaps to remove
+     */
     removeAll(values) {
         if (!this.noWeakRefMap)
             values.forEach(value => this.weakRefCache.delete(value.getId()));

package/dist/storage-browser/IndexedDBUnifiedStorage.d.ts

@@ -9,31 +9,55 @@ export type QuerySetCondition = {
 };
 /**
  * Browser IndexedDB storage implementation
+ *
  * @category Storage
  */
 export declare class IndexedDBUnifiedStorage implements IUnifiedStorage<UnifiedSwapStorageIndexes, UnifiedStorageCompositeIndexes> {
     protected readonly logger: LoggerType;
-    storageKey: string;
+    readonly storageKey: string;
     db?: IDBDatabase;
     constructor(storageKey: string);
     private tryMigrateLocalStorage;
     private tryMigrateOldIndexedDB;
+    /**
+     * Attempts to migrate the swap database from old implementations (either using prior version of IndexedDB or
+     *  Local Storage)
+     *
+     * NOTE: Reviver also needs to update the swap to the latest version
+     *
+     * @param storageKeys An array of tuples of storage keys used for the corresponding swap types
+     * @param reviver Swap data deserializer
+     */
     tryMigrate(storageKeys: [string, SwapType][], reviver: (obj: any) => ISwap): Promise<boolean>;
     private executeTransaction;
     private executeTransactionArr;
     private executeTransactionWithCursor;
+    /**
+     * @inheritDoc
+     */
     init(): Promise<void>;
     /**
-     * Params are specified in the following way:
-     *  - [[condition1, condition2]] - returns all rows where condition1 AND condition2 is met
-     *  - [[condition1], [condition2]] - returns all rows where condition1 OR condition2 is met
-     *  - [[condition1, condition2], [condition3]] - returns all rows where (condition1 AND condition2) OR condition3 is met
-     * @param params
+     * @inheritDoc
      */
     query(params: Array<Array<QueryParams>>): Promise<Array<UnifiedStoredObject>>;
-    querySingle(params: Array<QueryParams>): Promise<Array<UnifiedStoredObject>>;
+    /**
+     * @internal
+     */
+    protected querySingle(params: Array<QueryParams>): Promise<Array<UnifiedStoredObject>>;
+    /**
+     * @inheritDoc
+     */
     remove(object: UnifiedStoredObject): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     removeAll(arr: UnifiedStoredObject[]): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     save(object: UnifiedStoredObject): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     saveAll(arr: UnifiedStoredObject[]): Promise<void>;
 }

package/dist/storage-browser/IndexedDBUnifiedStorage.js

@@ -47,6 +47,7 @@ const indexes = {
 };
 /**
  * Browser IndexedDB storage implementation
+ *
  * @category Storage
  */
 class IndexedDBUnifiedStorage {
@@ -130,7 +131,15 @@ class IndexedDBUnifiedStorage {
             return false;
         }
     }
-    //NOTE: Reviver also needs to update the swap to the latest version
+    /**
+     * Attempts to migrate the swap database from old implementations (either using prior version of IndexedDB or
+     *  Local Storage)
+     *
+     * NOTE: Reviver also needs to update the swap to the latest version
+     *
+     * @param storageKeys An array of tuples of storage keys used for the corresponding swap types
+     * @param reviver Swap data deserializer
+     */
     async tryMigrate(storageKeys, reviver) {
         let someMigrated = false;
         for (let storageKey of storageKeys) {
@@ -188,6 +197,9 @@ class IndexedDBUnifiedStorage {
         const result = await Promise.all(promises);
         return result.flat();
     }
+    /**
+     * @inheritDoc
+     */
     async init() {
         if (this.db == null) {
             this.db = await new Promise((resolve, reject) => {
@@ -206,11 +218,7 @@ class IndexedDBUnifiedStorage {
         }
     }
     /**
-     * Params are specified in the following way:
-     *  - [[condition1, condition2]] - returns all rows where condition1 AND condition2 is met
-     *  - [[condition1], [condition2]] - returns all rows where condition1 OR condition2 is met
-     *  - [[condition1, condition2], [condition3]] - returns all rows where (condition1 AND condition2) OR condition3 is met
-     * @param params
+     * @inheritDoc
      */
     async query(params) {
         if (params.length === 0)
@@ -219,6 +227,9 @@ class IndexedDBUnifiedStorage {
         const resultSet = new Set(results.flat()); //Deduplicate
         return Array.from(resultSet);
     }
+    /**
+     * @internal
+     */
     async querySingle(params) {
         if (params.length === 0) {
             return await this.executeTransaction((objectStore) => objectStore.getAll(), true);
@@ -250,10 +261,16 @@ class IndexedDBUnifiedStorage {
             return await this.executeTransactionWithCursor(objectStore => [objectStore.openCursor()], (val) => matches(setConditions, val));
         }
     }
+    /**
+     * @inheritDoc
+     */
     async remove(object) {
         await this.executeTransaction(store => store.delete(object.id), false)
             .catch(() => null);
     }
+    /**
+     * @inheritDoc
+     */
     async removeAll(arr) {
         if (arr.length === 0)
             return;
@@ -261,9 +278,15 @@ class IndexedDBUnifiedStorage {
             return store.delete(object.id);
         }), false);
     }
+    /**
+     * @inheritDoc
+     */
     async save(object) {
         await this.executeTransaction(store => store.put(object), false);
     }
+    /**
+     * @inheritDoc
+     */
     async saveAll(arr) {
         if (arr.length === 0)
             return;

package/dist/storage-browser/LocalStorageManager.d.ts

@@ -1,6 +1,8 @@
 import { IStorageManager, StorageObject } from "@atomiqlabs/base";
 /**
- * StorageManager using browser's local storage API
+ * {@link IStorageManager} implementation using browser's local storage API, this is used as general purpose
+ *  key-value storage, not used for storing swaps! See {@link IUnifiedStorage} for swap storage interface.
+ *
  * @category Storage
  */
 export declare class LocalStorageManager<T extends StorageObject> implements IStorageManager<T> {
@@ -11,15 +13,37 @@ export declare class LocalStorageManager<T extends StorageObject> implements ISt
     data: {
         [hash: string]: T;
     };
+    /**
+     * @param storageKey The key-value store is stored as JSON serialized parameter of the Local Storage under
+     *  the specified `storageKey`
+     */
     constructor(storageKey: string);
+    /**
+     * @inheritDoc
+     */
     init(): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     saveData(hash: string, object: T): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     saveDataArr(arr: {
         id: string;
         object: T;
     }[]): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     removeData(hash: string): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     removeDataArr(hashArr: string[]): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     loadData(type: new (data: any) => T): Promise<T[]>;
     private save;
 }

package/dist/storage-browser/LocalStorageManager.js

@@ -2,15 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalStorageManager = void 0;
 /**
- * StorageManager using browser's local storage API
+ * {@link IStorageManager} implementation using browser's local storage API, this is used as general purpose
+ *  key-value storage, not used for storing swaps! See {@link IUnifiedStorage} for swap storage interface.
+ *
  * @category Storage
  */
 class LocalStorageManager {
+    /**
+     * @param storageKey The key-value store is stored as JSON serialized parameter of the Local Storage under
+     *  the specified `storageKey`
+     */
     constructor(storageKey) {
         this.rawData = {};
         this.data = {};
         this.storageKey = storageKey;
     }
+    /**
+     * @inheritDoc
+     */
     init() {
         const completedTxt = window.localStorage.getItem(this.storageKey);
         if (completedTxt != null) {
@@ -23,11 +32,17 @@ class LocalStorageManager {
         }
         return Promise.resolve();
     }
+    /**
+     * @inheritDoc
+     */
     saveData(hash, object) {
         this.data[hash] = object;
         this.rawData[hash] = object.serialize();
         return this.save();
     }
+    /**
+     * @inheritDoc
+     */
     saveDataArr(arr) {
         arr.forEach(e => {
             this.data[e.id] = e.object;
@@ -35,6 +50,9 @@ class LocalStorageManager {
         });
         return this.save();
     }
+    /**
+     * @inheritDoc
+     */
     removeData(hash) {
         if (this.rawData[hash] != null) {
             if (this.data[hash] != null)
@@ -44,6 +62,9 @@ class LocalStorageManager {
         }
         return Promise.resolve();
     }
+    /**
+     * @inheritDoc
+     */
     removeDataArr(hashArr) {
         hashArr.forEach(hash => {
             if (this.rawData[hash] != null) {
@@ -54,6 +75,9 @@ class LocalStorageManager {
         });
         return this.save();
     }
+    /**
+     * @inheritDoc
+     */
     loadData(type) {
         return Promise.resolve(Object.keys(this.rawData).map(e => {
             const deserialized = new type(this.rawData[e]);