@fluffylabs/anan-as 1.1.3-e748fc6 → 1.1.3-eee81bd

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/test-json.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import "json-bigint-patch";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+export const OK = "🟢";
+export const ERR = "🔴";
+// Main function
+export function run(processJson, options) {
+    // Get the JSON file arguments from the command line
+    const args = process.argv.slice(2);
+    for (;;) {
+        if (args.length === 0) {
+            break;
+        }
+        if (args[0] === "--debug") {
+            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] -");
+        process.exit(1);
+    }
+    if (args[0] === "-") {
+        if (options.isDebug) {
+            throw new Error("debug needs to be disabled!");
+        }
+        readFromStdin(processJson, options);
+        return;
+    }
+    const status = {
+        all: 0,
+        ok: [],
+        fail: [],
+    };
+    // Process each file
+    args.forEach((filePath) => {
+        // try whole directory
+        let dir = null;
+        try {
+            dir = readdirSync(filePath);
+        }
+        catch (_e) {
+            // Not a directory or inaccessible, will try as file
+        }
+        if (dir !== null) {
+            status.all += dir.length;
+            for (const file of dir) {
+                processFile(processJson, options, status, join(filePath, file));
+            }
+        }
+        else {
+            status.all += 1;
+            // or just process file
+            processFile(processJson, options, status, filePath);
+            // TODO print results to stdout
+        }
+    });
+    if (!options.isSilent) {
+        const icon = status.ok.length === status.all ? OK : ERR;
+        console.log(`${icon} Tests status: ${status.ok.length}/${status.all}`);
+    }
+    if (status.fail.length) {
+        console.error("Failures:");
+        for (const e of status.fail) {
+            console.error(`❗ ${e.filePath} (${e.name})`);
+        }
+        process.exit(-1);
+    }
+}
+function readFromStdin(processJson, options) {
+    process.stdin.setEncoding("utf8");
+    process.stderr.write("awaiting input\n");
+    options.isSilent = true;
+    // Read from stdin
+    let buffer = "";
+    process.stdin.on("data", (data) => {
+        buffer += data;
+        if (buffer.endsWith("\n\n")) {
+            const json = JSON.parse(buffer);
+            const out = processJson(json, options, "-");
+            // clear previous buffer
+            buffer = "";
+            console.log(JSON.stringify(out));
+            console.log();
+        }
+    });
+}
+function processFile(processJson, options, status, filePath) {
+    let jsonData;
+    try {
+        // Resolve the full file path
+        const absolutePath = resolve(filePath);
+        // Read the file synchronously
+        const fileContent = readFileSync(absolutePath, "utf-8");
+        // Parse the JSON content
+        jsonData = JSON.parse(fileContent);
+    }
+    catch (error) {
+        status.fail.push({ filePath, name: "<unknown>" });
+        console.error(`Error reading file: ${filePath}`);
+        console.error(error.message);
+        return;
+    }
+    try {
+        // Process the parsed JSON
+        const result = processJson(jsonData, options, filePath);
+        status.ok.push({ filePath, name: jsonData.name ?? filePath });
+        return result;
+    }
+    catch (error) {
+        status.fail.push({ filePath, name: jsonData.name ?? filePath });
+        console.error(`Error running test: ${filePath}`);
+        console.error(error.message);
+        return {};
+    }
+}
+export function read(data, field, defaultValue = undefined) {
+    if (field in data) {
+        return data[field];
+    }
+    if (defaultValue !== undefined) {
+        return defaultValue;
+    }
+    throw new Error(`Required field ${field} missing in ${JSON.stringify(data, null, 2)}`);
+}

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

