@exodus/bip322-js 1.1.0-exodus.6 → 1.1.0-rc.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,40 +1,9 @@
-/// <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
- */
+import * as bitcoin from '@exodus/bitcoinjs';
 declare class BIP322 {
     static TAG: 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 hashMessage(message: string): Buffer;
     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,108 +1,44 @@
-"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
- */
+import createHash from "create-hash";
+import * as bitcoin from '@exodus/bitcoinjs';
 class BIP322 {
-    /**
-     * 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 TAG = Buffer.from("BIP0322-signed-message");
     static hashMessage(message) {
-        // Compute the message hash - SHA256(SHA256(tag) || SHA256(tag) || message)
-        const tagHasher = (0, create_hash_1.default)('sha256');
+        const tagHasher = createHash('sha256');
         tagHasher.update(this.TAG);
         const tagHash = tagHasher.digest();
-        const messageHasher = (0, create_hash_1.default)('sha256');
+        const messageHasher = createHash('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();
-        // 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)
+        psbt.setVersion(0);
+        psbt.setLocktime(0);
         const messageHash = this.hashMessage(message);
-        // Construct the scriptSig - OP_0 PUSH32[ message_hash ]
-        const scriptSigPartOne = new Uint8Array([0x00, 0x20]); // OP_0 PUSH32
+        const scriptSigPartOne = new Uint8Array([0x00, 0x20]);
         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([]) // vin[0].scriptWitness = []
+            witnessScript: Buffer.from([])
         });
-        // Set the output
         psbt.addOutput({
             value: 0,
-            script: scriptPublicKey // vout[0].scriptPubKey = message_challenge
+            script: scriptPublicKey
         });
-        // 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();
-        // Set default value for nVersion and nLockTime
-        psbt.setVersion(0); // nVersion = 0
-        psbt.setLocktime(0); // nLockTime = 0
-        // Set the input
+        psbt.setVersion(0);
+        psbt.setLocktime(0);
         psbt.addInput({
             hash: toSpendTxId,
             index: 0,
@@ -112,36 +48,25 @@ 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]) // vout[0].scriptPubKey = OP_RETURN
+            script: Buffer.from([0x6a])
         });
         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 {
@@ -149,7 +74,5 @@ class BIP322 {
         }
     }
 }
-// BIP322 message tag
-BIP322.TAG = Buffer.from("BIP0322-signed-message");
-exports.default = BIP322;
+export default BIP322;
 //# sourceMappingURL=BIP322.js.map

package/dist/Signer.d.ts

@@ -1,25 +1,6 @@
-/// <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
- */
+import * as bitcoin from '@exodus/bitcoinjs';
 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,126 +1,61 @@
-"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
- */
+import BIP322 from './BIP322';
+import { Address } from './helpers';
+import * as bitcoin from '@exodus/bitcoinjs';
+import * as bitcoinMessage from 'bitcoinjs-message';
 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) {
-        // 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
+        const ECPair = bitcoin.ECPair;
+        let signer = Buffer.isBuffer(privateKeyOrWIF)
+            ? ECPair.fromPrivateKey(privateKeyOrWIF)
+            : ECPair.fromWIF(privateKeyOrWIF, network);
         if (!this.checkPubKeyCorrespondToAddress(signer.publicKey, address)) {
             throw new Error(`Invalid private key provided for signing message for ${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
+        if (Address.isP2PKH(address)) {
             return bitcoinMessage.sign(message, signer.privateKey, signer.compressed);
         }
-        // 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
+        const scriptPubKey = Address.convertAdressToScriptPubkey(address);
+        const toSpendTx = BIP322.buildToSpendTx(message, scriptPubKey);
         let toSignTx;
-        if (helpers_1.Address.isP2SH(address)) {
-            // P2SH-P2WPKH signing path
-            // Derive the P2SH-P2WPKH redeemScript from the corresponding hashed public key
+        if (Address.isP2SH(address)) {
             const redeemScript = bitcoin.payments.p2wpkh({
                 hash: bitcoin.crypto.hash160(signer.publicKey),
-                network: network
+                network,
             }).output;
-            toSignTx = BIP322_1.default.buildToSignTx(toSpendTx.getId(), redeemScript, true);
+            toSignTx = BIP322.buildToSignTx(toSpendTx.getId(), redeemScript, true);
         }
-        else if (helpers_1.Address.isP2WPKH(address)) {
-            // P2WPKH signing path
-            toSignTx = BIP322_1.default.buildToSignTx(toSpendTx.getId(), scriptPubKey);
+        else if (Address.isP2WPKH(address)) {
+            toSignTx = BIP322.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)));
-            // Draft a toSign transaction that spends toSpend transaction
-            toSignTx = BIP322_1.default.buildToSignTx(toSpendTx.getId(), scriptPubKey, false, internalPublicKey);
+            toSignTx = BIP322.buildToSignTx(toSpendTx.getId(), scriptPubKey, false, internalPublicKey);
         }
-        // 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);
+        const toSignTxSigned = toSignTx
+            .signAllInputs(signer, [bitcoin.Transaction.SIGHASH_ALL, bitcoin.Transaction.SIGHASH_DEFAULT])
+            .finalizeAllInputs();
+        return BIP322.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 (helpers_1.Address.isP2PKH(claimedAddress)) {
-            derivedAddresses = helpers_1.Address.convertPubKeyIntoAddress(publicKey, 'p2pkh');
+        if (Address.isP2PKH(claimedAddress)) {
+            derivedAddresses = Address.convertPubKeyIntoAddress(publicKey, 'p2pkh');
         }
-        else if (helpers_1.Address.isP2SH(claimedAddress)) {
-            derivedAddresses = helpers_1.Address.convertPubKeyIntoAddress(publicKey, 'p2sh-p2wpkh');
+        else if (Address.isP2SH(claimedAddress)) {
+            derivedAddresses = Address.convertPubKeyIntoAddress(publicKey, 'p2sh-p2wpkh');
         }
-        else if (helpers_1.Address.isP2WPKH(claimedAddress)) {
-            derivedAddresses = helpers_1.Address.convertPubKeyIntoAddress(publicKey, 'p2wpkh');
+        else if (Address.isP2WPKH(claimedAddress)) {
+            derivedAddresses = Address.convertPubKeyIntoAddress(publicKey, 'p2wpkh');
         }
-        else if (helpers_1.Address.isP2TR(claimedAddress)) {
-            derivedAddresses = helpers_1.Address.convertPubKeyIntoAddress(publicKey, 'p2tr');
+        else if (Address.isP2TR(claimedAddress)) {
+            derivedAddresses = Address.convertPubKeyIntoAddress(publicKey, 'p2tr');
         }
         else {
-            throw new Error('Unable to sign BIP-322 message for unsupported address type.'); // Unsupported address type
+            throw new Error('Unable to sign BIP-322 message for unsupported address type.');
         }
-        // Check if the derived address correspond to the claimedAddress
-        return (derivedAddresses.mainnet === claimedAddress) || (derivedAddresses.testnet === claimedAddress);
+        return (derivedAddresses.mainnet === claimedAddress || derivedAddresses.testnet === claimedAddress);
     }
 }
-exports.default = Signer;
+export default Signer;
 //# sourceMappingURL=Signer.js.map

package/dist/Verifier.d.ts

@@ -1,47 +1,8 @@
-/**
- * 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;