@typeberry/lib 0.5.10-6cb1bd5 → 0.5.10-7338c21

package/packages/jam/in-core/externalities/refine.test.js

@@ -3,12 +3,15 @@ import { describe, it } from "node:test";
 import { MAX_NUMBER_OF_EXPORTS_WP, SEGMENT_BYTES, tryAsServiceGas, tryAsServiceId, tryAsTimeSlot, } from "#@typeberry/block";
 import { Bytes, BytesBlob } from "#@typeberry/bytes";
 import { HashDictionary } from "#@typeberry/collections";
-import { tinyChainSpec } from "#@typeberry/config";
+import { PvmBackend, tinyChainSpec } from "#@typeberry/config";
 import { HASH_SIZE } from "#@typeberry/hash";
-import { SegmentExportError } from "#@typeberry/jam-host-calls";
+import { SegmentExportError, tryAsMachineId, tryAsProgramCounter } from "#@typeberry/jam-host-calls";
 import { tryAsU32, tryAsU64 } from "#@typeberry/numbers";
+import { HostCallRegisters } from "#@typeberry/pvm-host-calls";
+import { NO_OF_REGISTERS, REGISTER_BYTE_SIZE, Status, tryAsBigGas } from "#@typeberry/pvm-interface";
 import { InMemoryService, InMemoryState, PreimageItem, ServiceAccountInfo } from "#@typeberry/state";
 import { RefineExternalitiesImpl } from "./refine.js";
+const MINIMAL_PROGRAM = new Uint8Array([0, 1, 1, 0, 0x00]);
 function createSegment(byte = 0xab) {
     return Bytes.fill(SEGMENT_BYTES, byte);
 }
@@ -59,9 +62,13 @@ function createExt(overrides = {}) {
         currentServiceId: tryAsServiceId(42),
         lookupState: overrides.lookupState ?? defaultState,
         exportOffset: overrides.exportOffset ?? 0,
+        pvmBackend: PvmBackend.BuiltIn,
         ...overrides,
     });
 }
