@typeberry/lib 0.5.1-a4d7c93 → 0.5.1-eb84786

package/packages/core/pvm-interpreter/instruction.js

@@ -0,0 +1,143 @@
+export var Instruction;
+(function (Instruction) {
+    Instruction[Instruction["TRAP"] = 0] = "TRAP";
+    Instruction[Instruction["FALLTHROUGH"] = 1] = "FALLTHROUGH";
+    Instruction[Instruction["ECALLI"] = 10] = "ECALLI";
+    Instruction[Instruction["LOAD_IMM_64"] = 20] = "LOAD_IMM_64";
+    Instruction[Instruction["STORE_IMM_U8"] = 30] = "STORE_IMM_U8";
+    Instruction[Instruction["STORE_IMM_U16"] = 31] = "STORE_IMM_U16";
+    Instruction[Instruction["STORE_IMM_U32"] = 32] = "STORE_IMM_U32";
+    Instruction[Instruction["STORE_IMM_U64"] = 33] = "STORE_IMM_U64";
+    Instruction[Instruction["JUMP"] = 40] = "JUMP";
+    Instruction[Instruction["JUMP_IND"] = 50] = "JUMP_IND";
+    Instruction[Instruction["LOAD_IMM"] = 51] = "LOAD_IMM";
+    Instruction[Instruction["LOAD_U8"] = 52] = "LOAD_U8";
+    Instruction[Instruction["LOAD_I8"] = 53] = "LOAD_I8";
+    Instruction[Instruction["LOAD_U16"] = 54] = "LOAD_U16";
+    Instruction[Instruction["LOAD_I16"] = 55] = "LOAD_I16";
+    Instruction[Instruction["LOAD_U32"] = 56] = "LOAD_U32";
+    Instruction[Instruction["LOAD_I32"] = 57] = "LOAD_I32";
+    Instruction[Instruction["LOAD_U64"] = 58] = "LOAD_U64";
+    Instruction[Instruction["STORE_U8"] = 59] = "STORE_U8";
+    Instruction[Instruction["STORE_U16"] = 60] = "STORE_U16";
+    Instruction[Instruction["STORE_U32"] = 61] = "STORE_U32";
+    Instruction[Instruction["STORE_U64"] = 62] = "STORE_U64";
+    Instruction[Instruction["STORE_IMM_IND_U8"] = 70] = "STORE_IMM_IND_U8";
+    Instruction[Instruction["STORE_IMM_IND_U16"] = 71] = "STORE_IMM_IND_U16";
+    Instruction[Instruction["STORE_IMM_IND_U32"] = 72] = "STORE_IMM_IND_U32";
+    Instruction[Instruction["STORE_IMM_IND_U64"] = 73] = "STORE_IMM_IND_U64";
+    Instruction[Instruction["LOAD_IMM_JUMP"] = 80] = "LOAD_IMM_JUMP";
+    Instruction[Instruction["BRANCH_EQ_IMM"] = 81] = "BRANCH_EQ_IMM";
+    Instruction[Instruction["BRANCH_NE_IMM"] = 82] = "BRANCH_NE_IMM";
+    Instruction[Instruction["BRANCH_LT_U_IMM"] = 83] = "BRANCH_LT_U_IMM";
+    Instruction[Instruction["BRANCH_LE_U_IMM"] = 84] = "BRANCH_LE_U_IMM";
+    Instruction[Instruction["BRANCH_GE_U_IMM"] = 85] = "BRANCH_GE_U_IMM";
+    Instruction[Instruction["BRANCH_GT_U_IMM"] = 86] = "BRANCH_GT_U_IMM";
+    Instruction[Instruction["BRANCH_LT_S_IMM"] = 87] = "BRANCH_LT_S_IMM";
+    Instruction[Instruction["BRANCH_LE_S_IMM"] = 88] = "BRANCH_LE_S_IMM";
+    Instruction[Instruction["BRANCH_GE_S_IMM"] = 89] = "BRANCH_GE_S_IMM";
+    Instruction[Instruction["BRANCH_GT_S_IMM"] = 90] = "BRANCH_GT_S_IMM";
+    Instruction[Instruction["MOVE_REG"] = 100] = "MOVE_REG";
+    Instruction[Instruction["SBRK"] = 101] = "SBRK";
+    Instruction[Instruction["COUNT_SET_BITS_64"] = 102] = "COUNT_SET_BITS_64";
+    Instruction[Instruction["COUNT_SET_BITS_32"] = 103] = "COUNT_SET_BITS_32";
+    Instruction[Instruction["LEADING_ZERO_BITS_64"] = 104] = "LEADING_ZERO_BITS_64";
+    Instruction[Instruction["LEADING_ZERO_BITS_32"] = 105] = "LEADING_ZERO_BITS_32";
+    Instruction[Instruction["TRAILING_ZERO_BITS_64"] = 106] = "TRAILING_ZERO_BITS_64";
+    Instruction[Instruction["TRAILING_ZERO_BITS_32"] = 107] = "TRAILING_ZERO_BITS_32";
+    Instruction[Instruction["SIGN_EXTEND_8"] = 108] = "SIGN_EXTEND_8";
+    Instruction[Instruction["SIGN_EXTEND_16"] = 109] = "SIGN_EXTEND_16";
+    Instruction[Instruction["ZERO_EXTEND_16"] = 110] = "ZERO_EXTEND_16";
+    Instruction[Instruction["REVERSE_BYTES"] = 111] = "REVERSE_BYTES";
+    Instruction[Instruction["STORE_IND_U8"] = 120] = "STORE_IND_U8";
+    Instruction[Instruction["STORE_IND_U16"] = 121] = "STORE_IND_U16";
+    Instruction[Instruction["STORE_IND_U32"] = 122] = "STORE_IND_U32";
+    Instruction[Instruction["STORE_IND_U64"] = 123] = "STORE_IND_U64";
+    Instruction[Instruction["LOAD_IND_U8"] = 124] = "LOAD_IND_U8";
+    Instruction[Instruction["LOAD_IND_I8"] = 125] = "LOAD_IND_I8";
+    Instruction[Instruction["LOAD_IND_U16"] = 126] = "LOAD_IND_U16";
+    Instruction[Instruction["LOAD_IND_I16"] = 127] = "LOAD_IND_I16";
+    Instruction[Instruction["LOAD_IND_U32"] = 128] = "LOAD_IND_U32";
+    Instruction[Instruction["LOAD_IND_I32"] = 129] = "LOAD_IND_I32";
+    Instruction[Instruction["LOAD_IND_U64"] = 130] = "LOAD_IND_U64";
+    Instruction[Instruction["ADD_IMM_32"] = 131] = "ADD_IMM_32";
+    Instruction[Instruction["AND_IMM"] = 132] = "AND_IMM";
+    Instruction[Instruction["XOR_IMM"] = 133] = "XOR_IMM";
+    Instruction[Instruction["OR_IMM"] = 134] = "OR_IMM";
+    Instruction[Instruction["MUL_IMM_32"] = 135] = "MUL_IMM_32";
+    Instruction[Instruction["SET_LT_U_IMM"] = 136] = "SET_LT_U_IMM";
+    Instruction[Instruction["SET_LT_S_IMM"] = 137] = "SET_LT_S_IMM";
+    Instruction[Instruction["SHLO_L_IMM_32"] = 138] = "SHLO_L_IMM_32";
+    Instruction[Instruction["SHLO_R_IMM_32"] = 139] = "SHLO_R_IMM_32";
+    Instruction[Instruction["SHAR_R_IMM_32"] = 140] = "SHAR_R_IMM_32";
+    Instruction[Instruction["NEG_ADD_IMM_32"] = 141] = "NEG_ADD_IMM_32";
+    Instruction[Instruction["SET_GT_U_IMM"] = 142] = "SET_GT_U_IMM";
+    Instruction[Instruction["SET_GT_S_IMM"] = 143] = "SET_GT_S_IMM";
+    Instruction[Instruction["SHLO_L_IMM_ALT_32"] = 144] = "SHLO_L_IMM_ALT_32";
+    Instruction[Instruction["SHLO_R_IMM_ALT_32"] = 145] = "SHLO_R_IMM_ALT_32";
+    Instruction[Instruction["SHAR_R_IMM_ALT_32"] = 146] = "SHAR_R_IMM_ALT_32";
+    Instruction[Instruction["CMOV_IZ_IMM"] = 147] = "CMOV_IZ_IMM";
+    Instruction[Instruction["CMOV_NZ_IMM"] = 148] = "CMOV_NZ_IMM";
+    Instruction[Instruction["ADD_IMM_64"] = 149] = "ADD_IMM_64";
+    Instruction[Instruction["MUL_IMM_64"] = 150] = "MUL_IMM_64";
+    Instruction[Instruction["SHLO_L_IMM_64"] = 151] = "SHLO_L_IMM_64";
+    Instruction[Instruction["SHLO_R_IMM_64"] = 152] = "SHLO_R_IMM_64";
+    Instruction[Instruction["SHAR_R_IMM_64"] = 153] = "SHAR_R_IMM_64";
+    Instruction[Instruction["NEG_ADD_IMM_64"] = 154] = "NEG_ADD_IMM_64";
+    Instruction[Instruction["SHLO_L_IMM_ALT_64"] = 155] = "SHLO_L_IMM_ALT_64";
+    Instruction[Instruction["SHLO_R_IMM_ALT_64"] = 156] = "SHLO_R_IMM_ALT_64";
+    Instruction[Instruction["SHAR_R_IMM_ALT_64"] = 157] = "SHAR_R_IMM_ALT_64";
+    Instruction[Instruction["ROT_R_64_IMM"] = 158] = "ROT_R_64_IMM";
+    Instruction[Instruction["ROT_R_64_IMM_ALT"] = 159] = "ROT_R_64_IMM_ALT";
+    Instruction[Instruction["ROT_R_32_IMM"] = 160] = "ROT_R_32_IMM";
+    Instruction[Instruction["ROT_R_32_IMM_ALT"] = 161] = "ROT_R_32_IMM_ALT";
+    Instruction[Instruction["BRANCH_EQ"] = 170] = "BRANCH_EQ";
+    Instruction[Instruction["BRANCH_NE"] = 171] = "BRANCH_NE";
+    Instruction[Instruction["BRANCH_LT_U"] = 172] = "BRANCH_LT_U";
+    Instruction[Instruction["BRANCH_LT_S"] = 173] = "BRANCH_LT_S";
+    Instruction[Instruction["BRANCH_GE_U"] = 174] = "BRANCH_GE_U";
+    Instruction[Instruction["BRANCH_GE_S"] = 175] = "BRANCH_GE_S";
+    Instruction[Instruction["LOAD_IMM_JUMP_IND"] = 180] = "LOAD_IMM_JUMP_IND";
+    Instruction[Instruction["ADD_32"] = 190] = "ADD_32";
+    Instruction[Instruction["SUB_32"] = 191] = "SUB_32";
+    Instruction[Instruction["MUL_32"] = 192] = "MUL_32";
+    Instruction[Instruction["DIV_U_32"] = 193] = "DIV_U_32";
+    Instruction[Instruction["DIV_S_32"] = 194] = "DIV_S_32";
+    Instruction[Instruction["REM_U_32"] = 195] = "REM_U_32";
+    Instruction[Instruction["REM_S_32"] = 196] = "REM_S_32";
+    Instruction[Instruction["SHLO_L_32"] = 197] = "SHLO_L_32";
+    Instruction[Instruction["SHLO_R_32"] = 198] = "SHLO_R_32";
+    Instruction[Instruction["SHAR_R_32"] = 199] = "SHAR_R_32";
+    Instruction[Instruction["ADD_64"] = 200] = "ADD_64";
+    Instruction[Instruction["SUB_64"] = 201] = "SUB_64";
+    Instruction[Instruction["MUL_64"] = 202] = "MUL_64";
+    Instruction[Instruction["DIV_U_64"] = 203] = "DIV_U_64";
+    Instruction[Instruction["DIV_S_64"] = 204] = "DIV_S_64";
+    Instruction[Instruction["REM_U_64"] = 205] = "REM_U_64";
+    Instruction[Instruction["REM_S_64"] = 206] = "REM_S_64";
+    Instruction[Instruction["SHLO_L_64"] = 207] = "SHLO_L_64";
+    Instruction[Instruction["SHLO_R_64"] = 208] = "SHLO_R_64";
+    Instruction[Instruction["SHAR_R_64"] = 209] = "SHAR_R_64";
+    Instruction[Instruction["AND"] = 210] = "AND";
+    Instruction[Instruction["XOR"] = 211] = "XOR";
+    Instruction[Instruction["OR"] = 212] = "OR";
+    Instruction[Instruction["MUL_UPPER_S_S"] = 213] = "MUL_UPPER_S_S";
+    Instruction[Instruction["MUL_UPPER_U_U"] = 214] = "MUL_UPPER_U_U";
+    Instruction[Instruction["MUL_UPPER_S_U"] = 215] = "MUL_UPPER_S_U";
+    Instruction[Instruction["SET_LT_U"] = 216] = "SET_LT_U";
+    Instruction[Instruction["SET_LT_S"] = 217] = "SET_LT_S";
+    Instruction[Instruction["CMOV_IZ"] = 218] = "CMOV_IZ";
+    Instruction[Instruction["CMOV_NZ"] = 219] = "CMOV_NZ";
+    Instruction[Instruction["ROT_L_64"] = 220] = "ROT_L_64";
+    Instruction[Instruction["ROT_L_32"] = 221] = "ROT_L_32";
+    Instruction[Instruction["ROT_R_64"] = 222] = "ROT_R_64";
+    Instruction[Instruction["ROT_R_32"] = 223] = "ROT_R_32";
+    Instruction[Instruction["AND_INV"] = 224] = "AND_INV";
+    Instruction[Instruction["OR_INV"] = 225] = "OR_INV";
+    Instruction[Instruction["XNOR"] = 226] = "XNOR";
+    Instruction[Instruction["MAX"] = 227] = "MAX";
+    Instruction[Instruction["MAX_U"] = 228] = "MAX_U";
+    Instruction[Instruction["MIN"] = 229] = "MIN";
+    Instruction[Instruction["MIN_U"] = 230] = "MIN_U";
+})(Instruction || (Instruction = {}));
+export const HIGHEST_INSTRUCTION_NUMBER = Instruction.MIN_U;

