@typeberry/lib 0.5.11-10b197e → 0.5.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typeberry/lib",
-  "version": "0.5.11-10b197e",
+  "version": "0.5.11",
   "description": "Typeberry Library",
   "main": "./bin/lib/index.js",
   "types": "./bin/lib/index.d.ts",

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

@@ -0,0 +1,4 @@
+export * from "./is-authorized-fetch.js";
+export * from "./refine.js";
+export * from "./refine-fetch.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/in-core/externalities/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from "./is-authorized-fetch.js";
+export * from "./refine.js";
+export * from "./refine-fetch.js";

package/packages/jam/{transition/externalities/is-authorized-fetch-externalities.d.ts → in-core/externalities/is-authorized-fetch.d.ts}

@@ -1,22 +1,20 @@
-import { BytesBlob } from "#@typeberry/bytes";
+import type { BytesBlob } from "#@typeberry/bytes";
 import type { ChainSpec } from "#@typeberry/config";
 import { general } from "#@typeberry/jam-host-calls";
 import type { U64 } from "#@typeberry/numbers";
+import { type WorkPackageFetchData } from "#@typeberry/transition/externalities/fetch-externalities.js";
 export declare class IsAuthorizedFetchExternalities implements general.IIsAuthorizedFetch {
     private readonly chainSpec;
-    private readonly params;
+    private readonly pkg;
     readonly context = general.FetchContext.IsAuthorized;
-    constructor(chainSpec: ChainSpec, params: {
-        authToken: BytesBlob;
-        authConfiguration: BytesBlob;
-    });
+    constructor(chainSpec: ChainSpec, pkg: WorkPackageFetchData);
     constants(): BytesBlob;
     workPackage(): BytesBlob;
     authConfiguration(): BytesBlob;
     authToken(): BytesBlob;
     refineContext(): BytesBlob;
     allWorkItems(): BytesBlob;
-    oneWorkItem(_workItem: U64): BytesBlob | null;
-    workItemPayload(_workItem: U64): BytesBlob | null;
+    oneWorkItem(workItem: U64): BytesBlob | null;
+    workItemPayload(workItem: U64): BytesBlob | null;
 }
-//# sourceMappingURL=is-authorized-fetch-externalities.d.ts.map
+//# sourceMappingURL=is-authorized-fetch.d.ts.map

package/packages/jam/in-core/externalities/is-authorized-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-authorized-fetch.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/in-core/externalities/is-authorized-fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACpD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,4DAA4D,CAAC;AAEpE,qBAAa,8BAA+B,YAAW,OAAO,CAAC,kBAAkB;IAI7E,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,GAAG;IAJtB,QAAQ,CAAC,OAAO,qCAAqC;gBAGlC,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,oBAAoB;IAG5C,SAAS,IAAI,SAAS;IAItB,WAAW,IAAI,SAAS;IAIxB,iBAAiB,IAAI,SAAS;IAI9B,SAAS,IAAI,SAAS;IAItB,aAAa,IAAI,SAAS;IAI1B,YAAY,IAAI,SAAS;IAIzB,WAAW,CAAC,QAAQ,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI;IAK5C,eAAe,CAAC,QAAQ,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI;CAQjD"}

package/packages/jam/in-core/externalities/is-authorized-fetch.js

@@ -0,0 +1,41 @@
+import { general } from "#@typeberry/jam-host-calls";
+import { getEncodedConstants, u64ToArrayIndex, } from "#@typeberry/transition/externalities/fetch-externalities.js";
+export class IsAuthorizedFetchExternalities {
+    chainSpec;
+    pkg;
+    context = general.FetchContext.IsAuthorized;
+    constructor(chainSpec, pkg) {
+        this.chainSpec = chainSpec;
+        this.pkg = pkg;
+    }
+    constants() {
+        return getEncodedConstants(this.chainSpec);
+    }
+    workPackage() {
+        return this.pkg.packageView.encoded();
+    }
+    authConfiguration() {
+        return this.pkg.packageView.authConfiguration.view();
+    }
+    authToken() {
+        return this.pkg.packageView.authToken.view();
+    }
+    refineContext() {
+        return this.pkg.packageView.context.encoded();
+    }
+    allWorkItems() {
+        return this.pkg.workItemSummaries.encoded();
+    }
+    oneWorkItem(workItem) {
+        const idx = u64ToArrayIndex(workItem, this.pkg.workItemSummaries.length);
+        return idx === null ? null : (this.pkg.workItemSummaries.get(idx)?.encoded() ?? null);
+    }
+    workItemPayload(workItem) {
+        const items = this.pkg.packageView.items.view();
+        const idx = u64ToArrayIndex(workItem, items.length);
+        if (idx === null) {
+            return null;
+        }
+        return items.get(idx)?.view().payload.view() ?? null;
+    }
+}

