@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

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

@@ -0,0 +1,21 @@
+import { Memory } from "#@typeberry/pvm-interpreter/memory/index.js";
+import { Registers } from "#@typeberry/pvm-interpreter/registers.js";
+export declare class Program {
+    readonly code: Uint8Array;
+    readonly registers: Registers;
+    readonly memory: Memory;
+    metadata: Uint8Array;
+    static fromSpi(blob: Uint8Array, args: Uint8Array, hasMetadata: boolean): Program;
+    static fromGeneric(blob: Uint8Array, hasMetadata: boolean): Program;
+    private constructor();
+}
+/**
+ * A function that splits preimage into metadata and code.
+ *
+ * https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5
+ */
+export declare function extractCodeAndMetadata(blobWithMetadata: Uint8Array): {
+    metadata: Uint8Array<ArrayBufferLike>;
+    code: Uint8Array<ArrayBufferLike>;
+};
+//# sourceMappingURL=program.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-interpreter/program.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAiB,MAAM,4CAA4C,CAAC;AAEnF,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,qBAAa,OAAO;aAmCA,IAAI,EAAE,UAAU;aAChB,SAAS,EAAE,SAAS;aACpB,MAAM,EAAE,MAAM;IACvB,QAAQ,EAAE,UAAU;IArC7B,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO;IA0BvE,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO;IAOzD,OAAO;CAMR;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,gBAAgB,EAAE,UAAU;;;EAKlE"}

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

