@atomiqlabs/lp-lib 14.0.0-dev.13 → 14.0.0-dev.16

package/dist/prices/OKXSwapPrice.js

@@ -1,92 +1,92 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OKXSwapPrice = void 0;
-const ISwapPrice_1 = require("./ISwapPrice");
-const CACHE_DURATION = 15000;
-class OKXSwapPrice extends ISwapPrice_1.ISwapPrice {
-    constructor(url, coins) {
-        const coinsMap = {};
-        for (let pair in coins) {
-            const chains = coins[pair];
-            for (let chainId in chains) {
-                const tokenData = chains[chainId];
-                if (coinsMap[chainId] == null)
-                    coinsMap[chainId] = {};
-                coinsMap[chainId][tokenData.address] = {
-                    pair,
-                    decimals: tokenData.decimals
-                };
-            }
-        }
-        super(coinsMap);
-        this.cache = {};
-        this.url = url || "https://www.okx.com/api/v5";
-    }
-    async fetchPrice(pair) {
-        const response = await fetch(this.url + "/market/index-tickers?instId=" + pair, {
-            method: "GET"
-        });
-        if (response.status !== 200) {
-            let resp;
-            try {
-                resp = await response.text();
-            }
-            catch (e) {
-                throw new Error(response.statusText);
-            }
-            throw new Error(resp);
-        }
-        let jsonBody = await response.json();
-        return parseFloat(jsonBody.data[0].idxPx);
-    }
-    async getPrice(tokenData) {
-        const pair = tokenData.pair;
-        if (pair.startsWith("$fixed-")) {
-            const amt = parseFloat(pair.substring(7));
-            return BigInt(Math.floor(amt * 1000000));
-        }
-        const arr = pair.split(";");
-        const promises = [];
-        const cachedValue = this.cache[pair];
-        if (cachedValue == null || cachedValue.expiry < Date.now()) {
-            let resultPrice = 1;
-            for (let pair of arr) {
-                let invert = false;
-                if (pair.startsWith("!")) {
-                    invert = true;
-                    pair = pair.substring(1);
-                }
-                const cachedValue = this.cache[pair];
-                if (cachedValue == null || cachedValue.expiry < Date.now()) {
-                    promises.push(this.fetchPrice(pair).then(price => {
-                        this.cache[pair] = {
-                            price,
-                            expiry: Date.now() + CACHE_DURATION
-                        };
-                        if (invert) {
-                            resultPrice /= price;
-                        }
-                        else {
-                            resultPrice *= price;
-                        }
-                    }));
-                }
-                else {
-                    if (invert) {
-                        resultPrice /= cachedValue.price;
-                    }
-                    else {
-                        resultPrice *= cachedValue.price;
-                    }
-                }
-            }
-            await Promise.all(promises);
-            this.cache[pair] = {
-                price: resultPrice,
-                expiry: Date.now() + CACHE_DURATION
-            };
-        }
-        return BigInt(Math.floor(this.cache[pair].price * 100000000000000));
-    }
-}
-exports.OKXSwapPrice = OKXSwapPrice;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OKXSwapPrice = void 0;
+const ISwapPrice_1 = require("./ISwapPrice");
+const CACHE_DURATION = 15000;
+class OKXSwapPrice extends ISwapPrice_1.ISwapPrice {
+    constructor(url, coins) {
+        const coinsMap = {};
+        for (let pair in coins) {
+            const chains = coins[pair];
+            for (let chainId in chains) {
+                const tokenData = chains[chainId];
+                if (coinsMap[chainId] == null)
+                    coinsMap[chainId] = {};
+                coinsMap[chainId][tokenData.address] = {
+                    pair,
+                    decimals: tokenData.decimals
+                };
+            }
+        }
+        super(coinsMap);
+        this.cache = {};
+        this.url = url || "https://www.okx.com/api/v5";
+    }
+    async fetchPrice(pair) {
+        const response = await fetch(this.url + "/market/index-tickers?instId=" + pair, {
+            method: "GET"
+        });
+        if (response.status !== 200) {
+            let resp;
+            try {
+                resp = await response.text();
+            }
+            catch (e) {
+                throw new Error(response.statusText);
+            }
+            throw new Error(resp);
+        }
+        let jsonBody = await response.json();
+        return parseFloat(jsonBody.data[0].idxPx);
+    }
+    async getPrice(tokenData) {
+        const pair = tokenData.pair;
+        if (pair.startsWith("$fixed-")) {
+            const amt = parseFloat(pair.substring(7));
+            return BigInt(Math.floor(amt * 1000000));
+        }
+        const arr = pair.split(";");
+        const promises = [];
+        const cachedValue = this.cache[pair];
+        if (cachedValue == null || cachedValue.expiry < Date.now()) {
+            let resultPrice = 1;
+            for (let pair of arr) {
+                let invert = false;
+                if (pair.startsWith("!")) {
+                    invert = true;
+                    pair = pair.substring(1);
+                }
+                const cachedValue = this.cache[pair];
+                if (cachedValue == null || cachedValue.expiry < Date.now()) {
+                    promises.push(this.fetchPrice(pair).then(price => {
+                        this.cache[pair] = {
+                            price,
+                            expiry: Date.now() + CACHE_DURATION
+                        };
+                        if (invert) {
+                            resultPrice /= price;
+                        }
+                        else {
+                            resultPrice *= price;
+                        }
+                    }));
+                }
+                else {
+                    if (invert) {
+                        resultPrice /= cachedValue.price;
+                    }
+                    else {
+                        resultPrice *= cachedValue.price;
+                    }
+                }
+            }
+            await Promise.all(promises);
+            this.cache[pair] = {
+                price: resultPrice,
+                expiry: Date.now() + CACHE_DURATION
+            };
+        }
+        return BigInt(Math.floor(this.cache[pair].price * 100000000000000));
+    }
+}
+exports.OKXSwapPrice = OKXSwapPrice;

