Merge branch 'master' of github.com:bitcoinjs/bitcoinjs-lib

Author: decentraldev1

src/cjs/index.cjs

@@ -47,6 +47,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 exports.initEccLib =
   exports.Transaction =
   exports.opcodes =
+  exports.toXOnly =
   exports.Psbt =
   exports.Block =
   exports.script =
@@ -79,6 +80,12 @@ Object.defineProperty(exports, 'Psbt', {
     return psbt_js_1.Psbt;
   },
 });
+Object.defineProperty(exports, 'toXOnly', {
+  enumerable: true,
+  get: function () {
+    return psbt_js_1.toXOnly;
+  },
+});
 /** @hidden */
 var ops_js_1 = require('./ops.cjs');
 Object.defineProperty(exports, 'opcodes', {

src/cjs/index.d.ts

@@ -7,7 +7,7 @@ export { address, crypto, networks, payments, script };
 export { Block } from './block.js';
 /** @hidden */
 export { TaggedHashPrefix } from './crypto.js';
-export { Psbt, PsbtTxInput, PsbtTxOutput, Signer, SignerAsync, HDSigner, HDSignerAsync, } from './psbt.js';
+export { Psbt, PsbtTxInput, PsbtTxOutput, Signer, SignerAsync, HDSigner, HDSignerAsync, toXOnly, } from './psbt.js';
 /** @hidden */
 export { OPS as opcodes } from './ops.js';
 export { Transaction } from './transaction.js';

src/cjs/networks.cjs

@@ -1,6 +1,4 @@
 'use strict';
-// https://en.bitcoin.it/wiki/List_of_address_prefixes
-// Dogecoin BIP32 is a proposed standard: https://bitcointalk.org/index.php?topic=409731
 Object.defineProperty(exports, '__esModule', { value: true });
 exports.testnet = exports.regtest = exports.bitcoin = void 0;
 /**

src/cjs/networks.d.ts

@@ -1,6 +1,11 @@
 /**
- * Represents a Bitcoin network configuration，including messagePrefix, bech32, bip32, pubKeyHash, scriptHash, wif.
- * Support bitcoin、bitcoin testnet and bitcoin regtest.
+ * This module defines the network configurations for Bitcoin and its variants, including message prefixes,
+ * Bech32 address format, BIP32 key derivation prefixes, and other address-related configurations.
+ * It supports Bitcoin, Bitcoin testnet, and Bitcoin regtest networks.
+ *
+ * Additional information on address prefixes can be found here:
+ * - https://en.bitcoin.it/wiki/List_of_address_prefixes
+ *
  * @packageDocumentation
  */
 export interface Network {

src/cjs/payments/index.d.ts

@@ -1,7 +1,15 @@
 /**
- * Represents a payment object, which is used to create a payment.
+ * Provides functionality for creating and managing Bitcoin payment objects.
  *
- * Supports P2PKH、P2SH、P2WPKH、P2WSH、P2TR and so on
+ * This module supports multiple Bitcoin address types for payments, including:
+ * - P2PKH (Pay-to-PubKey-Hash)
+ * - P2SH (Pay-to-Script-Hash)
+ * - P2WPKH (Pay-to-Witness-PubKey-Hash)
+ * - P2WSH (Pay-to-Witness-Script-Hash)
+ * - P2TR (Taproot)
+ *
+ * The `Payment` interface defines the structure of a payment object used for constructing various
+ * payment types, with fields for signatures, public keys, redeem scripts, and more.
  *
  * @packageDocumentation
  */

src/cjs/psbt.cjs

@@ -44,7 +44,7 @@ var __importStar =
     return result;
   };
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.Psbt = void 0;
+exports.Psbt = exports.toXOnly = void 0;
 const bip174_1 = require('bip174');
 const varuint = __importStar(require('varuint-bitcoin'));
 const bip174_2 = require('bip174');
@@ -56,6 +56,12 @@ const bip341_js_1 = require('./payments/bip341.cjs');
 const bscript = __importStar(require('./script.cjs'));
 const transaction_js_1 = require('./transaction.cjs');
 const bip371_js_1 = require('./psbt/bip371.cjs');
+Object.defineProperty(exports, 'toXOnly', {
+  enumerable: true,
+  get: function () {
+    return bip371_js_1.toXOnly;
+  },
+});
 const psbtutils_js_1 = require('./psbt/psbtutils.cjs');
 const tools = __importStar(require('uint8array-tools'));
 /**

src/cjs/psbt.d.ts

@@ -2,6 +2,8 @@ import { Psbt as PsbtBase } from 'bip174';
 import { KeyValue, PsbtGlobalUpdate, PsbtInput, PsbtInputUpdate, PsbtOutput, PsbtOutputUpdate } from 'bip174';
 import { Network } from './networks.js';
 import { Transaction } from './transaction.js';
+import { toXOnly } from './psbt/bip371.js';
+export { toXOnly };
 export interface TransactionInput {
     hash: string | Uint8Array;
     index: number;
@@ -202,4 +204,3 @@ tapLeafHashToFinalize?: Uint8Array) => {
     finalScriptWitness: Uint8Array | undefined;
 };
 type AllScriptType = 'witnesspubkeyhash' | 'pubkeyhash' | 'multisig' | 'pubkey' | 'nonstandard' | 'p2sh-witnesspubkeyhash' | 'p2sh-pubkeyhash' | 'p2sh-multisig' | 'p2sh-pubkey' | 'p2sh-nonstandard' | 'p2wsh-pubkeyhash' | 'p2wsh-multisig' | 'p2wsh-pubkey' | 'p2wsh-nonstandard' | 'p2sh-p2wsh-pubkeyhash' | 'p2sh-p2wsh-multisig' | 'p2sh-p2wsh-pubkey' | 'p2sh-p2wsh-nonstandard';
-export {};

src/cjs/psbt/bip371.cjs

@@ -283,7 +283,7 @@ function extractTaprootSigs(input) {
   if (input.tapScriptSig)
     sigs.push(...input.tapScriptSig.map(s => s.signature));
   if (!sigs.length) {
-    const finalTapKeySig = getTapKeySigFromWithness(input.finalScriptWitness);
+    const finalTapKeySig = getTapKeySigFromWitness(input.finalScriptWitness);
     if (finalTapKeySig) sigs.push(finalTapKeySig);
   }
   return sigs;
@@ -293,7 +293,7 @@ function extractTaprootSigs(input) {
  * @param finalScriptWitness The final script witness.
  * @returns The taproot signature, or undefined if not found.
  */
-function getTapKeySigFromWithness(finalScriptWitness) {
+function getTapKeySigFromWitness(finalScriptWitness) {
   if (!finalScriptWitness) return;
   const witness = finalScriptWitness.slice(2);
   // todo: add schnorr signature validation

src/cjs/script.cjs

@@ -1,4 +1,11 @@
 'use strict';
+/**
+ * Script tools module for working with Bitcoin scripts.
+ * Provides utilities such as decompiling, compiling, converting to/from ASM, stack manipulation,
+ * and script validation functions.
+ *
+ * @packageDocumentation
+ */
 var __createBinding =
   (this && this.__createBinding) ||
   (Object.create
@@ -55,10 +62,6 @@ exports.toStack = toStack;
 exports.isCanonicalPubKey = isCanonicalPubKey;
 exports.isDefinedHashType = isDefinedHashType;
 exports.isCanonicalScriptSignature = isCanonicalScriptSignature;
-/**
- * Script tools, including decompile, compile, toASM, fromASM, toStack, isCanonicalPubKey, isCanonicalScriptSignature
- * @packageDocumentation
- */
 const bip66 = __importStar(require('./bip66.cjs'));
 const ops_js_1 = require('./ops.cjs');
 Object.defineProperty(exports, 'OPS', {
@@ -73,8 +76,16 @@ const scriptSignature = __importStar(require('./script_signature.cjs'));
 const types = __importStar(require('./types.cjs'));
 const tools = __importStar(require('uint8array-tools'));
 const v = __importStar(require('valibot'));
+/** Base opcode for OP_INT values. */
 const OP_INT_BASE = ops_js_1.OPS.OP_RESERVED; // OP_1 - 1
+/** Validation schema for a Bitcoin script stack. */
 const StackSchema = v.array(v.union([v.instance(Uint8Array), v.number()]));
+/**
+ * Determines if a value corresponds to an OP_INT opcode.
+ *
+ * @param value - The opcode to check.
+ * @returns True if the value is an OP_INT, false otherwise.
+ */
 function isOPInt(value) {
   return (
     v.is(v.number(), value) &&
@@ -83,57 +94,95 @@ function isOPInt(value) {
       value === ops_js_1.OPS.OP_1NEGATE)
   );
 }
+/**
+ * Checks if a script chunk is push-only (contains only data or OP_INT opcodes).
+ *
+ * @param value - The chunk to check.
+ * @returns True if the chunk is push-only, false otherwise.
+ */
 function isPushOnlyChunk(value) {
   return v.is(types.BufferSchema, value) || isOPInt(value);
 }
+/**
+ * Determines if a stack consists of only push operations.
+ *
+ * @param value - The stack to check.
+ * @returns True if all elements in the stack are push-only, false otherwise.
+ */
 function isPushOnly(value) {
   return v.is(v.pipe(v.any(), v.everyItem(isPushOnlyChunk)), value);
 }
+/**
+ * Counts the number of non-push-only opcodes in a stack.
+ *
+ * @param value - The stack to analyze.
+ * @returns The count of non-push-only opcodes.
+ */
 function countNonPushOnlyOPs(value) {
   return value.length - value.filter(isPushOnlyChunk).length;
 }
+/**
+ * Converts a minimal script buffer to its corresponding opcode, if applicable.
+ *
+ * @param buffer - The buffer to check.
+ * @returns The corresponding opcode or undefined if not minimal.
+ */
 function asMinimalOP(buffer) {
   if (buffer.length === 0) return ops_js_1.OPS.OP_0;
   if (buffer.length !== 1) return;
   if (buffer[0] >= 1 && buffer[0] <= 16) return OP_INT_BASE + buffer[0];
   if (buffer[0] === 0x81) return ops_js_1.OPS.OP_1NEGATE;
 }
+/**
+ * Determines if a buffer or stack is a Uint8Array.
+ *
+ * @param buf - The buffer or stack to check.
+ * @returns True if the input is a Uint8Array, false otherwise.
+ */
 function chunksIsBuffer(buf) {
   return buf instanceof Uint8Array;
 }
+/**
+ * Determines if a buffer or stack is a valid stack.
+ *
+ * @param buf - The buffer or stack to check.
+ * @returns True if the input is a stack, false otherwise.
+ */
 function chunksIsArray(buf) {
   return v.is(StackSchema, buf);
 }
+/**
+ * Determines if a single chunk is a Uint8Array.
+ *
+ * @param buf - The chunk to check.
+ * @returns True if the chunk is a Uint8Array, false otherwise.
+ */
 function singleChunkIsBuffer(buf) {
   return buf instanceof Uint8Array;
 }
 /**
- * Compiles an array of chunks into a Buffer.
+ * Compiles an array of script chunks into a Uint8Array.
  *
- * @param chunks - The array of chunks to compile.
- * @returns The compiled Buffer.
- * @throws Error if the compilation fails.
+ * @param chunks - The chunks to compile.
+ * @returns The compiled script as a Uint8Array.
+ * @throws Error if compilation fails.
  */
 function compile(chunks) {
-  // TODO: remove me
   if (chunksIsBuffer(chunks)) return chunks;
   v.parse(StackSchema, chunks);
   const bufferSize = chunks.reduce((accum, chunk) => {
-    // data chunk
     if (singleChunkIsBuffer(chunk)) {
       // adhere to BIP62.3, minimal push policy
       if (chunk.length === 1 && asMinimalOP(chunk) !== undefined) {
         return accum + 1;
       }
       return accum + pushdata.encodingLength(chunk.length) + chunk.length;
     }
-    // opcode
     return accum + 1;
-  }, 0.0);
+  }, 0);
   const buffer = new Uint8Array(bufferSize);
   let offset = 0;
   chunks.forEach(chunk => {
-    // data chunk
     if (singleChunkIsBuffer(chunk)) {
       // adhere to BIP62.3, minimal push policy
       const opcode = asMinimalOP(chunk);
@@ -154,15 +203,19 @@ function compile(chunks) {
   if (offset !== buffer.length) throw new Error('Could not decode chunks');
   return buffer;
 }
+/**
+ * Decompiles a script buffer into an array of chunks.
+ *
+ * @param buffer - The script buffer to decompile.
+ * @returns The decompiled chunks or null if decompilation fails.
+ */
 function decompile(buffer) {
-  // TODO: remove me
   if (chunksIsArray(buffer)) return buffer;
   v.parse(types.BufferSchema, buffer);
   const chunks = [];
   let i = 0;
   while (i < buffer.length) {
     const opcode = buffer[i];
-    // data chunk
     if (opcode > ops_js_1.OPS.OP_0 && opcode <= ops_js_1.OPS.OP_PUSHDATA4) {
       const d = pushdata.decode(buffer, i);
       // did reading a pushDataInt fail?
@@ -179,7 +232,6 @@ function decompile(buffer) {
       } else {
         chunks.push(data);
       }
-      // opcode
     } else {
       chunks.push(opcode);
       i += 1;
@@ -202,7 +254,6 @@ function toASM(chunks) {
   }
   return chunks
     .map(chunk => {
-      // data?
       if (singleChunkIsBuffer(chunk)) {
         const op = asMinimalOP(chunk);
         if (op === undefined) return tools.toHex(chunk);
@@ -249,13 +300,36 @@ function toStack(chunks) {
     return scriptNumber.encode(op - OP_INT_BASE);
   });
 }
+/**
+ * Checks if the provided buffer is a canonical public key.
+ *
+ * @param buffer - The buffer to check, expected to be a Uint8Array.
+ * @returns A boolean indicating whether the buffer is a canonical public key.
+ */
 function isCanonicalPubKey(buffer) {
   return types.isPoint(buffer);
 }
+/**
+ * Checks if the provided hash type is defined.
+ *
+ * A hash type is considered defined if its modified value (after masking with ~0x80)
+ * is greater than 0x00 and less than 0x04.
+ *
+ * @param hashType - The hash type to check.
+ * @returns True if the hash type is defined, false otherwise.
+ */
 function isDefinedHashType(hashType) {
   const hashTypeMod = hashType & ~0x80;
   return hashTypeMod > 0x00 && hashTypeMod < 0x04;
 }
+/**
+ * Checks if the provided buffer is a canonical script signature.
+ *
+ * A canonical script signature is a valid DER-encoded signature followed by a valid hash type byte.
+ *
+ * @param buffer - The buffer to check.
+ * @returns `true` if the buffer is a canonical script signature, `false` otherwise.
+ */
 function isCanonicalScriptSignature(buffer) {
   if (!(buffer instanceof Uint8Array)) return false;
   if (!isDefinedHashType(buffer[buffer.length - 1])) return false;