@bitgo-beta/abstract-utxo 1.6.1-alpha.44 → 1.6.1-alpha.441

package/dist/esm/abstractUtxoCoin.js

@@ -0,0 +1,616 @@
+import assert from 'assert';
+import { randomBytes } from 'crypto';
+import _ from 'lodash';
+import * as utxolib from '@bitgo-beta/utxo-lib';
+import { bip32 } from '@bitgo-beta/secp256k1';
+import { bitgo, getMainnet, isMainnet, isTestnet } from '@bitgo-beta/utxo-lib';
+import { BaseCoin, InvalidAddressDerivationPropertyError, InvalidAddressError, isTriple, KeyIndices, multisigTypes, TxIntentMismatchError, TxIntentMismatchRecipientError, isValidPrv, isValidXprv, } from '@bitgo-beta/sdk-core';
+import { fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { backupKeyRecovery, forCoin, recoverCrossChain, v1BackupKeyRecovery, v1Sweep, } from './recovery';
+import { isReplayProtectionUnspent } from './transaction/fixedScript/replayProtection';
+import { supportedCrossChainRecoveries } from './config';
+import { assertValidTransactionRecipient, explainTx, fromExtendedAddressFormat, isScriptRecipient, parseTransaction, verifyTransaction, } from './transaction';
+import { AggregateValidationError, ErrorMissingOutputs, ErrorImplicitExternalOutputs, } from './transaction/descriptor/verifyTransaction';
+import { assertDescriptorWalletAddress, getDescriptorMapFromWallet, isDescriptorWallet } from './descriptor';
+import { getChainFromNetwork, getFamilyFromNetwork, getFullNameFromNetwork } from './names';
+import { assertFixedScriptWalletAddress } from './address/fixedScript';
+import { isSdkBackend } from './transaction/types';
+import { decodePsbtWith, encodeTransaction, stringToBufferTryFormats } from './transaction/decode';
+import { toBip32Triple } from './keychains';
+import { verifyKeySignature, verifyUserPublicKey } from './verifyKey';
+import { getPolicyForEnv } from './descriptor/validatePolicy';
+import { signTransaction } from './transaction/signTransaction';
+import { isUtxoWalletData } from './wallet';
+import { isDescriptorWalletData } from './descriptor/descriptorWallet';
+export class ErrorDeprecatedTxFormat extends Error {
+    constructor(txFormat) {
+        super(`SDK support for txFormat=${txFormat} is deprecated on this environment. Please use psbt instead.`);
+    }
+}
+const { isChainCode, scriptTypeForChain, outputScripts } = bitgo;
+/**
+ * Convert ValidationError to TxIntentMismatchRecipientError with structured data
+ *
+ * This preserves the structured error information from the original ValidationError
+ * by extracting the mismatched outputs and converting them to the standardized format.
+ * The original error is preserved as the `cause` for debugging purposes.
+ */
+function convertValidationErrorToTxIntentMismatch(error, reqId, txParams, txHex, txExplanation) {
+    const mismatchedRecipients = [];
+    for (const err of error.errors) {
+        if (err instanceof ErrorMissingOutputs) {
+            mismatchedRecipients.push(...err.missingOutputs.map((output) => ({
+                address: output.address,
+                amount: output.amount.toString(),
+            })));
+        }
+        else if (err instanceof ErrorImplicitExternalOutputs) {
+            mismatchedRecipients.push(...err.implicitExternalOutputs.map((output) => ({
+                address: output.address,
+                amount: output.amount.toString(),
+            })));
+        }
+    }
+    const txIntentError = new TxIntentMismatchRecipientError(error.message, reqId, [txParams], txHex, mismatchedRecipients, txExplanation);
+    // Preserve the original structured error as the cause for debugging
+    // See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause
+    txIntentError.cause = error;
+    return txIntentError;
+}
+export class AbstractUtxoCoin extends BaseCoin {
+    constructor(bitgo, network, amountType = 'number') {
+        super(bitgo);
+        this.defaultSdkBackend = 'utxolib';
+        if (!utxolib.isValidNetwork(network)) {
+            throw new Error('invalid network: please make sure to use the same version of ' +
+                '@bitgo-beta/utxo-lib as this library when initializing an instance of this class');
+        }
+        this.amountType = amountType;
+        this._network = network;
+    }
+    get network() {
+        return this._network;
+    }
+    getChain() {
+        return getChainFromNetwork(this.network);
+    }
+    getFamily() {
+        return getFamilyFromNetwork(this.network);
+    }
+    getFullName() {
+        return getFullNameFromNetwork(this.network);
+    }
+    /** Indicates whether the coin supports a block target */
+    supportsBlockTarget() {
+        // FIXME: the SDK does not seem to use this anywhere so it is unclear what the purpose of this method is
+        switch (getMainnet(this.network)) {
+            case utxolib.networks.bitcoin:
+            case utxolib.networks.dogecoin:
+                return true;
+            default:
+                return false;
+        }
+    }
+    sweepWithSendMany() {
+        return true;
+    }
+    /** @deprecated */
+    static get validAddressTypes() {
+        return [...outputScripts.scriptTypes2Of3];
+    }
+    /**
+     * Returns the factor between the base unit and its smallest subdivison
+     * @return {number}
+     */
+    getBaseFactor() {
+        return 1e8;
+    }
+    /**
+     * Check if an address is valid
+     * @param address
+     * @param param
+     */
+    isValidAddress(address, param) {
+        if (typeof param === 'boolean' && param) {
+            throw new Error('deprecated');
+        }
+        // By default, allow all address formats.
+        // At the time of writing, the only additional address format is bch cashaddr.
+        const anyFormat = param?.anyFormat ?? true;
+        try {
+            // Find out if the address is valid for any format. Tries all supported formats by default.
+            // Throws if address cannot be decoded with any format.
+            const [format, script] = utxolib.addressFormat.toOutputScriptAndFormat(address, this.network);
+            // unless anyFormat is set, only 'default' is allowed.
+            if (!anyFormat && format !== 'default') {
+                return false;
+            }
+            // make sure that address is in normal representation for given format.
+            return address === utxolib.addressFormat.fromOutputScriptWithFormat(script, format, this.network);
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Return boolean indicating whether input is valid public key for the coin.
+     *
+     * @param {String} pub the pub to be checked
+     * @returns {Boolean} is it valid?
+     */
+    isValidPub(pub) {
+        try {
+            return bip32.fromBase58(pub).isNeutered();
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    preprocessBuildParams(params) {
+        if (params.recipients !== undefined) {
+            params.recipients =
+                params.recipients instanceof Array
+                    ? params?.recipients?.map((recipient) => {
+                        const { address, ...rest } = recipient;
+                        return { ...rest, ...fromExtendedAddressFormat(address) };
+                    })
+                    : params.recipients;
+        }
+        return params;
+    }
+    /**
+     * Get the latest block height
+     * @param reqId
+     */
+    async getLatestBlockHeight(reqId) {
+        if (reqId) {
+            this.bitgo.setRequestTracer(reqId);
+        }
+        const chainhead = await this.bitgo.get(this.url('/public/block/latest')).result();
+        return chainhead.height;
+    }
+    checkRecipient(recipient) {
+        assertValidTransactionRecipient(recipient);
+        if (!isScriptRecipient(recipient.address)) {
+            super.checkRecipient(recipient);
+        }
+    }
+    /**
+     * Run custom coin logic after a transaction prebuild has been received from BitGo
+     * @param prebuild
+     */
+    async postProcessPrebuild(prebuild) {
+        const tx = this.decodeTransactionFromPrebuild(prebuild);
+        if (_.isUndefined(prebuild.blockHeight)) {
+            prebuild.blockHeight = (await this.getLatestBlockHeight());
+        }
+        return _.extend({}, prebuild, { txHex: encodeTransaction(tx).toString('hex') });
+    }
+    /**
+     * Determine an address' type based on its witness and redeem script presence
+     * @param addressDetails
+     */
+    static inferAddressType(addressDetails) {
+        return isChainCode(addressDetails.chain) ? scriptTypeForChain(addressDetails.chain) : null;
+    }
+    createTransactionFromHex(hex) {
+        return utxolib.bitgo.createTransactionFromHex(hex, this.network, this.amountType);
+    }
+    decodeTransaction(input, decodeWith = this.defaultSdkBackend) {
+        if (typeof input === 'string') {
+            const buffer = stringToBufferTryFormats(input, ['hex', 'base64']);
+            return this.decodeTransaction(buffer, decodeWith);
+        }
+        if (utxolib.bitgo.isPsbt(input)) {
+            return decodePsbtWith(input, this.network, decodeWith);
+        }
+        else {
+            if (decodeWith !== 'utxolib') {
+                console.error('received decodeWith hint %s, ignoring for legacy transaction', decodeWith);
+            }
+            return utxolib.bitgo.createTransactionFromBuffer(input, this.network, {
+                amountType: this.amountType,
+            });
+        }
+    }
+    decodeTransactionAsPsbt(input) {
+        const decoded = this.decodeTransaction(input);
+        if (decoded instanceof fixedScriptWallet.BitGoPsbt || decoded instanceof utxolib.bitgo.UtxoPsbt) {
+            return decoded;
+        }
+        throw new Error('expected psbt but got transaction');
+    }
+    decodeTransactionFromPrebuild(prebuild) {
+        const string = prebuild.txHex ?? prebuild.txBase64;
+        if (!string) {
+            throw new Error('missing required txHex or txBase64 property');
+        }
+        let { decodeWith } = prebuild;
+        if (decodeWith !== undefined) {
+            if (typeof decodeWith !== 'string' || !isSdkBackend(decodeWith)) {
+                console.error('decodeWith %s is not a valid value, using default', decodeWith);
+                decodeWith = undefined;
+            }
+        }
+        return this.decodeTransaction(string, decodeWith);
+    }
+    toCanonicalTransactionRecipient(output) {
+        const amount = BigInt(output.valueString);
+        assertValidTransactionRecipient({ amount, address: output.address });
+        assert(output.address, 'address is required');
+        if (isScriptRecipient(output.address)) {
+            return { amount, address: output.address };
+        }
+        return { amount, address: this.canonicalAddress(output.address) };
+    }
+    /**
+     * Extract and fill transaction details such as internal/change spend, external spend (explicit vs. implicit), etc.
+     * @param params
+     * @returns {*}
+     */
+    async parseTransaction(params) {
+        return parseTransaction(this, params);
+    }
+    /**
+     * @deprecated - use function verifyUserPublicKey instead
+     */
+    verifyUserPublicKey(params) {
+        return verifyUserPublicKey(this.bitgo, params);
+    }
+    /**
+     * @deprecated - use function verifyKeySignature instead
+     */
+    verifyKeySignature(params) {
+        return verifyKeySignature(params);
+    }
+    /**
+     * Verify that a transaction prebuild complies with the original intention
+     *
+     * @param params
+     * @param params.txParams params object passed to send
+     * @param params.txPrebuild prebuild object returned by server
+     * @param params.txPrebuild.txHex prebuilt transaction's txHex form
+     * @param params.wallet Wallet object to obtain keys to verify against
+     * @param params.verification Object specifying some verification parameters
+     * @param params.verification.disableNetworking Disallow fetching any data from the internet for verification purposes
+     * @param params.verification.keychains Pass keychains manually rather than fetching them by id
+     * @param params.verification.addresses Address details to pass in for out-of-band verification
+     * @returns {boolean} True if verification passes
+     * @throws {TxIntentMismatchError} if transaction validation fails
+     * @throws {TxIntentMismatchRecipientError} if transaction recipients don't match user intent
+     */
+    async verifyTransaction(params) {
+        try {
+            return await verifyTransaction(this, this.bitgo, params);
+        }
+        catch (error) {
+            if (error instanceof AggregateValidationError) {
+                const txExplanation = await TxIntentMismatchError.tryGetTxExplanation(this, params.txPrebuild);
+                throw convertValidationErrorToTxIntentMismatch(error, params.reqId, params.txParams, params.txPrebuild.txHex, txExplanation);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Make sure an address is valid and throw an error if it's not.
+     * @param params.address The address string on the network
+     * @param params.addressType
+     * @param params.keychains Keychain objects with xpubs
+     * @param params.coinSpecific Coin-specific details for the address such as a witness script
+     * @param params.chain Derivation chain
+     * @param params.index Derivation index
+     * @throws {InvalidAddressError}
+     * @throws {InvalidAddressDerivationPropertyError}
+     * @throws {UnexpectedAddressError}
+     */
+    async isWalletAddress(params, wallet) {
+        const { address, keychains, chain, index } = params;
+        if (!this.isValidAddress(address)) {
+            throw new InvalidAddressError(`invalid address: ${address}`);
+        }
+        if (wallet && isDescriptorWallet(wallet)) {
+            if (!keychains) {
+                throw new Error('missing required param keychains');
+            }
+            if (!isTriple(keychains)) {
+                throw new Error('keychains must be a triple');
+            }
+            assertDescriptorWalletAddress(this.network, params, getDescriptorMapFromWallet(wallet, toBip32Triple(keychains), getPolicyForEnv(this.bitgo.env)));
+            return true;
+        }
+        if ((_.isUndefined(chain) && _.isUndefined(index)) || !(_.isFinite(chain) && _.isFinite(index))) {
+            throw new InvalidAddressDerivationPropertyError(`address validation failure: invalid chain (${chain}) or index (${index})`);
+        }
+        if (!keychains) {
+            throw new Error('missing required param keychains');
+        }
+        assertFixedScriptWalletAddress(this.network, {
+            address,
+            keychains,
+            format: params.format ?? 'base58',
+            addressType: params.addressType,
+            chain,
+            index,
+        });
+        return true;
+    }
+    /**
+     * @param addressType
+     * @returns true iff coin supports spending from unspentType
+     */
+    supportsAddressType(addressType) {
+        return utxolib.bitgo.outputScripts.isSupportedScriptType(this.network, addressType);
+    }
+    /** inherited doc */
+    getDefaultMultisigType() {
+        return multisigTypes.onchain;
+    }
+    /**
+     * @param chain
+     * @return true iff coin supports spending from chain
+     */
+    supportsAddressChain(chain) {
+        return isChainCode(chain) && this.supportsAddressType(utxolib.bitgo.scriptTypeForChain(chain));
+    }
+    keyIdsForSigning() {
+        return [KeyIndices.USER, KeyIndices.BACKUP, KeyIndices.BITGO];
+    }
+    async getMusig2Nonces(psbt, walletId) {
+        const buffer = encodeTransaction(psbt);
+        const response = await this.bitgo
+            .post(this.url('/wallet/' + walletId + '/tx/signpsbt'))
+            .send({ psbt: buffer.toString('hex') })
+            .result();
+        if (psbt instanceof utxolib.bitgo.UtxoPsbt) {
+            return decodePsbtWith(response.psbt, this.network, 'utxolib');
+        }
+        else {
+            return decodePsbtWith(response.psbt, this.network, 'wasm-utxo');
+        }
+    }
+    /**
+     * @deprecated Use getMusig2Nonces instead
+     * @returns input psbt added with deterministic MuSig2 nonce for bitgo key for each MuSig2 inputs.
+     * @param psbtHex all MuSig2 inputs should contain user MuSig2 nonce
+     * @param walletId
+     */
+    async signPsbt(psbtHex, walletId) {
+        const psbt = await this.getMusig2Nonces(this.decodeTransactionAsPsbt(psbtHex), walletId);
+        return { psbt: encodeTransaction(psbt).toString('hex') };
+    }
+    /**
+     * @returns input psbt added with deterministic MuSig2 nonce for bitgo key for each MuSig2 inputs from OVC.
+     * @param ovcJson JSON object provided by OVC with fields psbtHex and walletId
+     */
+    async signPsbtFromOVC(ovcJson) {
+        assert(ovcJson['psbtHex'], 'ovcJson must contain psbtHex');
+        assert(ovcJson['walletId'], 'ovcJson must contain walletId');
+        const hex = ovcJson['psbtHex'];
+        const walletId = ovcJson['walletId'];
+        const psbt = await this.getMusig2Nonces(this.decodeTransactionAsPsbt(hex), walletId);
+        return _.extend(ovcJson, { txHex: encodeTransaction(psbt).toString('hex') });
+    }
+    /**
+     * Assemble keychain and half-sign prebuilt transaction
+     * @param params - {@see SignTransactionOptions}
+     * @returns {Promise<SignedTransaction | HalfSignedUtxoTransaction>}
+     */
+    async signTransaction(params) {
+        return signTransaction(this, this.bitgo, params);
+    }
+    /**
+     * Sign a transaction with a custom signing function. Example use case is express external signer
+     * @param customSigningFunction custom signing function that returns a single signed transaction
+     * @param signTransactionParams parameters for custom signing function. Includes txPrebuild and pubs (for legacy tx only).
+     *
+     * @returns signed transaction as hex string
+     */
+    async signWithCustomSigningFunction(customSigningFunction, signTransactionParams) {
+        const txHex = signTransactionParams.txPrebuild.txHex;
+        assert(txHex, 'missing txHex parameter');
+        const tx = this.decodeTransaction(txHex);
+        const isTxWithKeyPathSpendInput = tx instanceof bitgo.UtxoPsbt && bitgo.isTransactionWithKeyPathSpendInput(tx);
+        if (!isTxWithKeyPathSpendInput) {
+            return await customSigningFunction({ ...signTransactionParams, coin: this });
+        }
+        const getTxHex = (v) => {
+            if ('txHex' in v) {
+                return v.txHex;
+            }
+            throw new Error('txHex not found in signTransaction result');
+        };
+        const signerNonceTx = await customSigningFunction({
+            ...signTransactionParams,
+            signingStep: 'signerNonce',
+            coin: this,
+        });
+        const { pubs } = signTransactionParams;
+        assert(pubs === undefined || isTriple(pubs));
+        const cosignerNonceTx = await this.signTransaction({
+            ...signTransactionParams,
+            pubs,
+            txPrebuild: { ...signTransactionParams.txPrebuild, txHex: getTxHex(signerNonceTx) },
+            signingStep: 'cosignerNonce',
+        });
+        return await customSigningFunction({
+            ...signTransactionParams,
+            txPrebuild: { ...signTransactionParams.txPrebuild, txHex: getTxHex(cosignerNonceTx) },
+            signingStep: 'signerSignature',
+            coin: this,
+        });
+    }
+    /**
+     * @param unspent
+     * @returns {boolean}
+     */
+    isBitGoTaintedUnspent(unspent) {
+        return isReplayProtectionUnspent(unspent, this.network);
+    }
+    /**
+     * Decompose a raw psbt/transaction into useful information, such as the total amounts,
+     * change amounts, and transaction outputs.
+     * @param params
+     */
+    async explainTransaction(params) {
+        return explainTx(this.decodeTransactionFromPrebuild(params), params, this.network);
+    }
+    /**
+     * @deprecated - use {@see backupKeyRecovery}
+     * Builds a funds recovery transaction without BitGo
+     * @param params - {@see backupKeyRecovery}
+     */
+    async recover(params) {
+        return backupKeyRecovery(this, this.bitgo, params);
+    }
+    async recoverV1(params) {
+        return v1BackupKeyRecovery(this, this.bitgo, params);
+    }
+    async sweepV1(params) {
+        return v1Sweep(this, this.bitgo, params);
+    }
+    /**
+     * Recover coin that was sent to wrong chain
+     * @param params
+     * @param params.txid The txid of the faulty transaction
+     * @param params.recoveryAddress address to send recovered funds to
+     * @param params.wallet the wallet that received the funds
+     * @param params.recoveryCoin the coin type of the wallet that received the funds
+     * @param params.signed return a half-signed transaction (default=true)
+     * @param params.walletPassphrase the wallet passphrase
+     * @param params.xprv the unencrypted xprv (used instead of wallet passphrase)
+     * @param params.apiKey for utxo coins other than [BTC,TBTC] this is a Block Chair api key
+     * @returns {*}
+     */
+    async recoverFromWrongChain(params) {
+        const { txid, recoveryAddress, wallet, walletPassphrase, xprv, apiKey } = params;
+        // params.recoveryCoin used to be params.coin, backwards compatibility
+        const recoveryCoin = params.coin || params.recoveryCoin;
+        if (!recoveryCoin) {
+            throw new Error('missing required object recoveryCoin');
+        }
+        // signed should default to true, and only be disabled if explicitly set to false (not undefined)
+        const signed = params.signed !== false;
+        const sourceCoinFamily = this.getFamily();
+        const recoveryCoinFamily = recoveryCoin.getFamily();
+        const supportedRecoveryCoins = supportedCrossChainRecoveries[sourceCoinFamily];
+        if (_.isUndefined(supportedRecoveryCoins) || !supportedRecoveryCoins.includes(recoveryCoinFamily)) {
+            throw new Error(`Recovery of ${sourceCoinFamily} balances from ${recoveryCoinFamily} wallets is not supported.`);
+        }
+        return await recoverCrossChain(this.bitgo, {
+            sourceCoin: this,
+            recoveryCoin,
+            walletId: wallet,
+            txid,
+            recoveryAddress,
+            walletPassphrase: signed ? walletPassphrase : undefined,
+            xprv: signed ? xprv : undefined,
+            apiKey,
+        });
+    }
+    /**
+     * Generate bip32 key pair
+     *
+     * @param seed
+     * @returns {Object} object with generated pub and prv
+     */
+    generateKeyPair(seed) {
+        if (!seed) {
+            // An extended private key has both a normal 256 bit private key and a 256
+            // bit chain code, both of which must be random. 512 bits is therefore the
+            // maximum entropy and gives us maximum security against cracking.
+            seed = randomBytes(512 / 8);
+        }
+        const extendedKey = bip32.fromSeed(seed);
+        return {
+            pub: extendedKey.neutered().toBase58(),
+            prv: extendedKey.toBase58(),
+        };
+    }
+    /**
+     * Determines the default transaction format based on wallet properties and network
+     * @param wallet - The wallet to check
+     * @param requestedFormat - Optional explicitly requested format
+     * @returns The transaction format to use, or undefined if no default applies
+     */
+    getDefaultTxFormat(wallet, requestedFormat) {
+        // If format is explicitly requested, use it
+        if (requestedFormat !== undefined) {
+            if (isTestnet(this.network) && requestedFormat === 'legacy') {
+                throw new ErrorDeprecatedTxFormat(requestedFormat);
+            }
+            return requestedFormat;
+        }
+        if (isTestnet(this.network)) {
+            return 'psbt-lite';
+        }
+        const walletFlagMusigKp = wallet.flag('musigKp') === 'true';
+        const isHotWallet = wallet.type() === 'hot';
+        // Determine if we should default to psbt format
+        const shouldDefaultToPsbt = wallet.subType() === 'distributedCustody' ||
+            // if mainnet, only default to psbt for btc hot wallets
+            (isMainnet(this.network) && getMainnet(this.network) === utxolib.networks.bitcoin && isHotWallet) ||
+            // default to psbt if it has the wallet flag
+            walletFlagMusigKp;
+        return shouldDefaultToPsbt ? 'psbt' : undefined;
+    }
+    async getExtraPrebuildParams(buildParams) {
+        const txFormat = this.getDefaultTxFormat(buildParams.wallet, buildParams.txFormat);
+        let changeAddressType = buildParams.changeAddressType;
+        // if the addressType is not specified, we need to default to p2trMusig2 for testnet hot wallets for staged rollout of p2trMusig2
+        if (buildParams.addressType === undefined && // addressType is deprecated and replaced by `changeAddress`
+            buildParams.changeAddressType === undefined &&
+            buildParams.changeAddress === undefined &&
+            buildParams.wallet.type() === 'hot') {
+            changeAddressType = ['p2trMusig2', 'p2wsh', 'p2shP2wsh', 'p2sh', 'p2tr'];
+        }
+        return {
+            txFormat,
+            changeAddressType,
+        };
+    }
+    preCreateBitGo(params) {
+        return;
+    }
+    async presignTransaction(params) {
+        if (params.walletData && isUtxoWalletData(params.walletData) && isDescriptorWalletData(params.walletData)) {
+            return params;
+        }
+        // In the case that we have a 'psbt-lite' transaction format, we want to indicate in signing to not fail
+        const txHex = (params.txHex ?? params.txPrebuild?.txHex);
+        if (txHex &&
+            utxolib.bitgo.isPsbt(txHex) &&
+            utxolib.bitgo.isPsbtLite(utxolib.bitgo.createPsbtFromHex(txHex, this.network)) &&
+            params.allowNonSegwitSigningWithoutPrevTx === undefined) {
+            return { ...params, allowNonSegwitSigningWithoutPrevTx: true };
+        }
+        return params;
+    }
+    async supplementGenerateWallet(walletParams, keychains) {
+        return walletParams;
+    }
+    transactionDataAllowed() {
+        return false;
+    }
+    valuelessTransferAllowed() {
+        return false;
+    }
+    getRecoveryProvider(apiToken) {
+        return forCoin(this.getChain(), apiToken);
+    }
+    /** @inheritDoc */
+    auditDecryptedKey({ multiSigType, publicKey, prv }) {
+        if (multiSigType === 'tss') {
+            throw new Error('tss auditing is not supported for this coin');
+        }
+        if (!isValidPrv(prv) && !isValidXprv(prv)) {
+            throw new Error('invalid private key');
+        }
+        if (publicKey) {
+            const genPubKey = bip32.fromBase58(prv).neutered().toBase58();
+            if (genPubKey !== publicKey) {
+                throw new Error('public key does not match private key');
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractUtxoCoin.js","sourceRoot":"","sources":["../../src/abstractUtxoCoin.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport { randomBytes } from 'crypto';\n\nimport _ from 'lodash';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\nimport { bip32 } from '@bitgo-beta/secp256k1';\nimport { bitgo, getMainnet, isMainnet, isTestnet } from '@bitgo-beta/utxo-lib';\nimport {\n  AddressCoinSpecific,\n  BaseCoin,\n  BitGoBase,\n  CreateAddressFormat,\n  ExtraPrebuildParamsOptions,\n  HalfSignedUtxoTransaction,\n  IBaseCoin,\n  InvalidAddressDerivationPropertyError,\n  InvalidAddressError,\n  IRequestTracer,\n  isTriple,\n  IWallet,\n  KeychainsTriplet,\n  KeyIndices,\n  MismatchedRecipient,\n  MultisigType,\n  multisigTypes,\n  ParseTransactionOptions as BaseParseTransactionOptions,\n  PrecreateBitGoOptions,\n  PresignTransactionOptions,\n  RequestTracer,\n  SignedTransaction,\n  TxIntentMismatchError,\n  SignTransactionOptions as BaseSignTransactionOptions,\n  SupplementGenerateWalletOptions,\n  TransactionParams as BaseTransactionParams,\n  TransactionPrebuild as BaseTransactionPrebuild,\n  Triple,\n  TxIntentMismatchRecipientError,\n  VerificationOptions,\n  VerifyAddressOptions as BaseVerifyAddressOptions,\n  VerifyTransactionOptions as BaseVerifyTransactionOptions,\n  Wallet,\n  isValidPrv,\n  isValidXprv,\n} from '@bitgo-beta/sdk-core';\nimport { fixedScriptWallet } from '@bitgo/wasm-utxo';\n\nimport {\n  backupKeyRecovery,\n  CrossChainRecoverySigned,\n  CrossChainRecoveryUnsigned,\n  forCoin,\n  recoverCrossChain,\n  RecoverParams,\n  RecoveryProvider,\n  v1BackupKeyRecovery,\n  V1RecoverParams,\n  v1Sweep,\n  V1SweepParams,\n} from './recovery';\nimport { isReplayProtectionUnspent } from './transaction/fixedScript/replayProtection';\nimport { supportedCrossChainRecoveries } from './config';\nimport {\n  assertValidTransactionRecipient,\n  DecodedTransaction,\n  explainTx,\n  fromExtendedAddressFormat,\n  isScriptRecipient,\n  parseTransaction,\n  verifyTransaction,\n} from './transaction';\nimport type { TransactionExplanation } from './transaction/fixedScript/explainTransaction';\nimport { Musig2Participant } from './transaction/fixedScript/musig2';\nimport {\n  AggregateValidationError,\n  ErrorMissingOutputs,\n  ErrorImplicitExternalOutputs,\n} from './transaction/descriptor/verifyTransaction';\nimport { assertDescriptorWalletAddress, getDescriptorMapFromWallet, isDescriptorWallet } from './descriptor';\nimport { getChainFromNetwork, getFamilyFromNetwork, getFullNameFromNetwork } from './names';\nimport { assertFixedScriptWalletAddress } from './address/fixedScript';\nimport { isSdkBackend, ParsedTransaction, SdkBackend } from './transaction/types';\nimport { decodePsbtWith, encodeTransaction, stringToBufferTryFormats } from './transaction/decode';\nimport { toBip32Triple, UtxoKeychain } from './keychains';\nimport { verifyKeySignature, verifyUserPublicKey } from './verifyKey';\nimport { getPolicyForEnv } from './descriptor/validatePolicy';\nimport { signTransaction } from './transaction/signTransaction';\nimport { isUtxoWalletData, UtxoWallet } from './wallet';\nimport { isDescriptorWalletData } from './descriptor/descriptorWallet';\n\nimport ScriptType2Of3 = utxolib.bitgo.outputScripts.ScriptType2Of3;\n\nexport type TxFormat =\n  // This is a legacy transaction format based around the bitcoinjs-lib serialization of unsigned transactions\n  // does not include prevOut data and is a bit painful to work with\n  // going to be deprecated in favor of psbt\n  // @deprecated\n  | 'legacy'\n  // This is the standard psbt format, including the full prevTx data for legacy transactions.\n  // This will remain supported but is not the default, since the data sizes can become prohibitively large.\n  | 'psbt'\n  // This is a nonstandard psbt version where legacy inputs are serialized as if they were segwit inputs.\n  // While this prevents us to fully verify the transaction fee, we have other checks in place to ensure the fee is within bounds.\n  | 'psbt-lite';\n\nexport class ErrorDeprecatedTxFormat extends Error {\n  constructor(txFormat: TxFormat) {\n    super(`SDK support for txFormat=${txFormat} is deprecated on this environment. Please use psbt instead.`);\n  }\n}\n\ntype UtxoCustomSigningFunction<TNumber extends number | bigint> = {\n  (params: {\n    coin: IBaseCoin;\n    txPrebuild: TransactionPrebuild<TNumber>;\n    pubs?: string[];\n    /**\n     * signingStep flag becomes applicable when both of the following conditions are met:\n     * 1) When the external express signer is activated\n     * 2) When the PSBT includes at least one taprootKeyPathSpend input.\n     *\n     * The signing process of a taprootKeyPathSpend input is a 4-step sequence:\n     * i) user nonce generation - signerNonce - this is the first call to external express signer signTransaction\n     * ii) bitgo nonce generation - cosignerNonce - this is the first and only call to local signTransaction\n     * iii) user signature - signerSignature - this is the second call to external express signer signTransaction\n     * iv) bitgo signature - not in signTransaction method’s scope\n     *\n     * In the absence of this flag, the aforementioned first three sequence is executed in a single signTransaction call.\n     *\n     * NOTE: We make a strong assumption that the external express signer and its caller uses sticky sessions,\n     * since PSBTs are cached in step 1 to be used in step 3 for MuSig2 user secure nonce access.\n     */\n    signingStep?: 'signerNonce' | 'signerSignature' | 'cosignerNonce';\n  }): Promise<SignedTransaction>;\n};\n\nconst { isChainCode, scriptTypeForChain, outputScripts } = bitgo;\n\ntype Unspent<TNumber extends number | bigint = number> = bitgo.Unspent<TNumber>;\n\n/**\n * Convert ValidationError to TxIntentMismatchRecipientError with structured data\n *\n * This preserves the structured error information from the original ValidationError\n * by extracting the mismatched outputs and converting them to the standardized format.\n * The original error is preserved as the `cause` for debugging purposes.\n */\nfunction convertValidationErrorToTxIntentMismatch(\n  error: AggregateValidationError,\n  reqId: string | IRequestTracer | undefined,\n  txParams: BaseTransactionParams,\n  txHex: string | undefined,\n  txExplanation?: unknown\n): TxIntentMismatchRecipientError {\n  const mismatchedRecipients: MismatchedRecipient[] = [];\n\n  for (const err of error.errors) {\n    if (err instanceof ErrorMissingOutputs) {\n      mismatchedRecipients.push(\n        ...err.missingOutputs.map((output) => ({\n          address: output.address,\n          amount: output.amount.toString(),\n        }))\n      );\n    } else if (err instanceof ErrorImplicitExternalOutputs) {\n      mismatchedRecipients.push(\n        ...err.implicitExternalOutputs.map((output) => ({\n          address: output.address,\n          amount: output.amount.toString(),\n        }))\n      );\n    }\n  }\n\n  const txIntentError = new TxIntentMismatchRecipientError(\n    error.message,\n    reqId,\n    [txParams],\n    txHex,\n    mismatchedRecipients,\n    txExplanation\n  );\n  // Preserve the original structured error as the cause for debugging\n  // See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause\n  (txIntentError as Error & { cause?: Error }).cause = error;\n  return txIntentError;\n}\n\nexport type { DecodedTransaction } from './transaction/types';\n\nexport type RootWalletKeys = bitgo.RootWalletKeys;\n\nexport type UtxoCoinSpecific = AddressCoinSpecific | DescriptorAddressCoinSpecific;\n\nexport interface VerifyAddressOptions<TCoinSpecific extends UtxoCoinSpecific> extends BaseVerifyAddressOptions {\n  chain?: number;\n  index: number;\n  coinSpecific?: TCoinSpecific;\n}\n\nexport type Bip322Message = {\n  address: string;\n  message: string;\n};\n\nexport interface TransactionInfo<TNumber extends number | bigint = number> {\n  /** Maps txid to txhex. Required for offline signing. */\n  txHexes?: Record<string, string>;\n  changeAddresses?: string[];\n  /** psbt does not require unspents. */\n  unspents?: Unspent<TNumber>[];\n}\n\nexport interface ExplainTransactionOptions<TNumber extends number | bigint = number> {\n  txHex: string;\n  txInfo?: TransactionInfo<TNumber>;\n  feeInfo?: string;\n  pubs?: Triple<string>;\n  decodeWith?: SdkBackend;\n}\n\nexport interface DecoratedExplainTransactionOptions<TNumber extends number | bigint = number>\n  extends ExplainTransactionOptions<TNumber> {\n  changeInfo?: { address: string; chain: number; index: number }[];\n}\n\nexport type UtxoNetwork = utxolib.Network;\n\nexport interface TransactionPrebuild<TNumber extends number | bigint = number> extends BaseTransactionPrebuild {\n  txInfo?: TransactionInfo<TNumber>;\n  blockHeight?: number;\n  decodeWith?: SdkBackend;\n}\n\nexport interface TransactionParams extends BaseTransactionParams {\n  walletPassphrase?: string;\n  allowExternalChangeAddress?: boolean;\n  changeAddress?: string;\n  rbfTxIds?: string[];\n}\n\nexport interface ParseTransactionOptions<TNumber extends number | bigint = number> extends BaseParseTransactionOptions {\n  txParams: TransactionParams;\n  txPrebuild: TransactionPrebuild<TNumber>;\n  wallet: UtxoWallet;\n  verification?: VerificationOptions;\n  reqId?: IRequestTracer;\n}\n\nexport interface GenerateAddressOptions {\n  addressType?: ScriptType2Of3;\n  threshold?: number;\n  chain?: number;\n  index?: number;\n  segwit?: boolean;\n  bech32?: boolean;\n}\n\nexport interface GenerateFixedScriptAddressOptions extends GenerateAddressOptions {\n  format?: CreateAddressFormat;\n  keychains: {\n    pub: string;\n    aspKeyId?: string;\n  }[];\n}\n\nexport interface AddressDetails {\n  address: string;\n  chain: number;\n  index: number;\n  coin: string;\n  coinSpecific: AddressCoinSpecific | DescriptorAddressCoinSpecific;\n  addressType?: string;\n}\n\nexport interface DescriptorAddressCoinSpecific extends AddressCoinSpecific {\n  descriptorName: string;\n  descriptorChecksum: string;\n}\n\ntype UtxoBaseSignTransactionOptions<TNumber extends number | bigint = number> = BaseSignTransactionOptions & {\n  /** Transaction prebuild from bitgo server */\n  txPrebuild: {\n    /**\n     * walletId is required in following 2 scenarios.\n     * 1. External signer express mode is used.\n     * 2. bitgo MuSig2 nonce is requested\n     */\n    walletId?: string;\n    txHex: string;\n    txInfo?: TransactionInfo<TNumber>;\n    decodeWith?: SdkBackend;\n  };\n  /** xpubs triple for wallet (user, backup, bitgo). Required only when txPrebuild.txHex is not a PSBT */\n  pubs?: Triple<string>;\n  /** xpub for cosigner (defaults to bitgo) */\n  cosignerPub?: string;\n  /**\n   * When true, creates full-signed transaction without placeholder signatures.\n   * When false, creates half-signed transaction with placeholder signatures.\n   */\n  isLastSignature?: boolean;\n  /**\n   * If true, allows signing a non-segwit input with a witnessUtxo instead requiring a previous\n   * transaction (nonWitnessUtxo)\n   */\n  allowNonSegwitSigningWithoutPrevTx?: boolean;\n  wallet?: UtxoWallet;\n};\n\nexport type SignTransactionOptions<TNumber extends number | bigint = number> = UtxoBaseSignTransactionOptions<TNumber> &\n  (\n    | {\n        prv: string;\n        signingStep?: 'signerNonce' | 'signerSignature';\n      }\n    | {\n        signingStep: 'cosignerNonce';\n      }\n  );\n\nexport interface MultiSigAddress {\n  outputScript: Buffer;\n  redeemScript?: Buffer;\n  witnessScript?: Buffer;\n  address: string;\n}\n\nexport interface RecoverFromWrongChainOptions {\n  txid: string;\n  recoveryAddress: string;\n  wallet: string;\n  walletPassphrase?: string;\n  xprv?: string;\n  apiKey?: string;\n  /** @deprecated */\n  coin?: AbstractUtxoCoin;\n  recoveryCoin?: AbstractUtxoCoin;\n  signed?: boolean;\n}\n\nexport interface VerifyKeySignaturesOptions {\n  userKeychain: { pub?: string };\n  keychainToVerify: { pub?: string };\n  keySignature: string;\n}\n\nexport interface VerifyUserPublicKeyOptions {\n  userKeychain?: UtxoKeychain;\n  disableNetworking: boolean;\n  txParams: TransactionParams;\n}\n\nexport interface VerifyTransactionOptions<TNumber extends number | bigint = number>\n  extends BaseVerifyTransactionOptions {\n  txPrebuild: TransactionPrebuild<TNumber>;\n  txParams: TransactionParams;\n  wallet: UtxoWallet;\n}\n\nexport interface SignPsbtRequest {\n  psbt: string;\n}\n\nexport interface SignPsbtResponse {\n  psbt: string;\n}\n\nexport abstract class AbstractUtxoCoin\n  extends BaseCoin\n  implements Musig2Participant<utxolib.bitgo.UtxoPsbt>, Musig2Participant<fixedScriptWallet.BitGoPsbt>\n{\n  public altScriptHash?: number;\n  public supportAltScriptDestination?: boolean;\n  public defaultSdkBackend: SdkBackend = 'utxolib';\n  public readonly amountType: 'number' | 'bigint';\n  private readonly _network: utxolib.Network;\n\n  protected constructor(bitgo: BitGoBase, network: utxolib.Network, amountType: 'number' | 'bigint' = 'number') {\n    super(bitgo);\n    if (!utxolib.isValidNetwork(network)) {\n      throw new Error(\n        'invalid network: please make sure to use the same version of ' +\n          '@bitgo-beta/utxo-lib as this library when initializing an instance of this class'\n      );\n    }\n    this.amountType = amountType;\n    this._network = network;\n  }\n\n  get network() {\n    return this._network;\n  }\n\n  getChain() {\n    return getChainFromNetwork(this.network);\n  }\n\n  getFamily() {\n    return getFamilyFromNetwork(this.network);\n  }\n\n  getFullName() {\n    return getFullNameFromNetwork(this.network);\n  }\n\n  /** Indicates whether the coin supports a block target */\n  supportsBlockTarget() {\n    // FIXME: the SDK does not seem to use this anywhere so it is unclear what the purpose of this method is\n    switch (getMainnet(this.network)) {\n      case utxolib.networks.bitcoin:\n      case utxolib.networks.dogecoin:\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  sweepWithSendMany(): boolean {\n    return true;\n  }\n\n  /** @deprecated */\n  static get validAddressTypes(): ScriptType2Of3[] {\n    return [...outputScripts.scriptTypes2Of3];\n  }\n\n  /**\n   * Returns the factor between the base unit and its smallest subdivison\n   * @return {number}\n   */\n  getBaseFactor() {\n    return 1e8;\n  }\n\n  /**\n   * Check if an address is valid\n   * @param address\n   * @param param\n   */\n  isValidAddress(address: string, param?: { anyFormat: boolean } | /* legacy parameter */ boolean): boolean {\n    if (typeof param === 'boolean' && param) {\n      throw new Error('deprecated');\n    }\n\n    // By default, allow all address formats.\n    // At the time of writing, the only additional address format is bch cashaddr.\n    const anyFormat = (param as { anyFormat: boolean } | undefined)?.anyFormat ?? true;\n    try {\n      // Find out if the address is valid for any format. Tries all supported formats by default.\n      // Throws if address cannot be decoded with any format.\n      const [format, script] = utxolib.addressFormat.toOutputScriptAndFormat(address, this.network);\n      // unless anyFormat is set, only 'default' is allowed.\n      if (!anyFormat && format !== 'default') {\n        return false;\n      }\n      // make sure that address is in normal representation for given format.\n      return address === utxolib.addressFormat.fromOutputScriptWithFormat(script, format, this.network);\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin.\n   *\n   * @param {String} pub the pub to be checked\n   * @returns {Boolean} is it valid?\n   */\n  isValidPub(pub: string) {\n    try {\n      return bip32.fromBase58(pub).isNeutered();\n    } catch (e) {\n      return false;\n    }\n  }\n\n  preprocessBuildParams(params: Record<string, any>): Record<string, any> {\n    if (params.recipients !== undefined) {\n      params.recipients =\n        params.recipients instanceof Array\n          ? params?.recipients?.map((recipient) => {\n              const { address, ...rest } = recipient;\n              return { ...rest, ...fromExtendedAddressFormat(address) };\n            })\n          : params.recipients;\n    }\n\n    return params;\n  }\n\n  /**\n   * Get the latest block height\n   * @param reqId\n   */\n  async getLatestBlockHeight(reqId?: RequestTracer): Promise<number> {\n    if (reqId) {\n      this.bitgo.setRequestTracer(reqId);\n    }\n    const chainhead = await this.bitgo.get(this.url('/public/block/latest')).result();\n    return (chainhead as any).height;\n  }\n\n  checkRecipient(recipient: { address: string; amount: number | string }): void {\n    assertValidTransactionRecipient(recipient);\n    if (!isScriptRecipient(recipient.address)) {\n      super.checkRecipient(recipient);\n    }\n  }\n\n  /**\n   * Run custom coin logic after a transaction prebuild has been received from BitGo\n   * @param prebuild\n   */\n  async postProcessPrebuild<TNumber extends number | bigint>(\n    prebuild: TransactionPrebuild<TNumber>\n  ): Promise<TransactionPrebuild<TNumber>> {\n    const tx = this.decodeTransactionFromPrebuild(prebuild);\n    if (_.isUndefined(prebuild.blockHeight)) {\n      prebuild.blockHeight = (await this.getLatestBlockHeight()) as number;\n    }\n    return _.extend({}, prebuild, { txHex: encodeTransaction(tx).toString('hex') });\n  }\n\n  /**\n   * Determine an address' type based on its witness and redeem script presence\n   * @param addressDetails\n   */\n  static inferAddressType(addressDetails: { chain: number }): ScriptType2Of3 | null {\n    return isChainCode(addressDetails.chain) ? scriptTypeForChain(addressDetails.chain) : null;\n  }\n\n  createTransactionFromHex<TNumber extends number | bigint = number>(\n    hex: string\n  ): utxolib.bitgo.UtxoTransaction<TNumber> {\n    return utxolib.bitgo.createTransactionFromHex<TNumber>(hex, this.network, this.amountType);\n  }\n\n  decodeTransaction<TNumber extends number | bigint>(\n    input: Buffer | string,\n    decodeWith: SdkBackend = this.defaultSdkBackend\n  ): DecodedTransaction<TNumber> {\n    if (typeof input === 'string') {\n      const buffer = stringToBufferTryFormats(input, ['hex', 'base64']);\n      return this.decodeTransaction(buffer, decodeWith);\n    }\n\n    if (utxolib.bitgo.isPsbt(input)) {\n      return decodePsbtWith(input, this.network, decodeWith);\n    } else {\n      if (decodeWith !== 'utxolib') {\n        console.error('received decodeWith hint %s, ignoring for legacy transaction', decodeWith);\n      }\n      return utxolib.bitgo.createTransactionFromBuffer(input, this.network, {\n        amountType: this.amountType,\n      });\n    }\n  }\n\n  decodeTransactionAsPsbt(input: Buffer | string): utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt {\n    const decoded = this.decodeTransaction(input);\n    if (decoded instanceof fixedScriptWallet.BitGoPsbt || decoded instanceof utxolib.bitgo.UtxoPsbt) {\n      return decoded;\n    }\n    throw new Error('expected psbt but got transaction');\n  }\n\n  decodeTransactionFromPrebuild<TNumber extends number | bigint>(prebuild: {\n    txHex?: string;\n    txBase64?: string;\n    decodeWith?: string;\n  }): DecodedTransaction<TNumber> {\n    const string = prebuild.txHex ?? prebuild.txBase64;\n    if (!string) {\n      throw new Error('missing required txHex or txBase64 property');\n    }\n    let { decodeWith } = prebuild;\n    if (decodeWith !== undefined) {\n      if (typeof decodeWith !== 'string' || !isSdkBackend(decodeWith)) {\n        console.error('decodeWith %s is not a valid value, using default', decodeWith);\n        decodeWith = undefined;\n      }\n    }\n    return this.decodeTransaction(string, decodeWith);\n  }\n\n  toCanonicalTransactionRecipient(output: { valueString: string; address?: string }): {\n    amount: bigint;\n    address: string;\n  } {\n    const amount = BigInt(output.valueString);\n    assertValidTransactionRecipient({ amount, address: output.address });\n    assert(output.address, 'address is required');\n    if (isScriptRecipient(output.address)) {\n      return { amount, address: output.address };\n    }\n    return { amount, address: this.canonicalAddress(output.address) };\n  }\n\n  /**\n   * Extract and fill transaction details such as internal/change spend, external spend (explicit vs. implicit), etc.\n   * @param params\n   * @returns {*}\n   */\n  async parseTransaction<TNumber extends number | bigint = number>(\n    params: ParseTransactionOptions<TNumber>\n  ): Promise<ParsedTransaction<TNumber>> {\n    return parseTransaction(this, params);\n  }\n\n  /**\n   * @deprecated - use function verifyUserPublicKey instead\n   */\n  protected verifyUserPublicKey(params: VerifyUserPublicKeyOptions): boolean {\n    return verifyUserPublicKey(this.bitgo, params);\n  }\n\n  /**\n   * @deprecated - use function verifyKeySignature instead\n   */\n  public verifyKeySignature(params: VerifyKeySignaturesOptions): boolean {\n    return verifyKeySignature(params);\n  }\n\n  /**\n   * Verify that a transaction prebuild complies with the original intention\n   *\n   * @param params\n   * @param params.txParams params object passed to send\n   * @param params.txPrebuild prebuild object returned by server\n   * @param params.txPrebuild.txHex prebuilt transaction's txHex form\n   * @param params.wallet Wallet object to obtain keys to verify against\n   * @param params.verification Object specifying some verification parameters\n   * @param params.verification.disableNetworking Disallow fetching any data from the internet for verification purposes\n   * @param params.verification.keychains Pass keychains manually rather than fetching them by id\n   * @param params.verification.addresses Address details to pass in for out-of-band verification\n   * @returns {boolean} True if verification passes\n   * @throws {TxIntentMismatchError} if transaction validation fails\n   * @throws {TxIntentMismatchRecipientError} if transaction recipients don't match user intent\n   */\n  async verifyTransaction<TNumber extends number | bigint = number>(\n    params: VerifyTransactionOptions<TNumber>\n  ): Promise<boolean> {\n    try {\n      return await verifyTransaction(this, this.bitgo, params);\n    } catch (error) {\n      if (error instanceof AggregateValidationError) {\n        const txExplanation = await TxIntentMismatchError.tryGetTxExplanation(\n          this as unknown as IBaseCoin,\n          params.txPrebuild\n        );\n        throw convertValidationErrorToTxIntentMismatch(\n          error,\n          params.reqId,\n          params.txParams,\n          params.txPrebuild.txHex,\n          txExplanation\n        );\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Make sure an address is valid and throw an error if it's not.\n   * @param params.address The address string on the network\n   * @param params.addressType\n   * @param params.keychains Keychain objects with xpubs\n   * @param params.coinSpecific Coin-specific details for the address such as a witness script\n   * @param params.chain Derivation chain\n   * @param params.index Derivation index\n   * @throws {InvalidAddressError}\n   * @throws {InvalidAddressDerivationPropertyError}\n   * @throws {UnexpectedAddressError}\n   */\n  async isWalletAddress(params: VerifyAddressOptions<UtxoCoinSpecific>, wallet?: IWallet): Promise<boolean> {\n    const { address, keychains, chain, index } = params;\n\n    if (!this.isValidAddress(address)) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    if (wallet && isDescriptorWallet(wallet)) {\n      if (!keychains) {\n        throw new Error('missing required param keychains');\n      }\n      if (!isTriple(keychains)) {\n        throw new Error('keychains must be a triple');\n      }\n      assertDescriptorWalletAddress(\n        this.network,\n        params,\n        getDescriptorMapFromWallet(wallet, toBip32Triple(keychains), getPolicyForEnv(this.bitgo.env))\n      );\n      return true;\n    }\n\n    if ((_.isUndefined(chain) && _.isUndefined(index)) || !(_.isFinite(chain) && _.isFinite(index))) {\n      throw new InvalidAddressDerivationPropertyError(\n        `address validation failure: invalid chain (${chain}) or index (${index})`\n      );\n    }\n\n    if (!keychains) {\n      throw new Error('missing required param keychains');\n    }\n\n    assertFixedScriptWalletAddress(this.network, {\n      address,\n      keychains,\n      format: params.format ?? 'base58',\n      addressType: params.addressType,\n      chain,\n      index,\n    });\n\n    return true;\n  }\n\n  /**\n   * @param addressType\n   * @returns true iff coin supports spending from unspentType\n   */\n  supportsAddressType(addressType: ScriptType2Of3): boolean {\n    return utxolib.bitgo.outputScripts.isSupportedScriptType(this.network, addressType);\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.onchain;\n  }\n\n  /**\n   * @param chain\n   * @return true iff coin supports spending from chain\n   */\n  supportsAddressChain(chain: number): boolean {\n    return isChainCode(chain) && this.supportsAddressType(utxolib.bitgo.scriptTypeForChain(chain));\n  }\n\n  keyIdsForSigning(): number[] {\n    return [KeyIndices.USER, KeyIndices.BACKUP, KeyIndices.BITGO];\n  }\n\n  /**\n   * @returns input psbt added with deterministic MuSig2 nonce for bitgo key for each MuSig2 inputs.\n   * @param psbt all MuSig2 inputs should contain user MuSig2 nonce\n   * @param walletId\n   */\n  async getMusig2Nonces(psbt: utxolib.bitgo.UtxoPsbt, walletId: string): Promise<utxolib.bitgo.UtxoPsbt>;\n  async getMusig2Nonces(psbt: fixedScriptWallet.BitGoPsbt, walletId: string): Promise<fixedScriptWallet.BitGoPsbt>;\n  async getMusig2Nonces<T extends utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt>(\n    psbt: T,\n    walletId: string\n  ): Promise<T>;\n  async getMusig2Nonces<T extends utxolib.bitgo.UtxoPsbt | fixedScriptWallet.BitGoPsbt>(\n    psbt: T,\n    walletId: string\n  ): Promise<T> {\n    const buffer = encodeTransaction(psbt);\n    const response = await this.bitgo\n      .post(this.url('/wallet/' + walletId + '/tx/signpsbt'))\n      .send({ psbt: buffer.toString('hex') })\n      .result();\n    if (psbt instanceof utxolib.bitgo.UtxoPsbt) {\n      return decodePsbtWith(response.psbt, this.network, 'utxolib') as T;\n    } else {\n      return decodePsbtWith(response.psbt, this.network, 'wasm-utxo') as T;\n    }\n  }\n\n  /**\n   * @deprecated Use getMusig2Nonces instead\n   * @returns input psbt added with deterministic MuSig2 nonce for bitgo key for each MuSig2 inputs.\n   * @param psbtHex all MuSig2 inputs should contain user MuSig2 nonce\n   * @param walletId\n   */\n  async signPsbt(psbtHex: string, walletId: string): Promise<SignPsbtResponse> {\n    const psbt = await this.getMusig2Nonces(this.decodeTransactionAsPsbt(psbtHex), walletId);\n    return { psbt: encodeTransaction(psbt).toString('hex') };\n  }\n\n  /**\n   * @returns input psbt added with deterministic MuSig2 nonce for bitgo key for each MuSig2 inputs from OVC.\n   * @param ovcJson JSON object provided by OVC with fields psbtHex and walletId\n   */\n  async signPsbtFromOVC(ovcJson: Record<string, unknown>): Promise<Record<string, unknown>> {\n    assert(ovcJson['psbtHex'], 'ovcJson must contain psbtHex');\n    assert(ovcJson['walletId'], 'ovcJson must contain walletId');\n    const hex = ovcJson['psbtHex'] as string;\n    const walletId = ovcJson['walletId'] as string;\n    const psbt = await this.getMusig2Nonces(this.decodeTransactionAsPsbt(hex), walletId);\n    return _.extend(ovcJson, { txHex: encodeTransaction(psbt).toString('hex') });\n  }\n\n  /**\n   * Assemble keychain and half-sign prebuilt transaction\n   * @param params - {@see SignTransactionOptions}\n   * @returns {Promise<SignedTransaction | HalfSignedUtxoTransaction>}\n   */\n  async signTransaction<TNumber extends number | bigint = number>(\n    params: SignTransactionOptions<TNumber>\n  ): Promise<SignedTransaction | HalfSignedUtxoTransaction> {\n    return signTransaction<TNumber>(this, this.bitgo, params);\n  }\n\n  /**\n   * Sign a transaction with a custom signing function. Example use case is express external signer\n   * @param customSigningFunction custom signing function that returns a single signed transaction\n   * @param signTransactionParams parameters for custom signing function. Includes txPrebuild and pubs (for legacy tx only).\n   *\n   * @returns signed transaction as hex string\n   */\n  async signWithCustomSigningFunction<TNumber extends number | bigint>(\n    customSigningFunction: UtxoCustomSigningFunction<TNumber>,\n    signTransactionParams: { txPrebuild: TransactionPrebuild<TNumber>; pubs?: string[] }\n  ): Promise<SignedTransaction> {\n    const txHex = signTransactionParams.txPrebuild.txHex;\n    assert(txHex, 'missing txHex parameter');\n\n    const tx = this.decodeTransaction(txHex);\n\n    const isTxWithKeyPathSpendInput = tx instanceof bitgo.UtxoPsbt && bitgo.isTransactionWithKeyPathSpendInput(tx);\n\n    if (!isTxWithKeyPathSpendInput) {\n      return await customSigningFunction({ ...signTransactionParams, coin: this });\n    }\n\n    const getTxHex = (v: SignedTransaction): string => {\n      if ('txHex' in v) {\n        return v.txHex;\n      }\n      throw new Error('txHex not found in signTransaction result');\n    };\n\n    const signerNonceTx = await customSigningFunction({\n      ...signTransactionParams,\n      signingStep: 'signerNonce',\n      coin: this,\n    });\n\n    const { pubs } = signTransactionParams;\n    assert(pubs === undefined || isTriple(pubs));\n\n    const cosignerNonceTx = await this.signTransaction<TNumber>({\n      ...signTransactionParams,\n      pubs,\n      txPrebuild: { ...signTransactionParams.txPrebuild, txHex: getTxHex(signerNonceTx) },\n      signingStep: 'cosignerNonce',\n    });\n\n    return await customSigningFunction({\n      ...signTransactionParams,\n      txPrebuild: { ...signTransactionParams.txPrebuild, txHex: getTxHex(cosignerNonceTx) },\n      signingStep: 'signerSignature',\n      coin: this,\n    });\n  }\n\n  /**\n   * @param unspent\n   * @returns {boolean}\n   */\n  isBitGoTaintedUnspent<TNumber extends number | bigint>(unspent: Unspent<TNumber>): boolean {\n    return isReplayProtectionUnspent<TNumber>(unspent, this.network);\n  }\n\n  /**\n   * Decompose a raw psbt/transaction into useful information, such as the total amounts,\n   * change amounts, and transaction outputs.\n   * @param params\n   */\n  override async explainTransaction<TNumber extends number | bigint = number>(\n    params: ExplainTransactionOptions<TNumber>\n  ): Promise<TransactionExplanation> {\n    return explainTx(this.decodeTransactionFromPrebuild(params), params, this.network);\n  }\n\n  /**\n   * @deprecated - use {@see backupKeyRecovery}\n   * Builds a funds recovery transaction without BitGo\n   * @param params - {@see backupKeyRecovery}\n   */\n  async recover(params: RecoverParams): ReturnType<typeof backupKeyRecovery> {\n    return backupKeyRecovery(this, this.bitgo, params);\n  }\n\n  async recoverV1(params: V1RecoverParams): ReturnType<typeof v1BackupKeyRecovery> {\n    return v1BackupKeyRecovery(this, this.bitgo, params);\n  }\n\n  async sweepV1(params: V1SweepParams): ReturnType<typeof v1Sweep> {\n    return v1Sweep(this, this.bitgo, params);\n  }\n\n  /**\n   * Recover coin that was sent to wrong chain\n   * @param params\n   * @param params.txid The txid of the faulty transaction\n   * @param params.recoveryAddress address to send recovered funds to\n   * @param params.wallet the wallet that received the funds\n   * @param params.recoveryCoin the coin type of the wallet that received the funds\n   * @param params.signed return a half-signed transaction (default=true)\n   * @param params.walletPassphrase the wallet passphrase\n   * @param params.xprv the unencrypted xprv (used instead of wallet passphrase)\n   * @param params.apiKey for utxo coins other than [BTC,TBTC] this is a Block Chair api key\n   * @returns {*}\n   */\n  async recoverFromWrongChain<TNumber extends number | bigint = number>(\n    params: RecoverFromWrongChainOptions\n  ): Promise<CrossChainRecoverySigned<TNumber> | CrossChainRecoveryUnsigned<TNumber>> {\n    const { txid, recoveryAddress, wallet, walletPassphrase, xprv, apiKey } = params;\n\n    // params.recoveryCoin used to be params.coin, backwards compatibility\n    const recoveryCoin = params.coin || params.recoveryCoin;\n    if (!recoveryCoin) {\n      throw new Error('missing required object recoveryCoin');\n    }\n    // signed should default to true, and only be disabled if explicitly set to false (not undefined)\n    const signed = params.signed !== false;\n\n    const sourceCoinFamily = this.getFamily();\n    const recoveryCoinFamily = recoveryCoin.getFamily();\n    const supportedRecoveryCoins = supportedCrossChainRecoveries[sourceCoinFamily];\n\n    if (_.isUndefined(supportedRecoveryCoins) || !supportedRecoveryCoins.includes(recoveryCoinFamily)) {\n      throw new Error(`Recovery of ${sourceCoinFamily} balances from ${recoveryCoinFamily} wallets is not supported.`);\n    }\n\n    return await recoverCrossChain<TNumber>(this.bitgo, {\n      sourceCoin: this,\n      recoveryCoin,\n      walletId: wallet,\n      txid,\n      recoveryAddress,\n      walletPassphrase: signed ? walletPassphrase : undefined,\n      xprv: signed ? xprv : undefined,\n      apiKey,\n    });\n  }\n\n  /**\n   * Generate bip32 key pair\n   *\n   * @param seed\n   * @returns {Object} object with generated pub and prv\n   */\n  generateKeyPair(seed: Buffer): { pub: string; prv: string } {\n    if (!seed) {\n      // An extended private key has both a normal 256 bit private key and a 256\n      // bit chain code, both of which must be random. 512 bits is therefore the\n      // maximum entropy and gives us maximum security against cracking.\n      seed = randomBytes(512 / 8);\n    }\n    const extendedKey = bip32.fromSeed(seed);\n    return {\n      pub: extendedKey.neutered().toBase58(),\n      prv: extendedKey.toBase58(),\n    };\n  }\n\n  /**\n   * Determines the default transaction format based on wallet properties and network\n   * @param wallet - The wallet to check\n   * @param requestedFormat - Optional explicitly requested format\n   * @returns The transaction format to use, or undefined if no default applies\n   */\n  getDefaultTxFormat(wallet: Wallet, requestedFormat?: TxFormat): TxFormat | undefined {\n    // If format is explicitly requested, use it\n    if (requestedFormat !== undefined) {\n      if (isTestnet(this.network) && requestedFormat === 'legacy') {\n        throw new ErrorDeprecatedTxFormat(requestedFormat);\n      }\n\n      return requestedFormat;\n    }\n\n    if (isTestnet(this.network)) {\n      return 'psbt-lite';\n    }\n\n    const walletFlagMusigKp = wallet.flag('musigKp') === 'true';\n    const isHotWallet = wallet.type() === 'hot';\n\n    // Determine if we should default to psbt format\n    const shouldDefaultToPsbt =\n      wallet.subType() === 'distributedCustody' ||\n      // if mainnet, only default to psbt for btc hot wallets\n      (isMainnet(this.network) && getMainnet(this.network) === utxolib.networks.bitcoin && isHotWallet) ||\n      // default to psbt if it has the wallet flag\n      walletFlagMusigKp;\n\n    return shouldDefaultToPsbt ? 'psbt' : undefined;\n  }\n\n  async getExtraPrebuildParams(buildParams: ExtraPrebuildParamsOptions & { wallet: Wallet }): Promise<{\n    txFormat?: TxFormat;\n    changeAddressType?: ScriptType2Of3[] | ScriptType2Of3;\n  }> {\n    const txFormat = this.getDefaultTxFormat(buildParams.wallet, buildParams.txFormat as TxFormat | undefined);\n    let changeAddressType = buildParams.changeAddressType as ScriptType2Of3[] | ScriptType2Of3 | undefined;\n\n    // if the addressType is not specified, we need to default to p2trMusig2 for testnet hot wallets for staged rollout of p2trMusig2\n    if (\n      buildParams.addressType === undefined && // addressType is deprecated and replaced by `changeAddress`\n      buildParams.changeAddressType === undefined &&\n      buildParams.changeAddress === undefined &&\n      buildParams.wallet.type() === 'hot'\n    ) {\n      changeAddressType = ['p2trMusig2', 'p2wsh', 'p2shP2wsh', 'p2sh', 'p2tr'];\n    }\n\n    return {\n      txFormat,\n      changeAddressType,\n    };\n  }\n\n  preCreateBitGo(params: PrecreateBitGoOptions): void {\n    return;\n  }\n\n  async presignTransaction(params: PresignTransactionOptions): Promise<any> {\n    if (params.walletData && isUtxoWalletData(params.walletData) && isDescriptorWalletData(params.walletData)) {\n      return params;\n    }\n    // In the case that we have a 'psbt-lite' transaction format, we want to indicate in signing to not fail\n    const txHex = (params.txHex ?? params.txPrebuild?.txHex) as string;\n    if (\n      txHex &&\n      utxolib.bitgo.isPsbt(txHex as string) &&\n      utxolib.bitgo.isPsbtLite(utxolib.bitgo.createPsbtFromHex(txHex, this.network)) &&\n      params.allowNonSegwitSigningWithoutPrevTx === undefined\n    ) {\n      return { ...params, allowNonSegwitSigningWithoutPrevTx: true };\n    }\n    return params;\n  }\n\n  async supplementGenerateWallet(\n    walletParams: SupplementGenerateWalletOptions,\n    keychains: KeychainsTriplet\n  ): Promise<any> {\n    return walletParams;\n  }\n\n  transactionDataAllowed(): boolean {\n    return false;\n  }\n\n  valuelessTransferAllowed(): boolean {\n    return false;\n  }\n\n  getRecoveryProvider(apiToken?: string): RecoveryProvider {\n    return forCoin(this.getChain(), apiToken);\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey({ multiSigType, publicKey, prv }) {\n    if (multiSigType === 'tss') {\n      throw new Error('tss auditing is not supported for this coin');\n    }\n    if (!isValidPrv(prv) && !isValidXprv(prv)) {\n      throw new Error('invalid private key');\n    }\n    if (publicKey) {\n      const genPubKey = bip32.fromBase58(prv).neutered().toBase58();\n      if (genPubKey !== publicKey) {\n        throw new Error('public key does not match private key');\n      }\n    }\n  }\n}\n"]}