@btc-vision/bitcoin 6.3.0 → 6.3.2

package/{src → browser}/types.d.ts

@@ -1,54 +1,37 @@
-/// <reference types="node" />
-export declare const typeforce: any;
-/**
- * Checks if two arrays of Buffers are equal.
- * @param a - The first array of Buffers.
- * @param b - The second array of Buffers.
- * @returns True if the arrays are equal, false otherwise.
- */
-export declare function stacksEqual(a: Buffer[], b: Buffer[]): boolean;
-/**
- * Checks if the given value is a valid elliptic curve point.
- * @param p - The value to check.
- * @returns True if the value is a valid elliptic curve point, false otherwise.
- */
-export declare function isPoint(p: Buffer | number | undefined | null): boolean;
-export declare function Satoshi(value: number): boolean;
-export interface XOnlyPointAddTweakResult {
-    parity: 1 | 0;
-    xOnlyPubkey: Uint8Array;
-}
-export interface Tapleaf {
-    output: Buffer;
-    version?: number;
-}
-export declare const TAPLEAF_VERSION_MASK = 254;
-export declare function isTapleaf(o: any): o is Tapleaf;
-/**
- * Binary tree repsenting script path spends for a Taproot input.
- * Each node is either a single Tapleaf, or a pair of Tapleaf | Taptree.
- * The tree has no balancing requirements.
- */
-export type Taptree = [Taptree | Tapleaf, Taptree | Tapleaf] | Tapleaf;
-export declare function isTaptree(scriptTree: any): scriptTree is Taptree;
-export interface TinySecp256k1Interface {
-    isXOnlyPoint(p: Uint8Array): boolean;
-    xOnlyPointAddTweak(p: Uint8Array, tweak: Uint8Array): XOnlyPointAddTweakResult | null;
-}
-export declare const Buffer256bit: any;
-export declare const Hash160bit: any;
-export declare const Hash256bit: any;
-export declare const Number: any;
-export declare const Array: any;
-export declare const Boolean: any;
-export declare const String: any;
-export declare const Buffer: any;
-export declare const Hex: any;
-export declare const maybe: any;
-export declare const tuple: any;
-export declare const UInt8: any;
-export declare const UInt32: any;
-export declare const Function: any;
-export declare const BufferN: any;
-export declare const Null: any;
-export declare const oneOf: any;
+export declare const typeforce: any;
+export declare function stacksEqual(a: Buffer[], b: Buffer[]): boolean;
+export declare function isPoint(p: Buffer | number | undefined | null): boolean;
+export declare function Satoshi(value: number): boolean;
+export interface XOnlyPointAddTweakResult {
+    parity: 1 | 0;
+    xOnlyPubkey: Uint8Array;
+}
+export interface Tapleaf {
+    output: Buffer;
+    version?: number;
+}
+export declare const TAPLEAF_VERSION_MASK = 254;
+export declare function isTapleaf(o: any): o is Tapleaf;
+export type Taptree = [Taptree | Tapleaf, Taptree | Tapleaf] | Tapleaf;
+export declare function isTaptree(scriptTree: any): scriptTree is Taptree;
+export interface TinySecp256k1Interface {
+    isXOnlyPoint(p: Uint8Array): boolean;
+    xOnlyPointAddTweak(p: Uint8Array, tweak: Uint8Array): XOnlyPointAddTweakResult | null;
+}
+export declare const Buffer256bit: any;
+export declare const Hash160bit: any;
+export declare const Hash256bit: any;
+export declare const Number: any;
+export declare const Array: any;
+export declare const Boolean: any;
+export declare const String: any;
+export declare const Buffer: any;
+export declare const Hex: any;
+export declare const maybe: any;
+export declare const tuple: any;
+export declare const UInt8: any;
+export declare const UInt32: any;
+export declare const Function: any;
+export declare const BufferN: any;
+export declare const Null: any;
+export declare const oneOf: any;

package/build/address.d.ts

@@ -0,0 +1,16 @@
+import { Network } from './networks.js';
+export interface Base58CheckResult {
+    hash: Buffer;
+    version: number;
+}
+export interface Bech32Result {
+    version: number;
+    prefix: string;
+    data: Buffer;
+}
+export declare function fromBase58Check(address: string): Base58CheckResult;
+export declare function fromBech32(address: string): Bech32Result;
+export declare function toBase58Check(hash: Buffer, version: number): string;
+export declare function toBech32(data: Buffer, version: number, prefix: string): string;
+export declare function fromOutputScript(output: Buffer, network?: Network): string;
+export declare function toOutputScript(address: string, network?: Network): Buffer;

package/build/address.js

