@typeberry/lib 0.5.2 → 0.5.3-aa4626d

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

@@ -0,0 +1,129 @@
+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";
+/**
+ * Outer VM return status.
+ *
+ * This is a limited status returned by outer VM.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/24a10124a101?v=0.7.2
+ */
+export var ReturnStatus;
+(function (ReturnStatus) {
+    /** Execution succesful. */
+    ReturnStatus[ReturnStatus["OK"] = 0] = "OK";
+    /** Execution went out of gas. */
+    ReturnStatus[ReturnStatus["OOG"] = 1] = "OOG";
+    /** Execution trapped or panicked. */
+    ReturnStatus[ReturnStatus["PANIC"] = 2] = "PANIC";
+})(ReturnStatus || (ReturnStatus = {}));
+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 consumedGas = pvmInstance.gas.used();
+        const pc = pvmInstance.getPC();
+        const gas = pvmInstance.gas.get();
+        if (status === Status.OOG) {
+            this.ioTracer?.logOog(pc, gas, registers);
+            return { consumedGas, status: ReturnStatus.OOG };
+        }
+        if (status === Status.HALT) {
+            this.ioTracer?.logHalt(pc, gas, registers);
+            const address = registers.get(7);
+            // NOTE we are taking the the lower U32 part of the register, hence it's safe.
+            const length = Number(registers.get(8) & 0xffffffffn);
+            const result = safeAllocUint8Array(length);
+            const loadResult = memory.loadInto(result, address);
+            if (loadResult.isError) {
+                return { consumedGas, status: ReturnStatus.OK, memorySlice: new Uint8Array() };
+            }
+            return { consumedGas, status: ReturnStatus.OK, memorySlice: result };
+        }
+        this.ioTracer?.logPanic(pvmInstance.getExitParam() ?? 0, pc, gas, registers);
+        return { consumedGas, status: ReturnStatus.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);
+            // NOTE: `basicGasCost(regs)` function is for compatibility reasons: pre GP 0.7.2
+            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"}

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

