@typeberry/lib 0.5.10 → 0.5.11-1fbacf3

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

@@ -5,7 +5,11 @@ export declare class HostCallRegisters {
     private readonly raw;
     private readonly registers;
     ioTracker: IoTracker | null;
-    constructor(bytes: Uint8Array);
+    /** Creates empty registers object. */
+    static empty(noOfRegisters?: number): HostCallRegisters;
+    /** Creates new `HostCallRegisters` by wrapping an already allocated byte array. */
+    static fromRaw(bytes: Uint8Array): HostCallRegisters;
+    private constructor();
     /** Get U64 register value. */
     get(registerIndex: number): U64;
     /** Set U64 register value. */

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,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"}
+{"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;IAkBR,OAAO,CAAC,QAAQ,CAAC,KAAK;IAjB1C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAa;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IAE9B,SAAS,EAAE,SAAS,GAAG,IAAI,CAAQ;IAE1C,sCAAsC;IACtC,MAAM,CAAC,KAAK,CAAC,aAAa,SAAkB;IAI5C,mFAAmF;IACnF,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,UAAU;IAMhC,OAAO;IAKP,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,5 +1,5 @@
 import { tryAsU64 } from "#@typeberry/numbers";
-import { REGISTER_BYTE_SIZE } from "#@typeberry/pvm-interface";
+import { NO_OF_REGISTERS, REGISTER_BYTE_SIZE } from "#@typeberry/pvm-interface";
 import { check } from "#@typeberry/utils";
 export class HostCallRegisters {
     bytes;
@@ -7,6 +7,16 @@ export class HostCallRegisters {
     registers;
     // Track register modifications.
     ioTracker = null;
+    /** Creates empty registers object. */
+    static empty(noOfRegisters = NO_OF_REGISTERS) {
+        return HostCallRegisters.fromRaw(new Uint8Array(noOfRegisters * REGISTER_BYTE_SIZE));
+    }
+    /** Creates new `HostCallRegisters` by wrapping an already allocated byte array. */
+    static fromRaw(bytes) {
+        check `${bytes.length % REGISTER_BYTE_SIZE === 0} registers array must be a multiply of ${REGISTER_BYTE_SIZE},
+    got: ${bytes.length}`;
+        return new HostCallRegisters(bytes);
+    }
     constructor(bytes) {
         this.bytes = bytes;
         this.raw = bytes;

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

@@ -7,14 +7,14 @@ describe("HostCallRegisters", () => {
         it("reads a u64 value from the underlying registers", () => {
             const regs = new BigUint64Array(13);
             regs[0] = 0xfffffffffffffffdn;
-            const hostCallRegisters = new HostCallRegisters(new Uint8Array(regs.buffer));
+            const hostCallRegisters = HostCallRegisters.fromRaw(new Uint8Array(regs.buffer));
             assert.strictEqual(hostCallRegisters.get(0), tryAsU64(0xfffffffffffffffdn));
         });
     });
     describe("setAllEncoded", () => {
         it("writes a u64 value to the underlying registers", () => {
             const regs = new BigUint64Array(13);
-            const hostCallRegisters = new HostCallRegisters(new Uint8Array(regs.buffer));
+            const hostCallRegisters = HostCallRegisters.fromRaw(new Uint8Array(regs.buffer));
             hostCallRegisters.set(0, tryAsU64(0xfffffffffffffffdn));
             const view = new DataView(hostCallRegisters.getEncoded().buffer);
             assert.strictEqual(view.getBigUint64(0, true), tryAsU64(0xfffffffffffffffdn));

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

@@ -29,7 +29,8 @@ export declare class HostCallsExecutor {
     private pvmInstanceManager;
     private hostCalls;
     private ioTracer;
-    constructor(pvmInstanceManager: PvmInstanceManager, hostCalls: HostCalls, ioTracer?: EcalliTraceLogger | null);
+    static new(pvmInstanceManager: PvmInstanceManager, hostCalls: HostCalls, ioTracer?: EcalliTraceLogger | null): HostCallsExecutor;
+    private constructor();
     private getReturnValue;
     private execute;
     runProgram(program: Uint8Array, args: Uint8Array, initialPc: number, initialGas: Gas): Promise<ReturnValue>;

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

@@ -1 +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,EAAgC,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;;;;;;GAMG;AACH,oBAAY,YAAY;IACtB,2BAA2B;IAC3B,EAAE,IAAI;IACN,iCAAiC;IACjC,GAAG,IAAI;IACP,qCAAqC;IACrC,KAAK,IAAI;CACV;AAED,MAAM,MAAM,WAAW,CAAC,IAAI,GAAG,GAAG,IAAI;IACpC,WAAW,EAAE,IAAI,CAAC;CACnB,GAAG,CACA;IACE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC;IACxB,WAAW,EAAE,UAAU,CAAC;CACzB,GACD;IACE,MAAM,EAAE,YAAY,CAAC,GAAG,GAAG,YAAY,CAAC,KAAK,CAAC;CAC/C,CACJ,CAAC;AAEF,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;YAqCR,OAAO;IAkFf,UAAU,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,GAAG,OAAO,CAAC,WAAW,CAAC;CAWlH"}
+{"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,EAAgC,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;;;;;;GAMG;AACH,oBAAY,YAAY;IACtB,2BAA2B;IAC3B,EAAE,IAAI;IACN,iCAAiC;IACjC,GAAG,IAAI;IACP,qCAAqC;IACrC,KAAK,IAAI;CACV;AAED,MAAM,MAAM,WAAW,CAAC,IAAI,GAAG,GAAG,IAAI;IACpC,WAAW,EAAE,IAAI,CAAC;CACnB,GAAG,CACA;IACE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC;IACxB,WAAW,EAAE,UAAU,CAAC;CACzB,GACD;IACE,MAAM,EAAE,YAAY,CAAC,GAAG,GAAG,YAAY,CAAC,KAAK,CAAC;CAC/C,CACJ,CAAC;AAEF,qBAAa,iBAAiB;IAU1B,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,QAAQ;IAXlB,MAAM,CAAC,GAAG,CACR,kBAAkB,EAAE,kBAAkB,EACtC,SAAS,EAAE,SAAS,EACpB,QAAQ,GAAE,iBAAiB,GAAG,IAAiC;IAKjE,OAAO;IAMP,OAAO,CAAC,cAAc;YAqCR,OAAO;IAkFf,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

@@ -24,6 +24,9 @@ export class HostCallsExecutor {
     pvmInstanceManager;
     hostCalls;
     ioTracer;
+    static new(pvmInstanceManager, hostCalls, ioTracer = EcalliTraceLogger.create()) {
+        return new HostCallsExecutor(pvmInstanceManager, hostCalls, ioTracer);
+    }
     constructor(pvmInstanceManager, hostCalls, ioTracer = EcalliTraceLogger.create()) {
         this.pvmInstanceManager = pvmInstanceManager;
         this.hostCalls = hostCalls;
@@ -54,9 +57,9 @@ export class HostCallsExecutor {
     }
     async execute(pvmInstance, initialPc) {
         const ioTracker = this.ioTracer?.tracker() ?? null;
-        const registers = new HostCallRegisters(pvmInstance.registers.getAllEncoded());
+        const registers = HostCallRegisters.fromRaw(pvmInstance.registers.getAllEncoded());
         registers.ioTracker = ioTracker;
-        const memory = new HostCallMemory(pvmInstance.memory);
+        const memory = HostCallMemory.new(pvmInstance.memory);
         memory.ioTracker = ioTracker;
         const gas = pvmInstance.gas;
         // log start of execution (note the PVM initialisation should be logged already)

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

@@ -5,10 +5,12 @@ import type { HostCallRegisters } from "./host-call-registers.js";
 export declare class HostCalls {
     private readonly hostCalls;
     private readonly missing;
-    constructor({ missing, handlers, }: {
+    /** Build a `HostCalls` registry, verifying that no two handlers share an index. */
+    static new({ missing, handlers }: {
         missing: HostCallHandler;
         handlers?: HostCallHandler[];
-    });
+    }): HostCalls;
+    private constructor();
     /** Get a host call by index. */
     get(hostCallIndex: HostCallIndex): HostCallHandler;
     traceHostCall(context: string, hostCallIndex: HostCallIndex, hostCallHandler: HostCallHandler, registers: HostCallRegisters, gas: Gas): void;

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":"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"}
+{"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;IAEzB,mFAAmF;IACnF,MAAM,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,QAAa,EAAE,EAAE;QAAE,OAAO,EAAE,eAAe,CAAC;QAAC,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAA;KAAE;IASjG,OAAO;IAIP,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

@@ -8,12 +8,17 @@ const logger = Logger.new(import.meta.filename, "host-calls-pvm");
 export class HostCalls {
     hostCalls = new Map();
     missing;
-    constructor({ missing, handlers = [], }) {
-        this.missing = missing;
+    /** Build a `HostCalls` registry, verifying that no two handlers share an index. */
+    static new({ missing, handlers = [] }) {
+        const hostCalls = new HostCalls(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);
+            check `${hostCalls.hostCalls.get(handler.index) === undefined} Overwriting host call handler at index ${handler.index}`;
+            hostCalls.hostCalls.set(handler.index, handler);
         }
+        return hostCalls;
+    }
+    constructor(missing) {
+        this.missing = missing;
     }
     /** Get a host call by index. */
     get(hostCallIndex) {

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

@@ -13,7 +13,7 @@ export class PvmInstanceManager {
         const instances = [];
         switch (interpreter) {
             case PvmBackend.BuiltIn:
-                instances.push(new Interpreter({
+                instances.push(Interpreter.new({
                     useSbrkGas: false,
                 }));
                 break;

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

@@ -12,6 +12,8 @@ export interface IPvmInterpreter {
     readonly memory: IMemory;
     /** Prepare SPI program to be executed. */
     resetJam(program: Uint8Array, args: Uint8Array, pc: number, gas: Gas): void;
+    /** Prepare a generic (non-SPI) program to be executed. */
+    resetGeneric(rawProgram: Uint8Array, pc: number, gas: Gas): void;
     /** Execute loaded program. */
     runProgram(): void;
     /** Get current Status. */

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

@@ -1 +1 @@
-{"version":3,"file":"pvm.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-interface/pvm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,MAAM,WAAW,eAAe;IAC9B,sBAAsB;IACtB,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAE1B,4BAA4B;IAC5B,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAE/B,yBAAyB;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAEzB,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC;IAE5E,8BAA8B;IAC9B,UAAU,IAAI,IAAI,CAAC;IAEnB,0BAA0B;IAC1B,SAAS,IAAI,MAAM,CAAC;IAEpB,mCAAmC;IACnC,KAAK,IAAI,MAAM,CAAC;IAEhB,sDAAsD;IACtD,YAAY,IAAI,GAAG,GAAG,IAAI,CAAC;CAC5B"}
+{"version":3,"file":"pvm.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-interface/pvm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,MAAM,WAAW,eAAe;IAC9B,sBAAsB;IACtB,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAE1B,4BAA4B;IAC5B,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAE/B,yBAAyB;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAEzB,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC;IAE5E,0DAA0D;IAC1D,YAAY,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC;IAEjE,8BAA8B;IAC9B,UAAU,IAAI,IAAI,CAAC;IAEnB,0BAA0B;IAC1B,SAAS,IAAI,MAAM,CAAC;IAEpB,mCAAmC;IACnC,KAAK,IAAI,MAAM,CAAC;IAEhB,sDAAsD;IACtD,YAAY,IAAI,GAAG,GAAG,IAAI,CAAC;CAC5B"}

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

@@ -5,7 +5,7 @@ import { NibblesDecoder } from "./decoders/nibbles-decoder.js";
 const IMMEDIATE_AND_OFFSET_MAX_LENGTH = 4;
 export class ArgsDecoder {
     nibblesDecoder = new NibblesDecoder();
-    offsetDecoder = new ImmediateDecoder();
+    offsetDecoder = ImmediateDecoder.new();
     code = new Uint8Array();
     mask = Mask.empty();
     reset(code, mask) {

package/packages/core/pvm-interpreter/args-decoder/args-decoder.test.js

@@ -11,19 +11,19 @@ import { ImmediateDecoder } from "./decoders/immediate-decoder.js";
 describe("ArgsDecoder", () => {
     function prepareData({ programBytes, maskBytes, argumentType, }) {
         const code = new Uint8Array(programBytes);
-        const mask = new Mask(BitVec.fromBlob(new Uint8Array(maskBytes), programBytes.length));
+        const mask = Mask.new(BitVec.fromBlob(new Uint8Array(maskBytes), programBytes.length));
         const argsDecoder = new ArgsDecoder();
         argsDecoder.reset(code, mask);
         const result = createResults()[argumentType];
         return { argsDecoder, result, argumentType };
     }
     function prepareImmediate(bytes) {
-        const immediate = new ImmediateDecoder();
+        const immediate = ImmediateDecoder.new();
         immediate.setBytes(new Uint8Array(bytes));
         return immediate;
     }
     function prepareExtendedWidthImmediate(bytes) {
-        const immediate = new ExtendedWitdthImmediateDecoder();
+        const immediate = ExtendedWitdthImmediateDecoder.new();
         immediate.setBytes(new Uint8Array(bytes));
         return immediate;
     }

package/packages/core/pvm-interpreter/args-decoder/args-decoding-results.js

@@ -11,7 +11,7 @@ export const createResults = () => {
     results[ArgumentType.ONE_IMMEDIATE] = {
         type: ArgumentType.ONE_IMMEDIATE,
         noOfBytesToSkip: 1,
-        immediateDecoder: new ImmediateDecoder(),
+        immediateDecoder: ImmediateDecoder.new(),
     };
     results[ArgumentType.TWO_REGISTERS] = {
         type: ArgumentType.TWO_REGISTERS,
@@ -30,7 +30,7 @@ export const createResults = () => {
         type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET,
         noOfBytesToSkip: 1,
         registerIndex: 0,
-        immediateDecoder: new ImmediateDecoder(),
+        immediateDecoder: ImmediateDecoder.new(),
         nextPc: 0,
     };
     results[ArgumentType.TWO_REGISTERS_ONE_OFFSET] = {
@@ -45,20 +45,20 @@ export const createResults = () => {
         noOfBytesToSkip: 1,
         firstRegisterIndex: 0,
         secondRegisterIndex: 0,
-        immediateDecoder: new ImmediateDecoder(),
+        immediateDecoder: ImmediateDecoder.new(),
     };
     results[ArgumentType.ONE_REGISTER_ONE_IMMEDIATE] = {
         type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE,
         noOfBytesToSkip: 1,
         registerIndex: 0,
-        immediateDecoder: new ImmediateDecoder(),
+        immediateDecoder: ImmediateDecoder.new(),
     };
     results[ArgumentType.ONE_REGISTER_TWO_IMMEDIATES] = {
         type: ArgumentType.ONE_REGISTER_TWO_IMMEDIATES,
         noOfBytesToSkip: 1,
         registerIndex: 0,
-        firstImmediateDecoder: new ImmediateDecoder(),
-        secondImmediateDecoder: new ImmediateDecoder(),
+        firstImmediateDecoder: ImmediateDecoder.new(),
+        secondImmediateDecoder: ImmediateDecoder.new(),
     };
     results[ArgumentType.ONE_OFFSET] = {
         type: ArgumentType.ONE_OFFSET,
@@ -68,14 +68,14 @@ export const createResults = () => {
     results[ArgumentType.TWO_IMMEDIATES] = {
         type: ArgumentType.TWO_IMMEDIATES,
         noOfBytesToSkip: 1,
-        firstImmediateDecoder: new ImmediateDecoder(),
-        secondImmediateDecoder: new ImmediateDecoder(),
+        firstImmediateDecoder: ImmediateDecoder.new(),
+        secondImmediateDecoder: ImmediateDecoder.new(),
     };
     results[ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES] = {
         type: ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES,
         noOfBytesToSkip: 1,
-        firstImmediateDecoder: new ImmediateDecoder(),
-        secondImmediateDecoder: new ImmediateDecoder(),
+        firstImmediateDecoder: ImmediateDecoder.new(),
+        secondImmediateDecoder: ImmediateDecoder.new(),
         firstRegisterIndex: 0,
         secondRegisterIndex: 0,
     };
@@ -83,7 +83,7 @@ export const createResults = () => {
         type: ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE,
         noOfBytesToSkip: 9,
         registerIndex: 0,
-        immediateDecoder: new ExtendedWitdthImmediateDecoder(),
+        immediateDecoder: ExtendedWitdthImmediateDecoder.new(),
     };
     return results;
 };

package/packages/core/pvm-interpreter/args-decoder/decoders/extended-with-immediate-decoder.d.ts

@@ -1,7 +1,8 @@
 export declare class ExtendedWitdthImmediateDecoder {
     private unsignedImmediate;
     private bytes;
-    constructor();
+    static new(): ExtendedWitdthImmediateDecoder;
+    private constructor();
     setBytes(bytes: Uint8Array): void;
     getValue(): bigint;
     getBytesAsLittleEndian(): Uint8Array<ArrayBufferLike>;

package/packages/core/pvm-interpreter/args-decoder/decoders/extended-with-immediate-decoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extended-with-immediate-decoder.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/pvm-interpreter/args-decoder/decoders/extended-with-immediate-decoder.ts"],"names":[],"mappings":"AAEA,qBAAa,8BAA8B;IACzC,OAAO,CAAC,iBAAiB,CAAiB;IAC1C,OAAO,CAAC,KAAK,CAAa;;IAQ1B,QAAQ,CAAC,KAAK,EAAE,UAAU;IAW1B,QAAQ;IAIR,sBAAsB;CAGvB"}
+{"version":3,"file":"extended-with-immediate-decoder.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/pvm-interpreter/args-decoder/decoders/extended-with-immediate-decoder.ts"],"names":[],"mappings":"AAEA,qBAAa,8BAA8B;IACzC,OAAO,CAAC,iBAAiB,CAAiB;IAC1C,OAAO,CAAC,KAAK,CAAa;IAE1B,MAAM,CAAC,GAAG;IAIV,OAAO;IAMP,QAAQ,CAAC,KAAK,EAAE,UAAU;IAW1B,QAAQ;IAIR,sBAAsB;CAGvB"}

package/packages/core/pvm-interpreter/args-decoder/decoders/extended-with-immediate-decoder.js

@@ -2,6 +2,9 @@ const IMMEDIATE_SIZE = 8;
 export class ExtendedWitdthImmediateDecoder {
     unsignedImmediate;
     bytes;
+    static new() {
+        return new ExtendedWitdthImmediateDecoder();
+    }
     constructor() {
         const buffer = new ArrayBuffer(IMMEDIATE_SIZE);
         this.unsignedImmediate = new BigUint64Array(buffer);

package/packages/core/pvm-interpreter/args-decoder/decoders/extended-with-immediate-decoder.test.js

@@ -4,7 +4,7 @@ import { ExtendedWitdthImmediateDecoder } from "./extended-with-immediate-decode
 describe("ExtendedWitdthImmediateDecoder", () => {
     describe("reading bytes as unsigned number", () => {
         it("8-bytes number", () => {
-            const decoder = new ExtendedWitdthImmediateDecoder();
+            const decoder = ExtendedWitdthImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88]);
             const expectedValue = 0x8899aabbccddeeffn;
             decoder.setBytes(encodedBytes);
@@ -13,7 +13,7 @@ describe("ExtendedWitdthImmediateDecoder", () => {
     });
     describe("read immediate as bytes (little endian)", () => {
         it("8-bytes number", () => {
-            const decoder = new ExtendedWitdthImmediateDecoder();
+            const decoder = ExtendedWitdthImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88]);
             const expectedBytes = new Uint8Array([0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88]);
             decoder.setBytes(encodedBytes);

package/packages/core/pvm-interpreter/args-decoder/decoders/immediate-decoder.d.ts

@@ -5,7 +5,8 @@ export declare class ImmediateDecoder {
     private i64;
     private view;
     private bytes;
-    constructor();
+    static new(): ImmediateDecoder;
+    private constructor();
     setBytes(bytes: Uint8Array): void;
     /**
      * @deprecated Use getU32 instead

package/packages/core/pvm-interpreter/args-decoder/decoders/immediate-decoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"immediate-decoder.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/pvm-interpreter/args-decoder/decoders/immediate-decoder.ts"],"names":[],"mappings":"AAKA,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,GAAG,CAAc;IACzB,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,GAAG,CAAiB;IAC5B,OAAO,CAAC,GAAG,CAAgB;IAC3B,OAAO,CAAC,IAAI,CAAW;IACvB,OAAO,CAAC,KAAK,CAAa;;IAY1B,QAAQ,CAAC,KAAK,EAAE,UAAU;IAe1B;;OAEG;IACH,WAAW;IAIX;;OAEG;IACH,SAAS;IAIT,MAAM,IAAI,MAAM;IAIhB,MAAM,IAAI,MAAM;IAIhB,MAAM,IAAI,MAAM;IAIhB,MAAM,IAAI,MAAM;IAIhB,sBAAsB;IAItB,8BAA8B;CAG/B"}
+{"version":3,"file":"immediate-decoder.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/pvm-interpreter/args-decoder/decoders/immediate-decoder.ts"],"names":[],"mappings":"AAKA,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,GAAG,CAAc;IACzB,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,GAAG,CAAiB;IAC5B,OAAO,CAAC,GAAG,CAAgB;IAC3B,OAAO,CAAC,IAAI,CAAW;IACvB,OAAO,CAAC,KAAK,CAAa;IAE1B,MAAM,CAAC,GAAG;IAIV,OAAO;IAUP,QAAQ,CAAC,KAAK,EAAE,UAAU;IAe1B;;OAEG;IACH,WAAW;IAIX;;OAEG;IACH,SAAS;IAIT,MAAM,IAAI,MAAM;IAIhB,MAAM,IAAI,MAAM;IAIhB,MAAM,IAAI,MAAM;IAIhB,MAAM,IAAI,MAAM;IAIhB,sBAAsB;IAItB,8BAA8B;CAG/B"}

package/packages/core/pvm-interpreter/args-decoder/decoders/immediate-decoder.js

@@ -9,6 +9,9 @@ export class ImmediateDecoder {
     i64;
     view;
     bytes;
+    static new() {
+        return new ImmediateDecoder();
+    }
     constructor() {
         const buffer = new ArrayBuffer(BUFFER_SIZE);
         this.u32 = new Uint32Array(buffer);

package/packages/core/pvm-interpreter/args-decoder/decoders/immediate-decoder.test.js

@@ -4,7 +4,7 @@ import { ImmediateDecoder } from "./immediate-decoder.js";
 describe("ImmediateDecoder", () => {
     describe("reading bytes as signed and unsigned number U32", () => {
         it("Positive number without elided octets", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0x01, 0x00, 0x00, 0x00]);
             const expectedSigned = 1;
             const expectedUnsigned = 1;
@@ -13,7 +13,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getUnsigned(), expectedUnsigned);
         });
         it("Negative number without elided octets", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff, 0xff, 0xff, 0xff]);
             const expectedSigned = -1;
             const expectedUnsigned = 2 ** 32 - 1;
@@ -22,7 +22,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getUnsigned(), expectedUnsigned);
         });
         it("Positive number with elided octets", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0x01]);
             const expectedSigned = 1;
             const expectedUnsigned = 1;
@@ -31,7 +31,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getUnsigned(), expectedUnsigned);
         });
         it("Negative number with elided octets", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff]);
             const expectedSigned = -1;
             const expectedUnsigned = 2 ** 32 - 1;
@@ -40,7 +40,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getUnsigned(), expectedUnsigned);
         });
         it("Large positive number without elided octets", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff, 0xff, 0x7f, 0x00]);
             const expectedSigned = 0x00_7f_ff_ff;
             const expectedUnsigned = 0x00_7f_ff_ff;
@@ -49,7 +49,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getUnsigned(), expectedUnsigned);
         });
         it("Large negative number without elided octets", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0x01, 0x00, 0x80, 0xff]);
             const expectedSigned = -0x00_7f_ff_ff;
             const expectedUnsigned = 0xff_80_00_01;
@@ -58,7 +58,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getUnsigned(), expectedUnsigned);
         });
         it("Maximum positive value", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff, 0xff, 0xff, 0x7f]);
             const expectedSigned = 0x7f_ff_ff_ff;
             const expectedUnsigned = 0x7f_ff_ff_ff;
@@ -67,7 +67,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getUnsigned(), expectedUnsigned);
         });
         it("Maximum negative value", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0x00, 0x00, 0x00, 0x80]);
             const expectedSigned = -(2 ** 31);
             const expectedUnsigned = 0x80_00_00_00;
@@ -76,7 +76,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getUnsigned(), expectedUnsigned);
         });
         it("Empty bytes array", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([]);
             const expectedSigned = 0;
             const expectedUnsigned = 0;
@@ -87,7 +87,7 @@ describe("ImmediateDecoder", () => {
     });
     describe("reading bytes as signed and unsigned number U64", () => {
         it("Positive number without elided octets", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0x01, 0x00, 0x00, 0x00]);
             const expectedSigned = 1n;
             const expectedUnsigned = 1n;
@@ -96,7 +96,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getU64(), expectedUnsigned);
         });
         it("Negative number without elided octets", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff, 0xff, 0xff, 0xff]);
             const expectedSigned = -1n;
             const expectedUnsigned = 2n ** 64n - 1n;
@@ -105,7 +105,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getU64(), expectedUnsigned);
         });
         it("Positive number with elided octets", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0x01]);
             const expectedSigned = 1n;
             const expectedUnsigned = 1n;
@@ -114,7 +114,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getU64(), expectedUnsigned);
         });
         it("Negative number with elided octets", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff]);
             const expectedSigned = -1n;
             const expectedUnsigned = 2n ** 64n - 1n;
@@ -123,7 +123,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getU64(), expectedUnsigned);
         });
         it("Large positive number without elided octets", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff, 0xff, 0x7f, 0x00]);
             const expectedSigned = 0x007fffffn;
             const expectedUnsigned = 0x007fffffn;
@@ -132,7 +132,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getU64(), expectedUnsigned);
         });
         it("Large negative number without elided octets", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0x01, 0x00, 0x80, 0xff]);
             const expectedSigned = -0x007fffffn;
             const expectedUnsigned = 0xffffffffff800001n;
@@ -141,7 +141,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getU64(), expectedUnsigned);
         });
         it("Maximum positive value", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff, 0xff, 0xff, 0x7f]);
             const expectedSigned = 0x7fffffffn;
             const expectedUnsigned = 0x7fffffffn;
@@ -150,7 +150,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getU64(), expectedUnsigned);
         });
         it("Maximum negative value", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0x00, 0x00, 0x00, 0x80]);
             const expectedSigned = -(2n ** 31n);
             const expectedUnsigned = 0xffffffff80000000n;
@@ -159,7 +159,7 @@ describe("ImmediateDecoder", () => {
             assert.strictEqual(decoder.getU64(), expectedUnsigned);
         });
         it("Empty bytes array", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([]);
             const expectedSigned = 0n;
             const expectedUnsigned = 0n;
@@ -170,28 +170,28 @@ describe("ImmediateDecoder", () => {
     });
     describe("getBytesAsLittleEndian", () => {
         it("should return empty bytes array", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([]);
             const expectedBytes = new Uint8Array([0, 0, 0, 0]);
             decoder.setBytes(encodedBytes);
             assert.deepStrictEqual(decoder.getBytesAsLittleEndian(), expectedBytes);
         });
         it("should return u8 number correctly encoded as little endian", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff]);
             const expectedBytes = new Uint8Array([0xff, 0xff, 0xff, 0xff]);
             decoder.setBytes(encodedBytes);
             assert.deepStrictEqual(decoder.getBytesAsLittleEndian(), expectedBytes);
         });
         it("should return u16 number correctly encoded as little endian", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff, 0xee]);
             const expectedBytes = new Uint8Array([0xff, 0xee, 0xff, 0xff]);
             decoder.setBytes(encodedBytes);
             assert.deepStrictEqual(decoder.getBytesAsLittleEndian(), expectedBytes);
         });
         it("should return u32 number correctly encoded as little endian", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff, 0xee, 0xdd, 0xcc]);
             const expectedBytes = new Uint8Array([0xff, 0xee, 0xdd, 0xcc]);
             decoder.setBytes(encodedBytes);
@@ -200,28 +200,28 @@ describe("ImmediateDecoder", () => {
     });
     describe("getExtendedBytesAsLittleEndian", () => {
         it("should return empty bytes array", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([]);
             const expectedBytes = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]);
             decoder.setBytes(encodedBytes);
             assert.deepStrictEqual(decoder.getExtendedBytesAsLittleEndian(), expectedBytes);
         });
         it("should return u8 number correctly encoded as little endian", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff]);
             const expectedBytes = new Uint8Array([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
             decoder.setBytes(encodedBytes);
             assert.deepStrictEqual(decoder.getExtendedBytesAsLittleEndian(), expectedBytes);
         });
         it("should return u16 number correctly encoded as little endian", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff, 0xee]);
             const expectedBytes = new Uint8Array([0xff, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
             decoder.setBytes(encodedBytes);
             assert.deepStrictEqual(decoder.getExtendedBytesAsLittleEndian(), expectedBytes);
         });
         it("should return u32 number correctly encoded as little endian", () => {
-            const decoder = new ImmediateDecoder();
+            const decoder = ImmediateDecoder.new();
             const encodedBytes = new Uint8Array([0xff, 0xee, 0xdd, 0xcc]);
             const expectedBytes = new Uint8Array([0xff, 0xee, 0xdd, 0xcc, 0xff, 0xff, 0xff, 0xff]);
             decoder.setBytes(encodedBytes);