@@ -0,0 +1,55 @@
+import { Decoder } from "#@typeberry/codec";
+import { Memory, MemoryBuilder } from "#@typeberry/pvm-interpreter/memory/index.js";
+import { tryAsMemoryIndex, tryAsSbrkIndex } from "#@typeberry/pvm-interpreter/memory/memory-index.js";
+import { Registers } from "#@typeberry/pvm-interpreter/registers.js";
+import { decodeStandardProgram } from "#@typeberry/pvm-interpreter/spi-decoder/index.js";
+export class Program {
+    code;
+    registers;
+    memory;
+    metadata;
+    static fromSpi(blob, args, hasMetadata) {
+        const { code: spiCode, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
+        const { code, memory: rawMemory, registers } = decodeStandardProgram(spiCode, args);
+        const regs = new Registers();
+        regs.copyFrom(registers);
+        const memoryBuilder = new MemoryBuilder();
+        for (const { start, end, data } of rawMemory.readable) {
+            const startIndex = tryAsMemoryIndex(start);
+            const endIndex = tryAsMemoryIndex(end);
+            memoryBuilder.setReadablePages(startIndex, endIndex, data ?? new Uint8Array());
+        }
+        for (const { start, end, data } of rawMemory.writeable) {
+            const startIndex = tryAsMemoryIndex(start);
+            const endIndex = tryAsMemoryIndex(end);
+            memoryBuilder.setWriteablePages(startIndex, endIndex, data ?? new Uint8Array());
+        }
+        const heapStart = tryAsMemoryIndex(rawMemory.sbrkIndex);
+        const heapEnd = tryAsSbrkIndex(rawMemory.heapEnd);
+        const memory = memoryBuilder.finalize(heapStart, heapEnd);
+        return new Program(code, regs, memory, metadata);
+    }
+    static fromGeneric(blob, hasMetadata) {
+        const { code, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
+        const regs = new Registers();
+        const memory = new Memory();
+        return new Program(code, regs, memory, metadata);
+    }
+    constructor(code, registers, memory, metadata = new Uint8Array()) {
+        this.code = code;
+        this.registers = registers;
+        this.memory = memory;
+        this.metadata = metadata;
+    }
+}
+/**
+ * A function that splits preimage into metadata and code.
+ *
+ * https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5
+ */
+export function extractCodeAndMetadata(blobWithMetadata) {
+    const decoder = Decoder.fromBlob(blobWithMetadata);
+    const metadata = decoder.bytesBlob().raw;
+    const code = decoder.remainingBytes().raw;
+    return { metadata, code };
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=program.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"program.test.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-interpreter/program.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,13 @@
+import { describe, it } from "node:test";
+import { BytesBlob } from "#@typeberry/bytes";
+import { deepEqual } from "#@typeberry/utils/test.js";
+import { extractCodeAndMetadata } from "./program.js";
+import { CODE, METADATA, PREIMAGE_TEST_BLOB } from "./test-preimage-blob.js";
+describe("extractCodeAndMetadata", () => {
+    it("should correctly decode code with metadata", () => {
+        const blobWithMetadata = BytesBlob.parseBlobNoPrefix(PREIMAGE_TEST_BLOB).raw;
+        const { code, metadata } = extractCodeAndMetadata(blobWithMetadata);
+        deepEqual(BytesBlob.blobFrom(code), BytesBlob.parseBlobNoPrefix(CODE));
+        deepEqual(BytesBlob.blobFrom(metadata), BytesBlob.parseBlobNoPrefix(METADATA));
+    });
+});

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

@@ -0,0 +1,27 @@
+import { type IRegisters } from "#@typeberry/pvm-interface";
+import { type Opaque } from "#@typeberry/utils";
+export type RegisterIndex = Opaque<number, "register index">;
+export declare const tryAsRegisterIndex: (index: number) => RegisterIndex;
+export declare class Registers implements IRegisters {
+    private readonly bytes;
+    private asSigned;
+    private asUnsigned;
+    constructor(bytes?: Uint8Array<ArrayBufferLike>);
+    getAllEncoded(): Uint8Array;
+    setAllEncoded(bytes: Uint8Array): void;
+    static fromBytes(bytes: Uint8Array): Registers;
+    getBytesAsLittleEndian(index: number, len: number): Uint8Array<ArrayBufferLike>;
+    copyFrom(regs: Registers | BigUint64Array): void;
+    reset(): void;
+    getLowerU32(registerIndex: number): number;
+    getLowerI32(registerIndex: number): number;
+    setU32(registerIndex: number, value: number): void;
+    setI32(registerIndex: number, value: number): void;
+    getU64(registerIndex: number): bigint;
+    getI64(registerIndex: number): bigint;
+    setU64(registerIndex: number, value: bigint): void;
+    setI64(registerIndex: number, value: bigint): void;
+    getAllU64(): BigUint64Array<ArrayBufferLike>;
+}
+export declare function signExtend32To64(value: number | bigint): bigint;
+//# sourceMappingURL=registers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registers.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-interpreter/registers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAmB,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAuB,KAAK,MAAM,EAAuB,MAAM,kBAAkB,CAAC;AAIzF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;AAE7D,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,KAAG,aAGlD,CAAC;AAEF,qBAAa,SAAU,YAAW,UAAU;IAI9B,OAAO,CAAC,QAAQ,CAAC,KAAK;IAHlC,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,UAAU,CAAiB;gBAEN,KAAK,8BAA8D;IAMhG,aAAa,IAAI,UAAU;IAI3B,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAKtC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,UAAU;IAKlC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAKjD,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc;IAKzC,KAAK;IAML,WAAW,CAAC,aAAa,EAAE,MAAM;IAIjC,WAAW,CAAC,aAAa,EAAE,MAAM;IAIjC,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAI3C,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAI3C,MAAM,CAAC,aAAa,EAAE,MAAM;IAI5B,MAAM,CAAC,aAAa,EAAE,MAAM;IAI5B,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAI3C,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAI3C,SAAS;CAGV;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAgB/D"}

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

@@ -0,0 +1,84 @@
+import { NO_OF_REGISTERS } from "#@typeberry/pvm-interface";
+import { asOpaqueType, check, safeAllocUint8Array } from "#@typeberry/utils";
+const REGISTER_SIZE_SHIFT = 3; // x << 3 === x * 8
+export const tryAsRegisterIndex = (index) => {
+    check `${index >= 0 && index < NO_OF_REGISTERS} Incorrect register index: ${index}!`;
+    return asOpaqueType(index);
+};
+export class Registers {
+    bytes;
+    asSigned;
+    asUnsigned;
+    constructor(bytes = safeAllocUint8Array(NO_OF_REGISTERS << REGISTER_SIZE_SHIFT)) {
+        this.bytes = bytes;
+        check `${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
+        this.asSigned = new BigInt64Array(bytes.buffer, bytes.byteOffset);
+        this.asUnsigned = new BigUint64Array(bytes.buffer, bytes.byteOffset);
+    }
+    getAllEncoded() {
+        return this.bytes;
+    }
+    setAllEncoded(bytes) {
+        check `${bytes.length === this.bytes.length} Incorrect size of input registers. Got: ${bytes.length}, need: ${this.bytes.length}`;
+        this.bytes.set(bytes, 0);
+    }
+    static fromBytes(bytes) {
+        check `${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
+        return new Registers(bytes);
+    }
+    getBytesAsLittleEndian(index, len) {
+        const offset = index << REGISTER_SIZE_SHIFT;
+        return this.bytes.subarray(offset, offset + len);
+    }
+    copyFrom(regs) {
+        const array = regs instanceof BigUint64Array ? regs : regs.asUnsigned;
+        this.asUnsigned.set(array);
+    }
+    reset() {
+        for (let i = 0; i < NO_OF_REGISTERS; i++) {
+            this.asUnsigned[i] = 0n;
+        }
+    }
+    getLowerU32(registerIndex) {
+        return Number(this.asUnsigned[registerIndex] & 0xffffffffn);
+    }
+    getLowerI32(registerIndex) {
+        return Number(this.getLowerU32(registerIndex)) >> 0;
+    }
+    setU32(registerIndex, value) {
+        this.asUnsigned[registerIndex] = signExtend32To64(value);
+    }
+    setI32(registerIndex, value) {
+        this.asSigned[registerIndex] = signExtend32To64(value);
+    }
+    getU64(registerIndex) {
+        return this.asUnsigned[registerIndex];
+    }
+    getI64(registerIndex) {
+        return this.asSigned[registerIndex];
+    }
+    setU64(registerIndex, value) {
+        this.asUnsigned[registerIndex] = value;
+    }
+    setI64(registerIndex, value) {
+        this.asSigned[registerIndex] = value;
+    }
+    getAllU64() {
+        return this.asUnsigned;
+    }
+}
+export function signExtend32To64(value) {
+    // Convert to BigInt if the value is a number
+    const bigValue = typeof value === "number" ? BigInt(value) : value;
+    // Ensure the value is treated as a 32-bit integer
+    const mask32 = BigInt(0xffffffff);
+    const signBit = BigInt(0x80000000);
+    const maskedValue = bigValue & mask32;
+    // Check the sign bit and extend the sign if necessary
+    if ((maskedValue & signBit) !== BigInt(0)) {
+        // If the sign bit is set, extend with ones
+        return maskedValue | ~mask32;
+    }
+    // If the sign bit is not set, return as is
+    return maskedValue;
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=registers.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registers.test.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-interpreter/registers.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,102 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { Registers } from "./registers.js";
+const U32_BYTES = 4;
+const U64_BYTES = 8;
+describe("Registers", () => {
+    describe("loading values", () => {
+        it("should return 0xff_ff_ff_ff correctly loaded into register", () => {
+            const registers = new Registers();
+            const expectedSignedNumber = -1;
+            const expectedUnsignedNumber = 2 ** 32 - 1;
+            registers.setU32(0, 0xff_ff_ff_ff);
+            assert.strictEqual(registers.getLowerI32(0), expectedSignedNumber);
+            assert.strictEqual(registers.getLowerU32(0), expectedUnsignedNumber);
+        });
+        it("should return 0x00_00_00_01 correctly loaded into register", () => {
+            const registers = new Registers();
+            const expectedSignedNumber = 1;
+            const expectedUnsignedNumber = 1;
+            registers.setU32(0, 0x00_00_00_01);
+            assert.strictEqual(registers.getLowerI32(0), expectedSignedNumber);
+            assert.strictEqual(registers.getLowerU32(0), expectedUnsignedNumber);
+        });
+        it("should return 0x80_00_00_00 correctly loaded into register", () => {
+            const registers = new Registers();
+            const expectedSignedNumber = -(2 ** 31);
+            const expectedUnsignedNumber = 2 ** 31;
+            registers.setU32(0, 0x80_00_00_00);
+            assert.strictEqual(registers.getLowerI32(0), expectedSignedNumber);
+            assert.strictEqual(registers.getLowerU32(0), expectedUnsignedNumber);
+        });
+    });
+    describe("getBytesAsLittleEndian", () => {
+        it("should return empty bytes array", () => {
+            const regs = new Registers();
+            const num = 0;
+            const expectedBytes = new Uint8Array([0, 0, 0, 0]);
+            regs.setU32(1, num);
+            assert.deepStrictEqual(regs.getBytesAsLittleEndian(1, U32_BYTES), expectedBytes);
+        });
+        it("should return u8 number correctly encoded as little endian", () => {
+            const regs = new Registers();
+            const num = 0xff;
+            const expectedBytes = new Uint8Array([0xff, 0, 0, 0]);
+            regs.setU32(1, num);
+            assert.deepStrictEqual(regs.getBytesAsLittleEndian(1, U32_BYTES), expectedBytes);
+        });
+        it("should return u16 number correctly encoded as little endian", () => {
+            const regs = new Registers();
+            const num = 0xff_ee;
+            const expectedBytes = new Uint8Array([0xee, 0xff, 0, 0]);
+            regs.setU32(1, num);
+            assert.deepStrictEqual(regs.getBytesAsLittleEndian(1, U32_BYTES), expectedBytes);
+        });
+        it("should return u32 number correctly encoded as little endian", () => {
+            const regs = new Registers();
+            const num = 0xff_ee_dd_cc;
+            const expectedBytes = new Uint8Array([0xcc, 0xdd, 0xee, 0xff]);
+            regs.setU32(1, num);
+            assert.deepStrictEqual(regs.getBytesAsLittleEndian(1, U32_BYTES), expectedBytes);
+        });
+    });
+    describe("Implemented IRegister", () => {
+        it("should correctly get all registers into bytes encoded", () => {
+            const regs = new Registers();
+            const num = 0xefcdab8967452301n;
+            const bytesReg = new Uint8Array([0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]);
+            const fill = new Uint8Array(12 * U64_BYTES).fill(0); // we set 1st register so we fill remaining 12 with 0
+            const expected = new Uint8Array([...bytesReg, ...fill]);
+            regs.setU64(0, num);
+            // when
+            const encodedAllRegisters = regs.getAllEncoded();
+            // then
+            assert.deepStrictEqual(encodedAllRegisters.length, expected.length);
+            assert.deepStrictEqual(encodedAllRegisters, expected);
+        });
+        it("should correctly set all registers from bytes encoded", () => {
+            const regs = new Registers();
+            const bytesReg = new Uint8Array([0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]);
+            const fill = new Uint8Array(12 * U64_BYTES).fill(0); // we set 1st register so we fill remaining 12 with 0
+            const bytes = new Uint8Array([...bytesReg, ...fill]);
+            const expected = 0xefcdab8967452301n;
+            regs.setAllEncoded(bytes);
+            const reg = regs.getU64(0);
+            assert.deepStrictEqual(reg, expected);
+        });
+        it("should throw when trying to set all registers from bytes encoded with incorrect size", () => {
+            const regs = new Registers();
+            const bytesReg = new Uint8Array([0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]);
+            const fill = new Uint8Array(12 * U64_BYTES).fill(0); // we set 1st register so we fill remaining 12 with 0
+            const bytes = new Uint8Array([...bytesReg, ...fill, 0x00]);
+            // too many
+            assert.throws(() => {
+                regs.setAllEncoded(bytes);
+            });
+            // too little
+            assert.throws(() => {
+                regs.setAllEncoded(fill);
+            });
+        });
+    });
+});

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

@@ -0,0 +1,8 @@
+export declare enum Result {
+    HALT = 0,
+    PANIC = 1,
+    FAULT_ACCESS = 2,
+    FAULT = 3,
+    HOST = 4
+}
+//# sourceMappingURL=result.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../../../packages/core/pvm-interpreter/result.ts"],"names":[],"mappings":"AAAA,oBAAY,MAAM;IAChB,IAAI,IAAI;IACR,KAAK,IAAI;IACT,YAAY,IAAI;IAChB,KAAK,IAAI;IACT,IAAI,IAAI;CACT"}

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

@@ -0,0 +1,8 @@
+export var Result;
+(function (Result) {
+    Result[Result["HALT"] = 0] = "HALT";
+    Result[Result["PANIC"] = 1] = "PANIC";
+    Result[Result["FAULT_ACCESS"] = 2] = "FAULT_ACCESS";
+    Result[Result["FAULT"] = 3] = "FAULT";
+    Result[Result["HOST"] = 4] = "HOST";
+})(Result || (Result = {}));

package/packages/core/pvm-interpreter/spi-decoder/decode-standard-program.d.ts

@@ -0,0 +1,35 @@
+import { WithDebug } from "#@typeberry/utils";
+export declare class MemorySegment extends WithDebug {
+    readonly start: number;
+    readonly end: number;
+    readonly data: Uint8Array | null;
+    static from({ start, end, data }: Omit<MemorySegment, never>): MemorySegment;
+    constructor(start: number, end: number, data: Uint8Array | null);
+}
+export declare class SpiMemory extends WithDebug {
+    readonly readable: MemorySegment[];
+    readonly writeable: MemorySegment[];
+    readonly sbrkIndex: number;
+    readonly heapEnd: number;
+    constructor(readable: MemorySegment[], writeable: MemorySegment[], sbrkIndex: number, heapEnd: number);
+}
+export declare class SpiProgram extends WithDebug {
+    readonly code: Uint8Array;
+    readonly memory: SpiMemory;
+    readonly registers: BigUint64Array;
+    constructor(code: Uint8Array, memory: SpiMemory, registers: BigUint64Array);
+}
+/**
+ * program = E_3(|o|) ++ E_3(|w|) ++ E_2(z) ++ E_3(s) ++ o ++ w ++ E_4(|c|) ++ c
+ *
+ * E_n - little endian encoding, n - length
+ * o - initial read only data
+ * w - initial heap
+ * z - heap pages filled with zeros
+ * s - stack size
+ * c - program code
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/2b92022b9202
+ */
+export declare function decodeStandardProgram(program: Uint8Array, args: Uint8Array): SpiProgram;
+//# sourceMappingURL=decode-standard-program.d.ts.map

package/packages/core/pvm-interpreter/spi-decoder/decode-standard-program.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-standard-program.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/spi-decoder/decode-standard-program.ts"],"names":[],"mappings":"AACA,OAAO,EAAS,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAapD,qBAAa,aAAc,SAAQ,SAAS;aAMxB,KAAK,EAAE,MAAM;aACb,GAAG,EAAE,MAAM;aACX,IAAI,EAAE,UAAU,GAAG,IAAI;IAPzC,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC,aAAa,EAAE,KAAK,CAAC;gBAK1C,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,UAAU,GAAG,IAAI;CAI1C;AACD,qBAAa,SAAU,SAAQ,SAAS;aAEpB,QAAQ,EAAE,aAAa,EAAE;aACzB,SAAS,EAAE,aAAa,EAAE;aAC1B,SAAS,EAAE,MAAM;aACjB,OAAO,EAAE,MAAM;gBAHf,QAAQ,EAAE,aAAa,EAAE,EACzB,SAAS,EAAE,aAAa,EAAE,EAC1B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM;CAIlC;AAED,qBAAa,UAAW,SAAQ,SAAS;aAErB,IAAI,EAAE,UAAU;aAChB,MAAM,EAAE,SAAS;aACjB,SAAS,EAAE,cAAc;gBAFzB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,SAAS,EACjB,SAAS,EAAE,cAAc;CAI5C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,cAgD1E"}

package/packages/core/pvm-interpreter/spi-decoder/decode-standard-program.js

@@ -0,0 +1,108 @@
+import { Decoder } from "#@typeberry/codec";
+import { check, WithDebug } from "#@typeberry/utils";
+import { ARGS_SEGMENT, DATA_LEGNTH as DATA_LENGTH, LAST_PAGE, PAGE_SIZE, SEGMENT_SIZE, STACK_SEGMENT, } from "./memory-conts.js";
+import { alignToPageSize, alignToSegmentSize } from "./memory-utils.js";
+const NO_OF_REGISTERS = 13;
+export class MemorySegment extends WithDebug {
+    start;
+    end;
+    data;
+    static from({ start, end, data }) {
+        return new MemorySegment(start, end, data);
+    }
+    constructor(start, end, data) {
+        super();
+        this.start = start;
+        this.end = end;
+        this.data = data;
+    }
+}
+export class SpiMemory extends WithDebug {
+    readable;
+    writeable;
+    sbrkIndex;
+    heapEnd;
+    constructor(readable, writeable, sbrkIndex, heapEnd) {
+        super();
+        this.readable = readable;
+        this.writeable = writeable;
+        this.sbrkIndex = sbrkIndex;
+        this.heapEnd = heapEnd;
+    }
+}
+export class SpiProgram extends WithDebug {
+    code;
+    memory;
+    registers;
+    constructor(code, memory, registers) {
+        super();
+        this.code = code;
+        this.memory = memory;
+        this.registers = registers;
+    }
+}
+/**
+ * program = E_3(|o|) ++ E_3(|w|) ++ E_2(z) ++ E_3(s) ++ o ++ w ++ E_4(|c|) ++ c
+ *
+ * E_n - little endian encoding, n - length
+ * o - initial read only data
+ * w - initial heap
+ * z - heap pages filled with zeros
+ * s - stack size
+ * c - program code
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/2b92022b9202
+ */
+export function decodeStandardProgram(program, args) {
+    const decoder = Decoder.fromBlob(program);
+    const oLength = decoder.u24();
+    const wLength = decoder.u24();
+    check `${args.length <= DATA_LENGTH} Incorrect arguments length`;
+    check `${oLength <= DATA_LENGTH} Incorrect readonly segment length`;
+    const readOnlyLength = oLength;
+    check `${wLength <= DATA_LENGTH} Incorrect heap segment length`;
+    const heapLength = wLength;
+    const noOfHeapZerosPages = decoder.u16();
+    const stackSize = decoder.u24();
+    const readOnlyMemory = decoder.bytes(readOnlyLength).raw;
+    const initialHeap = decoder.bytes(heapLength).raw;
+    const codeLength = decoder.u32();
+    const code = decoder.bytes(codeLength).raw;
+    decoder.finish();
+    const readonlyDataStart = SEGMENT_SIZE;
+    const readonlyDataEnd = SEGMENT_SIZE + alignToPageSize(readOnlyLength);
+    const heapDataStart = 2 * SEGMENT_SIZE + alignToSegmentSize(readOnlyLength);
+    const heapDataEnd = heapDataStart + alignToPageSize(heapLength);
+    const heapZerosEnd = heapDataStart + alignToPageSize(heapLength) + noOfHeapZerosPages * PAGE_SIZE;
+    const stackStart = STACK_SEGMENT - alignToPageSize(stackSize);
+    const stackEnd = STACK_SEGMENT;
+    const argsStart = ARGS_SEGMENT;
+    const argsEnd = argsStart + alignToPageSize(args.length);
+    const argsZerosEnd = argsEnd + alignToPageSize(args.length);
+    function nonEmpty(s) {
+        return s !== false;
+    }
+    const readableMemory = [
+        readOnlyLength > 0 && getMemorySegment(readonlyDataStart, readonlyDataEnd, readOnlyMemory),
+        args.length > 0 && getMemorySegment(argsStart, argsEnd, args),
+        argsEnd < argsZerosEnd && getMemorySegment(argsEnd, argsZerosEnd),
+    ].filter(nonEmpty);
+    const writeableMemory = [
+        heapLength > 0 && getMemorySegment(heapDataStart, heapDataEnd, initialHeap),
+        heapDataEnd < heapZerosEnd && getMemorySegment(heapDataEnd, heapZerosEnd),
+        stackStart < stackEnd && getMemorySegment(stackStart, stackEnd),
+    ].filter(nonEmpty);
+    return new SpiProgram(code, new SpiMemory(readableMemory, writeableMemory, heapZerosEnd, stackStart), getRegisters(args.length));
+}
+function getMemorySegment(start, end, data = null) {
+    return new MemorySegment(start, end, data);
+}
+function getRegisters(argsLength) {
+    const regs = new BigUint64Array(NO_OF_REGISTERS);
+    // GP reference: https://graypaper.fluffylabs.dev/#/579bd12/2c7c012cb101
+    regs[0] = BigInt(LAST_PAGE);
+    regs[1] = BigInt(STACK_SEGMENT);
+    regs[7] = BigInt(ARGS_SEGMENT);
+    regs[8] = BigInt(argsLength);
+    return regs;
+}

package/packages/core/pvm-interpreter/spi-decoder/decode-standard-program.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=decode-standard-program.test.d.ts.map

package/packages/core/pvm-interpreter/spi-decoder/decode-standard-program.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-standard-program.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/spi-decoder/decode-standard-program.test.ts"],"names":[],"mappings":""}

package/packages/core/pvm-interpreter/spi-decoder/decode-standard-program.test.js

@@ -0,0 +1,59 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { decodeStandardProgram, MemorySegment } from "./decode-standard-program.js";
+// E_3(|o|) = 04 00 00
+const O_LENGTH = new Uint8Array([0x04, 0x00, 0x00]);
+// E_3(|w|) = 02 00 00
+const W_LENGTH = new Uint8Array([0x02, 0x00, 0x00]);
+// E_2(z) = 03 00
+const Z = new Uint8Array([0x03, 0x00]);
+// E_3(s) = 20 00 00
+const STACK_SIZE = new Uint8Array([0x20, 0x00, 0x00]);
+// o = AB CD EF 01
+const O = new Uint8Array([0xab, 0xcd, 0xef, 0x01]);
+// w = 12 34
+const W = new Uint8Array([0x12, 0x34]);
+// E_4(|c|) = 06 00 00 00
+const C_LENGTH = new Uint8Array([0x06, 0x00, 0x00, 0x00]);
+// c = 12 34 56 78 9A BC
+const C = new Uint8Array([0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc]);
+const PROGRAM = new Uint8Array([...O_LENGTH, ...W_LENGTH, ...Z, ...STACK_SIZE, ...O, ...W, ...C_LENGTH, ...C]);
+const ARGS = new Uint8Array([0x1, 0x2, 0x3]);
+describe("decodeStandardProgram", () => {
+    const decodedProgram = decodeStandardProgram(PROGRAM, ARGS);
+    it("should exctract code correctly", () => {
+        assert.deepStrictEqual(decodedProgram.code, C);
+    });
+    it("should write args length to 9th register", () => {
+        const registerIndex = 8;
+        assert.strictEqual(decodedProgram.registers[registerIndex], BigInt(ARGS.length));
+    });
+    it("should prepare readable memory segments", () => {
+        const expectedMemory = [
+            {
+                start: 65536,
+                end: 69632,
+                data: O,
+            },
+            {
+                start: 4278124544,
+                end: 4278128640,
+                data: ARGS,
+            },
+            { start: 4278128640, end: 4278132736, data: null },
+        ].map(MemorySegment.from);
+        assert.deepStrictEqual(decodedProgram.memory.readable, expectedMemory);
+    });
+    it("should prepare writeable memory segments", () => {
+        const expectedMemory = [
+            { start: 196608, end: 200704, data: W },
+            { start: 200704, end: 212992, data: null },
+            { start: 4278054912, end: 4278059008, data: null },
+        ].map(MemorySegment.from);
+        assert.deepStrictEqual(decodedProgram.memory.writeable, expectedMemory);
+    });
+    it("sbrkIndex", () => {
+        const expectedSbreak = 212992;
+        assert.strictEqual(decodedProgram.memory.sbrkIndex, expectedSbreak);
+    });
+});

package/packages/core/pvm-interpreter/spi-decoder/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./decode-standard-program.js";
+export * from "./memory-conts.js";
+export * from "./memory-utils.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/spi-decoder/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC"}

package/packages/core/pvm-interpreter/spi-decoder/index.js

@@ -0,0 +1,3 @@
+export * from "./decode-standard-program.js";
+export * from "./memory-conts.js";
+export * from "./memory-utils.js";

package/packages/core/pvm-interpreter/spi-decoder/memory-conts.d.ts

@@ -0,0 +1,7 @@
+export declare const PAGE_SIZE: number;
+export declare const SEGMENT_SIZE: number;
+export declare const DATA_LEGNTH: number;
+export declare const STACK_SEGMENT = 4278059008;
+export declare const ARGS_SEGMENT = 4278124544;
+export declare const LAST_PAGE = 4294901760;
+//# sourceMappingURL=memory-conts.d.ts.map

package/packages/core/pvm-interpreter/spi-decoder/memory-conts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-conts.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/spi-decoder/memory-conts.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,QAAU,CAAC;AACjC,eAAO,MAAM,YAAY,QAAU,CAAC;AACpC,eAAO,MAAM,WAAW,QAAU,CAAC;AACnC,eAAO,MAAM,aAAa,aAAgB,CAAC;AAC3C,eAAO,MAAM,YAAY,aAAgB,CAAC;AAC1C,eAAO,MAAM,SAAS,aAAgB,CAAC"}

package/packages/core/pvm-interpreter/spi-decoder/memory-conts.js

@@ -0,0 +1,7 @@
+// GP reference: https://graypaper.fluffylabs.dev/#/7e6ff6a/2d32002d3200?v=0.6.7
+export const PAGE_SIZE = 2 ** 12; // Z_P from GP
+export const SEGMENT_SIZE = 2 ** 16; // Z_Z from GP
+export const DATA_LEGNTH = 2 ** 24; // Z_I from GP
+export const STACK_SEGMENT = 0xfe_fe_00_00; // 2^32 - 2Z_Z - Z_I from GP
+export const ARGS_SEGMENT = 0xfe_ff_00_00; // 2^32 - Z_Z - Z_I from GP
+export const LAST_PAGE = 0xff_ff_00_00;

package/packages/core/pvm-interpreter/spi-decoder/memory-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function alignToSegmentSize(size: number): number;
+export declare function alignToPageSize(size: number): number;
+//# sourceMappingURL=memory-utils.d.ts.map

package/packages/core/pvm-interpreter/spi-decoder/memory-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-utils.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/spi-decoder/memory-utils.ts"],"names":[],"mappings":"AAIA,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,UAG9C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,UAG3C"}

package/packages/core/pvm-interpreter/spi-decoder/memory-utils.js

@@ -0,0 +1,10 @@
+import { PAGE_SIZE, SEGMENT_SIZE } from "./memory-conts.js";
+// GP reference: https://graypaper.fluffylabs.dev/#/579bd12/2bd2022bd202
+export function alignToSegmentSize(size) {
+    // Q(x) from GP
+    return SEGMENT_SIZE * Math.ceil(size / SEGMENT_SIZE);
+}
+export function alignToPageSize(size) {
+    // P(x) from GP
+    return PAGE_SIZE * Math.ceil(size / PAGE_SIZE);
+}