package/dist/storage/IIntermediaryStorage.d.ts

@@ -1,18 +1,18 @@
-import { StorageObject } from "@atomiqlabs/base";
-export type StorageQueryParam = {
-    key: string;
-    value?: any;
-    values?: any[];
-};
-export interface IIntermediaryStorage<T extends StorageObject> {
-    init(): Promise<void>;
-    query(params: StorageQueryParam[]): Promise<{
-        hash: string;
-        sequence: bigint;
-        obj: T;
-    }[]>;
-    getData(hash: string, sequence: bigint | null): Promise<T>;
-    saveData(hash: string, sequence: bigint | null, object: T): Promise<void>;
-    removeData(hash: string, sequence: bigint | null): Promise<void>;
-    loadData(type: new (data: any) => T): Promise<void>;
-}
+import { StorageObject } from "@atomiqlabs/base";
+export type StorageQueryParam = {
+    key: string;
+    value?: any;
+    values?: any[];
+};
+export interface IIntermediaryStorage<T extends StorageObject> {
+    init(): Promise<void>;
+    query(params: StorageQueryParam[]): Promise<{
+        hash: string;
+        sequence: bigint;
+        obj: T;
+    }[]>;
+    getData(hash: string, sequence: bigint | null): Promise<T>;
+    saveData(hash: string, sequence: bigint | null, object: T): Promise<void>;
+    removeData(hash: string, sequence: bigint | null): Promise<void>;
+    loadData(type: new (data: any) => T): Promise<void>;
+}

package/dist/storage/IIntermediaryStorage.js

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

package/dist/storagemanager/IntermediaryStorageManager.d.ts

@@ -1,19 +1,19 @@
-import { StorageObject } from "@atomiqlabs/base";
-import { IIntermediaryStorage, StorageQueryParam } from "../storage/IIntermediaryStorage";
-export declare class IntermediaryStorageManager<T extends StorageObject> implements IIntermediaryStorage<T> {
-    private readonly directory;
-    private type;
-    private data;
-    private logger;
-    constructor(directory: string);
-    init(): Promise<void>;
-    query(params: StorageQueryParam[]): Promise<{
-        hash: string;
-        sequence: bigint;
-        obj: T;
-    }[]>;
-    getData(paymentHash: string, sequence: bigint | null): Promise<T>;
-    saveData(hash: string, sequence: bigint | null, object: T): Promise<void>;
-    removeData(hash: string, sequence: bigint | null): Promise<void>;
-    loadData(type: new (data: any) => T): Promise<void>;
-}
+import { StorageObject } from "@atomiqlabs/base";
+import { IIntermediaryStorage, StorageQueryParam } from "../storage/IIntermediaryStorage";
+export declare class IntermediaryStorageManager<T extends StorageObject> implements IIntermediaryStorage<T> {
+    private readonly directory;
+    private type;
+    private data;
+    private logger;
+    constructor(directory: string);
+    init(): Promise<void>;
+    query(params: StorageQueryParam[]): Promise<{
+        hash: string;
+        sequence: bigint;
+        obj: T;
+    }[]>;
+    getData(paymentHash: string, sequence: bigint | null): Promise<T>;
+    saveData(hash: string, sequence: bigint | null, object: T): Promise<void>;
+    removeData(hash: string, sequence: bigint | null): Promise<void>;
+    loadData(type: new (data: any) => T): Promise<void>;
+}

