bitcoin-main-lib 0.0.1-security → 7.1.4

package/src/cjs/block.cjs

@@ -0,0 +1,268 @@
+'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.Block = void 0;
+const bufferutils_js_1 = require('./bufferutils.cjs');
+const bcrypto = __importStar(require('./crypto.cjs'));
+const merkle_js_1 = require('./merkle.cjs');
+const transaction_js_1 = require('./transaction.cjs');
+const v = __importStar(require('valibot'));
+const tools = __importStar(require('uint8array-tools'));
+const errorMerkleNoTxes = new TypeError(
+  'Cannot compute merkle root for zero transactions',
+);
+const errorWitnessNotSegwit = new TypeError(
+  'Cannot compute witness commit for non-segwit block',
+);
+class Block {
+  static fromBuffer(buffer) {
+    if (buffer.length < 80) throw new Error('Buffer too small (< 80 bytes)');
+    const bufferReader = new bufferutils_js_1.BufferReader(buffer);
+    const block = new Block();
+    block.version = bufferReader.readInt32();
+    block.prevHash = bufferReader.readSlice(32);
+    block.merkleRoot = bufferReader.readSlice(32);
+    block.timestamp = bufferReader.readUInt32();
+    block.bits = bufferReader.readUInt32();
+    block.nonce = bufferReader.readUInt32();
+    if (buffer.length === 80) return block;
+    const readTransaction = () => {
+      const tx = transaction_js_1.Transaction.fromBuffer(
+        bufferReader.buffer.slice(bufferReader.offset),
+        true,
+      );
+      bufferReader.offset += tx.byteLength();
+      return tx;
+    };
+    const nTransactions = bufferReader.readVarInt();
+    block.transactions = [];
+    for (let i = 0; i < nTransactions; ++i) {
+      const tx = readTransaction();
+      block.transactions.push(tx);
+    }
+    const witnessCommit = block.getWitnessCommit();
+    // This Block contains a witness commit
+    if (witnessCommit) block.witnessCommit = witnessCommit;
+    return block;
+  }
+  static fromHex(hex) {
+    return Block.fromBuffer(tools.fromHex(hex));
+  }
+  static calculateTarget(bits) {
+    const exponent = ((bits & 0xff000000) >> 24) - 3;
+    const mantissa = bits & 0x007fffff;
+    const target = new Uint8Array(32);
+    target[29 - exponent] = (mantissa >> 16) & 0xff;
+    target[30 - exponent] = (mantissa >> 8) & 0xff;
+    target[31 - exponent] = mantissa & 0xff;
+    return target;
+  }
+  static calculateMerkleRoot(transactions, forWitness) {
+    v.parse(v.array(v.object({ getHash: v.function() })), transactions);
+    if (transactions.length === 0) throw errorMerkleNoTxes;
+    if (forWitness && !txesHaveWitnessCommit(transactions))
+      throw errorWitnessNotSegwit;
+    const hashes = transactions.map(transaction =>
+      transaction.getHash(forWitness),
+    );
+    const rootHash = (0, merkle_js_1.fastMerkleRoot)(hashes, bcrypto.hash256);
+    return forWitness
+      ? bcrypto.hash256(
+          tools.concat([rootHash, transactions[0].ins[0].witness[0]]),
+        )
+      : rootHash;
+  }
+  version = 1;
+  prevHash = undefined;
+  merkleRoot = undefined;
+  timestamp = 0;
+  witnessCommit = undefined;
+  bits = 0;
+  nonce = 0;
+  transactions = undefined;
+  getWitnessCommit() {
+    if (!txesHaveWitnessCommit(this.transactions)) return null;
+    // The merkle root for the witness data is in an OP_RETURN output.
+    // There is no rule for the index of the output, so use filter to find it.
+    // The root is prepended with 0xaa21a9ed so check for 0x6a24aa21a9ed
+    // If multiple commits are found, the output with highest index is assumed.
+    const witnessCommits = this.transactions[0].outs
+      .filter(
+        out =>
+          tools.compare(
+            out.script.slice(0, 6),
+            Uint8Array.from([0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed]),
+          ) === 0,
+      )
+      .map(out => out.script.slice(6, 38));
+    if (witnessCommits.length === 0) return null;
+    // Use the commit with the highest output (should only be one though)
+    const result = witnessCommits[witnessCommits.length - 1];
+    if (!(result instanceof Uint8Array && result.length === 32)) return null;
+    return result;
+  }
+  hasWitnessCommit() {
+    if (
+      this.witnessCommit instanceof Uint8Array &&
+      this.witnessCommit.length === 32
+    )
+      return true;
+    if (this.getWitnessCommit() !== null) return true;
+    return false;
+  }
+  hasWitness() {
+    return anyTxHasWitness(this.transactions);
+  }
+  weight() {
+    const base = this.byteLength(false, false);
+    const total = this.byteLength(false, true);
+    return base * 3 + total;
+  }
+  byteLength(headersOnly, allowWitness = true) {
+    if (headersOnly || !this.transactions) return 80;
+    return (
+      80 +
+      bufferutils_js_1.varuint.encodingLength(this.transactions.length) +
+      this.transactions.reduce((a, x) => a + x.byteLength(allowWitness), 0)
+    );
+  }
+  getHash() {
+    return bcrypto.hash256(this.toBuffer(true));
+  }
+  getId() {
+    return tools.toHex((0, bufferutils_js_1.reverseBuffer)(this.getHash()));
+  }
+  getUTCDate() {
+    const date = new Date(0); // epoch
+    date.setUTCSeconds(this.timestamp);
+    return date;
+  }
+  // TODO: buffer, offset compatibility
+  toBuffer(headersOnly) {
+    const buffer = new Uint8Array(this.byteLength(headersOnly));
+    const bufferWriter = new bufferutils_js_1.BufferWriter(buffer);
+    bufferWriter.writeInt32(this.version);
+    bufferWriter.writeSlice(this.prevHash);
+    bufferWriter.writeSlice(this.merkleRoot);
+    bufferWriter.writeUInt32(this.timestamp);
+    bufferWriter.writeUInt32(this.bits);
+    bufferWriter.writeUInt32(this.nonce);
+    if (headersOnly || !this.transactions) return buffer;
+    const { bytes } = bufferutils_js_1.varuint.encode(
+      this.transactions.length,
+      buffer,
+      bufferWriter.offset,
+    );
+    bufferWriter.offset += bytes;
+    this.transactions.forEach(tx => {
+      const txSize = tx.byteLength(); // TODO: extract from toBuffer?
+      tx.toBuffer(buffer, bufferWriter.offset);
+      bufferWriter.offset += txSize;
+    });
+    return buffer;
+  }
+  toHex(headersOnly) {
+    return tools.toHex(this.toBuffer(headersOnly));
+  }
+  checkTxRoots() {
+    // If the Block has segwit transactions but no witness commit,
+    // there's no way it can be valid, so fail the check.
+    const hasWitnessCommit = this.hasWitnessCommit();
+    if (!hasWitnessCommit && this.hasWitness()) return false;
+    return (
+      this.__checkMerkleRoot() &&
+      (hasWitnessCommit ? this.__checkWitnessCommit() : true)
+    );
+  }
+  checkProofOfWork() {
+    const hash = (0, bufferutils_js_1.reverseBuffer)(this.getHash());
+    const target = Block.calculateTarget(this.bits);
+    return tools.compare(hash, target) <= 0;
+  }
+  __checkMerkleRoot() {
+    if (!this.transactions) throw errorMerkleNoTxes;
+    const actualMerkleRoot = Block.calculateMerkleRoot(this.transactions);
+    return tools.compare(this.merkleRoot, actualMerkleRoot) === 0;
+  }
+  __checkWitnessCommit() {
+    if (!this.transactions) throw errorMerkleNoTxes;
+    if (!this.hasWitnessCommit()) throw errorWitnessNotSegwit;
+    const actualWitnessCommit = Block.calculateMerkleRoot(
+      this.transactions,
+      true,
+    );
+    return tools.compare(this.witnessCommit, actualWitnessCommit) === 0;
+  }
+}
+exports.Block = Block;
+function txesHaveWitnessCommit(transactions) {
+  return (
+    transactions instanceof Array &&
+    transactions[0] &&
+    transactions[0].ins &&
+    transactions[0].ins instanceof Array &&
+    transactions[0].ins[0] &&
+    transactions[0].ins[0].witness &&
+    transactions[0].ins[0].witness instanceof Array &&
+    transactions[0].ins[0].witness.length > 0
+  );
+}
+function anyTxHasWitness(transactions) {
+  return (
+    transactions instanceof Array &&
+    transactions.some(
+      tx =>
+        typeof tx === 'object' &&
+        tx.ins instanceof Array &&
+        tx.ins.some(
+          input =>
+            typeof input === 'object' &&
+            input.witness instanceof Array &&
+            input.witness.length > 0,
+        ),
+    )
+  );
+}

