@atomiqlabs/sdk 8.6.4 → 8.6.6

package/dist/prices/providers/OKXPriceProvider.js

@@ -1,29 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OKXPriceProvider = void 0;
-const ExchangePriceProvider_1 = require("./abstract/ExchangePriceProvider");
-const HttpUtils_1 = require("../../http/HttpUtils");
-/**
- * Price provider using OKX exchange API
- * @category Pricing
- */
-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;
-    }
-}
-exports.OKXPriceProvider = OKXPriceProvider;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OKXPriceProvider = void 0;
+const ExchangePriceProvider_1 = require("./abstract/ExchangePriceProvider");
+const HttpUtils_1 = require("../../http/HttpUtils");
+/**
+ * Price provider using OKX exchange API
+ * @category Pricing
+ */
+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;
+    }
+}
+exports.OKXPriceProvider = OKXPriceProvider;

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

@@ -1,17 +1,17 @@
-import { HttpPriceProvider } from "./HttpPriceProvider";
-import { CoinType } from "../../abstract/IPriceProvider";
-import { MultiChain } from "../../../swapper/Swapper";
-export declare 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 fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
-}
+import { HttpPriceProvider } from "./HttpPriceProvider";
+import { CoinType } from "../../abstract/IPriceProvider";
+import { MultiChain } from "../../../swapper/Swapper";
+export declare 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 fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
+}

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

@@ -1,21 +1,21 @@
-"use strict";
-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 => {
-            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));
-    }
-}
-exports.ExchangePriceProvider = ExchangePriceProvider;
+"use strict";
+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 => {
+            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));
+    }
+}
+exports.ExchangePriceProvider = ExchangePriceProvider;

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

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

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

@@ -1,12 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpPriceProvider = void 0;
-const IPriceProvider_1 = require("../../abstract/IPriceProvider");
-class HttpPriceProvider extends IPriceProvider_1.IPriceProvider {
-    constructor(coinsMap, url, httpRequestTimeout) {
-        super(coinsMap);
-        this.url = url;
-        this.httpRequestTimeout = httpRequestTimeout;
-    }
-}
-exports.HttpPriceProvider = HttpPriceProvider;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpPriceProvider = void 0;
+const IPriceProvider_1 = require("../../abstract/IPriceProvider");
+class HttpPriceProvider extends IPriceProvider_1.IPriceProvider {
+    constructor(coinsMap, url, httpRequestTimeout) {
+        super(coinsMap);
+        this.url = url;
+        this.httpRequestTimeout = httpRequestTimeout;
+    }
+}
+exports.HttpPriceProvider = HttpPriceProvider;

package/dist/storage/IUnifiedStorage.d.ts

@@ -1,85 +1,85 @@
-/**
- * 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/dist/storage/IUnifiedStorage.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/storage/UnifiedSwapStorage.d.ts

@@ -1,114 +1,114 @@
-import { ChainType } from "@atomiqlabs/base";
-import { IUnifiedStorage, QueryParams } from "./IUnifiedStorage";
-import { ISwap } from "../swaps/ISwap";
-declare const indexes: readonly [{
-    readonly key: "id";
-    readonly type: "string";
-    readonly unique: true;
-    readonly nullable: false;
-}, {
-    readonly key: "escrowHash";
-    readonly type: "string";
-    readonly unique: true;
-    readonly nullable: true;
-}, {
-    readonly key: "type";
-    readonly type: "number";
-    readonly unique: false;
-    readonly nullable: false;
-}, {
-    readonly key: "initiator";
-    readonly type: "string";
-    readonly unique: false;
-    readonly nullable: false;
-}, {
-    readonly key: "state";
-    readonly type: "number";
-    readonly unique: false;
-    readonly nullable: false;
-}, {
-    readonly key: "paymentHash";
-    readonly type: "string";
-    readonly unique: false;
-    readonly nullable: true;
-}];
-/**
- * Simple index types for SDK swap storage
- *
- * @category Storage
- * @useDeclaredType
- */
-export type UnifiedSwapStorageIndexes = typeof indexes;
-declare const compositeIndexes: readonly [{
-    readonly keys: readonly ["initiator", "id"];
-    readonly unique: false;
-}, {
-    readonly keys: readonly ["type", "state"];
-    readonly unique: false;
-}, {
-    readonly keys: readonly ["type", "paymentHash"];
-    readonly unique: false;
-}, {
-    readonly keys: readonly ["type", "initiator", "state"];
-    readonly unique: false;
-}];
-/**
- * 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 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:
-     *  - [[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
-     */
-    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 {};
+import { ChainType } from "@atomiqlabs/base";
+import { IUnifiedStorage, QueryParams } from "./IUnifiedStorage";
+import { ISwap } from "../swaps/ISwap";
+declare const indexes: readonly [{
+    readonly key: "id";
+    readonly type: "string";
+    readonly unique: true;
+    readonly nullable: false;
+}, {
+    readonly key: "escrowHash";
+    readonly type: "string";
+    readonly unique: true;
+    readonly nullable: true;
+}, {
+    readonly key: "type";
+    readonly type: "number";
+    readonly unique: false;
+    readonly nullable: false;
+}, {
+    readonly key: "initiator";
+    readonly type: "string";
+    readonly unique: false;
+    readonly nullable: false;
+}, {
+    readonly key: "state";
+    readonly type: "number";
+    readonly unique: false;
+    readonly nullable: false;
+}, {
+    readonly key: "paymentHash";
+    readonly type: "string";
+    readonly unique: false;
+    readonly nullable: true;
+}];
+/**
+ * Simple index types for SDK swap storage
+ *
+ * @category Storage
+ * @useDeclaredType
+ */
+export type UnifiedSwapStorageIndexes = typeof indexes;
+declare const compositeIndexes: readonly [{
+    readonly keys: readonly ["initiator", "id"];
+    readonly unique: false;
+}, {
+    readonly keys: readonly ["type", "state"];
+    readonly unique: false;
+}, {
+    readonly keys: readonly ["type", "paymentHash"];
+    readonly unique: false;
+}, {
+    readonly keys: readonly ["type", "initiator", "state"];
+    readonly unique: false;
+}];
+/**
+ * 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 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:
+     *  - [[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
+     */
+    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 {};