@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

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

@@ -0,0 +1,193 @@
+import { describe, it } from "node:test";
+import { Extrinsic, tryAsCoreIndex, tryAsServiceGas, tryAsServiceId, tryAsTimeSlot, tryAsValidatorIndex, } from "#@typeberry/block";
+import { Credential, ReportGuarantee } from "#@typeberry/block/guarantees.js";
+import { RefineContext, WorkPackageInfo } from "#@typeberry/block/refine-context.js";
+import { SignedTicket, tryAsTicketAttempt } from "#@typeberry/block/tickets.js";
+import { WorkPackageSpec, WorkReport } from "#@typeberry/block/work-report.js";
+import { WorkExecResult, WorkExecResultKind, WorkRefineLoad, WorkResult } from "#@typeberry/block/work-result.js";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { Decoder, Encoder } from "#@typeberry/codec";
+import { asKnownSize } from "#@typeberry/collections";
+import { tinyChainSpec } from "#@typeberry/config";
+import { ED25519_SIGNATURE_BYTES } from "#@typeberry/crypto";
+import { BANDERSNATCH_PROOF_BYTES } from "#@typeberry/crypto/bandersnatch.js";
+import { Blake2b, HASH_SIZE, keccak } from "#@typeberry/hash";
+import { tryAsU16, tryAsU32 } from "#@typeberry/numbers";
+import { asOpaqueType, deepEqual } from "#@typeberry/utils";
+import { TransitionHasher } from "./hasher.js";
+describe("TransitionHasher", () => {
+    describe("extrinsic", () => {
+        async function prepareHasher() {
+            const keccakHasher = await keccak.KeccakHasher.create();
+            const blake2b = await Blake2b.createHasher();
+            return new TransitionHasher(keccakHasher, blake2b);
+        }
+        function prepareExtrinsicView(partialExtrinsic) {
+            const spec = tinyChainSpec;
+            const extrinsic = Extrinsic.create({
+                tickets: partialExtrinsic.tickets ?? asOpaqueType([]),
+                preimages: partialExtrinsic.preimages ?? [],
+                guarantees: partialExtrinsic.guarantees ?? asOpaqueType([]),
+                assurances: partialExtrinsic.assurances ?? asOpaqueType([]),
+                disputes: partialExtrinsic.disputes ?? {
+                    verdicts: [],
+                    culprits: [],
+                    faults: [],
+                },
+            });
+            const encodedBlock = Encoder.encodeObject(Extrinsic.Codec, extrinsic, spec);
+            return Decoder.decodeObject(Extrinsic.Codec.View, encodedBlock, spec);
+        }
+        function prepareTickets() {
+            return rawTickets.map(({ attempt, signature }) => SignedTicket.create({
+                attempt: tryAsTicketAttempt(attempt),
+                signature: Bytes.parseBytes(signature, BANDERSNATCH_PROOF_BYTES).asOpaque(),
+            }));
+        }
+        function prepareGuarantees() {
+            return rawGuarantees.map(({ report, slot, signatures }) => ReportGuarantee.create({
+                report: WorkReport.create({
+                    workPackageSpec: WorkPackageSpec.create({
+                        erasureRoot: Bytes.parseBytes(report.package_spec.erasure_root, HASH_SIZE).asOpaque(),
+                        exportsCount: tryAsU16(report.package_spec.exports_count),
+                        exportsRoot: Bytes.parseBytes(report.package_spec.exports_root, HASH_SIZE).asOpaque(),
+                        hash: Bytes.parseBytes(report.package_spec.hash, HASH_SIZE).asOpaque(),
+                        length: tryAsU32(report.package_spec.length),
+                    }),
+                    authorizationGasUsed: tryAsServiceGas(report.auth_gas_used),
+                    authorizationOutput: BytesBlob.parseBlob(report.auth_output),
+                    authorizerHash: Bytes.parseBytes(report.authorizer_hash, HASH_SIZE).asOpaque(),
+                    context: RefineContext.create({
+                        anchor: Bytes.parseBytes(report.context.anchor, HASH_SIZE).asOpaque(),
+                        beefyRoot: Bytes.parseBytes(report.context.beefy_root, HASH_SIZE).asOpaque(),
+                        lookupAnchor: Bytes.parseBytes(report.context.lookup_anchor, HASH_SIZE).asOpaque(),
+                        lookupAnchorSlot: tryAsTimeSlot(report.context.lookup_anchor_slot),
+                        prerequisites: report.context.prerequisites.map((p) => Bytes.parseBytes(p, HASH_SIZE).asOpaque()),
+                        stateRoot: Bytes.parseBytes(report.context.state_root, HASH_SIZE).asOpaque(),
+                    }),
+                    coreIndex: tryAsCoreIndex(report.core_index),
+                    results: asKnownSize(report.results.map((result) => WorkResult.create({
+                        codeHash: Bytes.parseBytes(result.code_hash, HASH_SIZE).asOpaque(),
+                        gas: tryAsServiceGas(result.accumulate_gas),
+                        load: WorkRefineLoad.create({
+                            exportedSegments: tryAsU32(result.refine_load.exports),
+                            extrinsicCount: tryAsU32(result.refine_load.extrinsic_count),
+                            extrinsicSize: tryAsU32(result.refine_load.extrinsic_size),
+                            gasUsed: tryAsServiceGas(result.refine_load.gas_used),
+                            importedSegments: tryAsU32(result.refine_load.imports),
+                        }),
+                        payloadHash: Bytes.parseBytes(result.payload_hash, HASH_SIZE).asOpaque(),
+                        result: new WorkExecResult(WorkExecResultKind.ok, BytesBlob.parseBlob(result.result.ok)),
+                        serviceId: tryAsServiceId(result.service_id),
+                    }))),
+                    segmentRootLookup: report.segment_root_lookup.map((l) => WorkPackageInfo.create(l)),
+                }),
+                slot: tryAsTimeSlot(slot),
+                credentials: asOpaqueType(signatures.map(({ signature, validator_index }) => Credential.create({
+                    validatorIndex: tryAsValidatorIndex(validator_index),
+                    signature: Bytes.parseBytes(signature, ED25519_SIGNATURE_BYTES).asOpaque(),
+                }))),
+            }));
+        }
+        it("should correctly return extrinsic hash of empty extrinsic", async () => {
+            const hasher = await prepareHasher();
+            const extrinsicView = prepareExtrinsicView({});
+            const expectedResult = Bytes.parseBytes("0x189d15af832dfe4f67744008b62c334b569fcbb4c261e0f065655697306ca252", HASH_SIZE).asOpaque();
+            const result = hasher.extrinsic(extrinsicView).hash;
+            deepEqual(result, expectedResult);
+        });
+        it("should correctly return extrinsic hash of extrinsic that includes only tickets", async () => {
+            const hasher = await prepareHasher();
+            const tickets = prepareTickets();
+            const extrinsicView = prepareExtrinsicView({ tickets: asOpaqueType(tickets) });
+            const expectedResult = Bytes.parseBytes("0x9ac8334917373bfacc7878c1a534f29a3b06cf251384f68caa8b07908e862730", HASH_SIZE).asOpaque();
+            const result = hasher.extrinsic(extrinsicView).hash;
+            deepEqual(result, expectedResult);
+        });
+        it("should correctly return extrinsic hash of extrinsic that includes tickets and guarantees", async () => {
+            const hasher = await prepareHasher();
+            const tickets = prepareTickets();
+            const guarantees = prepareGuarantees();
+            const extrinsicView = prepareExtrinsicView({
+                tickets: asOpaqueType(tickets),
+                guarantees: asOpaqueType(guarantees),
+            });
+            const expectedResult = Bytes.parseBytes("0xfc365cc4a1e5fffac3bf9a0189fc8fca444b9c5dff670b6b3ad4e4b6d925551c", HASH_SIZE).asOpaque();
+            const result = hasher.extrinsic(extrinsicView).hash;
+            deepEqual(result, expectedResult);
+        });
+    });
+});
+const rawTickets = [
+    {
+        attempt: 2,
+        signature: "0x4593a173876eeff9cbb1a1dbb067857e386965d0a422e1c2a29c3c58c58f65b713595ca36f5947fbf60a0aee00504d4c0d068f827a3dc433739aaa9555eaf91995c4c50e9c1643804a7c41286b43fe2060964568c56331506e93a95c23a0d44b6963f008572f0d0b2f30d09067e2bfa01fa235503c0ea66561dccb3600535863557248c0827ae485ab4ed43188950a6d8704aea89ff13b28689c00f686cf55072fd6e47525d55fe2ef3bb6b8e85f685a8b8b5e0d3df5857424013f0650ad520ca428fc718d79e8e6e777606e4c63356dd2f5eb5e3297481ba6fd1f08c39e98e8bca39c2d9a47ea0aa5ed2e6a338d873aaa3f3fbffda9992126930bba9b8725f188eb629abd74b01d359121332f3f03c33ab89aa298b4fb6614f5e1e855beccdf812659631b4196dd09def5a13d8c12d78984e4d40d5061330f9475493fffeae7fc54c75500e3238f8ae3f656244c5704b35e45f03cf1f262e0f17b51e8336f07f1fff60107bf5be44ce0486828e5fb957365e4ae04c46e226fa92149406339da5e25fc97d713807c46827923b249884b8b4bb3c04556d1cc5ab82365ded4681788fd142b5349ce38e24a570eed6ee6ae23b4b111c646cc378e9a9b220234c351c762ac911682662544fcae9cf9ad0b8c868be04f095a9d408d0b0818650a1a02ddae0770a93d1075bfaa8109cba03e96d81c9aabe3254ba03feda526306a1c631cec48c7155d13f61f529d79a19fbcf529743547229f4c24c9519cb78258d411e2e9804e30e6700cead3530aa44a38054e01df2f347ec427d59de6cff73e8852eeee44e134a0e1e1a9cad3eac11b1eb04d90d2845c46cde686a35f35b13189329136bcbf69868f5e3a934d0e7b5bffc4804203bbbc5970ac230624845388f702d2eac28d466f72aea463aa16ad4781f993038a9ca794963ab5195f8f948f1ecb194821f8b8018dd815d1220172cb373bb02d26678e08b66836fd3165eb88c12cfb41f971158f26908e1d69c3a4f537896a595647b28c65793841952aa83473f590c860aa421e1c2ae0e9d24ef760091a7394cde960ce46719850ab29632bfc8623d59a0af6e076cd7be61bbbf64d9e57",
+    },
+    {
+        attempt: 1,
+        signature: "0x7f289e0aa6851b2331ffadf11fdf28a496ca09ab0a01bf95cf2d381345a61b34baaaeb4281eab1737c3918b2af224472b079d9d9d92dd0e5003b33312a7be044edc3f3a86c6d4b19de08a33948973515960268932b53dd3c23252e4b384e93c0adbb4677535ddf65d1d36efc3a7db80e415510bee77da97619e892d875c4fce384c5c6b59b22ebfede0df2b383e9c32d99aa50ba5ee6b7dc714c51395f441005afce82feb448bb0ee0c27410a113a9cf23841c4578f63f66833d5f9c64708219a98e40054fc06b38d0b90651b868f5b53c8e0eca74691f915afa14d3ce39b528ba8f9d81cc1203834e147ac682713d1d9679cc43fcaeb70bf7c7f49f80b07826a6baf5c5075b9c309ae271ffc62c3f87c40745dd049e5a54ee6aaf3763761d4fa3022139bbce6a4b0c95a92392dafefe660d56d4f0bb7e5282396be3cdb6a7dc614376f5c616af6e8e3c28452c9be918aea84ae33f067f7739c36b47ceba2e803f4649463def9a5592e2edbe141d26cae9775ec93d1abb6e3eff90ca8d13a380f16e1b857c78835ae2f354986e55827038398daa624bdb329812a974e1a3ea1829f5cf11fa36ae66dc3c898abe1ba4001953c1425c05b5caaeeebe09ec7cca28c414cdef2811240bd6a938eb2d305565fa0e5eda2eb63a932634203dfc2c5638df5109c6bde9b8cba67a0c5d85d6c2e422b52d1984a77ba3c5f2c1202cd35e51cc6c0eb59d55dbab458c53996beaa3779bdefd60bc53c8d90b3627bcb9130938f97d2c02dbeae6dc687b536d4b03d04a48f3cc39b2422c6e36ff1bd03ec7c258541fedd4e52cc464e299293a1d14374edbd14a58c05ef8f42eadb36a7105c53daa7f3770cee2d6f82c6a8bb56d830e800b6b50771e2af3690690fe8259d8ecec4deb547aa704a0a89f4def23bf0958269fdf94bc7d693983b6b610a66ec6b283cde7873e783af22dc803c1b36d7a2d6aafbab9e0c0b6347be1973c6377c9141857f68888ebfaeb9316a2712a2c0aafd3ff5f4ec32d88af8f19a59096f35b029fa3df92305f074368682bce1d302f5a23aebdf75856be8090f0c5afcbb38b7f28583771900a97ca2831b0c1563e1b357d",
+    },
+    {
+        attempt: 2,
+        signature: "0xab22ea9dbacd085f073bd6bd89f86ac2ff2fb756efa7987ba75e34ae016f6b54b89be7c5dee8e263f0a7377d17efd837df4364712bd6dee764614fcfccd50941d9948186747a20d3f81840f3f692b29077e91db30e32b4374568166d0bb9fc27ab6e59b0483b9e08e3874ff03256ee09fdec10fee622dbb79d7a153840b2e85a809a80325d7382a6d928db8c615d746ea86e886e5eaa7ee4f9b35850604dc90795a0e67b829d3520fe452c71d5d6d5420d2040e1c82099244b908accabe6ce1b9534143b9c1df803086a246840492f03c3513b6ed8baa22306b324f45c8da497090f187f4a65c593bcae74e622a33c8da9c41f7033261cb602d7bb7271abe23b6c48db2e39eb79df81bf243488d9a8113fe1ba556c9c6b89695359e26c67a66a843b7bd10acf9e1f475196046c0ad89286d5d085c3a4b8625a4de29af4566dadf3a096d4618b76e9398926872e78ebc68eb509c2b8427df383b7a6575f452b48fd713ea0c861e4405bedd73e0174a056523ad129cc6b14f6e425febfbca76caf5742fe1e1ff4f79db1e146e9bbdd8ebbc0ec03a441e8bc50a1cc5d5b470e564045249eeae9042b41e049d6bd3c202d6fa4276fd966dd116da3eaf38b0a58f8197f4e4656d9d9e601cb67b3ec5f106164e3983ab49bcd476e6637cc0da89b3f506699a8c80a4468c122476b90c98bb43bcf744850b750d9ce9b4a1c4e76994c1ed1871b460c7555651035d235510f9e7e78f5f2a58d8ca2722cca3a59a934fc2a3f2801dfcb9108bc7cff2551f654e52619c7e3db79bedc2c503a38ed45f639200683080541cf24cfc6d6cbccb1d82c87ddb380fdda9980c8abd1b230e4777549ad8307bde5c8be332f0935d5ae2233262f6bc0ee2742d8d60ac6fd7fec1af8fc57247eeff05c3200a4063fa50450c732a8b550e32b528320b51fe669631b556eb97a6a8a171024e99d252d76ede58624a7b74c1cde62cf2eb216f8798a81b14d34866cf0d1d2c27b2cd77086e7c69625a22f9755b4a9ced11f5e568f77389ac6834db9ba442d57202b07d3c0b0951056d2836405df3b86e940ba9e30117b10a0418daa4f43771541ab56e888ba1a5c0a",
+    },
+];
+const rawGuarantees = [
+    {
+        report: {
+            package_spec: {
+                hash: "0xac9928d4eb0c942a07c40157fa4498b2efbbc65136819517dc94d50ff2ca9f49",
+                length: 270,
+                erasure_root: "0xebb6b040a0ea039a8f9593e3a4b29005b1ebea1c5465c2753db1031a3ef30c85",
+                exports_root: "0x0000000000000000000000000000000000000000000000000000000000000000",
+                exports_count: 0,
+            },
+            context: {
+                anchor: "0x1a7d753af2e2be12f88dfcb7ca5c704641534094b061c8c3aa258d4b0acbf5c8",
+                state_root: "0x5e8f73cf5d9f94cb3a8313361a3b48e97968a9ac52ab9c29b4e88f4159c21560",
+                beefy_root: "0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5",
+                lookup_anchor: "0x3a31fd60656cb3de2c6ba9fafb8dee8d4c45d4bc87ca248cdda7625a68b987fb",
+                lookup_anchor_slot: 14,
+                prerequisites: [],
+            },
+            core_index: 0,
+            authorizer_hash: "0x0b27478648cd19b4f812f897a26976ecf312eac28508b4368d0c63ea949c7cb0",
+            auth_output: "0x",
+            segment_root_lookup: [],
+            results: [
+                {
+                    service_id: 0,
+                    code_hash: "0x15f8485e3a88e86182e63280720d5ec9892578f0e577fb1bcdda5cf497950815",
+                    payload_hash: "0x84796f4f11ace690fc5a5bdb847db1e63cb36c97ef8f90f067a0846b654bf1c2",
+                    accumulate_gas: 9876,
+                    result: {
+                        ok: "0xccbea4bf12716bc7f7583dd834aac2ca1b05af8dc5be285336156d0de73d9b9e20620000",
+                    },
+                    refine_load: {
+                        gas_used: 0,
+                        imports: 0,
+                        extrinsic_count: 0,
+                        extrinsic_size: 0,
+                        exports: 0,
+                    },
+                },
+            ],
+            auth_gas_used: 0,
+        },
+        slot: 14,
+        signatures: [
+            {
+                validator_index: 1,
+                signature: "0xefb5015b50b52af22829db4a9865ede9e164dfeaef56fc01b9bb828b850470e329905c5e972fc4d5e6dc880832b64dac0f21c244d2e9ab84ded5b05b85f94008",
+            },
+            {
+                validator_index: 2,
+                signature: "0x76b63e4abe1b74fd20141d5b0f15a3ef7a04737a0e9df40f4af67d4b8c6548d391955ec649cef1821e1511eb48ff421ad3043b346999d862db9baf0587253d0c",
+            },
+            {
+                validator_index: 3,
+                signature: "0x3b80860ea2c061de79cb5c406edb6b27e3cde895d3dee36e0c4b9a53fc88cb479ecc1e335a064c86cb0a1848ee78032c24a24ff3c1d62a566b32317b0bcb430d",
+            },
+        ],
+    },
+];

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