package/packages/jam/in-core/externalities/is-authorized-fetch.test.d.ts

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

package/packages/jam/in-core/externalities/is-authorized-fetch.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-authorized-fetch.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/in-core/externalities/is-authorized-fetch.test.ts"],"names":[],"mappings":""}

package/packages/jam/in-core/externalities/is-authorized-fetch.test.js

@@ -0,0 +1,101 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsServiceGas, tryAsServiceId, tryAsTimeSlot } from "#@typeberry/block";
+import { RefineContext } from "#@typeberry/block/refine-context.js";
+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 { fullChainSpec, tinyChainSpec } from "#@typeberry/config";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { tryAsU16, tryAsU64 } from "#@typeberry/numbers";
+import { buildWorkPackageFetchData } from "#@typeberry/transition/externalities/fetch-externalities.js";
+import { IsAuthorizedFetchExternalities } from "./is-authorized-fetch.js";
+function fetchDataFor(pkg, chainSpec = tinyChainSpec) {
+    return buildWorkPackageFetchData(chainSpec, pkg);
+}
+function buildWorkItem(overrides = {}) {
+    return WorkItem.create({
+        service: tryAsServiceId(overrides.service ?? 1),
+        codeHash: Bytes.fill(HASH_SIZE, 7).asOpaque(),
+        payload: BytesBlob.blobFrom(new Uint8Array(overrides.payloadLen ?? 3).fill(0xab)),
+        refineGasLimit: tryAsServiceGas(1_000_000),
+        accumulateGasLimit: tryAsServiceGas(2_000_000),
+        importSegments: asKnownSize([]),
+        extrinsic: [],
+        exportCount: tryAsU16(0),
+    });
+}
+function buildPackage(items = [buildWorkItem({})]) {
+    return WorkPackage.create({
+        authToken: BytesBlob.blobFrom(new Uint8Array([1, 2, 3])),
+        authCodeHost: tryAsServiceId(42),
+        authCodeHash: Bytes.fill(HASH_SIZE, 9).asOpaque(),
+        authConfiguration: BytesBlob.blobFrom(new Uint8Array([4, 5, 6, 7])),
+        context: RefineContext.create({
+            anchor: Bytes.fill(HASH_SIZE, 1).asOpaque(),
+            stateRoot: Bytes.fill(HASH_SIZE, 2).asOpaque(),
+            beefyRoot: Bytes.fill(HASH_SIZE, 3).asOpaque(),
+            lookupAnchor: Bytes.fill(HASH_SIZE, 4).asOpaque(),
+            lookupAnchorSlot: tryAsTimeSlot(16),
+            prerequisites: [],
+        }),
+        items: FixedSizeArray.new(items, tryAsWorkItemsCount(items.length)),
+    });
+}
+describe("IsAuthorizedFetchExternalities", () => {
+    it("returns different constants for different chain specs", () => {
+        const tinyExt = new IsAuthorizedFetchExternalities(tinyChainSpec, fetchDataFor(buildPackage(), tinyChainSpec));
+        const fullExt = new IsAuthorizedFetchExternalities(fullChainSpec, fetchDataFor(buildPackage(), fullChainSpec));
+        assert.notStrictEqual(tinyExt.constants().length, 0);
+        assert.notDeepStrictEqual(tinyExt.constants(), fullExt.constants());
+    });
+    it("returns encoded work package", () => {
+        const pkg = buildPackage();
+        const ext = new IsAuthorizedFetchExternalities(tinyChainSpec, fetchDataFor(pkg));
+        const expected = Encoder.encodeObject(WorkPackage.Codec, pkg, tinyChainSpec);
+        assert.deepStrictEqual(ext.workPackage().raw, expected.raw);
+    });
+    it("returns auth configuration and auth token from the package", () => {
+        const ext = new IsAuthorizedFetchExternalities(tinyChainSpec, fetchDataFor(buildPackage()));
+        assert.deepStrictEqual(ext.authConfiguration().raw, new Uint8Array([4, 5, 6, 7]));
+        assert.deepStrictEqual(ext.authToken().raw, new Uint8Array([1, 2, 3]));
+    });
+    it("returns encoded refine context", () => {
+        const pkg = buildPackage();
+        const ext = new IsAuthorizedFetchExternalities(tinyChainSpec, fetchDataFor(pkg));
+        const expected = Encoder.encodeObject(RefineContext.Codec, pkg.context);
+        assert.deepStrictEqual(ext.refineContext().raw, expected.raw);
+    });
+    it("returns concatenated work item summaries with 62 bytes per item", () => {
+        const items = [buildWorkItem({ service: 1 }), buildWorkItem({ service: 2, payloadLen: 5 })];
+        const ext = new IsAuthorizedFetchExternalities(tinyChainSpec, fetchDataFor(buildPackage(items)));
+        assert.strictEqual(ext.allWorkItems().length, 62 * items.length);
+    });
+    it("returns a single work item summary (kind 12)", () => {
+        const items = [buildWorkItem({ service: 1 }), buildWorkItem({ service: 2, payloadLen: 10 })];
+        const ext = new IsAuthorizedFetchExternalities(tinyChainSpec, fetchDataFor(buildPackage(items)));
+        const one = ext.oneWorkItem(tryAsU64(1));
+        assert.ok(one !== null);
+        assert.strictEqual(one.length, 62);
+        const serviceId = new DataView(one.raw.buffer, one.raw.byteOffset, 4).getUint32(0, true);
+        assert.strictEqual(serviceId, 2);
+    });
+    it("returns null for one work item when index is out of range", () => {
+        const ext = new IsAuthorizedFetchExternalities(tinyChainSpec, fetchDataFor(buildPackage()));
+        assert.strictEqual(ext.oneWorkItem(tryAsU64(99)), null);
+    });
+    it("returns the raw payload of a work item (kind 13)", () => {
+        const items = [buildWorkItem({ service: 1, payloadLen: 2 }), buildWorkItem({ service: 2, payloadLen: 5 })];
+        const ext = new IsAuthorizedFetchExternalities(tinyChainSpec, fetchDataFor(buildPackage(items)));
+        const payload = ext.workItemPayload(tryAsU64(1));
+        assert.ok(payload !== null);
+        assert.strictEqual(payload.length, 5);
+        assert.ok(payload.raw.every((x) => x === 0xab));
+    });
+    it("returns null for payload when index is out of range", () => {
+        const ext = new IsAuthorizedFetchExternalities(tinyChainSpec, fetchDataFor(buildPackage()));
+        assert.strictEqual(ext.workItemPayload(tryAsU64(99)), null);
+    });
+});