@@ -0,0 +1,148 @@
+import { bech32, bech32m } from 'bech32';
+import * as bs58check from 'bs58check';
+import { payments } from './index.js';
+import * as networks from './networks.js';
+import * as bscript from './script.js';
+import { Hash160bit, tuple, typeforce, UInt8 } from './types.js';
+const FUTURE_SEGWIT_MAX_SIZE = 40;
+const FUTURE_SEGWIT_MIN_SIZE = 2;
+const FUTURE_SEGWIT_MAX_VERSION = 16;
+const FUTURE_SEGWIT_MIN_VERSION = 2;
+const FUTURE_SEGWIT_VERSION_DIFF = 0x50;
+const FUTURE_SEGWIT_VERSION_WARNING = 'WARNING: Sending to a future segwit version address can lead to loss of funds. ' +
+    'End users MUST be warned carefully in the GUI and asked if they wish to proceed ' +
+    'with caution. Wallets should verify the segwit version from the output of fromBech32, ' +
+    'then decide when it is safe to use which version of segwit.';
+function _toFutureSegwitAddress(output, network) {
+    const data = output.slice(2);
+    if (data.length < FUTURE_SEGWIT_MIN_SIZE || data.length > FUTURE_SEGWIT_MAX_SIZE)
+        throw new TypeError('Invalid program length for segwit address');
+    const version = output[0] - FUTURE_SEGWIT_VERSION_DIFF;
+    if (version < FUTURE_SEGWIT_MIN_VERSION || version > FUTURE_SEGWIT_MAX_VERSION)
+        throw new TypeError('Invalid version for segwit address');
+    if (output[1] !== data.length)
+        throw new TypeError('Invalid script for segwit address');
+    console.warn(FUTURE_SEGWIT_VERSION_WARNING);
+    return toBech32(data, version, network.bech32);
+}
+export function fromBase58Check(address) {
+    const payload = Buffer.from(bs58check.default.decode(address));
+    if (payload.length < 21)
+        throw new TypeError(address + ' is too short');
+    if (payload.length > 21)
+        throw new TypeError(address + ' is too long');
+    const version = payload.readUInt8(0);
+    const hash = payload.slice(1);
+    return { version, hash };
+}
+export function fromBech32(address) {
+    let result;
+    let version;
+    try {
+        result = bech32.decode(address);
+    }
+    catch (e) { }
+    if (result) {
+        version = result.words[0];
+        if (version !== 0)
+            throw new TypeError(address + ' uses wrong encoding');
+    }
+    else {
+        result = bech32m.decode(address);
+        version = result.words[0];
+        if (version === 0)
+            throw new TypeError(address + ' uses wrong encoding');
+    }
+    const data = bech32.fromWords(result.words.slice(1));
+    return {
+        version,
+        prefix: result.prefix,
+        data: Buffer.from(data),
+    };
+}
+export function toBase58Check(hash, version) {
+    typeforce(tuple(Hash160bit, UInt8), arguments);
+    const payload = Buffer.allocUnsafe(21);
+    payload.writeUInt8(version, 0);
+    hash.copy(payload, 1);
+    return bs58check.default.encode(payload);
+}
+export function toBech32(data, version, prefix) {
+    const words = bech32.toWords(data);
+    words.unshift(version);
+    return version === 0 ? bech32.encode(prefix, words) : bech32m.encode(prefix, words);
+}
+export function fromOutputScript(output, network) {
+    network = network || networks.bitcoin;
+    try {
+        return payments.p2pkh({ output, network }).address;
+    }
+    catch (e) { }
+    try {
+        return payments.p2sh({ output, network }).address;
+    }
+    catch (e) { }
+    try {
+        return payments.p2wpkh({ output, network }).address;
+    }
+    catch (e) { }
+    try {
+        return payments.p2wsh({ output, network }).address;
+    }
+    catch (e) { }
+    try {
+        return payments.p2tr({ output, network }).address;
+    }
+    catch (e) { }
+    try {
+        return _toFutureSegwitAddress(output, network);
+    }
+    catch (e) { }
+    throw new Error(bscript.toASM(output) + ' has no matching Address');
+}
+export function toOutputScript(address, network) {
+    network = network || networks.bitcoin;
+    let decodeBase58;
+    let decodeBech32;
+    try {
+        decodeBase58 = fromBase58Check(address);
+    }
+    catch (e) { }
+    if (decodeBase58) {
+        if (decodeBase58.version === network.pubKeyHash)
+            return payments.p2pkh({ hash: decodeBase58.hash }).output;
+        if (decodeBase58.version === network.scriptHash)
+            return payments.p2sh({ hash: decodeBase58.hash }).output;
+    }
+    else {
+        try {
+            decodeBech32 = fromBech32(address);
+        }
+        catch (e) { }
+        if (decodeBech32) {
+            if (decodeBech32.prefix !== network.bech32)
+                throw new Error(address + ' has an invalid prefix');
+            if (decodeBech32.version === 0) {
+                if (decodeBech32.data.length === 20)
+                    return payments.p2wpkh({ hash: decodeBech32.data }).output;
+                if (decodeBech32.data.length === 32)
+                    return payments.p2wsh({ hash: decodeBech32.data }).output;
+            }
+            else if (decodeBech32.version === 1) {
+                if (decodeBech32.data.length === 32)
+                    return payments.p2tr({ pubkey: decodeBech32.data }).output;
+            }
+            else if (decodeBech32.version >= FUTURE_SEGWIT_MIN_VERSION &&
+                decodeBech32.version <= FUTURE_SEGWIT_MAX_VERSION &&
+                decodeBech32.data.length >= FUTURE_SEGWIT_MIN_SIZE &&
+                decodeBech32.data.length <= FUTURE_SEGWIT_MAX_SIZE) {
+                console.warn(FUTURE_SEGWIT_VERSION_WARNING);
+                return bscript.compile([
+                    decodeBech32.version + FUTURE_SEGWIT_VERSION_DIFF,
+                    decodeBech32.data,
+                ]);
+            }
+        }
+    }
+    return Buffer.from(address, 'hex');
+}