@@ -0,0 +1,14 @@
+export * from "./accumulate/index.js";
+export * from "./assurances.js";
+export * from "./authorization.js";
+export * from "./block-verifier.js";
+export * from "./chain-stf.js";
+export * from "./disputes/index.js";
+export * as externalities from "./externalities/index.js";
+export * from "./hasher.js";
+export * from "./preimages.js";
+export * from "./recent-history.js";
+export * from "./reports/index.js";
+export * from "./statistics.js";
+export * from "./test.utils.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/transition/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,OAAO,KAAK,aAAa,MAAM,0BAA0B,CAAC;AAC1D,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC"}

package/packages/jam/transition/index.js

@@ -0,0 +1,13 @@
+export * from "./accumulate/index.js";
+export * from "./assurances.js";
+export * from "./authorization.js";
+export * from "./block-verifier.js";
+export * from "./chain-stf.js";
+export * from "./disputes/index.js";
+export * as externalities from "./externalities/index.js";
+export * from "./hasher.js";
+export * from "./preimages.js";
+export * from "./recent-history.js";
+export * from "./reports/index.js";
+export * from "./statistics.js";
+export * from "./test.utils.js";

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

@@ -0,0 +1,23 @@
+import type { TimeSlot } from "#@typeberry/block";
+import type { PreimagesExtrinsic } from "#@typeberry/block/preimage.js";
+import type { Blake2b } from "#@typeberry/hash";
+import { type ServicesUpdate, type State } from "#@typeberry/state";
+import { Result } from "#@typeberry/utils";
+export type PreimagesState = Pick<State, "getService">;
+export type PreimagesStateUpdate = Pick<ServicesUpdate, "preimages">;
+export type PreimagesInput = {
+    preimages: PreimagesExtrinsic;
+    slot: TimeSlot;
+};
+export declare enum PreimagesErrorCode {
+    PreimageUnneeded = "preimage_unneeded",
+    PreimagesNotSortedUnique = "preimages_not_sorted_unique",
+    AccountNotFound = "account_not_found"
+}
+export declare class Preimages {
+    readonly state: PreimagesState;
+    readonly blake2b: Blake2b;
+    constructor(state: PreimagesState, blake2b: Blake2b);
+    integrate(input: PreimagesInput): Result<PreimagesStateUpdate, PreimagesErrorCode>;
+}
+//# sourceMappingURL=preimages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preimages.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/transition/preimages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAgB,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACrF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,EAAmC,KAAK,cAAc,EAAE,KAAK,KAAK,EAAkB,MAAM,kBAAkB,CAAC;AACpH,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;AAEvD,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;AAErE,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,kBAAkB,CAAC;IAC9B,IAAI,EAAE,QAAQ,CAAC;CAChB,CAAC;AAEF,oBAAY,kBAAkB;IAC5B,gBAAgB,sBAAsB;IACtC,wBAAwB,gCAAgC;IACxD,eAAe,sBAAsB;CACtC;AAED,qBAAa,SAAS;aAEF,KAAK,EAAE,cAAc;aACrB,OAAO,EAAE,OAAO;gBADhB,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,OAAO;IAGlC,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAAC,oBAAoB,EAAE,kBAAkB,CAAC;CAiEnF"}