package/packages/core/pvm-interpreter/interpreter.d.ts

@@ -0,0 +1,49 @@
+import { type U32 } from "#@typeberry/numbers";
+import { type Gas, type IPvmInterpreter, Status } from "#@typeberry/pvm-interface";
+import { Memory } from "./memory/index.js";
+import { Registers } from "./registers.js";
+type InterpreterOptions = {
+    useSbrkGas?: boolean;
+};
+export declare class Interpreter implements IPvmInterpreter {
+    private readonly useSbrkGas;
+    readonly registers: Registers;
+    readonly memory: Memory;
+    gas: import("@typeberry/pvm-interface").IGasCounter;
+    private code;
+    private mask;
+    private pc;
+    private argsDecoder;
+    private threeRegsDispatcher;
+    private twoRegsOneImmDispatcher;
+    private twoRegsDispatcher;
+    private oneRegOneImmOneOffsetDispatcher;
+    private twoRegsOneOffsetDispatcher;
+    private oneOffsetDispatcher;
+    private oneRegOneImmDispatcher;
+    private instructionResult;
+    private twoImmsDispatcher;
+    private oneRegTwoImmsDispatcher;
+    private noArgsDispatcher;
+    private twoRegsTwoImmsDispatcher;
+    private oneImmDispatcher;
+    private oneRegOneExtImmDispatcher;
+    private status;
+    private argsDecodingResults;
+    private basicBlocks;
+    private jumpTable;
+    constructor({ useSbrkGas }?: InterpreterOptions);
+    resetJam(program: Uint8Array, args: Uint8Array, pc: number, gas: Gas, hasMetadata?: boolean): void;
+    resetGeneric(rawProgram: Uint8Array, pc: number, gas: Gas, maybeRegisters?: Registers, maybeMemory?: Memory): void;
+    dumpProgram(): (string | number)[][];
+    runProgram(): void;
+    nextStep(): Status;
+    getPC(): number;
+    setNextPC(nextPc: number): void;
+    getStatus(): Status;
+    getExitParam(): null | U32;
+    getMemoryPage(pageNumber: number): null | Uint8Array;
+    calculateBlockGasCost(): Map<string, number>;
+}
+export {};
+//# sourceMappingURL=interpreter.d.ts.map

