@fluffylabs/anan-as 1.2.0 → 1.3.0-5cbd3aa

package/dist/test/test-gas-cost.js

@@ -2,7 +2,7 @@
 import "json-bigint-patch";
 import * as assert from "node:assert";
 import { ERR, OK, read, run } from "../bin/src/test-json.js";
-import { disassemble, getGasCosts, HasMetadata, InputKind } from "../build/release.js";
+import { disassemble, getBlockGasCosts, HasMetadata, InputKind } from "../build/release.js";
 // Run the CLI application
 main();
 // Main function
@@ -10,7 +10,6 @@ function main() {
     const options = {
         isDebug: false,
         isSilent: false,
-        useSbrkGas: false,
     };
     run(processGasCost, options);
 }
@@ -29,7 +28,7 @@ function processGasCost(data, options, filePath) {
         console.info(assembly);
         console.info("\n^^^^^^^^^^^\n");
     }
-    const result = asMap(getGasCosts(input.program, InputKind.Generic, HasMetadata.No));
+    const result = asMap(getBlockGasCosts(input.program, InputKind.Generic, HasMetadata.No));
     // silent mode - just put our vals into expected (comparison done externally)
     if (options.isSilent) {
         data.block_gas_costs = result;

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/dist/test/test-w3f-common.js

@@ -0,0 +1,125 @@
+import "json-bigint-patch";
+import * as assert from "node:assert";
+import { ERR, OK, read, run } from "../bin/src/test-json.js";
+const ignored = [
+    "inst_load_u8_nok",
+    "inst_store_imm_indirect_u16_with_offset_nok",
+    "inst_store_imm_indirect_u32_with_offset_nok",
+    "inst_store_imm_indirect_u64_with_offset_nok",
+    "inst_store_imm_indirect_u8_with_offset_nok",
+    "inst_store_imm_u8_trap_inaccessible",
+    "inst_store_imm_u8_trap_read_only",
+    "inst_store_indirect_u16_with_offset_nok",
+    "inst_store_indirect_u32_with_offset_nok",
+    "inst_store_indirect_u64_with_offset_nok",
+    "inst_store_indirect_u8_with_offset_nok",
+    "inst_store_u8_trap_inaccessible",
+    "inst_store_u8_trap_read_only",
+];
+export function runW3fTests(pvm) {
+    const options = {
+        isDebug: false,
+        isSilent: false,
+    };
+    run((data, opts, filePath) => processW3f(pvm, data, opts, filePath), options);
+}
+function processW3f(pvm, data, options, _filePath) {
+    if (options.isDebug) {
+        console.debug(`🤖 Running ${data.name}`);
+    }
+    if (ignored.includes(data.name)) {
+        if (options.isDebug) {
+            console.info(`⏭️ Skipping ${data.name}`);
+        }
+        return data;
+    }
+    // input
+    const input = {
+        registers: read(data, "initial-regs").map((x) => BigInt(x)),
+        pc: read(data, "initial-pc"),
+        pageMap: asPageMap(read(data, "initial-page-map")),
+        memory: asChunks(read(data, "initial-memory")),
+        gas: BigInt(read(data, "initial-gas")),
+        program: read(data, "program"),
+    };
+    if (options.isDebug) {
+        const assembly = pvm.disassemble(input.program, pvm.InputKind.Generic, pvm.HasMetadata.No);
+        console.info("===========");
+        console.info(assembly);
+        console.info("\n^^^^^^^^^^^\n");
+    }
+    const exe = pvm.prepareProgram(pvm.InputKind.Generic, pvm.HasMetadata.No, input.program, input.registers, input.pageMap, input.memory, [], 16);
+    const result = pvm.runProgram(exe, input.gas, input.pc, options.isDebug, true);
+    const status = statusAsString(result.status);
+    // Normalize registers to plain unsigned BigInt array for comparison.
+    // The portable build may store signed BigInts or plain numbers in registers.
+    result.registers = Array.from(result.registers).map((v) => typeof v === "bigint" ? BigInt.asUintN(64, v) : BigInt(v));
+    result.gas = typeof result.gas === "bigint" ? result.gas : BigInt(result.gas);
+    // Normalize memory chunks to plain objects for comparison.
+    // The portable build returns class instances; WASM returns plain objects.
+    result.memory = result.memory.map((chunk) => ({
+        address: chunk.address,
+        data: Array.from(chunk.data),
+    }));
+    // silent mode - just put our vals into expected (comparison done externally)
+    if (options.isSilent) {
+        data["expected-pc"] = result.pc;
+        data["expected-gas"] = result.gas;
+        data["expected-status"] = status;
+        data["expected-regs"] = result.registers;
+        data["expected-page-fault-address"] = result.exitCode;
+        return data;
+    }
+    // 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"),
+        memory: asChunks(read(data, "expected-memory")),
+        gas: BigInt(read(data, "expected-gas")),
+        exitCode: read(data, "expected-page-fault-address", 0),
+    };
+    try {
+        assert.deepStrictEqual({
+            ...result,
+            status,
+        }, expected);
+        console.log(`${OK} ${data.name}`);
+    }
+    catch (e) {
+        console.log(`${ERR} ${data.name}`);
+        throw e;
+    }
+    return data;
+}
+function asChunks(chunks) {
+    return chunks.map((chunk) => {
+        chunk.data = read(chunk, "contents");
+        delete chunk.contents;
+        return chunk;
+    });
+}
+var Access;
+(function (Access) {
+    Access[Access["Read"] = 1] = "Read";
+    Access[Access["Write"] = 2] = "Write";
+})(Access || (Access = {}));
+function asPageMap(pages) {
+    return pages.map((page) => {
+        page.access = read(page, "is-writable") ? Access.Write : Access.Read;
+        return page;
+    });
+}
+function statusAsString(status) {
+    const map = {
+        255: "ok",
+        0: "halt",
+        1: "panic",
+        2: "page-fault",
+        3: "host",
+        4: "oog",
+    };
+    return map[status] || `unknown(${status})`;
+}

