@atomiqlabs/lp-lib 17.0.1 → 17.0.3

package/dist/swaps/spv_vault_swap/SpvVault.d.ts

@@ -32,6 +32,7 @@ export declare class SpvVault<D extends SpvWithdrawalTransactionData = SpvWithdr
      */
     getConfirmedBalance(): SpvVaultTokenBalance[];
     serialize(): any;
+    static _getIdentifier(chainId: string, data: SpvVaultData): string;
     getIdentifier(): string;
     /**
      * Returns the latest vault utxo

package/dist/swaps/spv_vault_swap/SpvVault.js

@@ -120,8 +120,11 @@ class SpvVault extends base_1.Lockable {
             scOpenTxs: this.scOpenTxs
         };
     }
+    static _getIdentifier(chainId, data) {
+        return chainId + "_" + data.getOwner() + "_" + data.getVaultId().toString(10);
+    }
     getIdentifier() {
-        return this.chainId + "_" + this.data.getOwner() + "_" + this.data.getVaultId().toString(10);
+        return SpvVault._getIdentifier(this.chainId, this.data);
     }
     /**
      * Returns the latest vault utxo

package/dist/swaps/spv_vault_swap/SpvVaults.d.ts

@@ -1,5 +1,5 @@
 import { SpvVault } from "./SpvVault";
-import { BitcoinRpc, IStorageManager, SpvVaultClaimEvent, SpvVaultCloseEvent, SpvVaultDepositEvent, SpvVaultOpenEvent, SpvWithdrawalTransactionData } from "@atomiqlabs/base";
+import { BitcoinRpc, BtcBlock, IStorageManager, SpvVaultClaimEvent, SpvVaultCloseEvent, SpvVaultDepositEvent, SpvVaultOpenEvent, SpvWithdrawalTransactionData } from "@atomiqlabs/base";
 import { SpvVaultSwap } from "./SpvVaultSwap";
 import { IBitcoinWallet } from "../../wallets/IBitcoinWallet";
 import { ISpvVaultSigner } from "../../wallets/ISpvVaultSigner";
@@ -9,7 +9,7 @@ export declare class SpvVaults {
     readonly vaultStorage: IStorageManager<SpvVault>;
     readonly bitcoin: IBitcoinWallet;
     readonly vaultSigner: ISpvVaultSigner;
-    readonly bitcoinRpc: BitcoinRpc<any>;
+    readonly bitcoinRpc: BitcoinRpc<BtcBlock>;
     readonly config: {
         vaultsCheckInterval: number;
         maxUnclaimedWithdrawals?: number;
@@ -60,4 +60,11 @@ export declare class SpvVaults {
     saveVault(vault: SpvVault): Promise<void>;
     startVaultsWatchdog(): Promise<void>;
     init(): Promise<void>;
+    /**
+     * Recovers already created vaults for a given chain from on-chain data. Requires initialized BTC wallet to
+     *  fetch wallet transactions
+     *
+     * @param chainId
+     */
+    recoverVaults(chainId: string): Promise<SpvVault[]>;
 }

package/dist/swaps/spv_vault_swap/SpvVaults.js

