@atomiqlabs/lp-lib 15.0.13 → 16.0.0

package/dist/index.d.ts

@@ -9,6 +9,8 @@ export * from "./swaps/escrow/frombtc_abstract/FromBtcAbs";
 export * from "./swaps/escrow/frombtc_abstract/FromBtcSwapAbs";
 export * from "./swaps/escrow/frombtcln_abstract/FromBtcLnAbs";
 export * from "./swaps/escrow/frombtcln_abstract/FromBtcLnSwapAbs";
+export * from "./swaps/escrow/frombtcln_autoinit/FromBtcLnAuto";
+export * from "./swaps/escrow/frombtcln_autoinit/FromBtcLnAutoSwap";
 export * from "./swaps/escrow/tobtc_abstract/ToBtcAbs";
 export * from "./swaps/escrow/tobtc_abstract/ToBtcSwapAbs";
 export * from "./swaps/escrow/tobtcln_abstract/ToBtcLnAbs";

package/dist/index.js

@@ -25,6 +25,8 @@ __exportStar(require("./swaps/escrow/frombtc_abstract/FromBtcAbs"), exports);
 __exportStar(require("./swaps/escrow/frombtc_abstract/FromBtcSwapAbs"), exports);
 __exportStar(require("./swaps/escrow/frombtcln_abstract/FromBtcLnAbs"), exports);
 __exportStar(require("./swaps/escrow/frombtcln_abstract/FromBtcLnSwapAbs"), exports);
+__exportStar(require("./swaps/escrow/frombtcln_autoinit/FromBtcLnAuto"), exports);
+__exportStar(require("./swaps/escrow/frombtcln_autoinit/FromBtcLnAutoSwap"), exports);
 __exportStar(require("./swaps/escrow/tobtc_abstract/ToBtcAbs"), exports);
 __exportStar(require("./swaps/escrow/tobtc_abstract/ToBtcSwapAbs"), exports);
 __exportStar(require("./swaps/escrow/tobtcln_abstract/ToBtcLnAbs"), exports);

package/dist/info/InfoHandler.js

@@ -47,11 +47,8 @@ class InfoHandler {
                     signature: await singleChain.swapContract.getDataSignature(singleChain.signer, envelopeBuffer)
                 };
             }
-            const defaults = chains[this.chainData.default];
             const response = {
                 envelope,
-                address: defaults.address,
-                signature: defaults.signature,
                 chains
             };
             res.status(200).json(response);

package/dist/plugins/IPlugin.d.ts

