@btc-vision/bitcoin 6.3.0

package/src/bip66.js

@@ -0,0 +1,103 @@
+'use strict';
+// Reference https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki
+// Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
+// NOTE: SIGHASH byte ignored AND restricted, truncate before use
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.encode = exports.decode = exports.check = void 0;
+function check(buffer) {
+    if (buffer.length < 8) return false;
+    if (buffer.length > 72) return false;
+    if (buffer[0] !== 0x30) return false;
+    if (buffer[1] !== buffer.length - 2) return false;
+    if (buffer[2] !== 0x02) return false;
+    const lenR = buffer[3];
+    if (lenR === 0) return false;
+    if (5 + lenR >= buffer.length) return false;
+    if (buffer[4 + lenR] !== 0x02) return false;
+    const lenS = buffer[5 + lenR];
+    if (lenS === 0) return false;
+    if (6 + lenR + lenS !== buffer.length) return false;
+    if (buffer[4] & 0x80) return false;
+    if (lenR > 1 && buffer[4] === 0x00 && !(buffer[5] & 0x80)) return false;
+    if (buffer[lenR + 6] & 0x80) return false;
+    if (lenS > 1 && buffer[lenR + 6] === 0x00 && !(buffer[lenR + 7] & 0x80))
+        return false;
+    return true;
+}
+exports.check = check;
+function decode(buffer) {
+    if (buffer.length < 8) throw new Error('DER sequence length is too short');
+    if (buffer.length > 72) throw new Error('DER sequence length is too long');
+    if (buffer[0] !== 0x30) throw new Error('Expected DER sequence');
+    if (buffer[1] !== buffer.length - 2)
+        throw new Error('DER sequence length is invalid');
+    if (buffer[2] !== 0x02) throw new Error('Expected DER integer');
+    const lenR = buffer[3];
+    if (lenR === 0) throw new Error('R length is zero');
+    if (5 + lenR >= buffer.length) throw new Error('R length is too long');
+    if (buffer[4 + lenR] !== 0x02) throw new Error('Expected DER integer (2)');
+    const lenS = buffer[5 + lenR];
+    if (lenS === 0) throw new Error('S length is zero');
+    if (6 + lenR + lenS !== buffer.length)
+        throw new Error('S length is invalid');
+    if (buffer[4] & 0x80) throw new Error('R value is negative');
+    if (lenR > 1 && buffer[4] === 0x00 && !(buffer[5] & 0x80))
+        throw new Error('R value excessively padded');
+    if (buffer[lenR + 6] & 0x80) throw new Error('S value is negative');
+    if (lenS > 1 && buffer[lenR + 6] === 0x00 && !(buffer[lenR + 7] & 0x80))
+        throw new Error('S value excessively padded');
+    // non-BIP66 - extract R, S values
+    return {
+        r: buffer.slice(4, 4 + lenR),
+        s: buffer.slice(6 + lenR),
+    };
+}
+exports.decode = decode;
+/*
+ * Expects r and s to be positive DER integers.
+ *
+ * The DER format uses the most significant bit as a sign bit (& 0x80).
+ * If the significant bit is set AND the integer is positive, a 0x00 is prepended.
+ *
+ * Examples:
+ *
+ *      0 =>     0x00
+ *      1 =>     0x01
+ *     -1 =>     0xff
+ *    127 =>     0x7f
+ *   -127 =>     0x81
+ *    128 =>   0x0080
+ *   -128 =>     0x80
+ *    255 =>   0x00ff
+ *   -255 =>   0xff01
+ *  16300 =>   0x3fac
+ * -16300 =>   0xc054
+ *  62300 => 0x00f35c
+ * -62300 => 0xff0ca4
+ */
+function encode(r, s) {
+    const lenR = r.length;
+    const lenS = s.length;
+    if (lenR === 0) throw new Error('R length is zero');
+    if (lenS === 0) throw new Error('S length is zero');
+    if (lenR > 33) throw new Error('R length is too long');
+    if (lenS > 33) throw new Error('S length is too long');
+    if (r[0] & 0x80) throw new Error('R value is negative');
+    if (s[0] & 0x80) throw new Error('S value is negative');
+    if (lenR > 1 && r[0] === 0x00 && !(r[1] & 0x80))
+        throw new Error('R value excessively padded');
+    if (lenS > 1 && s[0] === 0x00 && !(s[1] & 0x80))
+        throw new Error('S value excessively padded');
+    const signature = Buffer.allocUnsafe(6 + lenR + lenS);
+    // 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
+    signature[0] = 0x30;
+    signature[1] = signature.length - 2;
+    signature[2] = 0x02;
+    signature[3] = r.length;
+    r.copy(signature, 4);
+    signature[4 + lenR] = 0x02;
+    signature[5 + lenR] = s.length;
+    s.copy(signature, 6 + lenR);
+    return signature;
+}
+exports.encode = encode;

package/src/block.d.ts

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

package/src/block.js

