@atomiqlabs/lp-lib 16.2.0 → 16.2.1

package/src/prices/OKXSwapPrice.ts

@@ -1,101 +1,101 @@
-import {ISwapPrice, ISwapPriceCoinsMap} from "./ISwapPrice";
-
-const CACHE_DURATION = 15000;
-
-export type OKXPriceData = {
-    [pair: string]: {
-        [chainId: string]: {
-            address: string,
-            decimals: number
-        }
-    }
-};
-
-export class OKXSwapPrice extends ISwapPrice<{ pair: string, decimals: number }> {
-
-    url: string;
-    cache: {
-        [pair: string]: {
-            price: number,
-            expiry: number
-        }
-    } = {};
-
-    constructor(url: string, coins: ISwapPriceCoinsMap<{pair: string, decimals: number}>) {
-        super(coins);
-        this.url = url || "https://www.okx.com/api/v5";
-    }
-
-    async fetchPrice(pair: string) {
-        const response: Response = await fetch(this.url+"/market/index-tickers?instId=" + pair, {
-            method: "GET"
-        });
-
-        if (response.status !== 200) {
-            let resp: string;
-            try {
-                resp = await response.text();
-            } catch (e) {
-                throw new Error(response.statusText);
-            }
-            throw new Error(resp);
-        }
-
-        let jsonBody: any = await response.json();
-
-        return parseFloat(jsonBody.data[0].idxPx);
-    }
-
-    async getPrice(tokenData: {pair: string}): Promise<bigint> {
-        const pair = tokenData.pair;
-        if(pair.startsWith("$fixed-")) {
-            const amt: number = 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));
-    }
-}
+import {ISwapPrice, ISwapPriceCoinsMap} from "./ISwapPrice";
+
+const CACHE_DURATION = 15000;
+
+export type OKXPriceData = {
+    [pair: string]: {
+        [chainId: string]: {
+            address: string,
+            decimals: number
+        }
+    }
+};
+
+export class OKXSwapPrice extends ISwapPrice<{ pair: string, decimals: number }> {
+
+    url: string;
+    cache: {
+        [pair: string]: {
+            price: number,
+            expiry: number
+        }
+    } = {};
+
+    constructor(url: string, coins: ISwapPriceCoinsMap<{pair: string, decimals: number}>) {
+        super(coins);
+        this.url = url || "https://www.okx.com/api/v5";
+    }
+
+    async fetchPrice(pair: string) {
+        const response: Response = await fetch(this.url+"/market/index-tickers?instId=" + pair, {
+            method: "GET"
+        });
+
+        if (response.status !== 200) {
+            let resp: string;
+            try {
+                resp = await response.text();
+            } catch (e) {
+                throw new Error(response.statusText);
+            }
+            throw new Error(resp);
+        }
+
+        let jsonBody: any = await response.json();
+
+        return parseFloat(jsonBody.data[0].idxPx);
+    }
+
+    async getPrice(tokenData: {pair: string}): Promise<bigint> {
+        const pair = tokenData.pair;
+        if(pair.startsWith("$fixed-")) {
+            const amt: number = 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));
+    }
+}

package/src/storage/IIntermediaryStorage.ts

@@ -1,20 +1,20 @@
-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/src/storagemanager/IntermediaryStorageManager.ts