@@ -487,5 +487,68 @@ class SpvVaults {
     async init() {
         const vaults = await this.vaultStorage.loadData(SpvVault_1.SpvVault);
     }
+    /**
+     * Recovers already created vaults for a given chain from on-chain data. Requires initialized BTC wallet to
+     *  fetch wallet transactions
+     *
+     * @param chainId
+     */
+    async recoverVaults(chainId) {
+        const chain = this.chains.chains[chainId];
+        if (chainId == null)
+            throw new Error(`Chain ${chainId} not found in known chains!`);
+        const vaults = await chain.spvVaultContract.getAllVaults(chain.signer.getAddress());
+        const recoveredVaults = [];
+        let minimumBlockheight = null;
+        for (let vaultData of vaults) {
+            const vaultIdentifier = SpvVault_1.SpvVault._getIdentifier(chainId, vaultData);
+            if (this.vaultStorage.data[vaultIdentifier] != null) {
+                this.logger.info(`recoverVaults(${chainId}): Skipping vault ${vaultIdentifier}, because it is already known!`);
+                continue;
+            }
+            const [txId, voutStr] = vaultData.getUtxo().split(":");
+            const btcTx = await this.bitcoinRpc.getTransaction(txId);
+            const btcTxOutput = btcTx.outs[parseInt(voutStr)];
+            const vaultAddress = this.bitcoin.fromOutputScript(Buffer.from(btcTxOutput.scriptPubKey.hex, "hex"));
+            const vault = new SpvVault_1.SpvVault(chainId, vaultData, vaultAddress);
+            vault.state = SpvVault_1.SpvVaultState.OPENED;
+            recoveredVaults.push(vault);
+            if (await this.bitcoinRpc.isSpent(vaultData.getUtxo())) {
+                if (!this.bitcoin.isReady())
+                    throw new Error("Bitcoin wallet is not ready, but is required to check wallet transactions!");
+                //The latest smart chain UTXO is spent, we need to check if we have some further transactions
+                // spending the vault UTXO in our wallet history
+                const btcTxBlock = await this.bitcoinRpc.getBlockHeader(btcTx.blockhash);
+                minimumBlockheight = minimumBlockheight == null
+                    ? btcTxBlock.getHeight()
+                    : Math.min(minimumBlockheight, btcTxBlock.getHeight());
+            }
+        }
+        if (minimumBlockheight != null) {
+            const txinMap = new Map();
+            const txs = await this.bitcoin.getWalletTransactions(minimumBlockheight);
+            txs.forEach(tx => {
+                tx.ins.forEach(txin => {
+                    txinMap.set(txin.txid + ":" + txin.vout, tx);
+                });
+            });
+            for (let vault of recoveredVaults) {
+                let utxo = vault.data.getUtxo();
+                let btcTx;
+                do {
+                    btcTx = txinMap.get(utxo);
+                    if (btcTx != null) {
+                        const withdrawalData = await chain.spvVaultContract.getWithdrawalData(btcTx);
+                        vault.addWithdrawal(withdrawalData);
+                        utxo = withdrawalData.getCreatedVaultUtxo();
+                    }
+                } while (btcTx != null);
+            }
+        }
+        for (let vault of recoveredVaults) {
+            await this.saveVault(vault);
+        }
+        return recoveredVaults;
+    }
 }
 exports.SpvVaults = SpvVaults;

package/dist/utils/Utils.js