package/packages/core/pvm-interpreter/interpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpreter.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-interpreter/interpreter.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,eAAe,EAAE,MAAM,EAAY,MAAM,0BAA0B,CAAC;AAW5F,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAsC3C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,KAAK,kBAAkB,GAAG;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAIF,qBAAa,WAAY,YAAW,eAAe;IACjD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;IACrC,QAAQ,CAAC,SAAS,YAAmB;IACrC,QAAQ,CAAC,MAAM,SAAgB;IAC/B,GAAG,iDAA2B;IAC9B,OAAO,CAAC,IAAI,CAAgC;IAC5C,OAAO,CAAC,IAAI,CAAgB;IAC5B,OAAO,CAAC,EAAE,CAAK;IACf,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,mBAAmB,CAAsB;IACjD,OAAO,CAAC,uBAAuB,CAA0B;IACzD,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,+BAA+B,CAAkC;IACzE,OAAO,CAAC,0BAA0B,CAA6B;IAC/D,OAAO,CAAC,mBAAmB,CAAsB;IACjD,OAAO,CAAC,sBAAsB,CAAyB;IACvD,OAAO,CAAC,iBAAiB,CAA2B;IACpD,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,uBAAuB,CAA0B;IACzD,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,wBAAwB,CAA2B;IAC3D,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,yBAAyB,CAA4B;IAC7D,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,SAAS,CAAqB;gBAE1B,EAAE,UAAkB,EAAE,GAAE,kBAAuB;IA0C3D,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,WAAW,UAAO;IAKxF,YAAY,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,cAAc,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,MAAM;IA0B3G,WAAW;IAIX,UAAU;IAIV,QAAQ;IAgHR,KAAK;IAIL,SAAS,CAAC,MAAM,EAAE,MAAM;IAIxB,SAAS;IAIT,YAAY,IAAI,IAAI,GAAG,GAAG;IAK1B,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,UAAU;IAIpD,qBAAqB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;CAsB7C"}

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

