@btc-vision/bitcoin 6.3.0

package/src/push_data.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+/**
+ * Calculates the encoding length of a number used for push data in Bitcoin transactions.
+ * @param i The number to calculate the encoding length for.
+ * @returns The encoding length of the number.
+ */
+export declare function encodingLength(i: number): number;
+/**
+ * Encodes a number into a buffer using a variable-length encoding scheme.
+ * The encoded buffer is written starting at the specified offset.
+ * Returns the size of the encoded buffer.
+ *
+ * @param buffer - The buffer to write the encoded data into.
+ * @param num - The number to encode.
+ * @param offset - The offset at which to start writing the encoded buffer.
+ * @returns The size of the encoded buffer.
+ */
+export declare function encode(buffer: Buffer, num: number, offset: number): number;
+/**
+ * Decodes a buffer and returns information about the opcode, number, and size.
+ * @param buffer - The buffer to decode.
+ * @param offset - The offset within the buffer to start decoding.
+ * @returns An object containing the opcode, number, and size, or null if decoding fails.
+ */
+export declare function decode(buffer: Buffer, offset: number): {
+    opcode: number;
+    number: number;
+    size: number;
+} | null;

package/src/push_data.js

@@ -0,0 +1,83 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.decode = exports.encode = exports.encodingLength = void 0;
+const ops_1 = require('./ops');
+/**
+ * Calculates the encoding length of a number used for push data in Bitcoin transactions.
+ * @param i The number to calculate the encoding length for.
+ * @returns The encoding length of the number.
+ */
+function encodingLength(i) {
+    return i < ops_1.OPS.OP_PUSHDATA1 ? 1 : i <= 0xff ? 2 : i <= 0xffff ? 3 : 5;
+}
+exports.encodingLength = encodingLength;
+/**
+ * Encodes a number into a buffer using a variable-length encoding scheme.
+ * The encoded buffer is written starting at the specified offset.
+ * Returns the size of the encoded buffer.
+ *
+ * @param buffer - The buffer to write the encoded data into.
+ * @param num - The number to encode.
+ * @param offset - The offset at which to start writing the encoded buffer.
+ * @returns The size of the encoded buffer.
+ */
+function encode(buffer, num, offset) {
+    const size = encodingLength(num);
+    // ~6 bit
+    if (size === 1) {
+        buffer.writeUInt8(num, offset);
+        // 8 bit
+    } else if (size === 2) {
+        buffer.writeUInt8(ops_1.OPS.OP_PUSHDATA1, offset);
+        buffer.writeUInt8(num, offset + 1);
+        // 16 bit
+    } else if (size === 3) {
+        buffer.writeUInt8(ops_1.OPS.OP_PUSHDATA2, offset);
+        buffer.writeUInt16LE(num, offset + 1);
+        // 32 bit
+    } else {
+        buffer.writeUInt8(ops_1.OPS.OP_PUSHDATA4, offset);
+        buffer.writeUInt32LE(num, offset + 1);
+    }
+    return size;
+}
+exports.encode = encode;
+/**
+ * Decodes a buffer and returns information about the opcode, number, and size.
+ * @param buffer - The buffer to decode.
+ * @param offset - The offset within the buffer to start decoding.
+ * @returns An object containing the opcode, number, and size, or null if decoding fails.
+ */
+function decode(buffer, offset) {
+    const opcode = buffer.readUInt8(offset);
+    let num;
+    let size;
+    // ~6 bit
+    if (opcode < ops_1.OPS.OP_PUSHDATA1) {
+        num = opcode;
+        size = 1;
+        // 8 bit
+    } else if (opcode === ops_1.OPS.OP_PUSHDATA1) {
+        if (offset + 2 > buffer.length) return null;
+        num = buffer.readUInt8(offset + 1);
+        size = 2;
+        // 16 bit
+    } else if (opcode === ops_1.OPS.OP_PUSHDATA2) {
+        if (offset + 3 > buffer.length) return null;
+        num = buffer.readUInt16LE(offset + 1);
+        size = 3;
+        // 32 bit
+    } else {
+        if (offset + 5 > buffer.length) return null;
+        if (opcode !== ops_1.OPS.OP_PUSHDATA4)
+            throw new Error('Unexpected opcode');
+        num = buffer.readUInt32LE(offset + 1);
+        size = 5;
+    }
+    return {
+        opcode,
+        number: num,
+        size,
+    };
+}
+exports.decode = decode;

