@bitgo-beta/abstract-utxo 1.1.1-beta.182 → 1.1.1-beta.1821

package/dist/cjs/src/offlineVault/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransactionExplanation = exports.descriptor = void 0;
+exports.descriptor = __importStar(require("./descriptor"));
+__exportStar(require("./OfflineVaultHalfSigned"), exports);
+var TransactionExplanation_1 = require("./TransactionExplanation");
+Object.defineProperty(exports, "getTransactionExplanation", { enumerable: true, get: function () { return TransactionExplanation_1.getTransactionExplanation; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvb2ZmbGluZVZhdWx0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDJEQUEyQztBQUMzQywyREFBeUM7QUFDekMsbUVBQXFFO0FBQTVELG1JQUFBLHlCQUF5QixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogYXMgZGVzY3JpcHRvciBmcm9tICcuL2Rlc2NyaXB0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9PZmZsaW5lVmF1bHRIYWxmU2lnbmVkJztcbmV4cG9ydCB7IGdldFRyYW5zYWN0aW9uRXhwbGFuYXRpb24gfSBmcm9tICcuL1RyYW5zYWN0aW9uRXhwbGFuYXRpb24nO1xuZXhwb3J0IHsgVHJhbnNhY3Rpb25FeHBsYW5hdGlvbiB9IGZyb20gJy4vVHJhbnNhY3Rpb25FeHBsYW5hdGlvbic7XG5leHBvcnQgeyBFeHBsYW5hdGlvbk91dHB1dCB9IGZyb20gJy4vVHJhbnNhY3Rpb25FeHBsYW5hdGlvbic7XG4iXX0=

package/dist/{src → cjs/src}/recovery/RecoveryProvider.d.ts

@@ -1,6 +1,5 @@
 import { AddressInfo, TransactionIO } from '@bitgo-beta/blockapis';
-import { bitgo } from '@bitgo-beta/utxo-lib';
-declare type Unspent<TNumber extends number | bigint = number> = bitgo.Unspent<TNumber>;
+import type { Unspent } from '../unspent';
 /**
  * An account with bear minimum information required for recoveries.
  */
@@ -18,5 +17,4 @@ export interface RecoveryProvider<TNumber extends number | bigint = number> {
     getTransactionIO(txid: string): Promise<TransactionIO>;
 }
 export declare function forCoin(coinName: string, apiToken?: string): RecoveryProvider<number>;
-export {};
 //# sourceMappingURL=RecoveryProvider.d.ts.map

package/dist/cjs/src/recovery/RecoveryProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecoveryProvider.d.ts","sourceRoot":"","sources":["../../../../src/recovery/RecoveryProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,WAAW,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAElF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAI1C;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM;IACxE,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAC1E,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IACtD,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACjD,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CACxD;AAED,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAgBrF"}

package/dist/cjs/src/recovery/RecoveryProvider.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forCoin = forCoin;
+const blockapis_1 = require("@bitgo-beta/blockapis");
+const baseApi_1 = require("./baseApi");
+function forCoin(coinName, apiToken) {
+    switch (coinName) {
+        case 'btc':
+        case 'tbtc':
+        case 'bch':
+        case 'bcha':
+        case 'bsv':
+        case 'btg':
+        case 'dash':
+        case 'doge':
+        case 'ltc':
+        case 'zec':
+            return blockapis_1.BlockchairApi.forCoin(coinName, { apiToken });
+    }
+    throw new baseApi_1.ApiNotImplementedError(coinName);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/src/recovery/backupKeyRecovery.d.ts

@@ -0,0 +1,90 @@
+import { BitGoBase } from '@bitgo-beta/sdk-core';
+import { fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { AbstractUtxoCoin } from '../abstractUtxoCoin';
+import { type WalletUnspent } from '../unspent';
+import { RecoveryProvider } from './RecoveryProvider';
+type ScriptType2Of3 = fixedScriptWallet.OutputScriptType;
+type WalletUnspentJSON = WalletUnspent & {
+    valueString: string;
+};
+export declare const DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V1 = 50;
+export declare const DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V1_SWEEP = 100;
+export declare const DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V2 = 50;
+export interface FormattedOfflineVaultTxInfo {
+    txInfo: {
+        unspents?: WalletUnspentJSON[];
+    };
+    txHex: string;
+    feeInfo: Record<string, never>;
+    coin: string;
+}
+export interface RecoverParams {
+    scan?: number;
+    userKey: string;
+    backupKey: string;
+    bitgoKey: string;
+    recoveryDestination: string;
+    krsProvider?: string;
+    ignoreAddressTypes: ScriptType2Of3[];
+    walletPassphrase?: string;
+    apiKey?: string;
+    userKeyPath?: string;
+    recoveryProvider?: RecoveryProvider;
+    /** Satoshi per byte */
+    feeRate?: number;
+}
+export type BackupKeyRecoveryTransansaction = {
+    inputs?: WalletUnspentJSON[];
+    transactionHex: string;
+    coin: string;
+    backupKey: string;
+    recoveryAmount: number;
+    recoveryAmountString: string;
+};
+/**
+ * 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 declare function backupKeyRecovery(coin: AbstractUtxoCoin, bitgo: BitGoBase, params: RecoverParams): Promise<BackupKeyRecoveryTransansaction | FormattedOfflineVaultTxInfo>;
+export interface BitGoV1Unspent {
+    tx_hash: string;
+    tx_output_n: number;
+    value: number;
+}
+export interface V1SweepParams {
+    walletId: string;
+    walletPassphrase: string;
+    unspents: BitGoV1Unspent[];
+    recoveryDestination: string;
+    userKey: string;
+    otp: string;
+}
+export interface V1RecoverParams extends Omit<V1SweepParams, 'otp'> {
+    backupKey: string;
+}
+export declare function v1BackupKeyRecovery(coin: AbstractUtxoCoin, bitgo: BitGoBase, params: V1RecoverParams): Promise<string>;
+export declare function v1Sweep(coin: AbstractUtxoCoin, bitgo: BitGoBase, params: V1SweepParams): Promise<{
+    tx: string;
+    hash: string;
+    status: string;
+}>;
+export {};
+//# sourceMappingURL=backupKeyRecovery.d.ts.map

package/dist/cjs/src/recovery/backupKeyRecovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backupKeyRecovery.d.ts","sourceRoot":"","sources":["../../../../src/recovery/backupKeyRecovery.ts"],"names":[],"mappings":"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"}

package/dist/cjs/src/recovery/backupKeyRecovery.js

@@ -0,0 +1,339 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V2 = exports.DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V1_SWEEP = exports.DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V1 = void 0;
+exports.backupKeyRecovery = backupKeyRecovery;
+exports.v1BackupKeyRecovery = v1BackupKeyRecovery;
+exports.v1Sweep = v1Sweep;
+const lodash_1 = __importDefault(require("lodash"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const signTransaction_1 = require("../transaction/fixedScript/signTransaction");
+const address_1 = require("../address");
+const decode_1 = require("../transaction/decode");
+const replayProtection_1 = require("../transaction/fixedScript/replayProtection");
+const names_1 = require("../names");
+const unspent_1 = require("../unspent");
+const RecoveryProvider_1 = require("./RecoveryProvider");
+const mempoolApi_1 = require("./mempoolApi");
+const coingeckoApi_1 = require("./coingeckoApi");
+const psbt_1 = require("./psbt");
+// V1 only deals with BTC. 50 sat/vbyte is very arbitrary.
+exports.DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V1 = 50;
+// FIXME(BTC-2691): it is unclear why sweeps have a different default than regular recovery. 100 sat/vbyte is extremely high.
+exports.DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V1_SWEEP = 100;
+// FIXME(BTC-2691): it makes little sense to have a single default for every coin.
+exports.DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V2 = 50;
+/**
+ * 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_1.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 = sdk_core_1.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');
+    }
+}
+/**
+ * Generate an address and format it for API queries
+ * @param coin - The coin instance
+ * @param coinName - The coin name
+ * @param walletKeys - The wallet keys
+ * @param chain - The chain code
+ * @param addrIndex - The address index
+ * @returns The formatted address (with cashaddr prefix stripped for BCH/BCHA)
+ */
+function getFormattedAddress(coin, coinName, walletKeys, chain, addrIndex) {
+    const format = coin.getChain() === 'bch' || coin.getChain() === 'bcha' ? 'cashaddr' : undefined;
+    const address = (0, address_1.generateAddressWithChainAndIndex)(coinName, walletKeys, chain, addrIndex, format);
+    // Blockchair uses cashaddr format when querying the API for address information. Strip the prefix for BCH/BCHA.
+    return format === 'cashaddr' ? address.split(':')[1] : address;
+}
+function hasWitnessData(scriptType) {
+    return scriptType !== 'p2sh';
+}
+async function queryBlockchainUnspentsPath(coin, params, walletKeys, chain) {
+    const scriptType = wasm_utxo_1.fixedScriptWallet.ChainCode.scriptType(chain);
+    const fetchPrevTx = !hasWitnessData(scriptType) && (0, names_1.getMainnetCoinName)(coin.name) !== 'zec';
+    const recoveryProvider = params.recoveryProvider ?? (0, RecoveryProvider_1.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 formattedAddress = getFormattedAddress(coin, coin.name, walletKeys, chain, addrIndex);
+        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: ${formattedAddress} with balance ${addrInfo.balance}`);
+                const addressUnspents = await recoveryProvider.getUnspentsForAddresses([formattedAddress]);
+                const processedUnspents = await Promise.all(addressUnspents.map(async (u) => {
+                    const { txid, vout } = (0, unspent_1.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_1.MempoolApi.forCoin(coin.getChain()).getRecoveryFeePerBytes();
+    }
+    catch (e) {
+        console.dir(e);
+        return defaultValue;
+    }
+}
+function getBip32Privkeys(bitgo, params) {
+    const keys = (0, sdk_core_1.getBip32Keys)(bitgo, params, { requireBitGoXpub: true });
+    if (!(0, sdk_core_1.isTriple)(keys)) {
+        throw new Error(`expected key triple`);
+    }
+    return keys.map((k) => wasm_utxo_1.BIP32.from(k.toBase58()));
+}
+/**
+ * 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
+ */
+async function backupKeyRecovery(coin, bitgo, params) {
+    if (lodash_1.default.isUndefined(params.userKey)) {
+        throw new Error('missing userKey');
+    }
+    if (lodash_1.default.isUndefined(params.backupKey)) {
+        throw new Error('missing backupKey');
+    }
+    if (lodash_1.default.isUndefined(params.recoveryDestination) ||
+        !coin.isValidAddress(params.recoveryDestination, { anyFormat: true })) {
+        throw new Error('invalid recoveryDestination');
+    }
+    if (!lodash_1.default.isUndefined(params.scan) && (!lodash_1.default.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 = (0, sdk_core_1.getIsKrsRecovery)(params);
+    const isUnsignedSweep = (0, sdk_core_1.getIsUnsignedSweep)(params);
+    const responseTxFormat = !isKrsRecovery || params.krsProvider === 'keyternal' ? 'legacy' : 'psbt';
+    const krsProvider = isKrsRecovery ? (0, sdk_core_1.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 = getBip32Privkeys(bitgo, params);
+    const walletKeys = wasm_utxo_1.fixedScriptWallet.RootWalletKeys.from({
+        triple: keys,
+        derivationPrefixes: [params.userKeyPath || 'm/0/0', 'm/0/0', 'm/0/0'],
+    });
+    const unspents = (await Promise.all(wasm_utxo_1.fixedScriptWallet.outputScriptTypes
+        .filter((addressType) => wasm_utxo_1.fixedScriptWallet.supportsScriptType(coin.name, addressType) &&
+        !params.ignoreAddressTypes?.includes(addressType))
+        .reduce((queries, addressType) => [
+        ...queries,
+        queryBlockchainUnspentsPath(coin, params, walletKeys, wasm_utxo_1.fixedScriptWallet.ChainCode.value(addressType, 'external')),
+        queryBlockchainUnspentsPath(coin, params, walletKeys, wasm_utxo_1.fixedScriptWallet.ChainCode.value(addressType, 'internal')),
+    ], []))).flat();
+    // Execute the queries and gather the unspents
+    const totalInputAmount = (0, unspent_1.unspentSum)(unspents);
+    if (totalInputAmount <= BigInt(0)) {
+        throw new sdk_core_1.ErrorNoInputToRecover();
+    }
+    const txInfo = {};
+    const feePerByte = params.feeRate !== undefined
+        ? params.feeRate
+        : await getRecoveryFeePerBytes(coin, { defaultValue: exports.DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V2 });
+    txInfo.inputs =
+        responseTxFormat === 'legacy'
+            ? unspents.map((u) => ({ ...u, value: Number(u.value), valueString: u.value.toString(), prevTx: undefined }))
+            : undefined;
+    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);
+        }
+    }
+    let krsFeeAddress;
+    if (krsProvider && krsFee > BigInt(0)) {
+        if (!krsProvider.feeAddresses) {
+            throw new Error(`keyProvider must define feeAddresses`);
+        }
+        krsFeeAddress = krsProvider.feeAddresses[coin.getChain()];
+        if (!krsFeeAddress) {
+            throw new Error('this KRS provider has not configured their fee structure yet - recovery cannot be completed');
+        }
+    }
+    let psbt = (0, psbt_1.createBackupKeyRecoveryPsbt)(coin.getChain(), walletKeys, unspents, {
+        feeRateSatVB: feePerByte,
+        recoveryDestination: params.recoveryDestination,
+        keyRecoveryServiceFee: krsFee,
+        keyRecoveryServiceFeeAddress: krsFeeAddress,
+    });
+    if (isUnsignedSweep) {
+        return {
+            txHex: (0, decode_1.encodeTransaction)(psbt).toString('hex'),
+            txInfo: {},
+            feeInfo: {},
+            coin: coin.getChain(),
+        };
+    }
+    const rootWalletKeysWasm = wasm_utxo_1.fixedScriptWallet.RootWalletKeys.from(walletKeys);
+    const replayProtection = { publicKeys: (0, replayProtection_1.getReplayProtectionPubkeys)(coin.name) };
+    // Sign with user key first
+    psbt = (0, signTransaction_1.signAndVerifyPsbt)(psbt, keys[0], rootWalletKeysWasm, replayProtection);
+    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'
+                ? Buffer.from(psbt.getHalfSignedLegacyFormat()).toString('hex')
+                : (0, decode_1.encodeTransaction)(psbt).toString('hex');
+    }
+    else {
+        // Sign with backup key
+        psbt = (0, signTransaction_1.signAndVerifyPsbt)(psbt, keys[1], rootWalletKeysWasm, replayProtection);
+        // Finalize and extract transaction
+        psbt.finalizeAllInputs();
+        txInfo.transactionHex = Buffer.from(psbt.extractTransaction().toBytes()).toString('hex');
+    }
+    if (isKrsRecovery) {
+        txInfo.coin = coin.getChain();
+        txInfo.backupKey = params.backupKey;
+        const recoveryAmount = (0, psbt_1.getRecoveryAmount)(psbt, walletKeys, params.recoveryDestination);
+        txInfo.recoveryAmount = Number(recoveryAmount);
+        txInfo.recoveryAmountString = recoveryAmount.toString();
+    }
+    return txInfo;
+}
+async function v1BackupKeyRecovery(coin, bitgo, params) {
+    if (lodash_1.default.isUndefined(params.recoveryDestination) ||
+        !coin.isValidAddress(params.recoveryDestination, { anyFormat: true })) {
+        throw new Error('invalid recoveryDestination');
+    }
+    const recoveryFeePerByte = await getRecoveryFeePerBytes(coin, {
+        defaultValue: exports.DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V1,
+    });
+    const v1wallet = await bitgo.wallets().get({ id: params.walletId });
+    return await v1wallet.recover({
+        ...params,
+        feeRate: recoveryFeePerByte,
+    });
+}
+async function v1Sweep(coin, bitgo, params) {
+    if (lodash_1.default.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: exports.DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V1_SWEEP,
+        });
+    }
+    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":"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","sourcesContent":["import _ from 'lodash';\nimport {\n  BitGoBase,\n  ErrorNoInputToRecover,\n  getKrsProvider,\n  getBip32Keys,\n  getIsKrsRecovery,\n  getIsUnsignedSweep,\n  isTriple,\n  krsProviders,\n  Triple,\n} from '@bitgo-beta/sdk-core';\nimport { BIP32, fixedScriptWallet } from '@bitgo/wasm-utxo';\n\nimport { AbstractUtxoCoin } from '../abstractUtxoCoin';\nimport { signAndVerifyPsbt } from '../transaction/fixedScript/signTransaction';\nimport { generateAddressWithChainAndIndex } from '../address';\nimport { encodeTransaction } from '../transaction/decode';\nimport { getReplayProtectionPubkeys } from '../transaction/fixedScript/replayProtection';\nimport { getMainnetCoinName, UtxoCoinName } from '../names';\nimport { parseOutputId, unspentSum, type WalletUnspent } from '../unspent';\n\nimport { forCoin, RecoveryProvider } from './RecoveryProvider';\nimport { MempoolApi } from './mempoolApi';\nimport { CoingeckoApi } from './coingeckoApi';\nimport { createBackupKeyRecoveryPsbt, getRecoveryAmount } from './psbt';\n\ntype ScriptType2Of3 = fixedScriptWallet.OutputScriptType;\ntype ChainCode = fixedScriptWallet.ChainCode;\ntype WalletUnspentJSON = WalletUnspent & {\n  valueString: string;\n};\n\n// V1 only deals with BTC. 50 sat/vbyte is very arbitrary.\nexport const DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V1 = 50;\n\n// FIXME(BTC-2691): it is unclear why sweeps have a different default than regular recovery. 100 sat/vbyte is extremely high.\nexport const DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V1_SWEEP = 100;\n\n// FIXME(BTC-2691): it makes little sense to have a single default for every coin.\nexport const DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V2 = 50;\nexport interface FormattedOfflineVaultTxInfo {\n  txInfo: {\n    unspents?: WalletUnspentJSON[];\n  };\n  txHex: string;\n  feeInfo: Record<string, never>;\n  coin: string;\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  /** Satoshi per byte */\n  feeRate?: number;\n}\n\n/**\n * Generate an address and format it for API queries\n * @param coin - The coin instance\n * @param coinName - The coin name\n * @param walletKeys - The wallet keys\n * @param chain - The chain code\n * @param addrIndex - The address index\n * @returns The formatted address (with cashaddr prefix stripped for BCH/BCHA)\n */\nfunction getFormattedAddress(\n  coin: AbstractUtxoCoin,\n  coinName: UtxoCoinName,\n  walletKeys: fixedScriptWallet.RootWalletKeys,\n  chain: ChainCode,\n  addrIndex: number\n): string {\n  const format = coin.getChain() === 'bch' || coin.getChain() === 'bcha' ? 'cashaddr' : undefined;\n  const address = generateAddressWithChainAndIndex(coinName, walletKeys, chain, addrIndex, format);\n\n  // Blockchair uses cashaddr format when querying the API for address information. Strip the prefix for BCH/BCHA.\n  return format === 'cashaddr' ? address.split(':')[1] : address;\n}\n\nfunction hasWitnessData(scriptType: ScriptType2Of3): boolean {\n  return scriptType !== 'p2sh';\n}\n\nasync function queryBlockchainUnspentsPath(\n  coin: AbstractUtxoCoin,\n  params: RecoverParams,\n  walletKeys: fixedScriptWallet.RootWalletKeys,\n  chain: ChainCode\n): Promise<WalletUnspent<bigint>[]> {\n  const scriptType = fixedScriptWallet.ChainCode.scriptType(chain);\n  const fetchPrevTx = !hasWitnessData(scriptType) && getMainnetCoinName(coin.name) !== 'zec';\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 formattedAddress = getFormattedAddress(coin, coin.name, walletKeys, chain, addrIndex);\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: ${formattedAddress} 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 } = 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\nfunction getBip32Privkeys(bitgo: BitGoBase, params: RecoverParams): Triple<BIP32> {\n  const keys = getBip32Keys(bitgo, params, { requireBitGoXpub: true });\n  if (!isTriple(keys)) {\n    throw new Error(`expected key triple`);\n  }\n  return keys.map((k) => BIP32.from(k.toBase58())) as Triple<BIP32>;\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 = !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 = getBip32Privkeys(bitgo, params);\n  const walletKeys = fixedScriptWallet.RootWalletKeys.from({\n    triple: keys,\n    derivationPrefixes: [params.userKeyPath || 'm/0/0', 'm/0/0', 'm/0/0'],\n  });\n\n  const unspents: WalletUnspent<bigint>[] = (\n    await Promise.all(\n      fixedScriptWallet.outputScriptTypes\n        .filter(\n          (addressType) =>\n            fixedScriptWallet.supportsScriptType(coin.name, addressType) &&\n            !params.ignoreAddressTypes?.includes(addressType)\n        )\n        .reduce(\n          (queries, addressType) => [\n            ...queries,\n            queryBlockchainUnspentsPath(\n              coin,\n              params,\n              walletKeys,\n              fixedScriptWallet.ChainCode.value(addressType, 'external')\n            ),\n            queryBlockchainUnspentsPath(\n              coin,\n              params,\n              walletKeys,\n              fixedScriptWallet.ChainCode.value(addressType, 'internal')\n            ),\n          ],\n          [] as Promise<WalletUnspent<bigint>[]>[]\n        )\n    )\n  ).flat();\n\n  // Execute the queries and gather the unspents\n  const totalInputAmount = unspentSum(unspents);\n  if (totalInputAmount <= BigInt(0)) {\n    throw new ErrorNoInputToRecover();\n  }\n\n  const txInfo = {} as BackupKeyRecoveryTransansaction;\n  const feePerByte: number =\n    params.feeRate !== undefined\n      ? params.feeRate\n      : await getRecoveryFeePerBytes(coin, { defaultValue: DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V2 });\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  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  let krsFeeAddress: string | undefined;\n  if (krsProvider && krsFee > BigInt(0)) {\n    if (!krsProvider.feeAddresses) {\n      throw new Error(`keyProvider must define feeAddresses`);\n    }\n\n    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\n  let psbt = createBackupKeyRecoveryPsbt(coin.getChain(), walletKeys, unspents, {\n    feeRateSatVB: feePerByte,\n    recoveryDestination: params.recoveryDestination,\n    keyRecoveryServiceFee: krsFee,\n    keyRecoveryServiceFeeAddress: krsFeeAddress,\n  });\n\n  if (isUnsignedSweep) {\n    return {\n      txHex: encodeTransaction(psbt).toString('hex'),\n      txInfo: {},\n      feeInfo: {},\n      coin: coin.getChain(),\n    };\n  }\n\n  const rootWalletKeysWasm = fixedScriptWallet.RootWalletKeys.from(walletKeys);\n  const replayProtection = { publicKeys: getReplayProtectionPubkeys(coin.name) };\n\n  // Sign with user key first\n  psbt = signAndVerifyPsbt(psbt, keys[0], rootWalletKeysWasm, replayProtection);\n\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        ? Buffer.from(psbt.getHalfSignedLegacyFormat()).toString('hex')\n        : encodeTransaction(psbt).toString('hex');\n  } else {\n    // Sign with backup key\n    psbt = signAndVerifyPsbt(psbt, keys[1], rootWalletKeysWasm, replayProtection);\n    // Finalize and extract transaction\n    psbt.finalizeAllInputs();\n    txInfo.transactionHex = Buffer.from(psbt.extractTransaction().toBytes()).toString('hex');\n  }\n\n  if (isKrsRecovery) {\n    txInfo.coin = coin.getChain();\n    txInfo.backupKey = params.backupKey;\n    const recoveryAmount = getRecoveryAmount(psbt, walletKeys, params.recoveryDestination);\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, {\n    defaultValue: DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V1,\n  });\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, {\n      defaultValue: DEFAULT_RECOVERY_FEERATE_SAT_VBYTE_V1_SWEEP,\n    });\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/{src → cjs/src}/recovery/baseApi.d.ts

@@ -1,7 +1,4 @@
-/**
- * @prettier
- */
-import * as superagent from 'superagent';
+import superagent from 'superagent';
 import { BitGoJsError } from '@bitgo-beta/sdk-core';
 export declare class ApiNotImplementedError extends BitGoJsError {
     constructor(coinName: string);
@@ -11,10 +8,10 @@ export declare class ApiRequestError extends BitGoJsError {
     static forRequest(req: superagent.Request, reason: Error | string): ApiRequestError;
     static forResponse(res: superagent.Response, reason: Error | string): ApiRequestError;
 }
-export declare type RequestOptions = {
+export type RequestOptions = {
     retry?: number;
 };
-export declare type Response<T> = {
+export type Response<T> = {
     map<V>(f: (body: T) => V): V;
 };
 export declare class BaseApi {

package/dist/cjs/src/recovery/baseApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseApi.d.ts","sourceRoot":"","sources":["../../../../src/recovery/baseApi.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,YAAY,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,qBAAa,sBAAuB,SAAQ,YAAY;gBAC1C,QAAQ,EAAE,MAAM;CAG7B;AAED,qBAAa,eAAgB,SAAQ,YAAY;gBACnC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,GAAG,MAAM;IAI/C,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,eAAe;IAInF,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,eAAe;CAGtF;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;IACxB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;CAC9B,CAAC;AAEF,qBAAa,OAAO;IACC,OAAO,EAAE,MAAM;gBAAf,OAAO,EAAE,MAAM;IAS5B,OAAO,CAAC,CAAC,EACb,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,OAAO,GAAG,SAAS,EAChC,MAAM,GAAE,cAAmB,GAC1B,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IA4BvB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAInE,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;CAGpF"}