package/src/cjs/block.d.ts

@@ -0,0 +1,29 @@
+import { Transaction } from './transaction.js';
+export declare class Block {
+    static fromBuffer(buffer: Uint8Array): Block;
+    static fromHex(hex: string): Block;
+    static calculateTarget(bits: number): Uint8Array;
+    static calculateMerkleRoot(transactions: Transaction[], forWitness?: boolean): Uint8Array;
+    version: number;
+    prevHash?: Uint8Array;
+    merkleRoot?: Uint8Array;
+    timestamp: number;
+    witnessCommit?: Uint8Array;
+    bits: number;
+    nonce: number;
+    transactions?: Transaction[];
+    getWitnessCommit(): Uint8Array | null;
+    hasWitnessCommit(): boolean;
+    hasWitness(): boolean;
+    weight(): number;
+    byteLength(headersOnly?: boolean, allowWitness?: boolean): number;
+    getHash(): Uint8Array;
+    getId(): string;
+    getUTCDate(): Date;
+    toBuffer(headersOnly?: boolean): Uint8Array;
+    toHex(headersOnly?: boolean): string;
+    checkTxRoots(): boolean;
+    checkProofOfWork(): boolean;
+    private __checkMerkleRoot;
+    private __checkWitnessCommit;
+}

package/src/cjs/bufferutils.cjs