package/dist/test/test-w3f-portable.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// @ts-expect-error: portable bundle has no TS declarations for direct import
+import * as pvm from "../dist/build/js/portable-bundle.js";
+import { runW3fTests } from "./test-w3f-common.js";
+runW3fTests(pvm);

package/dist/test/test-w3f.js

@@ -1,121 +1,4 @@
 #!/usr/bin/env node
-import "json-bigint-patch";
-import * as assert from "node:assert";
-import { ERR, OK, read, run } from "../bin/src/test-json.js";
-import { disassemble, HasMetadata, InputKind, prepareProgram, runProgram } from "../build/release.js";
-const ignored = [
-    "inst_load_u8_nok",
-    "inst_store_imm_indirect_u16_with_offset_nok",
-    "inst_store_imm_indirect_u32_with_offset_nok",
-    "inst_store_imm_indirect_u64_with_offset_nok",
-    "inst_store_imm_indirect_u8_with_offset_nok",
-    "inst_store_imm_u8_trap_inaccessible",
-    "inst_store_imm_u8_trap_read_only",
-    "inst_store_indirect_u16_with_offset_nok",
-    "inst_store_indirect_u32_with_offset_nok",
-    "inst_store_indirect_u64_with_offset_nok",
-    "inst_store_indirect_u8_with_offset_nok",
-    "inst_store_u8_trap_inaccessible",
-    "inst_store_u8_trap_read_only",
-];
-// Run the CLI application
-main();
-// Main function
-function main() {
-    const options = {
-        isDebug: false,
-        isSilent: false,
-        useSbrkGas: false,
-    };
-    run(processW3f, options);
-}
-function processW3f(data, options) {
-    if (options.isDebug) {
-        console.debug(`🤖 Running ${data.name}`);
-    }
-    if (ignored.includes(data.name)) {
-        if (options.isDebug) {
-            console.info(`⏭️ Skipping ${data.name}`);
-        }
-        return data;
-    }
-    // input
-    const input = {
-        registers: read(data, "initial-regs").map((x) => BigInt(x)),
-        pc: read(data, "initial-pc"),
-        pageMap: asPageMap(read(data, "initial-page-map")),
-        memory: asChunks(read(data, "initial-memory")),
-        gas: BigInt(read(data, "initial-gas")),
-        program: read(data, "program"),
-    };
-    if (options.isDebug) {
-        const assembly = disassemble(input.program, InputKind.Generic, HasMetadata.No);
-        console.info("===========");
-        console.info(assembly);
-        console.info("\n^^^^^^^^^^^\n");
-    }
-    const exe = prepareProgram(InputKind.Generic, HasMetadata.No, input.program, input.registers, input.pageMap, input.memory, [], 16);
-    const result = runProgram(exe, input.gas, input.pc, options.isDebug, options.useSbrkGas, true);
-    const status = statusAsString(result.status);
-    // silent mode - just put our vals into expected (comparison done externally)
-    if (options.isSilent) {
-        data["expected-pc"] = result.pc;
-        data["expected-gas"] = result.gas;
-        data["expected-status"] = status;
-        data["expected-regs"] = result.registers;
-        data["expected-page-fault-address"] = result.exitCode;
-        return data;
-    }
-    // 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"),
-        memory: asChunks(read(data, "expected-memory")),
-        gas: BigInt(read(data, "expected-gas")),
-        exitCode: read(data, "expected-page-fault-address", 0),
-    };
-    try {
-        assert.deepStrictEqual({
-            ...result,
-            status,
-        }, expected);
-        console.log(`${OK} ${data.name}`);
-    }
-    catch (e) {
-        console.log(`${ERR} ${data.name}`);
-        throw e;
-    }
-    return data;
-}
-function asChunks(chunks) {
-    return chunks.map((chunk) => {
-        chunk.data = read(chunk, "contents");
-        delete chunk.contents;
-        return chunk;
-    });
-}
-var Access;
-(function (Access) {
-    Access[Access["Read"] = 1] = "Read";
-    Access[Access["Write"] = 2] = "Write";
-})(Access || (Access = {}));
-function asPageMap(pages) {
-    return pages.map((page) => {
-        page.access = read(page, "is-writable") ? Access.Write : Access.Read;
-        return page;
-    });
-}
-function statusAsString(status) {
-    const map = {
-        255: "ok",
-        0: "halt",
-        1: "panic",
-        2: "page-fault",
-        3: "host",
-        4: "oog",
-    };
-    return map[status] || `unknown(${status})`;
-}
+import * as pvm from "../build/release.js";
+import { runW3fTests } from "./test-w3f-common.js";
+runW3fTests(pvm);

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@fluffylabs/anan-as",
 	"description": "AssemblyScript PVM interpreter.",