@@ -0,0 +1,256 @@
+import { Logger } from "#@typeberry/logger";
+import { tryAsU32 } from "#@typeberry/numbers";
+import { Status, tryAsGas } from "#@typeberry/pvm-interface";
+import { ArgsDecoder } from "./args-decoder/args-decoder.js";
+import { createResults } from "./args-decoder/args-decoding-results.js";
+import { ArgumentType } from "./args-decoder/argument-type.js";
+import { instructionArgumentTypeMap } from "./args-decoder/instruction-argument-type-map.js";
+import { assemblify } from "./assemblify.js";
+import { BasicBlocks } from "./basic-blocks/index.js";
+import { gasCounter } from "./gas.js";
+import { Instruction } from "./instruction.js";
+import { instructionGasMap } from "./instruction-gas-map.js";
+import { InstructionResult } from "./instruction-result.js";
+import { Memory } from "./memory/index.js";
+import { PAGE_SIZE } from "./memory/memory-consts.js";
+import { alignToPageSize } from "./memory/memory-utils.js";
+import { tryAsPageNumber } from "./memory/pages/page-utils.js";
+import { BitOps, BitRotationOps, BooleanOps, BranchOps, DynamicJumpOps, HostCallOps, LoadOps, MathOps, MemoryOps, MoveOps, NoArgsOps, ShiftOps, StoreOps, } from "./ops/index.js";
+import { NoArgsDispatcher, OneImmDispatcher, OneOffsetDispatcher, OneRegOneExtImmDispatcher, OneRegOneImmDispatcher, OneRegOneImmOneOffsetDispatcher, OneRegTwoImmsDispatcher, ThreeRegsDispatcher, TwoImmsDispatcher, TwoRegsDispatcher, TwoRegsOneImmDispatcher, TwoRegsOneOffsetDispatcher, TwoRegsTwoImmsDispatcher, } from "./ops-dispatchers/index.js";
+import { Program } from "./program.js";
+import { JumpTable } from "./program-decoder/jump-table.js";
+import { Mask } from "./program-decoder/mask.js";
+import { ProgramDecoder } from "./program-decoder/program-decoder.js";
+import { Registers } from "./registers.js";
+import { Result } from "./result.js";
+const logger = Logger.new(import.meta.filename, "pvm");
+export class Interpreter {
+    useSbrkGas;
+    registers = new Registers();
+    memory = new Memory();
+    gas = gasCounter(tryAsGas(0));
+    code = new Uint8Array();
+    mask = Mask.empty();
+    pc = 0;
+    argsDecoder;
+    threeRegsDispatcher;
+    twoRegsOneImmDispatcher;
+    twoRegsDispatcher;
+    oneRegOneImmOneOffsetDispatcher;
+    twoRegsOneOffsetDispatcher;
+    oneOffsetDispatcher;
+    oneRegOneImmDispatcher;
+    instructionResult = new InstructionResult();
+    twoImmsDispatcher;
+    oneRegTwoImmsDispatcher;
+    noArgsDispatcher;
+    twoRegsTwoImmsDispatcher;
+    oneImmDispatcher;
+    oneRegOneExtImmDispatcher;
+    status = Status.OK;
+    argsDecodingResults = createResults();
+    basicBlocks;
+    jumpTable = JumpTable.empty();
+    constructor({ useSbrkGas = false } = {}) {
+        this.useSbrkGas = useSbrkGas;
+        this.argsDecoder = new ArgsDecoder();
+        this.basicBlocks = new BasicBlocks();
+        const mathOps = new MathOps(this.registers);
+        const shiftOps = new ShiftOps(this.registers);
+        const bitOps = new BitOps(this.registers);
+        const booleanOps = new BooleanOps(this.registers);
+        const moveOps = new MoveOps(this.registers);
+        const branchOps = new BranchOps(this.registers, this.instructionResult, this.basicBlocks);
+        const loadOps = new LoadOps(this.registers, this.memory, this.instructionResult);
+        const storeOps = new StoreOps(this.registers, this.memory, this.instructionResult);
+        const noArgsOps = new NoArgsOps(this.instructionResult);
+        const dynamicJumpOps = new DynamicJumpOps(this.registers, this.jumpTable, this.instructionResult, this.basicBlocks);
+        const hostCallOps = new HostCallOps(this.instructionResult);
+        const memoryOps = new MemoryOps(this.registers, this.memory, this.instructionResult);
+        const bitRotationOps = new BitRotationOps(this.registers);
+        this.threeRegsDispatcher = new ThreeRegsDispatcher(mathOps, shiftOps, bitOps, booleanOps, moveOps, bitRotationOps);
+        this.twoRegsOneImmDispatcher = new TwoRegsOneImmDispatcher(mathOps, shiftOps, bitOps, booleanOps, moveOps, storeOps, loadOps, bitRotationOps);
+        this.twoRegsDispatcher = new TwoRegsDispatcher(moveOps, memoryOps, bitOps, bitRotationOps);
+        this.oneRegOneImmOneOffsetDispatcher = new OneRegOneImmOneOffsetDispatcher(branchOps, loadOps);
+        this.twoRegsOneOffsetDispatcher = new TwoRegsOneOffsetDispatcher(branchOps);
+        this.oneOffsetDispatcher = new OneOffsetDispatcher(branchOps);
+        this.oneRegOneImmDispatcher = new OneRegOneImmDispatcher(loadOps, storeOps, dynamicJumpOps);
+        this.twoImmsDispatcher = new TwoImmsDispatcher(storeOps);
+        this.oneRegTwoImmsDispatcher = new OneRegTwoImmsDispatcher(storeOps);
+        this.noArgsDispatcher = new NoArgsDispatcher(noArgsOps);
+        this.twoRegsTwoImmsDispatcher = new TwoRegsTwoImmsDispatcher(loadOps, dynamicJumpOps);
+        this.oneImmDispatcher = new OneImmDispatcher(hostCallOps);
+        this.oneRegOneExtImmDispatcher = new OneRegOneExtImmDispatcher(loadOps);
+    }
+    resetJam(program, args, pc, gas, hasMetadata = true) {
+        const p = Program.fromSpi(program, args, hasMetadata);
+        this.resetGeneric(p.code, pc, gas, p.registers, p.memory);
+    }
+    resetGeneric(rawProgram, pc, gas, maybeRegisters, maybeMemory) {
+        const programDecoder = new ProgramDecoder(rawProgram);
+        this.code = programDecoder.getCode();
+        this.mask = programDecoder.getMask();
+        this.jumpTable.copyFrom(programDecoder.getJumpTable());
+        this.pc = pc;
+        this.gas = gasCounter(gas);
+        this.status = Status.OK;
+        this.argsDecoder.reset(this.code, this.mask);
+        this.basicBlocks.reset(this.code, this.mask);
+        this.instructionResult.reset();
+        if (maybeRegisters !== undefined) {
+            this.registers.copyFrom(maybeRegisters);
+        }
+        else {
+            this.registers.reset();
+        }
+        if (maybeMemory !== undefined) {
+            this.memory.copyFrom(maybeMemory);
+        }
+        else {
+            this.memory.reset();
+        }
+    }
+    dumpProgram() {
+        return assemblify(this.code, this.mask);
+    }
+    runProgram() {
+        while (this.nextStep() === Status.OK) { }
+    }
+    nextStep() {
+        // we are being resumed from a host call, assume all good.
+        if (this.status === Status.HOST) {
+            this.status = Status.OK;
+            this.pc = this.instructionResult.nextPc;
+            this.instructionResult.reset();
+        }
+        /**
+         * We have two options to handle an invalid instruction:
+         * - change status to panic and quit program immediately,
+         * - treat the invalid instruction as a regular trap.
+         * The difference is that in the second case we don't need any additional condition and gas will be subtracted automagically so this option is implemented
+         * Reference: https://graypaper.fluffylabs.dev/#/579bd12/251100251200
+         */
+        const currentInstruction = this.code[this.pc] ?? Instruction.TRAP;
+        const isValidInstruction = Instruction[currentInstruction] !== undefined;
+        const gasCost = instructionGasMap[currentInstruction] ?? instructionGasMap[Instruction.TRAP];
+        const underflow = this.gas.sub(gasCost);
+        if (underflow) {
+            this.status = Status.OOG;
+            return this.status;
+        }
+        const argsType = instructionArgumentTypeMap[currentInstruction] ?? ArgumentType.NO_ARGUMENTS;
+        const argsResult = this.argsDecodingResults[argsType];
+        this.argsDecoder.fillArgs(this.pc, argsResult);
+        logger.insane `[PC: ${this.pc}] ${Instruction[currentInstruction]}`;
+        if (!isValidInstruction) {
+            this.instructionResult.status = Result.PANIC;
+        }
+        else {
+            this.instructionResult.nextPc = this.pc + argsResult.noOfBytesToSkip;
+            switch (argsResult.type) {
+                case ArgumentType.NO_ARGUMENTS:
+                    this.noArgsDispatcher.dispatch(currentInstruction);
+                    break;
+                case ArgumentType.ONE_IMMEDIATE:
+                    this.oneImmDispatcher.dispatch(currentInstruction, argsResult);
+                    break;
+                case ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET:
+                    this.oneRegOneImmOneOffsetDispatcher.dispatch(currentInstruction, argsResult);
+                    break;
+                case ArgumentType.TWO_REGISTERS:
+                    if (this.useSbrkGas && currentInstruction === Instruction.SBRK) {
+                        const calculateSbrkCost = (length) => (alignToPageSize(length) / PAGE_SIZE) * 16;
+                        const underflow = this.gas.sub(tryAsGas(calculateSbrkCost(this.registers.getLowerU32(argsResult.firstRegisterIndex))));
+                        if (underflow) {
+                            this.status = Status.OOG;
+                            return this.status;
+                        }
+                    }
+                    this.twoRegsDispatcher.dispatch(currentInstruction, argsResult);
+                    break;
+                case ArgumentType.THREE_REGISTERS:
+                    this.threeRegsDispatcher.dispatch(currentInstruction, argsResult);
+                    break;
+                case ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE:
+                    this.twoRegsOneImmDispatcher.dispatch(currentInstruction, argsResult);
+                    break;
+                case ArgumentType.TWO_REGISTERS_ONE_OFFSET:
+                    this.twoRegsOneOffsetDispatcher.dispatch(currentInstruction, argsResult);
+                    break;
+                case ArgumentType.ONE_OFFSET:
+                    this.oneOffsetDispatcher.dispatch(currentInstruction, argsResult);
+                    break;
+                case ArgumentType.ONE_REGISTER_ONE_IMMEDIATE:
+                    this.oneRegOneImmDispatcher.dispatch(currentInstruction, argsResult);
+                    break;
+                case ArgumentType.TWO_IMMEDIATES:
+                    this.twoImmsDispatcher.dispatch(currentInstruction, argsResult);
+                    break;
+                case ArgumentType.ONE_REGISTER_TWO_IMMEDIATES:
+                    this.oneRegTwoImmsDispatcher.dispatch(currentInstruction, argsResult);
+                    break;
+                case ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES:
+                    this.twoRegsTwoImmsDispatcher.dispatch(currentInstruction, argsResult);
+                    break;
+                case ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE:
+                    this.oneRegOneExtImmDispatcher.dispatch(currentInstruction, argsResult);
+                    break;
+            }
+        }
+        if (this.instructionResult.status !== null) {
+            switch (this.instructionResult.status) {
+                case Result.FAULT:
+                    this.status = Status.FAULT;
+                    break;
+                case Result.HALT:
+                    this.status = Status.HALT;
+                    break;
+                case Result.PANIC:
+                case Result.FAULT_ACCESS:
+                    this.status = Status.PANIC;
+                    break;
+                case Result.HOST:
+                    this.status = Status.HOST;
+                    break;
+            }
+            logger.insane `[PC: ${this.pc}] Status: ${Result[this.instructionResult.status]}`;
+            return this.status;
+        }
+        this.pc = this.instructionResult.nextPc;
+        return this.status;
+    }
+    getPC() {
+        return this.pc;
+    }
+    setNextPC(nextPc) {
+        this.pc = nextPc;
+    }
+    getStatus() {
+        return this.status;
+    }
+    getExitParam() {
+        const p = this.instructionResult.exitParam;
+        return p !== null ? tryAsU32(p) : p;
+    }
+    getMemoryPage(pageNumber) {
+        return this.memory.getPageDump(tryAsPageNumber(pageNumber));
+    }
+    calculateBlockGasCost() {
+        const codeLength = this.code.length;
+        const blocks = new Map();
+        let currentBlock = "0";
+        let gasCost = 0;
+        const getNextIstructionIndex = (index) => index + 1 + this.mask.getNoOfBytesToNextInstruction(index + 1);
+        for (let index = 0; index < codeLength; index = getNextIstructionIndex(index)) {
+            const instruction = this.code[index];
+            if (this.basicBlocks.isBeginningOfBasicBlock(index)) {
+                blocks.set(currentBlock, gasCost);
+                currentBlock = index.toString();
+                gasCost = 0;
+            }
+            gasCost += instructionGasMap[instruction];
+        }
+        blocks.set(currentBlock, gasCost);
+        return blocks;
+    }
+}