package/src/script.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import { OPS } from './ops';
+import { Stack } from './payments';
+import * as scriptNumber from './script_number';
+import * as scriptSignature from './script_signature';
+export { OPS };
+export declare function isPushOnly(value: Stack): boolean;
+export declare function countNonPushOnlyOPs(value: Stack): number;
+/**
+ * Compiles an array of chunks into a Buffer.
+ *
+ * @param chunks - The array of chunks to compile.
+ * @returns The compiled Buffer.
+ * @throws Error if the compilation fails.
+ */
+export declare function compile(chunks: Buffer | Stack): Buffer;
+export declare function decompile(buffer: Buffer | Array<number | Buffer>): Array<number | Buffer> | null;
+/**
+ * Converts the given chunks into an ASM (Assembly) string representation.
+ * If the chunks parameter is a Buffer, it will be decompiled into a Stack before conversion.
+ * @param chunks - The chunks to convert into ASM.
+ * @returns The ASM string representation of the chunks.
+ */
+export declare function toASM(chunks: Buffer | Array<number | Buffer>): string;
+/**
+ * Converts an ASM string to a Buffer.
+ * @param asm The ASM string to convert.
+ * @returns The converted Buffer.
+ */
+export declare function fromASM(asm: string): Buffer;
+/**
+ * Converts the given chunks into a stack of buffers.
+ *
+ * @param chunks - The chunks to convert.
+ * @returns The stack of buffers.
+ */
+export declare function toStack(chunks: Buffer | Array<number | Buffer>): Buffer[];
+export declare function isCanonicalPubKey(buffer: Buffer): boolean;
+export declare function isDefinedHashType(hashType: number): boolean;
+export declare function isCanonicalScriptSignature(buffer: Buffer): boolean;
+export declare const number: typeof scriptNumber;
+export declare const signature: typeof scriptSignature;

package/src/script.js

