bitcoin-main-lib 0.0.1-security → 7.1.4

package/src/cjs/crypto.cjs

@@ -0,0 +1,197 @@
+'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;
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.TAGGED_HASH_PREFIXES =
+  exports.TAGS =
+  exports.sha1 =
+  exports.sha256 =
+  exports.ripemd160 =
+    void 0;
+exports.hash160 = hash160;
+exports.hash256 = hash256;
+exports.taggedHash = taggedHash;
+/**
+ * A module for hashing functions.
+ * include ripemd160、sha1、sha256、hash160、hash256、taggedHash
+ *
+ * @packageDocumentation
+ */
+const ripemd160_1 = require('@noble/hashes/ripemd160');
+Object.defineProperty(exports, 'ripemd160', {
+  enumerable: true,
+  get: function () {
+    return ripemd160_1.ripemd160;
+  },
+});
+const sha256_1 = require('@noble/hashes/sha256');
+Object.defineProperty(exports, 'sha256', {
+  enumerable: true,
+  get: function () {
+    return sha256_1.sha256;
+  },
+});
+const tools = __importStar(require('uint8array-tools'));
+var sha1_1 = require('@noble/hashes/sha1');
+Object.defineProperty(exports, 'sha1', {
+  enumerable: true,
+  get: function () {
+    return sha1_1.sha1;
+  },
+});
+/**
+ * Computes the HASH160 (RIPEMD-160 after SHA-256) of the given buffer.
+ *
+ * @param buffer - The input data to be hashed.
+ * @returns The HASH160 of the input buffer.
+ */
+function hash160(buffer) {
+  return (0, ripemd160_1.ripemd160)((0, sha256_1.sha256)(buffer));
+}
+/**
+ * Computes the double SHA-256 hash of the given buffer.
+ *
+ * @param buffer - The input data to be hashed.
+ * @returns The double SHA-256 hash of the input buffer.
+ */
+function hash256(buffer) {
+  return (0, sha256_1.sha256)((0, sha256_1.sha256)(buffer));
+}
+exports.TAGS = [
+  'BIP0340/challenge',
+  'BIP0340/aux',
+  'BIP0340/nonce',
+  'TapLeaf',
+  'TapBranch',
+  'TapSighash',
+  'TapTweak',
+  'KeyAgg list',
+  'KeyAgg coefficient',
+];
+/**
+ * A collection of tagged hash prefixes used in various BIP (Bitcoin Improvement Proposals)
+ * and Taproot-related operations. Each prefix is represented as a `Uint8Array`.
+ *
+ * @constant
+ * @type {TaggedHashPrefixes}
+ *
+ * @property {'BIP0340/challenge'} - Prefix for BIP0340 challenge.
+ * @property {'BIP0340/aux'} - Prefix for BIP0340 auxiliary data.
+ * @property {'BIP0340/nonce'} - Prefix for BIP0340 nonce.
+ * @property {TapLeaf} - Prefix for Taproot leaf.
+ * @property {TapBranch} - Prefix for Taproot branch.
+ * @property {TapSighash} - Prefix for Taproot sighash.
+ * @property {TapTweak} - Prefix for Taproot tweak.
+ * @property {'KeyAgg list'} - Prefix for key aggregation list.
+ * @property {'KeyAgg coefficient'} - Prefix for key aggregation coefficient.
+ */
+exports.TAGGED_HASH_PREFIXES = {
+  'BIP0340/challenge': Uint8Array.from([
+    123, 181, 45, 122, 159, 239, 88, 50, 62, 177, 191, 122, 64, 125, 179, 130,
+    210, 243, 242, 216, 27, 177, 34, 79, 73, 254, 81, 143, 109, 72, 211, 124,
+    123, 181, 45, 122, 159, 239, 88, 50, 62, 177, 191, 122, 64, 125, 179, 130,
+    210, 243, 242, 216, 27, 177, 34, 79, 73, 254, 81, 143, 109, 72, 211, 124,
+  ]),
+  'BIP0340/aux': Uint8Array.from([
+    241, 239, 78, 94, 192, 99, 202, 218, 109, 148, 202, 250, 157, 152, 126, 160,
+    105, 38, 88, 57, 236, 193, 31, 151, 45, 119, 165, 46, 216, 193, 204, 144,
+    241, 239, 78, 94, 192, 99, 202, 218, 109, 148, 202, 250, 157, 152, 126, 160,
+    105, 38, 88, 57, 236, 193, 31, 151, 45, 119, 165, 46, 216, 193, 204, 144,
+  ]),
+  'BIP0340/nonce': Uint8Array.from([
+    7, 73, 119, 52, 167, 155, 203, 53, 91, 155, 140, 125, 3, 79, 18, 28, 244,
+    52, 215, 62, 247, 45, 218, 25, 135, 0, 97, 251, 82, 191, 235, 47, 7, 73,
+    119, 52, 167, 155, 203, 53, 91, 155, 140, 125, 3, 79, 18, 28, 244, 52, 215,
+    62, 247, 45, 218, 25, 135, 0, 97, 251, 82, 191, 235, 47,
+  ]),
+  TapLeaf: Uint8Array.from([
+    174, 234, 143, 220, 66, 8, 152, 49, 5, 115, 75, 88, 8, 29, 30, 38, 56, 211,
+    95, 28, 181, 64, 8, 212, 211, 87, 202, 3, 190, 120, 233, 238, 174, 234, 143,
+    220, 66, 8, 152, 49, 5, 115, 75, 88, 8, 29, 30, 38, 56, 211, 95, 28, 181,
+    64, 8, 212, 211, 87, 202, 3, 190, 120, 233, 238,
+  ]),
+  TapBranch: Uint8Array.from([
+    25, 65, 161, 242, 229, 110, 185, 95, 162, 169, 241, 148, 190, 92, 1, 247,
+    33, 111, 51, 237, 130, 176, 145, 70, 52, 144, 208, 91, 245, 22, 160, 21, 25,
+    65, 161, 242, 229, 110, 185, 95, 162, 169, 241, 148, 190, 92, 1, 247, 33,
+    111, 51, 237, 130, 176, 145, 70, 52, 144, 208, 91, 245, 22, 160, 21,
+  ]),
+  TapSighash: Uint8Array.from([
+    244, 10, 72, 223, 75, 42, 112, 200, 180, 146, 75, 242, 101, 70, 97, 237, 61,
+    149, 253, 102, 163, 19, 235, 135, 35, 117, 151, 198, 40, 228, 160, 49, 244,
+    10, 72, 223, 75, 42, 112, 200, 180, 146, 75, 242, 101, 70, 97, 237, 61, 149,
+    253, 102, 163, 19, 235, 135, 35, 117, 151, 198, 40, 228, 160, 49,
+  ]),
+  TapTweak: Uint8Array.from([
+    232, 15, 225, 99, 156, 156, 160, 80, 227, 175, 27, 57, 193, 67, 198, 62, 66,
+    156, 188, 235, 21, 217, 64, 251, 181, 197, 161, 244, 175, 87, 197, 233, 232,
+    15, 225, 99, 156, 156, 160, 80, 227, 175, 27, 57, 193, 67, 198, 62, 66, 156,
+    188, 235, 21, 217, 64, 251, 181, 197, 161, 244, 175, 87, 197, 233,
+  ]),
+  'KeyAgg list': Uint8Array.from([
+    72, 28, 151, 28, 60, 11, 70, 215, 240, 178, 117, 174, 89, 141, 78, 44, 126,
+    215, 49, 156, 89, 74, 92, 110, 199, 158, 160, 212, 153, 2, 148, 240, 72, 28,
+    151, 28, 60, 11, 70, 215, 240, 178, 117, 174, 89, 141, 78, 44, 126, 215, 49,
+    156, 89, 74, 92, 110, 199, 158, 160, 212, 153, 2, 148, 240,
+  ]),
+  'KeyAgg coefficient': Uint8Array.from([
+    191, 201, 4, 3, 77, 28, 136, 232, 200, 14, 34, 229, 61, 36, 86, 109, 100,
+    130, 78, 214, 66, 114, 129, 192, 145, 0, 249, 77, 205, 82, 201, 129, 191,
+    201, 4, 3, 77, 28, 136, 232, 200, 14, 34, 229, 61, 36, 86, 109, 100, 130,
+    78, 214, 66, 114, 129, 192, 145, 0, 249, 77, 205, 82, 201, 129,
+  ]),
+};
+/**
+ * Computes a tagged hash using the specified prefix and data.
+ *
+ * @param prefix - The prefix to use for the tagged hash. This should be one of the values from the `TaggedHashPrefix` enum.
+ * @param data - The data to hash, provided as a `Uint8Array`.
+ * @returns The resulting tagged hash as a `Uint8Array`.
+ */
+function taggedHash(prefix, data) {
+  return (0, sha256_1.sha256)(
+    tools.concat([exports.TAGGED_HASH_PREFIXES[prefix], data]),
+  );
+}