package/packages/core/pvm-interpreter/memory/errors.d.ts

@@ -0,0 +1,37 @@
+import { type U32 } from "#@typeberry/numbers";
+import { type PageFault as InterpreterPageFault } from "#@typeberry/pvm-interface";
+export declare class PageFault implements InterpreterPageFault {
+    address: U32;
+    isAccessFault: boolean;
+    private constructor();
+    static fromPageNumber(maybePageNumber: number, isAccessFault?: boolean): PageFault;
+    static fromMemoryIndex(maybeMemoryIndex: number, isAccessFault?: boolean): PageFault;
+}
+export declare class OutOfBounds extends Error {
+    constructor();
+}
+export declare class ChunkOverlap extends Error {
+    constructor();
+}
+export declare class ChunkTooLong extends Error {
+    constructor();
+}
+export declare class IncorrectSbrkIndex extends Error {
+    constructor();
+}
+export declare class FinalizedBuilderModification extends Error {
+    constructor();
+}
+export declare class ReservedMemoryFault extends Error {
+    constructor();
+}
+export declare class PageNotExist extends Error {
+    constructor();
+}
+export declare class ChunkNotFound extends Error {
+    constructor();
+}
+export declare class OutOfMemory extends Error {
+    constructor();
+}
+//# sourceMappingURL=errors.d.ts.map