package/packages/jam/in-core/externalities/refine-fetch.d.ts

@@ -0,0 +1,51 @@
+import type { EntropyHash, Segment, SegmentIndex } from "#@typeberry/block";
+import type { WorkItemExtrinsic } from "#@typeberry/block/work-item.js";
+import { type BytesBlob } from "#@typeberry/bytes";
+import type { KnownSizeArray } from "#@typeberry/collections";
+import type { ChainSpec } from "#@typeberry/config";
+import { general } from "#@typeberry/jam-host-calls";
+import type { U64 } from "#@typeberry/numbers";
+import { type WorkPackageFetchData } from "#@typeberry/transition/externalities/fetch-externalities.js";
+/** A single decoded import segment passed into refine. */
+export type ImportedSegment = {
+    index: SegmentIndex;
+    data: Segment;
+};
+/** An array whose length matches the work-package's work-item count. */
+export type PerWorkItem<T> = KnownSizeArray<T, "for each work item">;
+export type RefineFetchData = {
+    /** Pre-computed per-work-package encodings. */
+    packageData: WorkPackageFetchData;
+    /** Index of the work item currently being refined (`i` in GP). */
+    currentWorkItemIndex: number;
+    /** Imports per work item (`ī`). */
+    imports: PerWorkItem<ImportedSegment[]>;
+    /** Extrinsics per work item (`x̄`). */
+    extrinsics: PerWorkItem<WorkItemExtrinsic[]>;
+    /** Authorizer trace produced by Is-Authorized (`r`). */
+    authorizerTrace: BytesBlob;
+};
+export declare class RefineFetchExternalities implements general.IRefineFetch {
+    private readonly chainSpec;
+    private readonly data;
+    readonly context = general.FetchContext.Refine;
+    constructor(chainSpec: ChainSpec, data: RefineFetchData);
+    constants(): BytesBlob;
+    /**
+     * Refine entropy is `H₀` (zero hash) per GP §B.3.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/2fe0012fe201?v=0.7.2
+     */
+    entropy(): EntropyHash;
+    authorizerTrace(): BytesBlob;
+    workItemExtrinsic(workItem: U64 | null, index: U64): BytesBlob | null;
+    workItemImport(workItem: U64 | null, index: U64): BytesBlob | null;
+    workPackage(): BytesBlob;
+    authConfiguration(): BytesBlob;
+    authToken(): BytesBlob;
+    refineContext(): BytesBlob;
+    allWorkItems(): BytesBlob;
+    oneWorkItem(workItem: U64): BytesBlob | null;
+    workItemPayload(workItem: U64): BytesBlob | null;
+}
+//# sourceMappingURL=refine-fetch.d.ts.map