@@ -1,118 +1,118 @@
-import {StorageObject} from "@atomiqlabs/base";
-import * as fs from "fs/promises";
-import * as fsSync from "fs";
-import {IIntermediaryStorage, StorageQueryParam} from "../storage/IIntermediaryStorage";
-import {getLogger, LoggerType} from "../utils/Utils";
-
-export class IntermediaryStorageManager<T extends StorageObject> implements IIntermediaryStorage<T> {
-
-    private readonly directory: string;
-    private type: new(data: any) => T;
-    private data: {
-        [key: string]: T
-    } = {};
-    private logger: LoggerType;
-
-    constructor(directory: string) {
-        this.directory = directory;
-        this.logger = getLogger("IntermediaryStorageManager("+directory+"): ");
-    }
-
-    async init(): Promise<void> {
-        try {
-            await fs.mkdir(this.directory)
-        } catch (e) {}
-    }
-
-    query(params: StorageQueryParam[]): Promise<{hash: string, sequence: bigint, obj: T}[]> {
-        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: string, sequence: bigint | null): Promise<T> {
-        return Promise.resolve(this.data[paymentHash+"_"+(sequence || 0n).toString(16).padStart(16, "0")]);
-    }
-
-    async saveData(hash: string, sequence: bigint | null, object: T): Promise<void> {
-
-        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: string, sequence: bigint | null): Promise<void> {
-        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: new(data: any) => T): Promise<void> {
-        this.type = type;
-
-        if(!fsSync.existsSync(this.directory)) {
-            this.logger.debug("loadData(): Data directory not found!");
-            return;
-        }
-
-        let files: string[];
-        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;
-        }
-    }
-
-}
+import {StorageObject} from "@atomiqlabs/base";
+import * as fs from "fs/promises";
+import * as fsSync from "fs";
+import {IIntermediaryStorage, StorageQueryParam} from "../storage/IIntermediaryStorage";
+import {getLogger, LoggerType} from "../utils/Utils";
+
+export class IntermediaryStorageManager<T extends StorageObject> implements IIntermediaryStorage<T> {
+
+    private readonly directory: string;
+    private type: new(data: any) => T;
+    private data: {
+        [key: string]: T
+    } = {};
+    private logger: LoggerType;
+
+    constructor(directory: string) {
+        this.directory = directory;
+        this.logger = getLogger("IntermediaryStorageManager("+directory+"): ");
+    }
+
+    async init(): Promise<void> {
+        try {
+            await fs.mkdir(this.directory)
+        } catch (e) {}
+    }
+
+    query(params: StorageQueryParam[]): Promise<{hash: string, sequence: bigint, obj: T}[]> {
+        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: string, sequence: bigint | null): Promise<T> {
+        return Promise.resolve(this.data[paymentHash+"_"+(sequence || 0n).toString(16).padStart(16, "0")]);
+    }
+
+    async saveData(hash: string, sequence: bigint | null, object: T): Promise<void> {
+
+        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: string, sequence: bigint | null): Promise<void> {
+        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: new(data: any) => T): Promise<void> {
+        this.type = type;
+
+        if(!fsSync.existsSync(this.directory)) {
+            this.logger.debug("loadData(): Data directory not found!");
+            return;
+        }
+
+        let files: string[];
+        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;
+        }
+    }
+
+}

package/src/storagemanager/StorageManager.ts

@@ -1,78 +1,78 @@
-import {StorageObject, IStorageManager} from "@atomiqlabs/base";
-import * as fs from "fs/promises";
-import {getLogger, LoggerType} from "../utils/Utils";
-import * as fsSync from "fs";
-
-export class StorageManager<T extends StorageObject> implements IStorageManager<T> {
-
-    private readonly directory: string;
-    data: {
-        [key: string]: T
-    } = {};
-
-    private logger: LoggerType;
-
-    constructor(directory: string) {
-        this.directory = directory;
-        this.logger = getLogger("StorageManager("+directory+"): ");
-    }
-
-    async init(): Promise<void> {
-        try {
-            await fs.mkdir(this.directory)
-        } catch (e) {}
-    }
-
-    async saveData(hash: string, object: T): Promise<void> {
-
-        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: string): Promise<void> {
-        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: new(data: any) => T): Promise<T[]> {
-        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;
-    }
-
-}
+import {StorageObject, IStorageManager} from "@atomiqlabs/base";
+import * as fs from "fs/promises";
+import {getLogger, LoggerType} from "../utils/Utils";
+import * as fsSync from "fs";
+
+export class StorageManager<T extends StorageObject> implements IStorageManager<T> {
+
+    private readonly directory: string;
+    data: {
+        [key: string]: T
+    } = {};
+
+    private logger: LoggerType;
+
+    constructor(directory: string) {
+        this.directory = directory;
+        this.logger = getLogger("StorageManager("+directory+"): ");
+    }
+
+    async init(): Promise<void> {
+        try {
+            await fs.mkdir(this.directory)
+        } catch (e) {}
+    }
+
+    async saveData(hash: string, object: T): Promise<void> {
+
+        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: string): Promise<void> {
+        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: new(data: any) => T): Promise<T[]> {
+        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;
+    }
+
+}