package/packages/core/pvm-interpreter/memory/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/memory/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,KAAK,SAAS,IAAI,oBAAoB,EAAe,MAAM,0BAA0B,CAAC;AAK/F,qBAAa,SAAU,YAAW,oBAAoB;IAE3C,OAAO,EAAE,GAAG;IACZ,aAAa;IAFtB,OAAO;IAKP,MAAM,CAAC,cAAc,CAAC,eAAe,EAAE,MAAM,EAAE,aAAa,UAAQ;IAMpE,MAAM,CAAC,eAAe,CAAC,gBAAgB,EAAE,MAAM,EAAE,aAAa,UAAQ;CAKvE;AAED,qBAAa,WAAY,SAAQ,KAAK;;CAIrC;AAED,qBAAa,YAAa,SAAQ,KAAK;;CAItC;AAED,qBAAa,YAAa,SAAQ,KAAK;;CAItC;AAED,qBAAa,kBAAmB,SAAQ,KAAK;;CAI5C;AAED,qBAAa,4BAA6B,SAAQ,KAAK;;CAItD;AAED,qBAAa,mBAAoB,SAAQ,KAAK;;CAI7C;AAED,qBAAa,YAAa,SAAQ,KAAK;;CAItC;AAED,qBAAa,aAAc,SAAQ,KAAK;;CAIvC;AACD,qBAAa,WAAY,SAAQ,KAAK;;CAIrC"}

