@fluffylabs/anan-as 1.1.3-dde58f0 → 1.1.3-e01d5ea

package/dist/bin/index.js

@@ -4,7 +4,7 @@ import minimist from "minimist";
 import { disassemble, HasMetadata, InputKind, prepareProgram, runProgram } from "../build/release.js";
 const HELP_TEXT = `Usage:
   anan-as disassemble [--spi] [--no-metadata] <file.(jam|pvm|spi|bin)>
-  anan-as run [--spi] [--no-logs] [--no-metadata] [--pc <number>] [--gas <number>] <file.jam> [spi-args.bin or hex]
+  anan-as run [--spi] [--no-logs] [--no-metadata] [--pc <number>] [--gas <number>] <file.jam> [spi-args.bin]
 
 Commands:
   disassemble  Disassemble PVM bytecode to assembly
@@ -15,7 +15,7 @@ Flags:
   --no-metadata  Input does not contain metadata
   --no-logs      Disable execution logs (run command only)
   --pc <number>  Set initial program counter (default: 0)
-  --gas <number> Set initial gas amount (default: 10_000)
+  --gas <number> Set initial gas amount (default: 0)
   --help, -h     Show this help message`;
 main();
 function main() {
@@ -42,9 +42,8 @@ function main() {
 }
 function handleDisassemble(args) {
     const parsed = minimist(args, {
-        boolean: ["spi", "metadata", "help"],
+        boolean: ["spi", "no-metadata", "help"],
         alias: { h: "help" },
-        default: { metadata: true },
     });
     if (parsed.help) {
         console.log(HELP_TEXT);
@@ -77,7 +76,7 @@ function handleDisassemble(args) {
         process.exit(1);
     }
     const kind = parsed.spi ? InputKind.SPI : InputKind.Generic;
-    const hasMetadata = parsed.metadata ? HasMetadata.Yes : HasMetadata.No;
+    const hasMetadata = parsed["no-metadata"] ? HasMetadata.No : HasMetadata.Yes;
     const f = readFileSync(file);
     const name = kind === InputKind.Generic ? "generic PVM" : "JAM SPI";
     console.log(`🤖 Assembly of ${file} (as ${name})`);
@@ -85,11 +84,9 @@ function handleDisassemble(args) {
 }
 function handleRun(args) {
     const parsed = minimist(args, {
-        boolean: ["spi", "logs", "metadata", "help"],
-        /** Prevents parsing hex values as numbers. */
-        string: ["pc", "gas", "_"],
+        boolean: ["spi", "no-logs", "no-metadata", "help"],
+        string: ["pc", "gas"],
         alias: { h: "help" },
-        default: { metadata: true, logs: true },
     });
     if (parsed.help) {
         console.log(HELP_TEXT);
@@ -103,16 +100,16 @@ function handleRun(args) {
     }
     const kind = parsed.spi ? InputKind.SPI : InputKind.Generic;
     let programFile;
-    let spiArgsStr;
+    let spiArgsFile;
     if (kind === InputKind.SPI) {
-        // For SPI programs, expect: <program.spi> [spi-args.bin or hex]
+        // For SPI programs, expect: <program.spi> [spi-args.bin]
         if (files.length > 2) {
             console.error("Error: Too many arguments for SPI run command.");
-            console.error("Usage: anan-as run --spi [--no-logs] [--no-metadata] [--pc <number>] [--gas <number>] <program.spi> [spi-args.bin or hex]");
+            console.error("Usage: anan-as run --spi [--no-logs] [--no-metadata] [--pc <number>] [--gas <number>] <program.spi> [spi-args.bin]");
             process.exit(1);
         }
         programFile = files[0];
-        spiArgsStr = files[1]; // optional
+        spiArgsFile = files[1]; // optional
     }
     else {
         // For generic programs, expect exactly one file
@@ -123,116 +120,101 @@ function handleRun(args) {
         }
         programFile = files[0];
     }
+    // Validate program file extension
+    const expectedExt = kind === InputKind.SPI ? ".spi" : ".jam";
+    const dotIndex = programFile.lastIndexOf(".");
+    if (dotIndex === -1) {
+        console.error(`Error: File '${programFile}' has no extension.`);
+        console.error(`Expected: ${expectedExt}`);
+        process.exit(1);
+    }
+    const ext = programFile.substring(dotIndex);
+    if (ext !== expectedExt) {
+        console.error(`Error: Invalid file extension '${ext}' for run command.`);
+        console.error(`Expected: ${expectedExt}`);
+        process.exit(1);
+    }
     // Validate SPI args file if provided
-    const spiArgs = parseSpiArgs(spiArgsStr);
-    const logs = parsed.logs;
-    const hasMetadata = parsed.metadata ? HasMetadata.Yes : HasMetadata.No;
+    let spiArgs;
+    if (spiArgsFile) {
+        const argsDotIndex = spiArgsFile.lastIndexOf(".");
+        if (argsDotIndex === -1) {
+            console.error(`Error: SPI args file '${spiArgsFile}' has no extension.`);
+            console.error(`Expected: .bin`);
+            process.exit(1);
+        }
+        const argsExt = spiArgsFile.substring(argsDotIndex);
+        if (argsExt !== ".bin") {
+            console.error(`Error: SPI args file must have .bin extension, got '${argsExt}'.`);
+            process.exit(1);
+        }
+        spiArgs = new Uint8Array(readFileSync(spiArgsFile));
+    }
+    const logs = !parsed["no-logs"];
+    const hasMetadata = parsed["no-metadata"] ? HasMetadata.No : HasMetadata.Yes;
     // Parse and validate PC and gas options
-    const initialPc = parsePc(parsed);
-    const initialGas = parseGas(parsed);
-    const programCode = Array.from(readFileSync(programFile));
+    let initialPc = 0;
+    if (parsed.pc !== undefined) {
+        // Ensure it's a string/number, not boolean
+        if (typeof parsed.pc === "boolean") {
+            console.error("Error: --pc requires a value.");
+            process.exit(1);
+        }
+        const pcStr = String(parsed.pc);
+        // Reject floats and non-integer strings
+        if (pcStr.includes(".") || !/^-?\d+$/.test(pcStr)) {
+            console.error("Error: --pc must be a valid integer.");
+            process.exit(1);
+        }
+        const pcValue = parseInt(pcStr, 10);
+        if (!Number.isInteger(pcValue) || pcValue < 0 || pcValue > 0xffffffff) {
+            console.error("Error: --pc must be a non-negative integer <= 2^32-1.");
+            process.exit(1);
+        }
+        initialPc = pcValue;
+    }
+    let initialGas = BigInt(0);
+    if (parsed.gas !== undefined) {
+        // Ensure it's a string/number, not boolean
+        if (typeof parsed.gas === "boolean") {
+            console.error("Error: --gas requires a value.");
+            process.exit(1);
+        }
+        const gasStr = String(parsed.gas);
+        // Reject floats and non-integer strings
+        if (gasStr.includes(".") || !/^-?\d+$/.test(gasStr)) {
+            console.error("Error: --gas must be a valid integer.");
+            process.exit(1);
+        }
+        let gasValue;
+        try {
+            gasValue = BigInt(gasStr);
+        }
+        catch (_e) {
+            console.error("Error: --gas must be a valid integer.");
+            process.exit(1);
+        }
+        const MAX_I64 = (1n << 63n) - 1n;
+        if (gasValue < 0n || gasValue > MAX_I64) {
+            console.error("Error: --gas must be a non-negative integer <= 2^63-1.");
+            process.exit(1);
+        }
+        initialGas = gasValue;
+    }
+    const f = readFileSync(programFile);
     const name = kind === InputKind.Generic ? "generic PVM" : "JAM SPI";
     console.log(`🚀 Running ${programFile} (as ${name})`);
     try {
-        const program = prepareProgram(kind, hasMetadata, programCode, [], [], [], spiArgs);
+        const program = prepareProgram(kind, hasMetadata, Array.from(f), [], [], [], spiArgs ? Array.from(spiArgs) : []);
         const result = runProgram(program, initialGas, initialPc, logs, false);
         console.log(`Status: ${result.status}`);
         console.log(`Exit code: ${result.exitCode}`);
         console.log(`Program counter: ${result.pc}`);
         console.log(`Gas remaining: ${result.gas}`);
         console.log(`Registers: [${result.registers.join(", ")}]`);
-        console.log(`Result: [${hexEncode(result.result)}]`);
     }
     catch (error) {
         console.error(`Error running ${programFile}:`, error);
         process.exit(1);
     }
 }
-function parseGas(parsed) {
-    if (parsed.gas === undefined) {
-        return BigInt(10_000);
-    }
-    // Ensure it's a string/number, not boolean
-    if (typeof parsed.gas === "boolean") {
-        console.error("Error: --gas requires a value.");
-        process.exit(1);
-    }
-    const gasStr = String(parsed.gas);
-    // Reject floats and non-integer strings
-    if (gasStr.includes(".") || !/^-?\d+$/.test(gasStr)) {
-        console.error("Error: --gas must be a valid integer.");
-        process.exit(1);
-    }
-    let gasValue;
-    try {
-        gasValue = BigInt(gasStr);
-    }
-    catch (_e) {
-        console.error("Error: --gas must be a valid integer.");
-        process.exit(1);
-    }
-    const MAX_I64 = (1n << 63n) - 1n;
-    if (gasValue < 0n || gasValue > MAX_I64) {
-        console.error("Error: --gas must be a non-negative integer <= 2^63-1.");
-        process.exit(1);
-    }
-    return gasValue;
-}
-function parseSpiArgs(spiArgsStr) {
-    if (!spiArgsStr) {
-        return [];
-    }
-    try {
-        return Array.from(hexDecode(spiArgsStr));
-    }
-    catch (e) {
-        console.log(`Attempting to read ${spiArgsStr} as a file, since it's not a hex value: ${e}`);
-        return Array.from(readFileSync(spiArgsStr));
-    }
-}
-function parsePc(parsed) {
-    if (parsed.pc === undefined) {
-        return 0;
-    }
-    // Ensure it's a string/number, not boolean
-    if (typeof parsed.pc === "boolean") {
-        console.error("Error: --pc requires a value.");
-        process.exit(1);
-    }
-    const pcStr = String(parsed.pc);
-    // Reject floats and non-integer strings
-    if (pcStr.includes(".") || !/^-?\d+$/.test(pcStr)) {
-        console.error("Error: --pc must be a valid integer.");
-        process.exit(1);
-    }
-    const pcValue = parseInt(pcStr, 10);
-    if (!Number.isInteger(pcValue) || pcValue < 0 || pcValue > 0xffffffff) {
-        console.error("Error: --pc must be a non-negative integer <= 2^32-1.");
-        process.exit(1);
-    }
-    return pcValue;
-}
-function hexEncode(result) {
-    return `0x${result.map((x) => x.toString(16).padStart(2, "0")).join("")}`;
-}
-function hexDecode(data) {
-    if (!data.startsWith("0x")) {
-        throw new Error("hex input must start with 0x");
-    }
-    const hex = data.substring(2);
-    const len = hex.length;
-    if (len % 2 === 1) {
-        throw new Error("Odd number of nibbles");
-    }
-    const bytes = new Uint8Array(len / 2);
-    for (let i = 0; i < len; i += 2) {
-        const c = hex.substring(i, i + 2);
-        const byteIndex = i / 2;
-        const value = parseInt(c, 16);
-        if (Number.isNaN(value)) {
-            throw new Error(`hexDecode: invalid hex pair "${c}" in data "${data}" for bytes[${byteIndex}]`);
-        }
-        bytes[byteIndex] = value;
-    }
-    return bytes;
-}

package/dist/bin/test-w3f.js

@@ -68,8 +68,6 @@ function processW3f(data, options) {
     }
     // compare with expected values
     const expected = {
-        // just copy JAM-output result field
-        result: result.result,
         status: read(data, "expected-status"),
         registers: read(data, "expected-regs").map((x) => BigInt(x)),
         pc: read(data, "expected-pc"),