ecash-lib 4.8.0 → 4.9.0

package/src/op.ts

@@ -2,11 +2,14 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+import { MAX_SCRIPTNUM_BYTE_SIZE } from './consts.js';
 import { Bytes } from './io/bytes.js';
 import { Writer } from './io/writer.js';
 import {
     OP_0,
+    OP_1,
     OP_1NEGATE,
+    OP_16,
     OP_PUSHDATA1,
     OP_PUSHDATA2,
     OP_PUSHDATA4,
@@ -28,6 +31,106 @@ export interface PushOp {
     data: Uint8Array;
 }
 
+/**
+ * Check if bytes are a minimally encoded script number (not arbitrary data).
+ * See CScriptNum::IsMinimallyEncoded in script/script.cpp.
+ */
+function isMinimallyEncoded(data: Uint8Array): boolean {
+    if (data.length === 0) return true;
+    // Check that the number is encoded with the minimum possible number of bytes.
+    // If the most-significant-byte (excluding the sign bit) is zero then we're not minimal.
+    // This also rejects the negative-zero encoding, 0x80.
+    const last = data[data.length - 1]!;
+    if ((last & 0x7f) === 0) {
+        // One exception: if there's more than one byte and the most significant bit of the
+        // second-to-last byte is set, it would conflict with the sign bit. E.g. +-255
+        // encode to 0xff00 and 0xff80 respectively.
+        if (data.length <= 1 || (data[data.length - 2]! & 0x80) === 0) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Decode a minimally-encoded script number from bytes (little-endian, sign-magnitude).
+ * Validates size and minimal encoding; callers can rely on returned value being valid.
+ * Always returns bigint for type safety and full 64-bit range (matches CScriptNum::getint).
+ * Empty byte array decodes to 0.
+ * @throws Error if data exceeds max size or is not minimally encoded
+ */
+function decodeScriptNum(data: Uint8Array): bigint {
+    if (data.length === 0) {
+        return 0n;
+    }
+    if (data.length > MAX_SCRIPTNUM_BYTE_SIZE) {
+        throw new Error(
+            `Script number exceeds maximum size (${data.length} > ${MAX_SCRIPTNUM_BYTE_SIZE} bytes)`,
+        );
+    }
+    if (!isMinimallyEncoded(data)) {
+        throw new Error('Script number is not minimally encoded');
+    }
+    let result = 0n;
+    for (let i = 0; i < data.length; i++) {
+        result |= BigInt(data[i]!) << BigInt(8 * i);
+    }
+    if (data[data.length - 1]! & 0x80) {
+        const mask = ~(0x80n << BigInt(8 * (data.length - 1)));
+        result &= mask;
+        result = -result;
+    }
+    return result;
+}
+
+/**
+ * Check if the PushOp uses minimal push encoding for its data length.
+ * pushNumberOp always produces minimal pushes.
+ */
+function isMinimalPushOp(pushOp: PushOp): boolean {
+    const len = pushOp.data.length;
+    if (len === 0) return pushOp.opcode === OP_0;
+    if (len >= 1 && len <= 0x4b) return pushOp.opcode === len;
+    if (len >= 0x4c && len <= 0xff) return pushOp.opcode === OP_PUSHDATA1;
+    if (len >= 0x100 && len <= 0xffff) return pushOp.opcode === OP_PUSHDATA2;
+    if (len >= 0x10000 && len <= 0xffffffff)
+        return pushOp.opcode === OP_PUSHDATA4;
+    return false;
+}
+
+/**
+ * Parse a number from a script op.
+ * Inverse of pushNumberOp: handles OP_0 (0), OP_1NEGATE (-1), OP_1 through OP_16,
+ * single-byte push data, and multi-byte minimal script number encoding (up to 64-bit).
+ * Always returns bigint for type safety (matches CScriptNum::getint).
+ * @throws Error with descriptive message if the op does not encode a number
+ */
+export function parseNumberFromOp(op: Op): bigint {
+    if (typeof op === 'number') {
+        if (op === OP_0) {
+            return 0n;
+        }
+        if (op === OP_1NEGATE) {
+            return -1n;
+        }
+        if (op >= OP_1 && op <= OP_16) {
+            return BigInt(op - 0x50);
+        }
+        throw new Error(
+            `Opcode 0x${op.toString(16)} does not encode a number (expected OP_0, OP_1NEGATE, or OP_1-OP_16)`,
+        );
+    }
+    if (!isPushOp(op)) {
+        throw new Error('Op is not a push op');
+    }
+    if (!isMinimalPushOp(op)) {
+        throw new Error(
+            `Push uses non-minimal encoding (opcode 0x${op.opcode.toString(16)} for ${op.data.length} bytes)`,
+        );
+    }
+    return decodeScriptNum(op.data);
+}
+
 /** Returns true if the given object is a `PushOp` */
 export function isPushOp(op: any): op is PushOp {
     if (!op || typeof op !== 'object') {