@typeberry/lib 0.5.10 → 0.5.11-1fbacf3

package/packages/jam/transition/externalities/accumulate-fetch-externalities.d.ts

@@ -0,0 +1,19 @@
+import type { EntropyHash } from "#@typeberry/block";
+import type { BytesBlob } from "#@typeberry/bytes";
+import type { ChainSpec } from "#@typeberry/config";
+import { general, type PendingTransfer } from "#@typeberry/jam-host-calls";
+import type { U64 } from "#@typeberry/numbers";
+import type { Operand } from "../accumulate/operand.js";
+export declare class AccumulateFetchExternalities implements general.IAccumulateFetch {
+    private readonly entropyHash;
+    private readonly transfers;
+    private readonly operands;
+    private readonly chainSpec;
+    readonly context = general.FetchContext.Accumulate;
+    constructor(entropyHash: EntropyHash, transfers: PendingTransfer[], operands: Operand[], chainSpec: ChainSpec);
+    constants(): BytesBlob;
+    entropy(): EntropyHash;
+    allTransfersAndOperands(): BytesBlob | null;
+    oneTransferOrOperand(index: U64): BytesBlob | null;
+}
+//# sourceMappingURL=accumulate-fetch-externalities.d.ts.map

package/packages/jam/transition/externalities/accumulate-fetch-externalities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accumulate-fetch-externalities.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/externalities/accumulate-fetch-externalities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AASxD,qBAAa,4BAA6B,YAAW,OAAO,CAAC,gBAAgB;IAIzE,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAN5B,QAAQ,CAAC,OAAO,mCAAmC;gBAGhC,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,eAAe,EAAE,EAC5B,QAAQ,EAAE,OAAO,EAAE,EACnB,SAAS,EAAE,SAAS;IAGvC,SAAS,IAAI,SAAS;IAItB,OAAO,IAAI,WAAW;IAItB,uBAAuB,IAAI,SAAS,GAAG,IAAI;IAU3C,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI;CAqBnD"}

package/packages/jam/transition/externalities/accumulate-fetch-externalities.js

@@ -0,0 +1,45 @@
+import { Encoder } from "#@typeberry/codec";
+import { general } from "#@typeberry/jam-host-calls";
+import { getEncodedConstants, TRANSFER_OR_OPERAND, TRANSFERS_AND_OPERANDS, TransferOperandKind, } from "./fetch-externalities.js";
+export class AccumulateFetchExternalities {
+    entropyHash;
+    transfers;
+    operands;
+    chainSpec;
+    context = general.FetchContext.Accumulate;
+    constructor(entropyHash, transfers, operands, chainSpec) {
+        this.entropyHash = entropyHash;
+        this.transfers = transfers;
+        this.operands = operands;
+        this.chainSpec = chainSpec;
+    }
+    constants() {
+        return getEncodedConstants(this.chainSpec);
+    }
+    entropy() {
+        return this.entropyHash;
+    }
+    allTransfersAndOperands() {
+        const transfersAndOperands = this.transfers
+            .map((transfer) => ({ kind: TransferOperandKind.TRANSFER, value: transfer }))
+            .concat(this.operands.map((operand) => ({ kind: TransferOperandKind.OPERAND, value: operand })));
+        return Encoder.encodeObject(TRANSFERS_AND_OPERANDS, transfersAndOperands, this.chainSpec);
+    }
+    oneTransferOrOperand(index) {
+        if (index >= this.transfers.length + this.operands.length) {
+            return null;
+        }
+        // Transfers-first ordering, consistent with allTransfersAndOperands()
+        const kind = index < this.transfers.length ? TransferOperandKind.TRANSFER : TransferOperandKind.OPERAND;
+        const transferOrOperand = kind === TransferOperandKind.TRANSFER
+            ? { kind: TransferOperandKind.TRANSFER, value: this.transfers[Number(index)] }
+            : {
+                kind: TransferOperandKind.OPERAND,
+                value: this.operands[Number(index) - this.transfers.length],
+            };
+        if (transferOrOperand.value === undefined) {
+            return null;
+        }
+        return Encoder.encodeObject(TRANSFER_OR_OPERAND, transferOrOperand, this.chainSpec);
+    }
+}

package/packages/jam/transition/externalities/accumulate-fetch-externalities.test.d.ts

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

package/packages/jam/transition/externalities/accumulate-fetch-externalities.test.d.ts.map

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

package/packages/jam/transition/externalities/accumulate-fetch-externalities.test.js