package/dist/storagemanager/IntermediaryStorageManager.js

@@ -1,111 +1,111 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntermediaryStorageManager = void 0;
-const fs = require("fs/promises");
-const fsSync = require("fs");
-const Utils_1 = require("../utils/Utils");
-class IntermediaryStorageManager {
-    constructor(directory) {
-        this.data = {};
-        this.directory = directory;
-        this.logger = (0, Utils_1.getLogger)("IntermediaryStorageManager(" + directory + "): ");
-    }
-    async init() {
-        try {
-            await fs.mkdir(this.directory);
-        }
-        catch (e) { }
-    }
-    query(params) {
-        return Promise.resolve(Object.keys(this.data).filter((key) => {
-            const val = this.data[key];
-            for (let param of params) {
-                if (param.value != null) {
-                    if (typeof param.value === "object") {
-                        if (param.value.eq != null && !param.value.eq(val[param.key]))
-                            return false;
-                        if (param.value.equals != null && !param.value.equals(val[param.key]))
-                            return false;
-                    }
-                    else {
-                        if (param.value !== val[param.key])
-                            return false;
-                    }
-                }
-                else if (param.values != null) {
-                    let hasSome = false;
-                    for (let expectedValue of param.values) {
-                        if (typeof expectedValue === "object") {
-                            if (expectedValue.eq != null && !expectedValue.eq(val[param.key]))
-                                hasSome = true;
-                            if (expectedValue.equals != null && !expectedValue.equals(val[param.key]))
-                                hasSome = true;
-                        }
-                        else {
-                            if (expectedValue === val[param.key])
-                                hasSome = true;
-                        }
-                    }
-                    if (!hasSome)
-                        return false;
-                }
-            }
-            return true;
-        }).map(key => {
-            const [hash, sequenceStr] = key.split("_");
-            const sequence = BigInt("0x" + sequenceStr);
-            return {
-                obj: this.data[key],
-                hash,
-                sequence
-            };
-        }));
-    }
-    getData(paymentHash, sequence) {
-        return Promise.resolve(this.data[paymentHash + "_" + (sequence || 0n).toString(16).padStart(16, "0")]);
-    }
-    async saveData(hash, sequence, object) {
-        const _sequence = (sequence || 0n).toString(16).padStart(16, "0");
-        try {
-            await fs.mkdir(this.directory);
-        }
-        catch (e) { }
-        this.data[hash + "_" + _sequence] = object;
-        const cpy = object.serialize();
-        await fs.writeFile(this.directory + "/" + hash + "_" + _sequence + ".json", JSON.stringify(cpy));
-    }
-    async removeData(hash, sequence) {
-        const identifier = hash + "_" + (sequence || 0n).toString(16).padStart(16, "0");
-        try {
-            if (this.data[identifier] != null)
-                delete this.data[identifier];
-            await fs.rm(this.directory + "/" + identifier + ".json");
-        }
-        catch (e) {
-            this.logger.error("removeData(): Error when removing data: ", e);
-        }
-    }
-    async loadData(type) {
-        this.type = type;
-        if (!fsSync.existsSync(this.directory)) {
-            this.logger.debug("loadData(): Data directory not found!");
-            return;
-        }
-        let files;
-        try {
-            files = await fs.readdir(this.directory);
-        }
-        catch (e) {
-            this.logger.error("loadData(): Error when checking directory: ", e);
-            return;
-        }
-        for (let file of files) {
-            const indentifier = file.split(".")[0];
-            const result = await fs.readFile(this.directory + "/" + file);
-            const obj = JSON.parse(result.toString());
-            const parsed = new type(obj);
-            this.data[indentifier] = parsed;
-        }
-    }
-}
-exports.IntermediaryStorageManager = IntermediaryStorageManager;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntermediaryStorageManager = void 0;
+const fs = require("fs/promises");
+const fsSync = require("fs");
+const Utils_1 = require("../utils/Utils");
+class IntermediaryStorageManager {
+    constructor(directory) {
+        this.data = {};
+        this.directory = directory;
+        this.logger = (0, Utils_1.getLogger)("IntermediaryStorageManager(" + directory + "): ");
+    }
+    async init() {
+        try {
+            await fs.mkdir(this.directory);
+        }
+        catch (e) { }
+    }
+    query(params) {
+        return Promise.resolve(Object.keys(this.data).filter((key) => {
+            const val = this.data[key];
+            for (let param of params) {
+                if (param.value != null) {
+                    if (typeof param.value === "object") {
+                        if (param.value.eq != null && !param.value.eq(val[param.key]))
+                            return false;
+                        if (param.value.equals != null && !param.value.equals(val[param.key]))
+                            return false;
+                    }
+                    else {
+                        if (param.value !== val[param.key])
+                            return false;
+                    }
+                }
+                else if (param.values != null) {
+                    let hasSome = false;
+                    for (let expectedValue of param.values) {
+                        if (typeof expectedValue === "object") {
+                            if (expectedValue.eq != null && !expectedValue.eq(val[param.key]))
+                                hasSome = true;
+                            if (expectedValue.equals != null && !expectedValue.equals(val[param.key]))
+                                hasSome = true;
+                        }
+                        else {
+                            if (expectedValue === val[param.key])
+                                hasSome = true;
+                        }
+                    }
+                    if (!hasSome)
+                        return false;
+                }
+            }
+            return true;
+        }).map(key => {
+            const [hash, sequenceStr] = key.split("_");
+            const sequence = BigInt("0x" + sequenceStr);
+            return {
+                obj: this.data[key],
+                hash,
+                sequence
+            };
+        }));
+    }
+    getData(paymentHash, sequence) {
+        return Promise.resolve(this.data[paymentHash + "_" + (sequence || 0n).toString(16).padStart(16, "0")]);
+    }
+    async saveData(hash, sequence, object) {
+        const _sequence = (sequence || 0n).toString(16).padStart(16, "0");
+        try {
+            await fs.mkdir(this.directory);
+        }
+        catch (e) { }
+        this.data[hash + "_" + _sequence] = object;
+        const cpy = object.serialize();
+        await fs.writeFile(this.directory + "/" + hash + "_" + _sequence + ".json", JSON.stringify(cpy));
+    }
+    async removeData(hash, sequence) {
+        const identifier = hash + "_" + (sequence || 0n).toString(16).padStart(16, "0");
+        try {
+            if (this.data[identifier] != null)
+                delete this.data[identifier];
+            await fs.rm(this.directory + "/" + identifier + ".json");
+        }
+        catch (e) {
+            this.logger.error("removeData(): Error when removing data: ", e);
+        }
+    }
+    async loadData(type) {
+        this.type = type;
+        if (!fsSync.existsSync(this.directory)) {
+            this.logger.debug("loadData(): Data directory not found!");
+            return;
+        }
+        let files;
+        try {
+            files = await fs.readdir(this.directory);
+        }
+        catch (e) {
+            this.logger.error("loadData(): Error when checking directory: ", e);
+            return;
+        }
+        for (let file of files) {
+            const indentifier = file.split(".")[0];
+            const result = await fs.readFile(this.directory + "/" + file);
+            const obj = JSON.parse(result.toString());
+            const parsed = new type(obj);
+            this.data[indentifier] = parsed;
+        }
+    }
+}
+exports.IntermediaryStorageManager = IntermediaryStorageManager;