@@ -0,0 +1,315 @@
+const NO_OF_REGISTERS = 13;
+// Access.Write = 2 from assembly/memory-page.ts
+const ACCESS_WRITE = 2;
+export const STATUS = {
+    OK: 255,
+    HALT: 0,
+    PANIC: 1,
+    FAULT: 2,
+    HOST: 3,
+    OOG: 4,
+};
+export const ARGS_SEGMENT_START = 0xfeff0000;
+const LINE_PATTERN = /(program\s+0x|memwrite\s+0x|start\s+pc=|ecalli=\d+|memread\s+0x|setreg\s+r\d+|setgas\s+<-|HALT\s+pc=|OOG\s+pc=|PANIC=)/;
+export function parseTrace(input) {
+    const lines = input.split(/\r?\n/);
+    let program = null;
+    const initialMemWrites = [];
+    let start = null;
+    const ecalliEntries = [];
+    let currentEntry = null;
+    let termination = null;
+    for (const rawLine of lines) {
+        const line = extractPayload(rawLine);
+        if (!line) {
+            continue;
+        }
+        if (line.startsWith("program ")) {
+            program = parseHexBytes(line.replace("program ", "").trim());
+            continue;
+        }
+        if (line.startsWith("memwrite ")) {
+            const memwrite = parseMemWrite(line);
+            if (currentEntry) {
+                currentEntry.memWrites.push(memwrite);
+            }
+            else {
+                initialMemWrites.push(memwrite);
+            }
+            continue;
+        }
+        if (line.startsWith("start ")) {
+            start = parseStart(line);
+            continue;
+        }
+        if (line.startsWith("ecalli=")) {
+            const entry = parseEcalli(line);
+            ecalliEntries.push(entry);
+            currentEntry = entry;
+            continue;
+        }
+        if (line.startsWith("memread ")) {
+            if (!currentEntry) {
+                throw new Error(`memread without active ecalli: ${line}`);
+            }
+            currentEntry.memReads.push(parseMemRead(line));
+            continue;
+        }
+        if (line.startsWith("setreg ")) {
+            if (!currentEntry) {
+                throw new Error(`setreg without active ecalli: ${line}`);
+            }
+            const setReg = parseSetReg(line);
+            currentEntry.setRegs.push(setReg);
+            continue;
+        }
+        if (line.startsWith("setgas ")) {
+            if (!currentEntry) {
+                throw new Error(`setgas without active ecalli: ${line}`);
+            }
+            currentEntry.setGas = parseSetGas(line);
+            continue;
+        }
+        if (line.startsWith("HALT ") || line.startsWith("OOG ") || line.startsWith("PANIC=")) {
+            termination = parseTermination(line);
+            currentEntry = null;
+        }
+    }
+    if (!program) {
+        throw new Error("Missing program line in trace");
+    }
+    if (!start) {
+        throw new Error("Missing start line in trace");
+    }
+    if (!termination) {
+        throw new Error("Missing termination line in trace");
+    }
+    return {
+        program,
+        initialMemWrites,
+        start,
+        ecalliEntries,
+        termination,
+    };
+}
+function extractPayload(line) {
+    const match = LINE_PATTERN.exec(line);
+    if (!match || match.index === undefined) {
+        return null;
+    }
+    return line.slice(match.index).trim();
+}
+function parseStart(line) {
+    const match = /^start pc=(\d+) gas=(\d+)(.*)$/.exec(line);
+    if (!match) {
+        throw new Error(`Invalid start line: ${line}`);
+    }
+    return {
+        pc: parseInt(match[1], 10),
+        gas: BigInt(match[2]),
+        registers: parseRegisterDump(match[3]),
+    };
+}
+function parseEcalli(line) {
+    const match = /^ecalli=(\d+) pc=(\d+) gas=(\d+)(.*)$/.exec(line);
+    if (!match) {
+        throw new Error(`Invalid ecalli line: ${line}`);
+    }
+    return {
+        index: parseInt(match[1], 10),
+        pc: parseInt(match[2], 10),
+        gas: BigInt(match[3]),
+        registers: parseRegisterDump(match[4]),
+        memReads: [],
+        memWrites: [],
+        setRegs: [],
+    };
+}
+function parseMemWrite(line) {
+    const match = /^memwrite\s+0x([0-9a-f]+)\s+len=(\d+)\s+<-\s+0x([0-9a-f]+)$/i.exec(line);
+    if (!match) {
+        throw new Error(`Invalid memwrite line: ${line}`);
+    }
+    const address = parseInt(match[1], 16);
+    const data = parseHexBytes(`0x${match[3]}`);
+    const len = parseInt(match[2], 10);
+    if (data.length !== len) {
+        throw new Error(`memwrite length mismatch: expected ${len}, got ${data.length}`);
+    }
+    return { address, data };
+}
+function parseMemRead(line) {
+    const match = /^memread\s+0x([0-9a-f]+)\s+len=(\d+)\s+->\s+0x([0-9a-f]+)$/i.exec(line);
+    if (!match) {
+        throw new Error(`Invalid memread line: ${line}`);
+    }
+    const address = parseInt(match[1], 16);
+    const data = parseHexBytes(`0x${match[3]}`);
+    const len = parseInt(match[2], 10);
+    if (data.length !== len) {
+        throw new Error(`memread length mismatch: expected ${len}, got ${data.length}`);
+    }
+    return { address, data };
+}
+function parseSetReg(line) {
+    const match = /^setreg\s+r(\d+)\s+<-\s+0x([0-9a-f]+)$/i.exec(line);
+    if (!match) {
+        throw new Error(`Invalid setreg line: ${line}`);
+    }
+    const index = parseInt(match[1], 10);
+    if (index < 0 || index >= NO_OF_REGISTERS) {
+        throw new Error(`Register index out of range: ${index}`);
+    }
+    return {
+        index,
+        value: BigInt(`0x${match[2]}`),
+    };
+}
+function parseSetGas(line) {
+    const match = /^setgas\s+<-\s+(\d+)$/i.exec(line);
+    if (!match) {
+        throw new Error(`Invalid setgas line: ${line}`);
+    }
+    return BigInt(match[1]);
+}
+function parseTermination(line) {
+    if (line.startsWith("HALT ")) {
+        const match = /^HALT pc=(\d+) gas=(\d+)(.*)$/.exec(line);
+        if (!match) {
+            throw new Error(`Invalid HALT line: ${line}`);
+        }
+        return {
+            type: "HALT",
+            pc: parseInt(match[1], 10),
+            gas: BigInt(match[2]),
+            registers: parseRegisterDump(match[3]),
+        };
+    }
+    if (line.startsWith("OOG ")) {
+        const match = /^OOG pc=(\d+) gas=(\d+)(.*)$/.exec(line);
+        if (!match) {
+            throw new Error(`Invalid OOG line: ${line}`);
+        }
+        return {
+            type: "OOG",
+            pc: parseInt(match[1], 10),
+            gas: BigInt(match[2]),
+            registers: parseRegisterDump(match[3]),
+        };
+    }
+    if (line.startsWith("PANIC=")) {
+        const match = /^PANIC=([^\s]+) pc=(\d+) gas=(\d+)(.*)$/.exec(line);
+        if (!match) {
+            throw new Error(`Invalid PANIC line: ${line}`);
+        }
+        return {
+            type: "PANIC",
+            pc: parseInt(match[2], 10),
+            gas: BigInt(match[3]),
+            registers: parseRegisterDump(match[4]),
+            panicArg: parseNumber(match[1]),
+        };
+    }
+    throw new Error(`Unknown termination line: ${line}`);
+}
+function parseRegisterDump(input) {
+    const dump = new Map();
+    const regex = /r(\d+)=0x([0-9a-f]+)/gi;
+    for (const match of input.matchAll(regex)) {
+        const index = parseInt(match[1], 10);
+        if (index < 0 || index >= NO_OF_REGISTERS) {
+            throw new Error(`Register index out of range: ${index}`);
+        }
+        const value = BigInt(`0x${match[2]}`);
+        dump.set(index, value);
+    }
+    return dump;
+}
+function parseHexBytes(hex) {
+    if (!hex.startsWith("0x")) {
+        throw new Error(`Hex value must start with 0x: ${hex}`);
+    }
+    const data = hex.slice(2);
+    if (data.length % 2 !== 0) {
+        throw new Error(`Hex value must have even length: ${hex}`);
+    }
+    const bytes = new Uint8Array(data.length / 2);
+    for (let i = 0; i < data.length; i += 2) {
+        const pair = data.slice(i, i + 2);
+        if (!/^[0-9a-fA-F]{2}$/.test(pair)) {
+            throw new Error(`Invalid hex pair "${pair}" in hex value: ${hex}`);
+        }
+        bytes[i / 2] = Number.parseInt(pair, 16);
+    }
+    return bytes;
+}
+export function encodeRegistersFromDump(dump) {
+    const registers = new Array(NO_OF_REGISTERS).fill(0n);
+    for (const [index, value] of dump) {
+        registers[index] = value;
+    }
+    return registers;
+}
+export function buildInitialPages(memWrites) {
+    return memWrites
+        .filter((write) => write.data.length > 0)
+        .map((write) => ({
+        address: write.address,
+        length: write.data.length,
+        access: ACCESS_WRITE,
+    }));
+}
+export function buildInitialChunks(memWrites) {
+    return memWrites
+        .filter((write) => write.data.length > 0)
+        .map((write) => ({
+        address: write.address,
+        data: Array.from(write.data),
+    }));
+}
+export function isSpiTrace(start, memWrites) {
+    const r07 = start.registers.get(7);
+    if (r07 === BigInt(ARGS_SEGMENT_START)) {
+        return true;
+    }
+    return memWrites.some((write) => write.address === ARGS_SEGMENT_START);
+}
+export function extractSpiArgs(start, memWrites) {
+    const argLenBig = start.registers.get(8) ?? 0n;
+    // Validate bounds: must be non-negative and <= 1 MiB (2^20)
+    const MAX_ARG_LEN = 1n << 20n;
+    if (argLenBig < 0n || argLenBig > MAX_ARG_LEN) {
+        return new Uint8Array(0);
+    }
+    const argLen = Number(argLenBig);
+    if (argLen <= 0) {
+        return new Uint8Array(0);
+    }
+    const buffer = new Uint8Array(argLen);
+    for (const write of memWrites) {
+        if (write.address < ARGS_SEGMENT_START) {
+            continue;
+        }
+        const offset = write.address - ARGS_SEGMENT_START;
+        if (offset >= buffer.length) {
+            continue;
+        }
+        buffer.set(write.data.subarray(0, buffer.length - offset), offset);
+    }
+    return buffer;
+}
+export function statusToTermination(status) {
+    if (status === STATUS.HALT) {
+        return "HALT";
+    }
+    if (status === STATUS.OOG) {
+        return "OOG";
+    }
+    return "PANIC";
+}
+function parseNumber(value) {
+    if (value.startsWith("0x")) {
+        return Number.parseInt(value, 16);
+    }
+    return Number.parseInt(value, 10);
+}

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