package/packages/jam/transition/preimages.js

@@ -0,0 +1,63 @@
+import { tryAsU32 } from "#@typeberry/numbers";
+import { LookupHistoryItem, PreimageItem, UpdatePreimage } from "#@typeberry/state";
+import { Result } from "#@typeberry/utils";
+export var PreimagesErrorCode;
+(function (PreimagesErrorCode) {
+    PreimagesErrorCode["PreimageUnneeded"] = "preimage_unneeded";
+    PreimagesErrorCode["PreimagesNotSortedUnique"] = "preimages_not_sorted_unique";
+    PreimagesErrorCode["AccountNotFound"] = "account_not_found";
+})(PreimagesErrorCode || (PreimagesErrorCode = {}));
+export class Preimages {
+    state;
+    blake2b;
+    constructor(state, blake2b) {
+        this.state = state;
+        this.blake2b = blake2b;
+    }
+    integrate(input) {
+        // make sure lookup extrinsics are sorted and unique
+        // "The lookup extrinsic is a sequence of pairs of service indices and data.
+        // These pairs must be ordered and without duplicates."
+        // https://graypaper.fluffylabs.dev/#/5f542d7/181700181700
+        for (let i = 1; i < input.preimages.length; i++) {
+            const prevPreimage = input.preimages[i - 1];
+            const currPreimage = input.preimages[i];
+            if (prevPreimage.requester < currPreimage.requester) {
+                continue;
+            }
+            if (prevPreimage.requester > currPreimage.requester ||
+                currPreimage.blob.compare(prevPreimage.blob).isLessOrEqual()) {
+                return Result.error(PreimagesErrorCode.PreimagesNotSortedUnique, () => `Preimages not sorted/unique at index ${i}`);
+            }
+        }
+        const { preimages, slot } = input;
+        const pendingChanges = new Map();
+        // select preimages for integration
+        for (const preimage of preimages) {
+            const { requester, blob } = preimage;
+            const hash = this.blake2b.hashBytes(blob).asOpaque();
+            const service = this.state.getService(requester);
+            if (service === null) {
+                return Result.error(PreimagesErrorCode.AccountNotFound, () => `Service not found: ${requester}`);
+            }
+            const hasPreimage = service.hasPreimage(hash);
+            const slots = service.getLookupHistory(hash, tryAsU32(blob.length));
+            // https://graypaper.fluffylabs.dev/#/5f542d7/181800181900
+            // https://graypaper.fluffylabs.dev/#/5f542d7/116f0011a500
+            if (hasPreimage || slots === null || !LookupHistoryItem.isRequested(slots)) {
+                return Result.error(PreimagesErrorCode.PreimageUnneeded, () => `Preimage unneeded: requester=${requester}, hash=${hash}, hasPreimage=${hasPreimage}, isRequested=${slots !== null && LookupHistoryItem.isRequested(slots)}`);
+            }
+            // https://graypaper.fluffylabs.dev/#/5f542d7/18c00018f300
+            const updates = pendingChanges.get(requester) ?? [];
+            updates.push(UpdatePreimage.provide({
+                preimage: PreimageItem.create({ hash, blob }),
+                slot,
+                providedFor: requester,
+            }));
+            pendingChanges.set(requester, updates);
+        }
+        return Result.ok({
+            preimages: pendingChanges,
+        });
+    }
+}