@@ -0,0 +1,231 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.signature =
+    exports.number =
+    exports.isCanonicalScriptSignature =
+    exports.isDefinedHashType =
+    exports.isCanonicalPubKey =
+    exports.toStack =
+    exports.fromASM =
+    exports.toASM =
+    exports.decompile =
+    exports.compile =
+    exports.countNonPushOnlyOPs =
+    exports.isPushOnly =
+    exports.OPS =
+        void 0;
+/**
+ * Script tools, including decompile, compile, toASM, fromASM, toStack, isCanonicalPubKey, isCanonicalScriptSignature
+ * @packageDocumentation
+ */
+const bip66 = require('./bip66');
+const ops_1 = require('./ops');
+Object.defineProperty(exports, 'OPS', {
+    enumerable: true,
+    get: function () {
+        return ops_1.OPS;
+    },
+});
+const pushdata = require('./push_data');
+const scriptNumber = require('./script_number');
+const scriptSignature = require('./script_signature');
+const types = require('./types');
+const { typeforce } = types;
+const OP_INT_BASE = ops_1.OPS.OP_RESERVED; // OP_1 - 1
+function isOPInt(value) {
+    return (
+        types.Number(value) &&
+        (value === ops_1.OPS.OP_0 ||
+            (value >= ops_1.OPS.OP_1 && value <= ops_1.OPS.OP_16) ||
+            value === ops_1.OPS.OP_1NEGATE)
+    );
+}
+function isPushOnlyChunk(value) {
+    return types.Buffer(value) || isOPInt(value);
+}
+function isPushOnly(value) {
+    return types.Array(value) && value.every(isPushOnlyChunk);
+}
+exports.isPushOnly = isPushOnly;
+function countNonPushOnlyOPs(value) {
+    return value.length - value.filter(isPushOnlyChunk).length;
+}
+exports.countNonPushOnlyOPs = countNonPushOnlyOPs;
+function asMinimalOP(buffer) {
+    if (buffer.length === 0) return ops_1.OPS.OP_0;
+    if (buffer.length !== 1) return;
+    if (buffer[0] >= 1 && buffer[0] <= 16) return OP_INT_BASE + buffer[0];
+    if (buffer[0] === 0x81) return ops_1.OPS.OP_1NEGATE;
+}
+function chunksIsBuffer(buf) {
+    return Buffer.isBuffer(buf);
+}
+function chunksIsArray(buf) {
+    return types.Array(buf);
+}
+function singleChunkIsBuffer(buf) {
+    return Buffer.isBuffer(buf);
+}
+/**
+ * Compiles an array of chunks into a Buffer.
+ *
+ * @param chunks - The array of chunks to compile.
+ * @returns The compiled Buffer.
+ * @throws Error if the compilation fails.
+ */
+function compile(chunks) {
+    // TODO: remove me
+    if (chunksIsBuffer(chunks)) return chunks;
+    typeforce(types.Array, chunks);
+    const bufferSize = chunks.reduce((accum, chunk) => {
+        // data chunk
+        if (singleChunkIsBuffer(chunk)) {
+            // adhere to BIP62.3, minimal push policy
+            if (chunk.length === 1 && asMinimalOP(chunk) !== undefined) {
+                return accum + 1;
+            }
+            return accum + pushdata.encodingLength(chunk.length) + chunk.length;
+        }
+        // opcode
+        return accum + 1;
+    }, 0.0);
+    const buffer = Buffer.allocUnsafe(bufferSize);
+    let offset = 0;
+    chunks.forEach(chunk => {
+        // data chunk
+        if (singleChunkIsBuffer(chunk)) {
+            // adhere to BIP62.3, minimal push policy
+            const opcode = asMinimalOP(chunk);
+            if (opcode !== undefined) {
+                buffer.writeUInt8(opcode, offset);
+                offset += 1;
+                return;
+            }
+            offset += pushdata.encode(buffer, chunk.length, offset);
+            chunk.copy(buffer, offset);
+            offset += chunk.length;
+            // opcode
+        } else {
+            buffer.writeUInt8(chunk, offset);
+            offset += 1;
+        }
+    });
+    if (offset !== buffer.length) throw new Error('Could not decode chunks');
+    return buffer;
+}
+exports.compile = compile;
+function decompile(buffer) {
+    // TODO: remove me
+    if (chunksIsArray(buffer)) return buffer;
+    typeforce(types.Buffer, buffer);
+    const chunks = [];
+    let i = 0;
+    while (i < buffer.length) {
+        const opcode = buffer[i];
+        // data chunk
+        if (opcode > ops_1.OPS.OP_0 && opcode <= ops_1.OPS.OP_PUSHDATA4) {
+            const d = pushdata.decode(buffer, i);
+            // did reading a pushDataInt fail?
+            if (d === null) return null;
+            i += d.size;
+            // attempt to read too much data?
+            if (i + d.number > buffer.length) return null;
+            const data = buffer.slice(i, i + d.number);
+            i += d.number;
+            // decompile minimally
+            const op = asMinimalOP(data);
+            if (op !== undefined) {
+                chunks.push(op);
+            } else {
+                chunks.push(data);
+            }
+            // opcode
+        } else {
+            chunks.push(opcode);
+            i += 1;
+        }
+    }
+    return chunks;
+}
+exports.decompile = decompile;
+/**
+ * Converts the given chunks into an ASM (Assembly) string representation.
+ * If the chunks parameter is a Buffer, it will be decompiled into a Stack before conversion.
+ * @param chunks - The chunks to convert into ASM.
+ * @returns The ASM string representation of the chunks.
+ */
+function toASM(chunks) {
+    if (chunksIsBuffer(chunks)) {
+        chunks = decompile(chunks);
+    }
+    if (!chunks) {
+        throw new Error('Could not convert invalid chunks to ASM');
+    }
+    return chunks
+        .map(chunk => {
+            // data?
+            if (singleChunkIsBuffer(chunk)) {
+                const op = asMinimalOP(chunk);
+                if (op === undefined) return chunk.toString('hex');
+                chunk = op;
+            }
+            // opcode!
+            return ops_1.REVERSE_OPS[chunk];
+        })
+        .join(' ');
+}
+exports.toASM = toASM;
+/**
+ * Converts an ASM string to a Buffer.
+ * @param asm The ASM string to convert.
+ * @returns The converted Buffer.
+ */
+function fromASM(asm) {
+    typeforce(types.String, asm);
+    return compile(
+        asm.split(' ').map(chunkStr => {
+            // opcode?
+            if (ops_1.OPS[chunkStr] !== undefined) {
+                return ops_1.OPS[chunkStr];
+            }
+            typeforce(types.Hex, chunkStr);
+            // data!
+            return Buffer.from(chunkStr, 'hex');
+        }),
+    );
+}
+exports.fromASM = fromASM;
+/**
+ * Converts the given chunks into a stack of buffers.
+ *
+ * @param chunks - The chunks to convert.
+ * @returns The stack of buffers.
+ */
+function toStack(chunks) {
+    chunks = decompile(chunks);
+    typeforce(isPushOnly, chunks);
+    return chunks.map(op => {
+        if (singleChunkIsBuffer(op)) return op;
+        if (op === ops_1.OPS.OP_0) return Buffer.allocUnsafe(0);
+        return scriptNumber.encode(op - OP_INT_BASE);
+    });
+}
+exports.toStack = toStack;
+function isCanonicalPubKey(buffer) {
+    return types.isPoint(buffer);
+}
+exports.isCanonicalPubKey = isCanonicalPubKey;
+function isDefinedHashType(hashType) {
+    const hashTypeMod = hashType & ~0x80;
+    // return hashTypeMod > SIGHASH_ALL && hashTypeMod < SIGHASH_SINGLE
+    return hashTypeMod > 0x00 && hashTypeMod < 0x04;
+}
+exports.isDefinedHashType = isDefinedHashType;
+function isCanonicalScriptSignature(buffer) {
+    if (!Buffer.isBuffer(buffer)) return false;
+    if (!isDefinedHashType(buffer[buffer.length - 1])) return false;
+    return bip66.check(buffer.slice(0, -1));
+}
+exports.isCanonicalScriptSignature = isCanonicalScriptSignature;
+exports.number = scriptNumber;
+exports.signature = scriptSignature;

