@bitgo/abstract-utxo 10.5.0 → 10.7.0

package/dist/esm/recovery/backupKeyRecovery.js

@@ -0,0 +1,329 @@
+import assert from 'assert';
+import _ from 'lodash';
+import * as utxolib from '@bitgo/utxo-lib';
+import { Dimensions } from '@bitgo/unspents';
+import { ErrorNoInputToRecover, getKrsProvider, getBip32Keys, getIsKrsRecovery, getIsUnsignedSweep, isTriple, krsProviders, } from '@bitgo/sdk-core';
+import { getMainnet, networks } from '@bitgo/utxo-lib';
+import { signAndVerifyPsbt } from '../sign';
+import { forCoin } from './RecoveryProvider';
+import { MempoolApi } from './mempoolApi';
+import { CoingeckoApi } from './coingeckoApi';
+const { getInternalChainCode, scriptTypeForChain, outputScripts, getExternalChainCode } = utxolib.bitgo;
+/**
+ * This transforms the txInfo from recover into the format that offline-signing-tool expects
+ * @param coinName
+ * @param txInfo
+ * @param txHex
+ * @returns {{txHex: *, txInfo: {unspents: *}, feeInfo: {}, coin: void}}
+ */
+function formatForOfflineVault(coinName, txInfo, txHex) {
+    return {
+        txHex,
+        txInfo: {
+            unspents: txInfo.inputs.map((input) => {
+                assert(input.valueString);
+                return { ...input, valueString: input.valueString };
+            }),
+        },
+        feeInfo: {},
+        coin: coinName,
+    };
+}
+/**
+ * Get the current market price from a third party to be used for recovery
+ * This function is only intended for non-bitgo recovery transactions, when it is necessary
+ * to calculate the rough fee needed to pay to Keyternal. We are okay with approximating,
+ * because the resulting price of this function only has less than 1 dollar influence on the
+ * fee that needs to be paid to Keyternal.
+ *
+ * See calculateFeeAmount function:  return Math.round(feeAmountUsd / currentPrice * self.getBaseFactor());
+ *
+ * This end function should not be used as an accurate endpoint, since some coins' prices are missing from the provider
+ */
+async function getRecoveryMarketPrice(coin) {
+    return await new CoingeckoApi().getUSDPrice(coin.getFamily());
+}
+/**
+ * Calculates the amount (in base units) to pay a KRS provider when building a recovery transaction
+ * @param coin
+ * @param params
+ * @param params.provider {String} the KRS provider that holds the backup key
+ * @returns {*}
+ */
+async function calculateFeeAmount(coin, params) {
+    const krsProvider = krsProviders[params.provider];
+    if (krsProvider === undefined) {
+        throw new Error(`no fee structure specified for provider ${params.provider}`);
+    }
+    if (krsProvider.feeType === 'flatUsd') {
+        const feeAmountUsd = krsProvider.feeAmount;
+        const currentPrice = await getRecoveryMarketPrice(coin);
+        return Math.round((feeAmountUsd / currentPrice) * coin.getBaseFactor());
+    }
+    else {
+        // we can add more fee structures here as needed for different providers, such as percentage of recovery amount
+        throw new Error('Fee structure not implemented');
+    }
+}
+function getFormattedAddress(coin, address) {
+    // Blockchair uses cashaddr format when querying the API for address information. Convert legacy addresses to cashaddr
+    // before querying the API.
+    return coin.getChain() === 'bch' || coin.getChain() === 'bcha'
+        ? coin.canonicalAddress(address.address, 'cashaddr').split(':')[1]
+        : address.address;
+}
+async function queryBlockchainUnspentsPath(coin, params, walletKeys, chain) {
+    const scriptType = scriptTypeForChain(chain);
+    const fetchPrevTx = !utxolib.bitgo.outputScripts.hasWitnessData(scriptType) && getMainnet(coin.network) !== networks.zcash;
+    const recoveryProvider = params.recoveryProvider ?? forCoin(coin.getChain(), params.apiKey);
+    const MAX_SEQUENTIAL_ADDRESSES_WITHOUT_TXS = params.scan || 20;
+    let numSequentialAddressesWithoutTxs = 0;
+    const prevTxCache = new Map();
+    async function getPrevTx(txid) {
+        let prevTxHex = prevTxCache.get(txid);
+        if (!prevTxHex) {
+            prevTxHex = await recoveryProvider.getTransactionHex(txid);
+            prevTxCache.set(txid, prevTxHex);
+        }
+        return prevTxHex;
+    }
+    async function gatherUnspents(addrIndex) {
+        const walletKeysForUnspent = walletKeys.deriveForChainAndIndex(chain, addrIndex);
+        const address = coin.createMultiSigAddress(scriptType, 2, walletKeysForUnspent.publicKeys);
+        const formattedAddress = getFormattedAddress(coin, address);
+        const addrInfo = await recoveryProvider.getAddressInfo(formattedAddress);
+        // we use txCount here because it implies usage - having tx'es means the addr was generated and used
+        if (addrInfo.txCount === 0) {
+            numSequentialAddressesWithoutTxs++;
+        }
+        else {
+            numSequentialAddressesWithoutTxs = 0;
+            if (addrInfo.balance > 0) {
+                console.log(`Found an address with balance: ${address.address} with balance ${addrInfo.balance}`);
+                const addressUnspents = await recoveryProvider.getUnspentsForAddresses([formattedAddress]);
+                const processedUnspents = await Promise.all(addressUnspents.map(async (u) => {
+                    const { txid, vout } = utxolib.bitgo.parseOutputId(u.id);
+                    let val = BigInt(u.value);
+                    if (coin.amountType === 'bigint') {
+                        // blockchair returns the number with the correct precision, but in number format
+                        // json parse won't parse it correctly, so we requery the txid for the tx hex to decode here
+                        if (!Number.isSafeInteger(u.value)) {
+                            const txHex = await getPrevTx(txid);
+                            const tx = coin.createTransactionFromHex(txHex);
+                            val = tx.outs[vout].value;
+                        }
+                    }
+                    // the api may return cashaddr's instead of legacy for BCH and BCHA
+                    // downstream processes's only expect legacy addresses
+                    u = { ...u, address: coin.canonicalAddress(u.address) };
+                    return {
+                        ...u,
+                        value: val,
+                        chain: chain,
+                        index: addrIndex,
+                        prevTx: fetchPrevTx ? Buffer.from(await getPrevTx(txid), 'hex') : undefined,
+                    };
+                }));
+                walletUnspents.push(...processedUnspents);
+            }
+        }
+        if (numSequentialAddressesWithoutTxs >= MAX_SEQUENTIAL_ADDRESSES_WITHOUT_TXS) {
+            // stop searching for addresses with unspents in them, we've found ${MAX_SEQUENTIAL_ADDRESSES_WITHOUT_TXS} in a row with none
+            // we are done
+            return;
+        }
+        return gatherUnspents(addrIndex + 1);
+    }
+    // get unspents for these addresses
+    const walletUnspents = [];
+    // This will populate walletAddresses
+    await gatherUnspents(0);
+    if (walletUnspents.length === 0) {
+        // Couldn't find any addresses with funds
+        return [];
+    }
+    return walletUnspents;
+}
+async function getRecoveryFeePerBytes(coin, { defaultValue }) {
+    if (coin.getFamily() === 'doge') {
+        // https://github.com/dogecoin/dogecoin/blob/master/doc/fee-recommendation.md
+        // 0.01 DOGE per KB
+        return 1000;
+    }
+    try {
+        return await MempoolApi.forCoin(coin.getChain()).getRecoveryFeePerBytes();
+    }
+    catch (e) {
+        console.dir(e);
+        return defaultValue;
+    }
+}
+/**
+ * Builds a funds recovery transaction without BitGo.
+ *
+ * Returns transaction hex in legacy format for unsigned sweep transaction, half signed backup recovery transaction with KRS provider (only keyternal),
+ * fully signed backup recovery transaction without a KRS provider.
+ *
+ * Returns PSBT hex for half signed backup recovery transaction with KRS provider (excluding keyternal)
+ * For PSBT hex cases, Unspents are not required in response.
+ *
+ * @param coin
+ * @param bitgo
+ * @param params
+ * - userKey: [encrypted] xprv, or xpub
+ * - backupKey: [encrypted] xprv, or xpub if the xprv is held by a KRS provider
+ * - walletPassphrase: necessary if one of the xprvs is encrypted
+ * - bitgoKey: xpub
+ * - krsProvider: necessary if backup key is held by KRS
+ * - recoveryDestination: target address to send recovered funds to
+ * - scan: the amount of consecutive addresses without unspents to scan through before stopping
+ * - ignoreAddressTypes: (optional) scripts to ignore
+ *        for example: ['p2shP2wsh', 'p2wsh'] will prevent code from checking for wrapped-segwit and native-segwit chains on the public block explorers
+ */
+export async function backupKeyRecovery(coin, bitgo, params) {
+    if (_.isUndefined(params.userKey)) {
+        throw new Error('missing userKey');
+    }
+    if (_.isUndefined(params.backupKey)) {
+        throw new Error('missing backupKey');
+    }
+    if (_.isUndefined(params.recoveryDestination) ||
+        !coin.isValidAddress(params.recoveryDestination, { anyFormat: true })) {
+        throw new Error('invalid recoveryDestination');
+    }
+    if (!_.isUndefined(params.scan) && (!_.isInteger(params.scan) || params.scan < 0)) {
+        throw new Error('scan must be a positive integer');
+    }
+    if (params.feeRate !== undefined && (!Number.isFinite(params.feeRate) || params.feeRate <= 0)) {
+        throw new Error('feeRate must be a positive number');
+    }
+    const isKrsRecovery = getIsKrsRecovery(params);
+    const isUnsignedSweep = getIsUnsignedSweep(params);
+    const responseTxFormat = isUnsignedSweep || !isKrsRecovery || params.krsProvider === 'keyternal' ? 'legacy' : 'psbt';
+    const krsProvider = isKrsRecovery ? getKrsProvider(coin, params.krsProvider) : undefined;
+    // check whether key material and password authenticate the users and return parent keys of all three keys of the wallet
+    const keys = getBip32Keys(bitgo, params, { requireBitGoXpub: true });
+    if (!isTriple(keys)) {
+        throw new Error(`expected key triple`);
+    }
+    const walletKeys = new utxolib.bitgo.RootWalletKeys(keys, [
+        params.userKeyPath || utxolib.bitgo.RootWalletKeys.defaultPrefix,
+        utxolib.bitgo.RootWalletKeys.defaultPrefix,
+        utxolib.bitgo.RootWalletKeys.defaultPrefix,
+    ]);
+    const unspents = (await Promise.all(outputScripts.scriptTypes2Of3
+        .filter((addressType) => coin.supportsAddressType(addressType) && !params.ignoreAddressTypes?.includes(addressType))
+        .reduce((queries, addressType) => [
+        ...queries,
+        queryBlockchainUnspentsPath(coin, params, walletKeys, getExternalChainCode(addressType)),
+        queryBlockchainUnspentsPath(coin, params, walletKeys, getInternalChainCode(addressType)),
+    ], []))).flat();
+    // Execute the queries and gather the unspents
+    const totalInputAmount = utxolib.bitgo.unspentSum(unspents, 'bigint');
+    if (totalInputAmount <= BigInt(0)) {
+        throw new ErrorNoInputToRecover();
+    }
+    // Build the psbt
+    const psbt = utxolib.bitgo.createPsbtForNetwork({ network: coin.network });
+    // xpubs can become handy for many things.
+    utxolib.bitgo.addXpubsToPsbt(psbt, walletKeys);
+    const txInfo = {};
+    const feePerByte = params.feeRate !== undefined ? params.feeRate : await getRecoveryFeePerBytes(coin, { defaultValue: 50 });
+    // KRS recovery transactions have a 2nd output to pay the recovery fee, like paygo fees.
+    const dimensions = Dimensions.fromPsbt(psbt).plus(isKrsRecovery ? Dimensions.SingleOutput.p2wsh : Dimensions.ZERO);
+    const approximateFee = BigInt(dimensions.getVSize() * feePerByte);
+    txInfo.inputs =
+        responseTxFormat === 'legacy'
+            ? unspents.map((u) => ({ ...u, value: Number(u.value), valueString: u.value.toString(), prevTx: undefined }))
+            : undefined;
+    unspents.forEach((unspent) => {
+        utxolib.bitgo.addWalletUnspentToPsbt(psbt, unspent, walletKeys, 'user', 'backup');
+    });
+    let krsFee = BigInt(0);
+    if (isKrsRecovery && params.krsProvider) {
+        try {
+            krsFee = BigInt(await calculateFeeAmount(coin, { provider: params.krsProvider }));
+        }
+        catch (err) {
+            // Don't let this error block the recovery -
+            console.dir(err);
+        }
+    }
+    const recoveryAmount = totalInputAmount - approximateFee - krsFee;
+    if (recoveryAmount < BigInt(0)) {
+        throw new Error(`this wallet\'s balance is too low to pay the fees specified by the KRS provider. 
+          Existing balance on wallet: ${totalInputAmount.toString()}. Estimated network fee for the recovery transaction
+          : ${approximateFee.toString()}, KRS fee to pay: ${krsFee.toString()}. After deducting fees, your total 
+          recoverable balance is ${recoveryAmount.toString()}`);
+    }
+    const recoveryOutputScript = utxolib.address.toOutputScript(params.recoveryDestination, coin.network);
+    psbt.addOutput({ script: recoveryOutputScript, value: recoveryAmount });
+    if (krsProvider && krsFee > BigInt(0)) {
+        if (!krsProvider.feeAddresses) {
+            throw new Error(`keyProvider must define feeAddresses`);
+        }
+        const krsFeeAddress = krsProvider.feeAddresses[coin.getChain()];
+        if (!krsFeeAddress) {
+            throw new Error('this KRS provider has not configured their fee structure yet - recovery cannot be completed');
+        }
+        const krsFeeOutputScript = utxolib.address.toOutputScript(krsFeeAddress, coin.network);
+        psbt.addOutput({ script: krsFeeOutputScript, value: krsFee });
+    }
+    if (isUnsignedSweep) {
+        // TODO BTC-317 - When ready to PSBTify OVC, send psbt hex and skip unspents in response.
+        const txHex = psbt.getUnsignedTx().toBuffer().toString('hex');
+        return formatForOfflineVault(coin.getChain(), txInfo, txHex);
+    }
+    else {
+        signAndVerifyPsbt(psbt, walletKeys.user, { isLastSignature: false });
+        if (isKrsRecovery) {
+            // The KRS provider keyternal solely supports P2SH, P2WSH, and P2SH-P2WSH input script types.
+            // It currently uses an outdated BitGoJS SDK, which relies on a legacy transaction builder for cosigning.
+            // Unfortunately, upgrading the keyternal code presents challenges,
+            // which hinders the integration of the latest BitGoJS SDK with PSBT signing support.
+            txInfo.transactionHex =
+                params.krsProvider === 'keyternal'
+                    ? utxolib.bitgo.extractP2msOnlyHalfSignedTx(psbt).toBuffer().toString('hex')
+                    : psbt.toHex();
+        }
+        else {
+            const tx = signAndVerifyPsbt(psbt, walletKeys.backup, { isLastSignature: true });
+            txInfo.transactionHex = tx.toBuffer().toString('hex');
+        }
+    }
+    if (isKrsRecovery) {
+        txInfo.coin = coin.getChain();
+        txInfo.backupKey = params.backupKey;
+        txInfo.recoveryAmount = Number(recoveryAmount);
+        txInfo.recoveryAmountString = recoveryAmount.toString();
+    }
+    return txInfo;
+}
+export async function v1BackupKeyRecovery(coin, bitgo, params) {
+    if (_.isUndefined(params.recoveryDestination) ||
+        !coin.isValidAddress(params.recoveryDestination, { anyFormat: true })) {
+        throw new Error('invalid recoveryDestination');
+    }
+    const recoveryFeePerByte = await getRecoveryFeePerBytes(coin, { defaultValue: 50 });
+    const v1wallet = await bitgo.wallets().get({ id: params.walletId });
+    return await v1wallet.recover({
+        ...params,
+        feeRate: recoveryFeePerByte,
+    });
+}
+export async function v1Sweep(coin, bitgo, params) {
+    if (_.isUndefined(params.recoveryDestination) ||
+        !coin.isValidAddress(params.recoveryDestination, { anyFormat: true })) {
+        throw new Error('invalid recoveryDestination');
+    }
+    let recoveryFeePerByte = 100;
+    if (bitgo.env === 'prod') {
+        recoveryFeePerByte = await getRecoveryFeePerBytes(coin, { defaultValue: 100 });
+    }
+    const v1wallet = await bitgo.wallets().get({ id: params.walletId });
+    return await v1wallet.sweep({
+        ...params,
+        feeRate: recoveryFeePerByte,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backupKeyRecovery.js","sourceRoot":"","sources":["../../../src/recovery/backupKeyRecovery.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,OAAO,CAAC,MAAM,QAAQ,CAAC;AACvB,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAEL,qBAAqB,EACrB,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,QAAQ,EACR,YAAY,GACb,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAGvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE5C,OAAO,EAAE,OAAO,EAAoB,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAU9C,MAAM,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,aAAa,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC;AAexG;;;;;;GAMG;AACH,SAAS,qBAAqB,CAC5B,QAAgB,EAChB,MAA0B,EAC1B,KAAa;IAEb,OAAO;QACL,KAAK;QACL,MAAM,EAAE;YACN,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;gBACpC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;gBAC1B,OAAO,EAAE,GAAG,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC;YACtD,CAAC,CAAC;SACH;QACD,OAAO,EAAE,EAAE;QACX,IAAI,EAAE,QAAQ;KACf,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,KAAK,UAAU,sBAAsB,CAAC,IAAsB;IAC1D,OAAO,MAAM,IAAI,YAAY,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,kBAAkB,CAAC,IAAsB,EAAE,MAA4B;IACpF,MAAM,WAAW,GAAG,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAElD,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,2CAA2C,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;IAChF,CAAC;IAED,IAAI,WAAW,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QACtC,MAAM,YAAY,GAAG,WAAW,CAAC,SAAS,CAAC;QAC3C,MAAM,YAAY,GAAW,MAAM,sBAAsB,CAAC,IAAI,CAAC,CAAC;QAEhE,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,YAAY,GAAG,YAAY,CAAC,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;IAC1E,CAAC;SAAM,CAAC;QACN,+GAA+G;QAC/G,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;IACnD,CAAC;AACH,CAAC;AAiBD,SAAS,mBAAmB,CAAC,IAAsB,EAAE,OAAwB;IAC3E,sHAAsH;IACtH,2BAA2B;IAC3B,OAAO,IAAI,CAAC,QAAQ,EAAE,KAAK,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE,KAAK,MAAM;QAC5D,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAClE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;AACtB,CAAC;AAED,KAAK,UAAU,2BAA2B,CACxC,IAAsB,EACtB,MAAqB,EACrB,UAA0B,EAC1B,KAAgB;IAEhB,MAAM,UAAU,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAC7C,MAAM,WAAW,GACf,CAAC,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,cAAc,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,KAAK,CAAC;IACzG,MAAM,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5F,MAAM,oCAAoC,GAAG,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;IAC/D,IAAI,gCAAgC,GAAG,CAAC,CAAC;IACzC,MAAM,WAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;IAE9C,KAAK,UAAU,SAAS,CAAC,IAAY;QACnC,IAAI,SAAS,GAAG,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,SAAS,GAAG,MAAM,gBAAgB,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAC3D,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,KAAK,UAAU,cAAc,CAAC,SAAiB;QAC7C,MAAM,oBAAoB,GAAG,UAAU,CAAC,sBAAsB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QACjF,MAAM,OAAO,GAAG,IAAI,CAAC,qBAAqB,CAAC,UAAU,EAAE,CAAC,EAAE,oBAAoB,CAAC,UAAU,CAAC,CAAC;QAE3F,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC5D,MAAM,QAAQ,GAAG,MAAM,gBAAgB,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAC;QACzE,oGAAoG;QACpG,IAAI,QAAQ,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;YAC3B,gCAAgC,EAAE,CAAC;QACrC,CAAC;aAAM,CAAC;YACN,gCAAgC,GAAG,CAAC,CAAC;YAErC,IAAI,QAAQ,CAAC,OAAO,GAAG,CAAC,EAAE,CAAC;gBACzB,OAAO,CAAC,GAAG,CAAC,kCAAkC,OAAO,CAAC,OAAO,iBAAiB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;gBAClG,MAAM,eAAe,GAAG,MAAM,gBAAgB,CAAC,uBAAuB,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC;gBAC3F,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC,GAAG,CACzC,eAAe,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAkC,EAAE;oBAC9D,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;oBACzD,IAAI,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;oBAC1B,IAAI,IAAI,CAAC,UAAU,KAAK,QAAQ,EAAE,CAAC;wBACjC,iFAAiF;wBACjF,4FAA4F;wBAC5F,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;4BACnC,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,CAAC;4BACpC,MAAM,EAAE,GAAG,IAAI,CAAC,wBAAwB,CAAS,KAAK,CAAC,CAAC;4BACxD,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC;wBAC5B,CAAC;oBACH,CAAC;oBACD,mEAAmE;oBACnE,sDAAsD;oBACtD,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;oBACxD,OAAO;wBACL,GAAG,CAAC;wBACJ,KAAK,EAAE,GAAG;wBACV,KAAK,EAAE,KAAK;wBACZ,KAAK,EAAE,SAAS;wBAChB,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,SAAS,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS;qBACnD,CAAC;gBAC7B,CAAC,CAAC,CACH,CAAC;gBAEF,cAAc,CAAC,IAAI,CAAC,GAAG,iBAAiB,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;QAED,IAAI,gCAAgC,IAAI,oCAAoC,EAAE,CAAC;YAC7E,6HAA6H;YAC7H,cAAc;YACd,OAAO;QACT,CAAC;QAED,OAAO,cAAc,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;IACvC,CAAC;IAED,mCAAmC;IAEnC,MAAM,cAAc,GAA4B,EAAE,CAAC;IACnD,qCAAqC;IACrC,MAAM,cAAc,CAAC,CAAC,CAAC,CAAC;IAExB,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChC,yCAAyC;QACzC,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,OAAO,cAAc,CAAC;AACxB,CAAC;AAED,KAAK,UAAU,sBAAsB,CACnC,IAAsB,EACtB,EAAE,YAAY,EAA4B;IAE1C,IAAI,IAAI,CAAC,SAAS,EAAE,KAAK,MAAM,EAAE,CAAC;QAChC,6EAA6E;QAC7E,mBAAmB;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC;QACH,OAAO,MAAM,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,sBAAsB,EAAE,CAAC;IAC5E,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACf,OAAO,YAAY,CAAC;IACtB,CAAC;AACH,CAAC;AAWD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,IAAsB,EACtB,KAAgB,EAChB,MAAqB;IAErB,IAAI,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;IAED,IAAI,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACvC,CAAC;IAED,IACE,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,mBAAmB,CAAC;QACzC,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,mBAAmB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,EACrE,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;IACjD,CAAC;IAED,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,EAAE,CAAC;QAClF,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;IACrD,CAAC;IAED,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC,EAAE,CAAC;QAC9F,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;IACvD,CAAC;IAED,MAAM,aAAa,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAC/C,MAAM,eAAe,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACnD,MAAM,gBAAgB,GAAG,eAAe,IAAI,CAAC,aAAa,IAAI,MAAM,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC;IAErH,MAAM,WAAW,GAAG,aAAa,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAEzF,wHAAwH;IACxH,MAAM,IAAI,GAAG,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAC,CAAC;IACrE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;IACzC,CAAC;IACD,MAAM,UAAU,GAAG,IAAI,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,IAAI,EAAE;QACxD,MAAM,CAAC,WAAW,IAAI,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,aAAa;QAChE,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,aAAa;QAC1C,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,aAAa;KAC3C,CAAC,CAAC;IAEH,MAAM,QAAQ,GAA4B,CACxC,MAAM,OAAO,CAAC,GAAG,CACf,aAAa,CAAC,eAAe;SAC1B,MAAM,CACL,CAAC,WAAW,EAAE,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAAC,CAC5G;SACA,MAAM,CACL,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,CAAC;QACxB,GAAG,OAAO;QACV,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,oBAAoB,CAAC,WAAW,CAAC,CAAC;QACxF,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,oBAAoB,CAAC,WAAW,CAAC,CAAC;KACzF,EACD,EAAwC,CACzC,CACJ,CACF,CAAC,IAAI,EAAE,CAAC;IAET,8CAA8C;IAC9C,MAAM,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACtE,IAAI,gBAAgB,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QAClC,MAAM,IAAI,qBAAqB,EAAE,CAAC;IACpC,CAAC;IAED,iBAAiB;IACjB,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,oBAAoB,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IAC3E,0CAA0C;IAC1C,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAC/C,MAAM,MAAM,GAAG,EAAqC,CAAC;IACrD,MAAM,UAAU,GACd,MAAM,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,sBAAsB,CAAC,IAAI,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC,CAAC;IAE3G,wFAAwF;IACxF,MAAM,UAAU,GAAG,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IACnH,MAAM,cAAc,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,GAAG,UAAU,CAAC,CAAC;IAElE,MAAM,CAAC,MAAM;QACX,gBAAgB,KAAK,QAAQ;YAC3B,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;YAC7G,CAAC,CAAC,SAAS,CAAC;IAEhB,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC3B,OAAO,CAAC,KAAK,CAAC,sBAAsB,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IACpF,CAAC,CAAC,CAAC;IAEH,IAAI,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACvB,IAAI,aAAa,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;QACxC,IAAI,CAAC;YACH,MAAM,GAAG,MAAM,CAAC,MAAM,kBAAkB,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;QACpF,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,4CAA4C;YAC5C,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACnB,CAAC;IACH,CAAC;IAED,MAAM,cAAc,GAAG,gBAAgB,GAAG,cAAc,GAAG,MAAM,CAAC;IAElE,IAAI,cAAc,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/B,MAAM,IAAI,KAAK,CAAC;wCACoB,gBAAgB,CAAC,QAAQ,EAAE;cACrD,cAAc,CAAC,QAAQ,EAAE,qBAAqB,MAAM,CAAC,QAAQ,EAAE;mCAC1C,cAAc,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED,MAAM,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,mBAAmB,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACtG,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,oBAAoB,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC,CAAC;IAExE,IAAI,WAAW,IAAI,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QACtC,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QAC1D,CAAC;QAED,MAAM,aAAa,GAAG,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAEhE,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,6FAA6F,CAAC,CAAC;QACjH,CAAC;QAED,MAAM,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACvF,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;IAChE,CAAC;IAED,IAAI,eAAe,EAAE,CAAC;QACpB,yFAAyF;QACzF,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC9D,OAAO,qBAAqB,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,MAA4B,EAAE,KAAK,CAAC,CAAC;IACrF,CAAC;SAAM,CAAC;QACN,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC,CAAC;QACrE,IAAI,aAAa,EAAE,CAAC;YAClB,6FAA6F;YAC7F,yGAAyG;YACzG,mEAAmE;YACnE,qFAAqF;YACrF,MAAM,CAAC,cAAc;gBACnB,MAAM,CAAC,WAAW,KAAK,WAAW;oBAChC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC;oBAC5E,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;QACrB,CAAC;aAAM,CAAC;YACN,MAAM,EAAE,GAAG,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,MAAM,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;YACjF,MAAM,CAAC,cAAc,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAED,IAAI,aAAa,EAAE,CAAC;QAClB,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC9B,MAAM,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QACpC,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;QAC/C,MAAM,CAAC,oBAAoB,GAAG,cAAc,CAAC,QAAQ,EAAE,CAAC;IAC1D,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAqBD,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,IAAsB,EACtB,KAAgB,EAChB,MAAuB;IAEvB,IACE,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,mBAAmB,CAAC;QACzC,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,mBAAmB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,EACrE,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;IACjD,CAAC;IAED,MAAM,kBAAkB,GAAG,MAAM,sBAAsB,CAAC,IAAI,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC,CAAC;IACpF,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;IACpE,OAAO,MAAM,QAAQ,CAAC,OAAO,CAAC;QAC5B,GAAG,MAAM;QACT,OAAO,EAAE,kBAAkB;KAC5B,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,IAAsB,EACtB,KAAgB,EAChB,MAAqB;IAMrB,IACE,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,mBAAmB,CAAC;QACzC,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,mBAAmB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,EACrE,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;IACjD,CAAC;IAED,IAAI,kBAAkB,GAAG,GAAG,CAAC;IAC7B,IAAI,KAAK,CAAC,GAAG,KAAK,MAAM,EAAE,CAAC;QACzB,kBAAkB,GAAG,MAAM,sBAAsB,CAAC,IAAI,EAAE,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,CAAC;IACjF,CAAC;IAED,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;IACpE,OAAO,MAAM,QAAQ,CAAC,KAAK,CAAC;QAC1B,GAAG,MAAM;QACT,OAAO,EAAE,kBAAkB;KAC5B,CAAC,CAAC;AACL,CAAC","sourcesContent":["import assert from 'assert';\n\nimport _ from 'lodash';\nimport * as utxolib from '@bitgo/utxo-lib';\nimport { Dimensions } from '@bitgo/unspents';\nimport {\n  BitGoBase,\n  ErrorNoInputToRecover,\n  getKrsProvider,\n  getBip32Keys,\n  getIsKrsRecovery,\n  getIsUnsignedSweep,\n  isTriple,\n  krsProviders,\n} from '@bitgo/sdk-core';\nimport { getMainnet, networks } from '@bitgo/utxo-lib';\n\nimport { AbstractUtxoCoin, MultiSigAddress } from '../abstractUtxoCoin';\nimport { signAndVerifyPsbt } from '../sign';\n\nimport { forCoin, RecoveryProvider } from './RecoveryProvider';\nimport { MempoolApi } from './mempoolApi';\nimport { CoingeckoApi } from './coingeckoApi';\n\ntype ScriptType2Of3 = utxolib.bitgo.outputScripts.ScriptType2Of3;\ntype ChainCode = utxolib.bitgo.ChainCode;\ntype RootWalletKeys = utxolib.bitgo.RootWalletKeys;\ntype WalletUnspent<TNumber extends number | bigint> = utxolib.bitgo.WalletUnspent<TNumber>;\ntype WalletUnspentJSON = utxolib.bitgo.WalletUnspent & {\n  valueString: string;\n};\n\nconst { getInternalChainCode, scriptTypeForChain, outputScripts, getExternalChainCode } = utxolib.bitgo;\n\nexport interface OfflineVaultTxInfo {\n  inputs: WalletUnspentJSON[];\n}\n\nexport interface FormattedOfflineVaultTxInfo {\n  txInfo: {\n    unspents: WalletUnspentJSON[];\n  };\n  txHex: string;\n  feeInfo: Record<string, never>;\n  coin: string;\n}\n\n/**\n * This transforms the txInfo from recover into the format that offline-signing-tool expects\n * @param coinName\n * @param txInfo\n * @param txHex\n * @returns {{txHex: *, txInfo: {unspents: *}, feeInfo: {}, coin: void}}\n */\nfunction formatForOfflineVault(\n  coinName: string,\n  txInfo: OfflineVaultTxInfo,\n  txHex: string\n): FormattedOfflineVaultTxInfo {\n  return {\n    txHex,\n    txInfo: {\n      unspents: txInfo.inputs.map((input) => {\n        assert(input.valueString);\n        return { ...input, valueString: input.valueString };\n      }),\n    },\n    feeInfo: {},\n    coin: coinName,\n  };\n}\n\n/**\n * Get the current market price from a third party to be used for recovery\n * This function is only intended for non-bitgo recovery transactions, when it is necessary\n * to calculate the rough fee needed to pay to Keyternal. We are okay with approximating,\n * because the resulting price of this function only has less than 1 dollar influence on the\n * fee that needs to be paid to Keyternal.\n *\n * See calculateFeeAmount function:  return Math.round(feeAmountUsd / currentPrice * self.getBaseFactor());\n *\n * This end function should not be used as an accurate endpoint, since some coins' prices are missing from the provider\n */\nasync function getRecoveryMarketPrice(coin: AbstractUtxoCoin): Promise<number> {\n  return await new CoingeckoApi().getUSDPrice(coin.getFamily());\n}\n\n/**\n * Calculates the amount (in base units) to pay a KRS provider when building a recovery transaction\n * @param coin\n * @param params\n * @param params.provider {String} the KRS provider that holds the backup key\n * @returns {*}\n */\nasync function calculateFeeAmount(coin: AbstractUtxoCoin, params: { provider: string }): Promise<number> {\n  const krsProvider = krsProviders[params.provider];\n\n  if (krsProvider === undefined) {\n    throw new Error(`no fee structure specified for provider ${params.provider}`);\n  }\n\n  if (krsProvider.feeType === 'flatUsd') {\n    const feeAmountUsd = krsProvider.feeAmount;\n    const currentPrice: number = await getRecoveryMarketPrice(coin);\n\n    return Math.round((feeAmountUsd / currentPrice) * coin.getBaseFactor());\n  } else {\n    // we can add more fee structures here as needed for different providers, such as percentage of recovery amount\n    throw new Error('Fee structure not implemented');\n  }\n}\n\nexport interface RecoverParams {\n  scan?: number;\n  userKey: string;\n  backupKey: string;\n  bitgoKey: string;\n  recoveryDestination: string;\n  krsProvider?: string;\n  ignoreAddressTypes: ScriptType2Of3[];\n  walletPassphrase?: string;\n  apiKey?: string;\n  userKeyPath?: string;\n  recoveryProvider?: RecoveryProvider;\n  feeRate?: number;\n}\n\nfunction getFormattedAddress(coin: AbstractUtxoCoin, address: MultiSigAddress) {\n  // Blockchair uses cashaddr format when querying the API for address information. Convert legacy addresses to cashaddr\n  // before querying the API.\n  return coin.getChain() === 'bch' || coin.getChain() === 'bcha'\n    ? coin.canonicalAddress(address.address, 'cashaddr').split(':')[1]\n    : address.address;\n}\n\nasync function queryBlockchainUnspentsPath(\n  coin: AbstractUtxoCoin,\n  params: RecoverParams,\n  walletKeys: RootWalletKeys,\n  chain: ChainCode\n): Promise<WalletUnspent<bigint>[]> {\n  const scriptType = scriptTypeForChain(chain);\n  const fetchPrevTx =\n    !utxolib.bitgo.outputScripts.hasWitnessData(scriptType) && getMainnet(coin.network) !== networks.zcash;\n  const recoveryProvider = params.recoveryProvider ?? forCoin(coin.getChain(), params.apiKey);\n  const MAX_SEQUENTIAL_ADDRESSES_WITHOUT_TXS = params.scan || 20;\n  let numSequentialAddressesWithoutTxs = 0;\n  const prevTxCache = new Map<string, string>();\n\n  async function getPrevTx(txid: string): Promise<string> {\n    let prevTxHex = prevTxCache.get(txid);\n    if (!prevTxHex) {\n      prevTxHex = await recoveryProvider.getTransactionHex(txid);\n      prevTxCache.set(txid, prevTxHex);\n    }\n    return prevTxHex;\n  }\n\n  async function gatherUnspents(addrIndex: number) {\n    const walletKeysForUnspent = walletKeys.deriveForChainAndIndex(chain, addrIndex);\n    const address = coin.createMultiSigAddress(scriptType, 2, walletKeysForUnspent.publicKeys);\n\n    const formattedAddress = getFormattedAddress(coin, address);\n    const addrInfo = await recoveryProvider.getAddressInfo(formattedAddress);\n    // we use txCount here because it implies usage - having tx'es means the addr was generated and used\n    if (addrInfo.txCount === 0) {\n      numSequentialAddressesWithoutTxs++;\n    } else {\n      numSequentialAddressesWithoutTxs = 0;\n\n      if (addrInfo.balance > 0) {\n        console.log(`Found an address with balance: ${address.address} with balance ${addrInfo.balance}`);\n        const addressUnspents = await recoveryProvider.getUnspentsForAddresses([formattedAddress]);\n        const processedUnspents = await Promise.all(\n          addressUnspents.map(async (u): Promise<WalletUnspent<bigint>> => {\n            const { txid, vout } = utxolib.bitgo.parseOutputId(u.id);\n            let val = BigInt(u.value);\n            if (coin.amountType === 'bigint') {\n              // blockchair returns the number with the correct precision, but in number format\n              // json parse won't parse it correctly, so we requery the txid for the tx hex to decode here\n              if (!Number.isSafeInteger(u.value)) {\n                const txHex = await getPrevTx(txid);\n                const tx = coin.createTransactionFromHex<bigint>(txHex);\n                val = tx.outs[vout].value;\n              }\n            }\n            // the api may return cashaddr's instead of legacy for BCH and BCHA\n            // downstream processes's only expect legacy addresses\n            u = { ...u, address: coin.canonicalAddress(u.address) };\n            return {\n              ...u,\n              value: val,\n              chain: chain,\n              index: addrIndex,\n              prevTx: fetchPrevTx ? Buffer.from(await getPrevTx(txid), 'hex') : undefined,\n            } as WalletUnspent<bigint>;\n          })\n        );\n\n        walletUnspents.push(...processedUnspents);\n      }\n    }\n\n    if (numSequentialAddressesWithoutTxs >= MAX_SEQUENTIAL_ADDRESSES_WITHOUT_TXS) {\n      // stop searching for addresses with unspents in them, we've found ${MAX_SEQUENTIAL_ADDRESSES_WITHOUT_TXS} in a row with none\n      // we are done\n      return;\n    }\n\n    return gatherUnspents(addrIndex + 1);\n  }\n\n  // get unspents for these addresses\n\n  const walletUnspents: WalletUnspent<bigint>[] = [];\n  // This will populate walletAddresses\n  await gatherUnspents(0);\n\n  if (walletUnspents.length === 0) {\n    // Couldn't find any addresses with funds\n    return [];\n  }\n\n  return walletUnspents;\n}\n\nasync function getRecoveryFeePerBytes(\n  coin: AbstractUtxoCoin,\n  { defaultValue }: { defaultValue: number }\n): Promise<number> {\n  if (coin.getFamily() === 'doge') {\n    // https://github.com/dogecoin/dogecoin/blob/master/doc/fee-recommendation.md\n    // 0.01 DOGE per KB\n    return 1000;\n  }\n\n  try {\n    return await MempoolApi.forCoin(coin.getChain()).getRecoveryFeePerBytes();\n  } catch (e) {\n    console.dir(e);\n    return defaultValue;\n  }\n}\n\nexport type BackupKeyRecoveryTransansaction = {\n  inputs?: WalletUnspentJSON[];\n  transactionHex: string;\n  coin: string;\n  backupKey: string;\n  recoveryAmount: number;\n  recoveryAmountString: string;\n};\n\n/**\n * Builds a funds recovery transaction without BitGo.\n *\n * Returns transaction hex in legacy format for unsigned sweep transaction, half signed backup recovery transaction with KRS provider (only keyternal),\n * fully signed backup recovery transaction without a KRS provider.\n *\n * Returns PSBT hex for half signed backup recovery transaction with KRS provider (excluding keyternal)\n * For PSBT hex cases, Unspents are not required in response.\n *\n * @param coin\n * @param bitgo\n * @param params\n * - userKey: [encrypted] xprv, or xpub\n * - backupKey: [encrypted] xprv, or xpub if the xprv is held by a KRS provider\n * - walletPassphrase: necessary if one of the xprvs is encrypted\n * - bitgoKey: xpub\n * - krsProvider: necessary if backup key is held by KRS\n * - recoveryDestination: target address to send recovered funds to\n * - scan: the amount of consecutive addresses without unspents to scan through before stopping\n * - ignoreAddressTypes: (optional) scripts to ignore\n *        for example: ['p2shP2wsh', 'p2wsh'] will prevent code from checking for wrapped-segwit and native-segwit chains on the public block explorers\n */\nexport async function backupKeyRecovery(\n  coin: AbstractUtxoCoin,\n  bitgo: BitGoBase,\n  params: RecoverParams\n): Promise<BackupKeyRecoveryTransansaction | FormattedOfflineVaultTxInfo> {\n  if (_.isUndefined(params.userKey)) {\n    throw new Error('missing userKey');\n  }\n\n  if (_.isUndefined(params.backupKey)) {\n    throw new Error('missing backupKey');\n  }\n\n  if (\n    _.isUndefined(params.recoveryDestination) ||\n    !coin.isValidAddress(params.recoveryDestination, { anyFormat: true })\n  ) {\n    throw new Error('invalid recoveryDestination');\n  }\n\n  if (!_.isUndefined(params.scan) && (!_.isInteger(params.scan) || params.scan < 0)) {\n    throw new Error('scan must be a positive integer');\n  }\n\n  if (params.feeRate !== undefined && (!Number.isFinite(params.feeRate) || params.feeRate <= 0)) {\n    throw new Error('feeRate must be a positive number');\n  }\n\n  const isKrsRecovery = getIsKrsRecovery(params);\n  const isUnsignedSweep = getIsUnsignedSweep(params);\n  const responseTxFormat = isUnsignedSweep || !isKrsRecovery || params.krsProvider === 'keyternal' ? 'legacy' : 'psbt';\n\n  const krsProvider = isKrsRecovery ? getKrsProvider(coin, params.krsProvider) : undefined;\n\n  // check whether key material and password authenticate the users and return parent keys of all three keys of the wallet\n  const keys = getBip32Keys(bitgo, params, { requireBitGoXpub: true });\n  if (!isTriple(keys)) {\n    throw new Error(`expected key triple`);\n  }\n  const walletKeys = new utxolib.bitgo.RootWalletKeys(keys, [\n    params.userKeyPath || utxolib.bitgo.RootWalletKeys.defaultPrefix,\n    utxolib.bitgo.RootWalletKeys.defaultPrefix,\n    utxolib.bitgo.RootWalletKeys.defaultPrefix,\n  ]);\n\n  const unspents: WalletUnspent<bigint>[] = (\n    await Promise.all(\n      outputScripts.scriptTypes2Of3\n        .filter(\n          (addressType) => coin.supportsAddressType(addressType) && !params.ignoreAddressTypes?.includes(addressType)\n        )\n        .reduce(\n          (queries, addressType) => [\n            ...queries,\n            queryBlockchainUnspentsPath(coin, params, walletKeys, getExternalChainCode(addressType)),\n            queryBlockchainUnspentsPath(coin, params, walletKeys, getInternalChainCode(addressType)),\n          ],\n          [] as Promise<WalletUnspent<bigint>[]>[]\n        )\n    )\n  ).flat();\n\n  // Execute the queries and gather the unspents\n  const totalInputAmount = utxolib.bitgo.unspentSum(unspents, 'bigint');\n  if (totalInputAmount <= BigInt(0)) {\n    throw new ErrorNoInputToRecover();\n  }\n\n  // Build the psbt\n  const psbt = utxolib.bitgo.createPsbtForNetwork({ network: coin.network });\n  // xpubs can become handy for many things.\n  utxolib.bitgo.addXpubsToPsbt(psbt, walletKeys);\n  const txInfo = {} as BackupKeyRecoveryTransansaction;\n  const feePerByte: number =\n    params.feeRate !== undefined ? params.feeRate : await getRecoveryFeePerBytes(coin, { defaultValue: 50 });\n\n  // KRS recovery transactions have a 2nd output to pay the recovery fee, like paygo fees.\n  const dimensions = Dimensions.fromPsbt(psbt).plus(isKrsRecovery ? Dimensions.SingleOutput.p2wsh : Dimensions.ZERO);\n  const approximateFee = BigInt(dimensions.getVSize() * feePerByte);\n\n  txInfo.inputs =\n    responseTxFormat === 'legacy'\n      ? unspents.map((u) => ({ ...u, value: Number(u.value), valueString: u.value.toString(), prevTx: undefined }))\n      : undefined;\n\n  unspents.forEach((unspent) => {\n    utxolib.bitgo.addWalletUnspentToPsbt(psbt, unspent, walletKeys, 'user', 'backup');\n  });\n\n  let krsFee = BigInt(0);\n  if (isKrsRecovery && params.krsProvider) {\n    try {\n      krsFee = BigInt(await calculateFeeAmount(coin, { provider: params.krsProvider }));\n    } catch (err) {\n      // Don't let this error block the recovery -\n      console.dir(err);\n    }\n  }\n\n  const recoveryAmount = totalInputAmount - approximateFee - krsFee;\n\n  if (recoveryAmount < BigInt(0)) {\n    throw new Error(`this wallet\\'s balance is too low to pay the fees specified by the KRS provider. \n          Existing balance on wallet: ${totalInputAmount.toString()}. Estimated network fee for the recovery transaction\n          : ${approximateFee.toString()}, KRS fee to pay: ${krsFee.toString()}. After deducting fees, your total \n          recoverable balance is ${recoveryAmount.toString()}`);\n  }\n\n  const recoveryOutputScript = utxolib.address.toOutputScript(params.recoveryDestination, coin.network);\n  psbt.addOutput({ script: recoveryOutputScript, value: recoveryAmount });\n\n  if (krsProvider && krsFee > BigInt(0)) {\n    if (!krsProvider.feeAddresses) {\n      throw new Error(`keyProvider must define feeAddresses`);\n    }\n\n    const krsFeeAddress = krsProvider.feeAddresses[coin.getChain()];\n\n    if (!krsFeeAddress) {\n      throw new Error('this KRS provider has not configured their fee structure yet - recovery cannot be completed');\n    }\n\n    const krsFeeOutputScript = utxolib.address.toOutputScript(krsFeeAddress, coin.network);\n    psbt.addOutput({ script: krsFeeOutputScript, value: krsFee });\n  }\n\n  if (isUnsignedSweep) {\n    // TODO BTC-317 - When ready to PSBTify OVC, send psbt hex and skip unspents in response.\n    const txHex = psbt.getUnsignedTx().toBuffer().toString('hex');\n    return formatForOfflineVault(coin.getChain(), txInfo as OfflineVaultTxInfo, txHex);\n  } else {\n    signAndVerifyPsbt(psbt, walletKeys.user, { isLastSignature: false });\n    if (isKrsRecovery) {\n      // The KRS provider keyternal solely supports P2SH, P2WSH, and P2SH-P2WSH input script types.\n      // It currently uses an outdated BitGoJS SDK, which relies on a legacy transaction builder for cosigning.\n      // Unfortunately, upgrading the keyternal code presents challenges,\n      // which hinders the integration of the latest BitGoJS SDK with PSBT signing support.\n      txInfo.transactionHex =\n        params.krsProvider === 'keyternal'\n          ? utxolib.bitgo.extractP2msOnlyHalfSignedTx(psbt).toBuffer().toString('hex')\n          : psbt.toHex();\n    } else {\n      const tx = signAndVerifyPsbt(psbt, walletKeys.backup, { isLastSignature: true });\n      txInfo.transactionHex = tx.toBuffer().toString('hex');\n    }\n  }\n\n  if (isKrsRecovery) {\n    txInfo.coin = coin.getChain();\n    txInfo.backupKey = params.backupKey;\n    txInfo.recoveryAmount = Number(recoveryAmount);\n    txInfo.recoveryAmountString = recoveryAmount.toString();\n  }\n\n  return txInfo;\n}\n\nexport interface BitGoV1Unspent {\n  tx_hash: string;\n  tx_output_n: number;\n  value: number;\n}\n\nexport interface V1SweepParams {\n  walletId: string;\n  walletPassphrase: string;\n  unspents: BitGoV1Unspent[];\n  recoveryDestination: string;\n  userKey: string;\n  otp: string;\n}\n\nexport interface V1RecoverParams extends Omit<V1SweepParams, 'otp'> {\n  backupKey: string;\n}\n\nexport async function v1BackupKeyRecovery(\n  coin: AbstractUtxoCoin,\n  bitgo: BitGoBase,\n  params: V1RecoverParams\n): Promise<string> {\n  if (\n    _.isUndefined(params.recoveryDestination) ||\n    !coin.isValidAddress(params.recoveryDestination, { anyFormat: true })\n  ) {\n    throw new Error('invalid recoveryDestination');\n  }\n\n  const recoveryFeePerByte = await getRecoveryFeePerBytes(coin, { defaultValue: 50 });\n  const v1wallet = await bitgo.wallets().get({ id: params.walletId });\n  return await v1wallet.recover({\n    ...params,\n    feeRate: recoveryFeePerByte,\n  });\n}\n\nexport async function v1Sweep(\n  coin: AbstractUtxoCoin,\n  bitgo: BitGoBase,\n  params: V1SweepParams\n): Promise<{\n  tx: string;\n  hash: string;\n  status: string;\n}> {\n  if (\n    _.isUndefined(params.recoveryDestination) ||\n    !coin.isValidAddress(params.recoveryDestination, { anyFormat: true })\n  ) {\n    throw new Error('invalid recoveryDestination');\n  }\n\n  let recoveryFeePerByte = 100;\n  if (bitgo.env === 'prod') {\n    recoveryFeePerByte = await getRecoveryFeePerBytes(coin, { defaultValue: 100 });\n  }\n\n  const v1wallet = await bitgo.wallets().get({ id: params.walletId });\n  return await v1wallet.sweep({\n    ...params,\n    feeRate: recoveryFeePerByte,\n  });\n}\n"]}

package/dist/esm/recovery/baseApi.d.ts

@@ -0,0 +1,24 @@
+import superagent from 'superagent';
+import { BitGoJsError } from '@bitgo/sdk-core';
+export declare class ApiNotImplementedError extends BitGoJsError {
+    constructor(coinName: string);
+}
+export declare class ApiRequestError extends BitGoJsError {
+    constructor(url: string, reason: Error | string);
+    static forRequest(req: superagent.Request, reason: Error | string): ApiRequestError;
+    static forResponse(res: superagent.Response, reason: Error | string): ApiRequestError;
+}
+export type RequestOptions = {
+    retry?: number;
+};
+export type Response<T> = {
+    map<V>(f: (body: T) => V): V;
+};
+export declare class BaseApi {
+    baseUrl: string;
+    constructor(baseUrl: string);
+    request<T>(method: string, path: string, requestBody: unknown | undefined, params?: RequestOptions): Promise<Response<T>>;
+    get<T>(path: string, params?: RequestOptions): Promise<Response<T>>;
+    post<T>(path: string, body: unknown, params?: RequestOptions): Promise<Response<T>>;
+}
+//# sourceMappingURL=baseApi.d.ts.map

package/dist/esm/recovery/baseApi.js

@@ -0,0 +1,64 @@
+import superagent from 'superagent';
+import { BitGoJsError } from '@bitgo/sdk-core';
+export class ApiNotImplementedError extends BitGoJsError {
+    constructor(coinName) {
+        super(`api not implemented for coin ${coinName}`);
+    }
+}
+export class ApiRequestError extends BitGoJsError {
+    constructor(url, reason) {
+        super(`error in API request: ${url}: ${reason}`);
+    }
+    static forRequest(req, reason) {
+        return new ApiRequestError(req.toString(), reason);
+    }
+    static forResponse(res, reason) {
+        return new ApiRequestError(res.header, reason);
+    }
+}
+export class BaseApi {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+        if (!baseUrl.startsWith('https://')) {
+            throw new Error(`baseUrl must start with https://`);
+        }
+        if (baseUrl.endsWith(`/`)) {
+            throw new Error(`baseUrl must not end with slash (/)`);
+        }
+    }
+    async request(method, path, requestBody, params = {}) {
+        if (!path.startsWith(path)) {
+            throw new Error(`path must start with '/' character`);
+        }
+        const url = this.baseUrl + path;
+        let response;
+        try {
+            response = await superagent(method, url)
+                .retry(params.retry)
+                .send(requestBody);
+        }
+        catch (e) {
+            throw new ApiRequestError(url, e);
+        }
+        if (!response.ok) {
+            throw new ApiRequestError(url, `status code ${response.statusCode}`);
+        }
+        return {
+            map(f) {
+                try {
+                    return f(response.body);
+                }
+                catch (e) {
+                    throw new ApiRequestError(url, e);
+                }
+            },
+        };
+    }
+    get(path, params) {
+        return this.request('get', path, undefined, params);
+    }
+    post(path, body, params) {
+        return this.request('post', path, body, params);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/recovery/coingeckoApi.d.ts

@@ -0,0 +1,6 @@
+import { BaseApi } from './baseApi';
+export declare class CoingeckoApi extends BaseApi {
+    constructor();
+    getUSDPrice(coinFamily: string): Promise<number>;
+}
+//# sourceMappingURL=coingeckoApi.d.ts.map

package/dist/esm/recovery/coingeckoApi.js

@@ -0,0 +1,40 @@
+import { BaseApi } from './baseApi';
+const familyNamesToCoinGeckoIds = new Map()
+    .set('BTC', 'bitcoin')
+    .set('LTC', 'litecoin')
+    .set('BCH', 'bitcoin-cash')
+    .set('ZEC', 'zcash')
+    .set('DASH', 'dash')
+    // note: we don't have a source for price data of BCHA and BSV, but we will use BCH as a proxy. We will substitute
+    // it out for a better source when it becomes available.  TODO BG-26359.
+    .set('BCHA', 'bitcoin-cash')
+    .set('BSV', 'bitcoin-cash');
+export class CoingeckoApi extends BaseApi {
+    constructor() {
+        super('https://api.coingecko.com/api/v3');
+    }
+    async getUSDPrice(coinFamily) {
+        const coinGeckoId = familyNamesToCoinGeckoIds.get(coinFamily.toUpperCase());
+        if (!coinGeckoId) {
+            throw new Error(`There is no CoinGecko id for family name ${coinFamily.toUpperCase()}.`);
+        }
+        const coinGeckoUrl = `/simple/price?ids=${coinGeckoId}&vs_currencies=USD`;
+        const res = await this.get(coinGeckoUrl, { retry: 2 });
+        return res.map((body) => {
+            // An example of response
+            // {
+            //   "ethereum": {
+            //     "usd": 220.64
+            //   }
+            // }
+            if (!body) {
+                throw new Error('Unable to reach Coin Gecko API for price data');
+            }
+            if (!body[coinGeckoId]['usd'] || typeof body[coinGeckoId]['usd'] !== 'number') {
+                throw new Error('Unexpected response from Coin Gecko API for price data');
+            }
+            return body[coinGeckoId]['usd'];
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/recovery/crossChainRecovery.d.ts

@@ -0,0 +1,86 @@
+import * as utxolib from '@bitgo/utxo-lib';
+import { BitGoBase, IWallet } from '@bitgo/sdk-core';
+import { AbstractUtxoCoin, TransactionInfo } from '../abstractUtxoCoin';
+type RootWalletKeys = utxolib.bitgo.RootWalletKeys;
+export interface BuildRecoveryTransactionOptions {
+    wallet: string;
+    faultyTxId: string;
+    recoveryAddress: string;
+}
+type FeeInfo = {
+    size: number;
+    feeRate: number;
+    fee: number;
+    payGoFee: number;
+};
+export interface CrossChainRecoveryUnsigned<TNumber extends number | bigint = number> {
+    txHex: string;
+    txInfo: TransactionInfo<TNumber>;
+    walletId: string;
+    feeInfo: FeeInfo;
+    address: string;
+    coin: string;
+}
+export interface CrossChainRecoverySigned<TNumber extends number | bigint = number> {
+    version: 1 | 2;
+    txHex: string;
+    txInfo: TransactionInfo<TNumber>;
+    walletId: string;
+    sourceCoin: string;
+    recoveryCoin: string;
+    recoveryAddress?: string;
+    recoveryAmount?: TNumber;
+}
+type WalletV1 = {
+    keychains: {
+        xpub: string;
+    }[];
+    address({ address }: {
+        address: string;
+    }): Promise<{
+        chain: number;
+        index: number;
+    }>;
+    getEncryptedUserKeychain(): Promise<{
+        encryptedXprv: string;
+    }>;
+};
+export declare function getWallet(bitgo: BitGoBase, coin: AbstractUtxoCoin, walletId: string): Promise<IWallet | WalletV1>;
+/**
+ * @param recoveryCoin
+ * @param wallet
+ * @return wallet pubkeys
+ */
+export declare function getWalletKeys(recoveryCoin: AbstractUtxoCoin, wallet: IWallet | WalletV1): Promise<RootWalletKeys>;
+export declare function isWalletAddress(wallet: IWallet | WalletV1, address: string): Promise<boolean>;
+type RecoverParams = {
+    /** Wallet ID (can be v1 wallet or v2 wallet) */
+    walletId: string;
+    /** Coin to create the transaction for */
+    sourceCoin: AbstractUtxoCoin;
+    /** Coin that wallet keys were set up for */
+    recoveryCoin: AbstractUtxoCoin;
+    /** Source coin transaction to recover outputs from (sourceCoin) */
+    txid: string;
+    /** Source coin address to send the funds to */
+    recoveryAddress: string;
+    /** If set, decrypts private key and signs transaction */
+    walletPassphrase?: string;
+    /** If set, signs transaction */
+    xprv?: string;
+    /** for utxo coins other than [BTC,TBTC] this is a Block Chair api key **/
+    apiKey?: string;
+};
+/**
+ * Recover wallet deposits that were received on the wrong blockchain
+ * (for instance bitcoin deposits that were received for a litecoin wallet).
+ *
+ * Fetches the unspent data from BitGo's public blockchain API and the script data from the user's
+ * wallet.
+ *
+ * @param {BitGoBase} bitgo
+ * @param {RecoverParams} params
+ */
+export declare function recoverCrossChain<TNumber extends number | bigint = number>(bitgo: BitGoBase, params: RecoverParams): Promise<CrossChainRecoverySigned<TNumber> | CrossChainRecoveryUnsigned<TNumber>>;
+export {};
+//# sourceMappingURL=crossChainRecovery.d.ts.map