package/packages/jam/in-core/externalities/refine-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refine-fetch.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/in-core/externalities/refine-fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAS,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACpD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,4DAA4D,CAAC;AAEpE,0DAA0D;AAC1D,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,wEAAwE;AACxE,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC;AAErE,MAAM,MAAM,eAAe,GAAG;IAC5B,+CAA+C;IAC/C,WAAW,EAAE,oBAAoB,CAAC;IAClC,kEAAkE;IAClE,oBAAoB,EAAE,MAAM,CAAC;IAC7B,mCAAmC;IACnC,OAAO,EAAE,WAAW,CAAC,eAAe,EAAE,CAAC,CAAC;IACxC,uCAAuC;IACvC,UAAU,EAAE,WAAW,CAAC,iBAAiB,EAAE,CAAC,CAAC;IAC7C,wDAAwD;IACxD,eAAe,EAAE,SAAS,CAAC;CAC5B,CAAC;AAEF,qBAAa,wBAAyB,YAAW,OAAO,CAAC,YAAY;IAIjE,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,IAAI;IAJvB,QAAQ,CAAC,OAAO,+BAA+B;gBAG5B,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,eAAe;IAGxC,SAAS,IAAI,SAAS;IAItB;;;;OAIG;IACH,OAAO,IAAI,WAAW;IAItB,eAAe,IAAI,SAAS;IAI5B,iBAAiB,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI,EAAE,KAAK,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI;IAcrE,cAAc,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI,EAAE,KAAK,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI;IAelE,WAAW,IAAI,SAAS;IAIxB,iBAAiB,IAAI,SAAS;IAI9B,SAAS,IAAI,SAAS;IAItB,aAAa,IAAI,SAAS;IAI1B,YAAY,IAAI,SAAS;IAIzB,WAAW,CAAC,QAAQ,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI;IAM5C,eAAe,CAAC,QAAQ,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI;CAQjD"}

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

@@ -0,0 +1,80 @@
+import { Bytes } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { general } from "#@typeberry/jam-host-calls";
+import { getEncodedConstants, u64ToArrayIndex, } from "#@typeberry/transition/externalities/fetch-externalities.js";
+export class RefineFetchExternalities {
+    chainSpec;
+    data;
+    context = general.FetchContext.Refine;
+    constructor(chainSpec, data) {
+        this.chainSpec = chainSpec;
+        this.data = data;
+    }
+    constants() {
+        return getEncodedConstants(this.chainSpec);
+    }
+    /**
+     * Refine entropy is `H₀` (zero hash) per GP §B.3.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/2fe0012fe201?v=0.7.2
+     */
+    entropy() {
+        return Bytes.zero(HASH_SIZE).asOpaque();
+    }
+    authorizerTrace() {
+        return this.data.authorizerTrace;
+    }
+    workItemExtrinsic(workItem, index) {
+        const itemIdx = workItem === null ? this.data.currentWorkItemIndex : u64ToArrayIndex(workItem, this.data.extrinsics.length);
+        if (itemIdx === null) {
+            return null;
+        }
+        const perItem = this.data.extrinsics[itemIdx];
+        const xIdx = u64ToArrayIndex(index, perItem.length);
+        if (xIdx === null) {
+            return null;
+        }
+        return perItem[xIdx];
+    }
+    workItemImport(workItem, index) {
+        const itemIdx = workItem === null ? this.data.currentWorkItemIndex : u64ToArrayIndex(workItem, this.data.imports.length);
+        if (itemIdx === null) {
+            return null;
+        }
+        const perItem = this.data.imports[itemIdx];
+        const segIdx = u64ToArrayIndex(index, perItem.length);
+        if (segIdx === null) {
+            return null;
+        }
+        // `Segment` extends `BytesBlob`, so it can be returned directly.
+        return perItem[segIdx].data;
+    }
+    workPackage() {
+        return this.data.packageData.packageView.encoded();
+    }
+    authConfiguration() {
+        return this.data.packageData.packageView.authConfiguration.view();
+    }
+    authToken() {
+        return this.data.packageData.packageView.authToken.view();
+    }
+    refineContext() {
+        return this.data.packageData.packageView.context.encoded();
+    }
+    allWorkItems() {
+        return this.data.packageData.workItemSummaries.encoded();
+    }
+    oneWorkItem(workItem) {
+        const summaries = this.data.packageData.workItemSummaries;
+        const idx = u64ToArrayIndex(workItem, summaries.length);
+        return idx === null ? null : (summaries.get(idx)?.encoded() ?? null);
+    }
+    workItemPayload(workItem) {
+        const items = this.data.packageData.packageView.items.view();
+        const idx = u64ToArrayIndex(workItem, items.length);
+        if (idx === null) {
+            return null;
+        }
+        return items.get(idx)?.view().payload.view() ?? null;
+    }
+}