package/src/script_number.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/**
+ * Decodes a script number from a buffer.
+ *
+ * @param buffer - The buffer containing the script number.
+ * @param maxLength - The maximum length of the script number. Defaults to 4.
+ * @param minimal - Whether the script number should be minimal. Defaults to true.
+ * @returns The decoded script number.
+ * @throws {TypeError} If the script number overflows the maximum length.
+ * @throws {Error} If the script number is not minimally encoded when minimal is true.
+ */
+export declare function decode(buffer: Buffer, maxLength?: number, minimal?: boolean): number;
+/**
+ * Encodes a number into a Buffer using a specific format.
+ *
+ * @param _number - The number to encode.
+ * @returns The encoded number as a Buffer.
+ */
+export declare function encode(_number: number): Buffer;

package/src/script_number.js

@@ -0,0 +1,78 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.encode = exports.decode = void 0;
+/**
+ * Decodes a script number from a buffer.
+ *
+ * @param buffer - The buffer containing the script number.
+ * @param maxLength - The maximum length of the script number. Defaults to 4.
+ * @param minimal - Whether the script number should be minimal. Defaults to true.
+ * @returns The decoded script number.
+ * @throws {TypeError} If the script number overflows the maximum length.
+ * @throws {Error} If the script number is not minimally encoded when minimal is true.
+ */
+function decode(buffer, maxLength, minimal) {
+    maxLength = maxLength || 4;
+    minimal = minimal === undefined ? true : minimal;
+    const length = buffer.length;
+    if (length === 0) return 0;
+    if (length > maxLength) throw new TypeError('Script number overflow');
+    if (minimal) {
+        if ((buffer[length - 1] & 0x7f) === 0) {
+            if (length <= 1 || (buffer[length - 2] & 0x80) === 0)
+                throw new Error('Non-minimally encoded script number');
+        }
+    }
+    // 40-bit
+    if (length === 5) {
+        const a = buffer.readUInt32LE(0);
+        const b = buffer.readUInt8(4);
+        if (b & 0x80) return -((b & ~0x80) * 0x100000000 + a);
+        return b * 0x100000000 + a;
+    }
+    // 32-bit / 24-bit / 16-bit / 8-bit
+    let result = 0;
+    for (let i = 0; i < length; ++i) {
+        result |= buffer[i] << (8 * i);
+    }
+    if (buffer[length - 1] & 0x80)
+        return -(result & ~(0x80 << (8 * (length - 1))));
+    return result;
+}
+exports.decode = decode;
+function scriptNumSize(i) {
+    return i > 0x7fffffff
+        ? 5
+        : i > 0x7fffff
+        ? 4
+        : i > 0x7fff
+        ? 3
+        : i > 0x7f
+        ? 2
+        : i > 0x00
+        ? 1
+        : 0;
+}
+/**
+ * Encodes a number into a Buffer using a specific format.
+ *
+ * @param _number - The number to encode.
+ * @returns The encoded number as a Buffer.
+ */
+function encode(_number) {
+    let value = Math.abs(_number);
+    const size = scriptNumSize(value);
+    const buffer = Buffer.allocUnsafe(size);
+    const negative = _number < 0;
+    for (let i = 0; i < size; ++i) {
+        buffer.writeUInt8(value & 0xff, i);
+        value >>= 8;
+    }
+    if (buffer[size - 1] & 0x80) {
+        buffer.writeUInt8(negative ? 0x80 : 0x00, size - 1);
+    } else if (negative) {
+        buffer[size - 1] |= 0x80;
+    }
+    return buffer;
+}
+exports.encode = encode;