@@ -31,7 +31,8 @@ function expressHandlerWrapper(func) {
                 await func(req, res);
             }
             catch (e) {
-                expressHandlerWrapperLogger.error("Error in called function " + req.path + ": ", e);
+                if (!isDefinedRuntimeError(e) || e._httpStatus !== 200)
+                    expressHandlerWrapperLogger.error("Error in called function " + req.path + ": ", e);
                 let statusCode = 500;
                 const obj = {
                     code: 0,

package/dist/wallets/IBitcoinWallet.d.ts

@@ -23,6 +23,7 @@ export declare abstract class IBitcoinWallet {
     readonly network: BTC_NETWORK;
     protected constructor(network: BTC_NETWORK);
     toOutputScript(address: string): Buffer;
+    fromOutputScript(outputScript: Buffer): string;
     getSignedTransaction(destination: string, amount: number, feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
     getSignedMultiTransaction(destinations: {
         address: string;

package/dist/wallets/IBitcoinWallet.js

@@ -25,6 +25,9 @@ class IBitcoinWallet {
         }
         throw new Error("Unrecognized address type");
     }
+    fromOutputScript(outputScript) {
+        return (0, btc_signer_1.Address)(this.network).encode(btc_signer_1.OutScript.decode(outputScript));
+    }
     getSignedTransaction(destination, amount, feeRate, nonce, maxAllowedFeeRate) {
         return this.getSignedMultiTransaction([{ address: destination, amount }], feeRate, nonce, maxAllowedFeeRate);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/lp-lib",
-  "version": "17.0.1",
+  "version": "17.0.3",
   "description": "Main functionality implementation for atomiq LP node",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

package/src/swaps/spv_vault_swap/SpvVault.ts

@@ -152,8 +152,12 @@ export class SpvVault<
         }
     }
 
+    static _getIdentifier(chainId: string, data: SpvVaultData): string {
+        return chainId+"_"+data.getOwner()+"_"+data.getVaultId().toString(10);
+    }
+
     getIdentifier(): string {
-        return this.chainId+"_"+this.data.getOwner()+"_"+this.data.getVaultId().toString(10);
+        return SpvVault._getIdentifier(this.chainId, this.data);
     }
 
     /**

package/src/swaps/spv_vault_swap/SpvVaults.ts

@@ -1,11 +1,12 @@
 import {SpvVault, SpvVaultState} from "./SpvVault";
 import {
-    BitcoinRpc,
+    BitcoinRpc, BtcBlock, BtcTx,
     IStorageManager,
     SpvVaultClaimEvent,
     SpvVaultCloseEvent,
     SpvVaultDepositEvent,
-    SpvVaultOpenEvent, SpvWithdrawalTransactionData
+    SpvVaultOpenEvent,
+    SpvWithdrawalTransactionData
 } from "@atomiqlabs/base";
 import {SpvVaultSwap} from "./SpvVaultSwap";
 import {bigIntSorter, getLogger} from "../../utils/Utils";
@@ -27,7 +28,7 @@ export class SpvVaults {
 
     readonly bitcoin: IBitcoinWallet;
     readonly vaultSigner: ISpvVaultSigner;
-    readonly bitcoinRpc: BitcoinRpc<any>;
+    readonly bitcoinRpc: BitcoinRpc<BtcBlock>;
     readonly config: {vaultsCheckInterval: number, maxUnclaimedWithdrawals?: number};
     readonly chains: MultichainData;
 
@@ -565,4 +566,74 @@ export class SpvVaults {
         const vaults = await this.vaultStorage.loadData(SpvVault);
     }
 
+    /**
+     * Recovers already created vaults for a given chain from on-chain data. Requires initialized BTC wallet to
+     *  fetch wallet transactions
+     *
+     * @param chainId
+     */
+    async recoverVaults(chainId: string): Promise<SpvVault[]> {
+        const chain = this.chains.chains[chainId];
+        if(chainId==null) throw new Error(`Chain ${chainId} not found in known chains!`);
+        const vaults = await chain.spvVaultContract.getAllVaults(chain.signer.getAddress());
+
+        const recoveredVaults: SpvVault[] = [];
+        let minimumBlockheight = null;
+
+        for(let vaultData of vaults) {
+            const vaultIdentifier = SpvVault._getIdentifier(chainId, vaultData);
+            if(this.vaultStorage.data[vaultIdentifier]!=null) {
+                this.logger.info(`recoverVaults(${chainId}): Skipping vault ${vaultIdentifier}, because it is already known!`);
+                continue;
+            }
+            const [txId, voutStr] = vaultData.getUtxo().split(":");
+            const btcTx = await this.bitcoinRpc.getTransaction(txId);
+            const btcTxOutput = btcTx.outs[parseInt(voutStr)];
+            const vaultAddress = this.bitcoin.fromOutputScript(Buffer.from(btcTxOutput.scriptPubKey.hex, "hex"));
+            const vault = new SpvVault(chainId, vaultData, vaultAddress);
+            vault.state = SpvVaultState.OPENED;
+            recoveredVaults.push(vault);
+            if(await this.bitcoinRpc.isSpent(vaultData.getUtxo())) {
+                if(!this.bitcoin.isReady())
+                    throw new Error("Bitcoin wallet is not ready, but is required to check wallet transactions!");
+
+                //The latest smart chain UTXO is spent, we need to check if we have some further transactions
+                // spending the vault UTXO in our wallet history
+                const btcTxBlock = await this.bitcoinRpc.getBlockHeader(btcTx.blockhash);
+                minimumBlockheight = minimumBlockheight==null
+                    ? btcTxBlock.getHeight()
+                    : Math.min(minimumBlockheight, btcTxBlock.getHeight());
+            }
+        }
+
+        if(minimumBlockheight!=null) {
+            const txinMap = new Map<string, BtcTx>();
+            const txs = await this.bitcoin.getWalletTransactions(minimumBlockheight);
+            txs.forEach(tx => {
+                tx.ins.forEach(txin => {
+                    txinMap.set(txin.txid+":"+txin.vout, tx);
+                })
+            });
+
+            for(let vault of recoveredVaults) {
+                let utxo = vault.data.getUtxo();
+                let btcTx: BtcTx;
+                do {
+                    btcTx = txinMap.get(utxo);
+                    if(btcTx!=null) {
+                        const withdrawalData = await chain.spvVaultContract.getWithdrawalData(btcTx);
+                        vault.addWithdrawal(withdrawalData);
+                        utxo = withdrawalData.getCreatedVaultUtxo();
+                    }
+                } while(btcTx!=null);
+            }
+        }
+
+        for(let vault of recoveredVaults) {
+            await this.saveVault(vault);
+        }
+
+        return recoveredVaults;
+    }
+
 }

package/src/utils/Utils.ts

@@ -53,7 +53,9 @@ export function expressHandlerWrapper(func: (
             try {
                 await func(req, res);
             } catch (e) {
-                expressHandlerWrapperLogger.error("Error in called function "+req.path+": ", e);
+                if(!isDefinedRuntimeError(e) || e._httpStatus!==200)
+                    expressHandlerWrapperLogger.error("Error in called function "+req.path+": ", e);
+
                 let statusCode = 500;
                 const obj: {code: number, msg: string, data?: any} = {
                     code: 0,

package/src/wallets/IBitcoinWallet.ts

@@ -49,6 +49,10 @@ export abstract class IBitcoinWallet {
         throw new Error("Unrecognized address type");
     }
 
+    fromOutputScript(outputScript: Buffer): string {
+        return Address(this.network).encode(OutScript.decode(outputScript));
+    }
+
     getSignedTransaction(destination: string, amount: number, feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse> {
         return this.getSignedMultiTransaction([{address: destination, amount}], feeRate, nonce, maxAllowedFeeRate);
     }