@atomiqlabs/sdk 8.8.3 → 8.8.4

package/src/prices/providers/abstract/ExchangePriceProvider.ts

@@ -1,32 +1,32 @@
-import {HttpPriceProvider} from "./HttpPriceProvider";
-import {CoinType} from "../../abstract/IPriceProvider";
-import {MultiChain} from "../../../swapper/Swapper";
-
-export abstract class ExchangePriceProvider<T extends MultiChain> extends HttpPriceProvider<T> {
-
-    /**
-     * Fetches the price on the specific exchange pair
-     *
-     * @param pair
-     * @param abortSignal
-     * @protected
-     */
-    protected abstract fetchPair(pair: string, abortSignal?: AbortSignal): Promise<number>;
-
-    /**
-     * @inheritDoc
-     */
-    protected async fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint> {
-        const pairs: string[] = token.coinId.split(";");
-        const prices: number[] = await Promise.all(pairs.map(pair => {
-            let invert = pair.startsWith("!");
-            if(invert) pair = pair.substring(1);
-            return this.fetchPair(pair, abortSignal).then(value => invert ? 1/value : value);
-        }));
-
-        const price = prices.reduce((previousValue, currentValue) => previousValue * currentValue, 1);
-
-        return BigInt(Math.floor(price*100000000000000));
-    }
-
+import {HttpPriceProvider} from "./HttpPriceProvider";
+import {CoinType} from "../../abstract/IPriceProvider";
+import {MultiChain} from "../../../swapper/Swapper";
+
+export abstract class ExchangePriceProvider<T extends MultiChain> extends HttpPriceProvider<T> {
+
+    /**
+     * Fetches the price on the specific exchange pair
+     *
+     * @param pair
+     * @param abortSignal
+     * @protected
+     */
+    protected abstract fetchPair(pair: string, abortSignal?: AbortSignal): Promise<number>;
+
+    /**
+     * @inheritDoc
+     */
+    protected async fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint> {
+        const pairs: string[] = token.coinId.split(";");
+        const prices: number[] = await Promise.all(pairs.map(pair => {
+            let invert = pair.startsWith("!");
+            if(invert) pair = pair.substring(1);
+            return this.fetchPair(pair, abortSignal).then(value => invert ? 1/value : value);
+        }));
+
+        const price = prices.reduce((previousValue, currentValue) => previousValue * currentValue, 1);
+
+        return BigInt(Math.floor(price*100000000000000));
+    }
+
 }

package/src/prices/providers/abstract/HttpPriceProvider.ts

@@ -1,15 +1,15 @@
-import {CtorCoinTypes, IPriceProvider} from "../../abstract/IPriceProvider";
-import {MultiChain} from "../../../swapper/Swapper";
-
-export abstract class HttpPriceProvider<T extends MultiChain> extends IPriceProvider<T> {
-
-    url: string;
-    httpRequestTimeout?: number;
-
-    protected constructor(coinsMap: CtorCoinTypes<T>, url: string, httpRequestTimeout?: number) {
-        super(coinsMap);
-        this.url = url;
-        this.httpRequestTimeout = httpRequestTimeout;
-    }
-
+import {CtorCoinTypes, IPriceProvider} from "../../abstract/IPriceProvider";
+import {MultiChain} from "../../../swapper/Swapper";
+
+export abstract class HttpPriceProvider<T extends MultiChain> extends IPriceProvider<T> {
+
+    url: string;
+    httpRequestTimeout?: number;
+
+    protected constructor(coinsMap: CtorCoinTypes<T>, url: string, httpRequestTimeout?: number) {
+        super(coinsMap);
+        this.url = url;
+        this.httpRequestTimeout = httpRequestTimeout;
+    }
+
 }

package/src/storage/IUnifiedStorage.ts

@@ -1,95 +1,95 @@
-
-/**
- * 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, every storage object MUST have an `id` field
- *
- * @category Storage
- */
-export type UnifiedStoredObject = {id: string} & any;
-
-/**
- * Defines simple indexes (for queries that use a single key)
- *
- * @category Storage
- */
-export type UnifiedStorageIndexes = readonly {
-    key: string,
-    type: "number" | "string" | "boolean",
-    unique: boolean,
-    nullable: boolean
-}[];
-
-/**
- * Defines composite indexes (for queries that use multiple keys)
- *
- * @category Storage
- */
-export type UnifiedStorageCompositeIndexes = readonly {
-    keys: readonly string[],
-    unique: boolean
-}[];
-
-/**
- * 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
-     */
-    init(indexes: I, compositeIndexes: C): 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
-     */
-    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)
-     */
-    save(value: UnifiedStoredObject): Promise<void>;
-
-    /**
-     * Saves multiple objects to storage in a batch operation
-     * @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)
-     */
-    remove(value: UnifiedStoredObject): Promise<void>;
-
-    /**
-     * Removes multiple objects from storage in a batch operation
-     * @param value Array of objects to remove
-     */
-    removeAll(value: UnifiedStoredObject[]): Promise<void>;
-
-}
+
+/**
+ * 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, every storage object MUST have an `id` field
+ *
+ * @category Storage
+ */
+export type UnifiedStoredObject = {id: string} & any;
+
+/**
+ * Defines simple indexes (for queries that use a single key)
+ *
+ * @category Storage
+ */
+export type UnifiedStorageIndexes = readonly {
+    key: string,
+    type: "number" | "string" | "boolean",
+    unique: boolean,
+    nullable: boolean
+}[];
+
+/**
+ * Defines composite indexes (for queries that use multiple keys)
+ *
+ * @category Storage
+ */
+export type UnifiedStorageCompositeIndexes = readonly {
+    keys: readonly string[],
+    unique: boolean
+}[];
+
+/**
+ * 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
+     */
+    init(indexes: I, compositeIndexes: C): 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
+     */
+    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)
+     */
+    save(value: UnifiedStoredObject): Promise<void>;
+
+    /**
+     * Saves multiple objects to storage in a batch operation
+     * @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)
+     */
+    remove(value: UnifiedStoredObject): Promise<void>;
+
+    /**
+     * Removes multiple objects from storage in a batch operation
+     * @param value Array of objects to remove
+     */
+    removeAll(value: UnifiedStoredObject[]): Promise<void>;
+
+}

