@btc-vision/bitcoin 6.3.1 → 6.3.2

package/src/{block.js → block.ts}

@@ -1,31 +1,29 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.Block = void 0;
-const bufferutils_1 = require('./bufferutils');
-const bcrypto = require('./crypto');
-const merkle_1 = require('./merkle');
-const transaction_1 = require('./transaction');
-const types = require('./types');
+import { BufferReader, BufferWriter, reverseBuffer, varuint } from './bufferutils.js';
+import * as bcrypto from './crypto.js';
+import { fastMerkleRoot } from './merkle.js';
+import { Transaction } from './transaction.js';
+import * as types from './types.js';
+
 const { typeforce } = types;
-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 {
-    version = 1;
-    prevHash = undefined;
-    merkleRoot = undefined;
-    timestamp = 0;
-    witnessCommit = undefined;
-    bits = 0;
-    nonce = 0;
-    transactions = undefined;
-    static fromBuffer(buffer) {
-        if (buffer.length < 80)
-            throw new Error('Buffer too small (< 80 bytes)');
-        const bufferReader = new bufferutils_1.BufferReader(buffer);
+
+const errorMerkleNoTxes = new TypeError('Cannot compute merkle root for zero transactions');
+const errorWitnessNotSegwit = new TypeError('Cannot compute witness commit for non-segwit block');
+
+export class Block {
+    version: number = 1;
+    prevHash?: Buffer = undefined;
+    merkleRoot?: Buffer = undefined;
+    timestamp: number = 0;
+    witnessCommit?: Buffer = undefined;
+    bits: number = 0;
+    nonce: number = 0;
+    transactions?: Transaction[] = undefined;
+
+    static fromBuffer(buffer: Buffer): Block {
+        if (buffer.length < 80) throw new Error('Buffer too small (< 80 bytes)');
+
+        const bufferReader = new BufferReader(buffer);
+
         const block = new Block();
         block.version = bufferReader.readInt32();
         block.prevHash = bufferReader.readSlice(32);
@@ -33,168 +31,178 @@ class Block {
         block.timestamp = bufferReader.readUInt32();
         block.bits = bufferReader.readUInt32();
         block.nonce = bufferReader.readUInt32();
+
         if (buffer.length === 80) return block;
-        const readTransaction = () => {
-            const tx = transaction_1.Transaction.fromBuffer(
-                bufferReader.buffer.slice(bufferReader.offset),
-                true,
-            );
+
+        const readTransaction = (): any => {
+            const tx = 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) {
+
+    static fromHex(hex: string): Block {
         return Block.fromBuffer(Buffer.from(hex, 'hex'));
     }
-    static calculateTarget(bits) {
+
+    static calculateTarget(bits: number): Buffer {
         const exponent = ((bits & 0xff000000) >> 24) - 3;
         const mantissa = bits & 0x007fffff;
         const target = Buffer.alloc(32, 0);
         target.writeUIntBE(mantissa, 29 - exponent, 3);
         return target;
     }
-    static calculateMerkleRoot(transactions, forWitness) {
+
+    static calculateMerkleRoot(transactions: Transaction[], forWitness?: boolean): Buffer {
         typeforce([{ getHash: types.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_1.fastMerkleRoot)(hashes, bcrypto.hash256);
+        if (forWitness && !txesHaveWitnessCommit(transactions)) throw errorWitnessNotSegwit;
+
+        const hashes = transactions.map((transaction) => transaction.getHash(forWitness!));
+
+        const rootHash = fastMerkleRoot(hashes, bcrypto.hash256);
+
         return forWitness
-            ? bcrypto.hash256(
-                  Buffer.concat([rootHash, transactions[0].ins[0].witness[0]]),
-              )
+            ? bcrypto.hash256(Buffer.concat([rootHash, transactions[0].ins[0].witness[0]]))
             : rootHash;
     }
-    getWitnessCommit() {
-        if (!txesHaveWitnessCommit(this.transactions)) return null;
+
+    getWitnessCommit(): Buffer | null {
+        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 =>
-                out.script
-                    .slice(0, 6)
-                    .equals(Buffer.from('6a24aa21a9ed', 'hex')),
-            )
-            .map(out => out.script.slice(6, 38));
+        const witnessCommits = this.transactions![0].outs.filter((out) =>
+            out.script.slice(0, 6).equals(Buffer.from('6a24aa21a9ed', 'hex')),
+        ).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 Buffer && result.length === 32)) return null;
         return result;
     }
-    hasWitnessCommit() {
-        if (
-            this.witnessCommit instanceof Buffer &&
-            this.witnessCommit.length === 32
-        )
-            return true;
+
+    hasWitnessCommit(): boolean {
+        if (this.witnessCommit instanceof Buffer && this.witnessCommit.length === 32) return true;
         if (this.getWitnessCommit() !== null) return true;
         return false;
     }
-    hasWitness() {
-        return anyTxHasWitness(this.transactions);
+
+    hasWitness(): boolean {
+        return anyTxHasWitness(this.transactions!);
     }
-    weight() {
+
+    weight(): number {
         const base = this.byteLength(false, false);
         const total = this.byteLength(false, true);
         return base * 3 + total;
     }
-    byteLength(headersOnly, allowWitness = true) {
+
+    byteLength(headersOnly?: boolean, allowWitness: boolean = true): number {
         if (headersOnly || !this.transactions) return 80;
+
         return (
             80 +
-            bufferutils_1.varuint.encodingLength(this.transactions.length) +
-            this.transactions.reduce(
-                (a, x) => a + x.byteLength(allowWitness),
-                0,
-            )
+            varuint.encodingLength(this.transactions.length) +
+            this.transactions.reduce((a, x) => a + x.byteLength(allowWitness), 0)
         );
     }
-    getHash() {
+
+    getHash(): Buffer {
         return bcrypto.hash256(this.toBuffer(true));
     }
-    getId() {
-        return (0, bufferutils_1.reverseBuffer)(this.getHash()).toString('hex');
+
+    getId(): string {
+        return reverseBuffer(this.getHash()).toString('hex');
     }
-    getUTCDate() {
+
+    getUTCDate(): Date {
         const date = new Date(0); // epoch
         date.setUTCSeconds(this.timestamp);
+
         return date;
     }
+
     // TODO: buffer, offset compatibility
-    toBuffer(headersOnly) {
-        const buffer = Buffer.allocUnsafe(this.byteLength(headersOnly));
-        const bufferWriter = new bufferutils_1.BufferWriter(buffer);
+    toBuffer(headersOnly?: boolean): Buffer {
+        const buffer: Buffer = Buffer.allocUnsafe(this.byteLength(headersOnly));
+
+        const bufferWriter = new BufferWriter(buffer);
+
         bufferWriter.writeInt32(this.version);
-        bufferWriter.writeSlice(this.prevHash);
-        bufferWriter.writeSlice(this.merkleRoot);
+        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;
-        bufferutils_1.varuint.encode(
-            this.transactions.length,
-            buffer,
-            bufferWriter.offset,
-        );
-        bufferWriter.offset += bufferutils_1.varuint.encode.bytes;
-        this.transactions.forEach(tx => {
+
+        varuint.encode(this.transactions.length, buffer, bufferWriter.offset);
+        bufferWriter.offset += varuint.encode.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) {
+
+    toHex(headersOnly?: boolean): string {
         return this.toBuffer(headersOnly).toString('hex');
     }
-    checkTxRoots() {
+
+    checkTxRoots(): boolean {
         // 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)
-        );
+        return this.__checkMerkleRoot() && (hasWitnessCommit ? this.__checkWitnessCommit() : true);
     }
-    checkProofOfWork() {
-        const hash = (0, bufferutils_1.reverseBuffer)(this.getHash());
+
+    checkProofOfWork(): boolean {
+        const hash: Buffer = reverseBuffer(this.getHash());
         const target = Block.calculateTarget(this.bits);
+
         return hash.compare(target) <= 0;
     }
-    __checkMerkleRoot() {
+
+    private __checkMerkleRoot(): boolean {
         if (!this.transactions) throw errorMerkleNoTxes;
+
         const actualMerkleRoot = Block.calculateMerkleRoot(this.transactions);
-        return this.merkleRoot.compare(actualMerkleRoot) === 0;
+        return this.merkleRoot!.compare(actualMerkleRoot) === 0;
     }
-    __checkWitnessCommit() {
+
+    private __checkWitnessCommit(): boolean {
         if (!this.transactions) throw errorMerkleNoTxes;
         if (!this.hasWitnessCommit()) throw errorWitnessNotSegwit;
-        const actualWitnessCommit = Block.calculateMerkleRoot(
-            this.transactions,
-            true,
-        );
-        return this.witnessCommit.compare(actualWitnessCommit) === 0;
+
+        const actualWitnessCommit = Block.calculateMerkleRoot(this.transactions, true);
+        return this.witnessCommit!.compare(actualWitnessCommit) === 0;
     }
 }
-exports.Block = Block;
-function txesHaveWitnessCommit(transactions) {
+
+function txesHaveWitnessCommit(transactions: Transaction[]): boolean {
     return (
         transactions instanceof Array &&
         transactions[0] &&
@@ -206,15 +214,16 @@ function txesHaveWitnessCommit(transactions) {
         transactions[0].ins[0].witness.length > 0
     );
 }
-function anyTxHasWitness(transactions) {
+
+function anyTxHasWitness(transactions: Transaction[]): boolean {
     return (
         transactions instanceof Array &&
         transactions.some(
-            tx =>
+            (tx) =>
                 typeof tx === 'object' &&
                 tx.ins instanceof Array &&
                 tx.ins.some(
-                    input =>
+                    (input) =>
                         typeof input === 'object' &&
                         input.witness instanceof Array &&
                         input.witness.length > 0,

package/src/{bufferutils.js → bufferutils.ts}

@@ -1,37 +1,27 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.BufferReader =
-    exports.BufferWriter =
-    exports.cloneBuffer =
-    exports.reverseBuffer =
-    exports.writeUInt64LE =
-    exports.readUInt64LE =
-    exports.varuint =
-        void 0;
-const types = require('./types');
-const varuint = require('varuint-bitcoin');
-exports.varuint = varuint;
+import * as varuint from 'varuint-bitcoin';
+import * as types from './types.js';
+
 const { typeforce } = types;
+
+export { varuint };
+
 // https://github.com/feross/buffer/blob/master/index.js#L1127
-function verifuint(value, max) {
-    if (typeof value !== 'number')
-        throw new Error('cannot write a non-number as a number');
-    if (value < 0)
-        throw new Error(
-            'specified a negative value for writing an unsigned value',
-        );
+function verifuint(value: number, max: number): void {
+    if (typeof value !== 'number') throw new Error('cannot write a non-number as a number');
+    if (value < 0) throw new Error('specified a negative value for writing an unsigned value');
     if (value > max) throw new Error('RangeError: value out of range');
-    if (Math.floor(value) !== value)
-        throw new Error('value has a fractional component');
+    if (Math.floor(value) !== value) throw new Error('value has a fractional component');
 }
-function readUInt64LE(buffer, offset) {
+
+export function readUInt64LE(buffer: Buffer, offset: number): number {
     const a = buffer.readUInt32LE(offset);
     let b = buffer.readUInt32LE(offset + 4);
     b *= 0x100000000;
+
     verifuint(b + a, 0x001fffffffffffff);
     return b + a;
 }
-exports.readUInt64LE = readUInt64LE;
+
 /**
  * Writes a 64-bit unsigned integer in little-endian format to the specified buffer at the given offset.
  *
@@ -40,19 +30,20 @@ exports.readUInt64LE = readUInt64LE;
  * @param offset - The offset in the buffer where the value should be written.
  * @returns The new offset after writing the value.
  */
-function writeUInt64LE(buffer, value, offset) {
+export function writeUInt64LE(buffer: Buffer, value: number, offset: number): number {
     verifuint(value, 0x001fffffffffffff);
+
     buffer.writeInt32LE(value & -1, offset);
     buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4);
     return offset + 8;
 }
-exports.writeUInt64LE = writeUInt64LE;
+
 /**
  * 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) {
+export function reverseBuffer(buffer: Buffer): Buffer {
     if (buffer.length < 1) return buffer;
     let j = buffer.length - 1;
     let tmp = 0;
@@ -64,104 +55,110 @@ function reverseBuffer(buffer) {
     }
     return buffer;
 }
-exports.reverseBuffer = reverseBuffer;
-function cloneBuffer(buffer) {
+
+export function cloneBuffer(buffer: Buffer): Buffer {
     const clone = Buffer.allocUnsafe(buffer.length);
     buffer.copy(clone);
     return clone;
 }
-exports.cloneBuffer = cloneBuffer;
+
 /**
  * Helper class for serialization of bitcoin data types into a pre-allocated buffer.
  */
-class BufferWriter {
-    buffer;
-    offset;
-    constructor(buffer, offset = 0) {
-        this.buffer = buffer;
-        this.offset = offset;
+export class BufferWriter {
+    constructor(public buffer: Buffer, public offset: number = 0) {
         typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);
     }
-    static withCapacity(size) {
+
+    static withCapacity(size: number): BufferWriter {
         return new BufferWriter(Buffer.alloc(size));
     }
-    writeUInt8(i) {
+
+    writeUInt8(i: number): void {
         this.offset = this.buffer.writeUInt8(i, this.offset);
     }
-    writeInt32(i) {
+
+    writeInt32(i: number): void {
         this.offset = this.buffer.writeInt32LE(i, this.offset);
     }
-    writeUInt32(i) {
+
+    writeUInt32(i: number): void {
         this.offset = this.buffer.writeUInt32LE(i, this.offset);
     }
-    writeUInt64(i) {
+
+    writeUInt64(i: number): void {
         this.offset = writeUInt64LE(this.buffer, i, this.offset);
     }
-    writeVarInt(i) {
+
+    writeVarInt(i: number): void {
         varuint.encode(i, this.buffer, this.offset);
         this.offset += varuint.encode.bytes;
     }
-    writeSlice(slice) {
+
+    writeSlice(slice: Buffer): void {
         if (this.buffer.length < this.offset + slice.length) {
             throw new Error('Cannot write slice out of bounds');
         }
         this.offset += slice.copy(this.buffer, this.offset);
     }
-    writeVarSlice(slice) {
+
+    writeVarSlice(slice: Buffer): void {
         this.writeVarInt(slice.length);
         this.writeSlice(slice);
     }
-    writeVector(vector) {
+
+    writeVector(vector: Buffer[]): void {
         this.writeVarInt(vector.length);
-        vector.forEach(buf => this.writeVarSlice(buf));
+        vector.forEach((buf: Buffer) => this.writeVarSlice(buf));
     }
-    end() {
+
+    end(): Buffer {
         if (this.buffer.length === this.offset) {
             return this.buffer;
         }
-        throw new Error(
-            `buffer size ${this.buffer.length}, offset ${this.offset}`,
-        );
+        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;
+export class BufferReader {
+    constructor(public buffer: Buffer, public offset: number = 0) {
         typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);
     }
-    readUInt8() {
+
+    readUInt8(): number {
         const result = this.buffer.readUInt8(this.offset);
         this.offset++;
         return result;
     }
-    readInt32() {
+
+    readInt32(): number {
         const result = this.buffer.readInt32LE(this.offset);
         this.offset += 4;
         return result;
     }
-    readUInt32() {
+
+    readUInt32(): number {
         const result = this.buffer.readUInt32LE(this.offset);
         this.offset += 4;
         return result;
     }
-    readUInt64() {
+
+    readUInt64(): number {
         const result = readUInt64LE(this.buffer, this.offset);
         this.offset += 8;
         return result;
     }
-    readVarInt() {
+
+    readVarInt(): number {
         const vi = varuint.decode(this.buffer, this.offset);
         this.offset += varuint.decode.bytes;
         return vi;
     }
-    readSlice(n) {
+
+    readSlice(n: number): Buffer {
         if (this.buffer.length < this.offset + n) {
             throw new Error('Cannot read slice out of bounds');
         }
@@ -169,14 +166,15 @@ class BufferReader {
         this.offset += n;
         return result;
     }
-    readVarSlice() {
+
+    readVarSlice(): Buffer {
         return this.readSlice(this.readVarInt());
     }
-    readVector() {
+
+    readVector(): Buffer[] {
         const count = this.readVarInt();
-        const vector = [];
+        const vector: Buffer[] = [];
         for (let i = 0; i < count; i++) vector.push(this.readVarSlice());
         return vector;
     }
 }
-exports.BufferReader = BufferReader;

package/src/crypto/crypto-browser.js

@@ -0,0 +1,75 @@
+/* Browser Crypto Shims */
+import { hmac } from '@noble/hashes/hmac';
+import { pbkdf2 } from '@noble/hashes/pbkdf2';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha512 } from '@noble/hashes/sha512';
+import assert from 'assert';
+
+function assertArgument(check, message, name, value) {
+    assert(check, message, 'INVALID_ARGUMENT', { argument: name, value: value });
+}
+
+function getGlobal() {
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof global !== 'undefined') {
+        return global;
+    }
+    throw new Error('unable to locate global object');
+}
+
+const anyGlobal = getGlobal();
+const crypto = anyGlobal.crypto || anyGlobal.msCrypto;
+
+export function createHash(algo) {
+    switch (algo) {
+        case 'sha256':
+            return sha256.create();
+        case 'sha512':
+            return sha512.create();
+    }
+    assertArgument(false, 'invalid hashing algorithm name', 'algorithm', algo);
+}
+
+export function createHmac(_algo, key) {
+    const algo = { sha256, sha512 }[_algo];
+    assertArgument(algo != null, 'invalid hmac algorithm', 'algorithm', _algo);
+    return hmac.create(algo, key);
+}
+
+export function pbkdf2Sync(password, salt, iterations, keylen, _algo) {
+    const algo = { sha256, sha512 }[_algo];
+    assertArgument(algo != null, 'invalid pbkdf2 algorithm', 'algorithm', _algo);
+    return pbkdf2(algo, password, salt, { c: iterations, dkLen: keylen });
+}
+
+export function randomBytes(length) {
+    assert(
+        crypto != null,
+        'platform does not support secure random numbers',
+        'UNSUPPORTED_OPERATION',
+        {
+            operation: 'randomBytes',
+        },
+    );
+    assertArgument(
+        Number.isInteger(length) && length > 0 && length <= 1024,
+        'invalid length',
+        'length',
+        length,
+    );
+    const result = new Uint8Array(length);
+    crypto.getRandomValues(result);
+    return result;
+}
+
+export default {
+    createHash,
+    createHmac,
+    pbkdf2Sync,
+    randomBytes,
+};

package/src/crypto/crypto.ts

@@ -0,0 +1 @@
+export { createHash, createHmac, pbkdf2Sync, randomBytes } from 'crypto';