@typeberry/lib 0.5.10-6cb1bd5 → 0.5.10-9567cee

package/packages/jam/jam-host-calls/general/fetch.test.js

@@ -1,14 +1,15 @@
 import assert from "node:assert";
 import { describe, it } from "node:test";
 import { tryAsServiceId } from "#@typeberry/block";
-import { BytesBlob } from "#@typeberry/bytes";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
 import { tryAsU64 } from "#@typeberry/numbers";
 import { HostCallMemory, HostCallRegisters, PvmExecution } from "#@typeberry/pvm-host-calls";
 import { tryAsGas } from "#@typeberry/pvm-interface";
 import { gasCounter, MemoryBuilder, tryAsMemoryIndex, tryAsSbrkIndex } from "#@typeberry/pvm-interpreter";
 import { PAGE_SIZE } from "#@typeberry/pvm-interpreter/memory/memory-consts.js";
 import { emptyRegistersBuffer } from "../utils.js";
-import { Fetch, FetchKind } from "./fetch.js";
+import { Fetch, FetchContext, FetchKind } from "./fetch.js";
 import { HostCallResult } from "./results.js";
 describe("Fetch", () => {
     const IN_OUT_REG = 7;
@@ -16,7 +17,7 @@ describe("Fetch", () => {
     it("should return PvmExecution.Panic if memory write fails", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([1, 2, 3]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         fetchMock.constantsResponse = blob;
         const badOffset = tryAsU64(0xfffff);
         const registers = new HostCallRegisters(emptyRegistersBuffer());
@@ -33,10 +34,10 @@ describe("Fetch", () => {
     });
     it("should write empty result and set IN_OUT_REG to NONE if fetch returns null", async () => {
         const currentServiceId = tryAsServiceId(10_000);
-        const fetchMock = new FetchMock();
-        fetchMock.entropyResponse = null;
+        const fetchMock = new RefineFetchMock();
+        // authorizerTraceResponse is null by default — Kind 2 legitimately returns null
         const blob = BytesBlob.blobFromNumbers([]);
-        const { registers, memory, readBack } = prepareRegsAndMemory(blob, FetchKind.Entropy);
+        const { registers, memory, readBack } = prepareRegsAndMemory(blob, FetchKind.AuthorizerTrace);
         const fetch = new Fetch(currentServiceId, fetchMock);
         const result = await fetch.execute(gas, registers, memory);
         assert.strictEqual(result, undefined);
@@ -47,7 +48,7 @@ describe("Fetch", () => {
     it("should write nothing if offset >= blob length", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([1, 2, 3]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         fetchMock.constantsResponse = blob;
         const { registers, memory, readBack } = prepareRegsAndMemory(blob, FetchKind.Constants, 5, 2);
         const fetch = new Fetch(currentServiceId, fetchMock);
@@ -59,7 +60,7 @@ describe("Fetch", () => {
     it("should clamp offset + length to blob end", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([9, 8, 7, 6, 5]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         fetchMock.constantsResponse = blob;
         const { registers, memory, readBack } = prepareRegsAndMemory(blob, FetchKind.Constants, 3, 10);
         const fetch = new Fetch(currentServiceId, fetchMock);
@@ -71,7 +72,7 @@ describe("Fetch", () => {
     it("should return NONE and write nothing if fetch kind is unknown", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.empty();
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         fetchMock.constantsResponse = blob;
         const { registers, memory, readBack } = prepareRegsAndMemory(blob, FetchKind.Constants);
         registers.set(10, tryAsU64(999));
@@ -84,7 +85,7 @@ describe("Fetch", () => {
     it("should fetch constants and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([1, 2, 3, 4, 5]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         fetchMock.constantsResponse = blob;
         const { registers, memory, readBack, expectedLength } = prepareRegsAndMemory(blob, FetchKind.Constants);
         const fetch = new Fetch(currentServiceId, fetchMock);
@@ -95,8 +96,8 @@ describe("Fetch", () => {
     });
     it("should fetch entropy and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
-        const blob = BytesBlob.blobFromNumbers([10, 20, 30, 40]);
-        const fetchMock = new FetchMock();
+        const blob = Bytes.fill(HASH_SIZE, 10).asOpaque();
+        const fetchMock = new RefineFetchMock();
         fetchMock.entropyResponse = blob;
         const { registers, memory, readBack, expectedLength } = prepareRegsAndMemory(blob, FetchKind.Entropy);
         const fetch = new Fetch(currentServiceId, fetchMock);
@@ -108,7 +109,7 @@ describe("Fetch", () => {
     it("should fetch authorizer trace and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([9, 9, 9]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         fetchMock.authorizerTraceResponse = blob;
         const { registers, memory, readBack, expectedLength } = prepareRegsAndMemory(blob, FetchKind.AuthorizerTrace);
         const fetch = new Fetch(currentServiceId, fetchMock);
@@ -120,7 +121,7 @@ describe("Fetch", () => {
     it("should fetch other work item extrinsics and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([42, 43, 44]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         const workItem = tryAsU64(123);
         const index = tryAsU64(7);
         const key = `${workItem}:${index}`;
@@ -138,7 +139,7 @@ describe("Fetch", () => {
     it("should fetch my extrinsics and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([11, 12, 13]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         const index = tryAsU64(5);
         const key = `null:${index}`;
         fetchMock.workItemExtrinsicResponses.set(key, blob);
@@ -154,7 +155,7 @@ describe("Fetch", () => {
     it("should fetch other work item imports and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([21, 22, 23]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         const workItem = tryAsU64(42);
         const index = tryAsU64(3);
         const key = `${workItem}:${index}`;
@@ -172,7 +173,7 @@ describe("Fetch", () => {
     it("should fetch my imports and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([31, 32, 33]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         const index = tryAsU64(8);
         const key = `null:${index}`;
         fetchMock.workItemImportResponses.set(key, blob);
@@ -188,7 +189,7 @@ describe("Fetch", () => {
     it("should fetch work package and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([100, 101, 102]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         fetchMock.workPackageResponse = blob;
         const { registers, memory, readBack, expectedLength } = prepareRegsAndMemory(blob, FetchKind.WorkPackage);
         const fetch = new Fetch(currentServiceId, fetchMock);
@@ -200,7 +201,7 @@ describe("Fetch", () => {
     it("should fetch authorizer and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([201, 202, 203]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         fetchMock.authorizerResponse = blob;
         const { registers, memory, readBack, expectedLength } = prepareRegsAndMemory(blob, FetchKind.Authorizer);
         const fetch = new Fetch(currentServiceId, fetchMock);
@@ -212,7 +213,7 @@ describe("Fetch", () => {
     it("should fetch authorization token and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([210, 211, 212]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         fetchMock.authorizationTokenResponse = blob;
         const { registers, memory, readBack, expectedLength } = prepareRegsAndMemory(blob, FetchKind.AuthorizationToken);
         const fetch = new Fetch(currentServiceId, fetchMock);
@@ -224,7 +225,7 @@ describe("Fetch", () => {
     it("should fetch refine context and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([88, 89, 90]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         fetchMock.refineContextResponse = blob;
         const { registers, memory, readBack, expectedLength } = prepareRegsAndMemory(blob, FetchKind.RefineContext);
         const fetch = new Fetch(currentServiceId, fetchMock);
@@ -236,7 +237,7 @@ describe("Fetch", () => {
     it("should fetch all work items and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([70, 71, 72]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         fetchMock.allWorkItemsResponse = blob;
         const { registers, memory, readBack, expectedLength } = prepareRegsAndMemory(blob, FetchKind.AllWorkItems);
         const fetch = new Fetch(currentServiceId, fetchMock);
@@ -248,7 +249,7 @@ describe("Fetch", () => {
     it("should fetch one work item and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([33, 34, 35]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         const workItem = tryAsU64(55);
         fetchMock.oneWorkItemResponses.set(workItem.toString(), blob);
         const { registers, memory, readBack, expectedLength } = prepareRegsAndMemory(blob, FetchKind.OneWorkItem);
@@ -263,7 +264,7 @@ describe("Fetch", () => {
     it("should fetch work item payload and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([60, 61, 62]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new RefineFetchMock();
         const workItem = tryAsU64(77);
         fetchMock.workItemPayloadResponses.set(workItem.toString(), blob);
         const { registers, memory, readBack, expectedLength } = prepareRegsAndMemory(blob, FetchKind.WorkItemPayload);
@@ -278,8 +279,8 @@ describe("Fetch", () => {
     it("should fetch all transfers and operands and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([101, 102, 103]);
-        const fetchMock = new FetchMock();
-        fetchMock.allTransfersAndOperandsResponses = blob;
+        const fetchMock = new AccumulateFetchMock();
+        fetchMock.allTransfersAndOperandsResponse = blob;
         const { registers, memory, readBack, expectedLength } = prepareRegsAndMemory(blob, FetchKind.AllTransfersAndOperands);
         const fetch = new Fetch(currentServiceId, fetchMock);
         const result = await fetch.execute(gas, registers, memory);
@@ -290,7 +291,7 @@ describe("Fetch", () => {
     it("should fetch one operand or transfer and write result to memory", async () => {
         const currentServiceId = tryAsServiceId(10_000);
         const blob = BytesBlob.blobFromNumbers([115, 116, 117]);
-        const fetchMock = new FetchMock();
+        const fetchMock = new AccumulateFetchMock();
         const index = tryAsU64(9);
         fetchMock.oneTransferOrOperandResponses.set(index.toString(), blob);
         const { registers, memory, readBack, expectedLength } = prepareRegsAndMemory(blob, FetchKind.OneTransferOrOperand);
@@ -302,6 +303,43 @@ describe("Fetch", () => {
         assert.deepStrictEqual(readBack(), blob.raw);
         assert.deepStrictEqual(fetchMock.oneTransferOrOperandData, [[index]]);
     });
+    it("should return NONE for refine-only kinds in accumulate context", async () => {
+        const currentServiceId = tryAsServiceId(10_000);
+        const fetchMock = new AccumulateFetchMock();
+        const blob = BytesBlob.empty();
+        for (const kind of [
+            FetchKind.AuthorizerTrace,
+            FetchKind.OtherWorkItemExtrinsics,
+            FetchKind.MyExtrinsics,
+            FetchKind.OtherWorkItemImports,
+            FetchKind.MyImports,
+            FetchKind.WorkPackage,
+            FetchKind.Authorizer,
+            FetchKind.AuthorizationToken,
+            FetchKind.RefineContext,
+            FetchKind.AllWorkItems,
+            FetchKind.OneWorkItem,
+            FetchKind.WorkItemPayload,
+        ]) {
+            const { registers, memory } = prepareRegsAndMemory(blob, kind);
+            const fetch = new Fetch(currentServiceId, fetchMock);
+            const result = await fetch.execute(gas, registers, memory);
+            assert.strictEqual(result, undefined, `Expected undefined for kind ${kind}`);
+            assert.strictEqual(registers.get(IN_OUT_REG), HostCallResult.NONE, `Expected NONE for kind ${kind}`);
+        }
+    });
+    it("should return NONE for accumulate-only kinds in refine context", async () => {
+        const currentServiceId = tryAsServiceId(10_000);
+        const fetchMock = new RefineFetchMock();
+        const blob = BytesBlob.empty();
+        for (const kind of [FetchKind.AllTransfersAndOperands, FetchKind.OneTransferOrOperand]) {
+            const { registers, memory } = prepareRegsAndMemory(blob, kind);
+            const fetch = new Fetch(currentServiceId, fetchMock);
+            const result = await fetch.execute(gas, registers, memory);
+            assert.strictEqual(result, undefined, `Expected undefined for kind ${kind}`);
+            assert.strictEqual(registers.get(IN_OUT_REG), HostCallResult.NONE, `Expected NONE for kind ${kind}`);
+        }
+    });
     function prepareRegsAndMemory(blob, fetchKind, offset = 0, length = blob.length) {
         const pageStart = 2 ** 16;
         const memOffset = tryAsU64(pageStart + 1234);
@@ -327,14 +365,12 @@ describe("Fetch", () => {
         };
     }
 });
-class FetchMock {
+class RefineFetchMock {
+    context = FetchContext.Refine;
     workItemExtrinsicData = [];
     workItemImportData = [];
     oneWorkItemData = [];
     workItemPayloadData = [];
-    oneOperandData = [];
-    oneTransferData = [];
-    oneTransferOrOperandData = [];
     constantsResponse = null;
     entropyResponse = null;
     authorizerTraceResponse = null;
@@ -347,12 +383,6 @@ class FetchMock {
     allWorkItemsResponse = null;
     oneWorkItemResponses = new Map();
     workItemPayloadResponses = new Map();
-    allOperandsResponse = null;
-    oneOperandResponses = new Map();
-    allTransfersResponse = null;
-    oneTransferResponses = new Map();
-    allTransfersAndOperandsResponses = null;
-    oneTransferOrOperandResponses = new Map();
     constants() {
         if (this.constantsResponse === null) {
             throw new Error("Unexpected call to constants.");
@@ -360,6 +390,9 @@ class FetchMock {
         return this.constantsResponse;
     }
     entropy() {
+        if (this.entropyResponse === null) {
+            throw new Error("Unexpected call to entropy.");
+        }
         return this.entropyResponse;
     }
     authorizerTrace() {
@@ -412,30 +445,28 @@ class FetchMock {
         }
         return this.workItemPayloadResponses.get(key) ?? null;
     }
-    allOperands() {
-        return this.allOperandsResponse;
-    }
-    oneOperand(operandIndex) {
-        this.oneOperandData.push([operandIndex]);
-        const key = operandIndex.toString();
-        if (!this.oneOperandResponses.has(key)) {
-            throw new Error(`Missing mock response for oneOperand(${key})`);
+}
+class AccumulateFetchMock {
+    context = FetchContext.Accumulate;
+    oneTransferOrOperandData = [];
+    constantsResponse = null;
+    entropyResponse = null;
+    allTransfersAndOperandsResponse = null;
+    oneTransferOrOperandResponses = new Map();
+    constants() {
+        if (this.constantsResponse === null) {
+            throw new Error("Unexpected call to constants.");
         }
-        return this.oneOperandResponses.get(key) ?? null;
-    }
-    allTransfers() {
-        return this.allTransfersResponse;
+        return this.constantsResponse;
     }
-    oneTransfer(transferIndex) {
-        this.oneTransferData.push([transferIndex]);
-        const key = transferIndex.toString();
-        if (!this.oneTransferResponses.has(key)) {
-            throw new Error(`Missing mock response for oneTransfer(${key})`);
+    entropy() {
+        if (this.entropyResponse === null) {
+            throw new Error("Unexpected call to entropy.");
         }
-        return this.oneTransferResponses.get(key) ?? null;
+        return this.entropyResponse;
     }
     allTransfersAndOperands() {
-        return this.allTransfersAndOperandsResponses;
+        return this.allTransfersAndOperandsResponse;
     }
     oneTransferOrOperand(index) {
         this.oneTransferOrOperandData.push([index]);

package/packages/jam/transition/accumulate/accumulate.js

@@ -11,7 +11,7 @@ import { MAX_VALUE_U64, sumU64, tryAsU32 } from "#@typeberry/numbers";
 import { accumulationOutputComparator, hashComparator, ServiceAccountInfo, tryAsPerCore, } from "#@typeberry/state";
 import { assertEmpty, Compatibility, GpVersion, Result, TestSuite } from "#@typeberry/utils";
 import { AccumulateExternalities } from "../externalities/accumulate-externalities.js";
-import { FetchExternalities } from "../externalities/index.js";
+import { AccumulateFetchExternalities } from "../externalities/accumulate-fetch-externalities.js";
 import { AccumulateData } from "./accumulate-data.js";
 import { AccumulateQueue, pruneQueue } from "./accumulate-queue.js";
 import { GAS_TO_INVOKE_WORK_REPORT, } from "./accumulate-state.js";
@@ -86,7 +86,7 @@ export class Accumulate {
         }
         const nextServiceId = generateNextServiceId({ serviceId, entropy, timeslot: slot }, this.chainSpec, this.blake2b);
         const partialState = new AccumulateExternalities(this.chainSpec, this.blake2b, updatedState, serviceId, nextServiceId, slot);
-        const fetchExternalities = FetchExternalities.createForAccumulate({ entropy, transfers, operands }, this.chainSpec);
+        const fetchExternalities = new AccumulateFetchExternalities(entropy, transfers, operands, this.chainSpec);
         const externalities = {
             partialState,
             serviceExternalities: partialState,

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);
+    });
+});