utxo-lib 1.0.1

package/dist/src/bitgo/zcash/ZcashPsbt.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZcashPsbt = void 0;
+const UtxoPsbt_1 = require("../UtxoPsbt");
+const ZcashTransaction_1 = require("./ZcashTransaction");
+const __1 = require("../../");
+const bip174_1 = require("bip174");
+const types = require("bitcoinjs-lib/src/types");
+const typeforce = require('typeforce');
+const CONSENSUS_BRANCH_ID_KEY = Buffer.concat([
+    Buffer.of(0xfc),
+    Buffer.of(0x05),
+    Buffer.from(UtxoPsbt_1.PSBT_PROPRIETARY_IDENTIFIER),
+    Buffer.of(UtxoPsbt_1.ProprietaryKeySubtype.ZEC_CONSENSUS_BRANCH_ID),
+]);
+class ZcashPsbt extends UtxoPsbt_1.UtxoPsbt {
+    static transactionFromBuffer(buffer, network) {
+        return ZcashTransaction_1.ZcashTransaction.fromBuffer(buffer, false, 'bigint', network);
+    }
+    static createPsbt(opts, data) {
+        return new ZcashPsbt(opts, data || new bip174_1.Psbt(new __1.PsbtTransaction({ tx: new ZcashTransaction_1.ZcashTransaction(opts.network) })));
+    }
+    /**
+     * In version < 5 of Zcash transactions, the consensus branch ID is not serialized in the transaction
+     * whereas in version 5 it is. If the transaction is less than a version 5, set the consensus branch id
+     * in the global map in the psbt. If it is a version 5 transaction, throw an error if the consensus
+     * branch id is set in the psbt (because it should be on the transaction already).
+     * @param buffer Psbt buffer
+     * @param opts options
+     */
+    static fromBuffer(buffer, opts) {
+        var _a;
+        const psbt = super.fromBuffer(buffer, opts);
+        // Read `consensusBranchId` from the global-map
+        let consensusBranchId = undefined;
+        (_a = psbt.data.globalMap.unknownKeyVals) === null || _a === void 0 ? void 0 : _a.forEach(({ key, value }, i) => {
+            if (key.equals(CONSENSUS_BRANCH_ID_KEY)) {
+                consensusBranchId = value.readUint32LE();
+            }
+        });
+        switch (psbt.tx.version) {
+            case 4:
+            case ZcashTransaction_1.ZcashTransaction.VERSION4_BRANCH_CANOPY:
+            case ZcashTransaction_1.ZcashTransaction.VERSION4_BRANCH_NU5:
+                if (!consensusBranchId || !psbt.data.globalMap.unknownKeyVals) {
+                    throw new Error('Could not find consensus branch id on psbt for version 4 Zcash transaction');
+                }
+                psbt.tx.consensusBranchId = consensusBranchId;
+                psbt.data.globalMap.unknownKeyVals = psbt.data.globalMap.unknownKeyVals.filter(({ key }) => key !== CONSENSUS_BRANCH_ID_KEY);
+                // Delete consensusBranchId from globalMap so that if we were to serialize the psbt again
+                // we would not add a duplicate key into the global map
+                psbt.data.globalMap.unknownKeyVals.pop();
+                return psbt;
+            case 5:
+            case ZcashTransaction_1.ZcashTransaction.VERSION5_BRANCH_NU5:
+                if (consensusBranchId) {
+                    throw new Error('Found consensus branch id in psbt global-map for version 5 Zcash transaction');
+                }
+                return psbt;
+            default:
+                throw new Error(`Unsupported transaction version ${psbt.tx.version}`);
+        }
+    }
+    /**
+     * If it is a version 4 transaction, add the consensus branch id to
+     * the global map. If it is a version 5 transaction, just return the
+     * buffer because the consensus branch id is already serialized in
+     * the transaction.
+     */
+    toBuffer() {
+        if (this.tx.version === 5 || this.tx.version === ZcashTransaction_1.ZcashTransaction.VERSION5_BRANCH_NU5) {
+            return super.toBuffer();
+        }
+        const value = Buffer.alloc(4);
+        value.writeUint32LE(this.tx.consensusBranchId);
+        this.addUnknownKeyValToGlobal({ key: CONSENSUS_BRANCH_ID_KEY, value });
+        if (!this.data.globalMap.unknownKeyVals) {
+            throw new Error('Failed adding consensus branch id to unknownKeyVals');
+        }
+        const buff = super.toBuffer();
+        this.data.globalMap.unknownKeyVals.pop();
+        return buff;
+    }
+    setVersion(version, overwinter = true) {
+        typeforce(types.UInt32, version);
+        this.tx.overwintered = overwinter ? 1 : 0;
+        this.tx.version = version;
+        return this;
+    }
+    setDefaultsForVersion(network, version) {
+        switch (version) {
+            case 4:
+            case ZcashTransaction_1.ZcashTransaction.VERSION4_BRANCH_CANOPY:
+            case ZcashTransaction_1.ZcashTransaction.VERSION4_BRANCH_NU5:
+                this.setVersion(4);
+                break;
+            case 5:
+            case ZcashTransaction_1.ZcashTransaction.VERSION5_BRANCH_NU5:
+                this.setVersion(5);
+                break;
+            default:
+                throw new Error(`invalid version ${version}`);
+        }
+        this.tx.versionGroupId = ZcashTransaction_1.getDefaultVersionGroupIdForVersion(version);
+        this.tx.consensusBranchId = ZcashTransaction_1.getDefaultConsensusBranchIdForVersion(network, version);
+    }
+    // For Zcash transactions, we do not have to have non-witness UTXO data for non-segwit
+    // transactions because zcash hashes the value directly. Thus, it is unnecessary to have
+    // the previous transaction hash on the unspent.
+    signInput(inputIndex, keyPair, sighashTypes) {
+        return this.withUnsafeSignNonSegwitTrue(super.signInput.bind(this, inputIndex, keyPair, sighashTypes));
+    }
+    validateSignaturesOfInput(inputIndex, validator, pubkey) {
+        return this.withUnsafeSignNonSegwitTrue(super.validateSignaturesOfInput.bind(this, inputIndex, validator, pubkey));
+    }
+    withUnsafeSignNonSegwitTrue(fn) {
+        this.__CACHE.__UNSAFE_SIGN_NONSEGWIT = true;
+        try {
+            return fn();
+        }
+        finally {
+            this.__CACHE.__UNSAFE_SIGN_NONSEGWIT = false;
+        }
+    }
+    setPropertyCheckSignatures(propName, value) {
+        if (this.tx[propName] === value) {
+            return;
+        }
+        this.checkForSignatures(propName);
+        this.tx[propName] = value;
+    }
+    setConsensusBranchId(consensusBranchId) {
+        typeforce(types.UInt32, consensusBranchId);
+        this.setPropertyCheckSignatures('consensusBranchId', consensusBranchId);
+    }
+    setVersionGroupId(versionGroupId) {
+        typeforce(types.UInt32, versionGroupId);
+        this.setPropertyCheckSignatures('versionGroupId', versionGroupId);
+    }
+    setExpiryHeight(expiryHeight) {
+        typeforce(types.UInt32, expiryHeight);
+        this.setPropertyCheckSignatures('expiryHeight', expiryHeight);
+    }
+}
+exports.ZcashPsbt = ZcashPsbt;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ZcashPsbt.js","sourceRoot":"","sources":["../../../../src/bitgo/zcash/ZcashPsbt.ts"],"names":[],"mappings":"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","sourcesContent":["import { PSBT_PROPRIETARY_IDENTIFIER, PsbtOpts, ProprietaryKeySubtype, UtxoPsbt } from '../UtxoPsbt';\nimport {\n  getDefaultConsensusBranchIdForVersion,\n  getDefaultVersionGroupIdForVersion,\n  ZcashTransaction,\n} from './ZcashTransaction';\nimport { Network, PsbtTransaction, Signer } from '../../';\nimport { Psbt as PsbtBase } from 'bip174';\nimport * as types from 'bitcoinjs-lib/src/types';\nimport { ValidateSigFunction } from 'bitcoinjs-lib/src/psbt';\nconst typeforce = require('typeforce');\n\nconst CONSENSUS_BRANCH_ID_KEY = Buffer.concat([\n  Buffer.of(0xfc),\n  Buffer.of(0x05),\n  Buffer.from(PSBT_PROPRIETARY_IDENTIFIER),\n  Buffer.of(ProprietaryKeySubtype.ZEC_CONSENSUS_BRANCH_ID),\n]);\n\nexport class ZcashPsbt extends UtxoPsbt<ZcashTransaction<bigint>> {\n  protected static transactionFromBuffer(buffer: Buffer, network: Network): ZcashTransaction<bigint> {\n    return ZcashTransaction.fromBuffer<bigint>(buffer, false, 'bigint', network);\n  }\n\n  static createPsbt(opts: PsbtOpts, data?: PsbtBase): ZcashPsbt {\n    return new ZcashPsbt(\n      opts,\n      data || new PsbtBase(new PsbtTransaction({ tx: new ZcashTransaction<bigint>(opts.network) }))\n    );\n  }\n\n  /**\n   * In version < 5 of Zcash transactions, the consensus branch ID is not serialized in the transaction\n   * whereas in version 5 it is. If the transaction is less than a version 5, set the consensus branch id\n   * in the global map in the psbt. If it is a version 5 transaction, throw an error if the consensus\n   * branch id is set in the psbt (because it should be on the transaction already).\n   * @param buffer Psbt buffer\n   * @param opts options\n   */\n  static fromBuffer(buffer: Buffer, opts: PsbtOpts): UtxoPsbt<ZcashTransaction<bigint>> {\n    const psbt = super.fromBuffer(buffer, opts) as ZcashPsbt;\n\n    // Read `consensusBranchId` from the global-map\n    let consensusBranchId: number | undefined = undefined;\n    psbt.data.globalMap.unknownKeyVals?.forEach(({ key, value }, i) => {\n      if (key.equals(CONSENSUS_BRANCH_ID_KEY)) {\n        consensusBranchId = value.readUint32LE();\n      }\n    });\n    switch (psbt.tx.version) {\n      case 4:\n      case ZcashTransaction.VERSION4_BRANCH_CANOPY:\n      case ZcashTransaction.VERSION4_BRANCH_NU5:\n        if (!consensusBranchId || !psbt.data.globalMap.unknownKeyVals) {\n          throw new Error('Could not find consensus branch id on psbt for version 4 Zcash transaction');\n        }\n        psbt.tx.consensusBranchId = consensusBranchId;\n        psbt.data.globalMap.unknownKeyVals = psbt.data.globalMap.unknownKeyVals.filter(\n          ({ key }) => key !== CONSENSUS_BRANCH_ID_KEY\n        );\n\n        // Delete consensusBranchId from globalMap so that if we were to serialize the psbt again\n        // we would not add a duplicate key into the global map\n        psbt.data.globalMap.unknownKeyVals.pop();\n        return psbt;\n      case 5:\n      case ZcashTransaction.VERSION5_BRANCH_NU5:\n        if (consensusBranchId) {\n          throw new Error('Found consensus branch id in psbt global-map for version 5 Zcash transaction');\n        }\n        return psbt;\n      default:\n        throw new Error(`Unsupported transaction version ${psbt.tx.version}`);\n    }\n  }\n\n  /**\n   * If it is a version 4 transaction, add the consensus branch id to\n   * the global map. If it is a version 5 transaction, just return the\n   * buffer because the consensus branch id is already serialized in\n   * the transaction.\n   */\n  toBuffer(): Buffer {\n    if (this.tx.version === 5 || this.tx.version === ZcashTransaction.VERSION5_BRANCH_NU5) {\n      return super.toBuffer();\n    }\n    const value = Buffer.alloc(4);\n    value.writeUint32LE(this.tx.consensusBranchId);\n    this.addUnknownKeyValToGlobal({ key: CONSENSUS_BRANCH_ID_KEY, value });\n    if (!this.data.globalMap.unknownKeyVals) {\n      throw new Error('Failed adding consensus branch id to unknownKeyVals');\n    }\n    const buff = super.toBuffer();\n    this.data.globalMap.unknownKeyVals.pop();\n    return buff;\n  }\n\n  setVersion(version: number, overwinter = true): this {\n    typeforce(types.UInt32, version);\n    this.tx.overwintered = overwinter ? 1 : 0;\n    this.tx.version = version;\n    return this;\n  }\n\n  setDefaultsForVersion(network: Network, version: number): void {\n    switch (version) {\n      case 4:\n      case ZcashTransaction.VERSION4_BRANCH_CANOPY:\n      case ZcashTransaction.VERSION4_BRANCH_NU5:\n        this.setVersion(4);\n        break;\n      case 5:\n      case ZcashTransaction.VERSION5_BRANCH_NU5:\n        this.setVersion(5);\n        break;\n      default:\n        throw new Error(`invalid version ${version}`);\n    }\n\n    this.tx.versionGroupId = getDefaultVersionGroupIdForVersion(version);\n    this.tx.consensusBranchId = getDefaultConsensusBranchIdForVersion(network, version);\n  }\n\n  // For Zcash transactions, we do not have to have non-witness UTXO data for non-segwit\n  // transactions because zcash hashes the value directly. Thus, it is unnecessary to have\n  // the previous transaction hash on the unspent.\n  signInput(inputIndex: number, keyPair: Signer, sighashTypes?: number[]): this {\n    return this.withUnsafeSignNonSegwitTrue(super.signInput.bind(this, inputIndex, keyPair, sighashTypes));\n  }\n\n  validateSignaturesOfInput(inputIndex: number, validator: ValidateSigFunction, pubkey?: Buffer): boolean {\n    return this.withUnsafeSignNonSegwitTrue(super.validateSignaturesOfInput.bind(this, inputIndex, validator, pubkey));\n  }\n\n  private withUnsafeSignNonSegwitTrue<T>(fn: () => T): T {\n    (this as any).__CACHE.__UNSAFE_SIGN_NONSEGWIT = true;\n    try {\n      return fn();\n    } finally {\n      (this as any).__CACHE.__UNSAFE_SIGN_NONSEGWIT = false;\n    }\n  }\n\n  private setPropertyCheckSignatures(propName: keyof ZcashTransaction<bigint>, value: unknown) {\n    if (this.tx[propName] === value) {\n      return;\n    }\n    this.checkForSignatures(propName);\n    this.tx[propName] = value as any;\n  }\n\n  setConsensusBranchId(consensusBranchId: number): void {\n    typeforce(types.UInt32, consensusBranchId);\n    this.setPropertyCheckSignatures('consensusBranchId', consensusBranchId);\n  }\n\n  setVersionGroupId(versionGroupId: number): void {\n    typeforce(types.UInt32, versionGroupId);\n    this.setPropertyCheckSignatures('versionGroupId', versionGroupId);\n  }\n\n  setExpiryHeight(expiryHeight: number): void {\n    typeforce(types.UInt32, expiryHeight);\n    this.setPropertyCheckSignatures('expiryHeight', expiryHeight);\n  }\n}\n"]}

package/dist/src/bitgo/zcash/ZcashTransaction.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="node" />
+import { networks } from '../../networks';
+import { UtxoTransaction } from '../UtxoTransaction';
+export declare type ZcashNetwork = typeof networks.zcash | typeof networks.zcashTest;
+export declare class UnsupportedTransactionError extends Error {
+    constructor(message: string);
+}
+export declare function getDefaultVersionGroupIdForVersion(version: number): number;
+export declare function getDefaultConsensusBranchIdForVersion(network: ZcashNetwork, version: number): number;
+export declare class ZcashTransaction<TNumber extends number | bigint = number> extends UtxoTransaction<TNumber> {
+    network: ZcashNetwork;
+    static VERSION_JOINSPLITS_SUPPORT: number;
+    static VERSION_OVERWINTER: number;
+    static VERSION_SAPLING: number;
+    static VERSION4_BRANCH_CANOPY: number;
+    static VERSION4_BRANCH_NU5: number;
+    static VERSION5_BRANCH_NU5: number;
+    overwintered: number;
+    versionGroupId: number;
+    expiryHeight: number;
+    consensusBranchId: number;
+    constructor(network: ZcashNetwork, tx?: ZcashTransaction<bigint | number>, amountType?: 'bigint' | 'number');
+    static fromBuffer<TNumber extends number | bigint = number>(buffer: Buffer, __noStrict: boolean, amountType?: 'number' | 'bigint', network?: ZcashNetwork): ZcashTransaction<TNumber>;
+    static fromBufferWithVersion<TNumber extends number | bigint>(buf: Buffer, network: ZcashNetwork, version?: number, amountType?: 'number' | 'bigint'): ZcashTransaction<TNumber>;
+    byteLength(): number;
+    isSaplingCompatible(): boolean;
+    isOverwinterCompatible(): boolean;
+    supportsJoinSplits(): boolean;
+    /**
+     * Build a hash for all or none of the transaction inputs depending on the hashtype
+     * @param hashType
+     * @returns Buffer - BLAKE2b hash or 256-bit zero if doesn't apply
+     */
+    getPrevoutHash(hashType: number): Buffer;
+    /**
+     * Build a hash for all or none of the transactions inputs sequence numbers depending on the hashtype
+     * @param hashType
+     * @returns Buffer BLAKE2b hash or 256-bit zero if doesn't apply
+     */
+    getSequenceHash(hashType: number): Buffer;
+    /**
+     * Build a hash for one, all or none of the transaction outputs depending on the hashtype
+     * @param hashType
+     * @param inIndex
+     * @returns Buffer BLAKE2b hash or 256-bit zero if doesn't apply
+     */
+    getOutputsHash(hashType: number, inIndex: number): Buffer;
+    /**
+     * Hash transaction for signing a transparent transaction in Zcash. Protected transactions are not supported.
+     * @param inIndex
+     * @param prevOutScript
+     * @param value
+     * @param hashType
+     * @returns Buffer BLAKE2b hash
+     */
+    hashForSignatureByNetwork(inIndex: number | undefined, prevOutScript: Buffer, value: bigint | number | undefined, hashType: number): Buffer;
+    toBuffer(buffer?: Buffer, initialOffset?: number): Buffer;
+    getHash(forWitness?: boolean): Buffer;
+    clone<TN2 extends number | bigint = TNumber>(amountType?: 'bigint' | 'number'): ZcashTransaction<TN2>;
+}
+//# sourceMappingURL=ZcashTransaction.d.ts.map

package/dist/src/bitgo/zcash/ZcashTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZcashTransaction.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/zcash/ZcashTransaction.ts"],"names":[],"mappings":";AAOA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAgB,MAAM,oBAAoB,CAAC;AAMnE,oBAAY,YAAY,GAAG,OAAO,QAAQ,CAAC,KAAK,GAAG,OAAO,QAAQ,CAAC,SAAS,CAAC;AAY7E,qBAAa,2BAA4B,SAAQ,KAAK;gBACxC,OAAO,EAAE,MAAM;CAG5B;AAED,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAS1E;AAED,wBAAgB,qCAAqC,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAkBpG;AAED,qBAAa,gBAAgB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,CAAE,SAAQ,eAAe,CAAC,OAAO,CAAC;IAiBnF,OAAO,EAAE,YAAY;IAhBxC,MAAM,CAAC,0BAA0B,SAAK;IACtC,MAAM,CAAC,kBAAkB,SAAK;IAC9B,MAAM,CAAC,eAAe,SAAK;IAE3B,MAAM,CAAC,sBAAsB,SAAO;IACpC,MAAM,CAAC,mBAAmB,SAAO;IACjC,MAAM,CAAC,mBAAmB,SAAO;IAGjC,YAAY,SAAK;IAEjB,cAAc,SAAK;IAEnB,YAAY,SAAK;IACjB,iBAAiB,EAAE,MAAM,CAAC;gBAEP,OAAO,EAAE,YAAY,EAAE,EAAE,CAAC,EAAE,gBAAgB,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,UAAU,CAAC,EAAE,QAAQ,GAAG,QAAQ;IAgBlH,MAAM,CAAC,UAAU,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EACxD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,OAAO,EACnB,UAAU,GAAE,QAAQ,GAAG,QAAmB,EAC1C,OAAO,CAAC,EAAE,YAAY,GACrB,gBAAgB,CAAC,OAAO,CAAC;IAmC5B,MAAM,CAAC,qBAAqB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EAC1D,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,YAAY,EACrB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,GAAE,QAAQ,GAAG,QAAmB,GACzC,gBAAgB,CAAC,OAAO,CAAC;IAQ5B,UAAU,IAAI,MAAM;IA8BpB,mBAAmB,IAAI,OAAO;IAI9B,sBAAsB,IAAI,OAAO;IAIjC,kBAAkB,IAAI,OAAO;IAI7B;;;;OAIG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAcxC;;;;OAIG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAiBzC;;;;;OAKG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IA4BzD;;;;;;;OAOG;IACH,yBAAyB,CACvB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClC,QAAQ,EAAE,MAAM,GACf,MAAM;IAsFT,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,aAAa,SAAI,GAAG,MAAM;IAyBpD,OAAO,CAAC,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM;IAUrC,KAAK,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,UAAU,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,gBAAgB,CAAC,GAAG,CAAC;CAGtG"}

package/dist/src/bitgo/zcash/ZcashTransaction.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZcashTransaction = exports.getDefaultConsensusBranchIdForVersion = exports.getDefaultVersionGroupIdForVersion = exports.UnsupportedTransactionError = void 0;
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const types = require("bitcoinjs-lib/src/types");
+const bufferutils_1 = require("bitcoinjs-lib/src/bufferutils");
+const varuint = require('varuint-bitcoin');
+const typeforce = require('typeforce');
+const UtxoTransaction_1 = require("../UtxoTransaction");
+const ZcashBufferutils_1 = require("./ZcashBufferutils");
+const hashZip0244_1 = require("./hashZip0244");
+const ZERO = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+// https://github.com/zcash/zcash/blob/v4.7.0/src/primitives/transaction.h#L40
+const SAPLING_VERSION_GROUP_ID = 0x892f2085;
+// https://github.com/zcash/zcash/blob/v4.7.0/src/primitives/transaction.h#L52
+const ZIP225_VERSION_GROUP_ID = 0x26a7270a;
+// https://github.com/zcash/zcash/blob/v4.7.0/src/consensus/upgrades.cpp#L11
+const OVERWINTER_BRANCH_ID = 0x5ba81b19;
+const CANOPY_BRANCH_ID = 0xe9ff75a6;
+const NU5_BRANCH_ID = 0xc2d6d0b4;
+class UnsupportedTransactionError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.UnsupportedTransactionError = UnsupportedTransactionError;
+function getDefaultVersionGroupIdForVersion(version) {
+    switch (version) {
+        case 400:
+        case 450:
+            return SAPLING_VERSION_GROUP_ID;
+        case 500:
+            return ZIP225_VERSION_GROUP_ID;
+    }
+    throw new Error(`no value for version ${version}`);
+}
+exports.getDefaultVersionGroupIdForVersion = getDefaultVersionGroupIdForVersion;
+function getDefaultConsensusBranchIdForVersion(network, version) {
+    switch (version) {
+        case 1:
+        case 2:
+            return 0;
+        case 3:
+            return OVERWINTER_BRANCH_ID;
+        case ZcashTransaction.VERSION4_BRANCH_CANOPY:
+            // https://zips.z.cash/zip-0251
+            return CANOPY_BRANCH_ID;
+        case 4:
+        case 5:
+        case ZcashTransaction.VERSION4_BRANCH_NU5:
+        case ZcashTransaction.VERSION5_BRANCH_NU5:
+            // https://zips.z.cash/zip-0252
+            return NU5_BRANCH_ID;
+    }
+    throw new Error(`no value for version ${version}`);
+}
+exports.getDefaultConsensusBranchIdForVersion = getDefaultConsensusBranchIdForVersion;
+class ZcashTransaction extends UtxoTransaction_1.UtxoTransaction {
+    constructor(network, tx, amountType) {
+        super(network, tx, amountType);
+        this.network = network;
+        // 1 if the transaction is post overwinter upgrade, 0 otherwise
+        this.overwintered = 0;
+        // 0x03C48270 (63210096) for overwinter and 0x892F2085 (2301567109) for sapling
+        this.versionGroupId = 0;
+        // Block height after which this transactions will expire, or 0 to disable expiry
+        this.expiryHeight = 0;
+        let consensusBranchId;
+        if (tx) {
+            this.overwintered = tx.overwintered;
+            this.versionGroupId = tx.versionGroupId;
+            this.expiryHeight = tx.expiryHeight;
+            if (tx.consensusBranchId !== undefined) {
+                consensusBranchId = tx.consensusBranchId;
+            }
+        }
+        this.consensusBranchId = consensusBranchId !== null && consensusBranchId !== void 0 ? consensusBranchId : getDefaultConsensusBranchIdForVersion(network, this.version);
+    }
+    static fromBuffer(buffer, __noStrict, amountType = 'number', network) {
+        /* istanbul ignore next */
+        if (!network) {
+            throw new Error(`must provide network`);
+        }
+        const bufferReader = new bufferutils_1.BufferReader(buffer);
+        const tx = new ZcashTransaction(network);
+        tx.version = bufferReader.readInt32();
+        // Split the header into fOverwintered and nVersion
+        // https://github.com/zcash/zcash/blob/v4.5.1/src/primitives/transaction.h#L772
+        tx.overwintered = tx.version >>> 31; // Must be 1 for version 3 and up
+        tx.version = tx.version & 0x07fffffff; // 3 for overwinter
+        tx.consensusBranchId = getDefaultConsensusBranchIdForVersion(network, tx.version);
+        if (tx.isOverwinterCompatible()) {
+            tx.versionGroupId = bufferReader.readUInt32();
+        }
+        if (tx.version === 5) {
+            ZcashBufferutils_1.fromBufferV5(bufferReader, tx, amountType);
+        }
+        else {
+            ZcashBufferutils_1.fromBufferV4(bufferReader, tx, amountType);
+        }
+        if (__noStrict)
+            return tx;
+        if (bufferReader.offset !== buffer.length) {
+            const trailing = buffer.slice(bufferReader.offset);
+            throw new Error(`Unexpected trailing bytes: ${trailing.toString('hex')}`);
+        }
+        return tx;
+    }
+    static fromBufferWithVersion(buf, network, version, amountType = 'number') {
+        const tx = ZcashTransaction.fromBuffer(buf, false, amountType, network);
+        if (version) {
+            tx.consensusBranchId = getDefaultConsensusBranchIdForVersion(network, version);
+        }
+        return tx;
+    }
+    byteLength() {
+        let byteLength = super.byteLength();
+        if (this.isOverwinterCompatible()) {
+            byteLength += 4; // nVersionGroupId
+        }
+        if (this.isOverwinterCompatible()) {
+            byteLength += 4; // nExpiryHeight
+        }
+        const emptyVectorLength = varuint.encodingLength(0);
+        if (this.version === 5) {
+            // https://github.com/zcash/zcash/blob/v4.5.1/src/primitives/transaction.h#L822
+            byteLength += 4; // consensusBranchId
+            byteLength += emptyVectorLength; // saplingBundle inputs
+            byteLength += emptyVectorLength; // saplingBundle outputs
+            byteLength += 1; // orchardBundle (empty)
+        }
+        else {
+            if (this.isSaplingCompatible()) {
+                // https://github.com/zcash/zcash/blob/v4.5.1/src/primitives/transaction.h#L862
+                byteLength += 8; // valueBalance (uint64)
+                byteLength += emptyVectorLength; // inputs
+                byteLength += emptyVectorLength; // outputs
+            }
+            if (this.supportsJoinSplits()) {
+                //
+                byteLength += emptyVectorLength; // joinsplits
+            }
+        }
+        return byteLength;
+    }
+    isSaplingCompatible() {
+        return !!this.overwintered && this.version >= ZcashTransaction.VERSION_SAPLING;
+    }
+    isOverwinterCompatible() {
+        return !!this.overwintered && this.version >= ZcashTransaction.VERSION_OVERWINTER;
+    }
+    supportsJoinSplits() {
+        return !!this.overwintered && this.version >= ZcashTransaction.VERSION_JOINSPLITS_SUPPORT;
+    }
+    /**
+     * Build a hash for all or none of the transaction inputs depending on the hashtype
+     * @param hashType
+     * @returns Buffer - BLAKE2b hash or 256-bit zero if doesn't apply
+     */
+    getPrevoutHash(hashType) {
+        if (!(hashType & bitcoinjs_lib_1.Transaction.SIGHASH_ANYONECANPAY)) {
+            const bufferWriter = new bufferutils_1.BufferWriter(Buffer.allocUnsafe(36 * this.ins.length));
+            this.ins.forEach(function (txIn) {
+                bufferWriter.writeSlice(txIn.hash);
+                bufferWriter.writeUInt32(txIn.index);
+            });
+            return hashZip0244_1.getBlake2bHash(bufferWriter.buffer, 'ZcashPrevoutHash');
+        }
+        return ZERO;
+    }
+    /**
+     * Build a hash for all or none of the transactions inputs sequence numbers depending on the hashtype
+     * @param hashType
+     * @returns Buffer BLAKE2b hash or 256-bit zero if doesn't apply
+     */
+    getSequenceHash(hashType) {
+        if (!(hashType & bitcoinjs_lib_1.Transaction.SIGHASH_ANYONECANPAY) &&
+            (hashType & 0x1f) !== bitcoinjs_lib_1.Transaction.SIGHASH_SINGLE &&
+            (hashType & 0x1f) !== bitcoinjs_lib_1.Transaction.SIGHASH_NONE) {
+            const bufferWriter = new bufferutils_1.BufferWriter(Buffer.allocUnsafe(4 * this.ins.length));
+            this.ins.forEach(function (txIn) {
+                bufferWriter.writeUInt32(txIn.sequence);
+            });
+            return hashZip0244_1.getBlake2bHash(bufferWriter.buffer, 'ZcashSequencHash');
+        }
+        return ZERO;
+    }
+    /**
+     * Build a hash for one, all or none of the transaction outputs depending on the hashtype
+     * @param hashType
+     * @param inIndex
+     * @returns Buffer BLAKE2b hash or 256-bit zero if doesn't apply
+     */
+    getOutputsHash(hashType, inIndex) {
+        if ((hashType & 0x1f) !== bitcoinjs_lib_1.Transaction.SIGHASH_SINGLE && (hashType & 0x1f) !== bitcoinjs_lib_1.Transaction.SIGHASH_NONE) {
+            // Find out the size of the outputs and write them
+            const txOutsSize = this.outs.reduce(function (sum, output) {
+                return sum + 8 + UtxoTransaction_1.varSliceSize(output.script);
+            }, 0);
+            const bufferWriter = new bufferutils_1.BufferWriter(Buffer.allocUnsafe(txOutsSize));
+            this.outs.forEach(function (out) {
+                bufferWriter.writeUInt64(out.value);
+                bufferWriter.writeVarSlice(out.script);
+            });
+            return hashZip0244_1.getBlake2bHash(bufferWriter.buffer, 'ZcashOutputsHash');
+        }
+        else if ((hashType & 0x1f) === bitcoinjs_lib_1.Transaction.SIGHASH_SINGLE && inIndex < this.outs.length) {
+            // Write only the output specified in inIndex
+            const output = this.outs[inIndex];
+            const bufferWriter = new bufferutils_1.BufferWriter(Buffer.allocUnsafe(8 + UtxoTransaction_1.varSliceSize(output.script)));
+            bufferWriter.writeUInt64(output.value);
+            bufferWriter.writeVarSlice(output.script);
+            return hashZip0244_1.getBlake2bHash(bufferWriter.buffer, 'ZcashOutputsHash');
+        }
+        return ZERO;
+    }
+    /**
+     * Hash transaction for signing a transparent transaction in Zcash. Protected transactions are not supported.
+     * @param inIndex
+     * @param prevOutScript
+     * @param value
+     * @param hashType
+     * @returns Buffer BLAKE2b hash
+     */
+    hashForSignatureByNetwork(inIndex, prevOutScript, value, hashType) {
+        if (value === undefined) {
+            throw new Error(`must provide value`);
+        }
+        // https://github.com/zcash/zcash/blob/v4.5.1/src/script/interpreter.cpp#L1175
+        if (this.version === 5) {
+            return hashZip0244_1.getSignatureDigest(this, inIndex, prevOutScript, value, hashType);
+        }
+        // ZCash amounts are always within Number.MAX_SAFE_INTEGER
+        value = typeof value === 'bigint' ? Number(value) : value;
+        typeforce(types.tuple(types.UInt32, types.Buffer, types.Number), [inIndex, prevOutScript, value]);
+        if (inIndex === undefined) {
+            throw new Error(`invalid inIndex`);
+        }
+        /* istanbul ignore next */
+        if (inIndex >= this.ins.length) {
+            throw new Error('Input index is out of range');
+        }
+        /* istanbul ignore next */
+        if (!this.isOverwinterCompatible()) {
+            throw new Error(`unsupported version ${this.version}`);
+        }
+        const hashPrevouts = this.getPrevoutHash(hashType);
+        const hashSequence = this.getSequenceHash(hashType);
+        const hashOutputs = this.getOutputsHash(hashType, inIndex);
+        const hashJoinSplits = ZERO;
+        const hashShieldedSpends = ZERO;
+        const hashShieldedOutputs = ZERO;
+        let baseBufferSize = 0;
+        baseBufferSize += 4 * 5; // header, nVersionGroupId, lock_time, nExpiryHeight, hashType
+        baseBufferSize += 32 * 4; // 256 hashes: hashPrevouts, hashSequence, hashOutputs, hashJoinSplits
+        baseBufferSize += 4 * 2; // input.index, input.sequence
+        baseBufferSize += 8; // value
+        baseBufferSize += 32; // input.hash
+        baseBufferSize += UtxoTransaction_1.varSliceSize(prevOutScript); // prevOutScript
+        if (this.isSaplingCompatible()) {
+            baseBufferSize += 32 * 2; // hashShieldedSpends and hashShieldedOutputs
+            baseBufferSize += 8; // valueBalance
+        }
+        const mask = this.overwintered ? 1 : 0;
+        const header = this.version | (mask << 31);
+        const bufferWriter = new bufferutils_1.BufferWriter(Buffer.alloc(baseBufferSize));
+        bufferWriter.writeInt32(header);
+        bufferWriter.writeUInt32(this.versionGroupId);
+        bufferWriter.writeSlice(hashPrevouts);
+        bufferWriter.writeSlice(hashSequence);
+        bufferWriter.writeSlice(hashOutputs);
+        bufferWriter.writeSlice(hashJoinSplits);
+        if (this.isSaplingCompatible()) {
+            bufferWriter.writeSlice(hashShieldedSpends);
+            bufferWriter.writeSlice(hashShieldedOutputs);
+        }
+        bufferWriter.writeUInt32(this.locktime);
+        bufferWriter.writeUInt32(this.expiryHeight);
+        if (this.isSaplingCompatible()) {
+            bufferWriter.writeSlice(ZcashBufferutils_1.VALUE_INT64_ZERO);
+        }
+        bufferWriter.writeInt32(hashType);
+        // The input being signed (replacing the scriptSig with scriptCode + amount)
+        // The prevout may already be contained in hashPrevout, and the nSequence
+        // may already be contained in hashSequence.
+        const input = this.ins[inIndex];
+        bufferWriter.writeSlice(input.hash);
+        bufferWriter.writeUInt32(input.index);
+        bufferWriter.writeVarSlice(prevOutScript);
+        bufferWriter.writeUInt64(value);
+        bufferWriter.writeUInt32(input.sequence);
+        const personalization = Buffer.alloc(16);
+        const prefix = 'ZcashSigHash';
+        personalization.write(prefix);
+        personalization.writeUInt32LE(this.consensusBranchId, prefix.length);
+        return hashZip0244_1.getBlake2bHash(bufferWriter.buffer, personalization);
+    }
+    toBuffer(buffer, initialOffset = 0) {
+        if (!buffer)
+            buffer = Buffer.allocUnsafe(this.byteLength());
+        const bufferWriter = new bufferutils_1.BufferWriter(buffer, initialOffset);
+        if (this.isOverwinterCompatible()) {
+            const mask = this.overwintered ? 1 : 0;
+            bufferWriter.writeInt32(this.version | (mask << 31)); // Set overwinter bit
+            bufferWriter.writeUInt32(this.versionGroupId);
+        }
+        else {
+            bufferWriter.writeInt32(this.version);
+        }
+        if (this.version === 5) {
+            ZcashBufferutils_1.toBufferV5(bufferWriter, this);
+        }
+        else {
+            ZcashBufferutils_1.toBufferV4(bufferWriter, this);
+        }
+        if (initialOffset !== undefined) {
+            return buffer.slice(initialOffset, bufferWriter.offset);
+        }
+        return buffer;
+    }
+    getHash(forWitness) {
+        if (forWitness) {
+            throw new Error(`invalid argument`);
+        }
+        if (this.version === 5) {
+            return hashZip0244_1.getTxidDigest(this);
+        }
+        return bitcoinjs_lib_1.crypto.hash256(this.toBuffer());
+    }
+    clone(amountType) {
+        return new ZcashTransaction(this.network, this, amountType);
+    }
+}
+exports.ZcashTransaction = ZcashTransaction;
+ZcashTransaction.VERSION_JOINSPLITS_SUPPORT = 2;
+ZcashTransaction.VERSION_OVERWINTER = 3;
+ZcashTransaction.VERSION_SAPLING = 4;
+ZcashTransaction.VERSION4_BRANCH_CANOPY = 400;
+ZcashTransaction.VERSION4_BRANCH_NU5 = 450;
+ZcashTransaction.VERSION5_BRANCH_NU5 = 500;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ZcashTransaction.js","sourceRoot":"","sources":["../../../../src/bitgo/zcash/ZcashTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { Transaction, crypto } from 'bitcoinjs-lib';\nimport * as types from 'bitcoinjs-lib/src/types';\nimport { BufferReader, BufferWriter } from 'bitcoinjs-lib/src/bufferutils';\n\nconst varuint = require('varuint-bitcoin');\nconst typeforce = require('typeforce');\n\nimport { networks } from '../../networks';\nimport { UtxoTransaction, varSliceSize } from '../UtxoTransaction';\nimport { fromBufferV4, fromBufferV5, toBufferV4, toBufferV5, VALUE_INT64_ZERO } from './ZcashBufferutils';\nimport { getBlake2bHash, getSignatureDigest, getTxidDigest } from './hashZip0244';\n\nconst ZERO = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');\n\nexport type ZcashNetwork = typeof networks.zcash | typeof networks.zcashTest;\n\n// https://github.com/zcash/zcash/blob/v4.7.0/src/primitives/transaction.h#L40\nconst SAPLING_VERSION_GROUP_ID = 0x892f2085;\n// https://github.com/zcash/zcash/blob/v4.7.0/src/primitives/transaction.h#L52\nconst ZIP225_VERSION_GROUP_ID = 0x26a7270a;\n\n// https://github.com/zcash/zcash/blob/v4.7.0/src/consensus/upgrades.cpp#L11\nconst OVERWINTER_BRANCH_ID = 0x5ba81b19;\nconst CANOPY_BRANCH_ID = 0xe9ff75a6;\nconst NU5_BRANCH_ID = 0xc2d6d0b4;\n\nexport class UnsupportedTransactionError extends Error {\n  constructor(message: string) {\n    super(message);\n  }\n}\n\nexport function getDefaultVersionGroupIdForVersion(version: number): number {\n  switch (version) {\n    case 400:\n    case 450:\n      return SAPLING_VERSION_GROUP_ID;\n    case 500:\n      return ZIP225_VERSION_GROUP_ID;\n  }\n  throw new Error(`no value for version ${version}`);\n}\n\nexport function getDefaultConsensusBranchIdForVersion(network: ZcashNetwork, version: number): number {\n  switch (version) {\n    case 1:\n    case 2:\n      return 0;\n    case 3:\n      return OVERWINTER_BRANCH_ID;\n    case ZcashTransaction.VERSION4_BRANCH_CANOPY:\n      // https://zips.z.cash/zip-0251\n      return CANOPY_BRANCH_ID;\n    case 4:\n    case 5:\n    case ZcashTransaction.VERSION4_BRANCH_NU5:\n    case ZcashTransaction.VERSION5_BRANCH_NU5:\n      // https://zips.z.cash/zip-0252\n      return NU5_BRANCH_ID;\n  }\n  throw new Error(`no value for version ${version}`);\n}\n\nexport class ZcashTransaction<TNumber extends number | bigint = number> extends UtxoTransaction<TNumber> {\n  static VERSION_JOINSPLITS_SUPPORT = 2;\n  static VERSION_OVERWINTER = 3;\n  static VERSION_SAPLING = 4;\n\n  static VERSION4_BRANCH_CANOPY = 400;\n  static VERSION4_BRANCH_NU5 = 450;\n  static VERSION5_BRANCH_NU5 = 500;\n\n  // 1 if the transaction is post overwinter upgrade, 0 otherwise\n  overwintered = 0;\n  // 0x03C48270 (63210096) for overwinter and 0x892F2085 (2301567109) for sapling\n  versionGroupId = 0;\n  // Block height after which this transactions will expire, or 0 to disable expiry\n  expiryHeight = 0;\n  consensusBranchId: number;\n\n  constructor(public network: ZcashNetwork, tx?: ZcashTransaction<bigint | number>, amountType?: 'bigint' | 'number') {\n    super(network, tx, amountType);\n\n    let consensusBranchId;\n    if (tx) {\n      this.overwintered = tx.overwintered;\n      this.versionGroupId = tx.versionGroupId;\n      this.expiryHeight = tx.expiryHeight;\n\n      if (tx.consensusBranchId !== undefined) {\n        consensusBranchId = tx.consensusBranchId;\n      }\n    }\n    this.consensusBranchId = consensusBranchId ?? getDefaultConsensusBranchIdForVersion(network, this.version);\n  }\n\n  static fromBuffer<TNumber extends number | bigint = number>(\n    buffer: Buffer,\n    __noStrict: boolean,\n    amountType: 'number' | 'bigint' = 'number',\n    network?: ZcashNetwork\n  ): ZcashTransaction<TNumber> {\n    /* istanbul ignore next */\n    if (!network) {\n      throw new Error(`must provide network`);\n    }\n\n    const bufferReader = new BufferReader(buffer);\n    const tx = new ZcashTransaction<TNumber>(network);\n    tx.version = bufferReader.readInt32();\n\n    // Split the header into fOverwintered and nVersion\n    // https://github.com/zcash/zcash/blob/v4.5.1/src/primitives/transaction.h#L772\n    tx.overwintered = tx.version >>> 31; // Must be 1 for version 3 and up\n    tx.version = tx.version & 0x07fffffff; // 3 for overwinter\n    tx.consensusBranchId = getDefaultConsensusBranchIdForVersion(network, tx.version);\n\n    if (tx.isOverwinterCompatible()) {\n      tx.versionGroupId = bufferReader.readUInt32();\n    }\n\n    if (tx.version === 5) {\n      fromBufferV5(bufferReader, tx, amountType);\n    } else {\n      fromBufferV4(bufferReader, tx, amountType);\n    }\n\n    if (__noStrict) return tx;\n    if (bufferReader.offset !== buffer.length) {\n      const trailing = buffer.slice(bufferReader.offset);\n      throw new Error(`Unexpected trailing bytes: ${trailing.toString('hex')}`);\n    }\n\n    return tx;\n  }\n\n  static fromBufferWithVersion<TNumber extends number | bigint>(\n    buf: Buffer,\n    network: ZcashNetwork,\n    version?: number,\n    amountType: 'number' | 'bigint' = 'number'\n  ): ZcashTransaction<TNumber> {\n    const tx = ZcashTransaction.fromBuffer<TNumber>(buf, false, amountType, network);\n    if (version) {\n      tx.consensusBranchId = getDefaultConsensusBranchIdForVersion(network, version);\n    }\n    return tx;\n  }\n\n  byteLength(): number {\n    let byteLength = super.byteLength();\n    if (this.isOverwinterCompatible()) {\n      byteLength += 4; // nVersionGroupId\n    }\n    if (this.isOverwinterCompatible()) {\n      byteLength += 4; // nExpiryHeight\n    }\n    const emptyVectorLength = varuint.encodingLength(0);\n    if (this.version === 5) {\n      // https://github.com/zcash/zcash/blob/v4.5.1/src/primitives/transaction.h#L822\n      byteLength += 4; // consensusBranchId\n      byteLength += emptyVectorLength; // saplingBundle inputs\n      byteLength += emptyVectorLength; // saplingBundle outputs\n      byteLength += 1; // orchardBundle (empty)\n    } else {\n      if (this.isSaplingCompatible()) {\n        // https://github.com/zcash/zcash/blob/v4.5.1/src/primitives/transaction.h#L862\n        byteLength += 8; // valueBalance (uint64)\n        byteLength += emptyVectorLength; // inputs\n        byteLength += emptyVectorLength; // outputs\n      }\n      if (this.supportsJoinSplits()) {\n        //\n        byteLength += emptyVectorLength; // joinsplits\n      }\n    }\n    return byteLength;\n  }\n\n  isSaplingCompatible(): boolean {\n    return !!this.overwintered && this.version >= ZcashTransaction.VERSION_SAPLING;\n  }\n\n  isOverwinterCompatible(): boolean {\n    return !!this.overwintered && this.version >= ZcashTransaction.VERSION_OVERWINTER;\n  }\n\n  supportsJoinSplits(): boolean {\n    return !!this.overwintered && this.version >= ZcashTransaction.VERSION_JOINSPLITS_SUPPORT;\n  }\n\n  /**\n   * Build a hash for all or none of the transaction inputs depending on the hashtype\n   * @param hashType\n   * @returns Buffer - BLAKE2b hash or 256-bit zero if doesn't apply\n   */\n  getPrevoutHash(hashType: number): Buffer {\n    if (!(hashType & Transaction.SIGHASH_ANYONECANPAY)) {\n      const bufferWriter = new BufferWriter(Buffer.allocUnsafe(36 * this.ins.length));\n\n      this.ins.forEach(function (txIn) {\n        bufferWriter.writeSlice(txIn.hash);\n        bufferWriter.writeUInt32(txIn.index);\n      });\n\n      return getBlake2bHash(bufferWriter.buffer, 'ZcashPrevoutHash');\n    }\n    return ZERO;\n  }\n\n  /**\n   * Build a hash for all or none of the transactions inputs sequence numbers depending on the hashtype\n   * @param hashType\n   * @returns Buffer BLAKE2b hash or 256-bit zero if doesn't apply\n   */\n  getSequenceHash(hashType: number): Buffer {\n    if (\n      !(hashType & Transaction.SIGHASH_ANYONECANPAY) &&\n      (hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&\n      (hashType & 0x1f) !== Transaction.SIGHASH_NONE\n    ) {\n      const bufferWriter = new BufferWriter(Buffer.allocUnsafe(4 * this.ins.length));\n\n      this.ins.forEach(function (txIn) {\n        bufferWriter.writeUInt32(txIn.sequence);\n      });\n\n      return getBlake2bHash(bufferWriter.buffer, 'ZcashSequencHash');\n    }\n    return ZERO;\n  }\n\n  /**\n   * Build a hash for one, all or none of the transaction outputs depending on the hashtype\n   * @param hashType\n   * @param inIndex\n   * @returns Buffer BLAKE2b hash or 256-bit zero if doesn't apply\n   */\n  getOutputsHash(hashType: number, inIndex: number): Buffer {\n    if ((hashType & 0x1f) !== Transaction.SIGHASH_SINGLE && (hashType & 0x1f) !== Transaction.SIGHASH_NONE) {\n      // Find out the size of the outputs and write them\n      const txOutsSize = this.outs.reduce(function (sum, output) {\n        return sum + 8 + varSliceSize(output.script);\n      }, 0);\n\n      const bufferWriter = new BufferWriter(Buffer.allocUnsafe(txOutsSize));\n\n      this.outs.forEach(function (out) {\n        bufferWriter.writeUInt64(out.value);\n        bufferWriter.writeVarSlice(out.script);\n      });\n\n      return getBlake2bHash(bufferWriter.buffer, 'ZcashOutputsHash');\n    } else if ((hashType & 0x1f) === Transaction.SIGHASH_SINGLE && inIndex < this.outs.length) {\n      // Write only the output specified in inIndex\n      const output = this.outs[inIndex];\n\n      const bufferWriter = new BufferWriter(Buffer.allocUnsafe(8 + varSliceSize(output.script)));\n      bufferWriter.writeUInt64(output.value);\n      bufferWriter.writeVarSlice(output.script);\n\n      return getBlake2bHash(bufferWriter.buffer, 'ZcashOutputsHash');\n    }\n    return ZERO;\n  }\n\n  /**\n   * Hash transaction for signing a transparent transaction in Zcash. Protected transactions are not supported.\n   * @param inIndex\n   * @param prevOutScript\n   * @param value\n   * @param hashType\n   * @returns Buffer BLAKE2b hash\n   */\n  hashForSignatureByNetwork(\n    inIndex: number | undefined,\n    prevOutScript: Buffer,\n    value: bigint | number | undefined,\n    hashType: number\n  ): Buffer {\n    if (value === undefined) {\n      throw new Error(`must provide value`);\n    }\n\n    // https://github.com/zcash/zcash/blob/v4.5.1/src/script/interpreter.cpp#L1175\n    if (this.version === 5) {\n      return getSignatureDigest(this, inIndex, prevOutScript, value, hashType);\n    }\n\n    // ZCash amounts are always within Number.MAX_SAFE_INTEGER\n    value = typeof value === 'bigint' ? Number(value) : value;\n    typeforce(types.tuple(types.UInt32, types.Buffer, types.Number), [inIndex, prevOutScript, value]);\n\n    if (inIndex === undefined) {\n      throw new Error(`invalid inIndex`);\n    }\n\n    /* istanbul ignore next */\n    if (inIndex >= this.ins.length) {\n      throw new Error('Input index is out of range');\n    }\n\n    /* istanbul ignore next */\n    if (!this.isOverwinterCompatible()) {\n      throw new Error(`unsupported version ${this.version}`);\n    }\n\n    const hashPrevouts = this.getPrevoutHash(hashType);\n    const hashSequence = this.getSequenceHash(hashType);\n    const hashOutputs = this.getOutputsHash(hashType, inIndex);\n    const hashJoinSplits = ZERO;\n    const hashShieldedSpends = ZERO;\n    const hashShieldedOutputs = ZERO;\n\n    let baseBufferSize = 0;\n    baseBufferSize += 4 * 5; // header, nVersionGroupId, lock_time, nExpiryHeight, hashType\n    baseBufferSize += 32 * 4; // 256 hashes: hashPrevouts, hashSequence, hashOutputs, hashJoinSplits\n    baseBufferSize += 4 * 2; // input.index, input.sequence\n    baseBufferSize += 8; // value\n    baseBufferSize += 32; // input.hash\n    baseBufferSize += varSliceSize(prevOutScript); // prevOutScript\n    if (this.isSaplingCompatible()) {\n      baseBufferSize += 32 * 2; // hashShieldedSpends and hashShieldedOutputs\n      baseBufferSize += 8; // valueBalance\n    }\n\n    const mask = this.overwintered ? 1 : 0;\n    const header = this.version | (mask << 31);\n\n    const bufferWriter = new BufferWriter(Buffer.alloc(baseBufferSize));\n    bufferWriter.writeInt32(header);\n    bufferWriter.writeUInt32(this.versionGroupId);\n    bufferWriter.writeSlice(hashPrevouts);\n    bufferWriter.writeSlice(hashSequence);\n    bufferWriter.writeSlice(hashOutputs);\n    bufferWriter.writeSlice(hashJoinSplits);\n    if (this.isSaplingCompatible()) {\n      bufferWriter.writeSlice(hashShieldedSpends);\n      bufferWriter.writeSlice(hashShieldedOutputs);\n    }\n    bufferWriter.writeUInt32(this.locktime);\n    bufferWriter.writeUInt32(this.expiryHeight);\n    if (this.isSaplingCompatible()) {\n      bufferWriter.writeSlice(VALUE_INT64_ZERO);\n    }\n    bufferWriter.writeInt32(hashType);\n\n    // The input being signed (replacing the scriptSig with scriptCode + amount)\n    // The prevout may already be contained in hashPrevout, and the nSequence\n    // may already be contained in hashSequence.\n    const input = this.ins[inIndex];\n    bufferWriter.writeSlice(input.hash);\n    bufferWriter.writeUInt32(input.index);\n    bufferWriter.writeVarSlice(prevOutScript);\n    bufferWriter.writeUInt64(value);\n    bufferWriter.writeUInt32(input.sequence);\n\n    const personalization = Buffer.alloc(16);\n    const prefix = 'ZcashSigHash';\n    personalization.write(prefix);\n    personalization.writeUInt32LE(this.consensusBranchId, prefix.length);\n\n    return getBlake2bHash(bufferWriter.buffer, personalization);\n  }\n\n  toBuffer(buffer?: Buffer, initialOffset = 0): Buffer {\n    if (!buffer) buffer = Buffer.allocUnsafe(this.byteLength());\n\n    const bufferWriter = new BufferWriter(buffer, initialOffset);\n\n    if (this.isOverwinterCompatible()) {\n      const mask = this.overwintered ? 1 : 0;\n      bufferWriter.writeInt32(this.version | (mask << 31)); // Set overwinter bit\n      bufferWriter.writeUInt32(this.versionGroupId);\n    } else {\n      bufferWriter.writeInt32(this.version);\n    }\n\n    if (this.version === 5) {\n      toBufferV5(bufferWriter, this);\n    } else {\n      toBufferV4(bufferWriter, this);\n    }\n\n    if (initialOffset !== undefined) {\n      return buffer.slice(initialOffset, bufferWriter.offset);\n    }\n    return buffer;\n  }\n\n  getHash(forWitness?: boolean): Buffer {\n    if (forWitness) {\n      throw new Error(`invalid argument`);\n    }\n    if (this.version === 5) {\n      return getTxidDigest(this);\n    }\n    return crypto.hash256(this.toBuffer());\n  }\n\n  clone<TN2 extends number | bigint = TNumber>(amountType?: 'bigint' | 'number'): ZcashTransaction<TN2> {\n    return new ZcashTransaction<TN2>(this.network, this, amountType);\n  }\n}\n"]}