+function emptyRegisters() {
+    return new HostCallRegisters(new Uint8Array(NO_OF_REGISTERS * REGISTER_BYTE_SIZE));
+}
 describe("RefineExternalitiesImpl", () => {
     describe("historicalLookup", () => {
         const PREIMAGE_HASH = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
@@ -160,4 +167,162 @@ describe("RefineExternalitiesImpl", () => {
             assert.deepStrictEqual(exported[0].raw.subarray(0, 5), new Uint8Array([1, 2, 3, 4, 5]));
         });
     });
+    describe("machineInit", () => {
+        it("should create a new inner PVM and return a machine ID", async () => {
+            const ext = createExt();
+            const code = BytesBlob.blobFrom(MINIMAL_PROGRAM);
+            const pc = tryAsProgramCounter(0);
+            const result = await ext.machineInit(code, pc);
+            assert.strictEqual(result.isOk, true);
+            assert.strictEqual(result.ok, tryAsMachineId(0));
+        });
+        it("should assign sequential machine IDs", async () => {
+            const ext = createExt();
+            const code = BytesBlob.blobFrom(MINIMAL_PROGRAM);
+            const pc = tryAsProgramCounter(0);
+            const r1 = await ext.machineInit(code, pc);
+            const r2 = await ext.machineInit(code, pc);
+            const r3 = await ext.machineInit(code, pc);
+            assert.strictEqual(r1.isOk, true);
+            assert.strictEqual(r1.ok, tryAsMachineId(0));
+            assert.strictEqual(r2.isOk, true);
+            assert.strictEqual(r2.ok, tryAsMachineId(1));
+            assert.strictEqual(r3.isOk, true);
+            assert.strictEqual(r3.ok, tryAsMachineId(2));
+        });
+        it("should return error for invalid program blob", async () => {
+            const ext = createExt();
+            const invalidCode = BytesBlob.blobFrom(new Uint8Array([0xff, 0xff, 0xff]));
+            const pc = tryAsProgramCounter(0);
+            const result = await ext.machineInit(invalidCode, pc);
+            assert.strictEqual(result.isError, true);
+        });
+        it("should return error for empty program blob", async () => {
+            const ext = createExt();
+            const emptyCode = BytesBlob.blobFrom(new Uint8Array([]));
+            const pc = tryAsProgramCounter(0);
+            const result = await ext.machineInit(emptyCode, pc);
+            assert.strictEqual(result.isError, true);
+        });
+        it("should accept a non-zero program counter", async () => {
+            const ext = createExt();
+            const code = BytesBlob.blobFrom(MINIMAL_PROGRAM);
+            const pc = tryAsProgramCounter(1);
+            const result = await ext.machineInit(code, pc);
+            assert.strictEqual(result.isOk, true);
+        });
+    });
+    describe("machineExpunge", () => {
+        it("should remove machine and return its program counter (0)", async () => {
+            const ext = createExt();
+            const code = BytesBlob.blobFrom(MINIMAL_PROGRAM);
+            const initResult = await ext.machineInit(code, tryAsProgramCounter(0));
+            assert.strictEqual(initResult.isOk, true);
+            const machineId = initResult.ok;
+            const result = await ext.machineExpunge(machineId);
+            assert.strictEqual(result.isOk, true);
+            // PC should be 0 since we initialized with PC=0
+            assert.strictEqual(result.ok, tryAsProgramCounter(0));
+        });
+        it("should remove machine and return its program counter (10)", async () => {
+            const ext = createExt();
+            const code = BytesBlob.blobFrom(MINIMAL_PROGRAM);
+            const initResult = await ext.machineInit(code, tryAsProgramCounter(10));
+            assert.strictEqual(initResult.isOk, true);
+            const machineId = initResult.ok;
+            const result = await ext.machineExpunge(machineId);
+            assert.strictEqual(result.isOk, true);
+            // PC should be 10 since we initialized with PC=10
+            assert.strictEqual(result.ok, tryAsProgramCounter(10));
+        });
+        it("should return NoMachineError for non-existent machine", async () => {
+            const ext = createExt();
+            const result = await ext.machineExpunge(tryAsMachineId(999));
+            assert.strictEqual(result.isError, true);
+        });
+        it("should not allow double expunge", async () => {
+            const ext = createExt();
+            const code = BytesBlob.blobFrom(MINIMAL_PROGRAM);
+            const initResult = await ext.machineInit(code, tryAsProgramCounter(0));
+            assert.strictEqual(initResult.isOk, true);
+            const machineId = initResult.ok;
+            const r1 = await ext.machineExpunge(machineId);
+            assert.strictEqual(r1.isOk, true);
+            const r2 = await ext.machineExpunge(machineId);
+            assert.strictEqual(r2.isError, true);
+        });
+        it("should remove exact machine from multiple and return its program counter (10)", async () => {
+            const ext = createExt();
+            const code = BytesBlob.blobFrom(MINIMAL_PROGRAM);
+            await ext.machineInit(code, tryAsProgramCounter(0));
+            const initResult = await ext.machineInit(code, tryAsProgramCounter(10));
+            await ext.machineInit(code, tryAsProgramCounter(20));
+            assert.strictEqual(initResult.isOk, true);
+            const machineId = initResult.ok;
+            const result = await ext.machineExpunge(machineId);
+            assert.strictEqual(result.isOk, true);
+            // PC should be 10 since we initialized with PC=10
+            assert.strictEqual(result.ok, tryAsProgramCounter(10));
+        });
+    });
+    describe("machineInvoke", () => {
+        it("should return NoMachineError for non-existent machine", async () => {
+            const ext = createExt();
+            const regs = emptyRegisters();
+            const result = await ext.machineInvoke(tryAsMachineId(999), tryAsBigGas(1000n), regs);
+            assert.strictEqual(result.isError, true);
+        });
+        it("should execute inner PVM and return PANIC for TRAP instruction", async () => {
+            const ext = createExt();
+            const code = BytesBlob.blobFrom(MINIMAL_PROGRAM);
+            const initResult = await ext.machineInit(code, tryAsProgramCounter(0));
+            assert.strictEqual(initResult.isOk, true);
+            const machineId = initResult.ok;
+            const regs = emptyRegisters();
+            const result = await ext.machineInvoke(machineId, tryAsBigGas(1000n), regs);
+            assert.strictEqual(result.isOk, true);
+            assert.strictEqual(result.ok.result.status, Status.PANIC);
+        });
+        it("should return OOG when gas is exhausted", async () => {
+            const ext = createExt();
+            const code = BytesBlob.blobFrom(MINIMAL_PROGRAM);
+            const initResult = await ext.machineInit(code, tryAsProgramCounter(0));
+            assert.strictEqual(initResult.isOk, true);
+            const machineId = initResult.ok;
+            const regs = emptyRegisters();
+            // With 0 gas, should immediately OOG
+            const result = await ext.machineInvoke(machineId, tryAsBigGas(0n), regs);
+            assert.strictEqual(result.isOk, true);
+            assert.strictEqual(result.ok.result.status, Status.OOG);
+        });
+        it("should pass registers to inner PVM and return them back", async () => {
+            const ext = createExt();
+            const code = BytesBlob.blobFrom(MINIMAL_PROGRAM);
+            const initResult = await ext.machineInit(code, tryAsProgramCounter(0));
+            assert.strictEqual(initResult.isOk, true);
+            const machineId = initResult.ok;
+            const regs = emptyRegisters();
+            regs.set(0, tryAsU64(0xdeadbeefn));
+            regs.set(5, tryAsU64(0xcafebaben));
+            const result = await ext.machineInvoke(machineId, tryAsBigGas(1000n), regs);
+            assert.strictEqual(result.isOk, true);
+            // Registers should be returned (TRAP doesn't modify registers)
+            assert.strictEqual(result.ok.registers.get(0), tryAsU64(0xdeadbeefn));
+            assert.strictEqual(result.ok.registers.get(5), tryAsU64(0xcafebaben));
+        });
+        it("should return remaining gas after execution", async () => {
+            const ext = createExt();
+            const code = BytesBlob.blobFrom(MINIMAL_PROGRAM);
+            const initResult = await ext.machineInit(code, tryAsProgramCounter(0));
+            assert.strictEqual(initResult.isOk, true);
+            const machineId = initResult.ok;
+            const regs = emptyRegisters();
+            const result = await ext.machineInvoke(machineId, tryAsBigGas(1000n), regs);
+            assert.strictEqual(result.isOk, true);
+            // TRAP costs 1 gas, so remaining should be 999
+            const remaining = Number(result.ok.gas);
+            assert.ok(remaining < 1000);
+            assert.ok(remaining >= 0);
+        });
+    });
 });