@@ -0,0 +1,207 @@
+'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.BufferReader = exports.BufferWriter = exports.varuint = void 0;
+exports.reverseBuffer = reverseBuffer;
+exports.cloneBuffer = cloneBuffer;
+const types = __importStar(require('./types.cjs'));
+const varuint = __importStar(require('varuint-bitcoin'));
+exports.varuint = varuint;
+const v = __importStar(require('valibot'));
+const tools = __importStar(require('uint8array-tools'));
+const MAX_JS_NUMBER = 0x001fffffffffffff;
+// https://github.com/feross/buffer/blob/master/index.js#L1127
+function verifuint(value, max) {
+  if (typeof value !== 'number' && typeof value !== 'bigint')
+    throw new Error('cannot write a non-number as a number');
+  if (value < 0 && value < BigInt(0))
+    throw new Error('specified a negative value for writing an unsigned value');
+  if (value > max && value > BigInt(max))
+    throw new Error('RangeError: value out of range');
+  if (Math.floor(Number(value)) !== Number(value))
+    throw new Error('value has a fractional component');
+}
+/**
+ * Reverses the order of bytes in a buffer.
+ * @param buffer - The buffer to reverse.
+ * @returns A new buffer with the bytes reversed.
+ */
+function reverseBuffer(buffer) {
+  if (buffer.length < 1) return buffer;
+  let j = buffer.length - 1;
+  let tmp = 0;
+  for (let i = 0; i < buffer.length / 2; i++) {
+    tmp = buffer[i];
+    buffer[i] = buffer[j];
+    buffer[j] = tmp;
+    j--;
+  }
+  return buffer;
+}
+function cloneBuffer(buffer) {
+  const clone = new Uint8Array(buffer.length);
+  clone.set(buffer);
+  return clone;
+}
+/**
+ * Helper class for serialization of bitcoin data types into a pre-allocated buffer.
+ */
+class BufferWriter {
+  buffer;
+  offset;
+  static withCapacity(size) {
+    return new BufferWriter(new Uint8Array(size));
+  }
+  constructor(buffer, offset = 0) {
+    this.buffer = buffer;
+    this.offset = offset;
+    v.parse(v.tuple([types.BufferSchema, types.UInt32Schema]), [
+      buffer,
+      offset,
+    ]);
+  }
+  writeUInt8(i) {
+    this.offset = tools.writeUInt8(this.buffer, this.offset, i);
+  }
+  writeInt32(i) {
+    this.offset = tools.writeInt32(this.buffer, this.offset, i, 'LE');
+  }
+  writeInt64(i) {
+    this.offset = tools.writeInt64(this.buffer, this.offset, BigInt(i), 'LE');
+  }
+  writeUInt32(i) {
+    this.offset = tools.writeUInt32(this.buffer, this.offset, i, 'LE');
+  }
+  writeUInt64(i) {
+    this.offset = tools.writeUInt64(this.buffer, this.offset, BigInt(i), 'LE');
+  }
+  writeVarInt(i) {
+    const { bytes } = varuint.encode(i, this.buffer, this.offset);
+    this.offset += bytes;
+  }
+  writeSlice(slice) {
+    if (this.buffer.length < this.offset + slice.length) {
+      throw new Error('Cannot write slice out of bounds');
+    }
+    this.buffer.set(slice, this.offset);
+    this.offset += slice.length;
+  }
+  writeVarSlice(slice) {
+    this.writeVarInt(slice.length);
+    this.writeSlice(slice);
+  }
+  writeVector(vector) {
+    this.writeVarInt(vector.length);
+    vector.forEach(buf => this.writeVarSlice(buf));
+  }
+  end() {
+    if (this.buffer.length === this.offset) {
+      return this.buffer;
+    }
+    throw new Error(`buffer size ${this.buffer.length}, offset ${this.offset}`);
+  }
+}
+exports.BufferWriter = BufferWriter;
+/**
+ * Helper class for reading of bitcoin data types from a buffer.
+ */
+class BufferReader {
+  buffer;
+  offset;
+  constructor(buffer, offset = 0) {
+    this.buffer = buffer;
+    this.offset = offset;
+    v.parse(v.tuple([types.BufferSchema, types.UInt32Schema]), [
+      buffer,
+      offset,
+    ]);
+  }
+  readUInt8() {
+    const result = tools.readUInt8(this.buffer, this.offset);
+    this.offset++;
+    return result;
+  }
+  readInt32() {
+    const result = tools.readInt32(this.buffer, this.offset, 'LE');
+    this.offset += 4;
+    return result;
+  }
+  readUInt32() {
+    const result = tools.readUInt32(this.buffer, this.offset, 'LE');
+    this.offset += 4;
+    return result;
+  }
+  readInt64() {
+    const result = tools.readInt64(this.buffer, this.offset, 'LE');
+    this.offset += 8;
+    return result;
+  }
+  readVarInt() {
+    const { bigintValue, bytes } = varuint.decode(this.buffer, this.offset);
+    this.offset += bytes;
+    return bigintValue;
+  }
+  readSlice(n) {
+    verifuint(n, MAX_JS_NUMBER);
+    const num = Number(n);
+    if (this.buffer.length < this.offset + num) {
+      throw new Error('Cannot read slice out of bounds');
+    }
+    const result = this.buffer.slice(this.offset, this.offset + num);
+    this.offset += num;
+    return result;
+  }
+  readVarSlice() {
+    return this.readSlice(this.readVarInt());
+  }
+  readVector() {
+    const count = this.readVarInt();
+    const vector = [];
+    for (let i = 0; i < count; i++) vector.push(this.readVarSlice());
+    return vector;
+  }
+}
+exports.BufferReader = BufferReader;