package/packages/jam/in-core/externalities/refine-fetch.test.d.ts

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

package/packages/jam/in-core/externalities/refine-fetch.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refine-fetch.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/in-core/externalities/refine-fetch.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,219 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsServiceGas, tryAsServiceId, tryAsTimeSlot } from "#@typeberry/block";
+import { RefineContext } from "#@typeberry/block/refine-context.js";
+import { ImportSpec, WorkItem, WorkItemExtrinsicSpec } from "#@typeberry/block/work-item.js";
+import { SEGMENT_BYTES, tryAsSegmentIndex } from "#@typeberry/block/work-item-segment.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 { fullChainSpec, tinyChainSpec } from "#@typeberry/config";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { tryAsU16, tryAsU32, tryAsU64 } from "#@typeberry/numbers";
+import { buildWorkPackageFetchData } from "#@typeberry/transition/externalities/fetch-externalities.js";
+import { asOpaqueType } from "#@typeberry/utils";
+import { RefineFetchExternalities } from "./refine-fetch.js";
+const asExtrinsic = (bytes) => asOpaqueType(bytes);
+function buildWorkItem(overrides) {
+    const codeHash = Bytes.fill(HASH_SIZE, 7).asOpaque();
+    const imports = Array.from({ length: overrides.importCount ?? 0 }, (_, i) => ImportSpec.create({ treeRoot: Bytes.zero(HASH_SIZE), index: tryAsSegmentIndex(i) }));
+    const extrinsicSpecs = Array.from({ length: overrides.extrinsicCount ?? 0 }, () => WorkItemExtrinsicSpec.create({ hash: Bytes.zero(HASH_SIZE).asOpaque(), len: tryAsU32(0) }));
+    return WorkItem.create({
+        service: tryAsServiceId(overrides.service ?? 1),
+        codeHash,
+        payload: BytesBlob.blobFrom(new Uint8Array(overrides.payloadLen ?? 3).fill(0xab)),
+        refineGasLimit: tryAsServiceGas(1_000_000),
+        accumulateGasLimit: tryAsServiceGas(2_000_000),
+        importSegments: asKnownSize(imports),
+        extrinsic: extrinsicSpecs,
+        exportCount: tryAsU16(overrides.exportCount ?? 0),
+    });
+}
+function buildWorkPackage(items) {
+    return WorkPackage.create({
+        authToken: BytesBlob.blobFrom(new Uint8Array([1, 2, 3])),
+        authCodeHost: tryAsServiceId(42),
+        authCodeHash: Bytes.fill(HASH_SIZE, 9).asOpaque(),
+        authConfiguration: BytesBlob.blobFrom(new Uint8Array([4, 5, 6, 7])),
+        context: RefineContext.create({
+            anchor: Bytes.fill(HASH_SIZE, 1).asOpaque(),
+            stateRoot: Bytes.fill(HASH_SIZE, 2).asOpaque(),
+            beefyRoot: Bytes.fill(HASH_SIZE, 3).asOpaque(),
+            lookupAnchor: Bytes.fill(HASH_SIZE, 4).asOpaque(),
+            lookupAnchorSlot: tryAsTimeSlot(16),
+            prerequisites: [],
+        }),
+        items: FixedSizeArray.new(items, tryAsWorkItemsCount(items.length)),
+    });
+}
+function prepareRefineData(opts = {}) {
+    const chainSpec = opts.chainSpec ?? tinyChainSpec;
+    const items = opts.items ?? [buildWorkItem({})];
+    const workPackage = buildWorkPackage(items);
+    const packageData = buildWorkPackageFetchData(chainSpec, workPackage);
+    return new RefineFetchExternalities(chainSpec, {
+        packageData,
+        currentWorkItemIndex: opts.currentWorkItemIndex ?? 0,
+        imports: opts.imports ?? asKnownSize(items.map(() => [])),
+        extrinsics: opts.extrinsics ?? asKnownSize(items.map(() => [])),
+        authorizerTrace: opts.authorizerTrace ?? BytesBlob.empty(),
+    });
+}
+describe("RefineFetchExternalities", () => {
+    it("should return different constants for different chain specs", () => {
+        const tinyExt = prepareRefineData({ chainSpec: tinyChainSpec });
+        const fullExt = prepareRefineData({ chainSpec: fullChainSpec });
+        assert.notStrictEqual(tinyExt.constants().length, 0);
+        assert.notStrictEqual(fullExt.constants().length, 0);
+        assert.notDeepStrictEqual(tinyExt.constants(), fullExt.constants());
+    });
+    it("should return entropy H_0 (zero hash) per GP §B.3", () => {
+        const ext = prepareRefineData();
+        const entropy = ext.entropy();
+        assert.strictEqual(entropy.length, HASH_SIZE);
+        assert.ok(entropy.isEqualTo(Bytes.zero(HASH_SIZE).asOpaque()));
+    });
+    it("should return the supplied authorizer trace", () => {
+        const trace = BytesBlob.blobFrom(new Uint8Array([0xaa, 0xbb, 0xcc]));
+        const ext = prepareRefineData({ authorizerTrace: trace });
+        assert.deepStrictEqual(ext.authorizerTrace().raw, trace.raw);
+    });
+    it("should return an extrinsic by work item index and extrinsic index", () => {
+        const items = [buildWorkItem({}), buildWorkItem({ service: 2 })];
+        const extrinsics = asKnownSize([
+            [asExtrinsic(BytesBlob.blobFrom(new Uint8Array([1])))],
+            [
+                asExtrinsic(BytesBlob.blobFrom(new Uint8Array([2, 2]))),
+                asExtrinsic(BytesBlob.blobFrom(new Uint8Array([3, 3, 3]))),
+            ],
+        ]);
+        const ext = prepareRefineData({ items, extrinsics });
+        const other = ext.workItemExtrinsic(tryAsU64(1), tryAsU64(1));
+        assert.ok(other !== null);
+        assert.deepStrictEqual(other.raw, new Uint8Array([3, 3, 3]));
+    });
+    it("should return current item's extrinsic when workItem is null", () => {
+        const items = [buildWorkItem({}), buildWorkItem({ service: 2 })];
+        const extrinsics = asKnownSize([
+            [asExtrinsic(BytesBlob.blobFrom(new Uint8Array([9])))],
+            [asExtrinsic(BytesBlob.blobFrom(new Uint8Array([8])))],
+        ]);
+        const ext = prepareRefineData({ items, extrinsics, currentWorkItemIndex: 1 });
+        const mine = ext.workItemExtrinsic(null, tryAsU64(0));
+        assert.ok(mine !== null);
+        assert.deepStrictEqual(mine.raw, new Uint8Array([8]));
+    });
+    it("should return null for out-of-range extrinsic indices", () => {
+        const items = [buildWorkItem({})];
+        const extrinsics = asKnownSize([
+            [asExtrinsic(BytesBlob.blobFrom(new Uint8Array([1])))],
+        ]);
+        const ext = prepareRefineData({ items, extrinsics });
+        assert.strictEqual(ext.workItemExtrinsic(tryAsU64(5), tryAsU64(0)), null);
+        assert.strictEqual(ext.workItemExtrinsic(tryAsU64(0), tryAsU64(5)), null);
+        assert.strictEqual(ext.workItemExtrinsic(null, tryAsU64(5)), null);
+    });
+    it("should treat U64 indices above the safe-integer range as out of range", () => {
+        const items = [buildWorkItem({})];
+        const ext = prepareRefineData({ items });
+        const huge = tryAsU64(2n ** 53n); // first value > Number.MAX_SAFE_INTEGER
+        assert.strictEqual(ext.workItemExtrinsic(huge, tryAsU64(0)), null);
+        assert.strictEqual(ext.workItemExtrinsic(null, huge), null);
+        assert.strictEqual(ext.workItemImport(huge, tryAsU64(0)), null);
+        assert.strictEqual(ext.oneWorkItem(huge), null);
+        assert.strictEqual(ext.workItemPayload(huge), null);
+    });
+    it("should return an import segment by work item index and segment index", () => {
+        const items = [buildWorkItem({}), buildWorkItem({ service: 2 })];
+        const segBytes = new Uint8Array(SEGMENT_BYTES).fill(0x55);
+        const imports = asKnownSize([
+            [],
+            [{ index: tryAsSegmentIndex(0), data: Bytes.fromBlob(segBytes, SEGMENT_BYTES) }],
+        ]);
+        const ext = prepareRefineData({ items, imports });
+        const imp = ext.workItemImport(tryAsU64(1), tryAsU64(0));
+        assert.ok(imp !== null);
+        assert.deepStrictEqual(imp.raw, segBytes);
+    });
+    it("should return null for out-of-range import indices", () => {
+        const ext = prepareRefineData();
+        assert.strictEqual(ext.workItemImport(tryAsU64(10), tryAsU64(0)), null);
+        assert.strictEqual(ext.workItemImport(null, tryAsU64(10)), null);
+        assert.strictEqual(ext.workItemImport(tryAsU64(0), tryAsU64(10)), null);
+    });
+    it("should return encoded work package", () => {
+        const items = [buildWorkItem({})];
+        const ext = prepareRefineData({ items });
+        const expected = Encoder.encodeObject(WorkPackage.Codec, buildWorkPackage(items), tinyChainSpec);
+        assert.deepStrictEqual(ext.workPackage().raw, expected.raw);
+    });
+    it("should return auth configuration and auth token from the package", () => {
+        const ext = prepareRefineData();
+        assert.deepStrictEqual(ext.authConfiguration().raw, new Uint8Array([4, 5, 6, 7]));
+        assert.deepStrictEqual(ext.authToken().raw, new Uint8Array([1, 2, 3]));
+    });
+    it("should return encoded refine context", () => {
+        const ext = prepareRefineData();
+        const context = RefineContext.create({
+            anchor: Bytes.fill(HASH_SIZE, 1).asOpaque(),
+            stateRoot: Bytes.fill(HASH_SIZE, 2).asOpaque(),
+            beefyRoot: Bytes.fill(HASH_SIZE, 3).asOpaque(),
+            lookupAnchor: Bytes.fill(HASH_SIZE, 4).asOpaque(),
+            lookupAnchorSlot: tryAsTimeSlot(16),
+            prerequisites: [],
+        });
+        const expected = Encoder.encodeObject(RefineContext.Codec, context);
+        assert.deepStrictEqual(ext.refineContext().raw, expected.raw);
+    });
+    it("should return concatenated work item summaries (kind 11) with 62 bytes per item", () => {
+        const items = [
+            buildWorkItem({ service: 1, payloadLen: 7, exportCount: 2, importCount: 1, extrinsicCount: 0 }),
+            buildWorkItem({ service: 2, payloadLen: 4, exportCount: 0, importCount: 0, extrinsicCount: 3 }),
+        ];
+        const ext = prepareRefineData({ items });
+        const all = ext.allWorkItems();
+        assert.strictEqual(all.length, 62 * items.length);
+    });
+    it("should return a single work item summary (kind 12)", () => {
+        const items = [buildWorkItem({ service: 1 }), buildWorkItem({ service: 2, payloadLen: 10 })];
+        const ext = prepareRefineData({ items });
+        const one = ext.oneWorkItem(tryAsU64(1));
+        assert.ok(one !== null);
+        assert.strictEqual(one.length, 62);
+        // first 4 bytes are the service id (u32 LE).
+        const serviceId = new DataView(one.raw.buffer, one.raw.byteOffset, 4).getUint32(0, true);
+        assert.strictEqual(serviceId, 2);
+        // payload length is the last 4 bytes (u32 LE).
+        const payloadLen = new DataView(one.raw.buffer, one.raw.byteOffset + 58, 4).getUint32(0, true);
+        assert.strictEqual(payloadLen, 10);
+    });
+    it("should return null for one work item when index is out of range", () => {
+        const ext = prepareRefineData();
+        assert.strictEqual(ext.oneWorkItem(tryAsU64(99)), null);
+    });
+    it("should return the raw payload of a work item (kind 13)", () => {
+        const items = [buildWorkItem({ service: 1, payloadLen: 2 }), buildWorkItem({ service: 2, payloadLen: 5 })];
+        const ext = prepareRefineData({ items });
+        const payload = ext.workItemPayload(tryAsU64(1));
+        assert.ok(payload !== null);
+        assert.strictEqual(payload.length, 5);
+        assert.ok(payload.raw.every((x) => x === 0xab));
+    });
+    it("should return null for payload when index is out of range", () => {
+        const ext = prepareRefineData();
+        assert.strictEqual(ext.workItemPayload(tryAsU64(99)), null);
+    });
+    // guard against silent accidental changes to the helpers — tryAsU32 ensures
+    // encoded lengths match GP's S(w) spec.
+    it("uses unsigned little-endian u32 for payload length regardless of platform", () => {
+        const items = [buildWorkItem({ service: 1, payloadLen: 0x1234 })];
+        const ext = prepareRefineData({ items });
+        const one = ext.oneWorkItem(tryAsU64(0));
+        assert.ok(one !== null);
+        const payloadLen = new DataView(one.raw.buffer, one.raw.byteOffset + 58, 4).getUint32(0, true);
+        assert.strictEqual(payloadLen, 0x1234);
+        // tryAsU32 would throw on negative values
+        assert.doesNotThrow(() => tryAsU32(0x1234));
+    });
+});

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

