@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/jam/state-merkleization/serialize-state-update.js

@@ -0,0 +1,183 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import { Encoder } from "#@typeberry/codec";
+import { tryAsU32 } from "#@typeberry/numbers";
+import { SafroleData, tryAsLookupHistorySlots, UpdatePreimageKind, UpdateServiceKind, UpdateStorageKind, } from "#@typeberry/state";
+import { serialize } from "./serialize.js";
+/** What should be done with that key? */
+export var StateEntryUpdateAction;
+(function (StateEntryUpdateAction) {
+    /** Insert an entry. */
+    StateEntryUpdateAction[StateEntryUpdateAction["Insert"] = 0] = "Insert";
+    /** Remove an entry. */
+    StateEntryUpdateAction[StateEntryUpdateAction["Remove"] = 1] = "Remove";
+})(StateEntryUpdateAction || (StateEntryUpdateAction = {}));
+const EMPTY_BLOB = BytesBlob.empty();
+/** Serialize given state update into a series of key-value pairs. */
+export function* serializeStateUpdate(spec, blake2b, update) {
+    // first let's serialize all of the simple entries (if present!)
+    yield* serializeBasicKeys(spec, update);
+    const encode = (codec, val) => Encoder.encodeObject(codec, val, spec);
+    // then let's proceed with service updates
+    yield* serializeServiceUpdates(update.updated, encode, blake2b);
+    yield* serializePreimages(update.preimages, encode, blake2b);
+    yield* serializeStorage(update.storage, blake2b);
+    yield* serializeRemovedServices(update.removed);
+}
+function* serializeRemovedServices(servicesRemoved) {
+    if (servicesRemoved === undefined) {
+        return;
+    }
+    for (const serviceId of servicesRemoved) {
+        const codec = serialize.serviceData(serviceId);
+        yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
+    }
+}
+function* serializeStorage(storageUpdates, blake2b) {
+    if (storageUpdates === undefined) {
+        return;
+    }
+    for (const [serviceId, updates] of storageUpdates.entries()) {
+        for (const { action } of updates) {
+            switch (action.kind) {
+                case UpdateStorageKind.Set: {
+                    const key = action.storage.key;
+                    const codec = serialize.serviceStorage(blake2b, serviceId, key);
+                    yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
+                    break;
+                }
+                case UpdateStorageKind.Remove: {
+                    const key = action.key;
+                    const codec = serialize.serviceStorage(blake2b, serviceId, key);
+                    yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
+                    break;
+                }
+            }
+        }
+    }
+}
+function* serializePreimages(preimagesUpdates, encode, blake2b) {
+    if (preimagesUpdates === undefined) {
+        return;
+    }
+    for (const [serviceId, updates] of preimagesUpdates.entries()) {
+        for (const { action } of updates) {
+            switch (action.kind) {
+                case UpdatePreimageKind.Provide: {
+                    const { hash, blob } = action.preimage;
+                    const codec = serialize.servicePreimages(blake2b, serviceId, hash);
+                    yield [StateEntryUpdateAction.Insert, codec.key, blob];
+                    if (action.slot !== null) {
+                        const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, tryAsU32(blob.length));
+                        yield [
+                            StateEntryUpdateAction.Insert,
+                            codec2.key,
+                            encode(codec2.Codec, tryAsLookupHistorySlots([action.slot])),
+                        ];
+                    }
+                    break;
+                }
+                case UpdatePreimageKind.UpdateOrAdd: {
+                    const { hash, length, slots } = action.item;
+                    const codec = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
+                    yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, slots)];
+                    break;
+                }
+                case UpdatePreimageKind.Remove: {
+                    const { hash, length } = action;
+                    const codec = serialize.servicePreimages(blake2b, serviceId, hash);
+                    yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
+                    const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
+                    yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
+                    break;
+                }
+            }
+        }
+    }
+}
+function* serializeServiceUpdates(servicesUpdates, encode, blake2b) {
+    if (servicesUpdates === undefined) {
+        return;
+    }
+    for (const [serviceId, { action }] of servicesUpdates.entries()) {
+        // new service being created or updated
+        const codec = serialize.serviceData(serviceId);
+        yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, action.account)];
+        // additional lookup history update
+        if (action.kind === UpdateServiceKind.Create && action.lookupHistory !== null) {
+            const { lookupHistory } = action;
+            const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, lookupHistory.hash, lookupHistory.length);
+            yield [StateEntryUpdateAction.Insert, codec2.key, encode(codec2.Codec, lookupHistory.slots)];
+        }
+    }
+}
+function* serializeBasicKeys(spec, update) {
+    function doSerialize(val, codec) {
+        return [StateEntryUpdateAction.Insert, codec.key, Encoder.encodeObject(codec.Codec, val, spec)];
+    }
+    if (update.authPools !== undefined) {
+        yield doSerialize(update.authPools, serialize.authPools); // C(1)
+    }
+    if (update.authQueues !== undefined) {
+        yield doSerialize(update.authQueues, serialize.authQueues); // C(2)
+    }
+    if (update.recentBlocks !== undefined) {
+        yield doSerialize(update.recentBlocks, serialize.recentBlocks); // C(3)
+    }
+    const safroleData = getSafroleData(update.nextValidatorData, update.epochRoot, update.sealingKeySeries, update.ticketsAccumulator);
+    if (safroleData !== undefined) {
+        yield doSerialize(safroleData, serialize.safrole); // C(4)
+    }
+    if (update.disputesRecords !== undefined) {
+        yield doSerialize(update.disputesRecords, serialize.disputesRecords); // C(5)
+    }
+    if (update.entropy !== undefined) {
+        yield doSerialize(update.entropy, serialize.entropy); // C(6)
+    }
+    if (update.designatedValidatorData !== undefined) {
+        yield doSerialize(update.designatedValidatorData, serialize.designatedValidators); // C(7)
+    }
+    if (update.currentValidatorData !== undefined) {
+        yield doSerialize(update.currentValidatorData, serialize.currentValidators); // C(8)
+    }
+    if (update.previousValidatorData !== undefined) {
+        yield doSerialize(update.previousValidatorData, serialize.previousValidators); // C(9)
+    }
+    if (update.availabilityAssignment !== undefined) {
+        yield doSerialize(update.availabilityAssignment, serialize.availabilityAssignment); // C(10)
+    }
+    if (update.timeslot !== undefined) {
+        yield doSerialize(update.timeslot, serialize.timeslot); // C(11)
+    }
+    if (update.privilegedServices !== undefined) {
+        yield doSerialize(update.privilegedServices, serialize.privilegedServices); // C(12)
+    }
+    if (update.statistics !== undefined) {
+        yield doSerialize(update.statistics, serialize.statistics); // C(13)
+    }
+    if (update.accumulationQueue !== undefined) {
+        yield doSerialize(update.accumulationQueue, serialize.accumulationQueue); // C(14)
+    }
+    if (update.recentlyAccumulated !== undefined) {
+        yield doSerialize(update.recentlyAccumulated, serialize.recentlyAccumulated); // C(15)
+    }
+    if (update.accumulationOutputLog !== undefined) {
+        yield doSerialize(update.accumulationOutputLog, serialize.accumulationOutputLog); // C(16)
+    }
+}
+function getSafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator) {
+    if (nextValidatorData === undefined ||
+        epochRoot === undefined ||
+        sealingKeySeries === undefined ||
+        ticketsAccumulator === undefined) {
+        if ([nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator].some((x) => x !== undefined)) {
+            throw new Error("SafroleData needs to be updated all at once!");
+        }
+        return undefined;
+    }
+    return SafroleData.create({
+        nextValidatorData,
+        epochRoot,
+        sealingKeySeries,
+        ticketsAccumulator,
+    });
+}