package/src/script_signature.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+interface ScriptSignature {
+    signature: Buffer;
+    hashType: number;
+}
+/**
+ * Decodes a buffer into a ScriptSignature object.
+ * @param buffer - The buffer to decode.
+ * @returns The decoded ScriptSignature object.
+ * @throws Error if the hashType is invalid.
+ */
+export declare function decode(buffer: Buffer): ScriptSignature;
+/**
+ * Encodes a signature and hash type into a buffer.
+ * @param signature - The signature to encode.
+ * @param hashType - The hash type to encode.
+ * @returns The encoded buffer.
+ * @throws Error if the hashType is invalid.
+ */
+export declare function encode(signature: Buffer, hashType: number): Buffer;
+export {};

package/src/script_signature.js

@@ -0,0 +1,79 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.encode = exports.decode = void 0;
+const bip66 = require('./bip66');
+const script_1 = require('./script');
+const types = require('./types');
+const { typeforce } = types;
+const ZERO = Buffer.alloc(1, 0);
+/**
+ * Converts a buffer to a DER-encoded buffer.
+ * @param x - The buffer to be converted.
+ * @returns The DER-encoded buffer.
+ */
+function toDER(x) {
+    let i = 0;
+    while (x[i] === 0) ++i;
+    if (i === x.length) return ZERO;
+    x = x.slice(i);
+    if (x[0] & 0x80) return Buffer.concat([ZERO, x], 1 + x.length);
+    return x;
+}
+/**
+ * Converts a DER-encoded signature to a buffer.
+ * If the first byte of the input buffer is 0x00, it is skipped.
+ * The resulting buffer is 32 bytes long, filled with zeros if necessary.
+ * @param x - The DER-encoded signature.
+ * @returns The converted buffer.
+ */
+function fromDER(x) {
+    if (x[0] === 0x00) x = x.slice(1);
+    const buffer = Buffer.alloc(32, 0);
+    const bstart = Math.max(0, 32 - x.length);
+    x.copy(buffer, bstart);
+    return buffer;
+}
+// BIP62: 1 byte hashType flag (only 0x01, 0x02, 0x03, 0x81, 0x82 and 0x83 are allowed)
+/**
+ * Decodes a buffer into a ScriptSignature object.
+ * @param buffer - The buffer to decode.
+ * @returns The decoded ScriptSignature object.
+ * @throws Error if the hashType is invalid.
+ */
+function decode(buffer) {
+    const hashType = buffer.readUInt8(buffer.length - 1);
+    if (!(0, script_1.isDefinedHashType)(hashType)) {
+        throw new Error('Invalid hashType ' + hashType);
+    }
+    const decoded = bip66.decode(buffer.slice(0, -1));
+    const r = fromDER(decoded.r);
+    const s = fromDER(decoded.s);
+    const signature = Buffer.concat([r, s], 64);
+    return { signature, hashType };
+}
+exports.decode = decode;
+/**
+ * Encodes a signature and hash type into a buffer.
+ * @param signature - The signature to encode.
+ * @param hashType - The hash type to encode.
+ * @returns The encoded buffer.
+ * @throws Error if the hashType is invalid.
+ */
+function encode(signature, hashType) {
+    typeforce(
+        {
+            signature: types.BufferN(64),
+            hashType: types.UInt8,
+        },
+        { signature, hashType },
+    );
+    if (!(0, script_1.isDefinedHashType)(hashType)) {
+        throw new Error('Invalid hashType ' + hashType);
+    }
+    const hashTypeBuffer = Buffer.allocUnsafe(1);
+    hashTypeBuffer.writeUInt8(hashType, 0);
+    const r = toDER(signature.slice(0, 32));
+    const s = toDER(signature.slice(32, 64));
+    return Buffer.concat([bip66.encode(r, s), hashTypeBuffer]);
+}
+exports.encode = encode;