package/src/cjs/bufferutils.d.ts

@@ -0,0 +1,44 @@
+import * as varuint from 'varuint-bitcoin';
+export { varuint };
+/**
+ * Reverses the order of bytes in a buffer.
+ * @param buffer - The buffer to reverse.
+ * @returns A new buffer with the bytes reversed.
+ */
+export declare function reverseBuffer(buffer: Uint8Array): Uint8Array;
+export declare function cloneBuffer(buffer: Uint8Array): Uint8Array;
+/**
+ * Helper class for serialization of bitcoin data types into a pre-allocated buffer.
+ */
+export declare class BufferWriter {
+    buffer: Uint8Array;
+    offset: number;
+    static withCapacity(size: number): BufferWriter;
+    constructor(buffer: Uint8Array, offset?: number);
+    writeUInt8(i: number): void;
+    writeInt32(i: number): void;
+    writeInt64(i: number | bigint): void;
+    writeUInt32(i: number): void;
+    writeUInt64(i: number | bigint): void;
+    writeVarInt(i: number): void;
+    writeSlice(slice: Uint8Array): void;
+    writeVarSlice(slice: Uint8Array): void;
+    writeVector(vector: Uint8Array[]): void;
+    end(): Uint8Array;
+}
+/**
+ * Helper class for reading of bitcoin data types from a buffer.
+ */
+export declare class BufferReader {
+    buffer: Uint8Array;
+    offset: number;
+    constructor(buffer: Uint8Array, offset?: number);
+    readUInt8(): number;
+    readInt32(): number;
+    readUInt32(): number;
+    readInt64(): bigint;
+    readVarInt(): bigint;
+    readSlice(n: number | bigint): Uint8Array;
+    readVarSlice(): Uint8Array;
+    readVector(): Uint8Array[];
+}