package/packages/jam/transition/preimages.test.d.ts

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

package/packages/jam/transition/preimages.test.d.ts.map

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

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

@@ -0,0 +1,158 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsServiceGas, tryAsServiceId, tryAsTimeSlot } from "#@typeberry/block";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { HashDictionary } from "#@typeberry/collections";
+import { tinyChainSpec } from "#@typeberry/config";
+import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
+import { tryAsU32, tryAsU64 } from "#@typeberry/numbers";
+import { InMemoryService, InMemoryState, LookupHistoryItem, PreimageItem, ServiceAccountInfo, tryAsLookupHistorySlots, } from "#@typeberry/state";
+import { deepEqual, Result } from "#@typeberry/utils";
+import { Preimages, PreimagesErrorCode } from "./preimages.js";
+function createInput(preimages, slot) {
+    return {
+        preimages: preimages,
+        slot: tryAsTimeSlot(slot),
+    };
+}
+function createAccount(id, preimagesEntries = [], lookupHistoryEntries = []) {
+    const preimages = HashDictionary.fromEntries(preimagesEntries.map((x) => [x.hash, x]));
+    const lookupHistory = HashDictionary.fromEntries(lookupHistoryEntries.map((x) => [x.hash, [x]]));
+    return new InMemoryService(id, {
+        info: ServiceAccountInfo.create({
+            codeHash: Bytes.zero(HASH_SIZE).asOpaque(),
+            balance: tryAsU64(0),
+            accumulateMinGas: tryAsServiceGas(0),
+            onTransferMinGas: tryAsServiceGas(0),
+            storageUtilisationBytes: tryAsU64(0),
+            storageUtilisationCount: tryAsU32(0),
+            gratisStorage: tryAsU64(0),
+            created: tryAsTimeSlot(0),
+            lastAccumulation: tryAsTimeSlot(0),
+            parentService: tryAsServiceId(0),
+        }),
+        storage: new Map(),
+        preimages,
+        lookupHistory,
+    });
+}
+describe("Preimages", async () => {
+    const blake2b = await Blake2b.createHasher();
+    it("should reject preimages that are not sorted by requester", () => {
+        const state = InMemoryState.partial(tinyChainSpec, {
+            services: new Map([
+                [tryAsServiceId(0), createAccount(tryAsServiceId(0))],
+                [tryAsServiceId(1), createAccount(tryAsServiceId(1))],
+            ]),
+        });
+        const preimages = new Preimages(state, blake2b);
+        const blob1 = BytesBlob.parseBlob("0xd34db33f11223344556677889900aabbccddeeff0123456789abcdef01234567");
+        const blob2 = BytesBlob.parseBlob("0xf00dc0de11223344556677889900aabbccddeeff0123456789abcdef01234567");
+        const input = createInput([
+            { requester: tryAsServiceId(1), blob: blob1 },
+            { requester: tryAsServiceId(0), blob: blob2 },
+        ], tryAsTimeSlot(12));
+        const result = preimages.integrate(input);
+        deepEqual(result, Result.error(PreimagesErrorCode.PreimagesNotSortedUnique, () => "Preimages not sorted/unique at index 1"));
+    });
+    it("should reject preimages that are sorted by requester but not by blob", () => {
+        const state = InMemoryState.partial(tinyChainSpec, {
+            services: new Map([[tryAsServiceId(0), createAccount(tryAsServiceId(0))]]),
+        });
+        const preimages = new Preimages(state, blake2b);
+        const blob1 = BytesBlob.parseBlob("0xf00dc0de11223344556677889900aabbccddeeff0123456789abcdef01234567");
+        const blob2 = BytesBlob.parseBlob("0xd34db33f11223344556677889900aabbccddeeff0123456789abcdef01234567");
+        const input = createInput([
+            { requester: tryAsServiceId(0), blob: blob1 },
+            { requester: tryAsServiceId(0), blob: blob2 },
+        ], tryAsTimeSlot(12));
+        const result = preimages.integrate(input);
+        deepEqual(result, Result.error(PreimagesErrorCode.PreimagesNotSortedUnique, () => "Preimages not sorted/unique at index 1"));
+    });
+    it("should reject duplicates", () => {
+        const state = InMemoryState.partial(tinyChainSpec, {
+            services: new Map([[tryAsServiceId(0), createAccount(tryAsServiceId(0))]]),
+        });
+        const preimages = new Preimages(state, blake2b);
+        const blob = BytesBlob.parseBlob("0xdeadbeef11223344556677889900aabbccddeeff0123456789abcdef01234567");
+        const input = createInput([
+            { requester: tryAsServiceId(0), blob },
+            { requester: tryAsServiceId(0), blob },
+        ], tryAsTimeSlot(12));
+        const result = preimages.integrate(input);
+        deepEqual(result, Result.error(PreimagesErrorCode.PreimagesNotSortedUnique, () => "Preimages not sorted/unique at index 1"));
+    });
+    it("should reject preimages when account not found", () => {
+        const state = InMemoryState.partial(tinyChainSpec, {
+            services: new Map([[tryAsServiceId(0), createAccount(tryAsServiceId(0))]]),
+        });
+        const preimages = new Preimages(state, blake2b);
+        const blob = BytesBlob.parseBlob("0xc0ffee0011223344556677889900aabbccddeeff0123456789abcdef01234567");
+        const input = createInput([{ requester: tryAsServiceId(1), blob }], tryAsTimeSlot(12));
+        const result = preimages.integrate(input);
+        deepEqual(result, Result.error(PreimagesErrorCode.AccountNotFound, () => "Service not found: 1"));
+    });
+    it("should reject unrequested preimages", () => {
+        const state = InMemoryState.partial(tinyChainSpec, {
+            services: new Map([[tryAsServiceId(0), createAccount(tryAsServiceId(0))]]),
+        });
+        const preimages = new Preimages(state, blake2b);
+        const blob = BytesBlob.parseBlob("0xbaddcafe11223344556677889900aabbccddeeff0123456789abcdef01234567");
+        const input = createInput([{ requester: tryAsServiceId(0), blob }], tryAsTimeSlot(12));
+        const result = preimages.integrate(input);
+        deepEqual(result, Result.error(PreimagesErrorCode.PreimageUnneeded, () => "Preimage unneeded: requester=0, hash=0xc3fc57df6dc7504b8d3763a68716b735224356f809930d31d84c7c1d3d3c5506, hasPreimage=false, isRequested=false"));
+    });
+    it("should reject already integrated preimages", () => {
+        const blob = BytesBlob.parseBlob("0xcafebabe11223344556677889900aabbccddeeff0123456789abcdef01234567");
+        const hash = blake2b.hashBytes(blob).asOpaque();
+        const preimages = [PreimageItem.create({ hash, blob })];
+        const lookupHistory = [
+            new LookupHistoryItem(hash, tryAsU32(blob.length), tryAsLookupHistorySlots([tryAsTimeSlot(5)])),
+        ];
+        const state = InMemoryState.partial(tinyChainSpec, {
+            services: new Map([[tryAsServiceId(0), createAccount(tryAsServiceId(0), preimages, lookupHistory)]]),
+        });
+        const preimagesService = new Preimages(state, blake2b);
+        const input = createInput([{ requester: tryAsServiceId(0), blob }], tryAsTimeSlot(12));
+        const result = preimagesService.integrate(input);
+        deepEqual(result, Result.error(PreimagesErrorCode.PreimageUnneeded, () => "Preimage unneeded: requester=0, hash=0x3bb1eaa37b44192b79bd422264cbe973cf3ce4549c3b193ee39a7a8ebbf90a1f, hasPreimage=true, isRequested=false"));
+    });
+    it("should successfully integrate preimages", () => {
+        const blob1 = BytesBlob.parseBlob("0x1337beef11223344556677889900aabbccddeeff0123456789abcdef01234567");
+        const blob2 = BytesBlob.parseBlob("0x8badf00d11223344556677889900aabbccddeeff0123456789abcdef01234567");
+        const hash1 = blake2b.hashBytes(blob1).asOpaque();
+        const hash2 = blake2b.hashBytes(blob2).asOpaque();
+        const lookupHistory = [
+            new LookupHistoryItem(hash1, tryAsU32(blob1.length), tryAsLookupHistorySlots([])),
+            new LookupHistoryItem(hash2, tryAsU32(blob2.length), tryAsLookupHistorySlots([])),
+        ];
+        const state = InMemoryState.partial(tinyChainSpec, {
+            services: new Map([
+                [tryAsServiceId(0), createAccount(tryAsServiceId(0), [], lookupHistory)],
+                [tryAsServiceId(1), createAccount(tryAsServiceId(1), [], lookupHistory)],
+            ]),
+        });
+        const preimages = new Preimages(state, blake2b);
+        const input = createInput([
+            { requester: tryAsServiceId(0), blob: blob1 },
+            { requester: tryAsServiceId(1), blob: blob2 },
+        ], tryAsTimeSlot(12));
+        const result = preimages.integrate(input);
+        assert.deepStrictEqual(result.isOk, true);
+        state.applyUpdate(result.ok);
+        const account0 = state.services.get(tryAsServiceId(0));
+        assert.ok(account0 !== undefined);
+        const account0LookupHistory = Array.from(account0.data.lookupHistory.values());
+        assert.strictEqual(account0.data.preimages.has(hash1), true);
+        assert.strictEqual(account0.data.preimages.get(hash1)?.blob, blob1);
+        assert.deepStrictEqual(account0LookupHistory[0][0].slots, tryAsLookupHistorySlots([tryAsTimeSlot(12)]));
+        assert.deepStrictEqual(account0LookupHistory[1][0].slots, tryAsLookupHistorySlots([]));
+        const account1 = state.services.get(tryAsServiceId(1));
+        assert.ok(account1 !== undefined);
+        const account1LookupHistory = Array.from(account1.data.lookupHistory.values());
+        assert.strictEqual(account1.data.preimages.has(hash2), true);
+        assert.strictEqual(account1.data.preimages.get(hash2)?.blob, blob2);
+        assert.deepStrictEqual(account1LookupHistory[0][0].slots, tryAsLookupHistorySlots([]));
+        assert.deepStrictEqual(account1LookupHistory[1][0].slots, tryAsLookupHistorySlots([tryAsTimeSlot(12)]));
+    });
+});