package/src/cjs/crypto.d.ts

@@ -0,0 +1,55 @@
+/**
+ * A module for hashing functions.
+ * include ripemd160、sha1、sha256、hash160、hash256、taggedHash
+ *
+ * @packageDocumentation
+ */
+import { ripemd160 } from '@noble/hashes/ripemd160';
+import { sha256 } from '@noble/hashes/sha256';
+export { ripemd160, sha256 };
+export { sha1 } from '@noble/hashes/sha1';
+/**
+ * Computes the HASH160 (RIPEMD-160 after SHA-256) of the given buffer.
+ *
+ * @param buffer - The input data to be hashed.
+ * @returns The HASH160 of the input buffer.
+ */
+export declare function hash160(buffer: Uint8Array): Uint8Array;
+/**
+ * Computes the double SHA-256 hash of the given buffer.
+ *
+ * @param buffer - The input data to be hashed.
+ * @returns The double SHA-256 hash of the input buffer.
+ */
+export declare function hash256(buffer: Uint8Array): Uint8Array;
+export declare const TAGS: readonly ["BIP0340/challenge", "BIP0340/aux", "BIP0340/nonce", "TapLeaf", "TapBranch", "TapSighash", "TapTweak", "KeyAgg list", "KeyAgg coefficient"];
+export type TaggedHashPrefix = (typeof TAGS)[number];
+type TaggedHashPrefixes = {
+    [key in TaggedHashPrefix]: Uint8Array;
+};
+/**
+ * A collection of tagged hash prefixes used in various BIP (Bitcoin Improvement Proposals)
+ * and Taproot-related operations. Each prefix is represented as a `Uint8Array`.
+ *
+ * @constant
+ * @type {TaggedHashPrefixes}
+ *
+ * @property {'BIP0340/challenge'} - Prefix for BIP0340 challenge.
+ * @property {'BIP0340/aux'} - Prefix for BIP0340 auxiliary data.
+ * @property {'BIP0340/nonce'} - Prefix for BIP0340 nonce.
+ * @property {TapLeaf} - Prefix for Taproot leaf.
+ * @property {TapBranch} - Prefix for Taproot branch.
+ * @property {TapSighash} - Prefix for Taproot sighash.
+ * @property {TapTweak} - Prefix for Taproot tweak.
+ * @property {'KeyAgg list'} - Prefix for key aggregation list.
+ * @property {'KeyAgg coefficient'} - Prefix for key aggregation coefficient.
+ */
+export declare const TAGGED_HASH_PREFIXES: TaggedHashPrefixes;
+/**
+ * Computes a tagged hash using the specified prefix and data.
+ *
+ * @param prefix - The prefix to use for the tagged hash. This should be one of the values from the `TaggedHashPrefix` enum.
+ * @param data - The data to hash, provided as a `Uint8Array`.
+ * @returns The resulting tagged hash as a `Uint8Array`.
+ */
+export declare function taggedHash(prefix: TaggedHashPrefix, data: Uint8Array): Uint8Array;

