@bitgo-beta/abstract-utxo 1.6.1-alpha.43 → 1.6.1-alpha.431

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

@@ -0,0 +1,96 @@
+import * as utxolib from '@bitgo-beta/utxo-lib';
+import { BitGoBase, IWallet } from '@bitgo-beta/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>;
+/**
+ * Convert a Litecoin P2SH address from M... format (scriptHash 0x32) to the legacy 3... format (scriptHash 0x05).
+ * This is needed for cross-chain recovery when LTC was sent to a BTC address, because the BTC wallet
+ * stores addresses in the 3... format while the LTC blockchain returns addresses in M... format.
+ *
+ * @param address - LTC address to convert
+ * @param network - The Litecoin network
+ * @returns The address in legacy 3... format, or the original address if it's not a P2SH address
+ */
+export declare function convertLtcAddressToLegacyFormat(address: string, network: utxolib.Network): string;
+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

package/dist/{src → esm}/recovery/crossChainRecovery.d.ts.map

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

package/dist/esm/recovery/crossChainRecovery.js

@@ -0,0 +1,368 @@
+import * as utxolib from '@bitgo-beta/utxo-lib';
+import { bip32 } from '@bitgo-beta/secp256k1';
+import { Dimensions } from '@bitgo-beta/unspents';
+import { Wallet } from '@bitgo-beta/sdk-core';
+import { decrypt } from '@bitgo-beta/sdk-api';
+import { signAndVerifyWalletTransaction } from '../transaction/fixedScript/signLegacyTransaction';
+const { unspentSum, scriptTypeForChain, outputScripts } = utxolib.bitgo;
+export async function getWallet(bitgo, coin, walletId) {
+    try {
+        return await coin.wallets().get({ id: walletId });
+    }
+    catch (e) {
+        // TODO: BG-46364 handle errors more gracefully
+        // The v2 endpoint coin.wallets().get() may throw 404 or 400 errors, but this should not prevent us from searching for the walletId in v1 wallets.
+        if (e.status >= 500) {
+            throw e;
+        }
+    }
+    try {
+        return await bitgo.wallets().get({ id: walletId });
+    }
+    catch (e) {
+        throw new Error(`could not get wallet ${walletId} from v1 or v2: ${e.toString()}`);
+    }
+}
+/**
+ * @param recoveryCoin
+ * @param wallet
+ * @return wallet pubkeys
+ */
+export async function getWalletKeys(recoveryCoin, wallet) {
+    let xpubs;
+    if (wallet instanceof Wallet) {
+        const keychains = (await recoveryCoin.keychains().getKeysForSigning({ wallet }));
+        if (keychains.length !== 3) {
+            throw new Error(`expected triple got ${keychains.length}`);
+        }
+        xpubs = keychains.map((k) => k.pub);
+    }
+    else {
+        xpubs = wallet.keychains.map((k) => k.xpub);
+    }
+    return new utxolib.bitgo.RootWalletKeys(xpubs.map((k) => bip32.fromBase58(k)));
+}
+export async function isWalletAddress(wallet, address) {
+    try {
+        let addressData;
+        if (wallet instanceof Wallet) {
+            addressData = await wallet.getAddress({ address });
+        }
+        else {
+            addressData = await wallet.address({ address });
+        }
+        return addressData !== undefined;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/**
+ * Convert a Litecoin P2SH address from M... format (scriptHash 0x32) to the legacy 3... format (scriptHash 0x05).
+ * This is needed for cross-chain recovery when LTC was sent to a BTC address, because the BTC wallet
+ * stores addresses in the 3... format while the LTC blockchain returns addresses in M... format.
+ *
+ * @param address - LTC address to convert
+ * @param network - The Litecoin network
+ * @returns The address in legacy 3... format, or the original address if it's not a P2SH address
+ */
+export function convertLtcAddressToLegacyFormat(address, network) {
+    try {
+        // Try to decode as bech32 - these don't need conversion
+        utxolib.address.fromBech32(address);
+        return address;
+    }
+    catch (e) {
+        // Not bech32, continue to base58
+    }
+    try {
+        const decoded = utxolib.address.fromBase58Check(address, network);
+        // Only convert P2SH addresses (scriptHash), not P2PKH (pubKeyHash)
+        if (decoded.version === network.scriptHash) {
+            // Convert to legacy format using Bitcoin's scriptHash (0x05)
+            const legacyScriptHash = utxolib.networks.bitcoin.scriptHash;
+            return utxolib.address.toBase58Check(decoded.hash, legacyScriptHash, network);
+        }
+        // P2PKH or other - return unchanged
+        return address;
+    }
+    catch (e) {
+        // If decoding fails, return the original address
+        return address;
+    }
+}
+/**
+ * @param coin
+ * @param txid
+ * @param amountType
+ * @param wallet
+ * @param apiKey - a blockchair api key
+ * @return all unspents for transaction outputs, including outputs from other transactions
+ */
+async function getAllRecoveryOutputs(coin, txid, amountType = 'number', wallet, apiKey) {
+    const api = coin.getRecoveryProvider(apiKey);
+    const tx = await api.getTransactionIO(txid);
+    const walletAddresses = (await Promise.all(tx.outputs.map(async (output) => {
+        // For some coins (bch) we need to convert the address to legacy format since the api returns the address
+        // in non legacy format. However, we want to keep the address in the same format as the response since we
+        // are going to hit the API again to fetch address unspents.
+        const canonicalAddress = coin.canonicalAddress(output.address);
+        let isWalletOwned = await isWalletAddress(wallet, canonicalAddress);
+        // For LTC cross-chain recovery: if the address isn't found, try the legacy format.
+        // When LTC is sent to a BTC address, the LTC blockchain returns M... addresses
+        // but the BTC wallet stores addresses in 3... format.
+        if (!isWalletOwned && coin.getFamily() === 'ltc') {
+            const legacyAddress = convertLtcAddressToLegacyFormat(output.address, coin.network);
+            if (legacyAddress !== output.address) {
+                isWalletOwned = await isWalletAddress(wallet, legacyAddress);
+            }
+        }
+        return isWalletOwned ? output.address : null;
+    }))).filter((address) => address !== null);
+    const unspents = await api.getUnspentsForAddresses(walletAddresses);
+    if (unspents.length === 0) {
+        throw new Error(`No recovery unspents found.`);
+    }
+    // the api may return cashaddr's instead of legacy for BCH and BCHA
+    // downstream processes's only expect legacy addresses
+    return unspents.map((recoveryOutput) => {
+        return {
+            ...recoveryOutput,
+            address: coin.canonicalAddress(recoveryOutput.address),
+            value: utxolib.bitgo.toTNumber(BigInt(recoveryOutput.value), amountType),
+        };
+    });
+}
+async function getScriptId(coin, wallet, script) {
+    const address = utxolib.address.fromOutputScript(script, coin.network);
+    let addressData;
+    if (wallet instanceof Wallet) {
+        addressData = await wallet.getAddress({ address });
+    }
+    else {
+        addressData = await wallet.address({ address });
+    }
+    if (typeof addressData.chain === 'number' && typeof addressData.index === 'number') {
+        return { chain: addressData.chain, index: addressData.index };
+    }
+    throw new Error(`invalid address data: ${JSON.stringify(addressData)}`);
+}
+/**
+ * Lookup address data from unspents on sourceCoin in address database of recoveryCoin.
+ * Return full walletUnspents including scriptId in sourceCoin format.
+ *
+ * @param sourceCoin
+ * @param recoveryCoin
+ * @param unspents
+ * @param wallet
+ * @return walletUnspents
+ */
+async function toWalletUnspents(sourceCoin, recoveryCoin, unspents, wallet) {
+    const addresses = new Set(unspents.map((u) => u.address));
+    const walletUnspents = [];
+    for (const address of addresses) {
+        let scriptId;
+        try {
+            scriptId = await getScriptId(recoveryCoin, wallet, utxolib.address.toOutputScript(address, sourceCoin.network));
+        }
+        catch (e) {
+            console.error(`error getting scriptId for ${address}:`, e);
+            continue;
+        }
+        const filteredUnspents = unspents
+            .filter((u) => u.address === address)
+            .map((u) => ({
+            ...u,
+            ...scriptId,
+        }));
+        walletUnspents.push(...filteredUnspents);
+    }
+    return walletUnspents;
+}
+/**
+ * @param coin
+ * @return feeRate for transaction
+ */
+async function getFeeRateSatVB(coin) {
+    // TODO: use feeRate API
+    const feeRate = {
+        bch: 20,
+        tbch: 20,
+        bcha: 20,
+        tbcha: 20,
+        bsv: 20,
+        tbsv: 20,
+        btc: 80,
+        tbtc: 80,
+        tbtcsig: 80,
+        tbtc4: 80,
+        tbtcbgsig: 80,
+        ltc: 100,
+        tltc: 100,
+        doge: 1000,
+        tdoge: 1000,
+    }[coin.getChain()];
+    if (!feeRate) {
+        throw new Error(`no feeRate for ${coin.getChain()}`);
+    }
+    return feeRate;
+}
+/**
+ * @param xprv
+ * @param passphrase
+ * @param wallet
+ * @return signing key
+ */
+async function getPrv(xprv, passphrase, wallet) {
+    if (xprv) {
+        const key = bip32.fromBase58(xprv);
+        if (key.isNeutered()) {
+            throw new Error(`not a private key`);
+        }
+        return key;
+    }
+    if (!wallet || !passphrase) {
+        throw new Error(`no xprv given: need wallet and passphrase to continue`);
+    }
+    let encryptedPrv;
+    if (wallet instanceof Wallet) {
+        encryptedPrv = (await wallet.getEncryptedUserKeychain()).encryptedPrv;
+    }
+    else {
+        encryptedPrv = (await wallet.getEncryptedUserKeychain()).encryptedXprv;
+    }
+    return getPrv(decrypt(passphrase, encryptedPrv));
+}
+/**
+ * @param network
+ * @param unspents
+ * @param targetAddress
+ * @param feeRateSatVB
+ * @param signer - if set, sign transaction
+ * @param amountType
+ * @return transaction spending full input amount to targetAddress
+ */
+function createSweepTransaction(network, unspents, targetAddress, feeRateSatVB, signer, amountType = 'number') {
+    const inputValue = unspentSum(unspents, amountType);
+    const vsize = Dimensions.fromUnspents(unspents, {
+        p2tr: { scriptPathLevel: 1 },
+        p2trMusig2: { scriptPathLevel: undefined },
+    })
+        .plus(Dimensions.fromOutput({ script: utxolib.address.toOutputScript(targetAddress, network) }))
+        .getVSize();
+    const fee = vsize * feeRateSatVB;
+    const transactionBuilder = utxolib.bitgo.createTransactionBuilderForNetwork(network);
+    transactionBuilder.addOutput(targetAddress, utxolib.bitgo.toTNumber(BigInt(inputValue) - BigInt(fee), amountType));
+    unspents.forEach((unspent) => {
+        utxolib.bitgo.addToTransactionBuilder(transactionBuilder, unspent);
+    });
+    let transaction = transactionBuilder.buildIncomplete();
+    if (signer) {
+        transaction = signAndVerifyWalletTransaction(transactionBuilder, unspents, signer, {
+            isLastSignature: false,
+        });
+    }
+    return transaction;
+}
+function getTxInfo(transaction, unspents, walletId, walletKeys, amountType = 'number') {
+    const inputAmount = utxolib.bitgo.unspentSum(unspents, amountType);
+    const outputAmount = utxolib.bitgo.toTNumber(transaction.outs.reduce((sum, o) => sum + BigInt(o.value), BigInt(0)), amountType);
+    const outputs = transaction.outs.map((o) => ({
+        address: utxolib.address.fromOutputScript(o.script, transaction.network),
+        valueString: o.value.toString(),
+        change: false,
+    }));
+    const inputs = unspents.map((u) => {
+        // NOTE:
+        // The `redeemScript` and `walletScript` properties are required for legacy versions of BitGoJS
+        // which might require these scripts for signing. The Wallet Recovery Wizard (WRW) can create
+        // unsigned prebuilds that are submitted to BitGoJS instances which are not necessarily the same
+        // version.
+        const addressKeys = walletKeys.deriveForChainAndIndex(u.chain, u.index);
+        const scriptType = scriptTypeForChain(u.chain);
+        const { redeemScript, witnessScript } = outputScripts.createOutputScript2of3(addressKeys.publicKeys, scriptType);
+        return {
+            ...u,
+            wallet: walletId,
+            fromWallet: walletId,
+            redeemScript: redeemScript?.toString('hex'),
+            witnessScript: witnessScript?.toString('hex'),
+        };
+    });
+    return {
+        inputAmount,
+        outputAmount,
+        minerFee: inputAmount - outputAmount,
+        spendAmount: outputAmount,
+        inputs,
+        unspents: inputs,
+        outputs,
+        externalOutputs: outputs,
+        changeOutputs: [],
+        payGoFee: 0,
+    } /* cast to TransactionInfo to allow extra fields may be required by legacy consumers of this data */;
+}
+function getFeeInfo(transaction, unspents, amountType = 'number') {
+    const vsize = Dimensions.fromUnspents(unspents, {
+        p2tr: { scriptPathLevel: 1 },
+        p2trMusig2: { scriptPathLevel: undefined },
+    })
+        .plus(Dimensions.fromOutputs(transaction.outs))
+        .getVSize();
+    const inputAmount = utxolib.bitgo.unspentSum(unspents, amountType);
+    const outputAmount = transaction.outs.reduce((sum, o) => sum + BigInt(o.value), BigInt(0));
+    const fee = Number(BigInt(inputAmount) - outputAmount);
+    return {
+        size: vsize,
+        fee,
+        feeRate: fee / vsize,
+        payGoFee: 0,
+    };
+}
+/**
+ * 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 async function recoverCrossChain(bitgo, params) {
+    const wallet = await getWallet(bitgo, params.recoveryCoin, params.walletId);
+    const unspents = await getAllRecoveryOutputs(params.sourceCoin, params.txid, params.sourceCoin.amountType, wallet, params.apiKey);
+    const walletUnspents = await toWalletUnspents(params.sourceCoin, params.recoveryCoin, unspents, wallet);
+    const walletKeys = await getWalletKeys(params.recoveryCoin, wallet);
+    const prv = params.xprv || params.walletPassphrase ? await getPrv(params.xprv, params.walletPassphrase, wallet) : undefined;
+    const signer = prv
+        ? new utxolib.bitgo.WalletUnspentSigner(walletKeys, prv, walletKeys.bitgo)
+        : undefined;
+    const feeRateSatVB = await getFeeRateSatVB(params.sourceCoin);
+    const transaction = createSweepTransaction(params.sourceCoin.network, walletUnspents, params.recoveryAddress, feeRateSatVB, signer, params.sourceCoin.amountType);
+    const recoveryAmount = transaction.outs[0].value;
+    const txHex = transaction.toBuffer().toString('hex');
+    const txInfo = getTxInfo(transaction, walletUnspents, params.walletId, walletKeys, params.sourceCoin.amountType);
+    if (prv) {
+        return {
+            version: wallet instanceof Wallet ? 2 : 1,
+            walletId: params.walletId,
+            txHex,
+            txInfo,
+            sourceCoin: params.sourceCoin.getChain(),
+            recoveryCoin: params.recoveryCoin.getChain(),
+            recoveryAmount,
+        };
+    }
+    else {
+        return {
+            txHex,
+            txInfo,
+            walletId: params.walletId,
+            feeInfo: getFeeInfo(transaction, walletUnspents, params.sourceCoin.amountType),
+            address: params.recoveryAddress,
+            coin: params.sourceCoin.getChain(),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crossChainRecovery.js","sourceRoot":"","sources":["../../../src/recovery/crossChainRecovery.ts"],"names":[],"mappings":"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","sourcesContent":["import * as utxolib from '@bitgo-beta/utxo-lib';\nimport { BIP32Interface, bip32 } from '@bitgo-beta/secp256k1';\nimport { Dimensions } from '@bitgo-beta/unspents';\nimport { BitGoBase, IWallet, Keychain, Triple, Wallet } from '@bitgo-beta/sdk-core';\nimport { decrypt } from '@bitgo-beta/sdk-api';\n\nimport { AbstractUtxoCoin, TransactionInfo } from '../abstractUtxoCoin';\nimport { signAndVerifyWalletTransaction } from '../transaction/fixedScript/signLegacyTransaction';\n\nconst { unspentSum, scriptTypeForChain, outputScripts } = utxolib.bitgo;\ntype RootWalletKeys = utxolib.bitgo.RootWalletKeys;\ntype Unspent<TNumber extends number | bigint = number> = utxolib.bitgo.Unspent<TNumber>;\ntype WalletUnspent<TNumber extends number | bigint = number> = utxolib.bitgo.WalletUnspent<TNumber>;\ntype WalletUnspentLegacy<TNumber extends number | bigint = number> = utxolib.bitgo.WalletUnspentLegacy<TNumber>;\n\nexport interface BuildRecoveryTransactionOptions {\n  wallet: string;\n  faultyTxId: string;\n  recoveryAddress: string;\n}\n\ntype FeeInfo = {\n  size: number;\n  feeRate: number;\n  fee: number;\n  payGoFee: number;\n};\n\nexport interface CrossChainRecoveryUnsigned<TNumber extends number | bigint = number> {\n  txHex: string;\n  txInfo: TransactionInfo<TNumber>;\n  walletId: string;\n  feeInfo: FeeInfo;\n  address: string;\n  coin: string;\n}\n\nexport interface CrossChainRecoverySigned<TNumber extends number | bigint = number> {\n  version: 1 | 2;\n  txHex: string;\n  txInfo: TransactionInfo<TNumber>;\n  walletId: string;\n  sourceCoin: string;\n  recoveryCoin: string;\n  recoveryAddress?: string;\n  recoveryAmount?: TNumber;\n}\n\ntype WalletV1 = {\n  keychains: { xpub: string }[];\n  address({ address }: { address: string }): Promise<{ chain: number; index: number }>;\n  getEncryptedUserKeychain(): Promise<{ encryptedXprv: string }>;\n};\n\nexport async function getWallet(\n  bitgo: BitGoBase,\n  coin: AbstractUtxoCoin,\n  walletId: string\n): Promise<IWallet | WalletV1> {\n  try {\n    return await coin.wallets().get({ id: walletId });\n  } catch (e) {\n    // TODO: BG-46364 handle errors more gracefully\n    // The v2 endpoint coin.wallets().get() may throw 404 or 400 errors, but this should not prevent us from searching for the walletId in v1 wallets.\n    if (e.status >= 500) {\n      throw e;\n    }\n  }\n\n  try {\n    return await bitgo.wallets().get({ id: walletId });\n  } catch (e) {\n    throw new Error(`could not get wallet ${walletId} from v1 or v2: ${e.toString()}`);\n  }\n}\n\n/**\n * @param recoveryCoin\n * @param wallet\n * @return wallet pubkeys\n */\nexport async function getWalletKeys(\n  recoveryCoin: AbstractUtxoCoin,\n  wallet: IWallet | WalletV1\n): Promise<RootWalletKeys> {\n  let xpubs: Triple<string>;\n\n  if (wallet instanceof Wallet) {\n    const keychains = (await recoveryCoin.keychains().getKeysForSigning({ wallet })) as unknown as Keychain[];\n    if (keychains.length !== 3) {\n      throw new Error(`expected triple got ${keychains.length}`);\n    }\n    xpubs = keychains.map((k) => k.pub) as Triple<string>;\n  } else {\n    xpubs = (wallet as WalletV1).keychains.map((k) => k.xpub) as Triple<string>;\n  }\n\n  return new utxolib.bitgo.RootWalletKeys(xpubs.map((k) => bip32.fromBase58(k)) as Triple<BIP32Interface>);\n}\n\nexport async function isWalletAddress(wallet: IWallet | WalletV1, address: string): Promise<boolean> {\n  try {\n    let addressData;\n    if (wallet instanceof Wallet) {\n      addressData = await wallet.getAddress({ address });\n    } else {\n      addressData = await (wallet as WalletV1).address({ address });\n    }\n\n    return addressData !== undefined;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Convert a Litecoin P2SH address from M... format (scriptHash 0x32) to the legacy 3... format (scriptHash 0x05).\n * This is needed for cross-chain recovery when LTC was sent to a BTC address, because the BTC wallet\n * stores addresses in the 3... format while the LTC blockchain returns addresses in M... format.\n *\n * @param address - LTC address to convert\n * @param network - The Litecoin network\n * @returns The address in legacy 3... format, or the original address if it's not a P2SH address\n */\nexport function convertLtcAddressToLegacyFormat(address: string, network: utxolib.Network): string {\n  try {\n    // Try to decode as bech32 - these don't need conversion\n    utxolib.address.fromBech32(address);\n    return address;\n  } catch (e) {\n    // Not bech32, continue to base58\n  }\n\n  try {\n    const decoded = utxolib.address.fromBase58Check(address, network);\n    // Only convert P2SH addresses (scriptHash), not P2PKH (pubKeyHash)\n    if (decoded.version === network.scriptHash) {\n      // Convert to legacy format using Bitcoin's scriptHash (0x05)\n      const legacyScriptHash = utxolib.networks.bitcoin.scriptHash;\n      return utxolib.address.toBase58Check(decoded.hash, legacyScriptHash, network);\n    }\n    // P2PKH or other - return unchanged\n    return address;\n  } catch (e) {\n    // If decoding fails, return the original address\n    return address;\n  }\n}\n\n/**\n * @param coin\n * @param txid\n * @param amountType\n * @param wallet\n * @param apiKey - a blockchair api key\n * @return all unspents for transaction outputs, including outputs from other transactions\n */\nasync function getAllRecoveryOutputs<TNumber extends number | bigint = number>(\n  coin: AbstractUtxoCoin,\n  txid: string,\n  amountType: 'number' | 'bigint' = 'number',\n  wallet: IWallet | WalletV1,\n  apiKey?: string\n): Promise<Unspent<TNumber>[]> {\n  const api = coin.getRecoveryProvider(apiKey);\n  const tx = await api.getTransactionIO(txid);\n  const walletAddresses = (\n    await Promise.all(\n      tx.outputs.map(async (output) => {\n        // For some coins (bch) we need to convert the address to legacy format since the api returns the address\n        // in non legacy format. However, we want to keep the address in the same format as the response since we\n        // are going to hit the API again to fetch address unspents.\n        const canonicalAddress = coin.canonicalAddress(output.address);\n        let isWalletOwned = await isWalletAddress(wallet, canonicalAddress);\n\n        // For LTC cross-chain recovery: if the address isn't found, try the legacy format.\n        // When LTC is sent to a BTC address, the LTC blockchain returns M... addresses\n        // but the BTC wallet stores addresses in 3... format.\n        if (!isWalletOwned && coin.getFamily() === 'ltc') {\n          const legacyAddress = convertLtcAddressToLegacyFormat(output.address, coin.network);\n          if (legacyAddress !== output.address) {\n            isWalletOwned = await isWalletAddress(wallet, legacyAddress);\n          }\n        }\n\n        return isWalletOwned ? output.address : null;\n      })\n    )\n  ).filter((address) => address !== null);\n\n  const unspents = await api.getUnspentsForAddresses(walletAddresses as string[]);\n  if (unspents.length === 0) {\n    throw new Error(`No recovery unspents found.`);\n  }\n  // the api may return cashaddr's instead of legacy for BCH and BCHA\n  // downstream processes's only expect legacy addresses\n  return unspents.map((recoveryOutput) => {\n    return {\n      ...recoveryOutput,\n      address: coin.canonicalAddress(recoveryOutput.address),\n      value: utxolib.bitgo.toTNumber<TNumber>(BigInt(recoveryOutput.value), amountType),\n    };\n  });\n}\n\n/**\n * Data required for address and signature derivation\n */\ntype ScriptId = {\n  chain: number;\n  index: number;\n};\n\nasync function getScriptId(coin: AbstractUtxoCoin, wallet: IWallet | WalletV1, script: Buffer): Promise<ScriptId> {\n  const address = utxolib.address.fromOutputScript(script, coin.network);\n  let addressData: { chain: number; index: number };\n  if (wallet instanceof Wallet) {\n    addressData = await wallet.getAddress({ address });\n  } else {\n    addressData = await (wallet as WalletV1).address({ address });\n  }\n  if (typeof addressData.chain === 'number' && typeof addressData.index === 'number') {\n    return { chain: addressData.chain, index: addressData.index };\n  }\n\n  throw new Error(`invalid address data: ${JSON.stringify(addressData)}`);\n}\n\n/**\n * Lookup address data from unspents on sourceCoin in address database of recoveryCoin.\n * Return full walletUnspents including scriptId in sourceCoin format.\n *\n * @param sourceCoin\n * @param recoveryCoin\n * @param unspents\n * @param wallet\n * @return walletUnspents\n */\nasync function toWalletUnspents<TNumber extends number | bigint = number>(\n  sourceCoin: AbstractUtxoCoin,\n  recoveryCoin: AbstractUtxoCoin,\n  unspents: Unspent<TNumber>[],\n  wallet: IWallet | WalletV1\n): Promise<WalletUnspent<TNumber>[]> {\n  const addresses = new Set(unspents.map((u) => u.address));\n  const walletUnspents: WalletUnspent<TNumber>[] = [];\n\n  for (const address of addresses) {\n    let scriptId;\n    try {\n      scriptId = await getScriptId(recoveryCoin, wallet, utxolib.address.toOutputScript(address, sourceCoin.network));\n    } catch (e) {\n      console.error(`error getting scriptId for ${address}:`, e);\n      continue;\n    }\n    const filteredUnspents = unspents\n      .filter((u) => u.address === address)\n      .map((u) => ({\n        ...u,\n        ...scriptId,\n      }));\n    walletUnspents.push(...filteredUnspents);\n  }\n\n  return walletUnspents;\n}\n\n/**\n * @param coin\n * @return feeRate for transaction\n */\nasync function getFeeRateSatVB(coin: AbstractUtxoCoin): Promise<number> {\n  // TODO: use feeRate API\n  const feeRate = {\n    bch: 20,\n    tbch: 20,\n    bcha: 20,\n    tbcha: 20,\n    bsv: 20,\n    tbsv: 20,\n    btc: 80,\n    tbtc: 80,\n    tbtcsig: 80,\n    tbtc4: 80,\n    tbtcbgsig: 80,\n    ltc: 100,\n    tltc: 100,\n    doge: 1000,\n    tdoge: 1000,\n  }[coin.getChain()];\n\n  if (!feeRate) {\n    throw new Error(`no feeRate for ${coin.getChain()}`);\n  }\n\n  return feeRate;\n}\n\n/**\n * @param xprv\n * @param passphrase\n * @param wallet\n * @return signing key\n */\nasync function getPrv(xprv?: string, passphrase?: string, wallet?: IWallet | WalletV1): Promise<BIP32Interface> {\n  if (xprv) {\n    const key = bip32.fromBase58(xprv);\n    if (key.isNeutered()) {\n      throw new Error(`not a private key`);\n    }\n    return key;\n  }\n\n  if (!wallet || !passphrase) {\n    throw new Error(`no xprv given: need wallet and passphrase to continue`);\n  }\n\n  let encryptedPrv: string;\n  if (wallet instanceof Wallet) {\n    encryptedPrv = (await wallet.getEncryptedUserKeychain()).encryptedPrv;\n  } else {\n    encryptedPrv = (await (wallet as WalletV1).getEncryptedUserKeychain()).encryptedXprv;\n  }\n\n  return getPrv(decrypt(passphrase, encryptedPrv));\n}\n\n/**\n * @param network\n * @param unspents\n * @param targetAddress\n * @param feeRateSatVB\n * @param signer - if set, sign transaction\n * @param amountType\n * @return transaction spending full input amount to targetAddress\n */\nfunction createSweepTransaction<TNumber extends number | bigint = number>(\n  network: utxolib.Network,\n  unspents: WalletUnspent<TNumber>[],\n  targetAddress: string,\n  feeRateSatVB: number,\n  signer?: utxolib.bitgo.WalletUnspentSigner<RootWalletKeys>,\n  amountType: 'number' | 'bigint' = 'number'\n): utxolib.bitgo.UtxoTransaction<TNumber> {\n  const inputValue = unspentSum<TNumber>(unspents, amountType);\n  const vsize = Dimensions.fromUnspents(unspents, {\n    p2tr: { scriptPathLevel: 1 },\n    p2trMusig2: { scriptPathLevel: undefined },\n  })\n    .plus(Dimensions.fromOutput({ script: utxolib.address.toOutputScript(targetAddress, network) }))\n    .getVSize();\n  const fee = vsize * feeRateSatVB;\n\n  const transactionBuilder = utxolib.bitgo.createTransactionBuilderForNetwork<TNumber>(network);\n  transactionBuilder.addOutput(\n    targetAddress,\n    utxolib.bitgo.toTNumber<TNumber>(BigInt(inputValue) - BigInt(fee), amountType)\n  );\n  unspents.forEach((unspent) => {\n    utxolib.bitgo.addToTransactionBuilder(transactionBuilder, unspent);\n  });\n  let transaction = transactionBuilder.buildIncomplete();\n  if (signer) {\n    transaction = signAndVerifyWalletTransaction<TNumber>(transactionBuilder, unspents, signer, {\n      isLastSignature: false,\n    });\n  }\n  return transaction;\n}\n\nfunction getTxInfo<TNumber extends number | bigint = number>(\n  transaction: utxolib.bitgo.UtxoTransaction<TNumber>,\n  unspents: WalletUnspent<TNumber>[],\n  walletId: string,\n  walletKeys: RootWalletKeys,\n  amountType: 'number' | 'bigint' = 'number'\n): TransactionInfo<TNumber> {\n  const inputAmount = utxolib.bitgo.unspentSum<TNumber>(unspents, amountType);\n  const outputAmount = utxolib.bitgo.toTNumber<TNumber>(\n    transaction.outs.reduce((sum, o) => sum + BigInt(o.value), BigInt(0)),\n    amountType\n  );\n  const outputs = transaction.outs.map((o) => ({\n    address: utxolib.address.fromOutputScript(o.script, transaction.network),\n    valueString: o.value.toString(),\n    change: false,\n  }));\n  const inputs = unspents.map((u) => {\n    // NOTE:\n    // The `redeemScript` and `walletScript` properties are required for legacy versions of BitGoJS\n    // which might require these scripts for signing. The Wallet Recovery Wizard (WRW) can create\n    // unsigned prebuilds that are submitted to BitGoJS instances which are not necessarily the same\n    // version.\n    const addressKeys = walletKeys.deriveForChainAndIndex(u.chain, u.index);\n    const scriptType = scriptTypeForChain(u.chain);\n    const { redeemScript, witnessScript } = outputScripts.createOutputScript2of3(addressKeys.publicKeys, scriptType);\n\n    return {\n      ...u,\n      wallet: walletId,\n      fromWallet: walletId,\n      redeemScript: redeemScript?.toString('hex'),\n      witnessScript: witnessScript?.toString('hex'),\n    } as WalletUnspentLegacy<TNumber>;\n  });\n  return {\n    inputAmount,\n    outputAmount,\n    minerFee: inputAmount - outputAmount,\n    spendAmount: outputAmount,\n    inputs,\n    unspents: inputs,\n    outputs,\n    externalOutputs: outputs,\n    changeOutputs: [],\n    payGoFee: 0,\n  } /* cast to TransactionInfo to allow extra fields may be required by legacy consumers of this data */ as TransactionInfo<TNumber>;\n}\n\nfunction getFeeInfo<TNumber extends number | bigint = number>(\n  transaction: utxolib.bitgo.UtxoTransaction<TNumber>,\n  unspents: WalletUnspent<TNumber>[],\n  amountType: 'number' | 'bigint' = 'number'\n): FeeInfo {\n  const vsize = Dimensions.fromUnspents(unspents, {\n    p2tr: { scriptPathLevel: 1 },\n    p2trMusig2: { scriptPathLevel: undefined },\n  })\n    .plus(Dimensions.fromOutputs(transaction.outs))\n    .getVSize();\n  const inputAmount = utxolib.bitgo.unspentSum<TNumber>(unspents, amountType);\n  const outputAmount = transaction.outs.reduce((sum, o) => sum + BigInt(o.value), BigInt(0));\n  const fee = Number(BigInt(inputAmount) - outputAmount);\n  return {\n    size: vsize,\n    fee,\n    feeRate: fee / vsize,\n    payGoFee: 0,\n  };\n}\n\ntype RecoverParams = {\n  /** Wallet ID (can be v1 wallet or v2 wallet) */\n  walletId: string;\n  /** Coin to create the transaction for */\n  sourceCoin: AbstractUtxoCoin;\n  /** Coin that wallet keys were set up for */\n  recoveryCoin: AbstractUtxoCoin;\n  /** Source coin transaction to recover outputs from (sourceCoin) */\n  txid: string;\n  /** Source coin address to send the funds to */\n  recoveryAddress: string;\n  /** If set, decrypts private key and signs transaction */\n  walletPassphrase?: string;\n  /** If set, signs transaction */\n  xprv?: string;\n  /** for utxo coins other than [BTC,TBTC] this is a Block Chair api key **/\n  apiKey?: string;\n};\n\n/**\n * Recover wallet deposits that were received on the wrong blockchain\n * (for instance bitcoin deposits that were received for a litecoin wallet).\n *\n * Fetches the unspent data from BitGo's public blockchain API and the script data from the user's\n * wallet.\n *\n * @param {BitGoBase} bitgo\n * @param {RecoverParams} params\n */\nexport async function recoverCrossChain<TNumber extends number | bigint = number>(\n  bitgo: BitGoBase,\n  params: RecoverParams\n): Promise<CrossChainRecoverySigned<TNumber> | CrossChainRecoveryUnsigned<TNumber>> {\n  const wallet = await getWallet(bitgo, params.recoveryCoin, params.walletId);\n  const unspents = await getAllRecoveryOutputs<TNumber>(\n    params.sourceCoin,\n    params.txid,\n    params.sourceCoin.amountType,\n    wallet,\n    params.apiKey\n  );\n  const walletUnspents = await toWalletUnspents<TNumber>(params.sourceCoin, params.recoveryCoin, unspents, wallet);\n  const walletKeys = await getWalletKeys(params.recoveryCoin, wallet);\n  const prv =\n    params.xprv || params.walletPassphrase ? await getPrv(params.xprv, params.walletPassphrase, wallet) : undefined;\n  const signer = prv\n    ? new utxolib.bitgo.WalletUnspentSigner<RootWalletKeys>(walletKeys, prv, walletKeys.bitgo)\n    : undefined;\n  const feeRateSatVB = await getFeeRateSatVB(params.sourceCoin);\n  const transaction = createSweepTransaction<TNumber>(\n    params.sourceCoin.network,\n    walletUnspents,\n    params.recoveryAddress,\n    feeRateSatVB,\n    signer,\n    params.sourceCoin.amountType\n  );\n  const recoveryAmount = transaction.outs[0].value;\n  const txHex = transaction.toBuffer().toString('hex');\n  const txInfo = getTxInfo<TNumber>(\n    transaction,\n    walletUnspents,\n    params.walletId,\n    walletKeys,\n    params.sourceCoin.amountType\n  );\n  if (prv) {\n    return {\n      version: wallet instanceof Wallet ? 2 : 1,\n      walletId: params.walletId,\n      txHex,\n      txInfo,\n      sourceCoin: params.sourceCoin.getChain(),\n      recoveryCoin: params.recoveryCoin.getChain(),\n      recoveryAmount,\n    };\n  } else {\n    return {\n      txHex,\n      txInfo,\n      walletId: params.walletId,\n      feeInfo: getFeeInfo(transaction, walletUnspents, params.sourceCoin.amountType),\n      address: params.recoveryAddress,\n      coin: params.sourceCoin.getChain(),\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,7 @@
+export * from './RecoveryProvider';
+export * from './backupKeyRecovery';
+export * from './baseApi';
+export * from './coingeckoApi';
+export * from './crossChainRecovery';
+export * from './mempoolApi';
+//# sourceMappingURL=index.d.ts.map

package/dist/{src → esm}/recovery/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/recovery/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/recovery/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC"}

package/dist/esm/recovery/index.js

@@ -0,0 +1,7 @@
+export * from './RecoveryProvider';
+export * from './backupKeyRecovery';
+export * from './baseApi';
+export * from './coingeckoApi';
+export * from './crossChainRecovery';
+export * from './mempoolApi';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmVjb3ZlcnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vUmVjb3ZlcnlQcm92aWRlcic7XG5leHBvcnQgKiBmcm9tICcuL2JhY2t1cEtleVJlY292ZXJ5JztcbmV4cG9ydCAqIGZyb20gJy4vYmFzZUFwaSc7XG5leHBvcnQgKiBmcm9tICcuL2NvaW5nZWNrb0FwaSc7XG5leHBvcnQgKiBmcm9tICcuL2Nyb3NzQ2hhaW5SZWNvdmVyeSc7XG5leHBvcnQgKiBmcm9tICcuL21lbXBvb2xBcGknO1xuIl19

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

@@ -0,0 +1,7 @@
+import { BaseApi } from './baseApi';
+export declare class MempoolApi extends BaseApi {
+    static forCoin(coinName: string): MempoolApi;
+    constructor(baseUrl: string);
+    getRecoveryFeePerBytes(): Promise<number>;
+}
+//# sourceMappingURL=mempoolApi.d.ts.map

package/dist/{src → esm}/recovery/mempoolApi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mempoolApi.d.ts","sourceRoot":"","sources":["../../../src/recovery/mempoolApi.ts"],"names":[],"mappings":"AAKA,OAAO,EAA0B,OAAO,EAAE,MAAM,WAAW,CAAC;AAE5D,qBAAa,UAAW,SAAQ,OAAO;IACrC,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU;gBAUhC,OAAO,EAAE,MAAM;IAIrB,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC;CAShD"}
+{"version":3,"file":"mempoolApi.d.ts","sourceRoot":"","sources":["../../../src/recovery/mempoolApi.ts"],"names":[],"mappings":"AAEA,OAAO,EAA0B,OAAO,EAAE,MAAM,WAAW,CAAC;AAE5D,qBAAa,UAAW,SAAQ,OAAO;IACrC,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU;gBAUhC,OAAO,EAAE,MAAM;IAIrB,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC;CAWhD"}

package/dist/esm/recovery/mempoolApi.js

@@ -0,0 +1,29 @@
+import _ from 'lodash';
+import { ApiNotImplementedError, BaseApi } from './baseApi';
+export class MempoolApi extends BaseApi {
+    static forCoin(coinName) {
+        switch (coinName) {
+            case 'btc':
+            case 'tbtc':
+                // FIXME: tbtc is enabled here for legacy reasons;
+                return new MempoolApi('https://mempool.space/api/v1');
+        }
+        throw new ApiNotImplementedError(coinName);
+    }
+    constructor(baseUrl) {
+        super(baseUrl);
+    }
+    async getRecoveryFeePerBytes() {
+        const res = await this.get('/fees/recommended');
+        return res.map((body) => {
+            if (body.fastestFee && _.isInteger(body.fastestFee)) {
+                return body.fastestFee;
+            }
+            else if (body.hourFee && _.isInteger(body.hourFee)) {
+                return body.hourFee;
+            }
+            throw new Error('unexpected response');
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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