@fluffylabs/anan-as 1.2.0-abcb88c → 1.2.0-b6d0f93

package/dist/bin/index.js

@@ -91,7 +91,7 @@ function handleDisassemble(args) {
         console.error("Supported extensions: .jam, .pvm, .spi, .bin");
         process.exit(1);
     }
-    const ext = file.substring(dotIndex);
+    const ext = file.slice(dotIndex);
     if (!validExtensions.includes(ext)) {
         console.error(`Error: Invalid file extension '${ext}' for disassemble command.`);
         console.error("Supported extensions: .jam, .pvm, .spi, .bin");
@@ -380,25 +380,26 @@ function parseMem(memStr) {
         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 addrStr = spec.slice(0, colonIdx).trim();
+        let hexStr = spec.slice(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);
+            hexStr = hexStr.slice(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)}".`);
+            const pair = hexStr.slice(j, j + 2);
+            if (!/^[0-9a-fA-F]{2}$/.test(pair)) {
+                throw new Error(`--mem entry ${i} has invalid hex byte at position ${j}: "${pair}".`);
             }
+            const byte = parseInt(pair, 16);
             data.push(byte);
         }
         return { address, data };

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

@@ -1,3 +1,4 @@
+// Trace format: https://github.com/FluffyLabs/jam-ecalli-trace/blob/main/ecalli-trace-jip.md
 const NO_OF_REGISTERS = 13;
 // Access.Write = 2 from assembly/memory-page.ts
 const ACCESS_WRITE = 2;

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

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 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 { 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) {
@@ -25,11 +25,12 @@ export function replayTraceFile(filePath, options) {
     try {
         let gas = start.gas;
         let pc = start.pc;
-        // Print start line
-        tracer.start(pc, gas, start.registers);
-        if (spiArgs.length > 0) {
-            tracer.spiArgs(ARGS_SEGMENT_START, spiArgs);
+        // Print prelude: program, initial memwrites, start
+        tracer.program(program);
+        for (const write of initialMemWrites) {
+            tracer.memwrite(write.address, write.data);
         }
+        tracer.start(pc, gas, start.registers);
         for (;;) {
             const pause = pvmResume(id, gas, pc, options.logs);
             if (!pause) {

package/dist/bin/src/tracer.js

@@ -1,29 +1,29 @@
-import { hexEncode } from "./utils.js";
+// Trace output format: https://github.com/FluffyLabs/jam-ecalli-trace/blob/main/ecalli-trace-jip.md
 export class ConsoleTracer {
+    program(data) {
+        console.log(`program ${formatHex(data)}`);
+    }
     start(pc, gas, registers) {
         console.log(`start pc=${pc} gas=${gas} ${formatRegisters(registers)}`);
     }
-    spiArgs(address, data) {
-        console.log(`  memwrite ${address} len=${data.length} <- ${hexEncode(data)}`);
-    }
     ecalli(index, pc, gas, registers) {
-        console.log(`\necalli=${index} pc=${pc} gas=${gas} ${formatRegisters(registers)}`);
+        console.log(`ecalli=${index} pc=${pc} gas=${gas} ${formatRegisters(registers)}`);
     }
     memread(address, data) {
-        console.log(`  memread 0x${address.toString(16)} len=${data.length} -> ${formatHex(data)}`);
+        console.log(` memread ${formatAddress(address)} len=${data.length} -> ${formatHex(data)}`);
     }
     memwrite(address, data) {
-        console.log(`  memwrite 0x${address.toString(16)} len=${data.length} <- ${formatHex(data)}`);
+        console.log(` memwrite ${formatAddress(address)} len=${data.length} <- ${formatHex(data)}`);
     }
     setreg(index, value) {
-        console.log(`  setreg r${index.toString().padStart(2, "0")} <- 0x${value.toString(16)}`);
+        console.log(` setreg r${index.toString().padStart(2, "0")} <- 0x${value.toString(16)}`);
     }
     setgas(gas) {
-        console.log(`  setgas <- ${gas}`);
+        console.log(` setgas <- ${gas}`);
     }
     termination(type, exitCode, pc, gas, registers) {
-        let termLine = `\n------\n${type}`;
-        if (type === "PANIC" && exitCode !== 0) {
+        let termLine = `${type}`;
+        if (type === "PANIC") {
             termLine += `=${exitCode}`;
         }
         termLine += ` pc=${pc} gas=${gas} ${formatRegisters(registers)}`;
@@ -31,8 +31,8 @@ export class ConsoleTracer {
     }
 }
 export class NoOpTracer {
+    program() { }
     start() { }
-    spiArgs() { }
     ecalli() { }
     memread() { }
     memwrite() { }
@@ -56,9 +56,12 @@ function formatRegisters(registers) {
     }
     return entries
         .sort((a, b) => a.idx - b.idx)
-        .map((e) => `r${e.idx}=0x${e.val.toString(16)}`)
+        .map((e) => `r${e.idx.toString().padStart(2, "0")}=0x${e.val.toString(16)}`)
         .join(" ");
 }
+function formatAddress(address) {
+    return `0x${Number(address).toString(16).padStart(8, "0")}`;
+}
 function formatHex(data) {
     return `0x${Buffer.from(data).toString("hex")}`;
 }

package/dist/bin/src/utils.js

@@ -6,14 +6,14 @@ export function hexDecode(data) {
     if (!data.startsWith("0x")) {
         throw new Error("hex input must start with 0x");
     }
-    const hex = data.substring(2);
+    const hex = data.slice(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 c = hex.slice(i, i + 2);
         const byteIndex = i / 2;
         if (!/^[0-9a-fA-F]{2}$/.test(c)) {
             throw new Error(`hexDecode: invalid hex pair "${c}" in data "${data}" for bytes[${byteIndex}]`);

package/dist/build/js/portable/bootstrap.js

@@ -1,3 +1,4 @@
+"use strict";
 // Portable bootstrap for globals that must exist before assembly/portable executes.
 const g = globalThis;
 if (g.ASC_TARGET === undefined) {

package/dist/build/js/portable-bundle.js

@@ -376,7 +376,8 @@ if (typeof globalScope.ASC_TARGET === "undefined") {
   }, defaultComparator = function(a, b) {
     if (a == b) {
       if (a != 0) return 0;
-      a = 1 / a, b = 1 / b;
+      a = 1 / a;
+      b = 1 / b;
     } else {
       let nanA = a != a, nanB = b != b;
       if (nanA | nanB) return nanA - nanB;
@@ -622,9 +623,9 @@ if (typeof globalScope.ASC_TARGET === "undefined") {
   }
   if (!String.prototype.replaceAll) {
     Object.defineProperty(String.prototype, "replaceAll", {
-      value: function replaceAll(search, replacment) {
-        let res = this.split(search).join(replacment);
-        if (!search.length) res = replacment + res + replacment;
+      value: function replaceAll(search, replacement) {
+        let res = this.split(search).join(replacement);
+        if (!search.length) res = replacement + res + replacement;
         return res;
       },
       configurable: true

package/dist/test/test-trace-format.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+import * as assert from "node:assert";
+import { parseTrace } from "../bin/src/trace-parse.js";
+// Test: round-trip parse of a spec-compliant trace
+{
+    const input = [
+        "program 0x0102aabbccddeeff",
+        "memwrite 0x00001000 len=8 <- 0x0000000000000001",
+        "start pc=0 gas=10000 r07=0x10 r09=0x10000",
+        "",
+        "ecalli=10 pc=42 gas=9980 r01=0x1 r03=0x1000",
+        "memread 0x00001000 len=4 -> 0x01020304",
+        "memread 0x00001020 len=8 -> 0x0000000000000040",
+        "memwrite 0x00002000 len=2 <- 0xffee",
+        "setreg r00 <- 0x100",
+        "setreg r02 <- 0x4",
+        "setgas <- 9950",
+        "",
+        "HALT pc=42 gas=9920 r00=0x100 r02=0x4",
+    ].join("\n");
+    const trace = parseTrace(input);
+    // Program
+    assert.deepStrictEqual(Array.from(trace.program), [0x01, 0x02, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff], "program bytes");
+    // Initial memwrite
+    assert.strictEqual(trace.initialMemWrites.length, 1, "one initial memwrite");
+    assert.strictEqual(trace.initialMemWrites[0].address, 0x00001000, "memwrite address");
+    assert.strictEqual(trace.initialMemWrites[0].data.length, 8, "memwrite data length");
+    // Start
+    assert.strictEqual(trace.start.pc, 0, "start pc");
+    assert.strictEqual(trace.start.gas, 10000n, "start gas");
+    assert.strictEqual(trace.start.registers.get(7), 0x10n, "start r07");
+    assert.strictEqual(trace.start.registers.get(9), 0x10000n, "start r09");
+    assert.strictEqual(trace.start.registers.has(0), false, "start r00 omitted (zero)");
+    // Ecalli
+    assert.strictEqual(trace.ecalliEntries.length, 1, "one ecalli");
+    const ecalli = trace.ecalliEntries[0];
+    assert.strictEqual(ecalli.index, 10, "ecalli index");
+    assert.strictEqual(ecalli.pc, 42, "ecalli pc");
+    assert.strictEqual(ecalli.gas, 9980n, "ecalli gas");
+    assert.strictEqual(ecalli.registers.get(1), 0x1n, "ecalli r01");
+    assert.strictEqual(ecalli.registers.get(3), 0x1000n, "ecalli r03");
+    // Memreads
+    assert.strictEqual(ecalli.memReads.length, 2, "two memreads");
+    assert.strictEqual(ecalli.memReads[0].address, 0x00001000, "memread 0 address");
+    assert.strictEqual(ecalli.memReads[0].data.length, 4, "memread 0 length");
+    assert.strictEqual(ecalli.memReads[1].address, 0x00001020, "memread 1 address");
+    // Memwrites
+    assert.strictEqual(ecalli.memWrites.length, 1, "one ecalli memwrite");
+    assert.strictEqual(ecalli.memWrites[0].address, 0x00002000, "ecalli memwrite address");
+    // Setregs
+    assert.strictEqual(ecalli.setRegs.length, 2, "two setregs");
+    assert.strictEqual(ecalli.setRegs[0].index, 0, "setreg 0 index");
+    assert.strictEqual(ecalli.setRegs[0].value, 0x100n, "setreg 0 value");
+    assert.strictEqual(ecalli.setRegs[1].index, 2, "setreg 1 index");
+    assert.strictEqual(ecalli.setRegs[1].value, 0x4n, "setreg 1 value");
+    // Setgas
+    assert.strictEqual(ecalli.setGas, 9950n, "setgas");
+    // Termination
+    assert.strictEqual(trace.termination.type, "HALT", "termination type");
+    assert.strictEqual(trace.termination.pc, 42, "termination pc");
+    assert.strictEqual(trace.termination.gas, 9920n, "termination gas");
+    assert.strictEqual(trace.termination.registers.get(0), 0x100n, "termination r00");
+    assert.strictEqual(trace.termination.registers.get(2), 0x4n, "termination r02");
+    console.log("PASS: spec example round-trip");
+}
+// Test: PANIC=0 (argument must always be present)
+{
+    const input = ["program 0x00", "start pc=0 gas=100", "PANIC=0 pc=5 gas=50 r00=0x1"].join("\n");
+    const trace = parseTrace(input);
+    assert.strictEqual(trace.termination.type, "PANIC", "panic type");
+    assert.strictEqual(trace.termination.panicArg, 0, "panic arg is 0");
+    assert.strictEqual(trace.termination.pc, 5, "panic pc");
+    assert.strictEqual(trace.termination.gas, 50n, "panic gas");
+    console.log("PASS: PANIC=0");
+}
+// Test: PANIC with non-zero argument
+{
+    const input = ["program 0x00", "start pc=0 gas=100", "PANIC=42 pc=10 gas=0"].join("\n");
+    const trace = parseTrace(input);
+    assert.strictEqual(trace.termination.panicArg, 42, "panic arg 42");
+    assert.strictEqual(trace.termination.registers.size, 0, "no registers");
+    console.log("PASS: PANIC=42");
+}
+// Test: OOG termination
+{
+    const input = ["program 0x00", "start pc=0 gas=100", "OOG pc=99 gas=0"].join("\n");
+    const trace = parseTrace(input);
+    assert.strictEqual(trace.termination.type, "OOG", "OOG type");
+    assert.strictEqual(trace.termination.gas, 0n, "OOG gas is 0");
+    console.log("PASS: OOG");
+}
+// Test: lines with log prefixes are handled (extractPayload)
+{
+    const input = [
+        "TRACE [ecalli] program 0xaa",
+        "TRACE [ecalli] start pc=0 gas=500 r00=0x1",
+        "TRACE [ecalli] HALT pc=10 gas=400",
+    ].join("\n");
+    const trace = parseTrace(input);
+    assert.deepStrictEqual(Array.from(trace.program), [0xaa], "prefixed program");
+    assert.strictEqual(trace.start.registers.get(0), 0x1n, "prefixed start r00");
+    assert.strictEqual(trace.termination.type, "HALT", "prefixed halt");
+    console.log("PASS: log-prefixed lines");
+}
+// Test: comment lines are ignored
+{
+    const input = [
+        "comment implementation typeberry 0.8.3",
+        "comment chain-id fluffy-testnet",
+        "program 0xbb",
+        "comment accumulate",
+        "start pc=0 gas=100",
+        "HALT pc=5 gas=90",
+    ].join("\n");
+    const trace = parseTrace(input);
+    assert.deepStrictEqual(Array.from(trace.program), [0xbb], "comment lines ignored");
+    console.log("PASS: comment lines ignored");
+}
+// Test: zero-padded register indices in register dump
+{
+    const input = ["program 0x00", "start pc=0 gas=100 r00=0xff r12=0x1", "HALT pc=5 gas=90 r00=0xff r12=0x1"].join("\n");
+    const trace = parseTrace(input);
+    assert.strictEqual(trace.start.registers.get(0), 0xffn, "r00 parsed");
+    assert.strictEqual(trace.start.registers.get(12), 0x1n, "r12 parsed");
+    console.log("PASS: zero-padded register indices");
+}
+// Test: empty register dump (all zeros)
+{
+    const input = ["program 0x00", "start pc=0 gas=100", "HALT pc=5 gas=90"].join("\n");
+    const trace = parseTrace(input);
+    assert.strictEqual(trace.start.registers.size, 0, "empty register dump");
+    assert.strictEqual(trace.termination.registers.size, 0, "empty termination registers");
+    console.log("PASS: empty register dump");
+}
+// Test: multiple ecalli entries
+{
+    const input = [
+        "program 0x00",
+        "start pc=0 gas=10000",
+        "ecalli=1 pc=10 gas=9000 r00=0x1",
+        "setreg r00 <- 0x2",
+        "ecalli=2 pc=20 gas=8000 r00=0x2",
+        "memwrite 0x00001000 len=1 <- 0xff",
+        "setgas <- 7900",
+        "HALT pc=30 gas=7800",
+    ].join("\n");
+    const trace = parseTrace(input);
+    assert.strictEqual(trace.ecalliEntries.length, 2, "two ecalli entries");
+    assert.strictEqual(trace.ecalliEntries[0].index, 1, "first ecalli index");
+    assert.strictEqual(trace.ecalliEntries[0].setRegs.length, 1, "first ecalli setregs");
+    assert.strictEqual(trace.ecalliEntries[0].setGas, undefined, "first ecalli no setgas");
+    assert.strictEqual(trace.ecalliEntries[1].index, 2, "second ecalli index");
+    assert.strictEqual(trace.ecalliEntries[1].memWrites.length, 1, "second ecalli memwrites");
+    assert.strictEqual(trace.ecalliEntries[1].setGas, 7900n, "second ecalli setgas");
+    console.log("PASS: multiple ecalli entries");
+}
+// Test: missing program throws
+assert.throws(() => parseTrace("start pc=0 gas=100\nHALT pc=5 gas=90"), /Missing program/, "missing program");
+console.log("PASS: missing program throws");
+// Test: missing start throws
+assert.throws(() => parseTrace("program 0x00\nHALT pc=5 gas=90"), /Missing start/, "missing start");
+console.log("PASS: missing start throws");
+// Test: missing termination throws
+assert.throws(() => parseTrace("program 0x00\nstart pc=0 gas=100"), /Missing termination/, "missing termination");
+console.log("PASS: missing termination throws");
+console.log("\nAll trace format tests passed.");

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@fluffylabs/anan-as",
 	"description": "AssemblyScript PVM interpreter.",
-	"version": "1.2.0-abcb88c",
+	"version": "1.2.0-b6d0f93",
 	"main": "./dist/bin/index.js",
 	"bin": {
 		"anan-as": "./dist/bin/index.js"
@@ -32,7 +32,7 @@
 		"qa": "biome ci",
 		"qa-fix": "npm run format; npm run lint",
 		"start": "tsx ./bin/index.ts",
-		"test": "npm run asbuild:test && tsx ./test/test-as.ts && tsx ./test/test-trace-replay.ts",
+		"test": "npm run asbuild:test && tsx ./test/test-as.ts && tsx ./test/test-trace-format.ts && tsx ./test/test-trace-replay.ts",
 		"tsbuild": "tsc && npm run tsbuild:portable",
 		"tsbuild:portable": "tsc --project portable/tsconfig.json && esbuild dist/build/js/portable/index.js --bundle --format=esm --platform=node --outfile=dist/build/js/portable-bundle.js",
 		"test:w3f": "tsx ./test/test-w3f.ts",
@@ -53,14 +53,14 @@
 		"node": ">=18.3.0"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.4.5",
+		"@biomejs/biome": "^2.4.10",
 		"@typeberry/lib": "^0.5.8",
 		"@types/node": "^25.3.3",
 		"assemblyscript": "^0.28.9",
-		"esbuild": "^0.27.3",
+		"esbuild": "^0.28.0",
 		"json-bigint-patch": "^0.0.8",
 		"tsx": "^4.21.0",
-		"typescript": "^5.9.3"
+		"typescript": "^6.0.2"
 	},
 	"files": [
 		"dist/**/*.wasm",