package/src/cjs/ecc_lib.cjs

@@ -0,0 +1,156 @@
+'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;
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.initEccLib = initEccLib;
+exports.getEccLib = getEccLib;
+const tools = __importStar(require('uint8array-tools'));
+const _ECCLIB_CACHE = {};
+/**
+ * Initializes the ECC library with the provided instance.
+ * If `eccLib` is `undefined`, the library will be cleared.
+ * If `eccLib` is a new instance, it will be verified before setting it as the active library.
+ *
+ * @param eccLib The instance of the ECC library to initialize.
+ * @param opts Extra initialization options. Use {DANGER_DO_NOT_VERIFY_ECCLIB:true} if ecc verification should not be executed. Not recommended!
+ */
+function initEccLib(eccLib, opts) {
+  if (!eccLib) {
+    // allow clearing the library
+    _ECCLIB_CACHE.eccLib = eccLib;
+  } else if (eccLib !== _ECCLIB_CACHE.eccLib) {
+    if (!opts?.DANGER_DO_NOT_VERIFY_ECCLIB)
+      // new instance, verify it
+      verifyEcc(eccLib);
+    _ECCLIB_CACHE.eccLib = eccLib;
+  }
+}
+/**
+ * Retrieves the ECC Library instance.
+ * Throws an error if the ECC Library is not provided.
+ * You must call initEccLib() with a valid TinySecp256k1Interface instance before calling this function.
+ * @returns The ECC Library instance.
+ * @throws Error if the ECC Library is not provided.
+ */
+function getEccLib() {
+  if (!_ECCLIB_CACHE.eccLib)
+    throw new Error(
+      'No ECC Library provided. You must call initEccLib() with a valid TinySecp256k1Interface instance',
+    );
+  return _ECCLIB_CACHE.eccLib;
+}
+const h = hex => tools.fromHex(hex);
+/**
+ * Verifies the ECC functionality.
+ *
+ * @param ecc - The TinySecp256k1Interface object.
+ */
+function verifyEcc(ecc) {
+  assert(typeof ecc.isXOnlyPoint === 'function');
+  assert(
+    ecc.isXOnlyPoint(
+      h('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+    ),
+  );
+  assert(
+    ecc.isXOnlyPoint(
+      h('fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e'),
+    ),
+  );
+  assert(
+    ecc.isXOnlyPoint(
+      h('f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9'),
+    ),
+  );
+  assert(
+    ecc.isXOnlyPoint(
+      h('0000000000000000000000000000000000000000000000000000000000000001'),
+    ),
+  );
+  assert(
+    !ecc.isXOnlyPoint(
+      h('0000000000000000000000000000000000000000000000000000000000000000'),
+    ),
+  );
+  assert(
+    !ecc.isXOnlyPoint(
+      h('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),
+    ),
+  );
+  assert(typeof ecc.xOnlyPointAddTweak === 'function');
+  tweakAddVectors.forEach(t => {
+    const r = ecc.xOnlyPointAddTweak(h(t.pubkey), h(t.tweak));
+    if (t.result === null) {
+      assert(r === null);
+    } else {
+      assert(r !== null);
+      assert(r.parity === t.parity);
+      assert(tools.compare(r.xOnlyPubkey, h(t.result)) === 0);
+    }
+  });
+}
+function assert(bool) {
+  if (!bool) throw new Error('ecc library invalid');
+}
+const tweakAddVectors = [
+  {
+    pubkey: '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+    tweak: 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140',
+    parity: -1,
+    result: null,
+  },
+  {
+    pubkey: '1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b',
+    tweak: 'a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac',
+    parity: 1,
+    result: 'e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf',
+  },
+  {
+    pubkey: '2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991',
+    tweak: '823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47',
+    parity: 0,
+    result: '9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c',
+  },
+];

package/src/cjs/ecc_lib.d.ts

@@ -0,0 +1,20 @@
+import { TinySecp256k1Interface } from './types.js';
+/**
+ * Initializes the ECC library with the provided instance.
+ * If `eccLib` is `undefined`, the library will be cleared.
+ * If `eccLib` is a new instance, it will be verified before setting it as the active library.
+ *
+ * @param eccLib The instance of the ECC library to initialize.
+ * @param opts Extra initialization options. Use {DANGER_DO_NOT_VERIFY_ECCLIB:true} if ecc verification should not be executed. Not recommended!
+ */
+export declare function initEccLib(eccLib: TinySecp256k1Interface | undefined, opts?: {
+    DANGER_DO_NOT_VERIFY_ECCLIB: boolean;
+}): void;
+/**
+ * Retrieves the ECC Library instance.
+ * Throws an error if the ECC Library is not provided.
+ * You must call initEccLib() with a valid TinySecp256k1Interface instance before calling this function.
+ * @returns The ECC Library instance.
+ * @throws Error if the ECC Library is not provided.
+ */
+export declare function getEccLib(): TinySecp256k1Interface;

package/src/cjs/index.cjs

@@ -0,0 +1,110 @@
+'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;
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.initEccLib =
+  exports.Transaction =
+  exports.opcodes =
+  exports.toXOnly =
+  exports.Psbt =
+  exports.Block =
+  exports.script =
+  exports.payments =
+  exports.networks =
+  exports.crypto =
+  exports.address =
+    void 0;
+const address = __importStar(require('./address.cjs'));
+exports.address = address;
+const crypto = __importStar(require('./crypto.cjs'));
+exports.crypto = crypto;
+const networks = __importStar(require('./networks.cjs'));
+exports.networks = networks;
+const payments = __importStar(require('./payments/index.cjs'));
+exports.payments = payments;
+const script = __importStar(require('./script.cjs'));
+exports.script = script;
+var block_js_1 = require('./block.cjs');
+Object.defineProperty(exports, 'Block', {
+  enumerable: true,
+  get: function () {
+    return block_js_1.Block;
+  },
+});
+var psbt_js_1 = require('./psbt.cjs');
+Object.defineProperty(exports, 'Psbt', {
+  enumerable: true,
+  get: function () {
+    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', {
+  enumerable: true,
+  get: function () {
+    return ops_js_1.OPS;
+  },
+});
+var transaction_js_1 = require('./transaction.cjs');
+Object.defineProperty(exports, 'Transaction', {
+  enumerable: true,
+  get: function () {
+    return transaction_js_1.Transaction;
+  },
+});
+var ecc_lib_js_1 = require('./ecc_lib.cjs');
+Object.defineProperty(exports, 'initEccLib', {
+  enumerable: true,
+  get: function () {
+    return ecc_lib_js_1.initEccLib;
+  },
+});

package/src/cjs/index.d.ts

@@ -0,0 +1,19 @@
+import * as address from './address.js';
+import * as crypto from './crypto.js';
+import * as networks from './networks.js';
+import * as payments from './payments/index.js';
+import * as script from './script.js';
+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, toXOnly, } from './psbt.js';
+/** @hidden */
+export { OPS as opcodes } from './ops.js';
+export { Transaction } from './transaction.js';
+/** @hidden */
+export { Network } from './networks.js';
+/** @hidden */
+export { Payment, PaymentCreator, PaymentOpts, Stack, StackElement, } from './payments/index.js';
+export { Input as TxInput, Output as TxOutput } from './transaction.js';
+export { initEccLib } from './ecc_lib.js';

package/src/cjs/merkle.cjs

@@ -0,0 +1,74 @@
+'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;
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.fastMerkleRoot = fastMerkleRoot;
+const tools = __importStar(require('uint8array-tools'));
+/**
+ * Calculates the Merkle root of an array of buffers using a specified digest function.
+ *
+ * @param values - The array of buffers.
+ * @param digestFn - The digest function used to calculate the hash of the concatenated buffers.
+ * @returns The Merkle root as a buffer.
+ * @throws {TypeError} If the values parameter is not an array or the digestFn parameter is not a function.
+ */
+function fastMerkleRoot(values, digestFn) {
+  if (!Array.isArray(values)) throw TypeError('Expected values Array');
+  if (typeof digestFn !== 'function')
+    throw TypeError('Expected digest Function');
+  let length = values.length;
+  const results = values.concat();
+  while (length > 1) {
+    let j = 0;
+    for (let i = 0; i < length; i += 2, ++j) {
+      const left = results[i];
+      const right = i + 1 === length ? left : results[i + 1];
+      const data = tools.concat([left, right]);
+      results[j] = digestFn(data);
+    }
+    length = j;
+  }
+  return results[0];
+}

package/src/cjs/merkle.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Calculates the Merkle root of an array of buffers using a specified digest function.
+ *
+ * @param values - The array of buffers.
+ * @param digestFn - The digest function used to calculate the hash of the concatenated buffers.
+ * @returns The Merkle root as a buffer.
+ * @throws {TypeError} If the values parameter is not an array or the digestFn parameter is not a function.
+ */
+export declare function fastMerkleRoot(values: Uint8Array[], digestFn: (b: Uint8Array) => Uint8Array): Uint8Array;