package/packages/jam/in-core/in-core.d.ts

@@ -1,23 +1,18 @@
-import { type CoreIndex, type Segment, type SegmentIndex, type ServiceGas } from "#@typeberry/block";
+import type { CoreIndex, Segment } from "#@typeberry/block";
 import { type WorkPackageHash } from "#@typeberry/block/refine-context.js";
 import type { WorkItemExtrinsic } from "#@typeberry/block/work-item.js";
 import type { WorkPackage } from "#@typeberry/block/work-package.js";
 import { WorkReport } from "#@typeberry/block/work-report.js";
-import { WorkExecResult, WorkResult } from "#@typeberry/block/work-result.js";
-import { type KnownSizeArray } from "#@typeberry/collections";
 import type { ChainSpec, PvmBackend } from "#@typeberry/config";
 import type { StatesDb } from "#@typeberry/database";
-import { type ReturnValue } from "#@typeberry/executor";
-import { type Blake2b, type WithHash } from "#@typeberry/hash";
+import type { Blake2b, WithHash } from "#@typeberry/hash";
 import { Result } from "#@typeberry/utils";
+import { type ImportedSegment, type PerWorkItem } from "./refine.js";
+export type { ImportedSegment, PerWorkItem, RefineItemResult } from "./refine.js";
 export type RefineResult = {
     report: WorkReport;
     exports: PerWorkItem<Segment[]>;
 };
