utxo-lib 1.0.1

package/dist/src/bitgo/UtxoPsbt.js

@@ -0,0 +1,469 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UtxoPsbt = exports.ProprietaryKeySubtype = exports.PSBT_PROPRIETARY_IDENTIFIER = void 0;
+const bip174_1 = require("bip174");
+const utils_1 = require("bip174/src/lib/utils");
+const bufferutils_1 = require("bitcoinjs-lib/src/bufferutils");
+const __1 = require("..");
+const UtxoTransaction_1 = require("./UtxoTransaction");
+const Unspent_1 = require("./Unspent");
+const scriptTypes_1 = require("./psbt/scriptTypes");
+const fromHalfSigned_1 = require("./psbt/fromHalfSigned");
+const outputScripts_1 = require("./outputScripts");
+const parseInput_1 = require("./parseInput");
+const bip32_1 = require("bip32");
+const bs58check = require("bs58check");
+const proprietaryKeyVal_1 = require("bip174/src/lib/proprietaryKeyVal");
+exports.PSBT_PROPRIETARY_IDENTIFIER = 'BITGO';
+var ProprietaryKeySubtype;
+(function (ProprietaryKeySubtype) {
+    ProprietaryKeySubtype[ProprietaryKeySubtype["ZEC_CONSENSUS_BRANCH_ID"] = 0] = "ZEC_CONSENSUS_BRANCH_ID";
+    ProprietaryKeySubtype[ProprietaryKeySubtype["MUSIG2_PARTICIPANT_PUB_KEYS"] = 1] = "MUSIG2_PARTICIPANT_PUB_KEYS";
+    ProprietaryKeySubtype[ProprietaryKeySubtype["MUSIG2_PUB_NONCE"] = 2] = "MUSIG2_PUB_NONCE";
+})(ProprietaryKeySubtype = exports.ProprietaryKeySubtype || (exports.ProprietaryKeySubtype = {}));
+// TODO: upstream does `checkInputsForPartialSigs` before doing things like
+// `setVersion`. Our inputs could have tapscriptsigs (or in future tapkeysigs)
+// and not fail that check. Do we want to do anything about that?
+class UtxoPsbt extends __1.Psbt {
+    static transactionFromBuffer(buffer, network) {
+        return UtxoTransaction_1.UtxoTransaction.fromBuffer(buffer, false, 'bigint', network);
+    }
+    static createPsbt(opts, data) {
+        return new UtxoPsbt(opts, data || new bip174_1.Psbt(new __1.PsbtTransaction({ tx: new UtxoTransaction_1.UtxoTransaction(opts.network) })));
+    }
+    static fromBuffer(buffer, opts) {
+        const transactionFromBuffer = (buffer) => {
+            const tx = this.transactionFromBuffer(buffer, opts.network);
+            return new __1.PsbtTransaction({ tx });
+        };
+        const psbtBase = bip174_1.Psbt.fromBuffer(buffer, transactionFromBuffer, {
+            bip32PathsAbsolute: opts.bip32PathsAbsolute,
+        });
+        const psbt = this.createPsbt(opts, psbtBase);
+        // Upstream checks for duplicate inputs here, but it seems to be of dubious value.
+        return psbt;
+    }
+    static fromHex(data, opts) {
+        return this.fromBuffer(Buffer.from(data, 'hex'), opts);
+    }
+    get network() {
+        return this.tx.network;
+    }
+    toHex() {
+        return this.toBuffer().toString('hex');
+    }
+    /**
+     * @return true iff PSBT input is finalized
+     */
+    isInputFinalized(inputIndex) {
+        const input = utils_1.checkForInput(this.data.inputs, inputIndex);
+        return Buffer.isBuffer(input.finalScriptSig) || Buffer.isBuffer(input.finalScriptWitness);
+    }
+    /**
+     * @return partialSig/tapScriptSig count iff input is not finalized
+     */
+    getSignatureCount(inputIndex) {
+        if (this.isInputFinalized(inputIndex)) {
+            throw new Error('Input is already finalized');
+        }
+        const input = utils_1.checkForInput(this.data.inputs, inputIndex);
+        return Math.max(Array.isArray(input.partialSig) ? input.partialSig.length : 0, Array.isArray(input.tapScriptSig) ? input.tapScriptSig.length : 0);
+    }
+    getNonWitnessPreviousTxids() {
+        const txInputs = this.txInputs; // These are somewhat costly to extract
+        const txidSet = new Set();
+        this.data.inputs.forEach((input, index) => {
+            if (!input.witnessUtxo) {
+                throw new Error('Must have witness UTXO for all inputs');
+            }
+            if (!scriptTypes_1.isSegwit(input.witnessUtxo.script, input.redeemScript)) {
+                txidSet.add(Unspent_1.getOutputIdForInput(txInputs[index]).txid);
+            }
+        });
+        return [...txidSet];
+    }
+    addNonWitnessUtxos(txBufs) {
+        const txInputs = this.txInputs; // These are somewhat costly to extract
+        this.data.inputs.forEach((input, index) => {
+            if (!input.witnessUtxo) {
+                throw new Error('Must have witness UTXO for all inputs');
+            }
+            if (!scriptTypes_1.isSegwit(input.witnessUtxo.script, input.redeemScript)) {
+                const { txid } = Unspent_1.getOutputIdForInput(txInputs[index]);
+                if (txBufs[txid] === undefined) {
+                    throw new Error('Not all required previous transactions provided');
+                }
+                this.updateInput(index, { nonWitnessUtxo: txBufs[txid] });
+            }
+        });
+        return this;
+    }
+    static fromTransaction(transaction, prevOutputs) {
+        if (prevOutputs.length !== transaction.ins.length) {
+            throw new Error(`Transaction has ${transaction.ins.length} inputs, but ${prevOutputs.length} previous outputs provided`);
+        }
+        const clonedTransaction = transaction.clone();
+        const updates = fromHalfSigned_1.unsign(clonedTransaction, prevOutputs);
+        const psbtBase = new bip174_1.Psbt(new __1.PsbtTransaction({ tx: clonedTransaction }));
+        clonedTransaction.ins.forEach(() => psbtBase.inputs.push({ unknownKeyVals: [] }));
+        clonedTransaction.outs.forEach(() => psbtBase.outputs.push({ unknownKeyVals: [] }));
+        const psbt = this.createPsbt({ network: transaction.network }, psbtBase);
+        updates.forEach((update, index) => {
+            psbt.updateInput(index, update);
+            psbt.updateInput(index, { witnessUtxo: { script: prevOutputs[index].script, value: prevOutputs[index].value } });
+        });
+        return psbt;
+    }
+    getUnsignedTx() {
+        return this.tx.clone();
+    }
+    static newTransaction(network) {
+        return new UtxoTransaction_1.UtxoTransaction(network);
+    }
+    get tx() {
+        return this.data.globalMap.unsignedTx.tx;
+    }
+    checkForSignatures(propName) {
+        this.data.inputs.forEach((input) => {
+            var _a, _b;
+            if (((_a = input.tapScriptSig) === null || _a === void 0 ? void 0 : _a.length) || input.tapKeySig || ((_b = input.partialSig) === null || _b === void 0 ? void 0 : _b.length)) {
+                throw new Error(`Cannot modify ${propName !== null && propName !== void 0 ? propName : 'transaction'} - signatures exist.`);
+            }
+        });
+    }
+    /**
+     * Mostly copied from bitcoinjs-lib/ts_src/psbt.ts
+     */
+    finalizeAllInputs() {
+        utils_1.checkForInput(this.data.inputs, 0); // making sure we have at least one
+        this.data.inputs.map((input, idx) => {
+            var _a;
+            return ((_a = input.tapScriptSig) === null || _a === void 0 ? void 0 : _a.length) ? this.finalizeTaprootInput(idx) : this.finalizeInput(idx);
+        });
+        return this;
+    }
+    finalizeTaprootInput(inputIndex) {
+        var _a, _b;
+        const input = utils_1.checkForInput(this.data.inputs, inputIndex);
+        // witness = control-block script first-sig second-sig
+        if (((_a = input.tapLeafScript) === null || _a === void 0 ? void 0 : _a.length) !== 1) {
+            throw new Error('Only one leaf script supported for finalizing');
+        }
+        const { controlBlock, script } = input.tapLeafScript[0];
+        const witness = [script, controlBlock];
+        const [pubkey1, pubkey2] = parseInput_1.parsePubScript(script, 'p2tr').publicKeys;
+        for (const pk of [pubkey1, pubkey2]) {
+            const sig = (_b = input.tapScriptSig) === null || _b === void 0 ? void 0 : _b.find(({ pubkey }) => pubkey.equals(pk));
+            if (!sig) {
+                throw new Error('Could not find signatures in Script Sig.');
+            }
+            witness.unshift(sig.signature);
+        }
+        const witnessLength = witness.reduce((s, b) => s + b.length + bufferutils_1.varuint.encodingLength(b.length), 1);
+        const bufferWriter = bufferutils_1.BufferWriter.withCapacity(witnessLength);
+        bufferWriter.writeVector(witness);
+        const finalScriptWitness = bufferWriter.end();
+        this.data.updateInput(inputIndex, { finalScriptWitness });
+        this.data.clearFinalizedInput(inputIndex);
+        return this;
+    }
+    finalizeTapInputWithSingleLeafScriptAndSignature(inputIndex) {
+        var _a, _b;
+        const input = utils_1.checkForInput(this.data.inputs, inputIndex);
+        if (((_a = input.tapLeafScript) === null || _a === void 0 ? void 0 : _a.length) !== 1) {
+            throw new Error('Only one leaf script supported for finalizing');
+        }
+        if (((_b = input.tapScriptSig) === null || _b === void 0 ? void 0 : _b.length) !== 1) {
+            throw new Error('Could not find signatures in Script Sig.');
+        }
+        const { controlBlock, script } = input.tapLeafScript[0];
+        const witness = [input.tapScriptSig[0].signature, script, controlBlock];
+        const witnessLength = witness.reduce((s, b) => s + b.length + bufferutils_1.varuint.encodingLength(b.length), 1);
+        const bufferWriter = bufferutils_1.BufferWriter.withCapacity(witnessLength);
+        bufferWriter.writeVector(witness);
+        const finalScriptWitness = bufferWriter.end();
+        this.data.updateInput(inputIndex, { finalScriptWitness });
+        this.data.clearFinalizedInput(inputIndex);
+        return this;
+    }
+    /**
+     * Mostly copied from bitcoinjs-lib/ts_src/psbt.ts
+     *
+     * Unlike the function it overrides, this does not take a validator. In BitGo
+     * context, we know how we want to validate so we just hard code the right
+     * validator.
+     */
+    validateSignaturesOfAllInputs() {
+        utils_1.checkForInput(this.data.inputs, 0); // making sure we have at least one
+        const results = this.data.inputs.map((input, idx) => {
+            var _a;
+            return ((_a = input.tapScriptSig) === null || _a === void 0 ? void 0 : _a.length)
+                ? this.validateTaprootSignaturesOfInput(idx)
+                : this.validateSignaturesOfInput(idx, (p, m, s) => __1.ecc.verify(m, p, s));
+        });
+        return results.reduce((final, res) => res && final, true);
+    }
+    validateTaprootSignaturesOfInput(inputIndex, pubkey) {
+        const input = this.data.inputs[inputIndex];
+        const tapSigs = (input || {}).tapScriptSig;
+        if (!input || !tapSigs || tapSigs.length < 1) {
+            throw new Error('No signatures to validate');
+        }
+        let mySigs;
+        if (pubkey) {
+            const xOnlyPubkey = outputScripts_1.toXOnlyPublicKey(pubkey);
+            mySigs = tapSigs.filter((sig) => sig.pubkey.equals(xOnlyPubkey));
+            if (mySigs.length < 1) {
+                throw new Error('No signatures for this pubkey');
+            }
+        }
+        else {
+            mySigs = tapSigs;
+        }
+        const results = [];
+        for (const pSig of mySigs) {
+            const { signature, leafHash, pubkey } = pSig;
+            let sigHashType;
+            let sig;
+            if (signature.length === 65) {
+                sigHashType = signature[64];
+                sig = signature.slice(0, 64);
+            }
+            else {
+                sigHashType = __1.Transaction.SIGHASH_DEFAULT;
+                sig = signature;
+            }
+            const { hash } = this.getTaprootHashForSig(inputIndex, [sigHashType], leafHash);
+            results.push(__1.ecc.verifySchnorr(hash, pubkey, sig));
+        }
+        return results.every((res) => res === true);
+    }
+    /**
+     * @return array of boolean values. True when corresponding index in `publicKeys` has signed the transaction.
+     * If no signature in the tx or no public key matching signature, the validation is considered as false.
+     */
+    getSignatureValidationArray(inputIndex) {
+        var _a;
+        const noSigErrorMessages = ['No signatures to validate', 'No signatures for this pubkey'];
+        const input = utils_1.checkForInput(this.data.inputs, inputIndex);
+        const isP2tr = (_a = input.tapScriptSig) === null || _a === void 0 ? void 0 : _a.length;
+        if (!this.data.globalMap.globalXpub) {
+            throw new Error('Cannot get signature validation array without global xpubs');
+        }
+        if (this.data.globalMap.globalXpub.length !== 3) {
+            throw new Error(`There must be 3 global xpubs and there are ${this.data.globalMap.globalXpub.length}`);
+        }
+        return this.data.globalMap.globalXpub.map((xpub) => {
+            // const bip32 = ECPair.fromPublicKey(xpub.extendedPubkey, { network: (this as any).opts.network });
+            const bip32 = bip32_1.BIP32Factory(__1.ecc).fromBase58(bs58check.encode(xpub.extendedPubkey));
+            try {
+                return isP2tr
+                    ? this.validateTaprootSignaturesOfInput(inputIndex, bip32.publicKey)
+                    : this.validateSignaturesOfInput(inputIndex, (p, m, s) => __1.ecc.verify(m, p, s), bip32.publicKey);
+            }
+            catch (err) {
+                // Not an elegant solution. Might need upstream changes like custom error types.
+                if (noSigErrorMessages.includes(err.message)) {
+                    return false;
+                }
+                throw err;
+            }
+        });
+    }
+    /**
+     * Mostly copied from bitcoinjs-lib/ts_src/psbt.ts
+     */
+    signAllInputsHD(hdKeyPair, sighashTypes = [__1.Transaction.SIGHASH_DEFAULT, __1.Transaction.SIGHASH_ALL]) {
+        var _a;
+        if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+            throw new Error('Need HDSigner to sign input');
+        }
+        const results = [];
+        for (let i = 0; i < this.data.inputs.length; i++) {
+            try {
+                if ((_a = this.data.inputs[i].tapBip32Derivation) === null || _a === void 0 ? void 0 : _a.length) {
+                    this.signTaprootInputHD(i, hdKeyPair, sighashTypes);
+                }
+                else {
+                    this.signInputHD(i, hdKeyPair, sighashTypes);
+                }
+                results.push(true);
+            }
+            catch (err) {
+                results.push(false);
+            }
+        }
+        if (results.every((v) => v === false)) {
+            throw new Error('No inputs were signed');
+        }
+        return this;
+    }
+    /**
+     * Mostly copied from bitcoinjs-lib/ts_src/psbt.ts:signInputHD
+     */
+    signTaprootInputHD(inputIndex, hdKeyPair, sighashTypes = [__1.Transaction.SIGHASH_DEFAULT, __1.Transaction.SIGHASH_ALL]) {
+        if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+            throw new Error('Need HDSigner to sign input');
+        }
+        const input = utils_1.checkForInput(this.data.inputs, inputIndex);
+        if (!input.tapBip32Derivation || input.tapBip32Derivation.length === 0) {
+            throw new Error('Need tapBip32Derivation to sign Taproot with HD');
+        }
+        const myDerivations = input.tapBip32Derivation
+            .map((bipDv) => {
+            if (bipDv.masterFingerprint.equals(hdKeyPair.fingerprint)) {
+                return bipDv;
+            }
+        })
+            .filter((v) => !!v);
+        if (myDerivations.length === 0) {
+            throw new Error('Need one tapBip32Derivation masterFingerprint to match the HDSigner fingerprint');
+        }
+        const signers = myDerivations.map((bipDv) => {
+            const node = hdKeyPair.derivePath(bipDv.path);
+            if (!bipDv.pubkey.equals(node.publicKey.slice(1))) {
+                throw new Error('pubkey did not match tapBip32Derivation');
+            }
+            return { signer: node, leafHashes: bipDv.leafHashes };
+        });
+        signers.forEach(({ signer, leafHashes }) => this.signTaprootInput(inputIndex, signer, leafHashes, sighashTypes));
+        return this;
+    }
+    signTaprootInput(inputIndex, signer, leafHashes, sighashTypes = [__1.Transaction.SIGHASH_DEFAULT, __1.Transaction.SIGHASH_ALL]) {
+        var _a;
+        const pubkey = outputScripts_1.toXOnlyPublicKey(signer.publicKey);
+        const input = utils_1.checkForInput(this.data.inputs, inputIndex);
+        // Figure out if this is script path or not, if not, tweak the private key
+        if (!((_a = input.tapLeafScript) === null || _a === void 0 ? void 0 : _a.length)) {
+            // See BitGo/BitGoJS/modules/utxo_lib/src/transaction_builder.ts:trySign for how to support it.
+            throw new Error('Taproot key path signing is not supported.');
+        }
+        if (input.tapLeafScript.length !== 1) {
+            throw new Error('Only one leaf script supported for signing');
+        }
+        const tapLeafScript = input.tapLeafScript[0];
+        const parsedControlBlock = __1.taproot.parseControlBlock(__1.ecc, tapLeafScript.controlBlock);
+        const { leafVersion } = parsedControlBlock;
+        if (leafVersion !== tapLeafScript.leafVersion) {
+            throw new Error('Tap script leaf version mismatch with control block');
+        }
+        const leafHash = __1.taproot.getTapleafHash(__1.ecc, parsedControlBlock, tapLeafScript.script);
+        if (!leafHashes.find((l) => l.equals(leafHash))) {
+            throw new Error(`Signer cannot sign for leaf hash ${leafHash.toString('hex')}`);
+        }
+        const { hash, sighashType } = this.getTaprootHashForSig(inputIndex, sighashTypes, leafHash);
+        let signature = signer.signSchnorr(hash);
+        if (sighashType !== __1.Transaction.SIGHASH_DEFAULT) {
+            signature = Buffer.concat([signature, Buffer.of(sighashType)]);
+        }
+        this.data.updateInput(inputIndex, {
+            tapScriptSig: [
+                {
+                    pubkey,
+                    signature,
+                    leafHash,
+                },
+            ],
+        });
+        return this;
+    }
+    getTaprootHashForSig(inputIndex, sighashTypes, leafHash) {
+        const sighashType = this.data.inputs[inputIndex].sighashType || __1.Transaction.SIGHASH_DEFAULT;
+        if (sighashTypes && sighashTypes.indexOf(sighashType) < 0) {
+            throw new Error(`Sighash type is not allowed. Retry the sign method passing the ` +
+                `sighashTypes array of whitelisted types. Sighash type: ${sighashType}`);
+        }
+        const txInputs = this.txInputs; // These are somewhat costly to extract
+        const prevoutScripts = [];
+        const prevoutValues = [];
+        this.data.inputs.forEach((input, i) => {
+            let prevout;
+            if (input.nonWitnessUtxo) {
+                // TODO: This could be costly, either cache it here, or find a way to share with super
+                const nonWitnessUtxoTx = this.constructor.transactionFromBuffer(input.nonWitnessUtxo, this.tx.network);
+                const prevoutHash = txInputs[i].hash;
+                const utxoHash = nonWitnessUtxoTx.getHash();
+                // If a non-witness UTXO is provided, its hash must match the hash specified in the prevout
+                if (!prevoutHash.equals(utxoHash)) {
+                    throw new Error(`Non-witness UTXO hash for input #${i} doesn't match the hash specified in the prevout`);
+                }
+                const prevoutIndex = txInputs[i].index;
+                prevout = nonWitnessUtxoTx.outs[prevoutIndex];
+            }
+            else if (input.witnessUtxo) {
+                prevout = input.witnessUtxo;
+            }
+            else {
+                throw new Error('Need a Utxo input item for signing');
+            }
+            prevoutScripts.push(prevout.script);
+            prevoutValues.push(prevout.value);
+        });
+        const hash = this.tx.hashForWitnessV1(inputIndex, prevoutScripts, prevoutValues, sighashType, leafHash);
+        return { hash, sighashType };
+    }
+    /**
+     * @retuns true iff the input is taproot.
+     */
+    isTaprootInput(inputIndex) {
+        const input = utils_1.checkForInput(this.data.inputs, inputIndex);
+        function isP2tr(output) {
+            try {
+                __1.p2trPayments.p2tr({ output }, { eccLib: __1.ecc });
+                return true;
+            }
+            catch (err) {
+                return false;
+            }
+        }
+        return !!(input.tapInternalKey ||
+            input.tapMerkleRoot ||
+            (input.tapLeafScript && input.tapLeafScript.length) ||
+            (input.tapBip32Derivation && input.tapBip32Derivation.length) ||
+            (input.witnessUtxo && isP2tr(input.witnessUtxo.script)));
+    }
+    /**
+     * @returns hash and hashType for taproot input at inputIndex
+     * @throws error if input at inputIndex is not a taproot input
+     */
+    getTaprootHashForSigChecked(inputIndex, sighashTypes = [__1.Transaction.SIGHASH_DEFAULT, __1.Transaction.SIGHASH_ALL], leafHash) {
+        if (!this.isTaprootInput(inputIndex)) {
+            throw new Error(`${inputIndex} input is not a taproot type to take taproot tx hash`);
+        }
+        return this.getTaprootHashForSig(inputIndex, sighashTypes, leafHash);
+    }
+    /**
+     * Adds proprietary key value pair to PSBT input.
+     * Default identifierEncoding is utf-8 for identifier.
+     */
+    addProprietaryKeyValToInput(inputIndex, keyValueData) {
+        return this.addUnknownKeyValToInput(inputIndex, {
+            key: proprietaryKeyVal_1.encodeProprietaryKey(keyValueData.key),
+            value: keyValueData.value,
+        });
+    }
+    /**
+     * To search any data from proprietary key value againts keydata.
+     * Default identifierEncoding is utf-8 for identifier.
+     */
+    getProprietaryKeyVals(inputIndex, keySearch) {
+        const input = utils_1.checkForInput(this.data.inputs, inputIndex);
+        if (!input.unknownKeyVals || input.unknownKeyVals.length === 0) {
+            return [];
+        }
+        const keyVals = input.unknownKeyVals.map(({ key, value }, i) => {
+            return { key: proprietaryKeyVal_1.decodeProprietaryKey(key), value };
+        });
+        return keyVals.filter((keyVal) => {
+            return (keySearch === undefined ||
+                (keySearch.identifier === keyVal.key.identifier &&
+                    keySearch.subtype === keyVal.key.subtype &&
+                    (!Buffer.isBuffer(keySearch.keydata) || keySearch.keydata.equals(keyVal.key.keydata))));
+        });
+    }
+    clone() {
+        return super.clone();
+    }
+}
+exports.UtxoPsbt = UtxoPsbt;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UtxoPsbt.js","sourceRoot":"","sources":["../../../src/bitgo/UtxoPsbt.ts"],"names":[],"mappings":"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","sourcesContent":["import { Psbt as PsbtBase } from 'bip174';\nimport { TapBip32Derivation, Transaction as ITransaction, TransactionFromBuffer } from 'bip174/src/lib/interfaces';\nimport { checkForInput } from 'bip174/src/lib/utils';\nimport { BufferWriter, varuint } from 'bitcoinjs-lib/src/bufferutils';\n\nimport {\n  taproot,\n  HDSigner,\n  Psbt,\n  PsbtTransaction,\n  Transaction,\n  TxOutput,\n  Network,\n  ecc as eccLib,\n  p2trPayments,\n} from '..';\nimport { UtxoTransaction } from './UtxoTransaction';\nimport { getOutputIdForInput } from './Unspent';\nimport { isSegwit } from './psbt/scriptTypes';\nimport { unsign } from './psbt/fromHalfSigned';\nimport { toXOnlyPublicKey } from './outputScripts';\nimport { parsePubScript } from './parseInput';\nimport { BIP32Factory } from 'bip32';\nimport * as bs58check from 'bs58check';\nimport { decodeProprietaryKey, encodeProprietaryKey, ProprietaryKey } from 'bip174/src/lib/proprietaryKeyVal';\n\nexport const PSBT_PROPRIETARY_IDENTIFIER = 'BITGO';\n\nexport enum ProprietaryKeySubtype {\n  ZEC_CONSENSUS_BRANCH_ID = 0x00,\n  MUSIG2_PARTICIPANT_PUB_KEYS = 0x01,\n  MUSIG2_PUB_NONCE = 0x02,\n}\n\nexport interface HDTaprootSigner extends HDSigner {\n  /**\n   * The path string must match /^m(\\/\\d+'?)+$/\n   * ex. m/44'/0'/0'/1/23 levels with ' must be hard derivations\n   */\n  derivePath(path: string): HDTaprootSigner;\n  /**\n   * Input hash (the \"message digest\") for the signature algorithm\n   * Return a 64 byte signature (32 byte r and 32 byte s in that order)\n   */\n  signSchnorr(hash: Buffer): Buffer;\n}\n\nexport interface SchnorrSigner {\n  publicKey: Buffer;\n  signSchnorr(hash: Buffer): Buffer;\n}\n\nexport interface TaprootSigner {\n  leafHashes: Buffer[];\n  signer: SchnorrSigner;\n}\n\nexport interface PsbtOpts {\n  network: Network;\n  maximumFeeRate?: number; // [sat/byte]\n  bip32PathsAbsolute?: boolean;\n}\n\n/**\n * Psbt proprietary keydata object.\n * <compact size uint identifier length> <bytes identifier> <compact size uint subtype> <bytes subkeydata>\n * => <bytes valuedata>\n */\nexport interface ProprietaryKeyValueData {\n  key: ProprietaryKey;\n  value: Buffer;\n}\n\n/**\n * Psbt proprietary keydata object search fields.\n * <compact size uint identifier length> <bytes identifier> <compact size uint subtype> <bytes subkeydata>\n */\nexport interface ProprietaryKeySearch {\n  identifier: string;\n  subtype: number;\n  keydata?: Buffer;\n  identifierEncoding?: BufferEncoding;\n}\n\n// TODO: upstream does `checkInputsForPartialSigs` before doing things like\n// `setVersion`. Our inputs could have tapscriptsigs (or in future tapkeysigs)\n// and not fail that check. Do we want to do anything about that?\nexport class UtxoPsbt<Tx extends UtxoTransaction<bigint> = UtxoTransaction<bigint>> extends Psbt {\n  protected static transactionFromBuffer(buffer: Buffer, network: Network): UtxoTransaction<bigint> {\n    return UtxoTransaction.fromBuffer<bigint>(buffer, false, 'bigint', network);\n  }\n\n  static createPsbt(opts: PsbtOpts, data?: PsbtBase): UtxoPsbt {\n    return new UtxoPsbt(\n      opts,\n      data || new PsbtBase(new PsbtTransaction({ tx: new UtxoTransaction<bigint>(opts.network) }))\n    );\n  }\n\n  static fromBuffer(buffer: Buffer, opts: PsbtOpts): UtxoPsbt {\n    const transactionFromBuffer: TransactionFromBuffer = (buffer: Buffer): ITransaction => {\n      const tx = this.transactionFromBuffer(buffer, opts.network);\n      return new PsbtTransaction({ tx });\n    };\n    const psbtBase = PsbtBase.fromBuffer(buffer, transactionFromBuffer, {\n      bip32PathsAbsolute: opts.bip32PathsAbsolute,\n    });\n    const psbt = this.createPsbt(opts, psbtBase);\n    // Upstream checks for duplicate inputs here, but it seems to be of dubious value.\n    return psbt;\n  }\n\n  static fromHex(data: string, opts: PsbtOpts): UtxoPsbt {\n    return this.fromBuffer(Buffer.from(data, 'hex'), opts);\n  }\n\n  get network(): Network {\n    return this.tx.network;\n  }\n\n  toHex(): string {\n    return this.toBuffer().toString('hex');\n  }\n\n  /**\n   * @return true iff PSBT input is finalized\n   */\n  isInputFinalized(inputIndex: number): boolean {\n    const input = checkForInput(this.data.inputs, inputIndex);\n    return Buffer.isBuffer(input.finalScriptSig) || Buffer.isBuffer(input.finalScriptWitness);\n  }\n\n  /**\n   * @return partialSig/tapScriptSig count iff input is not finalized\n   */\n  getSignatureCount(inputIndex: number): number {\n    if (this.isInputFinalized(inputIndex)) {\n      throw new Error('Input is already finalized');\n    }\n    const input = checkForInput(this.data.inputs, inputIndex);\n    return Math.max(\n      Array.isArray(input.partialSig) ? input.partialSig.length : 0,\n      Array.isArray(input.tapScriptSig) ? input.tapScriptSig.length : 0\n    );\n  }\n\n  getNonWitnessPreviousTxids(): string[] {\n    const txInputs = this.txInputs; // These are somewhat costly to extract\n    const txidSet = new Set<string>();\n    this.data.inputs.forEach((input, index) => {\n      if (!input.witnessUtxo) {\n        throw new Error('Must have witness UTXO for all inputs');\n      }\n      if (!isSegwit(input.witnessUtxo.script, input.redeemScript)) {\n        txidSet.add(getOutputIdForInput(txInputs[index]).txid);\n      }\n    });\n    return [...txidSet];\n  }\n\n  addNonWitnessUtxos(txBufs: Record<string, Buffer>): this {\n    const txInputs = this.txInputs; // These are somewhat costly to extract\n    this.data.inputs.forEach((input, index) => {\n      if (!input.witnessUtxo) {\n        throw new Error('Must have witness UTXO for all inputs');\n      }\n      if (!isSegwit(input.witnessUtxo.script, input.redeemScript)) {\n        const { txid } = getOutputIdForInput(txInputs[index]);\n        if (txBufs[txid] === undefined) {\n          throw new Error('Not all required previous transactions provided');\n        }\n        this.updateInput(index, { nonWitnessUtxo: txBufs[txid] });\n      }\n    });\n    return this;\n  }\n\n  static fromTransaction(transaction: UtxoTransaction<bigint>, prevOutputs: TxOutput<bigint>[]): UtxoPsbt {\n    if (prevOutputs.length !== transaction.ins.length) {\n      throw new Error(\n        `Transaction has ${transaction.ins.length} inputs, but ${prevOutputs.length} previous outputs provided`\n      );\n    }\n    const clonedTransaction = transaction.clone();\n    const updates = unsign(clonedTransaction, prevOutputs);\n\n    const psbtBase = new PsbtBase(new PsbtTransaction({ tx: clonedTransaction }));\n    clonedTransaction.ins.forEach(() => psbtBase.inputs.push({ unknownKeyVals: [] }));\n    clonedTransaction.outs.forEach(() => psbtBase.outputs.push({ unknownKeyVals: [] }));\n    const psbt = this.createPsbt({ network: transaction.network }, psbtBase);\n\n    updates.forEach((update, index) => {\n      psbt.updateInput(index, update);\n      psbt.updateInput(index, { witnessUtxo: { script: prevOutputs[index].script, value: prevOutputs[index].value } });\n    });\n\n    return psbt;\n  }\n\n  getUnsignedTx(): UtxoTransaction<bigint> {\n    return this.tx.clone();\n  }\n\n  protected static newTransaction(network: Network): UtxoTransaction<bigint> {\n    return new UtxoTransaction<bigint>(network);\n  }\n\n  protected get tx(): Tx {\n    return (this.data.globalMap.unsignedTx as PsbtTransaction).tx as Tx;\n  }\n\n  protected checkForSignatures(propName?: string): void {\n    this.data.inputs.forEach((input) => {\n      if (input.tapScriptSig?.length || input.tapKeySig || input.partialSig?.length) {\n        throw new Error(`Cannot modify ${propName ?? 'transaction'} - signatures exist.`);\n      }\n    });\n  }\n\n  /**\n   * Mostly copied from bitcoinjs-lib/ts_src/psbt.ts\n   */\n  finalizeAllInputs(): this {\n    checkForInput(this.data.inputs, 0); // making sure we have at least one\n    this.data.inputs.map((input, idx) => {\n      return input.tapScriptSig?.length ? this.finalizeTaprootInput(idx) : this.finalizeInput(idx);\n    });\n    return this;\n  }\n\n  finalizeTaprootInput(inputIndex: number): this {\n    const input = checkForInput(this.data.inputs, inputIndex);\n    // witness = control-block script first-sig second-sig\n    if (input.tapLeafScript?.length !== 1) {\n      throw new Error('Only one leaf script supported for finalizing');\n    }\n    const { controlBlock, script } = input.tapLeafScript[0];\n    const witness: Buffer[] = [script, controlBlock];\n    const [pubkey1, pubkey2] = parsePubScript(script, 'p2tr').publicKeys;\n    for (const pk of [pubkey1, pubkey2]) {\n      const sig = input.tapScriptSig?.find(({ pubkey }) => pubkey.equals(pk));\n      if (!sig) {\n        throw new Error('Could not find signatures in Script Sig.');\n      }\n      witness.unshift(sig.signature);\n    }\n\n    const witnessLength = witness.reduce((s, b) => s + b.length + varuint.encodingLength(b.length), 1);\n\n    const bufferWriter = BufferWriter.withCapacity(witnessLength);\n    bufferWriter.writeVector(witness);\n    const finalScriptWitness = bufferWriter.end();\n\n    this.data.updateInput(inputIndex, { finalScriptWitness });\n    this.data.clearFinalizedInput(inputIndex);\n\n    return this;\n  }\n\n  finalizeTapInputWithSingleLeafScriptAndSignature(inputIndex: number): this {\n    const input = checkForInput(this.data.inputs, inputIndex);\n    if (input.tapLeafScript?.length !== 1) {\n      throw new Error('Only one leaf script supported for finalizing');\n    }\n    if (input.tapScriptSig?.length !== 1) {\n      throw new Error('Could not find signatures in Script Sig.');\n    }\n\n    const { controlBlock, script } = input.tapLeafScript[0];\n    const witness: Buffer[] = [input.tapScriptSig[0].signature, script, controlBlock];\n    const witnessLength = witness.reduce((s, b) => s + b.length + varuint.encodingLength(b.length), 1);\n\n    const bufferWriter = BufferWriter.withCapacity(witnessLength);\n    bufferWriter.writeVector(witness);\n    const finalScriptWitness = bufferWriter.end();\n\n    this.data.updateInput(inputIndex, { finalScriptWitness });\n    this.data.clearFinalizedInput(inputIndex);\n\n    return this;\n  }\n\n  /**\n   * Mostly copied from bitcoinjs-lib/ts_src/psbt.ts\n   *\n   * Unlike the function it overrides, this does not take a validator. In BitGo\n   * context, we know how we want to validate so we just hard code the right\n   * validator.\n   */\n  validateSignaturesOfAllInputs(): boolean {\n    checkForInput(this.data.inputs, 0); // making sure we have at least one\n    const results = this.data.inputs.map((input, idx) => {\n      return input.tapScriptSig?.length\n        ? this.validateTaprootSignaturesOfInput(idx)\n        : this.validateSignaturesOfInput(idx, (p, m, s) => eccLib.verify(m, p, s));\n    });\n    return results.reduce((final, res) => res && final, true);\n  }\n\n  validateTaprootSignaturesOfInput(inputIndex: number, pubkey?: Buffer): boolean {\n    const input = this.data.inputs[inputIndex];\n    const tapSigs = (input || {}).tapScriptSig;\n    if (!input || !tapSigs || tapSigs.length < 1) {\n      throw new Error('No signatures to validate');\n    }\n    let mySigs;\n    if (pubkey) {\n      const xOnlyPubkey = toXOnlyPublicKey(pubkey);\n      mySigs = tapSigs.filter((sig) => sig.pubkey.equals(xOnlyPubkey));\n      if (mySigs.length < 1) {\n        throw new Error('No signatures for this pubkey');\n      }\n    } else {\n      mySigs = tapSigs;\n    }\n    const results: boolean[] = [];\n\n    for (const pSig of mySigs) {\n      const { signature, leafHash, pubkey } = pSig;\n      let sigHashType: number;\n      let sig: Buffer;\n      if (signature.length === 65) {\n        sigHashType = signature[64];\n        sig = signature.slice(0, 64);\n      } else {\n        sigHashType = Transaction.SIGHASH_DEFAULT;\n        sig = signature;\n      }\n      const { hash } = this.getTaprootHashForSig(inputIndex, [sigHashType], leafHash);\n      results.push(eccLib.verifySchnorr(hash, pubkey, sig));\n    }\n    return results.every((res) => res === true);\n  }\n\n  /**\n   * @return array of boolean values. True when corresponding index in `publicKeys` has signed the transaction.\n   * If no signature in the tx or no public key matching signature, the validation is considered as false.\n   */\n  getSignatureValidationArray(inputIndex: number): boolean[] {\n    const noSigErrorMessages = ['No signatures to validate', 'No signatures for this pubkey'];\n    const input = checkForInput(this.data.inputs, inputIndex);\n    const isP2tr = input.tapScriptSig?.length;\n    if (!this.data.globalMap.globalXpub) {\n      throw new Error('Cannot get signature validation array without global xpubs');\n    }\n    if (this.data.globalMap.globalXpub.length !== 3) {\n      throw new Error(`There must be 3 global xpubs and there are ${this.data.globalMap.globalXpub.length}`);\n    }\n    return this.data.globalMap.globalXpub.map((xpub) => {\n      // const bip32 = ECPair.fromPublicKey(xpub.extendedPubkey, { network: (this as any).opts.network });\n      const bip32 = BIP32Factory(eccLib).fromBase58(bs58check.encode(xpub.extendedPubkey));\n      try {\n        return isP2tr\n          ? this.validateTaprootSignaturesOfInput(inputIndex, bip32.publicKey)\n          : this.validateSignaturesOfInput(inputIndex, (p, m, s) => eccLib.verify(m, p, s), bip32.publicKey);\n      } catch (err) {\n        // Not an elegant solution. Might need upstream changes like custom error types.\n        if (noSigErrorMessages.includes(err.message)) {\n          return false;\n        }\n        throw err;\n      }\n    });\n  }\n\n  /**\n   * Mostly copied from bitcoinjs-lib/ts_src/psbt.ts\n   */\n  signAllInputsHD(\n    hdKeyPair: HDTaprootSigner,\n    sighashTypes: number[] = [Transaction.SIGHASH_DEFAULT, Transaction.SIGHASH_ALL]\n  ): this {\n    if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {\n      throw new Error('Need HDSigner to sign input');\n    }\n\n    const results: boolean[] = [];\n    for (let i = 0; i < this.data.inputs.length; i++) {\n      try {\n        if (this.data.inputs[i].tapBip32Derivation?.length) {\n          this.signTaprootInputHD(i, hdKeyPair, sighashTypes);\n        } else {\n          this.signInputHD(i, hdKeyPair, sighashTypes);\n        }\n        results.push(true);\n      } catch (err) {\n        results.push(false);\n      }\n    }\n    if (results.every((v) => v === false)) {\n      throw new Error('No inputs were signed');\n    }\n    return this;\n  }\n\n  /**\n   * Mostly copied from bitcoinjs-lib/ts_src/psbt.ts:signInputHD\n   */\n  signTaprootInputHD(\n    inputIndex: number,\n    hdKeyPair: HDTaprootSigner,\n    sighashTypes: number[] = [Transaction.SIGHASH_DEFAULT, Transaction.SIGHASH_ALL]\n  ): this {\n    if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {\n      throw new Error('Need HDSigner to sign input');\n    }\n    const input = checkForInput(this.data.inputs, inputIndex);\n    if (!input.tapBip32Derivation || input.tapBip32Derivation.length === 0) {\n      throw new Error('Need tapBip32Derivation to sign Taproot with HD');\n    }\n    const myDerivations = input.tapBip32Derivation\n      .map((bipDv) => {\n        if (bipDv.masterFingerprint.equals(hdKeyPair.fingerprint)) {\n          return bipDv;\n        }\n      })\n      .filter((v) => !!v) as TapBip32Derivation[];\n    if (myDerivations.length === 0) {\n      throw new Error('Need one tapBip32Derivation masterFingerprint to match the HDSigner fingerprint');\n    }\n    const signers: TaprootSigner[] = myDerivations.map((bipDv) => {\n      const node = hdKeyPair.derivePath(bipDv.path);\n      if (!bipDv.pubkey.equals(node.publicKey.slice(1))) {\n        throw new Error('pubkey did not match tapBip32Derivation');\n      }\n      return { signer: node, leafHashes: bipDv.leafHashes };\n    });\n    signers.forEach(({ signer, leafHashes }) => this.signTaprootInput(inputIndex, signer, leafHashes, sighashTypes));\n    return this;\n  }\n\n  signTaprootInput(\n    inputIndex: number,\n    signer: SchnorrSigner,\n    leafHashes: Buffer[],\n    sighashTypes: number[] = [Transaction.SIGHASH_DEFAULT, Transaction.SIGHASH_ALL]\n  ): this {\n    const pubkey = toXOnlyPublicKey(signer.publicKey);\n    const input = checkForInput(this.data.inputs, inputIndex);\n    // Figure out if this is script path or not, if not, tweak the private key\n    if (!input.tapLeafScript?.length) {\n      // See BitGo/BitGoJS/modules/utxo_lib/src/transaction_builder.ts:trySign for how to support it.\n      throw new Error('Taproot key path signing is not supported.');\n    }\n    if (input.tapLeafScript.length !== 1) {\n      throw new Error('Only one leaf script supported for signing');\n    }\n    const tapLeafScript = input.tapLeafScript[0];\n    const parsedControlBlock = taproot.parseControlBlock(eccLib, tapLeafScript.controlBlock);\n    const { leafVersion } = parsedControlBlock;\n    if (leafVersion !== tapLeafScript.leafVersion) {\n      throw new Error('Tap script leaf version mismatch with control block');\n    }\n    const leafHash = taproot.getTapleafHash(eccLib, parsedControlBlock, tapLeafScript.script);\n    if (!leafHashes.find((l) => l.equals(leafHash))) {\n      throw new Error(`Signer cannot sign for leaf hash ${leafHash.toString('hex')}`);\n    }\n    const { hash, sighashType } = this.getTaprootHashForSig(inputIndex, sighashTypes, leafHash);\n    let signature = signer.signSchnorr(hash);\n    if (sighashType !== Transaction.SIGHASH_DEFAULT) {\n      signature = Buffer.concat([signature, Buffer.of(sighashType)]);\n    }\n    this.data.updateInput(inputIndex, {\n      tapScriptSig: [\n        {\n          pubkey,\n          signature,\n          leafHash,\n        },\n      ],\n    });\n    return this;\n  }\n\n  private getTaprootHashForSig(\n    inputIndex: number,\n    sighashTypes?: number[],\n    leafHash?: Buffer\n  ): {\n    hash: Buffer;\n    sighashType: number;\n  } {\n    const sighashType = this.data.inputs[inputIndex].sighashType || Transaction.SIGHASH_DEFAULT;\n    if (sighashTypes && sighashTypes.indexOf(sighashType) < 0) {\n      throw new Error(\n        `Sighash type is not allowed. Retry the sign method passing the ` +\n          `sighashTypes array of whitelisted types. Sighash type: ${sighashType}`\n      );\n    }\n    const txInputs = this.txInputs; // These are somewhat costly to extract\n    const prevoutScripts: Buffer[] = [];\n    const prevoutValues: bigint[] = [];\n\n    this.data.inputs.forEach((input, i) => {\n      let prevout;\n      if (input.nonWitnessUtxo) {\n        // TODO: This could be costly, either cache it here, or find a way to share with super\n        const nonWitnessUtxoTx = (this.constructor as typeof UtxoPsbt).transactionFromBuffer(\n          input.nonWitnessUtxo,\n          this.tx.network\n        );\n\n        const prevoutHash = txInputs[i].hash;\n        const utxoHash = nonWitnessUtxoTx.getHash();\n\n        // If a non-witness UTXO is provided, its hash must match the hash specified in the prevout\n        if (!prevoutHash.equals(utxoHash)) {\n          throw new Error(`Non-witness UTXO hash for input #${i} doesn't match the hash specified in the prevout`);\n        }\n\n        const prevoutIndex = txInputs[i].index;\n        prevout = nonWitnessUtxoTx.outs[prevoutIndex];\n      } else if (input.witnessUtxo) {\n        prevout = input.witnessUtxo;\n      } else {\n        throw new Error('Need a Utxo input item for signing');\n      }\n      prevoutScripts.push(prevout.script);\n      prevoutValues.push(prevout.value);\n    });\n    const hash = this.tx.hashForWitnessV1(inputIndex, prevoutScripts, prevoutValues, sighashType, leafHash);\n    return { hash, sighashType };\n  }\n\n  /**\n   * @retuns true iff the input is taproot.\n   */\n  isTaprootInput(inputIndex: number): boolean {\n    const input = checkForInput(this.data.inputs, inputIndex);\n    function isP2tr(output: Buffer): boolean {\n      try {\n        p2trPayments.p2tr({ output }, { eccLib });\n        return true;\n      } catch (err) {\n        return false;\n      }\n    }\n    return !!(\n      input.tapInternalKey ||\n      input.tapMerkleRoot ||\n      (input.tapLeafScript && input.tapLeafScript.length) ||\n      (input.tapBip32Derivation && input.tapBip32Derivation.length) ||\n      (input.witnessUtxo && isP2tr(input.witnessUtxo.script))\n    );\n  }\n\n  /**\n   * @returns hash and hashType for taproot input at inputIndex\n   * @throws error if input at inputIndex is not a taproot input\n   */\n  getTaprootHashForSigChecked(\n    inputIndex: number,\n    sighashTypes: number[] = [Transaction.SIGHASH_DEFAULT, Transaction.SIGHASH_ALL],\n    leafHash?: Buffer\n  ): {\n    hash: Buffer;\n    sighashType: number;\n  } {\n    if (!this.isTaprootInput(inputIndex)) {\n      throw new Error(`${inputIndex} input is not a taproot type to take taproot tx hash`);\n    }\n    return this.getTaprootHashForSig(inputIndex, sighashTypes, leafHash);\n  }\n\n  /**\n   * Adds proprietary key value pair to PSBT input.\n   * Default identifierEncoding is utf-8 for identifier.\n   */\n  addProprietaryKeyValToInput(inputIndex: number, keyValueData: ProprietaryKeyValueData): this {\n    return this.addUnknownKeyValToInput(inputIndex, {\n      key: encodeProprietaryKey(keyValueData.key),\n      value: keyValueData.value,\n    });\n  }\n\n  /**\n   * To search any data from proprietary key value againts keydata.\n   * Default identifierEncoding is utf-8 for identifier.\n   */\n  getProprietaryKeyVals(inputIndex: number, keySearch?: ProprietaryKeySearch): ProprietaryKeyValueData[] {\n    const input = checkForInput(this.data.inputs, inputIndex);\n    if (!input.unknownKeyVals || input.unknownKeyVals.length === 0) {\n      return [];\n    }\n    const keyVals = input.unknownKeyVals.map(({ key, value }, i) => {\n      return { key: decodeProprietaryKey(key), value };\n    });\n    return keyVals.filter((keyVal) => {\n      return (\n        keySearch === undefined ||\n        (keySearch.identifier === keyVal.key.identifier &&\n          keySearch.subtype === keyVal.key.subtype &&\n          (!Buffer.isBuffer(keySearch.keydata) || keySearch.keydata.equals(keyVal.key.keydata)))\n      );\n    });\n  }\n\n  clone(): this {\n    return super.clone() as this;\n  }\n}\n"]}

package/dist/src/bitgo/UtxoTransaction.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import * as bitcoinjs from 'bitcoinjs-lib';
+import { Network } from '../networks';
+export declare function varSliceSize(slice: Buffer): number;
+export declare class UtxoTransaction<TNumber extends number | bigint = number> extends bitcoinjs.Transaction<TNumber> {
+    network: Network;
+    static SIGHASH_FORKID: number;
+    /** @deprecated use SIGHASH_FORKID */
+    static SIGHASH_BITCOINCASHBIP143: number;
+    constructor(network: Network, transaction?: bitcoinjs.Transaction<bigint | number>, amountType?: 'bigint' | 'number');
+    protected static newTransaction<TNumber extends number | bigint = number>(network: Network, transaction?: bitcoinjs.Transaction<bigint | number>, amountType?: 'number' | 'bigint'): UtxoTransaction<TNumber>;
+    static fromBuffer<TNumber extends number | bigint = number>(buf: Buffer, noStrict: boolean, amountType?: 'number' | 'bigint', network?: Network, prevOutput?: bitcoinjs.TxOutput<TNumber>[]): UtxoTransaction<TNumber>;
+    addForkId(hashType: number): number;
+    hashForWitnessV0(inIndex: number, prevOutScript: Buffer, value: TNumber, hashType: number): Buffer;
+    /**
+     * Calculate the hash to verify the signature against
+     */
+    hashForSignatureByNetwork(inIndex: number, prevoutScript: Buffer, value: TNumber | undefined, hashType: number): Buffer;
+    hashForSignature(inIndex: number, prevOutScript: Buffer, hashType: number, value?: TNumber): Buffer;
+    clone<TN2 extends bigint | number = TNumber>(amountType?: 'number' | 'bigint'): UtxoTransaction<TN2>;
+}
+//# sourceMappingURL=UtxoTransaction.d.ts.map

package/dist/src/bitgo/UtxoTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UtxoTransaction.d.ts","sourceRoot":"","sources":["../../../src/bitgo/UtxoTransaction.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,SAAS,MAAM,eAAe,CAAC;AAI3C,OAAO,EAAY,OAAO,EAA6B,MAAM,aAAa,CAAC;AAE3E,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGlD;AAED,qBAAa,eAAe,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,CAAE,SAAQ,SAAS,CAAC,WAAW,CAAC,OAAO,CAAC;IAMlG,OAAO,EAAE,OAAO;IALzB,MAAM,CAAC,cAAc,SAAQ;IAC7B,qCAAqC;IACrC,MAAM,CAAC,yBAAyB,SAAkC;gBAGzD,OAAO,EAAE,OAAO,EACvB,WAAW,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,MAAM,GAAG,MAAM,CAAC,EACpD,UAAU,CAAC,EAAE,QAAQ,GAAG,QAAQ;IAiBlC,SAAS,CAAC,MAAM,CAAC,cAAc,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EACtE,OAAO,EAAE,OAAO,EAChB,WAAW,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,MAAM,GAAG,MAAM,CAAC,EACpD,UAAU,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAC/B,eAAe,CAAC,OAAO,CAAC;IAI3B,MAAM,CAAC,UAAU,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EACxD,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,EACjB,UAAU,GAAE,QAAQ,GAAG,QAAmB,EAC1C,OAAO,CAAC,EAAE,OAAO,EACjB,UAAU,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,GACzC,eAAe,CAAC,OAAO,CAAC;IAW3B,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IASnC,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAIlG;;OAEG;IACH,yBAAyB,CACvB,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,OAAO,GAAG,SAAS,EAC1B,QAAQ,EAAE,MAAM,GACf,MAAM;IAkCT,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM;IAKnG,KAAK,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,UAAU,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,eAAe,CAAC,GAAG,CAAC;CAIrG"}