@atomiqlabs/lp-lib 11.0.5 → 12.0.0-beta.0

package/dist/prices/CoinGeckoSwapPrice.js

@@ -1,16 +1,6 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoinGeckoSwapPrice = void 0;
-const BN = require("bn.js");
 const ISwapPrice_1 = require("../swaps/ISwapPrice");
 const CACHE_DURATION = 15000;
 class CoinGeckoSwapPrice extends ISwapPrice_1.ISwapPrice {
@@ -37,40 +27,38 @@ class CoinGeckoSwapPrice extends ISwapPrice_1.ISwapPrice {
      *
      * @param coin
      */
-    getPrice(coin) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const coinId = coin.coinId;
-            if (coinId.startsWith("$fixed-")) {
-                const amt = parseFloat(coinId.substring(7));
-                return new BN(Math.floor(amt * 1000));
-            }
-            const cachedValue = this.cache[coinId];
-            if (cachedValue != null && cachedValue.expiry > Date.now()) {
-                return cachedValue.price;
+    async getPrice(coin) {
+        const coinId = coin.coinId;
+        if (coinId.startsWith("$fixed-")) {
+            const amt = parseFloat(coinId.substring(7));
+            return BigInt(Math.floor(amt * 1000));
+        }
+        const cachedValue = this.cache[coinId];
+        if (cachedValue != null && cachedValue.expiry > Date.now()) {
+            return cachedValue.price;
+        }
+        const response = await fetch(this.url + "/simple/price?ids=" + coinId + "&vs_currencies=sats&precision=3", {
+            method: "GET",
+            headers: { 'Content-Type': 'application/json' }
+        });
+        if (response.status !== 200) {
+            let resp;
+            try {
+                resp = await response.text();
             }
-            const response = yield fetch(this.url + "/simple/price?ids=" + coinId + "&vs_currencies=sats&precision=3", {
-                method: "GET",
-                headers: { 'Content-Type': 'application/json' }
-            });
-            if (response.status !== 200) {
-                let resp;
-                try {
-                    resp = yield response.text();
-                }
-                catch (e) {
-                    throw new Error(response.statusText);
-                }
-                throw new Error(resp);
+            catch (e) {
+                throw new Error(response.statusText);
             }
-            let jsonBody = yield response.json();
-            const amt = jsonBody[coinId].sats;
-            const result = new BN(amt * 1000);
-            this.cache[coinId] = {
-                price: result,
-                expiry: Date.now() + CACHE_DURATION
-            };
-            return result;
-        });
+            throw new Error(resp);
+        }
+        let jsonBody = await response.json();
+        const amt = jsonBody[coinId].sats;
+        const result = BigInt(Math.floor(amt * 1000));
+        this.cache[coinId] = {
+            price: result,
+            expiry: Date.now() + CACHE_DURATION
+        };
+        return result;
     }
 }
 exports.CoinGeckoSwapPrice = CoinGeckoSwapPrice;

package/dist/prices/OKXSwapPrice.d.ts

@@ -1,4 +1,3 @@
-import * as BN from "bn.js";
 import { ISwapPrice } from "../swaps/ISwapPrice";
 export type OKXPriceData = {
     [pair: string]: {
@@ -23,5 +22,5 @@ export declare class OKXSwapPrice extends ISwapPrice<{
     fetchPrice(pair: string): Promise<number>;
     getPrice(tokenData: {
         pair: string;
-    }): Promise<BN>;
+    }): Promise<bigint>;
 }

package/dist/prices/OKXSwapPrice.js

@@ -1,16 +1,6 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OKXSwapPrice = void 0;
-const BN = require("bn.js");
 const ISwapPrice_1 = require("../swaps/ISwapPrice");
 const CACHE_DURATION = 15000;
 class OKXSwapPrice extends ISwapPrice_1.ISwapPrice {
@@ -32,75 +22,71 @@ class OKXSwapPrice extends ISwapPrice_1.ISwapPrice {
         this.cache = {};
         this.url = url || "https://www.okx.com/api/v5";
     }
-    fetchPrice(pair) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield fetch(this.url + "/market/index-tickers?instId=" + pair, {
-                method: "GET"
-            });
-            if (response.status !== 200) {
-                let resp;
-                try {
-                    resp = yield response.text();
-                }
-                catch (e) {
-                    throw new Error(response.statusText);
-                }
-                throw new Error(resp);
-            }
-            let jsonBody = yield response.json();
-            return parseFloat(jsonBody.data[0].idxPx);
+    async fetchPrice(pair) {
+        const response = await fetch(this.url + "/market/index-tickers?instId=" + pair, {
+            method: "GET"
         });
-    }
-    getPrice(tokenData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pair = tokenData.pair;
-            if (pair.startsWith("$fixed-")) {
-                const amt = parseFloat(pair.substring(7));
-                return new BN(Math.floor(amt * 1000000));
+        if (response.status !== 200) {
+            let resp;
+            try {
+                resp = await response.text();
             }
-            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 {
+            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 /= cachedValue.price;
+                            resultPrice /= price;
                         }
                         else {
-                            resultPrice *= cachedValue.price;
+                            resultPrice *= price;
                         }
+                    }));
+                }
+                else {
+                    if (invert) {
+                        resultPrice /= cachedValue.price;
+                    }
+                    else {
+                        resultPrice *= cachedValue.price;
                     }
                 }
-                yield Promise.all(promises);
-                this.cache[pair] = {
-                    price: resultPrice,
-                    expiry: Date.now() + CACHE_DURATION
-                };
             }