-export type RefineItemResult = {
-    result: WorkResult;
-    exports: readonly Segment[];
-};
 export declare enum RefineError {
     /** State for context anchor block or lookup anchor is not found in the DB. */
     StateMissing = 0,
@@ -28,16 +23,11 @@ export declare enum RefineError {
     /** Authorization error. */
     AuthorizationError = 3
 }
-export type PerWorkItem<T> = KnownSizeArray<T, "for each work item">;
-export type ImportedSegment = {
-    index: SegmentIndex;
-    data: Segment;
-};
 export declare class InCore {
     readonly chainSpec: ChainSpec;
     private readonly states;
-    private readonly pvmBackend;
-    private readonly blake2b;
+    private readonly isAuthorized;
+    private readonly refineItem;
     constructor(chainSpec: ChainSpec, states: StatesDb, pvmBackend: PvmBackend, blake2b: Blake2b);
     /**
      * Work-report computation function.
@@ -50,11 +40,6 @@ export declare class InCore {
      * https://graypaper.fluffylabs.dev/#/ab2cdbd/1b7f021b7f02?v=0.7.2
      */
     refine(workPackageAndHash: WithHash<WorkPackageHash, WorkPackage>, core: CoreIndex, imports: PerWorkItem<ImportedSegment[]>, extrinsics: PerWorkItem<WorkItemExtrinsic[]>): Promise<Result<RefineResult, RefineError>>;
-    private amalgamateWorkReport;
-    private authorizePackage;
-    private refineItem;
-    extractWorkResult(execResult: ReturnValue<ServiceGas>): WorkExecResult;
-    private getServiceCode;
-    private createRefineExternalities;
+    private static amalgamateWorkReport;
 }
 //# sourceMappingURL=in-core.d.ts.map

package/packages/jam/in-core/in-core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-core.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/in-core/in-core.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,UAAU,EAIhB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAGL,KAAK,eAAe,EAErB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAY,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAmB,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAsC,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAGjH,OAAO,EAA+B,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC1F,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAA+D,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACpH,OAAO,EAAE,KAAK,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAKzE,OAAO,EAA4B,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAGpE,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,SAAS,OAAO,EAAE,CAAC;CAC7B,CAAC;AAEF,oBAAY,WAAW;IACrB,8EAA8E;IAC9E,YAAY,IAAI;IAChB,qFAAqF;IACrF,iBAAiB,IAAI;IACrB,wEAAwE;IACxE,uBAAuB,IAAI;IAC3B,2BAA2B;IAC3B,kBAAkB,IAAI;CACvB;AAqBD,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC;AAErE,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAgBF,qBAAa,MAAM;aAEC,SAAS,EAAE,SAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAHR,SAAS,EAAE,SAAS,EACnB,MAAM,EAAE,QAAQ,EAChB,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,OAAO;IAGnC;;;;;;;;;OASG;IACG,MAAM,CACV,kBAAkB,EAAE,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,EAC1D,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,WAAW,CAAC,eAAe,EAAE,CAAC,EACvC,UAAU,EAAE,WAAW,CAAC,iBAAiB,EAAE,CAAC,GAC3C,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;IAgF7C,OAAO,CAAC,oBAAoB;YAuDd,gBAAgB;YAkBhB,UAAU;IAoGxB,iBAAiB,CAAC,UAAU,EAAE,WAAW,CAAC,UAAU,CAAC;IAiBrD,OAAO,CAAC,cAAc;IAyCtB,OAAO,CAAC,yBAAyB;CA2BlC"}
+{"version":3,"file":"in-core.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/in-core/in-core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAsB,KAAK,eAAe,EAAmB,MAAM,oCAAoC,CAAC;AAC/G,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAmB,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAG9E,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAIzD,OAAO,EAAe,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAiC,MAAM,aAAa,CAAC;AAEpG,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAElF,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC;CACjC,CAAC;AAEF,oBAAY,WAAW;IACrB,8EAA8E;IAC9E,YAAY,IAAI;IAChB,qFAAqF;IACrF,iBAAiB,IAAI;IACrB,wEAAwE;IACxE,uBAAuB,IAAI;IAC3B,2BAA2B;IAC3B,kBAAkB,IAAI;CACvB;AAID,qBAAa,MAAM;aAKC,SAAS,EAAE,SAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IALzB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAGlB,SAAS,EAAE,SAAS,EACnB,MAAM,EAAE,QAAQ,EACjC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,OAAO;IAMlB;;;;;;;;;OASG;IACG,MAAM,CACV,kBAAkB,EAAE,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,EAC1D,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,WAAW,CAAC,eAAe,EAAE,CAAC,EACvC,UAAU,EAAE,WAAW,CAAC,iBAAiB,EAAE,CAAC,GAC3C,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;IAwF7C,OAAO,CAAC,MAAM,CAAC,oBAAoB;CAsDpC"}

package/packages/jam/in-core/in-core.js

@@ -1,18 +1,13 @@
-import { tryAsCoreIndex, tryAsServiceGas, } from "#@typeberry/block";
-import { W_C } from "#@typeberry/block/gp-constants.js";
-import { WorkPackageInfo, } from "#@typeberry/block/refine-context.js";
+import { WorkPackageInfo } from "#@typeberry/block/refine-context.js";
 import { WorkPackageSpec, WorkReport } from "#@typeberry/block/work-report.js";
-import { WorkExecResult, WorkExecResultKind, WorkRefineLoad, WorkResult } from "#@typeberry/block/work-result.js";
-import { Bytes, BytesBlob } from "#@typeberry/bytes";
-import { codec, Encoder } from "#@typeberry/codec";
+import { Bytes } from "#@typeberry/bytes";
 import { asKnownSize, FixedSizeArray } from "#@typeberry/collections";
-import { PvmExecutor, ReturnStatus } from "#@typeberry/executor";
 import { HASH_SIZE } from "#@typeberry/hash";
 import { Logger } from "#@typeberry/logger";
 import { tryAsU8, tryAsU16, tryAsU32 } from "#@typeberry/numbers";
-import { FetchExternalities } from "#@typeberry/transition/externalities/fetch-externalities.js";
-import { assertEmpty, assertNever, Result } from "#@typeberry/utils";
-import { RefineExternalitiesImpl } from "./externalities/refine.js";
+import { assertEmpty, Result } from "#@typeberry/utils";
+import { AuthorizationError, IsAuthorized } from "./is-authorized.js";
+import { Refine } from "./refine.js";
 export var RefineError;
 (function (RefineError) {
     /** State for context anchor block or lookup anchor is not found in the DB. */
@@ -24,39 +19,17 @@ export var RefineError;
     /** Authorization error. */
     RefineError[RefineError["AuthorizationError"] = 3] = "AuthorizationError";
 })(RefineError || (RefineError = {}));
-var ServiceCodeError;
-(function (ServiceCodeError) {
-    /** Service id is not found in the state. */
-    ServiceCodeError[ServiceCodeError["ServiceNotFound"] = 0] = "ServiceNotFound";
-    /** Expected service code does not match the state one. */
-    ServiceCodeError[ServiceCodeError["ServiceCodeMismatch"] = 1] = "ServiceCodeMismatch";
-    /** Code preimage missing. */
-    ServiceCodeError[ServiceCodeError["ServiceCodeMissing"] = 2] = "ServiceCodeMissing";
-    /** Code blob is too big. */
-    ServiceCodeError[ServiceCodeError["ServiceCodeTooBig"] = 3] = "ServiceCodeTooBig";
-})(ServiceCodeError || (ServiceCodeError = {}));
-var AuthorizationError;
-(function (AuthorizationError) {
-})(AuthorizationError || (AuthorizationError = {}));
 const logger = Logger.new(import.meta.filename, "refine");
-/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2ffe002ffe00?v=0.7.2 */
-const ARGS_CODEC = codec.object({
-    core: codec.varU32.convert((x) => tryAsU32(x), (x) => tryAsCoreIndex(x)),
-    workItemIndex: codec.varU32,
-    serviceId: codec.varU32.asOpaque(),
-    payloadLength: codec.varU32,
-    packageHash: codec.bytes(HASH_SIZE).asOpaque(),
-});
 export class InCore {
     chainSpec;
     states;
-    pvmBackend;
-    blake2b;
+    isAuthorized;
+    refineItem;
     constructor(chainSpec, states, pvmBackend, blake2b) {
         this.chainSpec = chainSpec;
         this.states = states;
-        this.pvmBackend = pvmBackend;
-        this.blake2b = blake2b;
+        this.isAuthorized = new IsAuthorized(chainSpec, pvmBackend, blake2b);
+        this.refineItem = new Refine(chainSpec, pvmBackend, blake2b);
     }
     /**
      * Work-report computation function.
@@ -70,13 +43,14 @@ export class InCore {
      */
     async refine(workPackageAndHash, core, imports, extrinsics) {
         const workPackageHash = workPackageAndHash.hash;
-        const { context, authorization, authCodeHash, authCodeHost, parametrization, items, ...rest } = workPackageAndHash.data;
+        const { context, authToken, authCodeHash, authCodeHost, authConfiguration, items, ...rest } = workPackageAndHash.data;
         assertEmpty(rest);
         // TODO [ToDr] Verify BEEFY root
         // TODO [ToDr] Verify prerequisites
         logger.log `[core:${core}] Attempting to refine work package with ${items.length} items.`;
-        // TODO [ToDr] GP link
         // Verify anchor block
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/15cd0215cd02?v=0.7.2
+        // TODO [ToDr] Validation
         const state = this.states.getState(context.anchor);
         if (state === null) {
             return Result.error(RefineError.StateMissing, () => `State at anchor block ${context.anchor} is missing.`);
@@ -96,7 +70,7 @@ export class InCore {
             return Result.error(RefineError.InvalidLookupAnchorSlot, () => `Lookup anchor slot does not match the one is state. Ours: ${lookupState.timeslot}, expected: ${context.lookupAnchorSlot}`);
         }
         // Check authorization
-        const authResult = await this.authorizePackage(authorization, authCodeHost, authCodeHash, parametrization);
+        const authResult = await this.isAuthorized.invoke(state, core, authToken, authCodeHost, authCodeHash, authConfiguration);
         if (authResult.isError) {
             return Result.error(RefineError.AuthorizationError, () => `Authorization error: ${AuthorizationError[authResult.error]}: ${authResult.details()}.`);
         }
@@ -106,14 +80,14 @@ export class InCore {
         const refineResults = [];
         for (const [idx, item] of items.entries()) {
             logger.info `[core:${core}][i:${idx}] Refining item for service ${item.service}.`;
-            const result = await this.refineItem(state, lookupState, idx, item, imports, extrinsics, core, workPackageHash, exportOffset);
+            const result = await this.refineItem.invoke(state, lookupState, idx, item, imports, extrinsics, core, workPackageHash, exportOffset);
             refineResults.push(result);
             exportOffset += result.exports.length;
         }
         // amalgamate the work report now
-        return Result.ok(this.amalgamateWorkReport(asKnownSize(refineResults), authResult.ok, workPackageHash, context, core));
+        return Result.ok(InCore.amalgamateWorkReport(asKnownSize(refineResults), authResult.ok, workPackageHash, context, core));
     }
-    amalgamateWorkReport(refineResults, authResult, workPackageHash, context, coreIndex) {
+    static amalgamateWorkReport(refineResults, authResult, workPackageHash, context, coreIndex) {
         // unzip exports and work results for each work item
         const exports = refineResults.map((x) => x.exports);
         const results = refineResults.map((x) => x.result);
@@ -156,148 +130,4 @@ export class InCore {
             exports: asKnownSize(exports),
         };
     }
-    async authorizePackage(_authorization, _authCodeHost, _authCodeHash, _parametrization) {
-        // TODO [ToDr] Check authorization?
-        const authorizerHash = Bytes.zero(HASH_SIZE).asOpaque();
-        const authorizationGasUsed = tryAsServiceGas(0);
-        const authorizationOutput = BytesBlob.empty();
-        return Result.ok({
-            authorizerHash,
-            authorizationGasUsed,
-            authorizationOutput,
-        });
-    }
-    async refineItem(state, lookupState, idx, item, allImports, allExtrinsics, coreIndex, workPackageHash, exportOffset) {
-        const payloadHash = this.blake2b.hashBytes(item.payload);
-        const baseResult = {
-            serviceId: item.service,
-            codeHash: item.codeHash,
-            payloadHash,
-            gas: item.refineGasLimit,
-        };
-        const imports = allImports[idx];
-        const extrinsics = allExtrinsics[idx];
-        const baseLoad = {
-            importedSegments: tryAsU32(imports.length),
-            extrinsicCount: tryAsU32(extrinsics.length),
-            extrinsicSize: tryAsU32(extrinsics.reduce((acc, x) => acc + x.length, 0)),
-        };
-        const maybeCode = this.getServiceCode(state, idx, item);
-        if (maybeCode.isError) {
-            const error = maybeCode.error === ServiceCodeError.ServiceCodeTooBig
-                ? WorkExecResultKind.codeOversize
-                : WorkExecResultKind.badCode;
-            return {
-                exports: [],
-                result: WorkResult.create({
-                    ...baseResult,
-                    result: WorkExecResult.error(error),
-                    load: WorkRefineLoad.create({
-                        ...baseLoad,
-                        gasUsed: tryAsServiceGas(item.refineGasLimit),
-                        exportedSegments: tryAsU32(0),
-                    }),
-                }),
-            };
-        }
-        const code = maybeCode.ok;
-        const externalities = this.createRefineExternalities({
-            payload: item.payload,
-            imports: allImports,
-            extrinsics: allExtrinsics,
-            currentServiceId: item.service,
-            lookupState,
-            exportOffset,
-        });
-        const executor = await PvmExecutor.createRefineExecutor(item.service, code, externalities, this.pvmBackend);
-        const args = Encoder.encodeObject(ARGS_CODEC, {
-            serviceId: item.service,
-            core: coreIndex,
-            workItemIndex: tryAsU32(idx),
-            payloadLength: tryAsU32(item.payload.length),
-            packageHash: workPackageHash,
-        });
-        const execResult = await executor.run(args, item.refineGasLimit);
-        const exports = externalities.refine.getExportedSegments();
-        if (exports.length !== item.exportCount) {
-            return {
-                exports,
-                result: WorkResult.create({
-                    ...baseResult,
-                    result: WorkExecResult.error(WorkExecResultKind.incorrectNumberOfExports),
-                    load: WorkRefineLoad.create({
-                        ...baseLoad,
-                        gasUsed: tryAsServiceGas(item.refineGasLimit),
-                        exportedSegments: tryAsU32(0),
-                    }),
-                }),
-            };
-        }
-        const result = this.extractWorkResult(execResult);
-        return {
-            exports,
-            result: WorkResult.create({
-                ...baseResult,
-                result,
-                load: WorkRefineLoad.create({
-                    ...baseLoad,
-                    gasUsed: tryAsServiceGas(execResult.consumedGas),
-                    exportedSegments: tryAsU32(exports.length),
-                }),
-            }),
-        };
-    }
-    extractWorkResult(execResult) {
-        if (execResult.status === ReturnStatus.OK) {
-            const slice = execResult.memorySlice;
-            // TODO [ToDr] Verify the output size and change digestTooBig?
-            return WorkExecResult.ok(BytesBlob.blobFrom(slice));
-        }
-        switch (execResult.status) {
-            case ReturnStatus.OOG:
-                return WorkExecResult.error(WorkExecResultKind.outOfGas);
-            case ReturnStatus.PANIC:
-                return WorkExecResult.error(WorkExecResultKind.panic);
-            default:
-                assertNever(execResult);
-        }
-    }
-    getServiceCode(state, idx, item) {
-        const serviceId = item.service;
-        const service = state.getService(serviceId);
-        // TODO [ToDr] GP link
-        // missing service
-        if (service === null) {
-            return Result.error(ServiceCodeError.ServiceNotFound, () => `[i:${idx}] Service ${serviceId} is missing in state.`);
-        }
-        // TODO [ToDr] GP link
-        // TODO [ToDr] shall we rather use the old codehash instead
-        if (!service.getInfo().codeHash.isEqualTo(item.codeHash)) {
-            return Result.error(ServiceCodeError.ServiceCodeMismatch, () => `[i:${idx}] Service ${serviceId} has invalid code hash. Ours: ${service.getInfo().codeHash}, expected: ${item.codeHash}`);
-        }
-        const code = service.getPreimage(item.codeHash.asOpaque());
-        if (code === null) {
-            return Result.error(ServiceCodeError.ServiceCodeMissing, () => `[i:${idx}] Code ${item.codeHash} for service ${serviceId} was not found.`);
-        }
-        if (code.length > W_C) {
-            return Result.error(ServiceCodeError.ServiceCodeTooBig, () => `[i:${idx}] Code ${item.codeHash} for service ${serviceId} is too big! ${code.length} bytes vs ${W_C} bytes max.`);
-        }
-        return Result.ok(code);
-    }
-    createRefineExternalities(args) {
-        // TODO [ToDr] Pass all required fetch data
-        const fetchExternalities = FetchExternalities.createForRefine({
-            entropy: undefined,
-            ...args,
-        }, this.chainSpec);
-        const refine = RefineExternalitiesImpl.create({
-            currentServiceId: args.currentServiceId,
-            lookupState: args.lookupState,
-            exportOffset: args.exportOffset,
-        });
-        return {
-            fetchExternalities,
-            refine,
-        };
-    }
 }

package/packages/jam/in-core/in-core.test.js

@@ -1,4 +1,6 @@
 import assert from "node:assert";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { before, describe, it } from "node:test";
 import { tryAsCoreIndex, tryAsServiceGas, tryAsServiceId, tryAsTimeSlot } from "#@typeberry/block";
 import { RefineContext } from "#@typeberry/block/refine-context.js";
@@ -6,21 +8,46 @@ import { WorkItem } from "#@typeberry/block/work-item.js";
 import { tryAsWorkItemsCount, WorkPackage } from "#@typeberry/block/work-package.js";
 import { Bytes, BytesBlob } from "#@typeberry/bytes";
 import { Encoder } from "#@typeberry/codec";
-import { asKnownSize, FixedSizeArray } from "#@typeberry/collections";
+import { asKnownSize, FixedSizeArray, HashDictionary } from "#@typeberry/collections";
 import { PvmBackend, tinyChainSpec } from "#@typeberry/config";
 import { InMemoryStates } from "#@typeberry/database";
 import { Blake2b, HASH_SIZE, WithHash } from "#@typeberry/hash";
-import { tryAsU16 } from "#@typeberry/numbers";
-import { testState } from "#@typeberry/state/test.utils.js";
+import { tryAsU16, tryAsU32, tryAsU64 } from "#@typeberry/numbers";
+import { InMemoryService, InMemoryState, PreimageItem, ServiceAccountInfo } from "#@typeberry/state";
 import { InCore, RefineError } from "./in-core.js";
+// Load the authorizer PVM fixture (checks authToken === authConfiguration).
+const AUTHORIZER_PVM = BytesBlob.blobFrom(readFileSync(resolve(import.meta.dirname, "fixtures/authorizer.pvm")));
+const AUTH_SERVICE_ID = tryAsServiceId(1);
 let blake2b;
 before(async () => {
     blake2b = await Blake2b.createHasher();
 });
-function createWorkItem(serviceId = 1) {
+function getAuthCodeHash() {
+    return blake2b.hashBytes(AUTHORIZER_PVM).asOpaque();
+}
+function createService(serviceId, codeHash, code) {
+    return new InMemoryService(serviceId, {
+        info: ServiceAccountInfo.create({
+            codeHash: codeHash.asOpaque(),
+            balance: tryAsU64(10_000_000_000),
+            accumulateMinGas: tryAsServiceGas(0n),
+            onTransferMinGas: tryAsServiceGas(0n),
+            storageUtilisationBytes: tryAsU64(0),
+            storageUtilisationCount: tryAsU32(0),
+            gratisStorage: tryAsU64(0),
+            created: tryAsTimeSlot(0),
+            lastAccumulation: tryAsTimeSlot(0),
+            parentService: tryAsServiceId(0),
+        }),
+        preimages: HashDictionary.fromEntries([PreimageItem.create({ hash: codeHash.asOpaque(), blob: code })].map((x) => [x.hash, x])),
+        lookupHistory: HashDictionary.fromEntries([]),
+        storage: new Map(),
+    });
+}
+function createWorkItem(codeHash, serviceId = 1) {
     return WorkItem.create({
         service: tryAsServiceId(serviceId),
-        codeHash: Bytes.zero(HASH_SIZE).asOpaque(),
+        codeHash,
         payload: BytesBlob.empty(),
         refineGasLimit: tryAsServiceGas(1_000_000),
         accumulateGasLimit: tryAsServiceGas(1_000_000),
@@ -29,12 +56,12 @@ function createWorkItem(serviceId = 1) {
         exportCount: tryAsU16(0),
     });
 }
-function createWorkPackage(anchorHash, stateRoot, lookupAnchorSlot = 0) {
+function createWorkPackage(anchorHash, stateRoot, authCodeHash, lookupAnchorSlot = 0) {
     return WorkPackage.create({
-        authorization: BytesBlob.empty(),
-        authCodeHost: tryAsServiceId(1),
-        authCodeHash: Bytes.zero(HASH_SIZE).asOpaque(),
-        parametrization: BytesBlob.empty(),
+        authToken: BytesBlob.empty(),
+        authCodeHost: AUTH_SERVICE_ID,
+        authCodeHash,
+        authConfiguration: BytesBlob.empty(),
         context: RefineContext.create({
             anchor: anchorHash,
             stateRoot,
@@ -43,7 +70,7 @@ function createWorkPackage(anchorHash, stateRoot, lookupAnchorSlot = 0) {
             lookupAnchorSlot: tryAsTimeSlot(lookupAnchorSlot),
             prerequisites: [],
         }),
-        items: FixedSizeArray.new([createWorkItem()], tryAsWorkItemsCount(1)),
+        items: FixedSizeArray.new([createWorkItem(authCodeHash)], tryAsWorkItemsCount(1)),
     });
 }
 function hashWorkPackage(spec, workPackage) {
@@ -59,7 +86,8 @@ describe("InCore", () => {
         const inCore = new InCore(spec, states, PvmBackend.BuiltIn, blake2b);
         const anchorHash = Bytes.fill(HASH_SIZE, 1).asOpaque();
         const stateRoot = Bytes.zero(HASH_SIZE).asOpaque();
-        const workPackage = createWorkPackage(anchorHash, stateRoot);
+        const authCodeHash = getAuthCodeHash();
+        const workPackage = createWorkPackage(anchorHash, stateRoot, authCodeHash);
         const result = await inCore.refine(hashWorkPackage(spec, workPackage), tryAsCoreIndex(0), asKnownSize([[]]), asKnownSize([[]]));
         assert.strictEqual(result.isError, true);
         assert.strictEqual(result.error, RefineError.StateMissing);
@@ -68,13 +96,17 @@ describe("InCore", () => {
         const spec = tinyChainSpec;
         const states = new InMemoryStates(spec);
         const inCore = new InCore(spec, states, PvmBackend.BuiltIn, blake2b);
+        const authCodeHash = getAuthCodeHash();
         const anchorHash = Bytes.fill(HASH_SIZE, 1).asOpaque();
-        const state = testState();
+        const state = InMemoryState.partial(spec, {
+            timeslot: tryAsTimeSlot(16),
+            services: new Map([[AUTH_SERVICE_ID, createService(AUTH_SERVICE_ID, authCodeHash, AUTHORIZER_PVM)]]),
+        });
         await states.insertInitialState(anchorHash, state);
         const correctStateRoot = await states.getStateRoot(state);
-        const workPackage = createWorkPackage(anchorHash, correctStateRoot, state.timeslot);
+        const workPackage = createWorkPackage(anchorHash, correctStateRoot, authCodeHash, state.timeslot);
         const result = await inCore.refine(hashWorkPackage(spec, workPackage), tryAsCoreIndex(0), asKnownSize([[]]), asKnownSize([[]]));
-        assert.strictEqual(result.isOk, true);
+        assert.strictEqual(result.isOk, true, `Expected OK but got error: ${result.isError ? result.details() : ""}`);
         assert.strictEqual(result.ok.report.coreIndex, 0);
         assert.strictEqual(result.ok.report.results.length, 1);
     });