@fluffylabs/anan-as 1.1.6 → 1.2.0-1c29182

package/dist/bin/index.js

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
-import minimist from "minimist";
-import { disassemble, HasMetadata, InputKind, prepareProgram, pvmDestroy, pvmResume, pvmSetRegisters, pvmStart, } from "../build/release.js";
+import { parseArgs } from "node:util";
+import { disassemble, HasMetadata, InputKind, prepareProgram, pvmDestroy, pvmReadMemory, pvmResume, pvmSetRegisters, pvmStart, } from "../build/release.js";
 import { LOG_GAS_COST, LOG_HOST_CALL_INDEX, printLogHostCall, WHAT } from "./src/log-host-call.js";
 import { STATUS } from "./src/trace-parse.js";
 import { replayTraceFile } from "./src/trace-replay.js";
 import { hexDecode, hexEncode } from "./src/utils.js";
+// Page access modes (matches assembly/memory-page.ts Access enum)
+const ACCESS_READ = 1;
+const ACCESS_WRITE = 2;
 const HELP_TEXT = `Usage:
   anan-as disassemble [--spi] [--no-metadata] <file.(jam|pvm|spi|bin)>
-  anan-as run [--spi] [--no-logs] [--no-metadata] [--no-log-host-call] [--pc <number>] [--gas <number>] <file.jam> [spi-args.bin or hex]
+  anan-as run [--spi] [--no-logs] [--no-metadata] [--no-log-host-call] [--pc <number>] [--gas <number>] [--regs <r0,r1,...,r12>] <file.jam> [spi-args.bin or hex]
   anan-as replay-trace [--no-metadata] [--no-verify] [--no-logs] [--no-log-host-call] <trace.log>
 
 Commands:
@@ -24,6 +27,10 @@ Flags:
   --no-verify         Skip verification against trace data (replay-trace only)
   --pc <number>       Set initial program counter (default: 0)
   --gas <number>      Set initial gas amount (default: 10_000)
+  --regs <values>     Set initial registers (comma-separated, 13 values: r0,r1,...,r12; supports decimal and 0x hex)
+  --pages <specs>     Add memory pages (semicolon-separated: "addr:size;addr:size:ro"; append ":r" or ":ro" for read-only)
+  --mem <specs>       Initialize memory (semicolon-separated: "addr:hex_bytes;addr:hex_bytes")
+  --dump <specs>      Dump memory after execution (semicolon-separated: "addr:len;addr:len")
   --help, -h          Show this help message`;
 main();
 function main() {
@@ -52,16 +59,19 @@ function main() {
     }
 }
 function handleDisassemble(args) {
-    const parsed = minimist(args, {
-        boolean: ["spi", "metadata", "help"],
-        alias: { h: "help" },
-        default: { metadata: true },
+    const { values, positionals: files } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            spi: { type: "boolean", default: false },
+            "no-metadata": { type: "boolean", default: false },
+            help: { type: "boolean", short: "h", default: false },
+        },
     });
