@typeberry/lib 0.5.2 → 0.5.3

package/packages/core/pvm-host-calls/ecalli-trace-logger.test.js

@@ -0,0 +1,231 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsU32, tryAsU64 } from "#@typeberry/numbers";
+import { NO_OF_REGISTERS, REGISTER_BYTE_SIZE, tryAsSmallGas } from "#@typeberry/pvm-interface";
+import { EcalliTraceLogger, IoTraceTracker } from "./ecalli-trace-logger.js";
+import { tryAsHostCallIndex } from "./host-call-handler.js";
+import { HostCallRegisters } from "./host-call-registers.js";
+/** Helper to create HostCallRegisters with specific values set. */
+function createRegisters(values) {
+    const bytes = new Uint8Array(NO_OF_REGISTERS * REGISTER_BYTE_SIZE);
+    const view = new DataView(bytes.buffer);
+    for (const [idx, value] of values) {
+        view.setBigUint64(idx * REGISTER_BYTE_SIZE, value, true);
+    }
+    return new HostCallRegisters(bytes);
+}
+describe("IoTraceLogger", () => {
+    describe("logProgram", () => {
+        it("formats program blob as hex", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            logger.logProgram(new Uint8Array([0x01, 0x02, 0xaa, 0xbb]), new Uint8Array());
+            assert.strictEqual(lines.length, 1);
+            assert.strictEqual(lines[0], "program 0x0102aabb");
+        });
+        it("handles empty program", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            logger.logProgram(new Uint8Array([]), new Uint8Array());
+            assert.strictEqual(lines[0], "program 0x");
+        });
+        it("logs args as initial memory write", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            logger.logProgram(new Uint8Array([0x01]), new Uint8Array([0x00, 0x01, 0x02]));
+            assert.strictEqual(lines.length, 2);
+            assert.strictEqual(lines[0], "program 0x01");
+            assert.strictEqual(lines[1], "memwrite 0xfeff0000 len=3 <- 0x000102");
+        });
+    });
+    describe("logStart", () => {
+        it("formats start with register dump", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            const regs = createRegisters(new Map([
+                [7, 0x10n],
+                [9, 0x10000n],
+            ]));
+            logger.logStart(0, tryAsSmallGas(10000), regs);
+            assert.strictEqual(lines[0], "start pc=0 gas=10000 r07=10 r09=10000");
+        });
+        it("handles no non-zero registers", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            const regs = createRegisters(new Map());
+            logger.logStart(42, tryAsSmallGas(5000), regs);
+            assert.strictEqual(lines[0], "start pc=42 gas=5000 ");
+        });
+    });
+    describe("logEcalli", () => {
+        it("formats ecalli with register dump", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            const regs = createRegisters(new Map([
+                [1, 0x1n],
+                [3, 0x1000n],
+            ]));
+            logger.logEcalli(tryAsHostCallIndex(10), 42, tryAsSmallGas(10000), regs);
+            assert.strictEqual(lines[0], "ecalli=10 pc=42 gas=10000 r01=1 r03=1000");
+        });
+        it("omits zero registers", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            const regs = createRegisters(new Map([
+                [0, 0n],
+                [1, 1n],
+            ]));
+            logger.logEcalli(tryAsHostCallIndex(5), 0, tryAsSmallGas(5000), regs);
+            assert.strictEqual(lines[0], "ecalli=5 pc=0 gas=5000 r01=1");
+        });
+        it("handles no non-zero registers", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            const regs = createRegisters(new Map());
+            logger.logEcalli(tryAsHostCallIndex(0), 0, tryAsSmallGas(100), regs);
+            assert.strictEqual(lines[0], "ecalli=0 pc=0 gas=100 ");
+        });
+    });
+    describe("logMemRead", () => {
+        it("formats memory read", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            logger.logMemRead(0x1000, 4, "0x01020304");
+            assert.strictEqual(lines[0], "memread 0x00001000 len=4 -> 0x01020304");
+        });
+    });
+    describe("logMemWrite", () => {
+        it("formats memory write", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            logger.logMemWrite(0x2000, 2, "0xffee");
+            assert.strictEqual(lines[0], "memwrite 0x00002000 len=2 <- 0xffee");
+        });
+    });
+    describe("logSetReg", () => {
+        it("formats register write with padded index", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            logger.logSetReg(0, 0x100n);
+            assert.strictEqual(lines[0], "setreg r00 <- 100");
+        });
+        it("formats two-digit register index", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            logger.logSetReg(12, 0x4n);
+            assert.strictEqual(lines[0], "setreg r12 <- 4");
+        });
+    });
+    describe("logSetGas", () => {
+        it("formats gas write", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            logger.logSetGas(tryAsSmallGas(9950));
+            assert.strictEqual(lines[0], "setgas <- 9950");
+        });
+    });
+    describe("logHostActions", () => {
+        it("logs actions in correct order: reads, writes, regs, gas", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            const tracker = new IoTraceTracker();
+            tracker.memWrite(tryAsU32(0x2000), new Uint8Array([0xab]));
+            tracker.memRead(tryAsU32(0x1000), new Uint8Array([0xcd]));
+            tracker.setReg(0, tryAsU64(0x100n));
+            logger.logHostActions(tracker, tryAsSmallGas(10000), tryAsSmallGas(9950));
+            assert.strictEqual(lines.length, 4);
+            assert.strictEqual(lines[0], "memread 0x00001000 len=1 -> 0xcd");
+            assert.strictEqual(lines[1], "memwrite 0x00002000 len=1 <- 0xab");
+            assert.strictEqual(lines[2], "setreg r00 <- 100");
+            assert.strictEqual(lines[3], "setgas <- 9950");
+        });
+        it("sorts reads by address", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            const tracker = new IoTraceTracker();
+            tracker.memRead(tryAsU32(0x2000), new Uint8Array([0x01]));
+            tracker.memRead(tryAsU32(0x1000), new Uint8Array([0x02]));
+            logger.logHostActions(tracker, tryAsSmallGas(100), tryAsSmallGas(100));
+            assert.strictEqual(lines[0], "memread 0x00001000 len=1 -> 0x02");
+            assert.strictEqual(lines[1], "memread 0x00002000 len=1 -> 0x01");
+        });
+        it("skips setgas if unchanged", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            const tracker = new IoTraceTracker();
+            logger.logHostActions(tracker, tryAsSmallGas(100), tryAsSmallGas(100));
+            assert.strictEqual(lines.length, 0);
+        });
+    });
+    describe("termination logging", () => {
+        it("logs HALT", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            const regs = createRegisters(new Map([[0, 0x100n]]));
+            logger.logHalt(42, tryAsSmallGas(9920), regs);
+            assert.strictEqual(lines[0], "HALT pc=42 gas=9920 r00=100");
+        });
+        it("logs OOG", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            const regs = createRegisters(new Map());
+            logger.logOog(100, tryAsSmallGas(0), regs);
+            assert.strictEqual(lines[0], "OOG pc=100 gas=0 ");
+        });
+        it("logs PANIC with argument", () => {
+            const lines = [];
+            const logger = EcalliTraceLogger.new((line) => lines.push(line));
+            const regs = createRegisters(new Map());
+            logger.logPanic(1, 50, tryAsSmallGas(500), regs);
+            assert.strictEqual(lines[0], "PANIC=1 pc=50 gas=500 ");
+        });
+    });
+    describe("noop logger", () => {
+        it("does not throw and produces no output", () => {
+            const logger = EcalliTraceLogger.noop();
+            logger.logContext("test");
+            logger.logProgram(new Uint8Array([1, 2, 3]), new Uint8Array());
+            logger.logSetGas(tryAsSmallGas(100));
+        });
+        it("returns null tracker", () => {
+            const logger = EcalliTraceLogger.noop();
+            const tracker = logger.tracker();
+            assert.strictEqual(tracker, null);
+        });
+    });
+    describe("IoTraceTracker", () => {
+        it("tracks memory reads", () => {
+            const tracker = new IoTraceTracker();
+            tracker.memRead(tryAsU32(0x1000), new Uint8Array([0x01, 0x02]));
+            tracker.memRead(tryAsU32(0x2000), new Uint8Array([0x03]));
+            assert.strictEqual(tracker.reads.length, 2);
+            assert.strictEqual(tracker.reads[0].address, 0x1000);
+            assert.strictEqual(tracker.reads[0].hex, "0x0102");
+        });
+        it("tracks memory writes", () => {
+            const tracker = new IoTraceTracker();
+            tracker.memWrite(tryAsU32(0x3000), new Uint8Array([0xaa, 0xbb]));
+            assert.strictEqual(tracker.writes.length, 1);
+            assert.strictEqual(tracker.writes[0].address, 0x3000);
+            assert.strictEqual(tracker.writes[0].hex, "0xaabb");
+        });
+        it("tracks register writes", () => {
+            const tracker = new IoTraceTracker();
+            tracker.setReg(5, tryAsU64(0x42n));
+            tracker.setReg(7, tryAsU64(0x100n));
+            assert.strictEqual(tracker.registers.size, 2);
+            assert.strictEqual(tracker.registers.get(5), tryAsU64(0x42n));
+            assert.strictEqual(tracker.registers.get(7), tryAsU64(0x100n));
+        });
+        it("clears all tracked data", () => {
+            const tracker = new IoTraceTracker();
+            tracker.memRead(tryAsU32(0x1000), new Uint8Array([0x01]));
+            tracker.memWrite(tryAsU32(0x2000), new Uint8Array([0x02]));
+            tracker.setReg(0, tryAsU64(0x100n));
+            tracker.clear();
+            assert.strictEqual(tracker.reads.length, 0);
+            assert.strictEqual(tracker.writes.length, 0);
+            assert.strictEqual(tracker.registers.size, 0);
+        });
+    });
+});