@@ -0,0 +1,130 @@
+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";
+export function replayTraceFile(filePath, options) {
+    const input = readFileSync(filePath, "utf8");
+    const trace = parseTrace(input);
+    const { program, initialMemWrites, start, ecalliEntries, termination } = trace;
+    const hasMetadata = options.hasMetadata;
+    const useSpi = isSpiTrace(start, initialMemWrites);
+    const programInput = Array.from(program);
+    const spiArgs = Array.from(extractSpiArgs(start, initialMemWrites));
+    const preparedProgram = useSpi
+        ? prepareProgram(InputKind.SPI, hasMetadata, programInput, [], [], [], spiArgs)
+        : prepareProgram(InputKind.Generic, hasMetadata, programInput, encodeRegistersFromDump(start.registers), buildInitialPages(initialMemWrites), buildInitialChunks(initialMemWrites), []);
+    const id = pvmStart(preparedProgram, true);
+    const initialEcalliCount = ecalliEntries.length;
+    const tracer = options.tracer ?? new ConsoleTracer();
+    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);
+        }
+        for (;;) {
+            const pause = pvmResume(id, gas, pc, options.logs);
+            if (!pause) {
+                throw new Error("pvmResume returned null");
+            }
+            if (pause.status === STATUS.HOST) {
+                const expectedEcalli = ecalliEntries.shift();
+                if (!expectedEcalli) {
+                    throw new Error("Unexpected host call");
+                }
+                // 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");
+                    assertEq(pause.gas, expectedEcalli.gas, "ecalli gas");
+                    assertRegisters(pause.registers, expectedEcalli.registers);
+                }
+                // Print and verify memreads
+                for (const read of expectedEcalli.memReads) {
+                    tracer.memread(read.address, read.data);
+                    if (options.verify) {
+                        const actualData = pvmReadMemory(id, read.address, read.data.length);
+                        if (!actualData) {
+                            throw new Error(`Failed to read memory at 0x${read.address.toString(16)}`);
+                        }
+                        assertMemEq(actualData, read.data, `memread at 0x${read.address.toString(16)}`);
+                    }
+                }
+                // Apply memory writes
+                for (const write of expectedEcalli.memWrites) {
+                    tracer.memwrite(write.address, write.data);
+                    const written = pvmWriteMemory(id, write.address, write.data);
+                    if (!written) {
+                        throw new Error(`Failed to write memory at 0x${write.address.toString(16)} for PVM ${id}`);
+                    }
+                }
+                // Apply register writes
+                const regs = pause.registers;
+                for (const setReg of expectedEcalli.setRegs) {
+                    tracer.setreg(setReg.index, setReg.value);
+                    regs[setReg.index] = setReg.value;
+                }
+                pvmSetRegisters(id, regs);
+                // Update gas
+                if (expectedEcalli.setGas !== undefined) {
+                    tracer.setgas(expectedEcalli.setGas);
+                    gas = expectedEcalli.setGas;
+                }
+                else {
+                    gas = pause.gas;
+                }
+                // Advance PC
+                pc = pause.nextPc;
+            }
+            else {
+                // Termination
+                const type = statusToTermination(pause.status);
+                tracer.termination(type, pause.exitCode, pause.pc, pause.gas, pause.registers);
+                if (options.verify) {
+                    assertEq(ecalliEntries.length, 0, "more host calls expected!");
+                    assertEq(type, termination.type, "termination type");
+                    assertEq(pause.pc, termination.pc, "termination pc");
+                    assertEq(pause.gas, termination.gas, "termination gas");
+                }
+                break;
+            }
+        }
+        return {
+            success: true,
+            ecalliCount: initialEcalliCount,
+            termination: trace.termination,
+        };
+    }
+    finally {
+        // after we are done, make sure to release resources
+        pvmDestroy(id);
+    }
+}
+function assertEq(actual, expected, label) {
+    if (actual !== expected) {
+        throw new Error(`\nMismatch ${label}:\n${expected} (expected)\n${actual} (got)`);
+    }
+}
+function assertRegisters(actual, expected) {
+    for (let i = 0; i < actual.length; i++) {
+        const actualValue = actual[i];
+        const expectedValue = expected.get(i) ?? 0n;
+        if (actualValue !== expectedValue) {
+            throw new Error(`\nRegister mismatch r${i}:\n0x${expectedValue.toString(16)} (expected)\n0x${actualValue.toString(16)} (got)`);
+        }
+    }
+}
+function assertMemEq(actual, expected, label) {
+    const actualString = hexEncode(actual);
+    const expectedString = hexEncode(expected);
+    assertEq(actualString, expectedString, label);
+}