@@ -0,0 +1,192 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsServiceGas, tryAsServiceId } from "#@typeberry/block";
+import { WorkExecResult } from "#@typeberry/block/work-result.js";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { codec, Encoder } from "#@typeberry/codec";
+import { fullChainSpec, tinyChainSpec } from "#@typeberry/config";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { TRANSFER_MEMO_BYTES } from "#@typeberry/jam-host-calls/externalities/partial-state.js";
+import { PendingTransfer } from "#@typeberry/jam-host-calls/externalities/pending-transfer.js";
+import { tryAsU64 } from "#@typeberry/numbers";
+import { Operand } from "../accumulate/operand.js";
+import { AccumulateFetchExternalities } from "./accumulate-fetch-externalities.js";
+import { TRANSFER_OR_OPERAND, TransferOperandKind } from "./fetch-externalities.js";
+describe("AccumulateFetchExternalities", () => {
+    const prepareOperands = (length) => {
+        const operands = [];
+        for (let i = 0; i < length; i++) {
+            operands.push(Operand.create({
+                authorizationOutput: BytesBlob.empty(),
+                authorizerHash: Bytes.fill(HASH_SIZE, i + 1).asOpaque(),
+                exportsRoot: Bytes.fill(HASH_SIZE, i + 2).asOpaque(),
+                hash: Bytes.fill(HASH_SIZE, i + 4).asOpaque(),
+                payloadHash: Bytes.fill(HASH_SIZE, i + 5).asOpaque(),
+                result: WorkExecResult.ok(BytesBlob.empty()),
+                gas: tryAsServiceGas(1_000),
+            }));
+        }
+        return operands;
+    };
+    const prepareTransfers = (length) => {
+        const transfers = [];
+        for (let i = 0; i < length; i++) {
+            transfers.push(PendingTransfer.create({
+                amount: tryAsU64(1000),
+                source: tryAsServiceId(i),
+                destination: tryAsServiceId(i + 1),
+                gas: tryAsServiceGas(10),
+                memo: Bytes.fill(TRANSFER_MEMO_BYTES, 0),
+            }));
+        }
+        return transfers;
+    };
+    // allTransfersAndOperands: transfers first, then operands
+    const toAllTransfersAndOperands = (operands, transfers) => {
+        return [
+            ...transfers.map((t) => ({ kind: TransferOperandKind.TRANSFER, value: t })),
+            ...operands.map((o) => ({ kind: TransferOperandKind.OPERAND, value: o })),
+        ];
+    };
+    // oneTransferOrOperand: transfers first, then operands (same as allTransfersAndOperands)
+    const toOneTransferOrOperandAt = (operands, transfers, index) => {
+        if (index >= transfers.length + operands.length) {
+            return null;
+        }
+        if (index < transfers.length) {
+            return { kind: TransferOperandKind.TRANSFER, value: transfers[index] };
+        }
+        return { kind: TransferOperandKind.OPERAND, value: operands[index - transfers.length] };
+    };
+    const encodeOneTransferOrOperand = (item, chainSpec) => {
+        if (item === null) {
+            return null;
+        }
+        return Encoder.encodeObject(TRANSFER_OR_OPERAND, item, chainSpec);
+    };
+    const prepareAccumulateData = ({ chainSpec, operands, entropy, transfers, }) => {
+        const defaultChainSpec = tinyChainSpec;
+        const defaultEntropy = Bytes.zero(HASH_SIZE).asOpaque();
+        const defaultOperands = [];
+        const defaultTransfers = [];
+        return new AccumulateFetchExternalities(entropy ?? defaultEntropy, transfers ?? defaultTransfers, operands ?? defaultOperands, chainSpec ?? defaultChainSpec);
+    };
+    it("should return different constants for different chain specs", () => {
+        const tinyFetchExternalities = prepareAccumulateData({ chainSpec: tinyChainSpec });
+        const fullFetchExternalities = prepareAccumulateData({ chainSpec: fullChainSpec });
+        const tinyConstants = tinyFetchExternalities.constants();
+        const fullConstants = fullFetchExternalities.constants();
+        assert.notStrictEqual(tinyConstants.length, 0);
+        assert.notStrictEqual(fullConstants.length, 0);
+        assert.notDeepStrictEqual(tinyConstants, fullConstants);
+    });
+    it("should return entropy hash", () => {
+        const expectedEntropy = Bytes.fill(HASH_SIZE, 5).asOpaque();
+        const fetchExternalities = prepareAccumulateData({ entropy: expectedEntropy });
+        const entropy = fetchExternalities.entropy();
+        assert.deepStrictEqual(entropy, expectedEntropy);
+    });
+    it("should return all transfers and operands", () => {
+        const operands = prepareOperands(3);
+        const transfers = prepareTransfers(2);
+        const chainSpec = tinyChainSpec;
+        const expected = toAllTransfersAndOperands(operands, transfers);
+        const encodedExpected = Encoder.encodeObject(codec.sequenceVarLen(TRANSFER_OR_OPERAND), expected, chainSpec);
+        const fetchExternalities = prepareAccumulateData({ operands, transfers, chainSpec });
+        const result = fetchExternalities.allTransfersAndOperands();
+        assert.deepStrictEqual(result, encodedExpected);
+    });
+    it("should return empty encoded sequence when no transfers and no operands", () => {
+        const chainSpec = tinyChainSpec;
+        const encodedExpected = Encoder.encodeObject(codec.sequenceVarLen(TRANSFER_OR_OPERAND), [], chainSpec);
+        const fetchExternalities = prepareAccumulateData({ operands: [], transfers: [], chainSpec });
+        const result = fetchExternalities.allTransfersAndOperands();
+        assert.deepStrictEqual(result, encodedExpected);
+    });
+    it("should return one transfer by index (first range)", () => {
+        const operands = prepareOperands(3);
+        const transfers = prepareTransfers(2);
+        const chainSpec = tinyChainSpec;
+        const encodedExpected = encodeOneTransferOrOperand(toOneTransferOrOperandAt(operands, transfers, 0), chainSpec);
+        const fetchExternalities = prepareAccumulateData({ operands, transfers, chainSpec });
+        // Transfers come first (indices 0..1), then operands (indices 2..4)
+        const result = fetchExternalities.oneTransferOrOperand(tryAsU64(0));
+        assert.deepStrictEqual(result, encodedExpected);
+    });
+    it("should return one operand by index (second range)", () => {
+        const operands = prepareOperands(3);
+        const transfers = prepareTransfers(2);
+        const chainSpec = tinyChainSpec;
+        const encodedExpected = encodeOneTransferOrOperand(toOneTransferOrOperandAt(operands, transfers, 2), chainSpec);
+        const fetchExternalities = prepareAccumulateData({ operands, transfers, chainSpec });
+        // Operands start after transfers, so index 2 is the first operand
+        const result = fetchExternalities.oneTransferOrOperand(tryAsU64(2));
+        assert.deepStrictEqual(result, encodedExpected);
+    });
+    it("should return null when index is out of bounds", () => {
+        const operands = prepareOperands(3);
+        const transfers = prepareTransfers(2);
+        const chainSpec = tinyChainSpec;
+        const fetchExternalities = prepareAccumulateData({ operands, transfers, chainSpec });
+        // Total items: 3 operands + 2 transfers = 5, so index 5 is out of bounds
+        const result = fetchExternalities.oneTransferOrOperand(tryAsU64(5));
+        assert.strictEqual(result, null);
+    });
+    it("should return null when index is far out of bounds", () => {
+        const operands = prepareOperands(3);
+        const transfers = prepareTransfers(2);
+        const chainSpec = tinyChainSpec;
+        const fetchExternalities = prepareAccumulateData({ operands, transfers, chainSpec });
+        const result = fetchExternalities.oneTransferOrOperand(tryAsU64(153));
+        assert.strictEqual(result, null);
+    });
+    it("should have consistent encoding between all and one", () => {
+        const operands = prepareOperands(2);
+        const transfers = prepareTransfers(2);
+        const chainSpec = tinyChainSpec;
+        const allItems = toAllTransfersAndOperands(operands, transfers);
+        const encodedAll = Encoder.encodeObject(codec.sequenceVarLen(TRANSFER_OR_OPERAND), allItems, chainSpec);
+        const fetchExternalities = prepareAccumulateData({ operands, transfers, chainSpec });
+        const all = fetchExternalities.allTransfersAndOperands();
+        assert.deepStrictEqual(all, encodedAll);
+        for (let i = 0; i < operands.length + transfers.length; i++) {
+            const one = fetchExternalities.oneTransferOrOperand(tryAsU64(i));
+            const encodedOne = encodeOneTransferOrOperand(toOneTransferOrOperandAt(operands, transfers, i), chainSpec);
+            assert.deepStrictEqual(one, encodedOne, `Mismatch at index ${i}`);
+        }
+        const outOfRange = fetchExternalities.oneTransferOrOperand(tryAsU64(operands.length + transfers.length));
+        assert.strictEqual(outOfRange, null);
+    });
+    it("should handle only operands without transfers", () => {
+        const operands = prepareOperands(5);
+        const chainSpec = tinyChainSpec;
+        const allItems = toAllTransfersAndOperands(operands, []);
+        const encodedAll = Encoder.encodeObject(codec.sequenceVarLen(TRANSFER_OR_OPERAND), allItems, chainSpec);
+        const fetchExternalities = prepareAccumulateData({ operands, transfers: [], chainSpec });
+        const result = fetchExternalities.allTransfersAndOperands();
+        assert.deepStrictEqual(result, encodedAll);
+        for (let i = 0; i < operands.length; i++) {
+            const one = fetchExternalities.oneTransferOrOperand(tryAsU64(i));
+            const encodedOne = encodeOneTransferOrOperand(toOneTransferOrOperandAt(operands, [], i), chainSpec);
+            assert.deepStrictEqual(one, encodedOne, `Mismatch at operand index ${i}`);
+        }
+        const outOfRange = fetchExternalities.oneTransferOrOperand(tryAsU64(operands.length));
+        assert.strictEqual(outOfRange, null);
+    });
+    it("should handle only transfers without operands", () => {
+        const transfers = prepareTransfers(5);
+        const chainSpec = tinyChainSpec;
+        const allItems = toAllTransfersAndOperands([], transfers);
+        const encodedAll = Encoder.encodeObject(codec.sequenceVarLen(TRANSFER_OR_OPERAND), allItems, chainSpec);
+        const fetchExternalities = prepareAccumulateData({ operands: [], transfers, chainSpec });
+        const result = fetchExternalities.allTransfersAndOperands();
+        assert.deepStrictEqual(result, encodedAll);
+        for (let i = 0; i < transfers.length; i++) {
+            const one = fetchExternalities.oneTransferOrOperand(tryAsU64(i));
+            const encodedOne = encodeOneTransferOrOperand(toOneTransferOrOperandAt([], transfers, i), chainSpec);
+            assert.deepStrictEqual(one, encodedOne, `Mismatch at transfer index ${i}`);
+        }
+        const outOfRange = fetchExternalities.oneTransferOrOperand(tryAsU64(transfers.length));
+        assert.strictEqual(outOfRange, null);
+    });
+});