package/src/storage/UnifiedSwapStorage.ts

@@ -1,141 +1,141 @@
-import {ChainType} from "@atomiqlabs/base";
-import {IUnifiedStorage, QueryParams} from "./IUnifiedStorage";
-import {ISwap} from "../swaps/ISwap";
-
-import {getLogger} from "../utils/Logger";
-
-const logger = getLogger("UnifiedSwapStorage: ");
-
-const indexes = [
-    {key: "id", type: "string", unique: true, nullable: false},
-    {key: "escrowHash", type: "string", unique: true, nullable: true},
-    {key: "type", type: "number", unique: false, nullable: false},
-    {key: "initiator", type: "string", unique: false, nullable: false},
-    {key: "state", type: "number", unique: false, nullable: false},
-    {key: "paymentHash", type: "string", unique: false, nullable: true},
-] as const;
-/**
- * Simple index types for SDK swap storage
- *
- * @category Storage
- * @useDeclaredType
- */
-export type UnifiedSwapStorageIndexes = typeof indexes;
-
-const compositeIndexes = [
-    {keys: ["initiator", "id"], unique: false},
-    {keys: ["type", "state"], unique: false},
-    {keys: ["type", "paymentHash"], unique: false},
-    {keys: ["type", "initiator", "state"], unique: false}
-] as const;
-/**
- * Composite index types for SDK swap storage
- *
- * @category Storage
- * @useDeclaredType
- */
-export type UnifiedSwapStorageCompositeIndexes = typeof compositeIndexes;
-
-/**
- * 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 class UnifiedSwapStorage<T extends ChainType> {
-
-    readonly storage: IUnifiedStorage<UnifiedSwapStorageIndexes, UnifiedSwapStorageCompositeIndexes>;
-    readonly weakRefCache: Map<string, WeakRef<ISwap<T>>> = new Map();
-    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) {
-        this.storage = storage;
-        this.noWeakRefMap = noWeakRefMap;
-    }
-
-    /**
-     * Initializes the underlying storage
-     */
-    init(): Promise<void> {
-        return this.storage.init(indexes, compositeIndexes);
-    }
-
-    /**
-     * 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
-     * @param reviver
-     */
-    async query<S extends ISwap<T>>(params: Array<Array<QueryParams>>, reviver: (obj: any) => S | null | undefined): Promise<Array<S>> {
-        const rawSwaps = await this.storage.query(params);
-
-        const result: Array<S> = [];
-        rawSwaps.forEach(rawObj => {
-            if(!this.noWeakRefMap) {
-                const savedRef = this.weakRefCache.get(rawObj.id)?.deref();
-                if(savedRef!=null) {
-                    result.push(savedRef as S);
-                    return;
-                }
-                logger.debug("query(): Reviving new swap instance: "+rawObj.id);
-            }
-            const value = reviver(rawObj);
-            if(value==null) return;
-            value._persisted = true;
-            if(!this.noWeakRefMap) this.weakRefCache.set(rawObj.id, new WeakRef<ISwap<T>>(value));
-            result.push(value);
-        });
-
-        return result;
-    }
-
-    /**
-     * Saves the swap to storage, updating indexes as needed
-     *
-     * @param value Swap to save
-     */
-    async save<S extends ISwap<T>>(value: S): Promise<void> {
-        if(!this.noWeakRefMap) this.weakRefCache.set(value.getId(), new WeakRef<ISwap<T>>(value));
-        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
-     */
-    async saveAll<S extends ISwap<T>>(values: S[]): Promise<void> {
-        if(!this.noWeakRefMap) values.forEach(value => this.weakRefCache.set(value.getId(), new WeakRef<ISwap<T>>(value)));
-        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
-     */
-    async remove<S extends ISwap<T>>(value: S): Promise<void> {
-        if(!this.noWeakRefMap) this.weakRefCache.delete(value.getId());
-        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
-     */
-    async removeAll<S extends ISwap<T>>(values: S[]): Promise<void> {
-        if(!this.noWeakRefMap) values.forEach(value => this.weakRefCache.delete(value.getId()));
-        await this.storage.removeAll(values.map(obj => obj.serialize()));
-        values.forEach(value => value._persisted = false);
-    }
-
-}
+import {ChainType} from "@atomiqlabs/base";
+import {IUnifiedStorage, QueryParams} from "./IUnifiedStorage";
+import {ISwap} from "../swaps/ISwap";
+
+import {getLogger} from "../utils/Logger";
+
+const logger = getLogger("UnifiedSwapStorage: ");
+
+const indexes = [
+    {key: "id", type: "string", unique: true, nullable: false},
+    {key: "escrowHash", type: "string", unique: true, nullable: true},
+    {key: "type", type: "number", unique: false, nullable: false},
+    {key: "initiator", type: "string", unique: false, nullable: false},
+    {key: "state", type: "number", unique: false, nullable: false},
+    {key: "paymentHash", type: "string", unique: false, nullable: true},
+] as const;
+/**
+ * Simple index types for SDK swap storage
+ *
+ * @category Storage
+ * @useDeclaredType
+ */
+export type UnifiedSwapStorageIndexes = typeof indexes;
+
+const compositeIndexes = [
+    {keys: ["initiator", "id"], unique: false},
+    {keys: ["type", "state"], unique: false},
+    {keys: ["type", "paymentHash"], unique: false},
+    {keys: ["type", "initiator", "state"], unique: false}
+] as const;
+/**
+ * Composite index types for SDK swap storage
+ *
+ * @category Storage
+ * @useDeclaredType
+ */
+export type UnifiedSwapStorageCompositeIndexes = typeof compositeIndexes;
+
+/**
+ * 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 class UnifiedSwapStorage<T extends ChainType> {
+
+    readonly storage: IUnifiedStorage<UnifiedSwapStorageIndexes, UnifiedSwapStorageCompositeIndexes>;
+    readonly weakRefCache: Map<string, WeakRef<ISwap<T>>> = new Map();
+    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) {
+        this.storage = storage;
+        this.noWeakRefMap = noWeakRefMap;
+    }
+
+    /**
+     * Initializes the underlying storage
+     */
+    init(): Promise<void> {
+        return this.storage.init(indexes, compositeIndexes);
+    }
+
+    /**
+     * 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
+     * @param reviver
+     */
+    async query<S extends ISwap<T>>(params: Array<Array<QueryParams>>, reviver: (obj: any) => S | null | undefined): Promise<Array<S>> {
+        const rawSwaps = await this.storage.query(params);
+
+        const result: Array<S> = [];
+        rawSwaps.forEach(rawObj => {
+            if(!this.noWeakRefMap) {
+                const savedRef = this.weakRefCache.get(rawObj.id)?.deref();
+                if(savedRef!=null) {
+                    result.push(savedRef as S);
+                    return;
+                }
+                logger.debug("query(): Reviving new swap instance: "+rawObj.id);
+            }
+            const value = reviver(rawObj);
+            if(value==null) return;
+            value._persisted = true;
+            if(!this.noWeakRefMap) this.weakRefCache.set(rawObj.id, new WeakRef<ISwap<T>>(value));
+            result.push(value);
+        });
+
+        return result;
+    }
+
+    /**
+     * Saves the swap to storage, updating indexes as needed
+     *
+     * @param value Swap to save
+     */
+    async save<S extends ISwap<T>>(value: S): Promise<void> {
+        if(!this.noWeakRefMap) this.weakRefCache.set(value.getId(), new WeakRef<ISwap<T>>(value));
+        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
+     */
+    async saveAll<S extends ISwap<T>>(values: S[]): Promise<void> {
+        if(!this.noWeakRefMap) values.forEach(value => this.weakRefCache.set(value.getId(), new WeakRef<ISwap<T>>(value)));
+        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
+     */
+    async remove<S extends ISwap<T>>(value: S): Promise<void> {
+        if(!this.noWeakRefMap) this.weakRefCache.delete(value.getId());
+        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
+     */
+    async removeAll<S extends ISwap<T>>(values: S[]): Promise<void> {
+        if(!this.noWeakRefMap) values.forEach(value => this.weakRefCache.delete(value.getId()));
+        await this.storage.removeAll(values.map(obj => obj.serialize()));
+        values.forEach(value => value._persisted = false);
+    }
+
+}