@exodus/bip322-js 1.1.0-rc.0 → 1.1.0

package/README.md

@@ -25,25 +25,25 @@ Available at https://acken2.github.io/bip322-js/
 
 ```js
 // Import modules that are useful to you
-const { BIP322, Signer, Verifier } = require('bip322-js')
+const { BIP322, Signer, Verifier } = require('bip322-js');
 
 // Signing a BIP-322 signature with a private key
-const privateKey = 'L3VFeEujGtevx9w18HD1fhRbCH67Az2dpCymeRE1SoPK6XQtaN2k'
-const address = 'bc1q9vza2e8x573nczrlzms0wvx3gsqjx7vavgkx0l'
-const message = 'Hello World'
-const signature = Signer.sign(privateKey, address, message)
-console.log(signature)
+const privateKey = 'L3VFeEujGtevx9w18HD1fhRbCH67Az2dpCymeRE1SoPK6XQtaN2k';
+const address = 'bc1q9vza2e8x573nczrlzms0wvx3gsqjx7vavgkx0l';
+const message = 'Hello World';
+const signature = Signer.sign(privateKey, address, message);
+console.log(signature);
 
 // Verifying a simple BIP-322 signature
-const validity = Verifier.verifySignature(address, message, signature)
-console.log(validity) // True
+const validity = Verifier.verifySignature(address, message, signature);
+console.log(validity); // True
 
 // You can also get the raw unsigned BIP-322 toSpend and toSign transaction directly
-const scriptPubKey = Buffer.from('00142b05d564e6a7a33c087f16e0f730d1440123799d', 'hex')
-const toSpend = BIP322.buildToSpendTx(message, scriptPubKey) // bitcoin.Transaction
-const toSpendTxId = toSpend.getId()
-const toSign = BIP322.buildToSignTx(toSpendTxId, scriptPubKey) // bitcoin.Psbt
+const scriptPubKey = Buffer.from('00142b05d564e6a7a33c087f16e0f730d1440123799d', 'hex');
+const toSpend = BIP322.buildToSpendTx(message, scriptPubKey); // bitcoin.Transaction
+const toSpendTxId = toSpend.getId();
+const toSign = BIP322.buildToSignTx(toSpendTxId, scriptPubKey); // bitcoin.Psbt
 // Do whatever you want to do with the PSBT
 ```
 
-More working examples can be found within the unit test for BIP322, Signer, and Verifier.
+More working examples can be found within the unit test for BIP322, Signer, and Verifier.

package/dist/BIP322.d.ts

@@ -1,9 +1,40 @@
-import * as bitcoin from '@exodus/bitcoinjs';
+/// <reference types="node" />
+import * as bitcoin from '@exodus/bitcoinjs-lib';
+/**
+ * Class that handles BIP-322 related operations.
+ * Reference: https://github.com/LegReq/bip0322-signatures/blob/master/BIP0322_signing.ipynb
+ */
 declare class BIP322 {
     static TAG: Buffer;
-    static hashMessage(message: string): Buffer;
+    /**
+     * Compute the message hash as specified in the BIP-322.
+     * The standard is specified in BIP-340 as:
+     *      The function hashtag(x) where tag is a UTF-8 encoded tag name and x is a byte array returns the 32-byte hash SHA256(SHA256(tag) || SHA256(tag) || x).
+     * @param message Message to be hashed
+     * @returns Hashed message
+     */
+    static hashMessage(message: string): any;
+    /**
+     * Build a to_spend transaction using simple signature in accordance to the BIP-322.
+     * @param message Message to be signed using BIP-322
+     * @param scriptPublicKey The script public key for the signing wallet
+     * @returns Bitcoin transaction that correspond to the to_spend transaction
+     */
     static buildToSpendTx(message: string, scriptPublicKey: Buffer): bitcoin.Transaction;
+    /**
+     * Build a to_sign transaction using simple signature in accordance to the BIP-322.
+     * @param toSpendTxId Transaction ID of the to_spend transaction as constructed by buildToSpendTx
+     * @param witnessScript The script public key for the signing wallet, or the redeemScript for P2SH-P2WPKH address
+     * @param isRedeemScript Set to true if the provided witnessScript is a redeemScript for P2SH-P2WPKH address, default to false
+     * @param tapInternalKey Used to set the taproot internal public key of a taproot signing address when provided, default to undefined
+     * @returns Ready-to-be-signed bitcoinjs.Psbt transaction
+     */
     static buildToSignTx(toSpendTxId: string, witnessScript: Buffer, isRedeemScript?: boolean, tapInternalKey?: Buffer): bitcoin.Psbt;
+    /**
+     * Encode witness stack in a signed BIP-322 PSBT into its base-64 encoded format.
+     * @param signedPsbt Signed PSBT
+     * @returns Base-64 encoded witness data
+     */
     static encodeWitness(signedPsbt: bitcoin.Psbt): string;
 }
 export default BIP322;