-    if (parsed.help) {
+    if (values.help) {
         console.log(HELP_TEXT);
         return;
     }
-    const files = parsed._;
     if (files.length === 0) {
         console.error("Error: No file provided for disassemble command.");
         console.error("Usage: anan-as disassemble [--spi] [--no-metadata] <file.(jam|pvm|spi|bin)>");
@@ -87,32 +97,41 @@ function handleDisassemble(args) {
         console.error("Supported extensions: .jam, .pvm, .spi, .bin");
         process.exit(1);
     }
-    const kind = parsed.spi ? InputKind.SPI : InputKind.Generic;
-    const hasMetadata = parsed.metadata ? HasMetadata.Yes : HasMetadata.No;
+    const kind = values.spi ? InputKind.SPI : InputKind.Generic;
+    const hasMetadata = values["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})`);
     console.log(disassemble(Array.from(f), kind, hasMetadata));
 }
 function handleRun(args) {
-    const parsed = minimist(args, {
-        boolean: ["spi", "logs", "metadata", "help", "log-host-call"],
-        /** Prevents parsing hex values as numbers. */
-        string: ["pc", "gas", "_"],
-        alias: { h: "help" },
-        default: { metadata: true, logs: true, "log-host-call": true },
+    const { values, positionals: files } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            spi: { type: "boolean", default: false },
+            "no-logs": { type: "boolean", default: false },
+            "no-metadata": { type: "boolean", default: false },
+            "no-log-host-call": { type: "boolean", default: false },
+            help: { type: "boolean", short: "h", default: false },
+            pc: { type: "string" },
+            gas: { type: "string" },
+            regs: { type: "string" },
+            pages: { type: "string" },
+            mem: { type: "string" },
+            dump: { type: "string" },
+        },
     });
-    if (parsed.help) {
+    if (values.help) {
         console.log(HELP_TEXT);
         return;
     }
-    const files = parsed._;
     if (files.length === 0) {
         console.error("Error: No file provided for run command.");
         console.error("Usage: anan-as run [--spi] [--no-logs] [--no-metadata] [--pc <number>] [--gas <number>] <file.jam> [spi-args.bin]");
         process.exit(1);
     }
-    const kind = parsed.spi ? InputKind.SPI : InputKind.Generic;
+    const kind = values.spi ? InputKind.SPI : InputKind.Generic;
     let programFile;
     let spiArgsStr;
     if (kind === InputKind.SPI) {
@@ -136,19 +155,24 @@ function handleRun(args) {
     }
     // Validate SPI args file if provided
     const spiArgs = parseSpiArgs(spiArgsStr);
-    const logs = parsed.logs;
-    const logHostCall = parsed["log-host-call"];
-    const hasMetadata = parsed.metadata ? HasMetadata.Yes : HasMetadata.No;
+    const logs = !values["no-logs"];
+    const logHostCall = !values["no-log-host-call"];
+    const hasMetadata = values["no-metadata"] ? HasMetadata.No : HasMetadata.Yes;
     // Parse and validate PC and gas options
-    const initialPc = parsePc(parsed);
-    const initialGas = parseGas(parsed);
+    const initialPc = parsePc(values.pc);
+    const initialGas = parseGas(values.gas);
+    const initialRegisters = parseRegs(values.regs);
+    const initialPages = parsePages(values.pages);
+    const initialMemory = parseMem(values.mem);
+    const dumpRegions = parseDump(values.dump);
     const programCode = Array.from(readFileSync(programFile));
     const name = kind === InputKind.Generic ? "generic PVM" : "JAM SPI";
     console.log(`🚀 Running ${programFile} (as ${name})`);
     try {
         const preallocateMemoryPages = 128;
-        const program = prepareProgram(kind, hasMetadata, programCode, [], [], [], spiArgs, preallocateMemoryPages);
-        const id = pvmStart(program, false);
+        const useBlockGas = true;
+        const program = prepareProgram(kind, hasMetadata, programCode, initialRegisters, initialPages, initialMemory, spiArgs, preallocateMemoryPages, useBlockGas);
+        const id = pvmStart(program);
         let gas = initialGas;
         let pc = initialPc;
         for (;;) {
@@ -171,6 +195,24 @@ function handleRun(args) {
                 break;
             }
         }
+        // Dump memory regions before destroying the VM
+        for (const region of dumpRegions) {
+            const data = pvmReadMemory(id, region.address, region.length);
+            const addrHex = `0x${region.address.toString(16)}`;
+            if (data) {
+                console.log(`\nMemory @ ${addrHex} (${region.length} bytes):`);
+                for (let off = 0; off < data.length; off += 16) {
+                    const addr = region.address + off;
+                    const slice = Array.from(data.slice(off, Math.min(off + 16, data.length)));
+                    const hex = slice.map((b) => b.toString(16).padStart(2, "0")).join(" ");
+                    const ascii = slice.map((b) => (b >= 0x20 && b < 0x7f ? String.fromCharCode(b) : ".")).join("");
+                    console.log(`  ${addr.toString(16).padStart(8, "0")}:  ${hex.padEnd(47)}  ${ascii}`);
+                }
+            }
+            else {
+                console.log(`\nMemory @ ${addrHex}: <page fault>`);
+            }
+        }
         const result = pvmDestroy(id);
         console.log(`Status: ${result?.status}`);
         console.log(`Exit code: ${result?.exitCode}`);
@@ -185,16 +227,21 @@ function handleRun(args) {
     }
 }
 function handleReplayTrace(args) {
-    const parsed = minimist(args, {
-        boolean: ["metadata", "verify", "logs", "help", "log-host-call"],
-        alias: { h: "help" },
-        default: { metadata: true, logs: true, verify: true, "log-host-call": true },
+    const { values, positionals: files } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            "no-metadata": { type: "boolean", default: false },
+            "no-verify": { type: "boolean", default: false },
+            "no-logs": { type: "boolean", default: false },
+            "no-log-host-call": { type: "boolean", default: false },
+            help: { type: "boolean", short: "h", default: false },
+        },
     });
-    if (parsed.help) {
+    if (values.help) {
         console.log(HELP_TEXT);
         return;
     }
-    const files = parsed._;
     if (files.length === 0) {
         console.error("Error: No trace file provided for replay-trace command.");
         console.error("Usage: anan-as replay-trace [--no-metadata] [--no-verify] [--no-logs] <trace.log>");
@@ -206,10 +253,10 @@ function handleReplayTrace(args) {
         process.exit(1);
     }
     const file = files[0];
-    const hasMetadata = parsed.metadata ? HasMetadata.Yes : HasMetadata.No;
-    const verify = parsed.verify;
-    const logs = parsed.logs;
-    const logHostCall = parsed["log-host-call"];
+    const hasMetadata = values["no-metadata"] ? HasMetadata.No : HasMetadata.Yes;
+    const verify = !values["no-verify"];
+    const logs = !values["no-logs"];
+    const logHostCall = !values["no-log-host-call"];
     try {
         const summary = replayTraceFile(file, {
             logs,
@@ -227,16 +274,10 @@ function handleReplayTrace(args) {
         process.exit(1);
     }
 }
-function parseGas(parsed) {
-    if (parsed.gas === undefined) {
+function parseGas(gasStr) {
+    if (gasStr === 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.");
@@ -269,16 +310,10 @@ function parseSpiArgs(spiArgsStr) {
         return Array.from(readFileSync(spiArgsStr));
     }
 }
-function parsePc(parsed) {
-    if (parsed.pc === undefined) {
+function parsePc(pcStr) {
+    if (pcStr === 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.");
@@ -291,3 +326,101 @@ function parsePc(parsed) {
     }
     return pcValue;
 }
+function parseRegs(regsStr) {
+    if (regsStr === undefined) {
+        return [];
+    }
+    const parts = regsStr.split(",");
+    if (parts.length !== 13) {
+        throw new Error(`--regs must have exactly 13 comma-separated values (got ${parts.length}).\nFormat: --regs r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12`);
+    }
+    return parts.map((s, i) => {
+        try {
+            return BigInt.asUintN(64, BigInt(s.trim()));
+        }
+        catch (_e) {
+            throw new Error(`--regs value at index ${i} ("${s.trim()}") is not a valid integer.`);
+        }
+    });
+}
+function parseNum(s) {
+    return Number(s.trim());
+}
+function parsePages(pagesStr) {
+    if (pagesStr === undefined) {
+        return [];
+    }
+    // Format: "addr:size;addr:size" — all pages are writable
+    // Or "addr:size:ro" (or "addr:size:r") for read-only
+    const specs = pagesStr.split(";").filter((s) => s.trim().length > 0);
+    return specs.map((spec, i) => {
+        const parts = spec.split(":");
+        if (parts.length < 2 || parts.length > 3) {
+            throw new Error(`--pages entry ${i} ("${spec}") must be "addr:size" or "addr:size:ro" (or "addr:size:r").`);
+        }
+        const address = parseNum(parts[0]);
+        const length = parseNum(parts[1]);
+        const flag = parts[2]?.trim();
+        const access = flag === "ro" || flag === "r" ? ACCESS_READ : ACCESS_WRITE;
+        if (Number.isNaN(address) || Number.isNaN(length) || length <= 0) {
+            throw new Error(`--pages entry ${i} ("${spec}") has invalid address or size.`);
+        }
+        return { address, length, access };
+    });
+}
+function parseMem(memStr) {
+    if (memStr === undefined) {
+        return [];
+    }
+    // Format: "addr:hexbytes;addr:hexbytes"
+    // Example: "0x20000:0500000000000000;0x20008:0300000000000000"
+    const specs = memStr.split(";").filter((s) => s.trim().length > 0);
+    return specs.map((spec, i) => {
+        const colonIdx = spec.indexOf(":");
+        if (colonIdx === -1) {
+            throw new Error(`--mem entry ${i} ("${spec}") must be "addr:hexbytes".`);
+        }
+        const addrStr = spec.substring(0, colonIdx).trim();
+        let hexStr = spec.substring(colonIdx + 1).trim();
+        const address = parseNum(addrStr);
+        if (Number.isNaN(address)) {
+            throw new Error(`--mem entry ${i} has invalid address "${addrStr}".`);
+        }
+        // Strip 0x prefix from hex data
+        if (hexStr.startsWith("0x") || hexStr.startsWith("0X")) {
+            hexStr = hexStr.substring(2);
+        }
+        if (hexStr.length % 2 !== 0) {
+            throw new Error(`--mem entry ${i} hex data has odd length.`);
+        }
+        const data = [];
+        for (let j = 0; j < hexStr.length; j += 2) {
+            const byte = parseInt(hexStr.substring(j, j + 2), 16);
+            if (Number.isNaN(byte)) {
+                throw new Error(`--mem entry ${i} has invalid hex byte at position ${j}: "${hexStr.substring(j, j + 2)}".`);
+            }
+            data.push(byte);
+        }
+        return { address, data };
+    });
+}
+function parseDump(dumpStr) {
+    if (dumpStr === undefined) {
+        return [];
+    }
+    // Format: "addr:len;addr:len"
+    // Example: "0x20000:64;0x20100:32"
+    const specs = dumpStr.split(";").filter((s) => s.trim().length > 0);
+    return specs.map((spec, i) => {
+        const parts = spec.split(":");
+        if (parts.length !== 2) {
+            throw new Error(`--dump entry ${i} ("${spec}") must be "addr:len".`);
+        }
+        const address = parseNum(parts[0]);
+        const length = parseNum(parts[1]);
+        if (Number.isNaN(address) || Number.isNaN(length) || length <= 0) {
+            throw new Error(`--dump entry ${i} ("${spec}") has invalid address or length.`);
+        }
+        return { address, length };
+    });
+}

package/dist/bin/src/fuzz.js

@@ -21,7 +21,7 @@ export function fuzz(data) {
             .join(",")
             .split(",")
             .map(() => BigInt(0));
-        const exe = prepareProgram(InputKind.Generic, HasMetadata.No, Array.from(program), registers, [], [], [], 0);
+        const exe = prepareProgram(InputKind.Generic, HasMetadata.No, Array.from(program), registers, [], [], [], 0, false);
         const output = runProgram(exe, gas, pc, printDebugInfo);
         const vmRegisters = decodeRegistersFromTypeberry(vm);
         collectErrors((assertFn) => {

package/dist/bin/src/test-json.js

@@ -16,18 +16,14 @@ export function run(processJson, options) {
             args.shift();
             options.isDebug = true;
         }
-        else if (args[0] === "--sbrk-gas") {
-            args.shift();
-            options.useSbrkGas = true;
-        }
         else {
             break;
         }
     }
     if (args.length === 0) {
         console.error("Error: No JSON files provided.");
-        console.error("Usage: index.js [--debug] [--sbrk-gas] <file1.json> [file2.json ...]");
-        console.error("read from stdin: index.js [--debug] [--sbrk-gas] -");
+        console.error("Usage: index.js [--debug] <file1.json> [file2.json ...]");
+        console.error("read from stdin: index.js [--debug] -");
         process.exit(1);
     }
     if (args[0] === "-") {

package/dist/bin/src/trace-replay.js

@@ -1,10 +1,12 @@
 import { readFileSync } from "node:fs";
-import { InputKind, prepareProgram, pvmDestroy, pvmReadMemory, pvmResume, pvmSetRegisters, pvmStart, pvmWriteMemory, } from "../../build/release.js";
+import * as defaultPvm from "../../build/release.js";
 import { LOG_HOST_CALL_INDEX, printLogHostCall } from "./log-host-call.js";
 import { ARGS_SEGMENT_START, buildInitialChunks, buildInitialPages, encodeRegistersFromDump, extractSpiArgs, isSpiTrace, parseTrace, STATUS, statusToTermination, } from "./trace-parse.js";
 import { ConsoleTracer } from "./tracer.js";
 import { hexEncode } from "./utils.js";
 export function replayTraceFile(filePath, options) {
+    const pvm = options.pvm ?? defaultPvm;
+    const { prepareProgram, pvmStart, pvmDestroy, pvmResume, pvmReadMemory, pvmWriteMemory, pvmSetRegisters, InputKind } = pvm;
     const input = readFileSync(filePath, "utf8");
     const trace = parseTrace(input);
     const { program, initialMemWrites, start, ecalliEntries, termination } = trace;
@@ -12,10 +14,12 @@ export function replayTraceFile(filePath, options) {
     const useSpi = isSpiTrace(start, initialMemWrites);
     const programInput = Array.from(program);
     const spiArgs = Array.from(extractSpiArgs(start, initialMemWrites));
+    const preallocateMemoryPages = 128;
+    const useBlockGas = options.useBlockGas ?? false;
     const preparedProgram = useSpi
-        ? prepareProgram(InputKind.SPI, hasMetadata, programInput, [], [], [], spiArgs, 0)
-        : prepareProgram(InputKind.Generic, hasMetadata, programInput, encodeRegistersFromDump(start.registers), buildInitialPages(initialMemWrites), buildInitialChunks(initialMemWrites), [], 0);
-    const id = pvmStart(preparedProgram, true);
+        ? prepareProgram(InputKind.SPI, hasMetadata, programInput, [], [], [], spiArgs, preallocateMemoryPages, useBlockGas)
+        : prepareProgram(InputKind.Generic, hasMetadata, programInput, encodeRegistersFromDump(start.registers), buildInitialPages(initialMemWrites), buildInitialChunks(initialMemWrites), [], preallocateMemoryPages, useBlockGas);
+    const id = pvmStart(preparedProgram);
     const initialEcalliCount = ecalliEntries.length;
     const tracer = options.tracer ?? new ConsoleTracer();
     try {