-            return new BN(Math.floor(this.cache[pair].price * 100000000000000));
-        });
+            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,5 +1,4 @@
 import { StorageObject } from "@atomiqlabs/base";
-import * as BN from "bn.js";
 export type StorageQueryParam = {
     key: string;
     value?: any;
@@ -7,9 +6,13 @@ export type StorageQueryParam = {
 };
 export interface IIntermediaryStorage<T extends StorageObject> {
     init(): Promise<void>;
-    query(params: StorageQueryParam[]): Promise<T[]>;
-    getData(hash: string, sequence: BN | null): Promise<T>;
-    saveData(hash: string, sequence: BN | null, object: T): Promise<void>;
-    removeData(hash: string, sequence: BN | null): 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/storagemanager/IntermediaryStorageManager.d.ts

@@ -1,15 +1,18 @@
 import { StorageObject } from "@atomiqlabs/base";
 import { IIntermediaryStorage, StorageQueryParam } from "../storage/IIntermediaryStorage";
-import * as BN from "bn.js";
 export declare class IntermediaryStorageManager<T extends StorageObject> implements IIntermediaryStorage<T> {
     private readonly directory;
     private type;
     private data;
     constructor(directory: string);
     init(): Promise<void>;
-    query(params: StorageQueryParam[]): Promise<T[]>;
-    getData(paymentHash: string, sequence: BN | null): Promise<T>;
-    saveData(hash: string, sequence: BN | null, object: T): Promise<void>;
-    removeData(hash: string, sequence: BN | null): 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,32 +1,21 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntermediaryStorageManager = void 0;
 const fs = require("fs/promises");
-const BN = require("bn.js");
 class IntermediaryStorageManager {
     constructor(directory) {
         this.data = {};
         this.directory = directory;
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield fs.mkdir(this.directory);
-            }
-            catch (e) { }
-        });
+    async init() {
+        try {
+            await fs.mkdir(this.directory);
+        }
+        catch (e) { }
     }
     query(params) {
-        return Promise.resolve(Object.keys(this.data).map((val) => this.data[val]).filter((val) => {
+        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") {
@@ -59,55 +48,57 @@ class IntermediaryStorageManager {
                 }
             }
             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 || new BN(0)).toString("hex", 8)]);
+        return Promise.resolve(this.data[paymentHash + "_" + (sequence || 0n).toString(16).padStart(16, "0")]);
     }
-    saveData(hash, sequence, object) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const _sequence = (sequence || new BN(0)).toString("hex", 8);
-            try {
-                yield fs.mkdir(this.directory);
-            }
-            catch (e) { }
-            this.data[hash + "_" + _sequence] = object;
-            const cpy = object.serialize();
-            yield fs.writeFile(this.directory + "/" + hash + "_" + _sequence + ".json", JSON.stringify(cpy));
-        });
+    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));
     }
-    removeData(hash, sequence) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const identifier = hash + "_" + (sequence || new BN(0)).toString("hex", 8);
-            try {
-                if (this.data[identifier] != null)
-                    delete this.data[identifier];
-                yield fs.rm(this.directory + "/" + identifier + ".json");
-            }
-            catch (e) {
-                console.error(e);
-            }
-        });
+    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) {
+            console.error(e);
+        }
     }
