@atomiqlabs/lp-lib 15.0.13 → 16.0.0

package/dist/swaps/spv_vault_swap/SpvVaults.js

@@ -9,20 +9,29 @@ const btc_signer_1 = require("@scure/btc-signer");
 const BitcoinUtils_1 = require("../../utils/BitcoinUtils");
 exports.VAULT_DUST_AMOUNT = 600;
 const VAULT_INIT_CONFIRMATIONS = 2;
+const MAX_PARALLEL_VAULTS_OPENING = 10;
 class SpvVaults {
-    constructor(vaultStorage, bitcoin, vaultSigner, bitcoinRpc, getChain, config) {
-        this.logger = {
-            debug: (msg, ...args) => console.debug("SpvVaults: " + msg, ...args),
-            info: (msg, ...args) => console.info("SpvVaults: " + msg, ...args),
-            warn: (msg, ...args) => console.warn("SpvVaults: " + msg, ...args),
-            error: (msg, ...args) => console.error("SpvVaults: " + msg, ...args)
-        };
+    constructor(vaultStorage, bitcoin, vaultSigner, bitcoinRpc, chains, config) {
+        this.logger = (0, Utils_1.getLogger)("SpvVaults: ");
         this.vaultStorage = vaultStorage;
         this.bitcoin = bitcoin;
         this.vaultSigner = vaultSigner;
         this.bitcoinRpc = bitcoinRpc;
-        this.getChain = getChain;
+        this.chains = chains;
         this.config = config;
+        for (let chainId in chains.chains) {
+            const { chainInterface } = chains.chains[chainId];
+            chainInterface.onBeforeTxReplace(async (oldTx, oldTxId, newTx, newTxId) => {
+                for (let key in this.vaultStorage.data) {
+                    const vaultData = this.vaultStorage.data[key];
+                    if (vaultData.scOpenTxs != null && vaultData.scOpenTxs[oldTxId] != null) {
+                        vaultData.scOpenTxs[newTxId] = newTx;
+                        await this.saveVault(vaultData);
+                        break;
+                    }
+                }
+            });
+        }
     }
     async processDepositEvent(vault, event) {
         vault.update(event);
@@ -51,7 +60,7 @@ class SpvVaults {
         await this.saveVault(vault);
     }
     async createVaults(chainId, count, token, confirmations = 2, feeRate) {
-        const { signer, chainInterface, tokenMultipliers, spvVaultContract } = this.getChain(chainId);
+        const { signer, chainInterface, tokenMultipliers, spvVaultContract } = this.chains.chains[chainId];
         const signerAddress = signer.getAddress();
         //Check vaultId of the latest saved vault
         let latestVaultId = -1n;
@@ -71,49 +80,54 @@ class SpvVaults {
             const address = await this.vaultSigner.getAddress(chainId, vaultId);
             vaultAddreses.push({ vaultId, address });
         }
-        //Construct transaction
-        const txResult = await this.bitcoin.getSignedMultiTransaction(vaultAddreses.map(val => {
-            return { address: val.address, amount: exports.VAULT_DUST_AMOUNT };
-        }), feeRate);
         const nativeToken = chainInterface.getNativeCurrencyAddress();
-        const vaults = await Promise.all(vaultAddreses.map(async (val, index) => {
-            const vaultData = await spvVaultContract.createVaultData(signerAddress, val.vaultId, txResult.txId + ":" + index, confirmations, [
-                { token, multiplier: tokenMultipliers?.[token] ?? 1n },
-                { token: nativeToken, multiplier: tokenMultipliers?.[nativeToken] ?? 1n }
-            ]);
-            return new SpvVault_1.SpvVault(chainId, vaultData, val.address);
-        }));
-        //Save vaults
-        if (this.vaultStorage.saveDataArr != null) {
-            await this.vaultStorage.saveDataArr(vaults.map(val => {
-                return { id: val.getIdentifier(), object: val };
+        let txId = null;
+        let vaults = null;
+        await this.bitcoin.execute(async () => {
+            //Construct transaction
+            const txResult = await this.bitcoin.getSignedMultiTransaction(vaultAddreses.map(val => {
+                return { address: val.address, amount: exports.VAULT_DUST_AMOUNT };
+            }), feeRate);
+            vaults = await Promise.all(vaultAddreses.map(async (val, index) => {
+                const vaultData = await spvVaultContract.createVaultData(signerAddress, val.vaultId, txResult.txId + ":" + index, confirmations, [
+                    { token, multiplier: tokenMultipliers?.[token] ?? 1n },
+                    { token: nativeToken, multiplier: tokenMultipliers?.[nativeToken] ?? 1n }
+                ]);
+                return new SpvVault_1.SpvVault(chainId, vaultData, val.address);
             }));
-        }
-        else {
-            for (let vault of vaults) {
-                await this.vaultStorage.saveData(vault.getIdentifier(), vault);
+            //Save vaults
+            if (this.vaultStorage.saveDataArr != null) {
+                await this.vaultStorage.saveDataArr(vaults.map(val => {
+                    return { id: val.getIdentifier(), object: val };
+                }));
             }
-        }
-        //Send bitcoin tx
-        await this.bitcoin.sendRawTransaction(txResult.raw);
-        this.logger.info("createVaults(): Funding " + count + " vaults, bitcoin txId: " + txResult.txId);
+            else {
+                for (let vault of vaults) {
+                    await this.vaultStorage.saveData(vault.getIdentifier(), vault);
+                }
+            }
+            //Send bitcoin tx
+            await this.bitcoin.sendRawTransaction(txResult.raw);
+            txId = txResult.txId;
+        });
+        this.logger.info("createVaults(): Funding " + count + " vaults, bitcoin txId: " + txId);
         return {
             vaultsCreated: vaults.map(val => val.data.getVaultId()),
-            btcTxId: txResult.txId
+            btcTxId: txId
         };
     }
     async listVaults(chainId, token) {
         return Object.keys(this.vaultStorage.data)
             .map(key => this.vaultStorage.data[key])
             .filter(val => chainId == null ? true : val.chainId === chainId)
-            .filter(val => val.data.getOwner() === this.getChain(val.chainId)?.signer?.getAddress())
+            .filter(val => val.data.getOwner() === this.chains.chains[val.chainId]?.signer?.getAddress())
             .filter(val => token == null ? true : val.data.getTokenData()[0].token === token);
     }
     async fundVault(vault, tokenAmounts) {
         if (vault.state !== SpvVault_1.SpvVaultState.OPENED)
             throw new Error("Vault not opened!");
         this.logger.info("fundVault(): Depositing tokens to the vault " + vault.data.getVaultId().toString(10) + ", amounts: " + tokenAmounts.map(val => val.toString(10)).join(", "));
-        const { signer, spvVaultContract } = this.getChain(vault.chainId);
+        const { signer, spvVaultContract } = this.chains.chains[vault.chainId];
         const txId = await spvVaultContract.deposit(signer, vault.data, tokenAmounts, { waitForConfirmation: true });
         this.logger.info("fundVault(): Tokens deposited to vault " + vault.data.getVaultId().toString(10) + ", amounts: " + tokenAmounts.map(val => val.toString(10)).join(", ") + ", txId: " + txId);
         return txId;
@@ -127,7 +141,7 @@ class SpvVaults {
         });
         if (!vault.isReady())
             throw new Error("Vault not ready, wait for the latest swap to get at least 1 confirmation!");
-        const { signer, spvVaultContract } = this.getChain(vault.chainId);
+        const { signer, spvVaultContract } = this.chains.chains[vault.chainId];
         const latestUtxo = vault.getLatestUtxo();
         const [txId, voutStr] = latestUtxo.split(":");
         const opReturnData = spvVaultContract.toOpReturnData(signer.getAddress(), tokenAmounts);
@@ -163,32 +177,36 @@ class SpvVaults {
             amount: 0n,
             script: opReturnScript
         });
-        psbt = await this.bitcoin.fundPsbt(psbt, feeRate);
-        if (psbt.inputsLength < 2)
-            throw new Error("PSBT needs at least 2 inputs!");
-        psbt.updateInput(0, { sequence: 0x80000000 });
-        psbt.updateInput(1, { sequence: 0x80000000 });
-        psbt = await this.vaultSigner.signPsbt(vault.chainId, vault.data.getVaultId(), psbt, [0]);
-        const res = await this.bitcoin.signPsbt(psbt);
-        const parsedTransaction = await this.bitcoinRpc.parseTransaction(res.raw);
-        const withdrawalData = await spvVaultContract.getWithdrawalData(parsedTransaction);
-        if (withdrawalData.getSpentVaultUtxo() !== vault.getLatestUtxo()) {
-            throw new Error("Latest vault UTXO already spent! Please try again later.");
-        }
-        withdrawalData.sending = true;
-        vault.addWithdrawal(withdrawalData);
-        await this.saveVault(vault);
-        try {
-            await this.bitcoin.sendRawTransaction(res.raw);
-            withdrawalData.sending = false;
-        }
-        catch (e) {
-            withdrawalData.sending = false;
-            vault.removeWithdrawal(withdrawalData);
+        let withdrawalTxId = null;
+        await this.bitcoin.execute(async () => {
+            psbt = await this.bitcoin.fundPsbt(psbt, feeRate);
+            if (psbt.inputsLength < 2)
+                throw new Error("PSBT needs at least 2 inputs!");
+            psbt.updateInput(0, { sequence: 0x80000000 });
+            psbt.updateInput(1, { sequence: 0x80000000 });
+            psbt = await this.vaultSigner.signPsbt(vault.chainId, vault.data.getVaultId(), psbt, [0]);
+            const res = await this.bitcoin.signPsbt(psbt);
+            withdrawalTxId = res.txId;
+            const parsedTransaction = await this.bitcoinRpc.parseTransaction(res.raw);
+            const withdrawalData = await spvVaultContract.getWithdrawalData(parsedTransaction);
+            if (withdrawalData.getSpentVaultUtxo() !== vault.getLatestUtxo()) {
+                throw new Error("Latest vault UTXO already spent! Please try again later.");
+            }
+            withdrawalData.sending = true;
+            vault.addWithdrawal(withdrawalData);
             await this.saveVault(vault);
-            throw e;
-        }
-        return res.txId;
+            try {
+                await this.bitcoin.sendRawTransaction(res.raw);
+                withdrawalData.sending = false;
+            }
+            catch (e) {
+                withdrawalData.sending = false;
+                vault.removeWithdrawal(withdrawalData);
+                await this.saveVault(vault);
+                throw e;
+            }
+        });
+        return withdrawalTxId;
     }
     /**
      * Call this to check whether some of the previously replaced transactions got re-introduced to the mempool
@@ -197,7 +215,7 @@ class SpvVaults {
      * @param save
      */
     async checkVaultReplacedTransactions(vault, save) {
-        const { spvVaultContract } = this.getChain(vault.chainId);
+        const { spvVaultContract } = this.chains.chains[vault.chainId];
         const initialVaultWithdrawalCount = vault.data.getWithdrawalCount();
         let latestWithdrawalIndex = initialVaultWithdrawalCount;
         const newPendingTxns = [];
@@ -276,8 +294,9 @@ class SpvVaults {
     async checkVaults() {
         const vaults = Object.keys(this.vaultStorage.data).map(key => this.vaultStorage.data[key]);
         const claimWithdrawals = [];
+        let promises = [];
         for (let vault of vaults) {
-            const { signer, spvVaultContract, chainInterface } = this.getChain(vault.chainId);
+            const { signer, spvVaultContract, chainInterface } = this.chains.chains[vault.chainId];
             if (vault.data.getOwner() !== signer.getAddress())
                 continue;
             if (vault.state === SpvVault_1.SpvVaultState.BTC_INITIATED) {
@@ -295,30 +314,45 @@ class SpvVaults {
             }
             if (vault.state === SpvVault_1.SpvVaultState.BTC_CONFIRMED) {
                 //Check if open txs were sent already
-                if (vault.scOpenTx != null) {
+                if (vault.scOpenTxs != null) {
                     //Check if confirmed
-                    const status = await chainInterface.getTxStatus(vault.scOpenTx.rawTx);
-                    if (status === "pending")
-                        return;
-                    if (status === "success") {
-                        vault.state = SpvVault_1.SpvVaultState.OPENED;
-                        await this.saveVault(vault);
-                        return;
+                    let _continue = false;
+                    for (let txId in vault.scOpenTxs) {
+                        const tx = vault.scOpenTxs[txId];
+                        const status = await chainInterface.getTxStatus(tx);
+                        if (status === "pending") {
+                            _continue = true;
+                            break;
+                        }
+                        if (status === "success") {
+                            vault.state = SpvVault_1.SpvVaultState.OPENED;
+                            await this.saveVault(vault);
+                            _continue = true;
+                            break;
+                        }
                     }
+                    if (_continue)
+                        continue;
                 }
                 const txs = await spvVaultContract.txsOpen(signer.getAddress(), vault.data);
                 let numTx = 0;
-                const txIds = await chainInterface.sendAndConfirm(signer, txs, true, undefined, false, async (txId, rawTx) => {
+                promises.push(chainInterface.sendAndConfirm(signer, txs, true, undefined, true, async (txId, rawTx) => {
                     numTx++;
                     if (numTx === txs.length) {
                         //Final tx
-                        vault.scOpenTx = { txId, rawTx };
+                        vault.scOpenTxs = { [txId]: rawTx };
                         await this.saveVault(vault);
                     }
-                });
-                this.logger.info("checkVaults(): Vault ID " + vault.data.getVaultId().toString(10) + " opened on " + vault.chainId + " txId: " + txIds.join(", "));
-                vault.state = SpvVault_1.SpvVaultState.OPENED;
-                await this.saveVault(vault);
+                }).then(txIds => {
+                    this.logger.info("checkVaults(): Vault ID " + vault.data.getVaultId().toString(10) + " opened on " + vault.chainId + " txId: " + txIds.join(", "));
+                    vault.state = SpvVault_1.SpvVaultState.OPENED;
+                    return this.saveVault(vault);
+                }));
+                if (promises.length >= MAX_PARALLEL_VAULTS_OPENING) {
+                    await Promise.all(promises);
+                    promises = [];
+                }
+                continue;
             }
             if (vault.state === SpvVault_1.SpvVaultState.OPENED) {
                 let changed = await this.checkVaultReplacedTransactions(vault);
@@ -379,7 +413,7 @@ class SpvVaults {
         }
     }
     async claimWithdrawals(vault, withdrawal) {
-        const { signer, spvVaultContract } = this.getChain(vault.chainId);
+        const { signer, spvVaultContract } = this.chains.chains[vault.chainId];
         try {
             const txId = await spvVaultContract.claim(signer, vault.data, withdrawal.map(tx => {
                 return { tx };
@@ -407,7 +441,7 @@ class SpvVaults {
      * @protected
      */
     async findVaultForSwap(chainIdentifier, totalSats, token, amount, gasToken, gasTokenAmount) {
-        const { signer } = this.getChain(chainIdentifier);
+        const { signer } = this.chains.chains[chainIdentifier];
         const pluginResponse = await PluginManager_1.PluginManager.onVaultSelection(chainIdentifier, totalSats, { token, amount }, { token: gasToken, amount: gasTokenAmount });
         if (pluginResponse != null) {
             AmountAssertions_1.AmountAssertions.handlePluginErrorResponses(pluginResponse);
@@ -442,7 +476,7 @@ class SpvVaults {
     async startVaultsWatchdog() {
         let rerun;
         rerun = async () => {
-            await this.checkVaults().catch(e => console.error(e));
+            await this.checkVaults().catch(e => this.logger.error("startVaultsWatchdog(): Error when periodically checking SPV vaults: ", e));
             setTimeout(rerun, this.config.vaultsCheckInterval);
         };
         await rerun();

package/dist/swaps/trusted/frombtc_trusted/FromBtcTrusted.js

@@ -334,7 +334,7 @@ class FromBtcTrusted extends SwapHandler_1.SwapHandler {
         const getAddress = (0, Utils_1.expressHandlerWrapper)(async (req, res) => {
             var _a;
             const metadata = { request: {}, times: {} };
-            const chainIdentifier = req.query.chain ?? this.chains.default;
+            const chainIdentifier = req.query.chain;
             const { chainInterface, signer } = this.getChain(chainIdentifier);
             metadata.times.requestReceived = Date.now();
             /**
@@ -347,7 +347,7 @@ class FromBtcTrusted extends SwapHandler_1.SwapHandler {
             const parsedBody = (0, SchemaVerifier_1.verifySchema)(req.query, {
                 address: (val) => val != null &&
                     typeof (val) === "string" &&
-                    chainInterface.isValidAddress(val) ? val : null,
+                    chainInterface.isValidAddress(val, true) ? val : null,
                 refundAddress: (val) => val == null ? "" :
                     typeof (val) === "string" &&
                         this.isValidBitcoinAddress(val) ? val : null,
@@ -618,7 +618,7 @@ class FromBtcTrusted extends SwapHandler_1.SwapHandler {
     async startDoubleSpendWatchdog() {
         let rerun;
         rerun = async () => {
-            await this.checkDoubleSpends().catch(e => console.error(e));
+            await this.checkDoubleSpends().catch(e => this.logger.error("startDoubleSpendWatchdog(): Error when checking double spends: ", e));
             setTimeout(rerun, this.config.doubleSpendCheckInterval);
         };
         await rerun();

package/dist/swaps/trusted/frombtcln_trusted/FromBtcLnTrusted.js

@@ -53,7 +53,7 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
             this.swapLogger.debug(invoiceData, "subscribeToInvoice(): invoice_updated: ", invoice);
             if (invoice.status !== "held")
                 return;
-            this.htlcReceived(invoiceData, invoice).catch(e => console.error(e));
+            this.htlcReceived(invoiceData, invoice).catch(e => this.swapLogger.error(invoiceData, "subscribeToInvoice(): Error calling htlcReceived(): ", e));
             this.activeSubscriptions.delete(hash);
         });
         this.swapLogger.debug(invoiceData, "subscribeToInvoice(): Subscribed to invoice payment");
@@ -79,7 +79,7 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
                     //Result is either FromBtcLnTrustedSwapState.RECEIVED or FromBtcLnTrustedSwapState.CANCELED
                 }
                 catch (e) {
-                    console.error(e);
+                    this.swapLogger.error(swap, "processPastSwap(): Error calling htlcReceived(): ", e);
                 }
                 return false;
             case "confirmed":
@@ -182,7 +182,7 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
                     await invoiceData.setState(FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.SENT);
                     await this.storageManager.saveData(invoice.id, null, invoiceData);
                 }
-            }).catch(e => console.error(e));
+            }).catch(e => this.swapLogger.error(invoiceData, "htlcReceived(): Error sending transfer txns", e));
             if (result == null) {
                 //Cancel invoice
                 await invoiceData.setState(FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.REFUNDED);
@@ -264,18 +264,16 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
                 msg: "Invoice expired/canceled"
             };
         const arr = invoice.description.split("-");
-        let chainIdentifier;
-        let address;
-        if (arr.length > 2 && arr[1] === "GAS") {
-            chainIdentifier = arr[0];
-            address = arr[2];
-        }
-        else {
-            chainIdentifier = this.chains.default;
-            address = invoice.description;
-        }
+        if (arr.length < 3 || arr[1] !== "GAS")
+            throw {
+                _httpStatus: 200,
+                code: 10001,
+                msg: "Invoice expired/canceled"
+            };
+        const chainIdentifier = arr[0];
+        const address = arr[2];
         const { chainInterface } = this.getChain(chainIdentifier);
-        if (!chainInterface.isValidAddress(address))
+        if (!chainInterface.isValidAddress(address, true))
             throw {
                 _httpStatus: 200,
                 code: 10001,
@@ -313,7 +311,7 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
         const createInvoice = (0, Utils_1.expressHandlerWrapper)(async (req, res) => {
             var _a;
             const metadata = { request: {}, times: {} };
-            const chainIdentifier = req.query.chain ?? this.chains.default;
+            const chainIdentifier = req.query.chain;
             const { signer, chainInterface } = this.getChain(chainIdentifier);
             metadata.times.requestReceived = Date.now();
             /**
@@ -324,7 +322,7 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
             const parsedBody = (0, SchemaVerifier_1.verifySchema)(req.query, {
                 address: (val) => val != null &&
                     typeof (val) === "string" &&
-                    chainInterface.isValidAddress(val) ? val : null,
+                    chainInterface.isValidAddress(val, true) ? val : null,
                 token: (val) => val != null &&
                     typeof (val) === "string" &&
                     this.isTokenSupported(chainIdentifier, val) ? val : null,
@@ -385,7 +383,6 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
             abortController.signal.throwIfAborted();
             metadata.times.invoiceCreated = Date.now();
             metadata.invoiceResponse = { ...hodlInvoice };
-            console.log("[From BTC-LN: REST.CreateInvoice] hodl invoice created: ", hodlInvoice);
             const createdSwap = new FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwap(chainIdentifier, hodlInvoice.request, hodlInvoice.mtokens, swapFee, swapFeeInToken, totalInToken, secret.toString("hex"), parsedBody.address, useToken);
             metadata.times.swapCreated = Date.now();
             createdSwap.metadata = metadata;

package/dist/utils/Utils.d.ts

@@ -1,5 +1,12 @@
 import { Request, Response } from "express";
 import { ServerParamEncoder } from "./paramcoders/server/ServerParamEncoder";
+export type LoggerType = {
+    debug: (msg: string, ...args: any[]) => void;
+    info: (msg: string, ...args: any[]) => void;
+    warn: (msg: string, ...args: any[]) => void;
+    error: (msg: string, ...args: any[]) => void;
+};
+export declare function getLogger(prefix: string | (() => string)): LoggerType;
 export type DefinedRuntimeError = {
     code: number;
     msg?: string;
@@ -10,13 +17,6 @@ export declare function isDefinedRuntimeError(obj: any): obj is DefinedRuntimeEr
 export declare function expressHandlerWrapper(func: (req: Request, res: Response) => Promise<void>): ((req: Request, res: Response & {
     responseStream: ServerParamEncoder;
 }) => void);
-export type LoggerType = {
-    debug: (msg: string, ...args: any[]) => void;
-    info: (msg: string, ...args: any[]) => void;
-    warn: (msg: string, ...args: any[]) => void;
-    error: (msg: string, ...args: any[]) => void;
-};
-export declare function getLogger(prefix: string): LoggerType;
 export declare const HEX_REGEX: RegExp;
 export declare function serializeBN(bn: bigint | null): string | null;
 export declare function deserializeBN(str: string | null): bigint | null;

package/dist/utils/Utils.js

@@ -1,6 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAbortController = exports.bigIntSorter = exports.deserializeBN = exports.serializeBN = exports.HEX_REGEX = exports.getLogger = exports.expressHandlerWrapper = exports.isDefinedRuntimeError = void 0;
+exports.getAbortController = exports.bigIntSorter = exports.deserializeBN = exports.serializeBN = exports.HEX_REGEX = exports.expressHandlerWrapper = exports.isDefinedRuntimeError = exports.getLogger = void 0;
+function getLogger(prefix) {
+    return {
+        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug((typeof (prefix) === "function" ? prefix() : prefix) + msg, ...args),
+        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info((typeof (prefix) === "function" ? prefix() : prefix) + msg, ...args),
+        warn: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 1) && console.warn((typeof (prefix) === "function" ? prefix() : prefix) + msg, ...args),
+        error: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 0) && console.error((typeof (prefix) === "function" ? prefix() : prefix) + msg, ...args)
+    };
+}
+exports.getLogger = getLogger;
 function isDefinedRuntimeError(obj) {
     if (obj.code != null && typeof (obj.code) === "number") {
         if (obj.msg != null && typeof (obj.msg) !== "string")
@@ -12,6 +21,7 @@ function isDefinedRuntimeError(obj) {
     return false;
 }
 exports.isDefinedRuntimeError = isDefinedRuntimeError;
+const expressHandlerWrapperLogger = getLogger("ExpressHandlerWrapper: ");
 function expressHandlerWrapper(func) {
     return (req, res) => {
         (async () => {
@@ -19,7 +29,7 @@ function expressHandlerWrapper(func) {
                 await func(req, res);
             }
             catch (e) {
-                console.error(e);
+                expressHandlerWrapperLogger.error("Error in called function " + req.path + ": ", e);
                 let statusCode = 500;
                 const obj = {
                     code: 0,
@@ -46,15 +56,6 @@ function expressHandlerWrapper(func) {
     };
 }
 exports.expressHandlerWrapper = expressHandlerWrapper;
-function getLogger(prefix) {
-    return {
-        debug: (msg, ...args) => console.debug(prefix + msg, ...args),
-        info: (msg, ...args) => console.info(prefix + msg, ...args),
-        warn: (msg, ...args) => console.warn(prefix + msg, ...args),
-        error: (msg, ...args) => console.error(prefix + msg, ...args)
-    };
-}
-exports.getLogger = getLogger;
 exports.HEX_REGEX = /[0-9a-fA-F]+/;
 function serializeBN(bn) {
     return bn == null ? null : bn.toString(10);

package/dist/utils/paramcoders/server/ServerParamDecoder.js

@@ -4,6 +4,7 @@ exports.serverParamDecoder = exports.RequestParsingError = exports.RequestTimeou
 const SchemaVerifier_1 = require("../SchemaVerifier");
 const ParamDecoder_1 = require("../ParamDecoder");
 const ServerParamEncoder_1 = require("./ServerParamEncoder");
+const Utils_1 = require("../../Utils");
 class RequestTimeoutError extends Error {
     constructor() {
         super("Request timed out");
@@ -20,6 +21,7 @@ class RequestParsingError extends Error {
     }
 }
 exports.RequestParsingError = RequestParsingError;
+const logger = (0, Utils_1.getLogger)("ServerParamDecoder: ");
 const serverParamDecoder = (timeoutMillis) => (req, res, next) => {
     let timeout;
     res.responseStream = new ServerParamEncoder_1.ServerParamEncoder(res, 200, req);
@@ -43,14 +45,14 @@ const serverParamDecoder = (timeoutMillis) => (req, res, next) => {
                 next();
             }
             catch (e) {
-                console.error("ServerParamDecoder: error reading legacy (non-streaming) http request", e);
+                logger.error("error reading legacy (non-streaming) http request", e);
                 req.destroy(new RequestParsingError());
                 res.destroy(new RequestParsingError());
             }
             clearTimeout(timeout);
         });
         req.on("error", (e) => {
-            console.error("ServerParamDecoder: error reading legacy (non-streaming) http request", e);
+            logger.error("error reading legacy (non-streaming) http request", e);
         });
         timeout = setTimeout(() => {
             req.destroy(new RequestTimeoutError());
@@ -64,7 +66,7 @@ const serverParamDecoder = (timeoutMillis) => (req, res, next) => {
             decoder.onData(data);
         }
         catch (e) {
-            console.error("ServerParamDecoder: error reading streaming http request: on(\"data\")", e);
+            logger.error("error reading streaming http request: on(\"data\")", e);
             req.destroy(new RequestParsingError());
             res.destroy(new RequestParsingError());
         }
@@ -74,7 +76,7 @@ const serverParamDecoder = (timeoutMillis) => (req, res, next) => {
             decoder.onEnd();
         }
         catch (e) {
-            console.error("ServerParamDecoder: error reading streaming http request: on(\"end\")", e);
+            logger.error("error reading streaming http request: on(\"end\")", e);
             req.destroy(new RequestParsingError());
             res.destroy(new RequestParsingError());
         }
@@ -85,7 +87,7 @@ const serverParamDecoder = (timeoutMillis) => (req, res, next) => {
             decoder.onError(e);
         }
         catch (e) {
-            console.error("ServerParamDecoder: error reading streaming http request: on(\"error\")", e);
+            logger.error("error reading streaming http request: on(\"error\")", e);
         }
     });
     timeout = setTimeout(() => {
@@ -93,7 +95,7 @@ const serverParamDecoder = (timeoutMillis) => (req, res, next) => {
             decoder.onEnd();
         }
         catch (e) {
-            console.error("ServerParamDecoder: error reading streaming http request: timeout", e);
+            logger.error("error reading streaming http request: timeout", e);
         }
         req.destroy(new RequestTimeoutError());
         res.destroy(new RequestTimeoutError());

package/dist/wallets/IBitcoinWallet.d.ts

@@ -64,4 +64,11 @@ export interface IBitcoinWallet {
     parsePsbt(psbt: Transaction): Promise<BtcTx>;
     getBlockheight(): Promise<number>;
     getFeeRate(): Promise<number>;
+    /**
+     * Post a task to be executed on the sequential thread of the wallet, this makes sure the UTXOs stay consistent during
+     *  operation, it is recommended to use this approach when spending wallet UTXOs
+     *
+     * @param executor
+     */
+    execute(executor: () => Promise<void>): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/lp-lib",
-  "version": "15.0.13",
+  "version": "16.0.0",
   "description": "Main functionality implementation for atomiq LP node",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -22,11 +22,11 @@
   "author": "adambor",
   "license": "ISC",
   "dependencies": {
-    "@atomiqlabs/base": "^11.0.0",
+    "@atomiqlabs/base": "^12.0.0",
     "@atomiqlabs/server-base": "^3.0.0",
     "@scure/btc-signer": "1.6.0",
     "express": "4.21.1",
-    "promise-queue-ts": "0.0.1"
+    "promise-queue-ts": "1.0.0"
   },
   "devDependencies": {
     "@types/express": "4.17.21",

package/src/index.ts

@@ -13,6 +13,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/src/info/InfoHandler.ts

@@ -13,8 +13,6 @@ type InfoHandlerResponseEnvelope = {
 
 type InfoHandlerResponse = {
     envelope: string,
-    address: string,
-    signature: string,
     chains: {
         [chainIdentifier: string]: {
             address: string,
@@ -88,12 +86,8 @@ export class InfoHandler {
                 };
             }
 
-            const defaults = chains[this.chainData.default];
-
             const response: InfoHandlerResponse = {
                 envelope,
-                address: defaults.address,
-                signature: defaults.signature,
                 chains
             };
 

package/src/plugins/IPlugin.ts

@@ -116,7 +116,7 @@ export interface IPlugin {
     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,
+        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,
@@ -125,7 +125,7 @@ export interface IPlugin {
         gasTokenAmount?: {input: false, 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,
+        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,