@fluffylabs/anan-as 1.1.3-c185e54 → 1.1.3-c81d96c

package/dist/bin/index.js

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
 import minimist from "minimist";
-import { disassemble, HasMetadata, InputKind, prepareProgram, runProgram } from "../build/release.js";
+import { disassemble, HasMetadata, InputKind, prepareProgram, pvmDestroy, 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";
 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 replay-trace [--no-metadata] [--no-verify] [--no-logs] <trace.log>
+  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 replay-trace [--no-metadata] [--no-verify] [--no-logs] [--no-log-host-call] <trace.log>
 
 Commands:
   disassemble  Disassemble PVM bytecode to assembly
@@ -15,13 +17,14 @@ Commands:
   replay-trace  Re-execute a ecalli IO trace
 
 Flags:
-  --spi          Treat input as JAM SPI format
-  --no-metadata  Input does not contain metadata
-  --no-logs      Disable execution logs
-  --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)
-  --help, -h     Show this help message`;
+  --spi               Treat input as JAM SPI format
+  --no-metadata       Input does not contain metadata
+  --no-logs           Disable execution logs
+  --no-log-host-call  Disable built-in handling of JIP-1 log host call (ecalli 100)
+  --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)
+  --help, -h          Show this help message`;
 main();
 function main() {
     const args = process.argv.slice(2);
@@ -93,11 +96,11 @@ function handleDisassemble(args) {
 }
 function handleRun(args) {
     const parsed = minimist(args, {
-        boolean: ["spi", "logs", "metadata", "help"],
+        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 },
+        default: { metadata: true, logs: true, "log-host-call": true },
     });
     if (parsed.help) {
         console.log(HELP_TEXT);
@@ -134,6 +137,7 @@ 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;
     // Parse and validate PC and gas options
     const initialPc = parsePc(parsed);
@@ -143,13 +147,36 @@ function handleRun(args) {
     console.log(`🚀 Running ${programFile} (as ${name})`);
     try {
         const program = prepareProgram(kind, hasMetadata, programCode, [], [], [], 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)}]`);
+        const id = pvmStart(program, false);
+        let gas = initialGas;
+        let pc = initialPc;
+        for (;;) {
+            const pause = pvmResume(id, gas, pc, logs);
+            if (!pause) {
+                throw new Error("pvmResume returned null");
+            }
+            if (pause.status === STATUS.HOST && pause.exitCode === LOG_HOST_CALL_INDEX && logHostCall) {
+                printLogHostCall(id, pause.registers);
+                // Set r7 = WHAT
+                const regs = pause.registers;
+                regs[7] = WHAT;
+                pvmSetRegisters(id, regs);
+                // Deduct gas and advance PC
+                gas = pause.gas >= LOG_GAS_COST ? pause.gas - LOG_GAS_COST : 0n;
+                pc = pause.nextPc;
+            }
+            else {
+                console.warn(`Unhandled host call: ecalli ${pause.exitCode}. Finishing.`);
+                break;
+            }
+        }
+        const result = pvmDestroy(id);
+        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);
@@ -158,9 +185,9 @@ function handleRun(args) {
 }
 function handleReplayTrace(args) {
     const parsed = minimist(args, {
-        boolean: ["metadata", "verify", "logs", "help"],
+        boolean: ["metadata", "verify", "logs", "help", "log-host-call"],
         alias: { h: "help" },
-        default: { metadata: true, logs: true, verify: true },
+        default: { metadata: true, logs: true, verify: true, "log-host-call": true },
     });
     if (parsed.help) {
         console.log(HELP_TEXT);
@@ -181,11 +208,13 @@ function handleReplayTrace(args) {
     const hasMetadata = parsed.metadata ? HasMetadata.Yes : HasMetadata.No;
     const verify = parsed.verify;
     const logs = parsed.logs;
+    const logHostCall = parsed["log-host-call"];
     try {
         const summary = replayTraceFile(file, {
             logs,
             hasMetadata,
             verify,
+            logHostCall,
         });
         console.log(`✅ Replay complete: ${summary.ecalliCount} ecalli entries`);
         console.log(`Status: ${summary.termination.type}`);

package/dist/bin/src/fuzz.js

@@ -58,7 +58,7 @@ export function fuzz(data) {
 }
 import { hexEncode } from "./utils.js";
 function programHex(program) {
-    return hexEncode(Array.from(program), false);
+    return hexEncode(program, false);
 }
 function linkTo(programHex) {
     return `https://pvm.fluffylabs.dev/?program=0x${programHex}#/`;

package/dist/bin/src/log-host-call.js

@@ -0,0 +1,41 @@
+import { pvmReadMemory } from "../../build/release.js";
+export const LOG_HOST_CALL_INDEX = 100;
+export const LOG_GAS_COST = 10n;
+/** The WHAT return value - indicates the host call is not implemented / acknowledged. */
+export const WHAT = 0xfffffffffffffffen;
+const LOG_LEVELS = ["FATAL", "ERROR", "WARN", "INFO", "DEBUG"];
+const MAX_LOG_LEN = 8192;
+/**
+ * Print the log message from a JIP-1 log host call (ecalli 100).
+ *
+ * Reads the level, target, and message from the PVM registers and memory,
+ * then prints via console.info.
+ */
+export function printLogHostCall(pvmId, registers) {
+    const level = Number(registers[7]);
+    const targetPtr = Number(registers[8] & 0xffffffffn);
+    const targetLen = Math.min(Math.max(0, Number(registers[9] & 0xffffffffn)), MAX_LOG_LEN);
+    const messagePtr = Number(registers[10] & 0xffffffffn);
+    const messageLen = Math.min(Math.max(0, Number(registers[11] & 0xffffffffn)), MAX_LOG_LEN);
+    const levelStr = LOG_LEVELS[level] ?? `LEVEL(${level})`;
+    let target = "";
+    if (targetPtr !== 0 && targetLen > 0) {
+        const targetBytes = pvmReadMemory(pvmId, targetPtr, targetLen);
+        if (targetBytes) {
+            target = new TextDecoder().decode(targetBytes);
+        }
+    }
+    let message = "";
+    if (messagePtr !== 0 && messageLen > 0) {
+        const messageBytes = pvmReadMemory(pvmId, messagePtr, messageLen);
+        if (messageBytes) {
+            message = new TextDecoder().decode(messageBytes);
+        }
+    }
+    if (target) {
+        console.info(`[${levelStr}] ${target}: ${message}`);
+    }
+    else {
+        console.info(`[${levelStr}] ${message}`);
+    }
+}

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

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import { InputKind, prepareProgram, pvmDestroy, pvmReadMemory, pvmResume, pvmSetRegisters, pvmStart, pvmWriteMemory, } 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";
@@ -37,6 +38,10 @@ export function replayTraceFile(filePath, options) {
                 }
                 // Print ecalli line
                 tracer.ecalli(expectedEcalli.index, pause.pc, pause.gas, pause.registers);
+                // Print log message for JIP-1 log host call
+                if (pause.exitCode === LOG_HOST_CALL_INDEX && options.logHostCall) {
+                    printLogHostCall(id, pause.registers);
+                }
                 if (options.verify) {
                     assertEq(pause.exitCode, expectedEcalli.index, "ecalli index");
                     assertEq(pause.pc, expectedEcalli.pc, "ecalli pc");
@@ -119,7 +124,7 @@ function assertRegisters(actual, expected) {
     }
 }
 function assertMemEq(actual, expected, label) {
-    const actualString = hexEncode(Array.from(actual));
-    const expectedString = hexEncode(Array.from(expected));
+    const actualString = hexEncode(actual);
+    const expectedString = hexEncode(expected);
     assertEq(actualString, expectedString, label);
 }

package/dist/bin/src/utils.js

@@ -1,5 +1,5 @@
 export function hexEncode(result, includePrefix = true) {
-    const hex = result.map((x) => x.toString(16).padStart(2, "0")).join("");
+    const hex = Array.from(result, (x) => x.toString(16).padStart(2, "0")).join("");
     return includePrefix ? `0x${hex}` : hex;
 }
 export function hexDecode(data) {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@fluffylabs/anan-as",
 	"description": "AssemblyScript PVM interpreter.",
-	"version": "1.1.3-c185e54",
+	"version": "1.1.3-c81d96c",
 	"main": "./dist/bin/index.js",
 	"bin": {
 		"anan-as": "./dist/bin/index.js"