-    loadData(type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.type = type;
-            let files;
-            try {
-                files = yield fs.readdir(this.directory);
-            }
-            catch (e) {
-                console.error(e);
-                return;
-            }
-            for (let file of files) {
-                const indentifier = file.split(".")[0];
-                const result = yield fs.readFile(this.directory + "/" + file);
-                const obj = JSON.parse(result.toString());
-                const parsed = new type(obj);
-                this.data[indentifier] = parsed;
-            }
-        });
+    async loadData(type) {
+        this.type = type;
+        let files;
+        try {
+            files = await fs.readdir(this.directory);
+        }
+        catch (e) {
+            console.error(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.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StorageManager = void 0;
 const fs = require("fs/promises");
@@ -16,59 +7,51 @@ class StorageManager {
         this.data = {};
         this.directory = directory;
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield fs.mkdir(this.directory);
-            }
-            catch (e) { }
-        });
+    async init() {
+        try {
+            await fs.mkdir(this.directory);
+        }
+        catch (e) { }
     }
-    saveData(hash, object) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield fs.mkdir(this.directory);
-            }
-            catch (e) { }
-            this.data[hash] = object;
-            const cpy = object.serialize();
-            yield fs.writeFile(this.directory + "/" + hash + ".json", JSON.stringify(cpy));
-        });
+    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));
     }
-    removeData(hash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const paymentHash = hash;
-            try {
-                if (this.data[paymentHash] != null)
-                    delete this.data[paymentHash];
-                yield fs.rm(this.directory + "/" + paymentHash + ".json");
-            }
-            catch (e) {
-                console.error(e);
-            }
-        });
+    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) {
+            console.error(e);
+        }
     }
-    loadData(type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let files;
-            try {
-                files = yield fs.readdir(this.directory);
-            }
-            catch (e) {
-                console.error(e);
-                return [];
-            }
-            const arr = [];
-            for (let file of files) {
-                const paymentHash = file.split(".")[0];
-                const result = yield 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;
-        });
+    async loadData(type) {
+        let files;
+        try {
+            files = await fs.readdir(this.directory);
+        }
+        catch (e) {
+            console.error(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;

package/dist/swaps/FromBtcBaseSwap.d.ts

@@ -1,16 +1,15 @@
 import { SwapData } from "@atomiqlabs/base";
 import { SwapHandlerSwap } from "./SwapHandlerSwap";
-import * as BN from "bn.js";
 export declare abstract class FromBtcBaseSwap<T extends SwapData, S = any> extends SwapHandlerSwap<T, S> {
-    amount: BN;
-    protected constructor(chainIdentifier: string, amount: BN, swapFee: BN, swapFeeInToken: BN);
+    amount: bigint;
+    protected constructor(chainIdentifier: string, amount: bigint, swapFee: bigint, swapFeeInToken: bigint);
     protected constructor(obj: any);
-    getInputAmount(): BN;
-    getTotalInputAmount(): BN;
-    getOutputAmount(): BN;
+    getInputAmount(): bigint;
+    getTotalInputAmount(): bigint;
+    getOutputAmount(): bigint;
     getSwapFee(): {
-        inInputToken: BN;
-        inOutputToken: BN;
+        inInputToken: bigint;
+        inOutputToken: bigint;
     };
     serialize(): any;
 }

package/dist/swaps/FromBtcBaseSwap.js

@@ -2,12 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcBaseSwap = void 0;
 const SwapHandlerSwap_1 = require("./SwapHandlerSwap");
-const BN = require("bn.js");
 const Utils_1 = require("../utils/Utils");
 class FromBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
     constructor(obj, amount, swapFee, swapFeeInToken) {
         super(obj, swapFee, swapFeeInToken);
-        if (typeof (obj) === "string" && BN.isBN(amount) && BN.isBN(swapFee) && BN.isBN(swapFeeInToken)) {
+        if (typeof (obj) === "string" && typeof (amount) === "bigint" && typeof (swapFee) === "bigint" && typeof (swapFeeInToken) === "bigint") {
             this.amount = amount;
         }
         else {
@@ -16,7 +15,7 @@ class FromBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
     }
     ;
     getInputAmount() {
-        return this.getTotalInputAmount().sub(this.getSwapFee().inInputToken);
+        return this.getTotalInputAmount() - this.getSwapFee().inInputToken;
     }
     getTotalInputAmount() {
         return this.amount;