package/packages/jam/transition/recent-history.d.ts

@@ -0,0 +1,60 @@
+import type { HeaderHash, StateRootHash } from "#@typeberry/block";
+import type { WorkPackageHash, WorkPackageInfo } from "#@typeberry/block/refine-context.js";
+import { type HashDictionary } from "#@typeberry/collections";
+import { type KeccakHash } from "#@typeberry/hash";
+import { type MmrHasher } from "#@typeberry/mmr";
+import { type State } from "#@typeberry/state";
+import type { AccumulateRoot } from "./accumulate/accumulate-state.js";
+export type RecentHistoryPartialInput = {
+    /** State root before current header. */
+    priorStateRoot: StateRootHash;
+};
+/** Current block input for the recent history transition. */
+export type RecentHistoryInput = {
+    /** Result of the partial transition. */
+    partial: RecentHistoryStateUpdate;
+    /** Current header hash. */
+    headerHash: HeaderHash;
+    /**
+     * Accumulation root calculated from `θ`: accumulation-output
+     * using the basic binary Merklization function (M_B , defined in appendix E)
+     *
+     * https://graypaper.fluffylabs.dev/#/1c979cb/0f70020f7202?v=0.7.1
+     */
+    accumulateRoot: AccumulateRoot;
+    /** Work packages in the guarantees extrinsic. */
+    workPackages: HashDictionary<WorkPackageHash, WorkPackageInfo>;
+};
+/** Recent history tests state. */
+export type RecentHistoryState = Pick<State, "recentBlocks">;
+/** Update of the recent history state. */
+export type RecentHistoryStateUpdate = Pick<RecentHistoryState, "recentBlocks">;
+/**
+ * Recent History transition function.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/0faf010faf01?v=0.5.4
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fb1010fb101?v=0.6.7
+ */
+export declare class RecentHistory {
+    private readonly hasher;
+    readonly state: RecentHistoryState;
+    constructor(hasher: MmrHasher<KeccakHash>, state: RecentHistoryState);
+    /**
+     * During the accumulation stage, a value with the partial transition
+     * of this state is provided which contains the update for the newly-known
+     * roots of the parent block.
+     *
+     * β_H† ≡ β_H except β_H†[|β_H| − 1]_s = H_r
+     *
+     * https://graypaper.fluffylabs.dev/#/1c979cb/0f55020f5502?v=0.7.1
+     */
+    partialTransition(input: RecentHistoryPartialInput): RecentHistoryStateUpdate;
+    /**
+     * `β′` = `β_H†` ++ (p, h: H(H), s: H_0, b: M_r(β′_B))
+     * where p = { (((g_r)_s)_p ↦ ((g_r)_s)_e) | g ∈ EG }
+     *
+     * https://graypaper.fluffylabs.dev/#/1c979cb/0fd2020fd202?v=0.7.1
+     */
+    transition(input: RecentHistoryInput): RecentHistoryStateUpdate;
+}
+//# sourceMappingURL=recent-history.d.ts.map