package/packages/core/pvm-interpreter/memory/errors.js

@@ -0,0 +1,68 @@
+import { tryAsU32 } from "#@typeberry/numbers";
+import { MEMORY_SIZE } from "#@typeberry/pvm-interface";
+import { tryAsMemoryIndex } from "./memory-index.js";
+import { getStartPageIndex, getStartPageIndexFromPageNumber } from "./memory-utils.js";
+import { tryAsPageNumber } from "./pages/page-utils.js";
+export class PageFault {
+    address;
+    isAccessFault;
+    constructor(address, isAccessFault = true) {
+        this.address = address;
+        this.isAccessFault = isAccessFault;
+    }
+    static fromPageNumber(maybePageNumber, isAccessFault = false) {
+        const pageNumber = tryAsPageNumber(maybePageNumber);
+        const startPageIndex = getStartPageIndexFromPageNumber(pageNumber);
+        return new PageFault(tryAsU32(startPageIndex), isAccessFault);
+    }
+    static fromMemoryIndex(maybeMemoryIndex, isAccessFault = false) {
+        const memoryIndex = tryAsMemoryIndex(maybeMemoryIndex % MEMORY_SIZE);
+        const startPageIndex = getStartPageIndex(memoryIndex);
+        return new PageFault(tryAsU32(startPageIndex), isAccessFault);
+    }
+}
+export class OutOfBounds extends Error {
+    constructor() {
+        super("Out of bounds");
+    }
+}
+export class ChunkOverlap extends Error {
+    constructor() {
+        super("Memory chunks cannot overlap each other!");
+    }
+}
+export class ChunkTooLong extends Error {
+    constructor() {
+        super("Memory chunk is longer than the address range!");
+    }
+}
+export class IncorrectSbrkIndex extends Error {
+    constructor() {
+        super("Space between sbrk index and max heap index should be empty!");
+    }
+}
+export class FinalizedBuilderModification extends Error {
+    constructor() {
+        super("MemoryBuilder was finalized and cannot be changed!");
+    }
+}
+export class ReservedMemoryFault extends Error {
+    constructor() {
+        super("You are trying to access reserved memory!");
+    }
+}
+export class PageNotExist extends Error {
+    constructor() {
+        super("You try to fill data on memory page that does not exist!");
+    }
+}
+export class ChunkNotFound extends Error {
+    constructor() {
+        super("Chunk does not exist or is too short");
+    }
+}
+export class OutOfMemory extends Error {
+    constructor() {
+        super("Out of memory");
+    }
+}