package/packages/jam/state-merkleization/serialize.d.ts

@@ -0,0 +1,93 @@
+import type { ServiceId } from "#@typeberry/block";
+import type { PreimageHash } from "#@typeberry/block/preimage.js";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { Descriptor } from "#@typeberry/codec";
+import { type Blake2b } from "#@typeberry/hash";
+import type { U32 } from "#@typeberry/numbers";
+import { DisputesRecords, RecentBlocks, type RecentBlocksView, ServiceAccountInfo, type State, StatisticsData, type StatisticsDataView, type StorageKey } from "#@typeberry/state";
+import { SafroleData, type SafroleDataView } from "#@typeberry/state/safrole-data.js";
+import type { StateView } from "#@typeberry/state/state-view.js";
+import { type StateKey } from "./keys.js";
+export type StateCodec<T, V = T> = {
+    key: StateKey;
+    Codec: Descriptor<T, V>;
+    extract: (s: State) => T;
+};
+/** Serialization for particular state entries. */
+export declare namespace serialize {
+    /** C(1): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b15013b1501?v=0.6.7 */
+    const authPools: StateCodec<State["authPools"], ReturnType<StateView["authPoolsView"]>>;
+    /** C(2): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b31013b3101?v=0.6.7 */
+    const authQueues: StateCodec<State["authQueues"], ReturnType<StateView["authQueuesView"]>>;
+    /**
+     * C(3): Recent blocks with compatibility
+     *  https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e013b3e01?v=0.6.7
+     */
+    const recentBlocks: StateCodec<RecentBlocks, RecentBlocksView>;
+    /** C(4): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b63013b6301?v=0.6.7 */
+    const safrole: StateCodec<SafroleData, SafroleDataView>;
+    /** C(5): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bba013bba01?v=0.6.7 */
+    const disputesRecords: StateCodec<DisputesRecords>;
+    /** C(6): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bf3013bf301?v=0.6.7 */
+    const entropy: StateCodec<State["entropy"]>;
+    /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
+    const designatedValidators: StateCodec<State["designatedValidatorData"], ReturnType<StateView["designatedValidatorDataView"]>>;
+    /** C(8): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b0d023b0d02?v=0.6.7 */
+    const currentValidators: StateCodec<State["currentValidatorData"], ReturnType<StateView["currentValidatorDataView"]>>;
+    /** C(9): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b1a023b1a02?v=0.6.7 */
+    const previousValidators: StateCodec<State["previousValidatorData"], ReturnType<StateView["previousValidatorDataView"]>>;
+    /** C(10): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b27023b2702?v=0.6.7 */
+    const availabilityAssignment: StateCodec<State["availabilityAssignment"], ReturnType<StateView["availabilityAssignmentView"]>>;
+    /** C(11): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e023b3e02?v=0.6.7 */
+    const timeslot: StateCodec<State["timeslot"]>;
+    /** C(12): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b4c023b4c02?v=0.6.7 */
+    const privilegedServices: StateCodec<State["privilegedServices"]>;
+    /** C(13): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b5e023b5e02?v=0.6.7 */
+    const statistics: StateCodec<StatisticsData, StatisticsDataView>;
+    /** C(14): https://graypaper.fluffylabs.dev/#/1c979cb/3bf0023bf002?v=0.7.1 */
+    const accumulationQueue: StateCodec<State["accumulationQueue"], ReturnType<StateView["accumulationQueueView"]>>;
+    /** C(15): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b96023b9602?v=0.6.7 */
+    const recentlyAccumulated: StateCodec<State["recentlyAccumulated"], ReturnType<StateView["recentlyAccumulatedView"]>>;
+    /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
+    const accumulationOutputLog: StateCodec<State["accumulationOutputLog"]>;
+    /** C(255, s): https://graypaper.fluffylabs.dev/#/85129da/383103383103?v=0.6.3 */
+    const serviceData: (serviceId: ServiceId) => {
+        key: import("@typeberry/hash").OpaqueHash & import("@typeberry/utils").WithOpaque<"stateKey">;
+        Codec: Descriptor<ServiceAccountInfo, import("@typeberry/codec").ViewOf<ServiceAccountInfo, {
+            codeHash: Descriptor<Bytes<32> & import("@typeberry/utils").WithOpaque<"CodeHash">, Bytes<32>>;
+            balance: Descriptor<import("@typeberry/numbers").U64, Bytes<8>>;
+            accumulateMinGas: Descriptor<bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">, Bytes<8>>;
+            onTransferMinGas: Descriptor<bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">, Bytes<8>>;
+            storageUtilisationBytes: Descriptor<import("@typeberry/numbers").U64, Bytes<8>>;
+            gratisStorage: Descriptor<import("@typeberry/numbers").U64, Bytes<8>>;
+            storageUtilisationCount: Descriptor<U32, Bytes<4>>;
+            created: Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">, Bytes<4>>;
+            lastAccumulation: Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">, Bytes<4>>;
+            parentService: Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">, Bytes<4>>;
+        }>>;
+    };
+    /** https://graypaper.fluffylabs.dev/#/85129da/384803384803?v=0.6.3 */
+    const serviceStorage: (blake2b: Blake2b, serviceId: ServiceId, key: StorageKey) => {
+        key: import("@typeberry/hash").OpaqueHash & import("@typeberry/utils").WithOpaque<"stateKey">;
+        Codec: Descriptor<BytesBlob, BytesBlob>;
+    };
+    /** https://graypaper.fluffylabs.dev/#/85129da/385b03385b03?v=0.6.3 */
+    const servicePreimages: (blake2b: Blake2b, serviceId: ServiceId, hash: PreimageHash) => {
+        key: import("@typeberry/hash").OpaqueHash & import("@typeberry/utils").WithOpaque<"stateKey">;
+        Codec: Descriptor<BytesBlob, BytesBlob>;
+    };
+    /** https://graypaper.fluffylabs.dev/#/85129da/387603387603?v=0.6.3 */
+    const serviceLookupHistory: (blake2b: Blake2b, serviceId: ServiceId, hash: PreimageHash, len: U32) => {
+        key: import("@typeberry/hash").OpaqueHash & import("@typeberry/utils").WithOpaque<"stateKey">;
+        Codec: Descriptor<readonly U32[], import("@typeberry/codec").SequenceView<U32, Bytes<4>>>;
+    };
+}
+/**
+ * Just dump the entire terminal blob as-is.
+ *
+ * NOTE this is most likely NOT what you need! `dump` cannot
+ * determine the boundary of the bytes, so it can only be used
+ * as the last element of the codec and can't be used in sequences!
+ */
+export declare const dumpCodec: Descriptor<BytesBlob, BytesBlob>;
+//# sourceMappingURL=serialize.d.ts.map