@@ -7,8 +7,8 @@ import type { ChainSpec, PvmBackend } from "#@typeberry/config";
 import type { StatesDb } from "#@typeberry/database";
 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";
+import type { ImportedSegment, PerWorkItem } from "./externalities/index.js";
+export type { ImportedSegment, PerWorkItem };
 export type RefineResult = {
     report: WorkReport;
     exports: PerWorkItem<Segment[]>;

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,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;aASC,SAAS,EAAE,SAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IATzB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IAEpC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO;IAI3F,OAAO;IAUP;;;;;;;;;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"}
+{"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;AAKzD,OAAO,EAAe,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE7E,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,CAAC;AAI7C,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;aASC,SAAS,EAAE,SAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IATzB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IAEpC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO;IAI3F,OAAO;IAUP;;;;;;;;;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;IAoF7C,OAAO,CAAC,MAAM,CAAC,oBAAoB;CAsDpC"}

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

@@ -5,6 +5,7 @@ import { asKnownSize, FixedSizeArray } from "#@typeberry/collections";
 import { HASH_SIZE } from "#@typeberry/hash";
 import { Logger } from "#@typeberry/logger";
 import { tryAsU8, tryAsU16, tryAsU32 } from "#@typeberry/numbers";
+import { buildWorkPackageFetchData } from "#@typeberry/transition/externalities/fetch-externalities.js";
 import { assertEmpty, Result } from "#@typeberry/utils";
 import { AuthorizationError, IsAuthorized } from "./is-authorized.js";
 import { Refine } from "./refine.js";
@@ -46,8 +47,7 @@ export class InCore {
      */
     async refine(workPackageAndHash, core, imports, extrinsics) {
         const workPackageHash = workPackageAndHash.hash;
-        const { context, authToken, authCodeHash, authCodeHost, authConfiguration, items, ...rest } = workPackageAndHash.data;
-        assertEmpty(rest);
+        const { context, items } = workPackageAndHash.data;
         // TODO [ToDr] Verify BEEFY root
         // TODO [ToDr] Verify prerequisites
         logger.log `[core:${core}] Attempting to refine work package with ${items.length} items.`;
@@ -72,8 +72,10 @@ export class InCore {
         if (lookupState.timeslot !== context.lookupAnchorSlot) {
             return Result.error(RefineError.InvalidLookupAnchorSlot, () => `Lookup anchor slot does not match the one is state. Ours: ${lookupState.timeslot}, expected: ${context.lookupAnchorSlot}`);
         }
+        // Eagerly build the per-package fetch data so we pay the encoding cost
+        const packageFetchData = buildWorkPackageFetchData(this.chainSpec, workPackageAndHash.data);
         // Check authorization
-        const authResult = await this.isAuthorized.invoke(state, core, authToken, authCodeHost, authCodeHash, authConfiguration);
+        const authResult = await this.isAuthorized.invoke(state, core, packageFetchData);
         if (authResult.isError) {
             return Result.error(RefineError.AuthorizationError, () => `Authorization error: ${AuthorizationError[authResult.error]}: ${authResult.details()}.`);
         }
@@ -83,7 +85,7 @@ 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.invoke(state, lookupState, idx, item, imports, extrinsics, core, workPackageHash, exportOffset);
+            const result = await this.refineItem.invoke(state, lookupState, packageFetchData, idx, item, imports, extrinsics, core, workPackageHash, exportOffset, authResult.ok.authorizationOutput);
             refineResults.push(result);
             exportOffset += result.exports.length;
         }