package/packages/jam/transition/recent-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recent-history.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/transition/recent-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAE3F,OAAO,EAAe,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC1E,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAgD,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC5F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAEvE,MAAM,MAAM,yBAAyB,GAAG;IACtC,wCAAwC;IACxC,cAAc,EAAE,aAAa,CAAC;CAC/B,CAAC;AAEF,6DAA6D;AAC7D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,wCAAwC;IACxC,OAAO,EAAE,wBAAwB,CAAC;IAClC,2BAA2B;IAC3B,UAAU,EAAE,UAAU,CAAC;IACvB;;;;;OAKG;IACH,cAAc,EAAE,cAAc,CAAC;IAC/B,iDAAiD;IACjD,YAAY,EAAE,cAAc,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;CAChE,CAAC;AAEF,kCAAkC;AAClC,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;AAE7D,0CAA0C;AAC1C,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,kBAAkB,EAAE,cAAc,CAAC,CAAC;AAEhF;;;;;GAKG;AACH,qBAAa,aAAa;IAEtB,OAAO,CAAC,QAAQ,CAAC,MAAM;aACP,KAAK,EAAE,kBAAkB;gBADxB,MAAM,EAAE,SAAS,CAAC,UAAU,CAAC,EAC9B,KAAK,EAAE,kBAAkB;IAG3C;;;;;;;;OAQG;IACH,iBAAiB,CAAC,KAAK,EAAE,yBAAyB,GAAG,wBAAwB;IAiB7E;;;;;OAKG;IACH,UAAU,CAAC,KAAK,EAAE,kBAAkB,GAAG,wBAAwB;CAsChE"}

