@atomiqlabs/lp-lib 15.0.13 → 16.0.0

package/src/plugins/PluginManager.ts

@@ -167,7 +167,7 @@ export class PluginManager {
     }
 
     static async onHandlePostFromBtcQuote(
-        swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV,
+        swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV | SwapHandlerType.FROM_BTCLN_AUTO,
         request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>,
         requestedAmount: {input: boolean, amount: bigint, token: string, pricePrefetch?: Promise<bigint>},
         chainIdentifier: string,
@@ -198,7 +198,7 @@ export class PluginManager {
     }
 
     static async onHandlePreFromBtcQuote(
-        swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV,
+        swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV | SwapHandlerType.FROM_BTCLN_AUTO,
         request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>,
         requestedAmount: {input: boolean, amount: bigint, token: string},
         chainIdentifier: string,

package/src/storagemanager/IntermediaryStorageManager.ts

@@ -1,6 +1,8 @@
 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> {
 
@@ -9,9 +11,11 @@ export class IntermediaryStorageManager<T extends StorageObject> implements IInt
     private data: {
         [key: string]: T
     } = {};
+    private logger: LoggerType;
 
     constructor(directory: string) {
         this.directory = directory;
+        this.logger = getLogger("IntermediaryStorageManager("+directory+"): ");
     }
 
     async init(): Promise<void> {
@@ -82,18 +86,23 @@ export class IntermediaryStorageManager<T extends StorageObject> implements IInt
             if(this.data[identifier]!=null) delete this.data[identifier];
             await fs.rm(this.directory+"/"+identifier+".json");
         } catch (e) {
-            console.error(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) {
-            console.error(e);
+            this.logger.error("loadData(): Error when checking directory: ", e);
             return;
         }
 

package/src/storagemanager/StorageManager.ts

@@ -1,5 +1,7 @@
 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> {
 
@@ -8,8 +10,11 @@ export class StorageManager<T extends StorageObject> implements IStorageManager<
         [key: string]: T
     } = {};
 
+    private logger: LoggerType;
+
     constructor(directory: string) {
         this.directory = directory;
+        this.logger = getLogger("StorageManager("+directory+"): ");
     }
 
     async init(): Promise<void> {
@@ -38,16 +43,21 @@ export class StorageManager<T extends StorageObject> implements IStorageManager<
             if(this.data[paymentHash]!=null) delete this.data[paymentHash];
             await fs.rm(this.directory+"/"+paymentHash+".json");
         } catch (e) {
-            console.error(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) {
-            console.error(e);
+            this.logger.error("loadData(): Error when checking directory: ", e);
             return [];
         }
 

package/src/swaps/SwapHandler.ts

@@ -8,6 +8,7 @@ import {SwapHandlerSwap} from "./SwapHandlerSwap";
 import {PluginManager} from "../plugins/PluginManager";
 import {IIntermediaryStorage} from "../storage/IIntermediaryStorage";
 import {IParamReader} from "../utils/paramcoders/IParamReader";
+import {getLogger, LoggerType} from "../utils/Utils";
 
 export enum SwapHandlerType {
     TO_BTC = "TO_BTC",
@@ -16,7 +17,8 @@ export enum SwapHandlerType {
     FROM_BTCLN = "FROM_BTCLN",
     FROM_BTCLN_TRUSTED = "FROM_BTCLN_TRUSTED",
     FROM_BTC_TRUSTED = "FROM_BTC_TRUSTED",
-    FROM_BTC_SPV = "FROM_BTC_SPV"
+    FROM_BTC_SPV = "FROM_BTC_SPV",
+    FROM_BTCLN_AUTO = "FROM_BTCLN_AUTO"
 }
 
 export type SwapHandlerInfoType = {
@@ -24,7 +26,6 @@ export type SwapHandlerInfoType = {
     swapBaseFee: number,
     min: number,
     max: number,
-    tokens: string[],
     chainTokens: {[chainId: string]: string[]};
     data?: any,
 };
@@ -46,8 +47,7 @@ export type SwapBaseConfig = {
 export type MultichainData = {
     chains: {
         [identifier: string]: ChainData
-    },
-    default: string
+    }
 };
 
 export type ChainData<T extends ChainType = ChainType> = {
@@ -85,12 +85,7 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHandlerSwap
 
     abstract config: SwapBaseConfig;
 
-    logger = {
-        debug: (msg: string, ...args: any) => console.debug("SwapHandler("+this.type+"): "+msg, ...args),
-        info: (msg: string, ...args: any) => console.info("SwapHandler("+this.type+"): "+msg, ...args),
-        warn: (msg: string, ...args: any) => console.warn("SwapHandler("+this.type+"): "+msg, ...args),
-        error: (msg: string, ...args: any) => console.error("SwapHandler("+this.type+"): "+msg, ...args)
-    };
+    logger: LoggerType = getLogger(() => "SwapHandler("+this.type+"): ");
 
     protected swapLogger = {
         debug: (swap: SwapHandlerSwap, msg: string, ...args: any) => this.logger.debug(swap.getIdentifier()+": "+msg, ...args),
@@ -107,7 +102,6 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHandlerSwap
     ) {
         this.storageManager = storageDirectory;
         this.chains = chainsData;
-        if(this.chains.chains[this.chains.default]==null) throw new Error("Invalid default chain specified");
         this.path = path;
         this.swapPricing = swapPricing;
         this.allowedTokens = {};
@@ -116,10 +110,6 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHandlerSwap
         }
     }
 
-    protected getDefaultChain(): ChainData {
-        return this.chains.chains[this.chains.default];
-    }
-
     protected getChain(identifier: string): ChainData {
         if(this.chains.chains[identifier]==null)
             throw {
@@ -137,7 +127,7 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHandlerSwap
     async startWatchdog() {
         let rerun: () => Promise<void>;
         rerun = async () => {
-            await this.processPastSwaps().catch( e => console.error(e));
+            await this.processPastSwaps().catch( e => this.logger.error("startWatchdog(): Error when processing past swaps: ", e));
             setTimeout(rerun, this.config.swapCheckInterval);
         };
         await rerun();
@@ -268,7 +258,6 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHandlerSwap
             min: Number(this.config.min),
             max: Number(this.config.max),
             data: this.getInfoData(),
-            tokens: Array.from<string>(this.allowedTokens[this.chains.default]),
             chainTokens
         };
     }

package/src/swaps/assertions/FromBtcAmountAssertions.ts

@@ -3,7 +3,7 @@ import {FromBtcRequestType} from "../escrow/frombtc_abstract/FromBtcAbs";
 import {FromBtcLnTrustedRequestType} from "../trusted/frombtcln_trusted/FromBtcLnTrusted";
 import {PluginManager} from "../../plugins/PluginManager";
 import {isPluginQuote, isQuoteSetFees} from "../../plugins/IPlugin";
-import {RequestData, SwapHandlerType} from "../SwapHandler";
+import {RequestData, SwapHandler, SwapHandlerType} from "../SwapHandler";
 import {AmountAssertions, AmountAssertionsConfig} from "./AmountAssertions";
 import {ISwapPrice} from "../../prices/ISwapPrice";
 import {FromBtcTrustedRequestType} from "../trusted/frombtc_trusted/FromBtcTrusted";
@@ -32,7 +32,7 @@ export class FromBtcAmountAssertions extends AmountAssertions {
      * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
      */
     async preCheckFromBtcAmounts(
-        swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV,
+        swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV | SwapHandlerType.FROM_BTCLN_AUTO,
         request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>,
         requestedAmount: {input: boolean, amount: bigint, token: string},
         gasAmount?: {input: false, amount: bigint, token: string}
@@ -94,7 +94,7 @@ export class FromBtcAmountAssertions extends AmountAssertions {
      * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
      */
     async checkFromBtcAmount(
-        swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV,
+        swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV | SwapHandlerType.FROM_BTCLN_AUTO,
         request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>,
         requestedAmount: {input: boolean, amount: bigint, token: string, pricePrefetch?: Promise<bigint>},
         fees: {baseFee: bigint, feePPM: bigint},
@@ -155,18 +155,27 @@ export class FromBtcAmountAssertions extends AmountAssertions {
         }
 
         let amountBDgas: bigint = 0n;
+        let gasSwapFee: bigint = 0n;
         if(gasTokenAmount!=null) {
             amountBDgas = await this.swapPricing.getToBtcSwapAmount(gasTokenAmount.amount, gasTokenAmount.token, chainIdentifier, true, gasTokenAmount.pricePrefetch);
+            signal.throwIfAborted();
+            const denominator = (1000000n - fees.feePPM);
+            const _amountBDgas = (amountBDgas * 1000000n + denominator - 1n) / denominator;
+            gasSwapFee = _amountBDgas - amountBDgas;
+            amountBDgas = _amountBDgas;
         }
 
         let amountBD: bigint;
+        let swapFee: bigint;
         if(!requestedAmount.input) {
             amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
             signal.throwIfAborted();
 
             // amt = (amt+base_fee)/(1-fee)
-            amountBD = (amountBD + fees.baseFee) * 1000000n / (1000000n - fees.feePPM);
-            amountBDgas = amountBDgas * 1000000n / (1000000n - fees.feePPM);
+            const denominator = (1000000n - fees.feePPM);
+            const _amountBD = ((amountBD + fees.baseFee) * 1000000n + denominator - 1n) / denominator;
+            swapFee = _amountBD - amountBD;
+            amountBD = _amountBD;
 
             const tooLow = amountBD < (this.config.min * 95n / 100n);
             const tooHigh = amountBD > (this.config.max * 105n / 100n);
@@ -191,6 +200,7 @@ export class FromBtcAmountAssertions extends AmountAssertions {
         } else {
             this.checkBtcAmountInBounds(requestedAmount.amount);
             amountBD = requestedAmount.amount - amountBDgas;
+            swapFee = fees.baseFee + ((amountBD * fees.feePPM + 999_999n) / 1000000n);
             if(amountBD < 0n) {
                 throw {
                     code: 20003,
@@ -203,11 +213,9 @@ export class FromBtcAmountAssertions extends AmountAssertions {
             }
         }
 
-        const swapFee = fees.baseFee + (amountBD * fees.feePPM / 1000000n);
         const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(swapFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch);
         signal.throwIfAborted();
 
-        const gasSwapFee = ((amountBDgas * fees.feePPM) + 999999n) / 1000000n;
         const gasSwapFeeInToken = gasTokenAmount==null ?
             0n :
             await this.swapPricing.getFromBtcSwapAmount(gasSwapFee, gasTokenAmount.token, chainIdentifier, true, gasTokenAmount.pricePrefetch);
@@ -217,7 +225,7 @@ export class FromBtcAmountAssertions extends AmountAssertions {
         if(!requestedAmount.input) {
             totalInToken = requestedAmount.amount;
         } else {
-            totalInToken = await this.swapPricing.getFromBtcSwapAmount(amountBD - swapFee - gasSwapFee, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
+            totalInToken = await this.swapPricing.getFromBtcSwapAmount(amountBD - swapFee, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
             signal.throwIfAborted();
         }
 

package/src/swaps/escrow/EscrowHandlerSwap.ts

@@ -55,14 +55,14 @@ export abstract class EscrowHandlerSwap<T extends SwapData = SwapData, S = any>
      * Returns the escrow hash - i.e. hash of the escrow data
      */
     getEscrowHash(): string {
-        return this.data.getEscrowHash();
+        return this.data?.getEscrowHash();
     }
 
     /**
      * Returns the claim data hash - i.e. hash passed to the claim handler
      */
     getClaimHash(): string {
-        return this.data.getClaimHash();
+        return this.data?.getClaimHash();
     }
 
     /**

package/src/swaps/escrow/FromBtcBaseSwapHandler.ts

@@ -84,12 +84,12 @@ export abstract class FromBtcBaseSwapHandler<V extends FromBtcBaseSwap<SwapData,
         abortController: AbortController
     ): Promise<bigint> {
         //Solana workaround
-        const {swapContract, chainInterface} = this.getChain(chainIdentifier);
+        const {swapContract, chainInterface, signer} = this.getChain(chainIdentifier);
         let feeResult: bigint;
         const gasToken = chainInterface.getNativeCurrencyAddress();
         if (swapContract.getRawRefundFee != null) {
             try {
-                feeResult = await swapContract.getRawRefundFee(dummySwapData);
+                feeResult = await swapContract.getRawRefundFee(signer.getAddress(), dummySwapData);
             } catch (e) {
                 this.logger.error("getBaseSecurityDepositPrefetch(): pre-fetch error: ", e);
                 abortController.abort(e);
@@ -97,7 +97,7 @@ export abstract class FromBtcBaseSwapHandler<V extends FromBtcBaseSwap<SwapData,
             }
         } else {
             try {
-                feeResult = await swapContract.getRefundFee(dummySwapData);
+                feeResult = await swapContract.getRefundFee(signer.getAddress(), dummySwapData);
             } catch (e1) {
                 this.logger.error("getBaseSecurityDepositPrefetch(): pre-fetch error: ", e1);
                 abortController.abort(e1);
@@ -116,11 +116,12 @@ export abstract class FromBtcBaseSwapHandler<V extends FromBtcBaseSwap<SwapData,
      * @param chainIdentifier
      * @param useToken
      * @param abortController
+     * @param inContract
      */
-    protected async getBalancePrefetch(chainIdentifier: string, useToken: string, abortController: AbortController): Promise<bigint> {
+    protected async getBalancePrefetch(chainIdentifier: string, useToken: string, abortController: AbortController, inContract: boolean = true): Promise<bigint> {
         const {swapContract, signer} = this.getChain(chainIdentifier);
         try {
-            return await swapContract.getBalance(signer.getAddress(), useToken, true);
+            return await swapContract.getBalance(signer.getAddress(), useToken, inContract);
         } catch (e) {
             this.logger.error("getBalancePrefetch(): balancePrefetch error: ", e);
             abortController.abort(e);
@@ -137,6 +138,8 @@ export abstract class FromBtcBaseSwapHandler<V extends FromBtcBaseSwap<SwapData,
      * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
      */
     protected async checkBalance(totalInToken: bigint, balancePrefetch: Promise<bigint>, signal: AbortSignal | null): Promise<void> {
+        if(totalInToken===0n) return;
+
         const balance = await balancePrefetch;
         if(signal!=null) signal.throwIfAborted();
 

package/src/swaps/escrow/frombtc_abstract/FromBtcAbs.ts

@@ -254,7 +254,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
                 times: {[key: string]: number},
             } = {request: {}, times: {}};
 
-            const chainIdentifier = req.query.chain as string ?? this.chains.default;
+            const chainIdentifier = req.query.chain as string;
             const {swapContract, signer, chainInterface} = this.getChain(chainIdentifier);
             const depositToken = req.query.depositToken as string ?? chainInterface.getNativeCurrencyAddress();
             this.checkAllowedDepositToken(chainIdentifier, depositToken);
@@ -279,7 +279,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             const parsedBody: FromBtcRequestType = await req.paramReader.getParams({
                 address: (val: string) => val!=null &&
                         typeof(val)==="string" &&
-                        chainInterface.isValidAddress(val) ? val : null,
+                        chainInterface.isValidAddress(val, true) ? val : null,
                 amount: FieldTypeEnum.BigInt,
                 token: (val: string) => val!=null &&
                         typeof(val)==="string" &&

package/src/swaps/escrow/frombtcln_abstract/FromBtcLnAbs.ts

@@ -522,17 +522,16 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
         };
 
         const arr = invoice.description.split("-");
-        let chainIdentifier: string;
-        let address: string;
-        if(arr.length>1) {
-            chainIdentifier = arr[0];
-            address = arr[1];
-        } else {
-            chainIdentifier = this.chains.default;
-            address = invoice.description;
-        }
+        if(arr.length<2) throw {
+            _httpStatus: 200,
+            code: 10001,
+            msg: "Invoice expired/canceled"
+        };
+        const chainIdentifier = arr[0];
+        const address = arr[1];
+
         const {chainInterface} = this.getChain(chainIdentifier);
-        if(!chainInterface.isValidAddress(address)) throw {
+        if(!chainInterface.isValidAddress(address, true)) throw {
             _httpStatus: 200,
             code: 10001,
             msg: "Invoice expired/canceled"
@@ -573,7 +572,7 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
                 times: {[key: string]: number}
             } = {request: {}, times: {}};
 
-            const chainIdentifier = req.query.chain as string ?? this.chains.default;
+            const chainIdentifier = req.query.chain as string;
             const {swapContract, signer, chainInterface} = this.getChain(chainIdentifier);
             const depositToken = req.query.depositToken as string ?? chainInterface.getNativeCurrencyAddress();
             this.checkAllowedDepositToken(chainIdentifier, depositToken);
@@ -595,7 +594,7 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
             const parsedBody: FromBtcLnRequestType = await req.paramReader.getParams({
                 address: (val: string) => val!=null &&
                             typeof(val)==="string" &&
-                            chainInterface.isValidAddress(val) ? val : null,
+                            chainInterface.isValidAddress(val, true) ? val : null,
                 paymentHash: (val: string) => val!=null &&
                             typeof(val)==="string" &&
                             val.length===64 &&

package/src/swaps/escrow/frombtcln_abstract/FromBtcLnSwapAbs.ts

@@ -114,6 +114,10 @@ export class FromBtcLnSwapAbs<T extends SwapData = SwapData> extends FromBtcBase
         return this.totalTokens;
     }
 
+    getClaimHash(): string {
+        return this.claimHash;
+    }
+
     getIdentifierHash(): string {
         return this.lnPaymentHash;
     }