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

package/src/plugins/IPlugin.ts

@@ -8,7 +8,6 @@ import {
     ToBtcRequestType
 } from "..";
 import {SwapHandlerSwap} from "../swaps/SwapHandlerSwap";
-import * as BN from "bn.js";
 import {Command} from "@atomiqlabs/server-base";
 import {FromBtcLnTrustedRequestType} from "../swaps/frombtcln_trusted/FromBtcLnTrusted";
 import {IBitcoinWallet} from "../wallets/IBitcoinWallet";
@@ -25,52 +24,52 @@ export function isQuoteThrow(obj: any): obj is QuoteThrow {
 
 export type QuoteSetFees = {
     type: "fees"
-    baseFee?: BN,
-    feePPM?: BN
+    baseFee?: bigint,
+    feePPM?: bigint
 };
 
 export function isQuoteSetFees(obj: any): obj is QuoteSetFees {
     return obj.type==="fees" &&
-        (obj.baseFee==null || BN.isBN(obj.baseFee)) &&
-        (obj.feePPM==null || BN.isBN(obj.feePPM));
+        (obj.baseFee==null || typeof(obj.baseFee) === "bigint") &&
+        (obj.feePPM==null || typeof(obj.feePPM) === "bigint");
 }
 
 export type QuoteAmountTooLow = {
     type: "low",
-    data: { min: BN, max: BN }
+    data: { min: bigint, max: bigint }
 }
 
 export function isQuoteAmountTooLow(obj: any): obj is QuoteAmountTooLow {
-    return obj.type==="low" && typeof(obj.data)==="object" && BN.isBN(obj.data.min) && BN.isBN(obj.data.max);
+    return obj.type==="low" && typeof(obj.data)==="object" && typeof(obj.data.min)==="bigint" && typeof(obj.data.max)==="bigint";
 }
 
 export type QuoteAmountTooHigh = {
     type: "high",
-    data: { min: BN, max: BN }
+    data: { min: bigint, max: bigint }
 }
 
 export function isQuoteAmountTooHigh(obj: any): obj is QuoteAmountTooHigh {
-    return obj.type==="high" && typeof(obj.data)==="object" && BN.isBN(obj.data.min) && BN.isBN(obj.data.max);
+    return obj.type==="high" && typeof(obj.data)==="object" && typeof(obj.data.min)==="bigint" && typeof(obj.data.max)==="bigint";
 }
 
 export type PluginQuote = {
     type: "success",
-    amount: {input: boolean, amount: BN},
-    swapFee: { inInputTokens: BN, inOutputTokens: BN }
+    amount: {input: boolean, amount: bigint},
+    swapFee: { inInputTokens: bigint, inOutputTokens: bigint }
 };
 
 export function isPluginQuote(obj: any): obj is PluginQuote {
     return obj.type==="success" &&
-        typeof(obj.amount)==="object" && typeof(obj.amount.input)==="boolean" && BN.isBN(obj.amount.amount) &&
-        typeof(obj.swapFee)==="object" && BN.isBN(obj.swapFee.inInputTokens) && BN.isBN(obj.swapFee.inOutputTokens);
+        typeof(obj.amount)==="object" && typeof(obj.amount.input)==="boolean" && typeof(obj.amount.amount)==="bigint" &&
+        typeof(obj.swapFee)==="object" && typeof(obj.swapFee.inInputTokens)==="bigint" && typeof(obj.swapFee.inOutputTokens)==="bigint";
 }
 
 export type ToBtcPluginQuote = PluginQuote & {
-    networkFee: { inInputTokens: BN, inOutputTokens: BN }
+    networkFee: { inInputTokens: bigint, inOutputTokens: bigint }
 }
 
 export function isToBtcPluginQuote(obj: any): obj is ToBtcPluginQuote {
-    return typeof(obj.networkFee)==="object" && BN.isBN(obj.networkFee.inInputTokens) && BN.isBN(obj.networkFee.inOutputTokens) &&
+    return typeof(obj.networkFee)==="object" && typeof(obj.networkFee.inInputTokens)==="bigint" && typeof(obj.networkFee.inOutputTokens)==="bigint" &&
         isPluginQuote(obj);
 }
 
@@ -113,38 +112,38 @@ export interface IPlugin {
 
     onHandlePreFromBtcQuote?(
         request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
-        requestedAmount: {input: boolean, amount: BN},
+        requestedAmount: {input: boolean, amount: bigint},
         chainIdentifier: string,
         token: string,
-        constraints: {minInBtc: BN, maxInBtc: BN},
-        fees: {baseFeeInBtc: BN, feePPM: BN}
+        constraints: {minInBtc: bigint, maxInBtc: bigint},
+        fees: {baseFeeInBtc: bigint, feePPM: bigint}
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh>;
     onHandlePostFromBtcQuote?(
         request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
-        requestedAmount: {input: boolean, amount: BN},
+        requestedAmount: {input: boolean, amount: bigint},
         chainIdentifier: string,
         token: string,
-        constraints: {minInBtc: BN, maxInBtc: BN},
-        fees: {baseFeeInBtc: BN, feePPM: BN},
-        pricePrefetchPromise?: Promise<BN> | null
+        constraints: {minInBtc: bigint, maxInBtc: bigint},
+        fees: {baseFeeInBtc: bigint, feePPM: bigint},
+        pricePrefetchPromise?: Promise<bigint> | null
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | PluginQuote>;
 
     onHandlePreToBtcQuote?(
         request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: BN},
+        requestedAmount: {input: boolean, amount: bigint},
         chainIdentifier: string,
         token: string,
-        constraints: {minInBtc: BN, maxInBtc: BN},
-        fees: {baseFeeInBtc: BN, feePPM: BN}
+        constraints: {minInBtc: bigint, maxInBtc: bigint},
+        fees: {baseFeeInBtc: bigint, feePPM: bigint}
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh>;
     onHandlePostToBtcQuote?(
         request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: BN},
+        requestedAmount: {input: boolean, amount: bigint},
         chainIdentifier: string,
         token: string,
-        constraints: {minInBtc: BN, maxInBtc: BN},
-        fees: {baseFeeInBtc: BN, feePPM: BN, networkFeeGetter: (amount: BN) => Promise<BN>},
-        pricePrefetchPromise?: Promise<BN> | null
+        constraints: {minInBtc: bigint, maxInBtc: bigint},
+        fees: {baseFeeInBtc: bigint, feePPM: bigint, networkFeeGetter: (amount: bigint) => Promise<bigint>},
+        pricePrefetchPromise?: Promise<bigint> | null
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | ToBtcPluginQuote>;
 
     /**

package/src/plugins/PluginManager.ts

@@ -16,7 +16,6 @@ import {
     ToBtcRequestType
 } from "..";
 import {SwapHandlerSwap} from "../swaps/SwapHandlerSwap";
-import * as BN from "bn.js";
 import * as fs from "fs";
 import {getLogger} from "../utils/Utils";
 import {FromBtcLnTrustedRequestType} from "../swaps/frombtcln_trusted/FromBtcLnTrusted";
@@ -31,15 +30,15 @@ export type FailSwapResponse = {
 
 export type FeeSwapResponse = {
     type: "fee",
-    baseFee: BN,
-    feePPM: BN
+    baseFee: bigint,
+    feePPM: bigint
 };
 
 export type AmountAndFeeSwapResponse = {
     type: "amountAndFee",
-    baseFee?: BN,
-    feePPM?: BN,
-    amount: BN
+    baseFee?: bigint,
+    feePPM?: bigint,
+    amount: bigint
 };
 
 export type SwapResponse = FailSwapResponse | FeeSwapResponse | AmountAndFeeSwapResponse;
@@ -168,12 +167,12 @@ export class PluginManager {
 
     static async onHandlePostFromBtcQuote(
         request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
-        requestedAmount: {input: boolean, amount: BN},
+        requestedAmount: {input: boolean, amount: bigint},
         chainIdentifier: string,
         token: string,
-        constraints: {minInBtc: BN, maxInBtc: BN},
-        fees: {baseFeeInBtc: BN, feePPM: BN},
-        pricePrefetchPromise?: Promise<BN> | null
+        constraints: {minInBtc: bigint, maxInBtc: bigint},
+        fees: {baseFeeInBtc: bigint, feePPM: bigint},
+        pricePrefetchPromise?: Promise<bigint> | null
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | PluginQuote> {
         for(let plugin of PluginManager.plugins.values()) {
             try {
@@ -199,11 +198,11 @@ export class PluginManager {
 
     static async onHandlePreFromBtcQuote(
         request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
-        requestedAmount: {input: boolean, amount: BN},
+        requestedAmount: {input: boolean, amount: bigint},
         chainIdentifier: string,
         token: string,
-        constraints: {minInBtc: BN, maxInBtc: BN},
-        fees: {baseFeeInBtc: BN, feePPM: BN}
+        constraints: {minInBtc: bigint, maxInBtc: bigint},
+        fees: {baseFeeInBtc: bigint, feePPM: bigint}
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh> {
         for(let plugin of PluginManager.plugins.values()) {
             try {
@@ -223,14 +222,14 @@ export class PluginManager {
         return null;
     }
 
-    static async onHandlePostToBtcQuote<T extends {networkFee: BN}>(
+    static async onHandlePostToBtcQuote<T extends {networkFee: bigint}>(
         request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: BN},
+        requestedAmount: {input: boolean, amount: bigint},
         chainIdentifier: string,
         token: string,
-        constraints: {minInBtc: BN, maxInBtc: BN},
-        fees: {baseFeeInBtc: BN, feePPM: BN, networkFeeGetter: (amount: BN) => Promise<T>},
-        pricePrefetchPromise?: Promise<BN> | null
+        constraints: {minInBtc: bigint, maxInBtc: bigint},
+        fees: {baseFeeInBtc: bigint, feePPM: bigint, networkFeeGetter: (amount: bigint) => Promise<T>},
+        pricePrefetchPromise?: Promise<bigint> | null
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | (ToBtcPluginQuote & {networkFeeData: T})> {
         for(let plugin of PluginManager.plugins.values()) {
             try {
@@ -239,7 +238,7 @@ export class PluginManager {
                     const result = await plugin.onHandlePostToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, {
                         baseFeeInBtc: fees.baseFeeInBtc,
                         feePPM: fees.feePPM,
-                        networkFeeGetter: async (amount: BN) => {
+                        networkFeeGetter: async (amount: bigint) => {
                             networkFeeData = await fees.networkFeeGetter(amount);
                             return networkFeeData.networkFee;
                         }
@@ -267,11 +266,11 @@ export class PluginManager {
 
     static async onHandlePreToBtcQuote(
         request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: BN},
+        requestedAmount: {input: boolean, amount: bigint},
         chainIdentifier: string,
         token: string,
-        constraints: {minInBtc: BN, maxInBtc: BN},
-        fees: {baseFeeInBtc: BN, feePPM: BN}
+        constraints: {minInBtc: bigint, maxInBtc: bigint},
+        fees: {baseFeeInBtc: bigint, feePPM: bigint}
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh> {
         for(let plugin of PluginManager.plugins.values()) {
             try {

package/src/prices/BinanceSwapPrice.ts

@@ -1,4 +1,3 @@
-import * as BN from "bn.js";
 import {ISwapPrice} from "../swaps/ISwapPrice";
 
 const CACHE_DURATION = 15000;
@@ -59,11 +58,11 @@ export class BinanceSwapPrice extends ISwapPrice<{ pair: string, decimals: numbe
         return parseFloat(jsonBody.price);
     }
 
-    async getPrice(tokenData: {pair: string}): Promise<BN> {
+    async getPrice(tokenData: {pair: string}): Promise<bigint> {
         const pair = tokenData.pair;
         if(pair.startsWith("$fixed-")) {
             const amt: number = parseFloat(pair.substring(7));
-            return new BN(Math.floor(amt*1000000));
+            return BigInt(Math.floor(amt*1000000));
         }
 
         const arr = pair.split(";");
@@ -109,6 +108,6 @@ export class BinanceSwapPrice extends ISwapPrice<{ pair: string, decimals: numbe
             };
         }
 
-        return new BN(Math.floor(this.cache[pair].price*100000000000000));
+        return BigInt(Math.floor(this.cache[pair].price*100000000000000));
     }
 }

package/src/prices/CoinGeckoSwapPrice.ts

@@ -1,4 +1,3 @@
-import * as BN from "bn.js";
 import {ISwapPrice} from "../swaps/ISwapPrice";
 
 const CACHE_DURATION = 15000;
@@ -17,7 +16,7 @@ export class CoinGeckoSwapPrice extends ISwapPrice<{coinId: string, decimals: nu
     url: string;
     cache: {
         [coinId: string]: {
-            price: BN,
+            price: bigint,
             expiry: number
         }
     } = {};
@@ -44,11 +43,11 @@ export class CoinGeckoSwapPrice extends ISwapPrice<{coinId: string, decimals: nu
      *
      * @param coin
      */
-    async getPrice(coin: {coinId: string}): Promise<BN> {
+    async getPrice(coin: {coinId: string}): Promise<bigint> {
         const coinId = coin.coinId;
         if(coinId.startsWith("$fixed-")) {
             const amt: number = parseFloat(coinId.substring(7));
-            return new BN(Math.floor(amt*1000));
+            return BigInt(Math.floor(amt*1000));
         }
 
         const cachedValue = this.cache[coinId];
@@ -75,7 +74,7 @@ export class CoinGeckoSwapPrice extends ISwapPrice<{coinId: string, decimals: nu
 
         const amt: number = jsonBody[coinId].sats;
 
-        const result = new BN(amt*1000);
+        const result = BigInt(Math.floor(amt*1000));
 
         this.cache[coinId] = {
             price: result,

package/src/prices/OKXSwapPrice.ts

@@ -1,4 +1,3 @@
-import * as BN from "bn.js";
 import {ISwapPrice} from "../swaps/ISwapPrice";
 
 const CACHE_DURATION = 15000;
@@ -59,11 +58,11 @@ export class OKXSwapPrice extends ISwapPrice<{ pair: string, decimals: number }>
         return parseFloat(jsonBody.data[0].idxPx);
     }
 
-    async getPrice(tokenData: {pair: string}): Promise<BN> {
+    async getPrice(tokenData: {pair: string}): Promise<bigint> {
         const pair = tokenData.pair;
         if(pair.startsWith("$fixed-")) {
             const amt: number = parseFloat(pair.substring(7));
-            return new BN(Math.floor(amt*1000000));
+            return BigInt(Math.floor(amt*1000000));
         }
 
         const arr = pair.split(";");
@@ -109,6 +108,6 @@ export class OKXSwapPrice extends ISwapPrice<{ pair: string, decimals: number }>
             };
         }
 
-        return new BN(Math.floor(this.cache[pair].price*100000000000000));
+        return BigInt(Math.floor(this.cache[pair].price*100000000000000));
     }
 }

package/src/storage/IIntermediaryStorage.ts

@@ -1,5 +1,4 @@
 import {StorageObject} from "@atomiqlabs/base";
-import * as BN from "bn.js";
 
 export type StorageQueryParam = {
     key: string,
@@ -11,11 +10,11 @@ export interface IIntermediaryStorage<T extends StorageObject> {
 
     init(): Promise<void>;
 
-    query(params: StorageQueryParam[]): Promise<T[]>;
+    query(params: StorageQueryParam[]): Promise<{hash: string, sequence: bigint, obj: 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>;
+    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,7 +1,6 @@
 import {StorageObject} from "@atomiqlabs/base";
 import * as fs from "fs/promises";
 import {IIntermediaryStorage, StorageQueryParam} from "../storage/IIntermediaryStorage";
-import * as BN from "bn.js";
 
 export class IntermediaryStorageManager<T extends StorageObject> implements IIntermediaryStorage<T> {
 
@@ -21,8 +20,9 @@ export class IntermediaryStorageManager<T extends StorageObject> implements IInt
         } catch (e) {}
     }
 
-    query(params: StorageQueryParam[]): Promise<T[]> {
-        return Promise.resolve(Object.keys(this.data).map((val) => this.data[val]).filter((val) => {
+    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") {
@@ -45,16 +45,24 @@ export class IntermediaryStorageManager<T extends StorageObject> implements IInt
                 }
             }
             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: BN | null): Promise<T> {
-        return Promise.resolve(this.data[paymentHash+"_"+(sequence || new BN(0)).toString("hex", 8)]);
+    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: BN | null, object: T): Promise<void> {
+    async saveData(hash: string, sequence: bigint | null, object: T): Promise<void> {
 
-        const _sequence = (sequence || new BN(0)).toString("hex", 8);
+        const _sequence = (sequence || 0n).toString(16).padStart(16, "0");
 
         try {
             await fs.mkdir(this.directory)
@@ -68,8 +76,8 @@ export class IntermediaryStorageManager<T extends StorageObject> implements IInt
 
     }
 
-    async removeData(hash: string, sequence: BN | null): Promise<void> {
-        const identifier = hash+"_"+(sequence || new BN(0)).toString("hex", 8);
+    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");

package/src/swaps/FromBtcBaseSwap.ts

@@ -1,37 +1,36 @@
 import {SwapData} from "@atomiqlabs/base";
 import {SwapHandlerSwap} from "./SwapHandlerSwap";
-import * as BN from "bn.js";
 import {deserializeBN, serializeBN} from "../utils/Utils";
 
 export abstract class FromBtcBaseSwap<T extends SwapData, S = any> extends SwapHandlerSwap<T, S> {
 
-    amount: BN;
+    amount: bigint;
 
-    protected constructor(chainIdentifier: string, amount: BN, swapFee: BN, swapFeeInToken: BN);
+    protected constructor(chainIdentifier: string, amount: bigint, swapFee: bigint, swapFeeInToken: bigint);
     protected constructor(obj: any);
 
-    protected constructor(obj?: any | string, amount?: BN, swapFee?: BN, swapFeeInToken?: BN) {
+    protected constructor(obj?: any | string, amount?: bigint, swapFee?: bigint, swapFeeInToken?: bigint) {
         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 {
             this.amount = deserializeBN(obj.amount);
         }
     };
 
-    getInputAmount(): BN {
-        return this.getTotalInputAmount().sub(this.getSwapFee().inInputToken);
+    getInputAmount(): bigint {
+        return this.getTotalInputAmount() - this.getSwapFee().inInputToken;
     }
 
-    getTotalInputAmount(): BN {
+    getTotalInputAmount(): bigint {
         return this.amount;
     }
 
-    getOutputAmount(): BN {
+    getOutputAmount(): bigint {
         return this.data.getAmount();
     }
 
-    getSwapFee(): { inInputToken: BN; inOutputToken: BN } {
+    getSwapFee(): { inInputToken: bigint; inOutputToken: bigint } {
         return {inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken};
     }