package/packages/core/pvm-host-calls/host-call-memory.d.ts

@@ -1,8 +1,10 @@
 import { type U64 } from "#@typeberry/numbers";
 import type { IMemory, PageFault } from "#@typeberry/pvm-interface";
 import { OK, Result } from "#@typeberry/utils";
+import type { IoTracker } from "./ecalli-io-tracker.js";
 export declare class HostCallMemory {
     private readonly memory;
+    ioTracker: IoTracker | null;
     constructor(memory: IMemory);
     /**
      * Save some bytes into memory under given address.

package/packages/core/pvm-host-calls/host-call-memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"host-call-memory.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-host-calls/host-call-memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE9C,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,OAAO;IAE5C;;;;;OAKG;IACH,SAAS,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC;IAYpE;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,GAAG,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC;CAWrE"}
+{"version":3,"file":"host-call-memory.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-host-calls/host-call-memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD,qBAAa,cAAc;IAIb,OAAO,CAAC,QAAQ,CAAC,MAAM;IAF5B,SAAS,EAAE,SAAS,GAAG,IAAI,CAAQ;gBAEb,MAAM,EAAE,OAAO;IAE5C;;;;;OAKG;IACH,SAAS,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC;IAgBpE;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,GAAG,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC;CAerE"}

package/packages/core/pvm-host-calls/host-call-memory.js

@@ -2,6 +2,8 @@ import { tryAsU32 } from "#@typeberry/numbers";
 import { OK, Result } from "#@typeberry/utils";
 export class HostCallMemory {
     memory;
+    // Track successful memory reads and writes.
+    ioTracker = null;
     constructor(memory) {
         this.memory = memory;
     }
@@ -19,7 +21,11 @@ export class HostCallMemory {
         //
         // https://graypaper.fluffylabs.dev/#/ab2cdbd/25ed0025ed00?v=0.7.2
         const address = tryAsU32(Number(regAddress & 0xffffffffn));
-        return this.memory.store(address, bytes);
+        const result = this.memory.store(address, bytes);
+        if (result.isOk && this.ioTracker !== null) {
+            this.ioTracker.memWrite(address, bytes);
+        }
+        return result;
     }
     /**
      * Read some bytes from memory under given address.
@@ -35,6 +41,10 @@ export class HostCallMemory {
         //
         // NOTE we are taking the the lower U32 part of the register, hence it's safe.
         const address = tryAsU32(Number(regAddress & 0xffffffffn));
-        return this.memory.read(address, output);
+        const result = this.memory.read(address, output);
+        if (result.isOk && this.ioTracker !== null) {
+            this.ioTracker.memRead(address, output);
+        }
+        return result;
     }
 }

package/packages/core/pvm-host-calls/host-call-registers.d.ts

@@ -1,7 +1,10 @@
 import { type U64 } from "#@typeberry/numbers";
+import type { IoTracker } from "./ecalli-io-tracker.js";
 export declare class HostCallRegisters {
     private readonly bytes;
+    private readonly raw;
     private readonly registers;
+    ioTracker: IoTracker | null;
     constructor(bytes: Uint8Array);
     /** Get U64 register value. */
     get(registerIndex: number): U64;
@@ -9,5 +12,8 @@ export declare class HostCallRegisters {
     set(registerIndex: number, value: U64): void;
     /** Get all registers encoded into little-endian bytes. */
     getEncoded(): Uint8Array;
+    /** Ovewrite all encoded registers. */
+    setEncoded(bytes: Uint8Array): void;
+    toString(): string;
 }
 //# sourceMappingURL=host-call-registers.d.ts.map

package/packages/core/pvm-host-calls/host-call-registers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"host-call-registers.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-host-calls/host-call-registers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAGxD,qBAAa,iBAAiB;IAGhB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;gBAER,KAAK,EAAE,UAAU;IAI9C,8BAA8B;IAC9B,GAAG,CAAC,aAAa,EAAE,MAAM,GAAG,GAAG;IAI/B,8BAA8B;IAC9B,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;IAIrC,0DAA0D;IAC1D,UAAU,IAAI,UAAU;CAGzB"}
+{"version":3,"file":"host-call-registers.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-host-calls/host-call-registers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD,qBAAa,iBAAiB;IAMhB,OAAO,CAAC,QAAQ,CAAC,KAAK;IALlC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAa;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IAE9B,SAAS,EAAE,SAAS,GAAG,IAAI,CAAQ;gBAEb,KAAK,EAAE,UAAU;IAK9C,8BAA8B;IAC9B,GAAG,CAAC,aAAa,EAAE,MAAM,GAAG,GAAG;IAI/B,8BAA8B;IAC9B,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;IAOrC,0DAA0D;IAC1D,UAAU,IAAI,UAAU;IAIxB,sCAAsC;IACtC,UAAU,CAAC,KAAK,EAAE,UAAU;IAK5B,QAAQ;CAWT"}