package/src/transaction.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+export interface Output {
+    script: Buffer;
+    value: number;
+}
+export interface Input {
+    hash: Buffer;
+    index: number;
+    script: Buffer;
+    sequence: number;
+    witness: Buffer[];
+}
+/**
+ * Represents a Bitcoin transaction.
+ */
+export declare class Transaction {
+    static readonly DEFAULT_SEQUENCE = 4294967295;
+    static readonly SIGHASH_DEFAULT = 0;
+    static readonly SIGHASH_ALL = 1;
+    static readonly SIGHASH_NONE = 2;
+    static readonly SIGHASH_SINGLE = 3;
+    static readonly SIGHASH_ANYONECANPAY = 128;
+    static readonly SIGHASH_OUTPUT_MASK = 3;
+    static readonly SIGHASH_INPUT_MASK = 128;
+    static readonly ADVANCED_TRANSACTION_MARKER = 0;
+    static readonly ADVANCED_TRANSACTION_FLAG = 1;
+    version: number;
+    locktime: number;
+    ins: Input[];
+    outs: Output[];
+    static fromBuffer(buffer: Buffer, _NO_STRICT?: boolean): Transaction;
+    static fromHex(hex: string): Transaction;
+    static isCoinbaseHash(buffer: Buffer): boolean;
+    isCoinbase(): boolean;
+    addInput(hash: Buffer, index: number, sequence?: number, scriptSig?: Buffer): number;
+    addOutput(scriptPubKey: Buffer, value: number): number;
+    hasWitnesses(): boolean;
+    weight(): number;
+    virtualSize(): number;
+    byteLength(_ALLOW_WITNESS?: boolean): number;
+    clone(): Transaction;
+    /**
+     * Hash transaction for signing a specific input.
+     *
+     * Bitcoin uses a different hash for each signed transaction input.
+     * This method copies the transaction, makes the necessary changes based on the
+     * hashType, and then hashes the result.
+     * This hash can then be used to sign the provided transaction input.
+     */
+    hashForSignature(inIndex: number, prevOutScript: Buffer, hashType: number): Buffer;
+    hashForWitnessV1(inIndex: number, prevOutScripts: Buffer[], values: number[], hashType: number, leafHash?: Buffer, annex?: Buffer): Buffer;
+    hashForWitnessV0(inIndex: number, prevOutScript: Buffer, value: number, hashType: number): Buffer;
+    getHash(forWitness?: boolean): Buffer;
+    getId(): string;
+    toBuffer(buffer?: Buffer, initialOffset?: number): Buffer;
+    toHex(): string;
+    setInputScript(index: number, scriptSig: Buffer): void;
+    setWitness(index: number, witness: Buffer[]): void;
+    private __toBuffer;
+}