package/dist/bin/src/tracer.js

@@ -0,0 +1,64 @@
+import { hexEncode } from "./utils.js";
+export class ConsoleTracer {
+    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)}`);
+    }
+    memread(address, data) {
+        console.log(`  memread 0x${address.toString(16)} len=${data.length} -> ${formatHex(data)}`);
+    }
+    memwrite(address, data) {
+        console.log(`  memwrite 0x${address.toString(16)} len=${data.length} <- ${formatHex(data)}`);
+    }
+    setreg(index, value) {
+        console.log(`  setreg r${index.toString().padStart(2, "0")} <- 0x${value.toString(16)}`);
+    }
+    setgas(gas) {
+        console.log(`  setgas <- ${gas}`);
+    }
+    termination(type, exitCode, pc, gas, registers) {
+        let termLine = `\n------\n${type}`;
+        if (type === "PANIC" && exitCode !== 0) {
+            termLine += `=${exitCode}`;
+        }
+        termLine += ` pc=${pc} gas=${gas} ${formatRegisters(registers)}`;
+        console.log(termLine);
+    }
+}
+export class NoOpTracer {
+    start() { }
+    spiArgs() { }
+    ecalli() { }
+    memread() { }
+    memwrite() { }
+    setreg() { }
+    setgas() { }
+    termination() { }
+}
+function formatRegisters(registers) {
+    const entries = [];
+    if (Array.isArray(registers)) {
+        registers.forEach((val, idx) => {
+            if (val !== 0n)
+                entries.push({ idx, val });
+        });
+    }
+    else {
+        for (const [idx, val] of registers) {
+            if (val !== 0n)
+                entries.push({ idx, val });
+        }
+    }
+    return entries
+        .sort((a, b) => a.idx - b.idx)
+        .map((e) => `r${e.idx}=0x${e.val.toString(16)}`)
+        .join(" ");
+}
+function formatHex(data) {
+    return `0x${Buffer.from(data).toString("hex")}`;
+}