@@ -0,0 +1,224 @@
+'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');
+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 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_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(Buffer.from(hex, 'hex'));
+    }
+    static calculateTarget(bits) {
+        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) {
+        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);
+        return forWitness
+            ? bcrypto.hash256(
+                  Buffer.concat([rootHash, transactions[0].ins[0].witness[0]]),
+              )
+            : rootHash;
+    }
+    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 =>
+                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;
+        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_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 (0, bufferutils_1.reverseBuffer)(this.getHash()).toString('hex');
+    }
+    getUTCDate() {
+        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);
+        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;
+        bufferutils_1.varuint.encode(
+            this.transactions.length,
+            buffer,
+            bufferWriter.offset,
+        );
+        bufferWriter.offset += bufferutils_1.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) {
+        return this.toBuffer(headersOnly).toString('hex');
+    }
+    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_1.reverseBuffer)(this.getHash());
+        const target = Block.calculateTarget(this.bits);
+        return hash.compare(target) <= 0;
+    }
+    __checkMerkleRoot() {
+        if (!this.transactions) throw errorMerkleNoTxes;
+        const actualMerkleRoot = Block.calculateMerkleRoot(this.transactions);
+        return this.merkleRoot.compare(actualMerkleRoot) === 0;
+    }
+    __checkWitnessCommit() {
+        if (!this.transactions) throw errorMerkleNoTxes;
+        if (!this.hasWitnessCommit()) throw errorWitnessNotSegwit;
+        const actualWitnessCommit = Block.calculateMerkleRoot(
+            this.transactions,
+            true,
+        );
+        return this.witnessCommit.compare(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/bufferutils.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import * as varuint from 'varuint-bitcoin';
+export { varuint };
+export declare function readUInt64LE(buffer: Buffer, offset: number): number;
+/**
+ * Writes a 64-bit unsigned integer in little-endian format to the specified buffer at the given offset.
+ *
+ * @param buffer - The buffer to write the value to.
+ * @param value - The 64-bit unsigned integer value to write.
+ * @param offset - The offset in the buffer where the value should be written.
+ * @returns The new offset after writing the value.
+ */
+export declare function writeUInt64LE(buffer: Buffer, value: number, offset: number): number;
+/**
+ * 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: Buffer): Buffer;
+export declare function cloneBuffer(buffer: Buffer): Buffer;
+/**
+ * Helper class for serialization of bitcoin data types into a pre-allocated buffer.
+ */
+export declare class BufferWriter {
+    buffer: Buffer;
+    offset: number;
+    constructor(buffer: Buffer, offset?: number);
+    static withCapacity(size: number): BufferWriter;
+    writeUInt8(i: number): void;
+    writeInt32(i: number): void;
+    writeUInt32(i: number): void;
+    writeUInt64(i: number): void;
+    writeVarInt(i: number): void;
+    writeSlice(slice: Buffer): void;
+    writeVarSlice(slice: Buffer): void;
+    writeVector(vector: Buffer[]): void;
+    end(): Buffer;
+}
+/**
+ * Helper class for reading of bitcoin data types from a buffer.
+ */
+export declare class BufferReader {
+    buffer: Buffer;
+    offset: number;
+    constructor(buffer: Buffer, offset?: number);
+    readUInt8(): number;
+    readInt32(): number;
+    readUInt32(): number;
+    readUInt64(): number;
+    readVarInt(): number;
+    readSlice(n: number): Buffer;
+    readVarSlice(): Buffer;
+    readVector(): Buffer[];
+}

package/src/bufferutils.js

@@ -0,0 +1,182 @@
+'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;
+const { typeforce } = types;
+// 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',
+        );
+    if (value > max) throw new Error('RangeError: value out of range');
+    if (Math.floor(value) !== value)
+        throw new Error('value has a fractional component');
+}
+function readUInt64LE(buffer, offset) {
+    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.
+ *
+ * @param buffer - The buffer to write the value to.
+ * @param value - The 64-bit unsigned integer value to write.
+ * @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) {
+    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) {
+    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;
+}
+exports.reverseBuffer = reverseBuffer;
+function cloneBuffer(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;
+        typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);
+    }
+    static withCapacity(size) {
+        return new BufferWriter(Buffer.alloc(size));
+    }
+    writeUInt8(i) {
+        this.offset = this.buffer.writeUInt8(i, this.offset);
+    }
+    writeInt32(i) {
+        this.offset = this.buffer.writeInt32LE(i, this.offset);
+    }
+    writeUInt32(i) {
+        this.offset = this.buffer.writeUInt32LE(i, this.offset);
+    }
+    writeUInt64(i) {
+        this.offset = writeUInt64LE(this.buffer, i, this.offset);
+    }
+    writeVarInt(i) {
+        varuint.encode(i, this.buffer, this.offset);
+        this.offset += varuint.encode.bytes;
+    }
+    writeSlice(slice) {
+        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) {
+        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;
+        typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);
+    }
+    readUInt8() {
+        const result = this.buffer.readUInt8(this.offset);
+        this.offset++;
+        return result;
+    }
+    readInt32() {
+        const result = this.buffer.readInt32LE(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    readUInt32() {
+        const result = this.buffer.readUInt32LE(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    readUInt64() {
+        const result = readUInt64LE(this.buffer, this.offset);
+        this.offset += 8;
+        return result;
+    }
+    readVarInt() {
+        const vi = varuint.decode(this.buffer, this.offset);
+        this.offset += varuint.decode.bytes;
+        return vi;
+    }
+    readSlice(n) {
+        if (this.buffer.length < this.offset + n) {
+            throw new Error('Cannot read slice out of bounds');
+        }
+        const result = this.buffer.slice(this.offset, this.offset + n);
+        this.offset += n;
+        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/crypto.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+export declare function ripemd160(buffer: Buffer): Buffer;
+export declare function sha1(buffer: Buffer): Buffer;
+export declare function sha256(buffer: Buffer): Buffer;
+export declare function hash160(buffer: Buffer): Buffer;
+export declare function hash256(buffer: Buffer): Buffer;
+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]: Buffer;
+};
+/** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */
+/**
+ * Defines the tagged hash prefixes used in the crypto module.
+ */
+export declare const TAGGED_HASH_PREFIXES: TaggedHashPrefixes;
+export declare function taggedHash(prefix: TaggedHashPrefix, data: Buffer): Buffer;
+export {};