package/packages/core/pvm-host-calls/host-call-registers.js

@@ -1,10 +1,15 @@
 import { tryAsU64 } from "#@typeberry/numbers";
 import { REGISTER_BYTE_SIZE } from "#@typeberry/pvm-interface";
+import { check } from "#@typeberry/utils";
 export class HostCallRegisters {
     bytes;
+    raw;
     registers;
+    // Track register modifications.
+    ioTracker = null;
     constructor(bytes) {
         this.bytes = bytes;
+        this.raw = bytes;
         this.registers = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     }
     /** Get U64 register value. */
@@ -14,9 +19,28 @@ export class HostCallRegisters {
     /** Set U64 register value. */
     set(registerIndex, value) {
         this.registers.setBigUint64(registerIndex * REGISTER_BYTE_SIZE, value, true);
+        if (this.ioTracker !== null) {
+            this.ioTracker.setReg(registerIndex, value);
+        }
     }
     /** Get all registers encoded into little-endian bytes. */
     getEncoded() {
         return this.bytes;
     }
+    /** Ovewrite all encoded registers. */
+    setEncoded(bytes) {
+        check `${bytes.length === this.raw.length} Invalid registers array: ${bytes.length} vs ${this.raw.length}`;
+        this.raw.set(bytes, 0);
+    }
+    toString() {
+        const elementCount = this.raw.byteLength / REGISTER_BYTE_SIZE;
+        const values = new BigUint64Array(this.raw.buffer, this.raw.byteOffset, elementCount);
+        const entries = [];
+        for (const [idx, value] of values.entries()) {
+            if (value !== 0n) {
+                entries.push(`r${idx.toString().padStart(2, "0")}=${value.toString(16)}`);
+            }
+        }
+        return entries.join(" ");
+    }
 }

package/packages/core/pvm-host-calls/host-calls-executor.d.ts

@@ -0,0 +1,31 @@
+import { type Gas, Status } from "#@typeberry/pvm-interface";
+import { EcalliTraceLogger } from "./ecalli-trace-logger.js";
+import type { HostCalls } from "./host-calls.js";
+import type { PvmInstanceManager } from "./pvm-instance-manager.js";
+declare class ReturnValue {
+    consumedGas: Gas;
+    status: Status | null;
+    memorySlice: Uint8Array | null;
+    private constructor();
+    static fromStatus(consumedGas: Gas, status: Status): ReturnValue;
+    static fromMemorySlice(consumedGas: Gas, memorySlice: Uint8Array): ReturnValue;
+    hasMemorySlice(): this is this & {
+        status: null;
+        memorySlice: Uint8Array;
+    };
+    hasStatus(): this is this & {
+        status: Status;
+        memorySlice: null;
+    };
+}
+export declare class HostCallsExecutor {
+    private pvmInstanceManager;
+    private hostCalls;
+    private ioTracer;
+    constructor(pvmInstanceManager: PvmInstanceManager, hostCalls: HostCalls, ioTracer?: EcalliTraceLogger | null);
+    private getReturnValue;
+    private execute;
+    runProgram(program: Uint8Array, args: Uint8Array, initialPc: number, initialGas: Gas): Promise<ReturnValue>;
+}
+export {};
+//# sourceMappingURL=host-calls-executor.d.ts.map

package/packages/core/pvm-host-calls/host-calls-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-calls-executor.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-host-calls/host-calls-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAwB,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAElF,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAI7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,cAAM,WAAW;IAEN,WAAW,EAAE,GAAG;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI;IACrB,WAAW,EAAE,UAAU,GAAG,IAAI;IAHvC,OAAO;IAWP,MAAM,CAAC,UAAU,CAAC,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM;IAIlD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,GAAG,EAAE,WAAW,EAAE,UAAU;IAIhE,cAAc,IAAI,IAAI,IAAI,IAAI,GAAG;QAAE,MAAM,EAAE,IAAI,CAAC;QAAC,WAAW,EAAE,UAAU,CAAA;KAAE;IAI1E,SAAS,IAAI,IAAI,IAAI,IAAI,GAAG;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,IAAI,CAAA;KAAE;CAGlE;AAED,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,QAAQ;gBAFR,kBAAkB,EAAE,kBAAkB,EACtC,SAAS,EAAE,SAAS,EACpB,QAAQ,GAAE,iBAAiB,GAAG,IAAiC;IAGzE,OAAO,CAAC,cAAc;YAoCR,OAAO;IAiFf,UAAU,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,GAAG,OAAO,CAAC,WAAW,CAAC;CAWlH"}

package/packages/core/pvm-host-calls/host-calls-executor.js

@@ -0,0 +1,137 @@
+import { Status } from "#@typeberry/pvm-interface";
+import { assertNever, check, safeAllocUint8Array } from "#@typeberry/utils";
+import { EcalliTraceLogger } from "./ecalli-trace-logger.js";
+import { PvmExecution, tryAsHostCallIndex } from "./host-call-handler.js";
+import { HostCallMemory } from "./host-call-memory.js";
+import { HostCallRegisters } from "./host-call-registers.js";
+class ReturnValue {
+    consumedGas;
+    status;
+    memorySlice;
+    constructor(consumedGas, status, memorySlice) {
+        this.consumedGas = consumedGas;
+        this.status = status;
+        this.memorySlice = memorySlice;
+        check `
+      ${(status === null && memorySlice !== null) || (status !== null && memorySlice === null)}
+      'status' and 'memorySlice' must not both be null or both be non-null — exactly one must be provided
+    `;
+    }
+    static fromStatus(consumedGas, status) {
+        return new ReturnValue(consumedGas, status, null);
+    }
+    static fromMemorySlice(consumedGas, memorySlice) {
+        return new ReturnValue(consumedGas, null, memorySlice);
+    }
+    hasMemorySlice() {
+        return this.memorySlice instanceof Uint8Array && this.status === null;
+    }
+    hasStatus() {
+        return !this.hasMemorySlice();
+    }
+}
+export class HostCallsExecutor {
+    pvmInstanceManager;
+    hostCalls;
+    ioTracer;
+    constructor(pvmInstanceManager, hostCalls, ioTracer = EcalliTraceLogger.create()) {
+        this.pvmInstanceManager = pvmInstanceManager;
+        this.hostCalls = hostCalls;
+        this.ioTracer = ioTracer;
+    }
+    getReturnValue(status, pvmInstance, registers, memory) {
+        const gasConsumed = pvmInstance.gas.used();
+        const pc = pvmInstance.getPC();
+        const gas = pvmInstance.gas.get();
+        if (status === Status.OOG) {
+            this.ioTracer?.logOog(pc, gas, registers);
+            return ReturnValue.fromStatus(gasConsumed, status);
+        }
+        if (status === Status.HALT) {
+            this.ioTracer?.logHalt(pc, gas, registers);
+            const address = registers.get(7);
+            const length = Number(registers.get(8) & 0xffffffffn);
+            const result = safeAllocUint8Array(length);
+            const loadResult = memory.loadInto(result, address);
+            if (loadResult.isError) {
+                return ReturnValue.fromMemorySlice(gasConsumed, new Uint8Array());
+            }
+            return ReturnValue.fromMemorySlice(gasConsumed, result);
+        }
+        this.ioTracer?.logPanic(pvmInstance.getExitParam() ?? 0, pc, gas, registers);
+        return ReturnValue.fromStatus(gasConsumed, Status.PANIC);
+    }
+    async execute(pvmInstance) {
+        const ioTracker = this.ioTracer?.tracker() ?? null;
+        const registers = new HostCallRegisters(pvmInstance.registers.getAllEncoded());
+        registers.ioTracker = ioTracker;
+        const memory = new HostCallMemory(pvmInstance.memory);
+        memory.ioTracker = ioTracker;
+        const gas = pvmInstance.gas;
+        // log start of execution (note the PVM initialisation should be logged already)
+        this.ioTracer?.logStart(pvmInstance.getPC(), pvmInstance.gas.get(), registers);
+        for (;;) {
+            // execute program as much as we can
+            pvmInstance.runProgram();
+            // and update the PVM state
+            registers.setEncoded(pvmInstance.registers.getAllEncoded());
+            const status = pvmInstance.getStatus();
+            const pc = pvmInstance.getPC();
+            const exitParam = pvmInstance.getExitParam() ?? -1;
+            if (status !== Status.HOST) {
+                return this.getReturnValue(status, pvmInstance, registers, memory);
+            }
+            // get the PVM state now
+            check `
+        ${exitParam !== -1}
+        "We know that the exit param is not null, because the status is 'Status.HOST'
+      `;
+            const hostCallIndex = tryAsHostCallIndex(exitParam);
+            // retrieve the host call
+            const hostCall = this.hostCalls.get(hostCallIndex);
+            const basicGasCost = typeof hostCall.basicGasCost === "number" ? hostCall.basicGasCost : hostCall.basicGasCost(registers);
+            // calculate gas
+            const gasBefore = gas.get();
+            const underflow = gas.sub(basicGasCost);
+            const pcLog = `[PC: ${pc}]`;
+            if (underflow) {
+                const gasAfterBasicGas = gas.get();
+                this.hostCalls.traceHostCall(`${pcLog} OOG`, hostCallIndex, hostCall, registers, gasAfterBasicGas);
+                this.ioTracer?.logSetGas(gasAfterBasicGas);
+                return this.getReturnValue(Status.OOG, pvmInstance, registers, memory);
+            }
+            this.ioTracer?.logEcalli(hostCallIndex, pc, gasBefore, registers);
+            this.hostCalls.traceHostCall(`${pcLog} Invoking`, hostCallIndex, hostCall, registers, gasBefore);
+            ioTracker?.clear();
+            const result = await hostCall.execute(gas, registers, memory);
+            const gasAfter = gas.get();
+            this.ioTracer?.logHostActions(ioTracker, gasBefore, gasAfter);
+            this.hostCalls.traceHostCall(result === undefined ? `${pcLog} Result` : `${pcLog} Status(${PvmExecution[result]})`, hostCallIndex, hostCall, registers, gasAfter);
+            pvmInstance.registers.setAllEncoded(registers.getEncoded());
+            if (result === PvmExecution.Halt) {
+                return this.getReturnValue(Status.HALT, pvmInstance, registers, memory);
+            }
+            if (result === PvmExecution.Panic) {
+                return this.getReturnValue(Status.PANIC, pvmInstance, registers, memory);
+            }
+            if (result === PvmExecution.OOG) {
+                return this.getReturnValue(Status.OOG, pvmInstance, registers, memory);
+            }
+            if (result === undefined) {
+                continue;
+            }
+            assertNever(result);
+        }
+    }
+    async runProgram(program, args, initialPc, initialGas) {
+        const pvmInstance = await this.pvmInstanceManager.getInstance();
+        pvmInstance.resetJam(program, args, initialPc, initialGas);
+        try {
+            this.ioTracer?.logProgram(program, args);
+            return await this.execute(pvmInstance);
+        }
+        finally {
+            this.pvmInstanceManager.releaseInstance(pvmInstance);
+        }
+    }
+}

package/packages/core/pvm-host-calls/host-calls.d.ts

@@ -1,29 +1,23 @@
-import { type Gas, Status } from "#@typeberry/pvm-interface";
-import type { HostCallsManager } from "./host-calls-manager.js";
-import type { InterpreterInstanceManager } from "./interpreter-instance-manager.js";
-declare class ReturnValue {
-    consumedGas: Gas;
-    status: Status | null;
-    memorySlice: Uint8Array | null;
-    private constructor();
-    static fromStatus(consumedGas: Gas, status: Status): ReturnValue;
-    static fromMemorySlice(consumedGas: Gas, memorySlice: Uint8Array): ReturnValue;
-    hasMemorySlice(): this is this & {
-        status: null;
-        memorySlice: Uint8Array;
-    };
-    hasStatus(): this is this & {
-        status: Status;
-        memorySlice: null;
-    };
-}
+import { type Gas } from "#@typeberry/pvm-interface";
+import { type HostCallHandler, type HostCallIndex, type PvmExecution } from "./host-call-handler.js";
+import type { HostCallRegisters } from "./host-call-registers.js";
+/** Container for all available host calls. */
 export declare class HostCalls {
-    private pvmInstanceManager;
-    private hostCalls;
-    constructor(pvmInstanceManager: InterpreterInstanceManager, hostCalls: HostCallsManager);
-    private getReturnValue;
-    private execute;
-    runProgram(program: Uint8Array, args: Uint8Array, initialPc: number, initialGas: Gas): Promise<ReturnValue>;
+    private readonly hostCalls;
+    private readonly missing;
+    constructor({ missing, handlers, }: {
+        missing: HostCallHandler;
+        handlers?: HostCallHandler[];
+    });
+    /** Get a host call by index. */
+    get(hostCallIndex: HostCallIndex): HostCallHandler;
+    traceHostCall(context: string, hostCallIndex: HostCallIndex, hostCallHandler: HostCallHandler, registers: HostCallRegisters, gas: Gas): void;
+}
+export declare class NoopMissing implements HostCallHandler {
+    index: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"HostCallIndex[U32]">;
+    basicGasCost: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"SmallGas[U32]">;
+    currentServiceId: import("@typeberry/numbers").U32;
+    tracedRegisters: never[];
+    execute(): Promise<undefined | PvmExecution>;
 }
-export {};
 //# sourceMappingURL=host-calls.d.ts.map

package/packages/core/pvm-host-calls/host-calls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"host-calls.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-host-calls/host-calls.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAwB,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAKlF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAEpF,cAAM,WAAW;IAEN,WAAW,EAAE,GAAG;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI;IACrB,WAAW,EAAE,UAAU,GAAG,IAAI;IAHvC,OAAO;IAWP,MAAM,CAAC,UAAU,CAAC,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM;IAIlD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,GAAG,EAAE,WAAW,EAAE,UAAU;IAIhE,cAAc,IAAI,IAAI,IAAI,IAAI,GAAG;QAAE,MAAM,EAAE,IAAI,CAAC;QAAC,WAAW,EAAE,UAAU,CAAA;KAAE;IAI1E,SAAS,IAAI,IAAI,IAAI,IAAI,GAAG;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,IAAI,CAAA;KAAE;CAGlE;AACD,qBAAa,SAAS;IAElB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,SAAS;gBADT,kBAAkB,EAAE,0BAA0B,EAC9C,SAAS,EAAE,gBAAgB;IAGrC,OAAO,CAAC,cAAc;YA2BR,OAAO;IAiEf,UAAU,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,GAAG,OAAO,CAAC,WAAW,CAAC;CASlH"}
+{"version":3,"file":"host-calls.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-host-calls/host-calls.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,GAAG,EAAiB,MAAM,0BAA0B,CAAC;AAEnE,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,YAAY,EAElB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIlE,8CAA8C;AAC9C,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6C;IACvE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;gBAEb,EACV,OAAO,EACP,QAAa,GACd,EAAE;QACD,OAAO,EAAE,eAAe,CAAC;QACzB,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;KAC9B;IASD,gCAAgC;IAChC,GAAG,CAAC,aAAa,EAAE,aAAa,GAAG,eAAe;IAIlD,aAAa,CACX,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe,EAChC,SAAS,EAAE,iBAAiB,EAC5B,GAAG,EAAE,GAAG;CAkBX;AAED,qBAAa,WAAY,YAAW,eAAe;IACjD,KAAK,iIAAmC;IACxC,YAAY,4HAAoB;IAChC,gBAAgB,mCAAe;IAC/B,eAAe,UAAM;IAEf,OAAO,IAAI,OAAO,CAAC,SAAS,GAAG,YAAY,CAAC;CAGnD"}