package/packages/jam/transition/recent-history.js

@@ -0,0 +1,77 @@
+import { Bytes } from "#@typeberry/bytes";
+import { asKnownSize } from "#@typeberry/collections";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { MerkleMountainRange } from "#@typeberry/mmr";
+import { BlockState, MAX_RECENT_HISTORY, RecentBlocks } from "#@typeberry/state";
+/**
+ * Recent History transition function.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/0faf010faf01?v=0.5.4
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fb1010fb101?v=0.6.7
+ */
+export class RecentHistory {
+    hasher;
+    state;
+    constructor(hasher, state) {
+        this.hasher = hasher;
+        this.state = state;
+    }
+    /**
+     * During the accumulation stage, a value with the partial transition
+     * of this state is provided which contains the update for the newly-known
+     * roots of the parent block.
+     *
+     * β_H† ≡ β_H except β_H†[|β_H| − 1]_s = H_r
+     *
+     * https://graypaper.fluffylabs.dev/#/1c979cb/0f55020f5502?v=0.7.1
+     */
+    partialTransition(input) {
+        const stateBlocks = this.state.recentBlocks;
+        const recentBlocks = stateBlocks.blocks.slice();
+        const lastState = recentBlocks.length > 0 ? recentBlocks[recentBlocks.length - 1] : null;
+        // update the posterior root of previous state.
+        if (lastState !== null) {
+            lastState.postStateRoot = input.priorStateRoot;
+        }
+        return {
+            recentBlocks: RecentBlocks.create({
+                blocks: asKnownSize(recentBlocks),
+                accumulationLog: stateBlocks.accumulationLog,
+            }), // β_H†
+        };
+    }
+    /**
+     * `β′` = `β_H†` ++ (p, h: H(H), s: H_0, b: M_r(β′_B))
+     * where p = { (((g_r)_s)_p ↦ ((g_r)_s)_e) | g ∈ EG }
+     *
+     * https://graypaper.fluffylabs.dev/#/1c979cb/0fd2020fd202?v=0.7.1
+     */
+    transition(input) {
+        const recentBlocks = input.partial.recentBlocks.blocks.slice();
+        // `β′_B`
+        const mmr = this.state.recentBlocks.accumulationLog !== null
+            ? MerkleMountainRange.fromPeaks(this.hasher, this.state.recentBlocks.accumulationLog)
+            : MerkleMountainRange.empty(this.hasher);
+        // append the accumulation root
+        mmr.append(input.accumulateRoot);
+        const peaks = mmr.getPeaks();
+        // push new state item
+        recentBlocks.push(BlockState.create({
+            headerHash: input.headerHash,
+            accumulationResult: mmr.getSuperPeakHash(),
+            postStateRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+            reported: input.workPackages,
+        }));
+        // we remove all items above `MAX_RECENT_HISTORY`.
+        if (recentBlocks.length > MAX_RECENT_HISTORY) {
+            recentBlocks.shift();
+        }
+        // write back to the state.
+        return {
+            recentBlocks: RecentBlocks.create(RecentBlocks.create({
+                blocks: asKnownSize(recentBlocks),
+                accumulationLog: peaks,
+            })),
+        };
+    }
+}

package/packages/jam/transition/recent-history.test.d.ts

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

package/packages/jam/transition/recent-history.test.d.ts.map

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