package/packages/jam/transition/externalities/fetch-externalities.d.ts

@@ -1,7 +1,9 @@
-import type { EntropyHash } from "#@typeberry/block";
-import type { BytesBlob } from "#@typeberry/bytes";
+import type { WorkItem } from "#@typeberry/block/work-item.js";
+import { WorkPackage, type WorkPackageView } from "#@typeberry/block/work-package.js";
+import { BytesBlob } from "#@typeberry/bytes";
+import { type DescribedBy, SequenceView } from "#@typeberry/codec";
 import type { ChainSpec } from "#@typeberry/config";
-import { type general, PendingTransfer } from "#@typeberry/jam-host-calls";
+import { PendingTransfer } from "#@typeberry/jam-host-calls";
 import { type U64 } from "#@typeberry/numbers";
 import { Operand } from "../accumulate/operand.js";
 export declare enum TransferOperandKind {
@@ -16,40 +18,55 @@ export type TransferOrOperand = {
     value: PendingTransfer;
 };
 export declare const TRANSFER_OR_OPERAND: import("@typeberry/codec").Descriptor<TransferOrOperand, TransferOrOperand>;
-declare enum FetchContext {
-    Accumulate = 0,
-    Refine = 1
-}
-type AccumulateFetchData = {
-    context: FetchContext.Accumulate;
-    entropy: EntropyHash;
-    transfers: PendingTransfer[];
-    operands: Operand[];
-};
-type RefineFetchData = {
-    context: FetchContext.Refine;
-    entropy: undefined;
+export declare const TRANSFERS_AND_OPERANDS: import("@typeberry/codec").Descriptor<TransferOrOperand[], SequenceView<TransferOrOperand, TransferOrOperand>>;
+export declare function getEncodedConstants(chainSpec: ChainSpec): BytesBlob;
+/**
+ * `S(w)` — work-item summary used by fetch in both the IsAuthorized
+ * and Refine contexts.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/31fc0231fc02?v=0.7.2
+ */
+declare const WORK_ITEM_SUMMARY_CODEC: import("@typeberry/codec").Descriptor<{
+    service: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">;
+    codeHash: import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"CodeHash">;
+    refineGasLimit: bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">;
+    accumulateGasLimit: bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">;
+    exportCount: import("@typeberry/numbers").U16;
+    importSegmentsCount: import("@typeberry/numbers").U16;
+    extrinsicCount: import("@typeberry/numbers").U16;
+    payloadLength: import("@typeberry/numbers").U32;
+}, import("@typeberry/codec").ViewOf<{
+    service: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">;
+    codeHash: import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"CodeHash">;
+    refineGasLimit: bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">;
+    accumulateGasLimit: bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">;
+    exportCount: import("@typeberry/numbers").U16;
+    importSegmentsCount: import("@typeberry/numbers").U16;
+    extrinsicCount: import("@typeberry/numbers").U16;
+    payloadLength: import("@typeberry/numbers").U32;
+}, import("@typeberry/codec").SimpleDescriptorRecord<{
+    service: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">;
+    codeHash: import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"CodeHash">;
+    refineGasLimit: bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">;
+    accumulateGasLimit: bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">;
+    exportCount: import("@typeberry/numbers").U16;
+    importSegmentsCount: import("@typeberry/numbers").U16;
+    extrinsicCount: import("@typeberry/numbers").U16;
+    payloadLength: import("@typeberry/numbers").U32;
+}>>>;
+type WorkItemSummary = DescribedBy<typeof WORK_ITEM_SUMMARY_CODEC>;
+type WorkItemSummaryView = DescribedBy<typeof WORK_ITEM_SUMMARY_CODEC.View>;
+export declare function encodeWorkItemSummary(item: WorkItem): BytesBlob;
+/** Encoded work package data for fetch, shared between `IsAuthorized` and `Refine` fetchers. */
+export type WorkPackageFetchData = {
+    /** Lazy view over the encoded work package. */
+    packageView: WorkPackageView;
+    /** SequenceView over the concatenated S(w) summaries. */
+    workItemSummaries: SequenceView<WorkItemSummary, WorkItemSummaryView>;
 };
-export declare class FetchExternalities implements general.IFetchExternalities {
-    private fetchData;
-    private chainSpec;
-    private constructor();
-    static createForAccumulate(fetchData: Omit<AccumulateFetchData, "context">, chainSpec: ChainSpec): FetchExternalities;
-    static createForRefine(fetchData: Omit<RefineFetchData, "context">, chainSpec: ChainSpec): FetchExternalities;
-    constants(): BytesBlob;
-    entropy(): BytesBlob | null;
-    authorizerTrace(): BytesBlob | null;
-    workItemExtrinsic(_workItem: U64 | null, _index: U64): BytesBlob | null;
-    workItemImport(_workItem: U64 | null, _index: U64): BytesBlob | null;
-    workPackage(): BytesBlob | null;
-    authorizer(): BytesBlob | null;
-    authorizationToken(): BytesBlob | null;
-    refineContext(): BytesBlob | null;
-    allWorkItems(): BytesBlob | null;
-    oneWorkItem(_workItem: U64): BytesBlob | null;
-    workItemPayload(_workItem: U64): BytesBlob | null;
-    allTransfersAndOperands(): BytesBlob | null;
-    oneTransferOrOperand(index: U64): BytesBlob | null;
-}
+/** Eagerly build the per-package fetch views. */
+export declare function buildWorkPackageFetchData(chainSpec: ChainSpec, workPackage: WorkPackage): WorkPackageFetchData;
+/** Converts u64 value taken from a register into valid index of array of given `length`. */
+export declare function u64ToArrayIndex(v: U64, len: number): number | null;
 export {};
 //# sourceMappingURL=fetch-externalities.d.ts.map

package/packages/jam/transition/externalities/fetch-externalities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch-externalities.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/externalities/fetch-externalities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,KAAK,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,EAAgC,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAQ5E,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAInD,oBAAY,mBAAmB;IAC7B,OAAO,IAAI;IACX,QAAQ,IAAI;CACb;AAED,MAAM,MAAM,iBAAiB,GACzB;IACE,IAAI,EAAE,mBAAmB,CAAC,OAAO,CAAC;IAClC,KAAK,EAAE,OAAO,CAAC;CAChB,GACD;IACE,IAAI,EAAE,mBAAmB,CAAC,QAAQ,CAAC;IACnC,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAEN,eAAO,MAAM,mBAAmB,6EAG9B,CAAC;AA2FH,aAAK,YAAY;IACf,UAAU,IAAI;IACd,MAAM,IAAI;CACX;AAED,KAAK,mBAAmB,GAAG;IACzB,OAAO,EAAE,YAAY,CAAC,UAAU,CAAC;IACjC,OAAO,EAAE,WAAW,CAAC;IACrB,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,OAAO,EAAE,YAAY,CAAC,MAAM,CAAC;IAE7B,OAAO,EAAE,SAAS,CAAC;CACpB,CAAC;AAOF,qBAAa,kBAAmB,YAAW,OAAO,CAAC,mBAAmB;IAElE,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,SAAS;IAFnB,OAAO;IAKP,MAAM,CAAC,mBAAmB,CACxB,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE,SAAS,CAAC,EAC/C,SAAS,EAAE,SAAS,GACnB,kBAAkB;IAIrB,MAAM,CAAC,eAAe,CAAC,SAAS,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,EAAE,SAAS,EAAE,SAAS,GAAG,kBAAkB;IAI7G,SAAS,IAAI,SAAS;IAItB,OAAO,IAAI,SAAS,GAAG,IAAI;IAS3B,eAAe,IAAI,SAAS,GAAG,IAAI;IAInC,iBAAiB,CAAC,SAAS,EAAE,GAAG,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI;IAIvE,cAAc,CAAC,SAAS,EAAE,GAAG,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI;IAIpE,WAAW,IAAI,SAAS,GAAG,IAAI;IAI/B,UAAU,IAAI,SAAS,GAAG,IAAI;IAI9B,kBAAkB,IAAI,SAAS,GAAG,IAAI;IAItC,aAAa,IAAI,SAAS,GAAG,IAAI;IAIjC,YAAY,IAAI,SAAS,GAAG,IAAI;IAIhC,WAAW,CAAC,SAAS,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI;IAI7C,eAAe,CAAC,SAAS,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI;IAIjD,uBAAuB,IAAI,SAAS,GAAG,IAAI;IAa3C,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI;CAuBnD"}
+{"version":3,"file":"fetch-externalities.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/externalities/fetch-externalities.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAA4B,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC/G,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAkB,KAAK,WAAW,EAAW,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC3F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAgC,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAQ5E,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAInD,oBAAY,mBAAmB;IAC7B,OAAO,IAAI;IACX,QAAQ,IAAI;CACb;AAED,MAAM,MAAM,iBAAiB,GACzB;IACE,IAAI,EAAE,mBAAmB,CAAC,OAAO,CAAC;IAClC,KAAK,EAAE,OAAO,CAAC;CAChB,GACD;IACE,IAAI,EAAE,mBAAmB,CAAC,QAAQ,CAAC;IACnC,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAEN,eAAO,MAAM,mBAAmB,6EAG9B,CAAC;AAEH,eAAO,MAAM,sBAAsB,gHAA4C,CAAC;AA0ChF,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,SAAS,aA6CvD;AAED;;;;;GAKG;AACH,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;IAS3B,CAAC;AACH,KAAK,eAAe,GAAG,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACnE,KAAK,mBAAmB,GAAG,WAAW,CAAC,OAAO,uBAAuB,CAAC,IAAI,CAAC,CAAC;AAE5E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,CAW/D;AAED,gGAAgG;AAChG,MAAM,MAAM,oBAAoB,GAAG;IACjC,+CAA+C;IAC/C,WAAW,EAAE,eAAe,CAAC;IAC7B,yDAAyD;IACzD,iBAAiB,EAAE,YAAY,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC;CACvE,CAAC;AAEF,iDAAiD;AACjD,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,GAAG,oBAAoB,CAY9G;AAED,4FAA4F;AAC5F,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAElE"}

package/packages/jam/transition/externalities/fetch-externalities.js

@@ -1,6 +1,9 @@
+import { reencodeAsView } from "#@typeberry/block";
 import { G_I, MAX_REPORT_DEPENDENCIES, O, Q, T, W_A, W_B, W_C, W_M, W_T, W_X } from "#@typeberry/block/gp-constants.js";
-import { MAX_NUMBER_OF_WORK_ITEMS } from "#@typeberry/block/work-package.js";
-import { codec, Encoder } from "#@typeberry/codec";
+import { MAX_NUMBER_OF_WORK_ITEMS, WorkPackage } from "#@typeberry/block/work-package.js";
+import { BytesBlob } from "#@typeberry/bytes";
+import { codec, Decoder, Encoder, SequenceView } from "#@typeberry/codec";
+import { HASH_SIZE } from "#@typeberry/hash";
 import { PendingTransfer } from "#@typeberry/jam-host-calls";
 import { tryAsU16, tryAsU32, tryAsU64 } from "#@typeberry/numbers";
 import { BASE_SERVICE_BALANCE, ELECTIVE_BYTE_BALANCE, ELECTIVE_ITEM_BALANCE, MAX_RECENT_HISTORY, } from "#@typeberry/state";
@@ -17,7 +20,7 @@ export const TRANSFER_OR_OPERAND = codec.union("TransferOrOperand", {
     [TransferOperandKind.OPERAND]: codec.object({ value: Operand.Codec }),
     [TransferOperandKind.TRANSFER]: codec.object({ value: PendingTransfer.Codec }),
 });
-const TRANSFERS_AND_OPERANDS = codec.sequenceVarLen(TRANSFER_OR_OPERAND);
+export const TRANSFERS_AND_OPERANDS = codec.sequenceVarLen(TRANSFER_OR_OPERAND);
 // https://github.com/gavofyork/graypaper/pull/414
 // 0.7.0 encoding is used for prior versions as well.
 const CONSTANTS_CODEC = codec.object({
@@ -56,7 +59,7 @@ const CONSTANTS_CODEC = codec.object({
     Y: codec.u32,
 });
 const encodedConstantsCache = new Map();
-function getEncodedConstants(chainSpec) {
+export function getEncodedConstants(chainSpec) {
     const constsFromCache = encodedConstantsCache.get(chainSpec);
     if (constsFromCache !== undefined) {
         return constsFromCache;
@@ -99,89 +102,42 @@ function getEncodedConstants(chainSpec) {
     encodedConstantsCache.set(chainSpec, encodedConsts);
     return encodedConsts;
 }
-var FetchContext;
-(function (FetchContext) {
-    FetchContext[FetchContext["Accumulate"] = 0] = "Accumulate";
-    FetchContext[FetchContext["Refine"] = 1] = "Refine";
-})(FetchContext || (FetchContext = {}));
-export class FetchExternalities {
-    fetchData;
-    chainSpec;
-    constructor(fetchData, chainSpec) {
-        this.fetchData = fetchData;
-        this.chainSpec = chainSpec;
-    }
-    static createForAccumulate(fetchData, chainSpec) {
-        return new FetchExternalities({ context: FetchContext.Accumulate, ...fetchData }, chainSpec);
-    }
-    static createForRefine(fetchData, chainSpec) {
-        return new FetchExternalities({ context: FetchContext.Refine, ...fetchData }, chainSpec);
-    }
-    constants() {
-        return getEncodedConstants(this.chainSpec);
-    }
-    entropy() {
-        const { entropy } = this.fetchData;
-        if (entropy === undefined) {
-            return null;
-        }
-        return entropy.asOpaque();
-    }
-    authorizerTrace() {
-        return null;
-    }
-    workItemExtrinsic(_workItem, _index) {
-        return null;
-    }
-    workItemImport(_workItem, _index) {
-        return null;
-    }
-    workPackage() {
-        return null;
-    }
-    authorizer() {
-        return null;
-    }
-    authorizationToken() {
-        return null;
-    }
-    refineContext() {
-        return null;
-    }
-    allWorkItems() {
-        return null;
-    }
-    oneWorkItem(_workItem) {
-        return null;
-    }
-    workItemPayload(_workItem) {
-        return null;
-    }
-    allTransfersAndOperands() {
-        if (this.fetchData.context === FetchContext.Accumulate) {
-            const { transfers, operands } = this.fetchData;
-            const transfersAndOperands = transfers
-                .map((transfer) => ({ kind: TransferOperandKind.TRANSFER, value: transfer }))
-                .concat(operands.map((operand) => ({ kind: TransferOperandKind.OPERAND, value: operand })));
-            return Encoder.encodeObject(TRANSFERS_AND_OPERANDS, transfersAndOperands, this.chainSpec);
-        }
-        return null;
-    }
-    oneTransferOrOperand(index) {
-        if (this.fetchData.context === FetchContext.Accumulate) {
-            const { operands, transfers } = this.fetchData;
-            if (index >= operands.length + transfers.length) {
-                return null;
-            }
-            const kind = index < operands.length ? TransferOperandKind.OPERAND : TransferOperandKind.TRANSFER;
-            const transferOrOperand = kind === TransferOperandKind.OPERAND
-                ? { kind: TransferOperandKind.OPERAND, value: operands[Number(index)] }
-                : { kind: TransferOperandKind.TRANSFER, value: transfers[Number(index) - operands.length] };
-            if (transferOrOperand.value === undefined) {
-                return null;
-            }
-            return Encoder.encodeObject(TRANSFER_OR_OPERAND, transferOrOperand, this.chainSpec);
-        }
-        return null;
-    }
+/**
+ * `S(w)` — work-item summary used by fetch in both the IsAuthorized
+ * and Refine contexts.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/31fc0231fc02?v=0.7.2
+ */
+const WORK_ITEM_SUMMARY_CODEC = codec.object({
+    service: codec.u32.asOpaque(),
+    codeHash: codec.bytes(HASH_SIZE).asOpaque(),
+    refineGasLimit: codec.u64.asOpaque(),
+    accumulateGasLimit: codec.u64.asOpaque(),
+    exportCount: codec.u16,
+    importSegmentsCount: codec.u16,
+    extrinsicCount: codec.u16,
+    payloadLength: codec.u32,
+});
+export function encodeWorkItemSummary(item) {
+    return Encoder.encodeObject(WORK_ITEM_SUMMARY_CODEC, {
+        service: item.service,
+        codeHash: item.codeHash,
+        refineGasLimit: item.refineGasLimit,
+        accumulateGasLimit: item.accumulateGasLimit,
+        exportCount: item.exportCount,
+        importSegmentsCount: tryAsU16(item.importSegments.length),
+        extrinsicCount: tryAsU16(item.extrinsic.length),
+        payloadLength: tryAsU32(item.payload.length),
+    });
+}
+/** Eagerly build the per-package fetch views. */
+export function buildWorkPackageFetchData(chainSpec, workPackage) {
+    const packageView = reencodeAsView(WorkPackage.Codec, workPackage, chainSpec);
+    const summariesBlob = BytesBlob.blobFromParts(workPackage.items.map((i) => encodeWorkItemSummary(i).raw));
+    const workItemSummaries = new SequenceView(Decoder.fromBytesBlob(summariesBlob), WORK_ITEM_SUMMARY_CODEC, workPackage.items.length);
+    return { packageView, workItemSummaries };
+}
+/** Converts u64 value taken from a register into valid index of array of given `length`. */
+export function u64ToArrayIndex(v, len) {
+    return v < BigInt(len) ? Number(v) : null;
 }

package/packages/jam/transition/externalities/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./accumulate-externalities.js";
+export * from "./accumulate-fetch-externalities.js";
 export * from "./fetch-externalities.js";
 //# sourceMappingURL=index.d.ts.map

package/packages/jam/transition/externalities/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/externalities/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/externalities/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC"}

package/packages/jam/transition/externalities/index.js

@@ -1,2 +1,3 @@
 export * from "./accumulate-externalities.js";
+export * from "./accumulate-fetch-externalities.js";
 export * from "./fetch-externalities.js";

package/packages/jam/transition/hasher.d.ts

@@ -7,7 +7,8 @@ export declare class TransitionHasher implements MmrHasher<KeccakHash> {
     private readonly keccakHasher;
     readonly blake2b: Blake2b;
     static create(): Promise<TransitionHasher>;
-    constructor(keccakHasher: keccak.KeccakHasher, blake2b: Blake2b);
+    static new(keccakHasher: keccak.KeccakHasher, blake2b: Blake2b): TransitionHasher;
+    private constructor();
     /** Concatenates two hashes and hash this concatenation */
     hashConcat(a: KeccakHash, b: KeccakHash): KeccakHash;
     hashConcatPrepend(id: BytesBlob, a: KeccakHash, b: KeccakHash): KeccakHash;

package/packages/jam/transition/hasher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hasher.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/transition/hasher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAkB,MAAM,kBAAkB,CAAC;AAC7G,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAC/F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGhD,8DAA8D;AAC9D,qBAAa,gBAAiB,YAAW,SAAS,CAAC,UAAU,CAAC;IAM1D,OAAO,CAAC,QAAQ,CAAC,YAAY;aACb,OAAO,EAAE,OAAO;WANrB,MAAM;gBAKA,YAAY,EAAE,MAAM,CAAC,YAAY,EAClC,OAAO,EAAE,OAAO;IAGlC,0DAA0D;IAC1D,UAAU,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU;IAIpD,iBAAiB,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU;IAI1E,8CAA8C;IAC9C,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAI5D;;;;OAIG;IACH,SAAS,CAAC,aAAa,EAAE,aAAa,GAAG,gBAAgB,CAAC,aAAa,EAAE,aAAa,CAAC;CA4BxF"}
+{"version":3,"file":"hasher.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/transition/hasher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAkB,MAAM,kBAAkB,CAAC;AAC7G,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAC/F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGhD,8DAA8D;AAC9D,qBAAa,gBAAiB,YAAW,SAAS,CAAC,UAAU,CAAC;IAU1D,OAAO,CAAC,QAAQ,CAAC,YAAY;aACb,OAAO,EAAE,OAAO;WAVrB,MAAM;IAInB,MAAM,CAAC,GAAG,CAAC,YAAY,EAAE,MAAM,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO;IAI9D,OAAO;IAKP,0DAA0D;IAC1D,UAAU,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU;IAIpD,iBAAiB,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU;IAI1E,8CAA8C;IAC9C,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAI5D;;;;OAIG;IACH,SAAS,CAAC,aAAa,EAAE,aAAa,GAAG,gBAAgB,CAAC,aAAa,EAAE,aAAa,CAAC;CA4BxF"}

package/packages/jam/transition/hasher.js

@@ -9,6 +9,9 @@ export class TransitionHasher {
     static async create() {
         return new TransitionHasher(await keccak.KeccakHasher.create(), await Blake2b.createHasher());
     }
+    static new(keccakHasher, blake2b) {
+        return new TransitionHasher(keccakHasher, blake2b);
+    }
     constructor(keccakHasher, blake2b) {
         this.keccakHasher = keccakHasher;
         this.blake2b = blake2b;
@@ -22,7 +25,7 @@ export class TransitionHasher {
     }
     /** Creates hash from the block header view */
     header(header) {
-        return new WithHash(this.blake2b.hashBytes(header.encoded()).asOpaque(), header);
+        return WithHash.new(this.blake2b.hashBytes(header.encoded()).asOpaque(), header);
     }
     /**
      * Merkle commitment of the extrinsic data
@@ -49,6 +52,6 @@ export class TransitionHasher {
         const ea = this.blake2b.hashBytes(extrinsicView.assurances.encoded()).asOpaque();
         const ed = this.blake2b.hashBytes(extrinsicView.disputes.encoded()).asOpaque();
         const encoded = BytesBlob.blobFromParts([et.raw, ep.raw, eg.raw, ea.raw, ed.raw]);
-        return new WithHashAndBytes(this.blake2b.hashBytes(encoded).asOpaque(), extrinsicView, encoded);
+        return WithHashAndBytes.create(this.blake2b.hashBytes(encoded).asOpaque(), extrinsicView, encoded);
     }
 }

package/packages/jam/transition/hasher.test.js

@@ -20,7 +20,7 @@ describe("TransitionHasher", () => {
         async function prepareHasher() {
             const keccakHasher = await keccak.KeccakHasher.create();
             const blake2b = await Blake2b.createHasher();
-            return new TransitionHasher(keccakHasher, blake2b);
+            return TransitionHasher.new(keccakHasher, blake2b);
         }
         function prepareExtrinsicView(partialExtrinsic) {
             const spec = tinyChainSpec;