package/dist/storagemanager/StorageManager.d.ts

@@ -1,13 +1,13 @@
-import { StorageObject, IStorageManager } from "@atomiqlabs/base";
-export declare class StorageManager<T extends StorageObject> implements IStorageManager<T> {
-    private readonly directory;
-    data: {
-        [key: string]: T;
-    };
-    private logger;
-    constructor(directory: string);
-    init(): Promise<void>;
-    saveData(hash: string, object: T): Promise<void>;
-    removeData(hash: string): Promise<void>;
-    loadData(type: new (data: any) => T): Promise<T[]>;
-}
+import { StorageObject, IStorageManager } from "@atomiqlabs/base";
+export declare class StorageManager<T extends StorageObject> implements IStorageManager<T> {
+    private readonly directory;
+    data: {
+        [key: string]: T;
+    };
+    private logger;
+    constructor(directory: string);
+    init(): Promise<void>;
+    saveData(hash: string, object: T): Promise<void>;
+    removeData(hash: string): Promise<void>;
+    loadData(type: new (data: any) => T): Promise<T[]>;
+}

package/dist/storagemanager/StorageManager.js

@@ -1,64 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StorageManager = void 0;
-const fs = require("fs/promises");
-const Utils_1 = require("../utils/Utils");
-const fsSync = require("fs");
-class StorageManager {
-    constructor(directory) {
-        this.data = {};
-        this.directory = directory;
-        this.logger = (0, Utils_1.getLogger)("StorageManager(" + directory + "): ");
-    }
-    async init() {
-        try {
-            await fs.mkdir(this.directory);
-        }
-        catch (e) { }
-    }
-    async saveData(hash, object) {
-        try {
-            await fs.mkdir(this.directory);
-        }
-        catch (e) { }
-        this.data[hash] = object;
-        const cpy = object.serialize();
-        await fs.writeFile(this.directory + "/" + hash + ".json", JSON.stringify(cpy));
-    }
-    async removeData(hash) {
-        const paymentHash = hash;
-        try {
-            if (this.data[paymentHash] != null)
-                delete this.data[paymentHash];
-            await fs.rm(this.directory + "/" + paymentHash + ".json");
-        }
-        catch (e) {
-            this.logger.error("removeData(): Error when removing data: ", e);
-        }
-    }
-    async loadData(type) {
-        if (!fsSync.existsSync(this.directory)) {
-            this.logger.debug("loadData(): Data directory not found!");
-            return;
-        }
-        let files;
-        try {
-            files = await fs.readdir(this.directory);
-        }
-        catch (e) {
-            this.logger.error("loadData(): Error when checking directory: ", e);
-            return [];
-        }
-        const arr = [];
-        for (let file of files) {
-            const paymentHash = file.split(".")[0];
-            const result = await fs.readFile(this.directory + "/" + file);
-            const obj = JSON.parse(result.toString());
-            const parsed = new type(obj);
-            arr.push(parsed);
-            this.data[paymentHash] = parsed;
-        }
-        return arr;
-    }
-}
-exports.StorageManager = StorageManager;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageManager = void 0;
+const fs = require("fs/promises");
+const Utils_1 = require("../utils/Utils");
+const fsSync = require("fs");
+class StorageManager {
+    constructor(directory) {
+        this.data = {};
+        this.directory = directory;
+        this.logger = (0, Utils_1.getLogger)("StorageManager(" + directory + "): ");
+    }
+    async init() {
+        try {
+            await fs.mkdir(this.directory);
+        }
+        catch (e) { }
+    }
+    async saveData(hash, object) {
+        try {
+            await fs.mkdir(this.directory);
+        }
+        catch (e) { }
+        this.data[hash] = object;
+        const cpy = object.serialize();
+        await fs.writeFile(this.directory + "/" + hash + ".json", JSON.stringify(cpy));
+    }
+    async removeData(hash) {
+        const paymentHash = hash;
+        try {
+            if (this.data[paymentHash] != null)
+                delete this.data[paymentHash];
+            await fs.rm(this.directory + "/" + paymentHash + ".json");
+        }
+        catch (e) {
+            this.logger.error("removeData(): Error when removing data: ", e);
+        }
+    }
+    async loadData(type) {
+        if (!fsSync.existsSync(this.directory)) {
+            this.logger.debug("loadData(): Data directory not found!");
+            return;
+        }
+        let files;
+        try {
+            files = await fs.readdir(this.directory);
+        }
+        catch (e) {
+            this.logger.error("loadData(): Error when checking directory: ", e);
+            return [];
+        }
+        const arr = [];
+        for (let file of files) {
+            const paymentHash = file.split(".")[0];
+            const result = await fs.readFile(this.directory + "/" + file);
+            const obj = JSON.parse(result.toString());
+            const parsed = new type(obj);
+            arr.push(parsed);
+            this.data[paymentHash] = parsed;
+        }
+        return arr;
+    }
+}
+exports.StorageManager = StorageManager;