@btc-vision/bitcoin 6.4.10 → 6.4.11

package/src/script.ts

@@ -1,247 +1,247 @@
-/**
- * Script tools, including decompile, compile, toASM, fromASM, toStack, isCanonicalPubKey, isCanonicalScriptSignature
- * @packageDocumentation
- */
-import * as bip66 from './bip66.js';
-import { Opcodes, opcodes, REVERSE_OPS } from './opcodes.js';
-import { Stack } from './payments/index.js';
-import * as pushdata from './push_data.js';
-import * as scriptNumber from './script_number.js';
-import * as scriptSignature from './script_signature.js';
-import * as types from './types.js';
-
-const { typeforce } = types;
-
-const OP_INT_BASE = opcodes.OP_RESERVED; // OP_1 - 1
-export { opcodes };
-
-function isOPInt(value: number): boolean {
-    return (
-        types.Number(value) &&
-        (value === opcodes.OP_0 ||
-            (value >= opcodes.OP_1 && value <= opcodes.OP_16) ||
-            value === opcodes.OP_1NEGATE)
-    );
-}
-
-function isPushOnlyChunk(value: number | Buffer): boolean {
-    return types.Buffer(value) || isOPInt(value as number);
-}
-
-export function isPushOnly(value: Stack): boolean {
-    return types.Array(value) && value.every(isPushOnlyChunk);
-}
-
-export function countNonPushOnlyOPs(value: Stack): number {
-    return value.length - value.filter(isPushOnlyChunk).length;
-}
-
-function asMinimalOP(buffer: Buffer): number | void {
-    if (buffer.length === 0) return opcodes.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 opcodes.OP_1NEGATE;
-}
-
-function chunksIsBuffer(buf: Buffer | Stack): buf is Buffer {
-    return Buffer.isBuffer(buf);
-}
-
-function chunksIsArray(buf: Buffer | Stack): buf is Stack {
-    return types.Array(buf);
-}
-
-function singleChunkIsBuffer(buf: number | Buffer): buf is Buffer {
-    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.
- */
-export function compile(chunks: Buffer | Stack): Buffer {
-    // TODO: remove me
-    if (chunksIsBuffer(chunks)) return chunks;
-
-    typeforce(types.Array, chunks);
-
-    const bufferSize = chunks.reduce((accum: number, 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;
-}
-
-export function decompile(buffer: Buffer | Array<number | Buffer>): Array<number | Buffer> | null {
-    // TODO: remove me
-    if (chunksIsArray(buffer)) return buffer;
-
-    typeforce(types.Buffer, buffer);
-
-    const chunks: Array<number | Buffer> = [];
-    let i = 0;
-
-    while (i < buffer.length) {
-        const opcode = buffer[i];
-
-        // data chunk
-        if (opcode > opcodes.OP_0 && opcode <= opcodes.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;
-}
-
-/**
- * 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 function toASM(chunks: Buffer | Array<number | Buffer>): string {
-    if (chunksIsBuffer(chunks)) {
-        chunks = decompile(chunks) as Stack;
-    }
-    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 as number;
-            }
-
-            // opcode!
-            return REVERSE_OPS[chunk];
-        })
-        .join(' ');
-}
-
-/**
- * Converts an ASM string to a Buffer.
- * @param asm The ASM string to convert.
- * @returns The converted Buffer.
- */
-export function fromASM(asm: string): Buffer {
-    typeforce(types.String, asm);
-
-    return compile(
-        asm.split(' ').map((chunkStr) => {
-            // opcode?
-            if (opcodes[chunkStr as keyof Opcodes] !== undefined) {
-                return opcodes[chunkStr as keyof Opcodes];
-            }
-            typeforce(types.Hex, chunkStr);
-
-            // data!
-            return Buffer.from(chunkStr, 'hex');
-        }),
-    );
-}
-
-/**
- * Converts the given chunks into a stack of buffers.
- *
- * @param chunks - The chunks to convert.
- * @returns The stack of buffers.
- */
-export function toStack(chunks: Buffer | Array<number | Buffer>): Buffer[] {
-    chunks = decompile(chunks) as Stack;
-    typeforce(isPushOnly, chunks);
-
-    return chunks.map((op) => {
-        if (singleChunkIsBuffer(op)) return op;
-        if (op === opcodes.OP_0) return Buffer.allocUnsafe(0);
-
-        return scriptNumber.encode(op - OP_INT_BASE);
-    });
-}
-
-export function isCanonicalPubKey(buffer: Buffer): boolean {
-    return types.isPoint(buffer);
-}
-
-export function isDefinedHashType(hashType: number): boolean {
-    const hashTypeMod = hashType & ~0x80;
-
-    // return hashTypeMod > SIGHASH_ALL && hashTypeMod < SIGHASH_SINGLE
-    return hashTypeMod > 0x00 && hashTypeMod < 0x04;
-}
-
-export function isCanonicalScriptSignature(buffer: Buffer): boolean {
-    if (!Buffer.isBuffer(buffer)) return false;
-    if (!isDefinedHashType(buffer[buffer.length - 1])) return false;
-
-    return bip66.check(buffer.slice(0, -1));
-}
-
-export const number = scriptNumber;
-export const signature = scriptSignature;
+/**
+ * Script tools, including decompile, compile, toASM, fromASM, toStack, isCanonicalPubKey, isCanonicalScriptSignature
+ * @packageDocumentation
+ */
+import * as bip66 from './bip66.js';
+import { Opcodes, opcodes, REVERSE_OPS } from './opcodes.js';
+import { Stack } from './payments/index.js';
+import * as pushdata from './push_data.js';
+import * as scriptNumber from './script_number.js';
+import * as scriptSignature from './script_signature.js';
+import * as types from './types.js';
+
+const { typeforce } = types;
+
+const OP_INT_BASE = opcodes.OP_RESERVED; // OP_1 - 1
+export { opcodes };
+
+function isOPInt(value: number): boolean {
+    return (
+        types.Number(value) &&
+        (value === opcodes.OP_0 ||
+            (value >= opcodes.OP_1 && value <= opcodes.OP_16) ||
+            value === opcodes.OP_1NEGATE)
+    );
+}
+
+function isPushOnlyChunk(value: number | Buffer): boolean {
+    return types.Buffer(value) || isOPInt(value as number);
+}
+
+export function isPushOnly(value: Stack): boolean {
+    return types.Array(value) && value.every(isPushOnlyChunk);
+}
+
+export function countNonPushOnlyOPs(value: Stack): number {
+    return value.length - value.filter(isPushOnlyChunk).length;
+}
+
+function asMinimalOP(buffer: Buffer): number | void {
+    if (buffer.length === 0) return opcodes.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 opcodes.OP_1NEGATE;
+}
+
+function chunksIsBuffer(buf: Buffer | Stack): buf is Buffer {
+    return Buffer.isBuffer(buf);
+}
+
+function chunksIsArray(buf: Buffer | Stack): buf is Stack {
+    return types.Array(buf);
+}
+
+function singleChunkIsBuffer(buf: number | Buffer): buf is Buffer {
+    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.
+ */
+export function compile(chunks: Buffer | Stack): Buffer {
+    // TODO: remove me
+    if (chunksIsBuffer(chunks)) return chunks;
+
+    typeforce(types.Array, chunks);
+
+    const bufferSize = chunks.reduce((accum: number, 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;
+}
+
+export function decompile(buffer: Buffer | Array<number | Buffer>): Array<number | Buffer> | null {
+    // TODO: remove me
+    if (chunksIsArray(buffer)) return buffer;
+
+    typeforce(types.Buffer, buffer);
+
+    const chunks: Array<number | Buffer> = [];
+    let i = 0;
+
+    while (i < buffer.length) {
+        const opcode = buffer[i];
+
+        // data chunk
+        if (opcode > opcodes.OP_0 && opcode <= opcodes.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;
+}
+
+/**
+ * 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 function toASM(chunks: Buffer | Array<number | Buffer>): string {
+    if (chunksIsBuffer(chunks)) {
+        chunks = decompile(chunks) as Stack;
+    }
+    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 as number;
+            }
+
+            // opcode!
+            return REVERSE_OPS[chunk];
+        })
+        .join(' ');
+}
+
+/**
+ * Converts an ASM string to a Buffer.
+ * @param asm The ASM string to convert.
+ * @returns The converted Buffer.
+ */
+export function fromASM(asm: string): Buffer {
+    typeforce(types.String, asm);
+
+    return compile(
+        asm.split(' ').map((chunkStr) => {
+            // opcode?
+            if (opcodes[chunkStr as keyof Opcodes] !== undefined) {
+                return opcodes[chunkStr as keyof Opcodes];
+            }
+            typeforce(types.Hex, chunkStr);
+
+            // data!
+            return Buffer.from(chunkStr, 'hex');
+        }),
+    );
+}
+
+/**
+ * Converts the given chunks into a stack of buffers.
+ *
+ * @param chunks - The chunks to convert.
+ * @returns The stack of buffers.
+ */
+export function toStack(chunks: Buffer | Array<number | Buffer>): Buffer[] {
+    chunks = decompile(chunks) as Stack;
+    typeforce(isPushOnly, chunks);
+
+    return chunks.map((op) => {
+        if (singleChunkIsBuffer(op)) return op;
+        if (op === opcodes.OP_0) return Buffer.allocUnsafe(0);
+
+        return scriptNumber.encode(op - OP_INT_BASE);
+    });
+}
+
+export function isCanonicalPubKey(buffer: Buffer): boolean {
+    return types.isPoint(buffer);
+}
+
+export function isDefinedHashType(hashType: number): boolean {
+    const hashTypeMod = hashType & ~0x80;
+
+    // return hashTypeMod > SIGHASH_ALL && hashTypeMod < SIGHASH_SINGLE
+    return hashTypeMod > 0x00 && hashTypeMod < 0x04;
+}
+
+export function isCanonicalScriptSignature(buffer: Buffer): boolean {
+    if (!Buffer.isBuffer(buffer)) return false;
+    if (!isDefinedHashType(buffer[buffer.length - 1])) return false;
+
+    return bip66.check(buffer.slice(0, -1));
+}
+
+export const number = scriptNumber;
+export const signature = scriptSignature;

package/src/script_number.ts

@@ -1,72 +1,72 @@
-/**
- * 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 function decode(buffer: Buffer, maxLength?: number, minimal?: boolean): number {
-    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;
-}
-
-function scriptNumSize(i: number): number {
-    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.
- */
-export function encode(_number: number): Buffer {
-    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;
-}
+/**
+ * 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 function decode(buffer: Buffer, maxLength?: number, minimal?: boolean): number {
+    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;
+}
+
+function scriptNumSize(i: number): number {
+    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.
+ */
+export function encode(_number: number): Buffer {
+    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;
+}