package/packages/core/pvm-interpreter/memory/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./memory.js";
+export * from "./memory-builder.js";
+export * from "./memory-index.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/core/pvm-interpreter/memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/memory/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}

package/packages/core/pvm-interpreter/memory/index.js

@@ -0,0 +1,3 @@
+export * from "./memory.js";
+export * from "./memory-builder.js";
+export * from "./memory-index.js";

package/packages/core/pvm-interpreter/memory/memory-builder.d.ts

@@ -0,0 +1,35 @@
+import { Memory } from "./memory.js";
+import { type MemoryIndex, type SbrkIndex } from "./memory-index.js";
+export declare class MemoryBuilder {
+    private readonly initialMemory;
+    private isFinalized;
+    private ensureNotFinalized;
+    private ensureNoReservedMemoryUsage;
+    /**
+     * Create entire readable pages to handle the `[start, end)` range.
+     *
+     * Note that both `start` and `end` must be multiple of the `PAGE_SIZE`, i.e.
+     * they need to be the start indices of the pages.
+     *
+     * The data passed will be placed at `start`, but might be shorter than the requested range,
+     * prepend it with zeros if you don't wish to have it at the beginning of the page.
+     */
+    setReadablePages(start: MemoryIndex, end: MemoryIndex, data?: Uint8Array): this;
+    /**
+     * Create entire writeable pages to handle the `[start, end)` range.
+     *
+     * Note that both `start` and `end` must be multiple of the `PAGE_SIZE`, i.e.
+     * they need to be the start indices of the pages.
+     *
+     * The data passed will be placed at `start`, but might be shorter than the requested range,
+     * prepend it with zeros if you don't wish to have it at the beginning of the page.
+     */
+    setWriteablePages(start: MemoryIndex, end: MemoryIndex, data?: Uint8Array): this;
+    /**
+     * This function can be useful when page map and initial memory data are provided separatelly.
+     * You can use setWriteablePages/setReadablePages to create empty pages and then setData to fill them
+     */
+    setData(start: MemoryIndex, data: Uint8Array): this;
+    finalize(startHeapIndex: MemoryIndex, endHeapIndex: SbrkIndex): Memory;
+}
+//# sourceMappingURL=memory-builder.d.ts.map

package/packages/core/pvm-interpreter/memory/memory-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-builder.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/memory/memory-builder.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,SAAS,EAAkB,MAAM,mBAAmB,CAAC;AAQrF,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0C;IACxE,OAAO,CAAC,WAAW,CAAS;IAE5B,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,2BAA2B;IAMnC;;;;;;;;OAQG;IACH,gBAAgB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,GAAE,UAA6B;IAyB1F;;;;;;;;OAQG;IACH,iBAAiB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,GAAE,UAA6B;IAyB3F;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,UAAU;IAwB5C,QAAQ,CAAC,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,GAAG,MAAM;CA0BvE"}