package/build/bip66.d.ts

@@ -0,0 +1,6 @@
+export declare function check(buffer: Buffer): boolean;
+export declare function decode(buffer: Buffer): {
+    r: Buffer;
+    s: Buffer;
+};
+export declare function encode(r: Buffer, s: Buffer): Buffer;

package/build/bip66.js

@@ -0,0 +1,99 @@
+export 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;
+}
+export 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');
+    return {
+        r: buffer.slice(4, 4 + lenR),
+        s: buffer.slice(6 + lenR),
+    };
+}
+export 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);
+    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;
+}

package/build/block.d.ts

@@ -0,0 +1,29 @@
+import { Transaction } from './transaction.js';
+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/build/block.js

@@ -0,0 +1,181 @@
+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');
+export class Block {
+    constructor() {
+        this.version = 1;
+        this.prevHash = undefined;
+        this.merkleRoot = undefined;
+        this.timestamp = 0;
+        this.witnessCommit = undefined;
+        this.bits = 0;
+        this.nonce = 0;
+        this.transactions = undefined;
+    }
+    static fromBuffer(buffer) {
+        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);
+        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.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();
+        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 = 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;
+        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;
+        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 +
+            varuint.encodingLength(this.transactions.length) +
+            this.transactions.reduce((a, x) => a + x.byteLength(allowWitness), 0));
+    }
+    getHash() {
+        return bcrypto.hash256(this.toBuffer(true));
+    }
+    getId() {
+        return reverseBuffer(this.getHash()).toString('hex');
+    }
+    getUTCDate() {
+        const date = new Date(0);
+        date.setUTCSeconds(this.timestamp);
+        return date;
+    }
+    toBuffer(headersOnly) {
+        const buffer = Buffer.allocUnsafe(this.byteLength(headersOnly));
+        const bufferWriter = new 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;
+        varuint.encode(this.transactions.length, buffer, bufferWriter.offset);
+        bufferWriter.offset += varuint.encode.bytes;
+        this.transactions.forEach((tx) => {
+            const txSize = tx.byteLength();
+            tx.toBuffer(buffer, bufferWriter.offset);
+            bufferWriter.offset += txSize;
+        });
+        return buffer;
+    }
+    toHex(headersOnly) {
+        return this.toBuffer(headersOnly).toString('hex');
+    }
+    checkTxRoots() {
+        const hasWitnessCommit = this.hasWitnessCommit();
+        if (!hasWitnessCommit && this.hasWitness())
+            return false;
+        return this.__checkMerkleRoot() && (hasWitnessCommit ? this.__checkWitnessCommit() : true);
+    }
+    checkProofOfWork() {
+        const hash = 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;
+    }
+}
+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/build/bufferutils.d.ts

@@ -0,0 +1,34 @@
+import * as varuint from 'varuint-bitcoin';
+export { varuint };
+export declare function readUInt64LE(buffer: Buffer, offset: number): number;
+export declare function writeUInt64LE(buffer: Buffer, value: number, offset: number): number;
+export declare function reverseBuffer(buffer: Buffer): Buffer;
+export declare function cloneBuffer(buffer: Buffer): 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;
+}
+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[];
+}