-	"version": "1.2.0",
+	"version": "1.3.0-5cbd3aa",
 	"main": "./dist/bin/index.js",
 	"bin": {
 		"anan-as": "./dist/bin/index.js"
@@ -32,12 +32,18 @@
 		"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",
-		"tsbuild": "tsc",
+		"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",
+		"test:w3f-portable": "tsx ./test/test-w3f-portable.ts",
 		"test:gas-cost": "tsx ./test/test-gas-cost.ts",
 		"update-version": "tsx ./web/bump-version.ts $GITHUB_SHA",
-		"web": "npx live-server ./web"
+		"web": "npx live-server ./web",
+		"bench": "tsx bench/run.ts --traces ./bench/traces --iterations 5 --warmup 1",
+		"bench:ci": "tsx bench/run.ts --traces ./bench/traces --iterations 5 --warmup 1 --output ./bench/results.json",
+		"bench:baseline": "tsx bench/run.ts --traces ./bench/traces --iterations 5 --warmup 1 --output ./bench/baseline.json",
+		"bench:compare": "tsx bench/compare.ts"
 	},
 	"type": "module",
 	"keywords": [],
@@ -47,13 +53,14 @@
 		"node": ">=18.3.0"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.3.11",
-		"@typeberry/lib": "^0.5.1",
-		"@types/node": "^25.0.0",
-		"assemblyscript": "^0.28.8",
+		"@biomejs/biome": "^2.4.10",
+		"@typeberry/lib": "^0.5.8",
+		"@types/node": "^25.3.3",
+		"assemblyscript": "^0.28.9",
+		"esbuild": "^0.28.0",
 		"json-bigint-patch": "^0.0.8",
-		"tsx": "^4.20.6",
-		"typescript": "^5.9.3"
+		"tsx": "^4.21.0",
+		"typescript": "^6.0.2"
 	},
 	"files": [
 		"dist/**/*.wasm",
@@ -111,6 +118,10 @@
 		"./release.wasm": "./dist/build/release.wasm",
 		"./release-mini.wasm": "./dist/build/release-mini.wasm",
 		"./release-stub.wasm": "./dist/build/release-stub.wasm",
-		"./compiler.wasm": "./dist/build/compiler.wasm"
+		"./compiler.wasm": "./dist/build/compiler.wasm",
+		"./js": {
+			"import": "./dist/build/js/portable-bundle.js",
+			"types": "./dist/build/js/portable/index.d.ts"
+		}
 	}
 }