package/dist/BIP322.js

@@ -1,44 +1,108 @@
-import createHash from "create-hash";
-import * as bitcoin from '@exodus/bitcoinjs';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Import dependencies
+const create_hash_1 = __importDefault(require("create-hash"));
+const bitcoin = __importStar(require("@exodus/bitcoinjs-lib"));
+/**
+ * Class that handles BIP-322 related operations.
+ * Reference: https://github.com/LegReq/bip0322-signatures/blob/master/BIP0322_signing.ipynb
+ */
 class BIP322 {
-    static TAG = Buffer.from("BIP0322-signed-message");
+    /**
+     * Compute the message hash as specified in the BIP-322.
+     * The standard is specified in BIP-340 as:
+     *      The function hashtag(x) where tag is a UTF-8 encoded tag name and x is a byte array returns the 32-byte hash SHA256(SHA256(tag) || SHA256(tag) || x).
+     * @param message Message to be hashed
+     * @returns Hashed message
+     */
     static hashMessage(message) {
-        const tagHasher = createHash('sha256');
+        // Compute the message hash - SHA256(SHA256(tag) || SHA256(tag) || message)
+        const tagHasher = (0, create_hash_1.default)('sha256');
         tagHasher.update(this.TAG);
         const tagHash = tagHasher.digest();
-        const messageHasher = createHash('sha256');
+        const messageHasher = (0, create_hash_1.default)('sha256');
         messageHasher.update(tagHash);
         messageHasher.update(tagHash);
         messageHasher.update(Buffer.from(message));
         const messageHash = messageHasher.digest();
         return messageHash;
     }
+    /**
+     * Build a to_spend transaction using simple signature in accordance to the BIP-322.
+     * @param message Message to be signed using BIP-322
+     * @param scriptPublicKey The script public key for the signing wallet
+     * @returns Bitcoin transaction that correspond to the to_spend transaction
+     */
     static buildToSpendTx(message, scriptPublicKey) {
+        // Create PSBT object for constructing the transaction
         const psbt = new bitcoin.Psbt();
-        psbt.setVersion(0);
-        psbt.setLocktime(0);
+        // Set default value for nVersion and nLockTime
+        psbt.setVersion(0); // nVersion = 0
+        psbt.setLocktime(0); // nLockTime = 0
+        // Compute the message hash - SHA256(SHA256(tag) || SHA256(tag) || message)
         const messageHash = this.hashMessage(message);
-        const scriptSigPartOne = new Uint8Array([0x00, 0x20]);
+        // Construct the scriptSig - OP_0 PUSH32[ message_hash ]
+        const scriptSigPartOne = new Uint8Array([0x00, 0x20]); // OP_0 PUSH32
         const scriptSig = new Uint8Array(scriptSigPartOne.length + messageHash.length);
         scriptSig.set(scriptSigPartOne);
         scriptSig.set(messageHash, scriptSigPartOne.length);
+        // Set the input
         psbt.addInput({
             hash: '0'.repeat(64),
             index: 0xFFFFFFFF,
             sequence: 0,
             finalScriptSig: Buffer.from(scriptSig),
-            witnessScript: Buffer.from([])
+            witnessScript: Buffer.from([]) // vin[0].scriptWitness = []
         });
+        // Set the output
         psbt.addOutput({
             value: 0,
-            script: scriptPublicKey
+            script: scriptPublicKey // vout[0].scriptPubKey = message_challenge
         });
+        // Return transaction
         return psbt.extractTransaction();
     }
+    /**
+     * Build a to_sign transaction using simple signature in accordance to the BIP-322.
+     * @param toSpendTxId Transaction ID of the to_spend transaction as constructed by buildToSpendTx
+     * @param witnessScript The script public key for the signing wallet, or the redeemScript for P2SH-P2WPKH address
+     * @param isRedeemScript Set to true if the provided witnessScript is a redeemScript for P2SH-P2WPKH address, default to false
+     * @param tapInternalKey Used to set the taproot internal public key of a taproot signing address when provided, default to undefined
+     * @returns Ready-to-be-signed bitcoinjs.Psbt transaction
+     */
     static buildToSignTx(toSpendTxId, witnessScript, isRedeemScript = false, tapInternalKey = undefined) {
+        // Create PSBT object for constructing the transaction
         const psbt = new bitcoin.Psbt();
-        psbt.setVersion(0);
-        psbt.setLocktime(0);
+        // Set default value for nVersion and nLockTime
+        psbt.setVersion(0); // nVersion = 0
+        psbt.setLocktime(0); // nLockTime = 0
+        // Set the input
         psbt.addInput({
             hash: toSpendTxId,
             index: 0,
@@ -48,25 +112,36 @@ class BIP322 {
                 value: 0
             }
         });
+        // Set redeemScript as witnessScript if isRedeemScript
         if (isRedeemScript) {
             psbt.updateInput(0, {
                 redeemScript: witnessScript
             });
         }
+        // Set tapInternalKey if provided
         if (tapInternalKey) {
             psbt.updateInput(0, {
                 tapInternalKey: tapInternalKey
             });
         }
+        // Set the output
         psbt.addOutput({
             value: 0,
-            script: Buffer.from([0x6a])
+            script: Buffer.from([0x6a]) // vout[0].scriptPubKey = OP_RETURN
         });
         return psbt;
     }
+    /**
+     * Encode witness stack in a signed BIP-322 PSBT into its base-64 encoded format.
+     * @param signedPsbt Signed PSBT
+     * @returns Base-64 encoded witness data
+     */
     static encodeWitness(signedPsbt) {
+        // Obtain the signed witness data
         const witness = signedPsbt.data.inputs[0].finalScriptWitness;
+        // Check if the witness data is present
         if (witness) {
+            // Return the base-64 encoded witness stack
             return witness.toString('base64');
         }
         else {
@@ -74,5 +149,7 @@ class BIP322 {
         }
     }
 }
-export default BIP322;
+// BIP322 message tag
+BIP322.TAG = Buffer.from("BIP0322-signed-message");
+exports.default = BIP322;
 //# sourceMappingURL=BIP322.js.map

package/dist/Signer.d.ts

@@ -1,6 +1,25 @@
-import * as bitcoin from '@exodus/bitcoinjs';
+/// <reference types="node" />
+import * as bitcoin from '@exodus/bitcoinjs-lib';
+/**
+ * Class that signs BIP-322 signature using a private key.
+ * Reference: https://github.com/LegReq/bip0322-signatures/blob/master/BIP0322_signing.ipynb
+ */
 declare class Signer {
+    /**
+     * Sign a BIP-322 signature from P2WPKH, P2SH-P2WPKH, and single-key-spend P2TR address and its corresponding private key.
+     * @param privateKeyOrWIF
+     * @param address Address to be signing the message
+     * @param message message_challenge to be signed by the address
+     * @param network Network that the address is located, defaults to the Bitcoin mainnet
+     * @returns BIP-322 simple signature, encoded in base-64
+     */
     static sign(privateKeyOrWIF: string | Buffer, address: string, message: string, network?: bitcoin.Network): string | Buffer;
+    /**
+     * Check if a given public key is the public key for a claimed address.
+     * @param publicKey Public key to be tested
+     * @param claimedAddress Address claimed to be derived based on the provided public key
+     * @returns True if the claimedAddress can be derived by the provided publicKey, false if otherwise
+     */
     private static checkPubKeyCorrespondToAddress;
 }
 export default Signer;

package/dist/Signer.js

@@ -1,61 +1,126 @@
-import BIP322 from './BIP322';
-import { Address } from './helpers';
-import * as bitcoin from '@exodus/bitcoinjs';
-import * as bitcoinMessage from 'bitcoinjs-message';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Import dependencies
+const BIP322_1 = __importDefault(require("./BIP322"));
+const ecpair_1 = __importDefault(require("ecpair"));
+const helpers_1 = require("./helpers");
+const bitcoin = __importStar(require("@exodus/bitcoinjs-lib"));
+const bitcoinerlab_secp256k1_1 = __importDefault(require("@exodus/bitcoinerlab-secp256k1"));
+const bitcoinMessage = __importStar(require("bitcoinjs-message"));
+/**
+ * Class that signs BIP-322 signature using a private key.
+ * Reference: https://github.com/LegReq/bip0322-signatures/blob/master/BIP0322_signing.ipynb
+ */
 class Signer {
+    /**
+     * Sign a BIP-322 signature from P2WPKH, P2SH-P2WPKH, and single-key-spend P2TR address and its corresponding private key.
+     * @param privateKeyOrWIF
+     * @param address Address to be signing the message
+     * @param message message_challenge to be signed by the address
+     * @param network Network that the address is located, defaults to the Bitcoin mainnet
+     * @returns BIP-322 simple signature, encoded in base-64
+     */
     static sign(privateKeyOrWIF, address, message, network = bitcoin.networks.bitcoin) {
-        const ECPair = bitcoin.ECPair;
-        let signer = Buffer.isBuffer(privateKeyOrWIF)
-            ? ECPair.fromPrivateKey(privateKeyOrWIF)
-            : ECPair.fromWIF(privateKeyOrWIF, network);
+        // Initialize private key used to sign the transaction
+        const ECPair = (0, ecpair_1.default)(bitcoinerlab_secp256k1_1.default);
+        let signer = Buffer.isBuffer(privateKeyOrWIF) ? ECPair.fromPrivateKey(privateKeyOrWIF) : ECPair.fromWIF(privateKeyOrWIF, network);
+        // Check if the private key can sign message for the given address
         if (!this.checkPubKeyCorrespondToAddress(signer.publicKey, address)) {
             throw new Error(`Invalid private key provided for signing message for ${address}.`);
         }
-        if (Address.isP2PKH(address)) {
+        // Handle legacy P2PKH signature
+        if (helpers_1.Address.isP2PKH(address)) {
+            // For P2PKH address, sign a legacy signature
+            // Reference: https://github.com/bitcoinjs/bitcoinjs-message/blob/c43430f4c03c292c719e7801e425d887cbdf7464/README.md?plain=1#L21
             return bitcoinMessage.sign(message, signer.privateKey, signer.compressed);
         }
-        const scriptPubKey = Address.convertAdressToScriptPubkey(address);
-        const toSpendTx = BIP322.buildToSpendTx(message, scriptPubKey);
+        // Convert address into corresponding script pubkey
+        const scriptPubKey = helpers_1.Address.convertAdressToScriptPubkey(address);
+        // Draft corresponding toSpend using the message and script pubkey
+        const toSpendTx = BIP322_1.default.buildToSpendTx(message, scriptPubKey);
+        // Draft corresponding toSign transaction based on the address type
         let toSignTx;
-        if (Address.isP2SH(address)) {
+        if (helpers_1.Address.isP2SH(address)) {
+            // P2SH-P2WPKH signing path
+            // Derive the P2SH-P2WPKH redeemScript from the corresponding hashed public key
             const redeemScript = bitcoin.payments.p2wpkh({
                 hash: bitcoin.crypto.hash160(signer.publicKey),
-                network,
+                network: network
             }).output;
-            toSignTx = BIP322.buildToSignTx(toSpendTx.getId(), redeemScript, true);
+            toSignTx = BIP322_1.default.buildToSignTx(toSpendTx.getId(), redeemScript, true);
         }
-        else if (Address.isP2WPKH(address)) {
-            toSignTx = BIP322.buildToSignTx(toSpendTx.getId(), scriptPubKey);
+        else if (helpers_1.Address.isP2WPKH(address)) {
+            // P2WPKH signing path
+            toSignTx = BIP322_1.default.buildToSignTx(toSpendTx.getId(), scriptPubKey);
         }
         else {
+            // P2TR signing path
+            // Extract the taproot internal public key
             const internalPublicKey = signer.publicKey.subarray(1, 33);
+            // Tweak the private key for signing, since the output and address uses tweaked key
+            // Reference: https://github.com/bitcoinjs/bitcoinjs-lib/blob/1a9119b53bcea4b83a6aa8b948f0e6370209b1b4/test/integration/taproot.spec.ts#L55
             signer = signer.tweak(bitcoin.crypto.taggedHash('TapTweak', signer.publicKey.subarray(1, 33)));
-            toSignTx = BIP322.buildToSignTx(toSpendTx.getId(), scriptPubKey, false, internalPublicKey);
+            // Draft a toSign transaction that spends toSpend transaction
+            toSignTx = BIP322_1.default.buildToSignTx(toSpendTx.getId(), scriptPubKey, false, internalPublicKey);
         }
-        const toSignTxSigned = toSignTx
-            .signAllInputs(signer, [bitcoin.Transaction.SIGHASH_ALL, bitcoin.Transaction.SIGHASH_DEFAULT])
-            .finalizeAllInputs();
-        return BIP322.encodeWitness(toSignTxSigned);
+        // Sign the toSign transaction
+        const toSignTxSigned = toSignTx.signAllInputs(signer, [bitcoin.Transaction.SIGHASH_ALL, bitcoin.Transaction.SIGHASH_DEFAULT]).finalizeAllInputs();
+        // Extract and return the signature
+        return BIP322_1.default.encodeWitness(toSignTxSigned);
     }
+    /**
+     * Check if a given public key is the public key for a claimed address.
+     * @param publicKey Public key to be tested
+     * @param claimedAddress Address claimed to be derived based on the provided public key
+     * @returns True if the claimedAddress can be derived by the provided publicKey, false if otherwise
+     */
     static checkPubKeyCorrespondToAddress(publicKey, claimedAddress) {
+        // Derive the same address type from the provided public key
         let derivedAddresses;
-        if (Address.isP2PKH(claimedAddress)) {
-            derivedAddresses = Address.convertPubKeyIntoAddress(publicKey, 'p2pkh');
+        if (helpers_1.Address.isP2PKH(claimedAddress)) {
+            derivedAddresses = helpers_1.Address.convertPubKeyIntoAddress(publicKey, 'p2pkh');
         }
-        else if (Address.isP2SH(claimedAddress)) {
-            derivedAddresses = Address.convertPubKeyIntoAddress(publicKey, 'p2sh-p2wpkh');
+        else if (helpers_1.Address.isP2SH(claimedAddress)) {
+            derivedAddresses = helpers_1.Address.convertPubKeyIntoAddress(publicKey, 'p2sh-p2wpkh');
         }
-        else if (Address.isP2WPKH(claimedAddress)) {
-            derivedAddresses = Address.convertPubKeyIntoAddress(publicKey, 'p2wpkh');
+        else if (helpers_1.Address.isP2WPKH(claimedAddress)) {
+            derivedAddresses = helpers_1.Address.convertPubKeyIntoAddress(publicKey, 'p2wpkh');
         }
-        else if (Address.isP2TR(claimedAddress)) {
-            derivedAddresses = Address.convertPubKeyIntoAddress(publicKey, 'p2tr');
+        else if (helpers_1.Address.isP2TR(claimedAddress)) {
+            derivedAddresses = helpers_1.Address.convertPubKeyIntoAddress(publicKey, 'p2tr');
         }
         else {
-            throw new Error('Unable to sign BIP-322 message for unsupported address type.');
+            throw new Error('Unable to sign BIP-322 message for unsupported address type.'); // Unsupported address type
         }
-        return (derivedAddresses.mainnet === claimedAddress || derivedAddresses.testnet === claimedAddress);
+        // Check if the derived address correspond to the claimedAddress
+        return (derivedAddresses.mainnet === claimedAddress) || (derivedAddresses.testnet === claimedAddress);
     }
 }
-export default Signer;
+exports.default = Signer;
 //# sourceMappingURL=Signer.js.map

package/dist/Verifier.d.ts

@@ -1,8 +1,47 @@
+/**
+ * Class that handles BIP-322 signature verification.
+ * Reference: https://github.com/LegReq/bip0322-signatures/blob/master/BIP0322_verification.ipynb
+ */
 declare class Verifier {
+    /**
+     * Verify a BIP-322 signature from P2WPKH, P2SH-P2WPKH, and single-key-spend P2TR address.
+     * @param signerAddress Address of the signing address
+     * @param message message_challenge signed by the address
+     * @param signatureBase64 Signature produced by the signing address
+     * @returns True if the provided signature is a valid BIP-322 signature for the given message and address, false if otherwise
+     * @throws If the provided signature fails basic validation, or if unsupported address and signature are provided
+     */
     static verifySignature(signerAddress: string, message: string, signatureBase64: string): boolean;
+    /**
+     * Verify a legacy BIP-137 signature.
+     * Note that a signature is considered valid for all types of addresses that can be derived from the recovered public key.
+     * @param signerAddress Address of the signing address
+     * @param message message_challenge signed by the address
+     * @param signatureBase64 Signature produced by the signing address
+     * @returns True if the provided signature is a valid BIP-137 signature for the given message and address, false if otherwise
+     * @throws If the provided signature fails basic validation, or if unsupported address and signature are provided
+     */
     private static verifyBIP137Signature;
+    /**
+     * Compute the hash to be signed for a given P2WPKH BIP-322 toSign transaction.
+     * @param toSignTx PSBT instance of the toSign transaction
+     * @returns Computed transaction hash that requires signing
+     */
     private static getHashForSigP2WPKH;
+    /**
+     * Compute the hash to be signed for a given P2SH-P2WPKH BIP-322 toSign transaction.
+     * @param toSignTx PSBT instance of the toSign transaction
+     * @param hashedPubkey Hashed public key of the signing address
+     * @returns Computed transaction hash that requires signing
+     */
     private static getHashForSigP2SHInP2WPKH;
+    /**
+     * Compute the hash to be signed for a given P2TR BIP-322 toSign transaction.
+     * @param toSignTx PSBT instance of the toSign transaction
+     * @param hashType Hash type used to sign the toSign transaction, must be either 0x00 or 0x01
+     * @returns Computed transaction hash that requires signing
+     * @throws Error if hashType is anything other than 0x00 or 0x01
+     */
     private static getHashForSigP2TR;
 }
 export default Verifier;