@@ -1,119 +1,47 @@
-import { Status } from "#@typeberry/pvm-interface";
-import { assertNever, check, safeAllocUint8Array } from "#@typeberry/utils";
-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();
-    }
-}
+import { Level, Logger } from "#@typeberry/logger";
+import { tryAsU32 } from "#@typeberry/numbers";
+import { tryAsSmallGas } from "#@typeberry/pvm-interface";
+import { check } from "#@typeberry/utils";
+import { tryAsHostCallIndex, } from "./host-call-handler.js";
+const logger = Logger.new(import.meta.filename, "host-calls-pvm");
+/** Container for all available host calls. */
 export class HostCalls {
-    pvmInstanceManager;
-    hostCalls;
-    constructor(pvmInstanceManager, hostCalls) {
-        this.pvmInstanceManager = pvmInstanceManager;
-        this.hostCalls = hostCalls;
-    }
-    getReturnValue(status, pvmInstance) {
-        const gasConsumed = pvmInstance.gas.used();
-        if (status === Status.OOG) {
-            return ReturnValue.fromStatus(gasConsumed, status);
-        }
-        if (status === Status.HALT) {
-            const regs = new HostCallRegisters(pvmInstance.registers.getAllEncoded());
-            const memory = new HostCallMemory(pvmInstance.memory);
-            const address = regs.get(7);
-            // NOTE we are taking the the lower U32 part of the register, hence it's safe.
-            const length = Number(regs.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);
+    hostCalls = new Map();
+    missing;
+    constructor({ missing, handlers = [], }) {
+        this.missing = missing;
+        for (const handler of handlers) {
+            check `${this.hostCalls.get(handler.index) === undefined} Overwriting host call handler at index ${handler.index}`;
+            this.hostCalls.set(handler.index, handler);
         }
-        return ReturnValue.fromStatus(gasConsumed, Status.PANIC);
     }
-    async execute(pvmInstance) {
-        pvmInstance.runProgram();
-        for (;;) {
-            let status = pvmInstance.getStatus();
-            if (status !== Status.HOST) {
-                return this.getReturnValue(status, pvmInstance);
-            }
-            check `
-        ${pvmInstance.getExitParam() !== null}
-        "We know that the exit param is not null, because the status is 'Status.HOST'
-      `;
-            const hostCallIndex = pvmInstance.getExitParam() ?? -1;
-            const gas = pvmInstance.gas;
-            const regs = new HostCallRegisters(pvmInstance.registers.getAllEncoded());
-            const memory = new HostCallMemory(pvmInstance.memory);
-            const index = tryAsHostCallIndex(hostCallIndex);
-            const hostCall = this.hostCalls.get(index);
-            const gasBefore = gas.get();
-            // NOTE: `basicGasCost(regs)` function is for compatibility reasons: pre GP 0.7.2
-            const basicGasCost = typeof hostCall.basicGasCost === "number" ? hostCall.basicGasCost : hostCall.basicGasCost(regs);
-            const underflow = gas.sub(basicGasCost);
-            const pcLog = `[PC: ${pvmInstance.getPC()}]`;
-            if (underflow) {
-                this.hostCalls.traceHostCall(`${pcLog} OOG`, index, hostCall, regs, gas.get());
-                return ReturnValue.fromStatus(gas.used(), Status.OOG);
-            }
-            this.hostCalls.traceHostCall(`${pcLog} Invoking`, index, hostCall, regs, gasBefore);
-            const result = await hostCall.execute(gas, regs, memory);
-            this.hostCalls.traceHostCall(result === undefined ? `${pcLog} Result` : `${pcLog} Status(${PvmExecution[result]})`, index, hostCall, regs, gas.get());
-            pvmInstance.registers.setAllEncoded(regs.getEncoded());
-            if (result === PvmExecution.Halt) {
-                status = Status.HALT;
-                return this.getReturnValue(status, pvmInstance);
-            }
-            if (result === PvmExecution.Panic) {
-                status = Status.PANIC;
-                return this.getReturnValue(status, pvmInstance);
-            }
-            if (result === PvmExecution.OOG) {
-                status = Status.OOG;
-                return this.getReturnValue(status, pvmInstance);
-            }
-            if (result === undefined) {
-                pvmInstance.runProgram();
-                status = pvmInstance.getStatus();
-                continue;
-            }
-            assertNever(result);
-        }
+    /** Get a host call by index. */
+    get(hostCallIndex) {
+        return this.hostCalls.get(hostCallIndex) ?? this.missing;
     }
-    async runProgram(program, args, initialPc, initialGas) {
-        const pvmInstance = await this.pvmInstanceManager.getInstance();
-        pvmInstance.resetJam(program, args, initialPc, initialGas);
-        try {
-            return await this.execute(pvmInstance);
-        }
-        finally {
-            this.pvmInstanceManager.releaseInstance(pvmInstance);
+    traceHostCall(context, hostCallIndex, hostCallHandler, registers, gas) {
+        if (logger.getLevel() > Level.INSANE) {
+            return;
         }
+        const { currentServiceId } = hostCallHandler;
+        const requested = hostCallIndex !== hostCallHandler.index ? ` (${hostCallIndex})` : "";
+        const name = `${hostCallHandler.constructor.name}:${hostCallHandler.index}`;
+        const registerValues = hostCallHandler.tracedRegisters
+            .map((idx) => [idx.toString().padStart(2, "0"), registers.get(idx)])
+            .filter((v) => v[1] !== 0n)
+            .map(([idx, value]) => {
+            return `r${idx}=${value} (0x${value.toString(16)})`;
+        })
+            .join(", ");
+        logger.insane `[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`;
+    }
+}
+export class NoopMissing {
+    index = tryAsHostCallIndex(2 ** 32 - 1);
+    basicGasCost = tryAsSmallGas(0);
+    currentServiceId = tryAsU32(0);
+    tracedRegisters = [];
+    async execute() {
+        return;
     }
 }

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

@@ -1,7 +1,8 @@
-export { type HostCallHandler, PvmExecution, traceRegisters, tryAsHostCallIndex } from "./host-call-handler.js";
-export { HostCallMemory } from "./host-call-memory.js";
-export { HostCallRegisters } from "./host-call-registers.js";
-export { HostCalls as PvmHostCallExtension } from "./host-calls.js";
-export { HostCallsManager as HostCalls } from "./host-calls-manager.js";
-export { InterpreterInstanceManager as PvmInstanceManager } from "./interpreter-instance-manager.js";
+export * from "./ecalli-trace-logger.js";
+export * from "./host-call-handler.js";
+export * from "./host-call-memory.js";
+export * from "./host-call-registers.js";
+export * from "./host-calls.js";
+export * from "./host-calls-executor.js";
+export * from "./pvm-instance-manager.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-host-calls/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAChH,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,SAAS,IAAI,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACpE,OAAO,EAAE,gBAAgB,IAAI,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAAE,0BAA0B,IAAI,kBAAkB,EAAE,MAAM,mCAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-host-calls/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC"}

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

@@ -1,6 +1,7 @@
-export { PvmExecution, traceRegisters, tryAsHostCallIndex } from "./host-call-handler.js";
-export { HostCallMemory } from "./host-call-memory.js";
-export { HostCallRegisters } from "./host-call-registers.js";
-export { HostCalls as PvmHostCallExtension } from "./host-calls.js";
-export { HostCallsManager as HostCalls } from "./host-calls-manager.js";
-export { InterpreterInstanceManager as PvmInstanceManager } from "./interpreter-instance-manager.js";
+export * from "./ecalli-trace-logger.js";
+export * from "./host-call-handler.js";
+export * from "./host-call-memory.js";
+export * from "./host-call-registers.js";
+export * from "./host-calls.js";
+export * from "./host-calls-executor.js";
+export * from "./pvm-instance-manager.js";

package/packages/core/pvm-host-calls/{interpreter-instance-manager.d.ts → pvm-instance-manager.d.ts}

@@ -1,11 +1,11 @@
 import { PvmBackend } from "#@typeberry/config";
 import type { IPvmInterpreter } from "#@typeberry/pvm-interface";
-export declare class InterpreterInstanceManager {
+export declare class PvmInstanceManager {
     private readonly instances;
     private waitingQueue;
     private constructor();
-    static new(interpreter: PvmBackend): Promise<InterpreterInstanceManager>;
+    static new(interpreter: PvmBackend): Promise<PvmInstanceManager>;
     getInstance(): Promise<IPvmInterpreter>;
     releaseInstance(pvm: IPvmInterpreter): void;
 }
-//# sourceMappingURL=interpreter-instance-manager.d.ts.map
+//# sourceMappingURL=pvm-instance-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pvm-instance-manager.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-host-calls/pvm-instance-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAQhE,qBAAa,kBAAkB;IAGT,OAAO,CAAC,QAAQ,CAAC,SAAS;IAF9C,OAAO,CAAC,YAAY,CAAmB;IAEvC,OAAO;WAEM,GAAG,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAmBhE,WAAW,IAAI,OAAO,CAAC,eAAe,CAAC;IAU7C,eAAe,CAAC,GAAG,EAAE,eAAe;CAOrC"}

package/packages/core/pvm-host-calls/{interpreter-instance-manager.js → pvm-instance-manager.js}

@@ -3,7 +3,7 @@ import { Interpreter } from "#@typeberry/pvm-interpreter";
 import { AnanasInterpreter } from "#@typeberry/pvm-interpreter-ananas";
 import { assertNever } from "#@typeberry/utils";
 // TODO [MaSo] Delete this & also make host calls independent from intepreters.
-export class InterpreterInstanceManager {
+export class PvmInstanceManager {
     instances;
     waitingQueue = [];
     constructor(instances) {
@@ -23,7 +23,7 @@ export class InterpreterInstanceManager {
             default:
                 assertNever(interpreter);
         }
-        return new InterpreterInstanceManager(instances);
+        return new PvmInstanceManager(instances);
     }
     async getInstance() {
         const instance = this.instances.pop();

package/packages/core/pvm-interpreter/ops/math-consts.d.ts

@@ -1,6 +1,5 @@
-export declare const MAX_VALUE = 4294967295;
-export declare const MAX_VALUE_U64: bigint;
-export declare const MIN_VALUE: number;
+export declare const MAX_VALUE_I64: bigint;
+export declare const MIN_VALUE_I32: number;
 export declare const MAX_SHIFT_U32 = 32;
 export declare const MAX_SHIFT_U64 = 64n;
 //# sourceMappingURL=math-consts.d.ts.map

package/packages/core/pvm-interpreter/ops/math-consts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"math-consts.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/ops/math-consts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,aAAa,CAAC;AACpC,eAAO,MAAM,aAAa,QAAY,CAAC;AACvC,eAAO,MAAM,SAAS,QAAa,CAAC;AACpC,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,aAAa,MAAM,CAAC"}
+{"version":3,"file":"math-consts.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/ops/math-consts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,QAAY,CAAC;AACvC,eAAO,MAAM,aAAa,QAAa,CAAC;AACxC,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,aAAa,MAAM,CAAC"}

package/packages/core/pvm-interpreter/ops/math-consts.js

@@ -1,5 +1,4 @@
-export const MAX_VALUE = 4294967295;
-export const MAX_VALUE_U64 = 2n ** 63n;
-export const MIN_VALUE = -(2 ** 31);
+export const MAX_VALUE_I64 = 2n ** 63n;
+export const MIN_VALUE_I32 = -(2 ** 31);
 export const MAX_SHIFT_U32 = 32;
 export const MAX_SHIFT_U64 = 64n;

package/packages/core/pvm-interpreter/ops/math-ops.js

@@ -1,5 +1,5 @@
 import { signExtend32To64 } from "../registers.js";
-import { MIN_VALUE } from "./math-consts.js";
+import { MIN_VALUE_I32 } from "./math-consts.js";
 import { addWithOverflowU32, addWithOverflowU64, maxBigInt, minBigInt, mulLowerUnsignedU32, mulU64, mulUpperSS, mulUpperSU, mulUpperUU, subU32, subU64, } from "./math-utils.js";
 export class MathOps {
     regs;
@@ -61,7 +61,7 @@ export class MathOps {
         if (this.regs.getLowerU32(secondIndex) === 0) {
             this.regs.setU64(resultIndex, 2n ** 64n - 1n);
         }
-        else if (this.regs.getLowerI32(secondIndex) === -1 && this.regs.getLowerI32(firstIndex) === MIN_VALUE) {
+        else if (this.regs.getLowerI32(secondIndex) === -1 && this.regs.getLowerI32(firstIndex) === MIN_VALUE_I32) {
             this.regs.setU64(resultIndex, signExtend32To64(this.regs.getLowerU32(firstIndex)));
         }
         else {
@@ -99,7 +99,7 @@ export class MathOps {
         if (this.regs.getLowerU32(secondIndex) === 0) {
             this.regs.setU64(resultIndex, BigInt(this.regs.getLowerI32(firstIndex)));
         }
-        else if (this.regs.getLowerI32(secondIndex) === -1 && this.regs.getLowerI32(firstIndex) === MIN_VALUE) {
+        else if (this.regs.getLowerI32(secondIndex) === -1 && this.regs.getLowerI32(firstIndex) === MIN_VALUE_I32) {
             this.regs.setU64(resultIndex, 0n);
         }
         else {

package/packages/core/pvm-interpreter/ops/math-utils.js

@@ -1,25 +1,25 @@
+import { MAX_VALUE_U32 } from "#@typeberry/numbers";
 import { check } from "#@typeberry/utils";
-import { MAX_VALUE } from "./math-consts.js";
 /**
  * Overflowing addition for two-complement representation of 32-bit signed numbers.
  */
 export function addWithOverflowU32(a, b) {
-    if (a > MAX_VALUE - b) {
+    if (a > MAX_VALUE_U32 - b) {
         /**
-         * MAX_VALUE is equal to 2 ** 32 - 1
-         * MAX_VALUE - ( (MAX_VALUE - a) + (MAX_VALUE - b) ) - 1
-         * = MAX_VALUE - (2MAX_VALUE - a - b) -1
-         * = MAX_VALUE - 2MAX_VALUE + a + b - 1
-         * = a + b - MAX_VALUE - 1
+         * MAX_VALUE_U32 is equal to 2 ** 32 - 1
+         * MAX_VALUE_U32 - ( (MAX_VALUE_U32 - a) + (MAX_VALUE_U32 - b) ) - 1
+         * = MAX_VALUE_U32 - (2MAX_VALUE_U32 - a - b) -1
+         * = MAX_VALUE_U32 - 2MAX_VALUE_U32 + a + b - 1
+         * = a + b - MAX_VALUE_U32 - 1
          * = a + b - 2 ** 32
-         * but we know that 2MAX_VALUE > a + b > MAX_VALUE so in this case:
+         * but we know that 2MAX_VALUE_U32 > a + b > MAX_VALUE_U32 so in this case:
          * a + b - 2 ** 32 <=> (a + b) % 2 ** 32
-         * = (a + b) % (MAX_VALUE + 1)
+         * = (a + b) % (MAX_VALUE_U32 + 1)
          */
-        const spaceToMaxA = MAX_VALUE - a;
-        const spaceToMaxB = MAX_VALUE - b;
+        const spaceToMaxA = MAX_VALUE_U32 - a;
+        const spaceToMaxB = MAX_VALUE_U32 - b;
         const overflowSum = spaceToMaxA + spaceToMaxB;
-        return MAX_VALUE - overflowSum - 1;
+        return MAX_VALUE_U32 - overflowSum - 1;
     }
     return a + b;
 }
@@ -34,7 +34,7 @@ export function addWithOverflowU64(a, b) {
  */
 export function subU32(a, b) {
     if (b > a) {
-        return MAX_VALUE - b + a + 1;
+        return MAX_VALUE_U32 - b + a + 1;
     }
     return a - b;
 }

package/packages/core/pvm-interpreter/ops/math-utils.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert";
 import { describe, it } from "node:test";
-import { MAX_VALUE, MAX_VALUE_U64 } from "./math-consts.js";
+import { MAX_VALUE_U32 } from "#@typeberry/numbers";
+import { MAX_VALUE_I64 } from "./math-consts.js";
 import { addWithOverflowU32, addWithOverflowU64, maxBigInt, minBigInt, mulLowerUnsignedU32, mulU64, mulUpperSS, mulUpperSU, mulUpperUU, subU32, subU64, unsignedRightShiftBigInt, } from "./math-utils.js";
 describe("math-utils", () => {
     describe("addWithOverflow", () => {
@@ -12,7 +13,7 @@ describe("math-utils", () => {
             assert.strictEqual(result, expectedResult);
         });
         it("should add two numbers (big and small) without overflow", () => {
-            const a = MAX_VALUE;
+            const a = MAX_VALUE_U32;
             const b = 6;
             const expectedResult = 5;
             const result = addWithOverflowU32(a, b);
@@ -26,9 +27,9 @@ describe("math-utils", () => {
             assert.strictEqual(result, expectedResult);
         });
         it("should add max values with overflow", () => {
-            const a = MAX_VALUE;
-            const b = MAX_VALUE;
-            const expectedResult = MAX_VALUE - 1;
+            const a = MAX_VALUE_U32;
+            const b = MAX_VALUE_U32;
+            const expectedResult = MAX_VALUE_U32 - 1;
             const result = addWithOverflowU32(a, b);
             assert.strictEqual(result, expectedResult);
         });
@@ -44,7 +45,7 @@ describe("math-utils", () => {
         it("should subtract two numbers with overflow", () => {
             const a = 5;
             const b = 6;
-            const expectedResult = MAX_VALUE;
+            const expectedResult = MAX_VALUE_U32;
             const result = subU32(a, b);
             assert.strictEqual(result, expectedResult);
         });
@@ -95,29 +96,29 @@ describe("math-utils", () => {
             assert.strictEqual(result, expectedResult);
         });
         it("should multiply two big positive numbers", () => {
-            const a = MAX_VALUE_U64;
-            const b = MAX_VALUE_U64;
+            const a = MAX_VALUE_I64;
+            const b = MAX_VALUE_I64;
             const expectedResult = 0x4000000000000000n;
             const result = mulUpperUU(a, b);
             assert.strictEqual(result, expectedResult);
         });
         it("should multiply two big positive and negative numbers", () => {
-            const a = MAX_VALUE_U64;
-            const b = -MAX_VALUE_U64;
+            const a = MAX_VALUE_I64;
+            const b = -MAX_VALUE_I64;
             const expectedResult = 4611686018427387904n;
             const result = mulUpperUU(a, b);
             assert.strictEqual(result, expectedResult);
         });
         it("should multiply two big negative and positive numbers", () => {
-            const a = -MAX_VALUE_U64;
-            const b = MAX_VALUE_U64;
+            const a = -MAX_VALUE_I64;
+            const b = MAX_VALUE_I64;
             const expectedResult = 4611686018427387904n;
             const result = mulUpperUU(a, b);
             assert.strictEqual(result, expectedResult);
         });
         it("should multiply two big negative numbers", () => {
-            const a = -MAX_VALUE_U64;
-            const b = -MAX_VALUE_U64;
+            const a = -MAX_VALUE_I64;
+            const b = -MAX_VALUE_I64;
             const expectedResult = 0x4000000000000000n;
             const result = mulUpperUU(a, b);
             assert.strictEqual(result, expectedResult);
@@ -153,8 +154,8 @@ describe("math-utils", () => {
             assert.strictEqual(result, expectedResult);
         });
         it("should multiply two big positive numbers", () => {
-            const a = MAX_VALUE_U64;
-            const b = MAX_VALUE_U64;
+            const a = MAX_VALUE_I64;
+            const b = MAX_VALUE_I64;
             const expectedResult = 0x4000000000000000n;
             const result = mulUpperSU(a, b);
             assert.strictEqual(result, expectedResult);

package/packages/core/telemetry/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@typeberry/telemetry",
-    "version": "0.5.2",
+    "version": "0.5.3",
     "description": "OpenTelemetry initialization utilities for Typeberry",
     "license": "MPL-2.0",
     "author": "Fluffy Labs",