@@ -72,7 +72,7 @@ export interface IPlugin {
     onSwapStateChange?(swap: SwapHandlerSwap): Promise<void>;
     onSwapCreate?(swap: SwapHandlerSwap): Promise<void>;
     onSwapRemove?(swap: SwapHandlerSwap): Promise<void>;
-    onHandlePreFromBtcQuote?(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
+    onHandlePreFromBtcQuote?(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;
@@ -87,7 +87,7 @@ export interface IPlugin {
         amount: bigint;
         token: string;
     }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh>;
-    onHandlePostFromBtcQuote?(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
+    onHandlePostFromBtcQuote?(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;

package/dist/plugins/PluginManager.d.ts

@@ -41,7 +41,7 @@ export declare class PluginManager {
     static swapStateChange(swap: SwapHandlerSwap, oldState?: any): Promise<void>;
     static swapCreate(swap: SwapHandlerSwap): Promise<void>;
     static swapRemove(swap: SwapHandlerSwap): Promise<void>;
-    static onHandlePostFromBtcQuote(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
+    static onHandlePostFromBtcQuote(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;
@@ -58,7 +58,7 @@ export declare class PluginManager {
         token: string;
         pricePrefetch?: Promise<bigint>;
     }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | PluginQuote>;
-    static onHandlePreFromBtcQuote(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
+    static onHandlePreFromBtcQuote(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;

package/dist/storagemanager/IntermediaryStorageManager.d.ts

@@ -4,6 +4,7 @@ export declare class IntermediaryStorageManager<T extends StorageObject> impleme
     private readonly directory;
     private type;
     private data;
+    private logger;
     constructor(directory: string);
     init(): Promise<void>;
     query(params: StorageQueryParam[]): Promise<{

package/dist/storagemanager/IntermediaryStorageManager.js

@@ -2,10 +2,13 @@
 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 {
@@ -79,17 +82,21 @@ class IntermediaryStorageManager {
             await fs.rm(this.directory + "/" + identifier + ".json");
         }
         catch (e) {
-            console.error(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) {
-            console.error(e);
+            this.logger.error("loadData(): Error when checking directory: ", e);
             return;
         }
         for (let file of files) {

package/dist/storagemanager/StorageManager.d.ts

@@ -4,6 +4,7 @@ export declare class StorageManager<T extends StorageObject> implements IStorage
     data: {
         [key: string]: T;
     };
+    private logger;
     constructor(directory: string);
     init(): Promise<void>;
     saveData(hash: string, object: T): Promise<void>;

package/dist/storagemanager/StorageManager.js

@@ -2,10 +2,13 @@
 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 {
@@ -30,16 +33,20 @@ class StorageManager {
             await fs.rm(this.directory + "/" + paymentHash + ".json");
         }
         catch (e) {
-            console.error(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) {
-            console.error(e);
+            this.logger.error("loadData(): Error when checking directory: ", e);
             return [];
         }
         const arr = [];

package/dist/swaps/SwapHandler.d.ts

@@ -4,6 +4,7 @@ import { ChainType } from "@atomiqlabs/base";
 import { SwapHandlerSwap } from "./SwapHandlerSwap";
 import { IIntermediaryStorage } from "../storage/IIntermediaryStorage";
 import { IParamReader } from "../utils/paramcoders/IParamReader";
+import { LoggerType } from "../utils/Utils";
 export declare enum SwapHandlerType {
     TO_BTC = "TO_BTC",
     FROM_BTC = "FROM_BTC",
@@ -11,14 +12,14 @@ export declare 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 = {
     swapFeePPM: number;
     swapBaseFee: number;
     min: number;
     max: number;
-    tokens: string[];
     chainTokens: {
         [chainId: string]: string[];
     };
@@ -41,7 +42,6 @@ export type MultichainData = {
     chains: {
         [identifier: string]: ChainData;
     };
-    default: string;
 };
 export type ChainData<T extends ChainType = ChainType> = {
     signer: T["Signer"];
@@ -77,12 +77,7 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHan
     };
     readonly swapPricing: ISwapPrice;
     abstract config: SwapBaseConfig;
-    logger: {
-        debug: (msg: string, ...args: any) => void;
-        info: (msg: string, ...args: any) => void;
-        warn: (msg: string, ...args: any) => void;
-        error: (msg: string, ...args: any) => void;
-    };
+    logger: LoggerType;
     protected swapLogger: {
         debug: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
         info: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
@@ -90,7 +85,6 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHan
         error: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
     };
     protected constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chainsData: MultichainData, swapPricing: ISwapPrice);
-    protected getDefaultChain(): ChainData;
     protected getChain(identifier: string): ChainData;
     protected abstract processPastSwaps(): Promise<void>;
     /**

package/dist/swaps/SwapHandler.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwapHandler = exports.SwapHandlerType = void 0;
 const PluginManager_1 = require("../plugins/PluginManager");
+const Utils_1 = require("../utils/Utils");
 var SwapHandlerType;
 (function (SwapHandlerType) {
     SwapHandlerType["TO_BTC"] = "TO_BTC";
@@ -11,18 +12,14 @@ var SwapHandlerType;
     SwapHandlerType["FROM_BTCLN_TRUSTED"] = "FROM_BTCLN_TRUSTED";
     SwapHandlerType["FROM_BTC_TRUSTED"] = "FROM_BTC_TRUSTED";
     SwapHandlerType["FROM_BTC_SPV"] = "FROM_BTC_SPV";
+    SwapHandlerType["FROM_BTCLN_AUTO"] = "FROM_BTCLN_AUTO";
 })(SwapHandlerType = exports.SwapHandlerType || (exports.SwapHandlerType = {}));
 /**
  * An abstract class defining a singular swap service
  */
 class SwapHandler {
     constructor(storageDirectory, path, chainsData, swapPricing) {
-        this.logger = {
-            debug: (msg, ...args) => console.debug("SwapHandler(" + this.type + "): " + msg, ...args),
-            info: (msg, ...args) => console.info("SwapHandler(" + this.type + "): " + msg, ...args),
-            warn: (msg, ...args) => console.warn("SwapHandler(" + this.type + "): " + msg, ...args),
-            error: (msg, ...args) => console.error("SwapHandler(" + this.type + "): " + msg, ...args)
-        };
+        this.logger = (0, Utils_1.getLogger)(() => "SwapHandler(" + this.type + "): ");
         this.swapLogger = {
             debug: (swap, msg, ...args) => this.logger.debug(swap.getIdentifier() + ": " + msg, ...args),
             info: (swap, msg, ...args) => this.logger.info(swap.getIdentifier() + ": " + msg, ...args),
@@ -31,8 +28,6 @@ class SwapHandler {
         };
         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 = {};
@@ -40,9 +35,6 @@ class SwapHandler {
             this.allowedTokens[chainId] = new Set(chainsData.chains[chainId].allowedTokens);
         }
     }
-    getDefaultChain() {
-        return this.chains.chains[this.chains.default];
-    }
     getChain(identifier) {
         if (this.chains.chains[identifier] == null)
             throw {
@@ -57,7 +49,7 @@ class SwapHandler {
     async startWatchdog() {
         let rerun;
         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();
@@ -152,7 +144,6 @@ class SwapHandler {
             min: Number(this.config.min),
             max: Number(this.config.max),
             data: this.getInfoData(),
-            tokens: Array.from(this.allowedTokens[this.chains.default]),
             chainTokens
         };
     }

package/dist/swaps/assertions/FromBtcAmountAssertions.d.ts

@@ -23,7 +23,7 @@ export declare class FromBtcAmountAssertions extends AmountAssertions {
      * @param gasAmount
      * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
      */
-    preCheckFromBtcAmounts(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
+    preCheckFromBtcAmounts(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;
@@ -48,7 +48,7 @@ export declare class FromBtcAmountAssertions extends AmountAssertions {
      * @param gasTokenAmount
      * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
      */
-    checkFromBtcAmount(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
+    checkFromBtcAmount(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;

package/dist/swaps/assertions/FromBtcAmountAssertions.js

@@ -98,16 +98,25 @@ class FromBtcAmountAssertions extends AmountAssertions_1.AmountAssertions {
             }
         }
         let amountBDgas = 0n;
+        let gasSwapFee = 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;
+        let swapFee;
         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);
             if (tooLow || tooHigh) {
@@ -128,6 +137,7 @@ class FromBtcAmountAssertions extends AmountAssertions_1.AmountAssertions {
         else {
             this.checkBtcAmountInBounds(requestedAmount.amount);
             amountBD = requestedAmount.amount - amountBDgas;
+            swapFee = fees.baseFee + ((amountBD * fees.feePPM + 999999n) / 1000000n);
             if (amountBD < 0n) {
                 throw {
                     code: 20003,
@@ -139,10 +149,8 @@ class FromBtcAmountAssertions extends AmountAssertions_1.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);
@@ -152,7 +160,7 @@ class FromBtcAmountAssertions extends AmountAssertions_1.AmountAssertions {
             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();
         }
         return {

package/dist/swaps/escrow/EscrowHandlerSwap.js

@@ -41,13 +41,13 @@ class EscrowHandlerSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
      * Returns the escrow hash - i.e. hash of the escrow data
      */
     getEscrowHash() {
-        return this.data.getEscrowHash();
+        return this.data?.getEscrowHash();
     }
     /**
      * Returns the claim data hash - i.e. hash passed to the claim handler
      */
     getClaimHash() {
-        return this.data.getClaimHash();
+        return this.data?.getClaimHash();
     }
     /**
      * Returns the identification hash of the swap, usually claim data hash, but can be overriden, e.g. for

package/dist/swaps/escrow/FromBtcBaseSwapHandler.d.ts

@@ -44,8 +44,9 @@ export declare abstract class FromBtcBaseSwapHandler<V extends FromBtcBaseSwap<S
      * @param chainIdentifier
      * @param useToken
      * @param abortController
+     * @param inContract
      */
-    protected getBalancePrefetch(chainIdentifier: string, useToken: string, abortController: AbortController): Promise<bigint>;
+    protected getBalancePrefetch(chainIdentifier: string, useToken: string, abortController: AbortController, inContract?: boolean): Promise<bigint>;
     /**
      * Checks if we have enough balance of the token in the swap vault
      *

package/dist/swaps/escrow/FromBtcBaseSwapHandler.js

@@ -53,12 +53,12 @@ class FromBtcBaseSwapHandler extends EscrowHandler_1.EscrowHandler {
      */
     async getBaseSecurityDepositPrefetch(chainIdentifier, dummySwapData, depositToken, gasTokenPricePrefetchPromise, depositTokenPricePrefetchPromise, abortController) {
         //Solana workaround
-        const { swapContract, chainInterface } = this.getChain(chainIdentifier);
+        const { swapContract, chainInterface, signer } = this.getChain(chainIdentifier);
         let feeResult;
         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);
@@ -68,7 +68,7 @@ class FromBtcBaseSwapHandler extends EscrowHandler_1.EscrowHandler {
         }
         else {
             try {
-                feeResult = await swapContract.getRefundFee(dummySwapData);
+                feeResult = await swapContract.getRefundFee(signer.getAddress(), dummySwapData);
             }
             catch (e1) {
                 this.logger.error("getBaseSecurityDepositPrefetch(): pre-fetch error: ", e1);
@@ -88,11 +88,12 @@ class FromBtcBaseSwapHandler extends EscrowHandler_1.EscrowHandler {
      * @param chainIdentifier
      * @param useToken
      * @param abortController
+     * @param inContract
      */
-    async getBalancePrefetch(chainIdentifier, useToken, abortController) {
+    async getBalancePrefetch(chainIdentifier, useToken, abortController, inContract = true) {
         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);
@@ -109,6 +110,8 @@ class FromBtcBaseSwapHandler extends EscrowHandler_1.EscrowHandler {
      * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
      */
     async checkBalance(totalInToken, balancePrefetch, signal) {
+        if (totalInToken === 0n)
+            return;
         const balance = await balancePrefetch;
         if (signal != null)
             signal.throwIfAborted();

package/dist/swaps/escrow/frombtc_abstract/FromBtcAbs.js

@@ -178,7 +178,7 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         restServer.use(this.path + "/getAddress", (0, ServerParamDecoder_1.serverParamDecoder)(10 * 1000));
         restServer.post(this.path + "/getAddress", (0, Utils_1.expressHandlerWrapper)(async (req, res) => {
             const metadata = { request: {}, times: {} };
-            const chainIdentifier = req.query.chain ?? this.chains.default;
+            const chainIdentifier = req.query.chain;
             const { swapContract, signer, chainInterface } = this.getChain(chainIdentifier);
             const depositToken = req.query.depositToken ?? chainInterface.getNativeCurrencyAddress();
             this.checkAllowedDepositToken(chainIdentifier, depositToken);
@@ -202,7 +202,7 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             const parsedBody = await req.paramReader.getParams({
                 address: (val) => val != null &&
                     typeof (val) === "string" &&
-                    chainInterface.isValidAddress(val) ? val : null,
+                    chainInterface.isValidAddress(val, true) ? val : null,
                 amount: SchemaVerifier_1.FieldTypeEnum.BigInt,
                 token: (val) => val != null &&
                     typeof (val) === "string" &&

package/dist/swaps/escrow/frombtcln_abstract/FromBtcLnAbs.js

@@ -412,18 +412,16 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
                 msg: "Invoice expired/canceled"
             };
         const arr = invoice.description.split("-");
-        let chainIdentifier;
-        let address;
-        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))
+        if (!chainInterface.isValidAddress(address, true))
             throw {
                 _httpStatus: 200,
                 code: 10001,
@@ -456,7 +454,7 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         restServer.use(this.path + "/createInvoice", (0, ServerParamDecoder_1.serverParamDecoder)(10 * 1000));
         restServer.post(this.path + "/createInvoice", (0, Utils_1.expressHandlerWrapper)(async (req, res) => {
             const metadata = { request: {}, times: {} };
-            const chainIdentifier = req.query.chain ?? this.chains.default;
+            const chainIdentifier = req.query.chain;
             const { swapContract, signer, chainInterface } = this.getChain(chainIdentifier);
             const depositToken = req.query.depositToken ?? chainInterface.getNativeCurrencyAddress();
             this.checkAllowedDepositToken(chainIdentifier, depositToken);
@@ -475,7 +473,7 @@ class FromBtcLnAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             const parsedBody = await req.paramReader.getParams({
                 address: (val) => val != null &&
                     typeof (val) === "string" &&
-                    chainInterface.isValidAddress(val) ? val : null,
+                    chainInterface.isValidAddress(val, true) ? val : null,
                 paymentHash: (val) => val != null &&
                     typeof (val) === "string" &&
                     val.length === 64 &&

package/dist/swaps/escrow/frombtcln_abstract/FromBtcLnSwapAbs.d.ts

@@ -24,6 +24,7 @@ export declare class FromBtcLnSwapAbs<T extends SwapData = SwapData> extends Fro
     serialize(): any;
     getToken(): string;
     getOutputAmount(): bigint;
+    getClaimHash(): string;
     getIdentifierHash(): string;
     getSequence(): bigint;
     isInitiated(): boolean;

package/dist/swaps/escrow/frombtcln_abstract/FromBtcLnSwapAbs.js

@@ -69,6 +69,9 @@ class FromBtcLnSwapAbs extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     getOutputAmount() {
         return this.totalTokens;
     }
+    getClaimHash() {
+        return this.claimHash;
+    }
     getIdentifierHash() {
         return this.lnPaymentHash;
     }

package/dist/swaps/escrow/frombtcln_autoinit/FromBtcLnAuto.d.ts

@@ -0,0 +1,111 @@
+import { Express } from "express";
+import { FromBtcLnAutoSwap, FromBtcLnAutoSwapState } from "./FromBtcLnAutoSwap";
+import { MultichainData, SwapHandlerType } from "../../SwapHandler";
+import { ISwapPrice } from "../../../prices/ISwapPrice";
+import { ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapData } from "@atomiqlabs/base";
+import { IIntermediaryStorage } from "../../../storage/IIntermediaryStorage";
+import { FromBtcBaseConfig, FromBtcBaseSwapHandler } from "../FromBtcBaseSwapHandler";
+import { ILightningWallet } from "../../../wallets/ILightningWallet";
+import { LightningAssertions } from "../../assertions/LightningAssertions";
+export type FromBtcLnAutoConfig = FromBtcBaseConfig & {
+    invoiceTimeoutSeconds?: number;
+    minCltv: bigint;
+    gracePeriod: bigint;
+    gasTokenMax: {
+        [chainId: string]: bigint;
+    };
+};
+export type FromBtcLnAutoRequestType = {
+    address: string;
+    paymentHash: string;
+    amount: bigint;
+    token: string;
+    gasToken: string;
+    gasAmount: bigint;
+    claimerBounty: bigint;
+    descriptionHash?: string;
+    exactOut?: boolean;
+};
+/**
+ * Swap handler handling from BTCLN swaps using submarine swaps
+ */
+export declare class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, FromBtcLnAutoSwapState> {
+    readonly type = SwapHandlerType.FROM_BTCLN_AUTO;
+    readonly swapType = ChainSwapType.HTLC;
+    activeSubscriptions: Set<string>;
+    readonly config: FromBtcLnAutoConfig;
+    readonly lightning: ILightningWallet;
+    readonly LightningAssertions: LightningAssertions;
+    constructor(storageDirectory: IIntermediaryStorage<FromBtcLnAutoSwap>, path: string, chains: MultichainData, lightning: ILightningWallet, swapPricing: ISwapPrice, config: FromBtcLnAutoConfig);
+    protected processPastSwap(swap: FromBtcLnAutoSwap): Promise<"REFUND" | "SETTLE" | null>;
+    protected refundSwaps(refundSwaps: FromBtcLnAutoSwap[]): Promise<void>;
+    protected settleInvoices(swaps: FromBtcLnAutoSwap[]): Promise<void>;
+    /**
+     * Checks past swaps, refunds and deletes ones that are already expired.
+     */
+    protected processPastSwaps(): Promise<void>;
+    protected processInitializeEvent(chainIdentifier: string, savedSwap: FromBtcLnAutoSwap, event: InitializeEvent<SwapData>): Promise<void>;
+    protected processClaimEvent(chainIdentifier: string, savedSwap: FromBtcLnAutoSwap, event: ClaimEvent<SwapData>): Promise<void>;
+    protected processRefundEvent(chainIdentifier: string, savedSwap: FromBtcLnAutoSwap, event: RefundEvent<SwapData>): Promise<void>;
+    /**
+     * Subscribe to a lightning network invoice
+     *
+     * @param swap
+     */
+    private subscribeToInvoice;
+    /**
+     * Called when lightning HTLC is received, also signs an init transaction on the smart chain side, expiry of the
+     *  smart chain authorization starts ticking as soon as this HTLC is received
+     *
+     * @param invoiceData
+     * @param invoice
+     */
+    private htlcReceived;
+    private offerHtlc;
+    /**
+     * Checks invoice description hash
+     *
+     * @param descriptionHash
+     * @throws {DefinedRuntimeError} will throw an error if the description hash is invalid
+     */
+    private checkDescriptionHash;
+    /**
+     * Asynchronously sends the LN node's public key to the client, so he can pre-fetch the node's channels from 1ml api
+     *
+     * @param responseStream
+     */
+    private sendPublicKeyAsync;
+    /**
+     * Returns the CLTV timeout (blockheight) of the received HTLC corresponding to the invoice. If multiple HTLCs are
+     *  received (MPP) it returns the lowest of the timeouts
+     *
+     * @param invoice
+     */
+    private getInvoicePaymentsTimeout;
+    /**
+     * Checks if the received HTLC's CLTV timeout is large enough to still process the swap
+     *
+     * @param invoice
+     * @throws {DefinedRuntimeError} Will throw if HTLC expires too soon and therefore cannot be processed
+     * @returns expiry timeout in seconds
+     */
+    private checkHtlcExpiry;
+    /**
+     * Cancels the swap (CANCELED state) & also cancels the LN invoice (including all pending HTLCs)
+     *
+     * @param invoiceData
+     */
+    private cancelSwapAndInvoice;
+    /**
+     *
+     * Checks if the lightning invoice is in HELD state (htlcs received but yet unclaimed)
+     *
+     * @param paymentHash
+     * @throws {DefinedRuntimeError} Will throw if the lightning invoice is not found, or if it isn't in the HELD state
+     * @returns the fetched lightning invoice
+     */
+    private checkInvoiceStatus;
+    startRestServer(restServer: Express): void;
+    init(): Promise<void>;
+    getInfoData(): any;
+}