package/packages/jam/state-merkleization/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/state-merkleization/serialize.ts"],"names":[],"mappings":"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"}

package/packages/jam/state-merkleization/serialize.js

@@ -0,0 +1,149 @@
+import { codecFixedSizeArray } from "#@typeberry/block/codec-utils.js";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { codec, Descriptor } from "#@typeberry/codec";
+import { SortedArray } from "#@typeberry/collections";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { accumulationQueueCodec, authPoolsCodec, authQueuesCodec, availabilityAssignmentsCodec, codecWithVersion, DisputesRecords, ENTROPY_ENTRIES, PrivilegedServices, RecentBlocks, ServiceAccountInfo, StatisticsData, validatorsDataCodec, } from "#@typeberry/state";
+import { AccumulationOutput, accumulationOutputComparator } from "#@typeberry/state/accumulation-output.js";
+import { recentlyAccumulatedCodec } from "#@typeberry/state/recently-accumulated.js";
+import { SafroleData } from "#@typeberry/state/safrole-data.js";
+import { Compatibility, GpVersion } from "#@typeberry/utils";
+import { StateKeyIdx, stateKeys } from "./keys.js";
+/** Serialization for particular state entries. */
+export var serialize;
+(function (serialize) {
+    /** C(1): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b15013b1501?v=0.6.7 */
+    serialize.authPools = {
+        key: stateKeys.index(StateKeyIdx.Alpha),
+        Codec: authPoolsCodec,
+        extract: (s) => s.authPools,
+    };
+    /** C(2): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b31013b3101?v=0.6.7 */
+    serialize.authQueues = {
+        key: stateKeys.index(StateKeyIdx.Phi),
+        Codec: authQueuesCodec,
+        extract: (s) => s.authQueues,
+    };
+    /**
+     * C(3): Recent blocks with compatibility
+     *  https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e013b3e01?v=0.6.7
+     */
+    serialize.recentBlocks = {
+        key: stateKeys.index(StateKeyIdx.Beta),
+        Codec: RecentBlocks.Codec,
+        extract: (s) => s.recentBlocks,
+    };
+    /** C(4): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b63013b6301?v=0.6.7 */
+    serialize.safrole = {
+        key: stateKeys.index(StateKeyIdx.Gamma),
+        Codec: SafroleData.Codec,
+        extract: (s) => SafroleData.create({
+            nextValidatorData: s.nextValidatorData,
+            epochRoot: s.epochRoot,
+            sealingKeySeries: s.sealingKeySeries,
+            ticketsAccumulator: s.ticketsAccumulator,
+        }),
+    };
+    /** C(5): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bba013bba01?v=0.6.7 */
+    serialize.disputesRecords = {
+        key: stateKeys.index(StateKeyIdx.Psi),
+        Codec: DisputesRecords.Codec,
+        extract: (s) => s.disputesRecords,
+    };
+    /** C(6): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bf3013bf301?v=0.6.7 */
+    serialize.entropy = {
+        key: stateKeys.index(StateKeyIdx.Eta),
+        Codec: codecFixedSizeArray(codec.bytes(HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
+        extract: (s) => s.entropy,
+    };
+    /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
+    serialize.designatedValidators = {
+        key: stateKeys.index(StateKeyIdx.Iota),
+        Codec: validatorsDataCodec,
+        extract: (s) => s.designatedValidatorData,
+    };
+    /** C(8): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b0d023b0d02?v=0.6.7 */
+    serialize.currentValidators = {
+        key: stateKeys.index(StateKeyIdx.Kappa),
+        Codec: validatorsDataCodec,
+        extract: (s) => s.currentValidatorData,
+    };
+    /** C(9): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b1a023b1a02?v=0.6.7 */
+    serialize.previousValidators = {
+        key: stateKeys.index(StateKeyIdx.Lambda),
+        Codec: validatorsDataCodec,
+        extract: (s) => s.previousValidatorData,
+    };
+    /** C(10): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b27023b2702?v=0.6.7 */
+    serialize.availabilityAssignment = {
+        key: stateKeys.index(StateKeyIdx.Rho),
+        Codec: availabilityAssignmentsCodec,
+        extract: (s) => s.availabilityAssignment,
+    };
+    /** C(11): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e023b3e02?v=0.6.7 */
+    serialize.timeslot = {
+        key: stateKeys.index(StateKeyIdx.Tau),
+        Codec: codec.u32.asOpaque(),
+        extract: (s) => s.timeslot,
+    };
+    /** C(12): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b4c023b4c02?v=0.6.7 */
+    serialize.privilegedServices = {
+        key: stateKeys.index(StateKeyIdx.Chi),
+        Codec: PrivilegedServices.Codec,
+        extract: (s) => s.privilegedServices,
+    };
+    /** C(13): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b5e023b5e02?v=0.6.7 */
+    serialize.statistics = {
+        key: stateKeys.index(StateKeyIdx.Pi),
+        Codec: StatisticsData.Codec,
+        extract: (s) => s.statistics,
+    };
+    /** C(14): https://graypaper.fluffylabs.dev/#/1c979cb/3bf0023bf002?v=0.7.1 */
+    serialize.accumulationQueue = {
+        key: stateKeys.index(StateKeyIdx.Omega),
+        Codec: accumulationQueueCodec,
+        extract: (s) => s.accumulationQueue,
+    };
+    /** C(15): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b96023b9602?v=0.6.7 */
+    serialize.recentlyAccumulated = {
+        key: stateKeys.index(StateKeyIdx.Xi),
+        Codec: recentlyAccumulatedCodec,
+        extract: (s) => s.recentlyAccumulated,
+    };
+    /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
+    serialize.accumulationOutputLog = {
+        key: stateKeys.index(StateKeyIdx.Theta),
+        Codec: codec.sequenceVarLen(AccumulationOutput.Codec).convert((i) => i.array, (o) => SortedArray.fromSortedArray(accumulationOutputComparator, o)),
+        extract: (s) => s.accumulationOutputLog,
+    };
+    /** C(255, s): https://graypaper.fluffylabs.dev/#/85129da/383103383103?v=0.6.3 */
+    serialize.serviceData = (serviceId) => ({
+        key: stateKeys.serviceInfo(serviceId),
+        Codec: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+            ? codecWithVersion(ServiceAccountInfo.Codec)
+            : ServiceAccountInfo.Codec,
+    });
+    /** https://graypaper.fluffylabs.dev/#/85129da/384803384803?v=0.6.3 */
+    serialize.serviceStorage = (blake2b, serviceId, key) => ({
+        key: stateKeys.serviceStorage(blake2b, serviceId, key),
+        Codec: dumpCodec,
+    });
+    /** https://graypaper.fluffylabs.dev/#/85129da/385b03385b03?v=0.6.3 */
+    serialize.servicePreimages = (blake2b, serviceId, hash) => ({
+        key: stateKeys.servicePreimage(blake2b, serviceId, hash),
+        Codec: dumpCodec,
+    });
+    /** https://graypaper.fluffylabs.dev/#/85129da/387603387603?v=0.6.3 */
+    serialize.serviceLookupHistory = (blake2b, serviceId, hash, len) => ({
+        key: stateKeys.serviceLookupHistory(blake2b, serviceId, hash, len),
+        Codec: codec.readonlyArray(codec.sequenceVarLen(codec.u32)),
+    });
+})(serialize || (serialize = {}));
+/**
+ * Just dump the entire terminal blob as-is.
+ *
+ * NOTE this is most likely NOT what you need! `dump` cannot
+ * determine the boundary of the bytes, so it can only be used
+ * as the last element of the codec and can't be used in sequences!
+ */
+export const dumpCodec = Descriptor.new("Dump", { bytes: 64, isExact: false }, (e, v) => e.bytes(Bytes.fromBlob(v.raw, v.raw.length)), (d) => BytesBlob.blobFrom(d.bytes(d.source.length - d.bytesRead()).raw), (s) => s.bytes(s.decoder.source.length - s.decoder.bytesRead()));

package/packages/jam/state-merkleization/serialize.test.d.ts

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

package/packages/jam/state-merkleization/serialize.test.d.ts.map

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

package/packages/jam/state-merkleization/serialize.test.js

@@ -0,0 +1,77 @@
+import assert from "node:assert";
+import { before, describe, it } from "node:test";
+import { tryAsServiceId } from "#@typeberry/block";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { Decoder, Encoder } from "#@typeberry/codec";
+import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
+import { tryAsU32 } from "#@typeberry/numbers";
+import { dumpCodec, serialize } from "./serialize.js";
+describe("Serialization keys", () => {
+    let blake2b;
+    before(async () => {
+        blake2b = await Blake2b.createHasher();
+    });
+    const cases = [
+        ["C(1)", () => serialize.authPools, "0x0100000000000000000000000000000000000000000000000000000000000000"],
+        ["C(2)", () => serialize.authQueues, "0x0200000000000000000000000000000000000000000000000000000000000000"],
+        ["C(3)", () => serialize.recentBlocks, "0x0300000000000000000000000000000000000000000000000000000000000000"],
+        ["C(4)", () => serialize.safrole, "0x0400000000000000000000000000000000000000000000000000000000000000"],
+        ["C(5)", () => serialize.disputesRecords, "0x0500000000000000000000000000000000000000000000000000000000000000"],
+        ["C(6)", () => serialize.entropy, "0x0600000000000000000000000000000000000000000000000000000000000000"],
+        [
+            "C(7)",
+            () => serialize.designatedValidators,
+            "0x0700000000000000000000000000000000000000000000000000000000000000",
+        ],
+        ["C(8)", () => serialize.currentValidators, "0x0800000000000000000000000000000000000000000000000000000000000000"],
+        ["C(9)", () => serialize.previousValidators, "0x0900000000000000000000000000000000000000000000000000000000000000"],
+        [
+            "C(10)",
+            () => serialize.availabilityAssignment,
+            "0x0a00000000000000000000000000000000000000000000000000000000000000",
+        ],
+        ["C(11)", () => serialize.timeslot, "0x0b00000000000000000000000000000000000000000000000000000000000000"],
+        ["C(12)", () => serialize.privilegedServices, "0x0c00000000000000000000000000000000000000000000000000000000000000"],
+        ["C(13)", () => serialize.statistics, "0x0d00000000000000000000000000000000000000000000000000000000000000"],
+        ["C(14)", () => serialize.accumulationQueue, "0x0e00000000000000000000000000000000000000000000000000000000000000"],
+        [
+            "C(15)",
+            () => serialize.recentlyAccumulated,
+            "0x0f00000000000000000000000000000000000000000000000000000000000000",
+        ],
+        [
+            "C(255, 0xeeee_bbbb)",
+            () => serialize.serviceData(tryAsServiceId(0xeeee_bbbb)),
+            "0xffbb00bb00ee00ee000000000000000000000000000000000000000000000000",
+        ],
+        [
+            "state",
+            () => serialize.serviceStorage(blake2b, tryAsServiceId(0xeeee), Bytes.fill(HASH_SIZE, 15).asOpaque()),
+            "0xee4bee970050003626c718ce62e1bcfb11cc7efb46f27111c166d8b5bb04fa21",
+        ],
+        [
+            "preimage",
+            () => serialize.servicePreimages(blake2b, tryAsServiceId(0xeeee), Bytes.fill(HASH_SIZE, 15).asOpaque()),
+            "0xeec4eef300fd00b4a04dd8ad011395b20fd8e65fc577abbf17103e293fec9a54",
+        ],
+        [
+            "lookup history",
+            () => serialize.serviceLookupHistory(blake2b, tryAsServiceId(0xeeee), Bytes.fill(HASH_SIZE, 15).asOpaque(), tryAsU32(0xdddd)),
+            "0xee4aee230054008acdb8294830cc22f321d57276978d0955a8bc33ffdd964cfb",
+        ],
+    ];
+    for (const [name, entry, expectedKey] of cases) {
+        it(`Should construct correct key for ${name}`, () => {
+            assert.strictEqual(entry().key.toString(), expectedKey);
+        });
+    }
+});
+describe("Codec Descriptors / dump", () => {
+    it("should just dump the bytes as-is", () => {
+        const input = BytesBlob.blobFromNumbers([1, 2, 3, 4, 5]);
+        const encoded = Encoder.encodeObject(dumpCodec, input);
+        const decoded = Decoder.decodeObject(dumpCodec, encoded);
+        assert.deepStrictEqual(decoded, input);
+        assert.deepStrictEqual(encoded, input);
+    });
+});

package/packages/jam/state-merkleization/serialized-state-view.d.ts

@@ -0,0 +1,42 @@
+import type { ServiceId } from "#@typeberry/block";
+import type { AuthorizerHash } from "#@typeberry/block/refine-context.js";
+import type { BytesBlob } from "#@typeberry/bytes";
+import { type SequenceView } from "#@typeberry/codec";
+import type { HashDictionary } from "#@typeberry/collections";
+import type { ChainSpec } from "#@typeberry/config";
+import type { AccumulationQueueView, AuthorizationPool, AuthorizationQueue, AvailabilityAssignmentsView, RecentBlocksView, RecentlyAccumulatedView, SafroleDataView, ServiceAccountInfoView, StatisticsDataView, ValidatorData, ValidatorDataView } from "#@typeberry/state";
+import type { StateView } from "#@typeberry/state/state-view.js";
+import type { StateKey } from "./keys.js";
+/**
+ * Abstraction over some backend containing serialized state entries.
+ *
+ * This may or may not be backed by some on-disk database or can be just stored in memory.
+ */
+export interface SerializedStateBackend {
+    /** Retrieve given state key. */
+    get(key: StateKey): BytesBlob | null;
+}
+export declare class SerializedStateView<T extends SerializedStateBackend> implements StateView {
+    private readonly spec;
+    backend: T;
+    /** Best-effort list of recently active services. */
+    private readonly recentlyUsedServices;
+    private readonly viewCache;
+    constructor(spec: ChainSpec, backend: T, 
+    /** Best-effort list of recently active services. */
+    recentlyUsedServices: ServiceId[], viewCache: HashDictionary<StateKey, unknown>);
+    private retrieveView;
+    availabilityAssignmentView(): AvailabilityAssignmentsView;
+    designatedValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView>;
+    currentValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView>;
+    previousValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView>;
+    authPoolsView(): SequenceView<AuthorizationPool, SequenceView<AuthorizerHash>>;
+    authQueuesView(): SequenceView<AuthorizationQueue, SequenceView<AuthorizerHash>>;
+    recentBlocksView(): RecentBlocksView;
+    statisticsView(): StatisticsDataView;
+    accumulationQueueView(): AccumulationQueueView;
+    recentlyAccumulatedView(): RecentlyAccumulatedView;
+    safroleDataView(): SafroleDataView;
+    getServiceInfoView(id: ServiceId): ServiceAccountInfoView | null;
+}
+//# sourceMappingURL=serialized-state-view.d.ts.map

package/packages/jam/state-merkleization/serialized-state-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialized-state-view.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/state-merkleization/serialized-state-view.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAA+B,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAClF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EACV,qBAAqB,EACrB,iBAAiB,EACjB,kBAAkB,EAClB,2BAA2B,EAC3B,gBAAgB,EAChB,uBAAuB,EACvB,eAAe,EACf,sBAAsB,EACtB,kBAAkB,EAClB,aAAa,EACb,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAG1C;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,gCAAgC;IAChC,GAAG,CAAC,GAAG,EAAE,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC;CACtC;AAED,qBAAa,mBAAmB,CAAC,CAAC,SAAS,sBAAsB,CAAE,YAAW,SAAS;IAEnF,OAAO,CAAC,QAAQ,CAAC,IAAI;IACd,OAAO,EAAE,CAAC;IACjB,oDAAoD;IACpD,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IACrC,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAJT,IAAI,EAAE,SAAS,EACzB,OAAO,EAAE,CAAC;IACjB,oDAAoD;IACnC,oBAAoB,EAAE,SAAS,EAAE,EACjC,SAAS,EAAE,cAAc,CAAC,QAAQ,EAAE,OAAO,CAAC;IAG/D,OAAO,CAAC,YAAY;IAoBpB,0BAA0B,IAAI,2BAA2B;IAIzD,2BAA2B,IAAI,YAAY,CAAC,aAAa,EAAE,iBAAiB,CAAC;IAI7E,wBAAwB,IAAI,YAAY,CAAC,aAAa,EAAE,iBAAiB,CAAC;IAI1E,yBAAyB,IAAI,YAAY,CAAC,aAAa,EAAE,iBAAiB,CAAC;IAI3E,aAAa,IAAI,YAAY,CAAC,iBAAiB,EAAE,YAAY,CAAC,cAAc,CAAC,CAAC;IAI9E,cAAc,IAAI,YAAY,CAAC,kBAAkB,EAAE,YAAY,CAAC,cAAc,CAAC,CAAC;IAIhF,gBAAgB,IAAI,gBAAgB;IAIpC,cAAc,IAAI,kBAAkB;IAIpC,qBAAqB,IAAI,qBAAqB;IAI9C,uBAAuB,IAAI,uBAAuB;IAIlD,eAAe,IAAI,eAAe;IAIlC,kBAAkB,CAAC,EAAE,EAAE,SAAS,GAAG,sBAAsB,GAAG,IAAI;CAWjE"}

package/packages/jam/state-merkleization/serialized-state-view.js

@@ -0,0 +1,79 @@
+import { Decoder } from "#@typeberry/codec";
+import { serialize } from "./serialize.js";
+export class SerializedStateView {
+    spec;
+    backend;
+    recentlyUsedServices;
+    viewCache;
+    constructor(spec, backend, 
+    /** Best-effort list of recently active services. */
+    recentlyUsedServices, viewCache) {
+        this.spec = spec;
+        this.backend = backend;
+        this.recentlyUsedServices = recentlyUsedServices;
+        this.viewCache = viewCache;
+    }
+    retrieveView({ key, Codec }, description) {
+        const cached = this.viewCache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const bytes = this.backend.get(key);
+        if (bytes === null) {
+            throw new Error(`Required state entry for ${description} is missing!. Accessing view of key: ${key}`);
+        }
+        // NOTE [ToDr] we are not using `Decoder.decodeObject` here because
+        // it needs to get to the end of the data (skip), yet that's expensive.
+        // we assume that the state data is correct and coherent anyway, so
+        // for performance reasons we simply create the view here.
+        const d = Decoder.fromBytesBlob(bytes);
+        d.attachContext(this.spec);
+        const view = Codec.View.decode(d);
+        this.viewCache.set(key, view);
+        return view;
+    }
+    availabilityAssignmentView() {
+        return this.retrieveView(serialize.availabilityAssignment, "availabilityAssignmentView");
+    }
+    designatedValidatorDataView() {
+        return this.retrieveView(serialize.designatedValidators, "designatedValidatorsView");
+    }
+    currentValidatorDataView() {
+        return this.retrieveView(serialize.currentValidators, "currentValidatorsView");
+    }
+    previousValidatorDataView() {
+        return this.retrieveView(serialize.previousValidators, "previousValidatorsView");
+    }
+    authPoolsView() {
+        return this.retrieveView(serialize.authPools, "authPoolsView");
+    }
+    authQueuesView() {
+        return this.retrieveView(serialize.authQueues, "authQueuesView");
+    }
+    recentBlocksView() {
+        return this.retrieveView(serialize.recentBlocks, "recentBlocksView");
+    }
+    statisticsView() {
+        return this.retrieveView(serialize.statistics, "statisticsView");
+    }
+    accumulationQueueView() {
+        return this.retrieveView(serialize.accumulationQueue, "accumulationQueueView");
+    }
+    recentlyAccumulatedView() {
+        return this.retrieveView(serialize.recentlyAccumulated, "recentlyAccumulatedView");
+    }
+    safroleDataView() {
+        return this.retrieveView(serialize.safrole, "safroleDataView");
+    }
+    getServiceInfoView(id) {
+        const serviceData = serialize.serviceData(id);
+        const bytes = this.backend.get(serviceData.key);
+        if (bytes === null) {
+            return null;
+        }
+        if (!this.recentlyUsedServices.includes(id)) {
+            this.recentlyUsedServices.push(id);
+        }
+        return Decoder.decodeObject(serviceData.Codec.View, bytes, this.spec);
+    }
+}