@typeberry/lib 0.0.5-1ef0e31 → 0.0.5-6197992

package/index.d.ts

@@ -4474,6 +4474,9 @@ declare namespace bandersnatch_d_exports {
 }
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Generate ring commitment given concatenation of ring keys.
+ */
 declare function ring_commitment(keys: Uint8Array): Uint8Array;
 /**
  * Derive Private and Public Key from Seed
@@ -4487,21 +4490,21 @@ declare function derive_public_key(seed: Uint8Array): Uint8Array;
  * or
  * https://graypaper.fluffylabs.dev/#/68eaa1f/0e54010e5401?v=0.6.4
  */
-declare function verify_seal(keys: Uint8Array, signer_key_index: number, seal_data: Uint8Array, payload: Uint8Array, aux_data: Uint8Array): Uint8Array;
+declare function verify_seal(signer_key: Uint8Array, seal_data: Uint8Array, payload: Uint8Array, aux_data: Uint8Array): Uint8Array;
 /**
  * Verify multiple tickets at once as defined in:
  * https://graypaper.fluffylabs.dev/#/68eaa1f/0f3e000f3e00?v=0.6.4
  *
  * NOTE: the aux_data of VRF function is empty!
  */
-declare function batch_verify_tickets(keys: Uint8Array, tickets_data: Uint8Array, vrf_input_data_len: number): Uint8Array;
+declare function batch_verify_tickets(ring_size: number, commitment: Uint8Array, tickets_data: Uint8Array, vrf_input_data_len: number): Uint8Array;
 type InitInput$2 = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 interface InitOutput$2 {
   readonly memory: WebAssembly.Memory;
   readonly ring_commitment: (a: number, b: number) => [number, number];
   readonly derive_public_key: (a: number, b: number) => [number, number];
-  readonly verify_seal: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
-  readonly batch_verify_tickets: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+  readonly verify_seal: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+  readonly batch_verify_tickets: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
   readonly __wbindgen_export_0: WebAssembly.Table;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
@@ -7852,6 +7855,173 @@ declare class JipChainSpec extends WithDebug {
   }
 }
 
+declare enum Level {
+  INSANE = 1,
+  TRACE = 2,
+  LOG = 3,
+  INFO = 4,
+  WARN = 5,
+  ERROR = 6,
+}
+
+type Options = {
+  defaultLevel: Level;
+  workingDir: string;
+  modules: Map<string, Level>;
+};
+
+/**
+ * A function to parse logger definition (including modules) given as a string.
+ *
+ * Examples
+ *  - `info` - setup default logging level to `info`.
+ *  - `trace` - default logging level set to `trace`.
+ *  - `debug;consensus=trace` - default level is set to `debug/log`, but consensus is in trace mode.
+ */
+declare function parseLoggerOptions(input: string, defaultLevel: Level, workingDir?: string): Options {
+  const modules = new Map<string, Level>();
+  const parts = input.toLowerCase().split(",");
+  let defLevel = defaultLevel;
+
+  for (const p of parts) {
+    const clean = p.trim();
+    // skip empty objects (forgotten `,` removed)
+    if (clean.length === 0) {
+      continue;
+    }
+    // we just have the default level
+    if (clean.includes("=")) {
+      const [mod, lvl] = clean.split("=");
+      modules.set(mod.trim(), parseLevel(lvl.trim()));
+    } else {
+      defLevel = parseLevel(clean);
+    }
+  }
+
+  // TODO [ToDr] Fix dirname for workers.
+  const myDir = (import.meta.dirname ?? "").split("/");
+  myDir.pop();
+  myDir.pop();
+  return {
+    defaultLevel: defLevel,
+    modules,
+    workingDir: workingDir ?? myDir.join("/"),
+  };
+}
+
+declare const GLOBAL_CONFIG = {
+  options: DEFAULT_OPTIONS,
+  transport: ConsoleTransport.create(DEFAULT_OPTIONS.defaultLevel, DEFAULT_OPTIONS),
+};
+
+/**
+ * A logger instance.
+ */
+declare class Logger {
+  /**
+   * Create a new logger instance given filename and an optional module name.
+   *
+   * If the module name is not given, `fileName` becomes the module name.
+   * The module name can be composed from multiple parts separated with `/`.
+   *
+   * The logger will use a global configuration which can be changed using
+   * [`configureLogger`] function.
+   */
+  static new(fileName?: string, moduleName?: string) {
+    const fName = fileName ?? "unknown";
+    const module = moduleName ?? fName;
+    return new Logger(module.padStart(8, " "), GLOBAL_CONFIG);
+  }
+
+  /**
+   * Return currently configured level for given module. */
+  static getLevel(moduleName: string): Level {
+    return findLevel(GLOBAL_CONFIG.options, moduleName);
+  }
+
+  /**
+   * Global configuration of all loggers.
+   *
+   * One can specify a default logging level (only logs with level >= default will be printed).
+   * It's also possible to configure per-module logging level that takes precedence
+   * over the default one.
+   *
+   * Changing the options affects all previously created loggers.
+   */
+  static configureAllFromOptions(options: Options) {
+    // find minimal level to optimise logging in case
+    // we don't care about low-level logs.
+    const minimalLevel = Array.from(options.modules.values()).reduce((level, modLevel) => {
+      return level < modLevel ? level : modLevel;
+    }, options.defaultLevel);
+
+    const transport = ConsoleTransport.create(minimalLevel, options);
+
+    // set the global config
+    GLOBAL_CONFIG.options = options;
+    GLOBAL_CONFIG.transport = transport;
+  }
+
+  /**
+   * Global configuration of all loggers.
+   *
+   * Parse configuration options from an input string typically obtained
+   * from environment variable `JAM_LOG`.
+   */
+  static configureAll(input: string, defaultLevel: Level, workingDir?: string) {
+    const options = parseLoggerOptions(input, defaultLevel, workingDir);
+    Logger.configureAllFromOptions(options);
+  }
+
+  private constructor(
+    private readonly moduleName: string,
+    private readonly config: typeof GLOBAL_CONFIG,
+  ) {}
+
+  /** Log a message with `INSANE` level. */
+  insane(val: string) {
+    this.config.transport.insane(this.moduleName, val);
+  }
+
+  /** Log a message with `TRACE` level. */
+  trace(val: string) {
+    this.config.transport.trace(this.moduleName, val);
+  }
+
+  /** Log a message with `DEBUG`/`LOG` level. */
+  log(val: string) {
+    this.config.transport.log(this.moduleName, val);
+  }
+
+  /** Log a message with `INFO` level. */
+  info(val: string) {
+    this.config.transport.info(this.moduleName, val);
+  }
+
+  /** Log a message with `WARN` level. */
+  warn(val: string) {
+    this.config.transport.warn(this.moduleName, val);
+  }
+
+  /** Log a message with `ERROR` level. */
+  error(val: string) {
+    this.config.transport.error(this.moduleName, val);
+  }
+}
+
+type index$g_Level = Level;
+declare const index$g_Level: typeof Level;
+type index$g_Logger = Logger;
+declare const index$g_Logger: typeof Logger;
+declare const index$g_parseLoggerOptions: typeof parseLoggerOptions;
+declare namespace index$g {
+  export {
+    index$g_Level as Level,
+    index$g_Logger as Logger,
+    index$g_parseLoggerOptions as parseLoggerOptions,
+  };
+}
+
 /** Block authorship options. */
 declare class AuthorshipOptions {
   static fromJson = json.object<JsonObject<AuthorshipOptions>, AuthorshipOptions>(
@@ -7871,6 +8041,8 @@ declare class AuthorshipOptions {
   ) {}
 }
 
+declare const logger$1 = Logger.new(import.meta.filename, "config");
+
 /** Development config. Will accept unsealed blocks for now. */
 declare const DEV_CONFIG = "dev";
 /** Default config file. */
@@ -7932,14 +8104,17 @@ declare class NodeConfiguration {
 
 declare function loadConfig(configPath: string): NodeConfiguration {
   if (configPath === DEFAULT_CONFIG) {
+    logger.log("🔧 Loading DEFAULT config");
     return parseFromJson(configs.default, NodeConfiguration.fromJson);
   }
 
   if (configPath === DEV_CONFIG) {
+    logger.log("🔧 Loading DEV config");
     return parseFromJson(configs.dev, NodeConfiguration.fromJson);
   }
 
   try {
+    logger.log(`🔧 Loading config from ${configPath}`);
     const configFile = fs.readFileSync(configPath, "utf8");
     const parsed = JSON.parse(configFile);
     return parseFromJson(parsed, NodeConfiguration.fromJson);
@@ -7948,29 +8123,30 @@ declare function loadConfig(configPath: string): NodeConfiguration {
   }
 }
 
-declare const index$g_DEFAULT_CONFIG: typeof DEFAULT_CONFIG;
-declare const index$g_DEV_CONFIG: typeof DEV_CONFIG;
-type index$g_JipChainSpec = JipChainSpec;
-declare const index$g_JipChainSpec: typeof JipChainSpec;
-type index$g_KnownChainSpec = KnownChainSpec;
-declare const index$g_KnownChainSpec: typeof KnownChainSpec;
-declare const index$g_NODE_DEFAULTS: typeof NODE_DEFAULTS;
-type index$g_NodeConfiguration = NodeConfiguration;
-declare const index$g_NodeConfiguration: typeof NodeConfiguration;
-declare const index$g_knownChainSpecFromJson: typeof knownChainSpecFromJson;
-declare const index$g_loadConfig: typeof loadConfig;
-declare const index$g_parseBootnode: typeof parseBootnode;
-declare namespace index$g {
+declare const index$f_DEFAULT_CONFIG: typeof DEFAULT_CONFIG;
+declare const index$f_DEV_CONFIG: typeof DEV_CONFIG;
+type index$f_JipChainSpec = JipChainSpec;
+declare const index$f_JipChainSpec: typeof JipChainSpec;
+type index$f_KnownChainSpec = KnownChainSpec;
+declare const index$f_KnownChainSpec: typeof KnownChainSpec;
+declare const index$f_NODE_DEFAULTS: typeof NODE_DEFAULTS;
+type index$f_NodeConfiguration = NodeConfiguration;
+declare const index$f_NodeConfiguration: typeof NodeConfiguration;
+declare const index$f_knownChainSpecFromJson: typeof knownChainSpecFromJson;
+declare const index$f_loadConfig: typeof loadConfig;
+declare const index$f_parseBootnode: typeof parseBootnode;
+declare namespace index$f {
   export {
-    index$g_DEFAULT_CONFIG as DEFAULT_CONFIG,
-    index$g_DEV_CONFIG as DEV_CONFIG,
-    index$g_JipChainSpec as JipChainSpec,
-    index$g_KnownChainSpec as KnownChainSpec,
-    index$g_NODE_DEFAULTS as NODE_DEFAULTS,
-    index$g_NodeConfiguration as NodeConfiguration,
-    index$g_knownChainSpecFromJson as knownChainSpecFromJson,
-    index$g_loadConfig as loadConfig,
-    index$g_parseBootnode as parseBootnode,
+    index$f_DEFAULT_CONFIG as DEFAULT_CONFIG,
+    index$f_DEV_CONFIG as DEV_CONFIG,
+    index$f_JipChainSpec as JipChainSpec,
+    index$f_KnownChainSpec as KnownChainSpec,
+    index$f_NODE_DEFAULTS as NODE_DEFAULTS,
+    index$f_NodeConfiguration as NodeConfiguration,
+    index$f_knownChainSpecFromJson as knownChainSpecFromJson,
+    index$f_loadConfig as loadConfig,
+    logger$1 as logger,
+    index$f_parseBootnode as parseBootnode,
   };
 }
 
@@ -8654,40 +8830,40 @@ declare function trieStringify(root: TrieNode | null, nodes: NodesDb): string {
   return `\nLeaf('${leaf.getKey().toString()}',${value})`;
 }
 
-type index$f_BranchNode = BranchNode;
-declare const index$f_BranchNode: typeof BranchNode;
-type index$f_InMemoryTrie = InMemoryTrie;
-declare const index$f_InMemoryTrie: typeof InMemoryTrie;
-type index$f_InputKey = InputKey;
-type index$f_LeafNode = LeafNode;
-declare const index$f_LeafNode: typeof LeafNode;
-type index$f_NodeType = NodeType;
-declare const index$f_NodeType: typeof NodeType;
-type index$f_NodesDb = NodesDb;
-declare const index$f_NodesDb: typeof NodesDb;
-declare const index$f_TRIE_NODE_BYTES: typeof TRIE_NODE_BYTES;
-declare const index$f_TRUNCATED_KEY_BITS: typeof TRUNCATED_KEY_BITS;
-type index$f_TRUNCATED_KEY_BYTES = TRUNCATED_KEY_BYTES;
-type index$f_TraversedPath = TraversedPath;
-declare const index$f_TraversedPath: typeof TraversedPath;
-type index$f_TrieHasher = TrieHasher;
-type index$f_TrieNode = TrieNode;
-declare const index$f_TrieNode: typeof TrieNode;
-type index$f_TrieNodeHash = TrieNodeHash;
-type index$f_TruncatedStateKey = TruncatedStateKey;
-type index$f_ValueHash = ValueHash;
-type index$f_WriteableNodesDb = WriteableNodesDb;
-declare const index$f_WriteableNodesDb: typeof WriteableNodesDb;
-declare const index$f_createSubtreeForBothLeaves: typeof createSubtreeForBothLeaves;
-declare const index$f_findNodeToReplace: typeof findNodeToReplace;
-declare const index$f_getBit: typeof getBit;
-declare const index$f_leafComparator: typeof leafComparator;
-declare const index$f_parseInputKey: typeof parseInputKey;
-declare const index$f_trieInsert: typeof trieInsert;
-declare const index$f_trieStringify: typeof trieStringify;
-declare namespace index$f {
-  export { index$f_BranchNode as BranchNode, index$f_InMemoryTrie as InMemoryTrie, index$f_LeafNode as LeafNode, index$f_NodeType as NodeType, index$f_NodesDb as NodesDb, index$f_TRIE_NODE_BYTES as TRIE_NODE_BYTES, index$f_TRUNCATED_KEY_BITS as TRUNCATED_KEY_BITS, index$f_TraversedPath as TraversedPath, index$f_TrieNode as TrieNode, index$f_WriteableNodesDb as WriteableNodesDb, index$f_createSubtreeForBothLeaves as createSubtreeForBothLeaves, index$f_findNodeToReplace as findNodeToReplace, index$f_getBit as getBit, index$f_leafComparator as leafComparator, index$f_parseInputKey as parseInputKey, index$f_trieInsert as trieInsert, index$f_trieStringify as trieStringify };
-  export type { index$f_InputKey as InputKey, StateKey$1 as StateKey, index$f_TRUNCATED_KEY_BYTES as TRUNCATED_KEY_BYTES, index$f_TrieHasher as TrieHasher, index$f_TrieNodeHash as TrieNodeHash, index$f_TruncatedStateKey as TruncatedStateKey, index$f_ValueHash as ValueHash };
+type index$e_BranchNode = BranchNode;
+declare const index$e_BranchNode: typeof BranchNode;
+type index$e_InMemoryTrie = InMemoryTrie;
+declare const index$e_InMemoryTrie: typeof InMemoryTrie;
+type index$e_InputKey = InputKey;
+type index$e_LeafNode = LeafNode;
+declare const index$e_LeafNode: typeof LeafNode;
+type index$e_NodeType = NodeType;
+declare const index$e_NodeType: typeof NodeType;
+type index$e_NodesDb = NodesDb;
+declare const index$e_NodesDb: typeof NodesDb;
+declare const index$e_TRIE_NODE_BYTES: typeof TRIE_NODE_BYTES;
+declare const index$e_TRUNCATED_KEY_BITS: typeof TRUNCATED_KEY_BITS;
+type index$e_TRUNCATED_KEY_BYTES = TRUNCATED_KEY_BYTES;
+type index$e_TraversedPath = TraversedPath;
+declare const index$e_TraversedPath: typeof TraversedPath;
+type index$e_TrieHasher = TrieHasher;
+type index$e_TrieNode = TrieNode;
+declare const index$e_TrieNode: typeof TrieNode;
+type index$e_TrieNodeHash = TrieNodeHash;
+type index$e_TruncatedStateKey = TruncatedStateKey;
+type index$e_ValueHash = ValueHash;
+type index$e_WriteableNodesDb = WriteableNodesDb;
+declare const index$e_WriteableNodesDb: typeof WriteableNodesDb;
+declare const index$e_createSubtreeForBothLeaves: typeof createSubtreeForBothLeaves;
+declare const index$e_findNodeToReplace: typeof findNodeToReplace;
+declare const index$e_getBit: typeof getBit;
+declare const index$e_leafComparator: typeof leafComparator;
+declare const index$e_parseInputKey: typeof parseInputKey;
+declare const index$e_trieInsert: typeof trieInsert;
+declare const index$e_trieStringify: typeof trieStringify;
+declare namespace index$e {
+  export { index$e_BranchNode as BranchNode, index$e_InMemoryTrie as InMemoryTrie, index$e_LeafNode as LeafNode, index$e_NodeType as NodeType, index$e_NodesDb as NodesDb, index$e_TRIE_NODE_BYTES as TRIE_NODE_BYTES, index$e_TRUNCATED_KEY_BITS as TRUNCATED_KEY_BITS, index$e_TraversedPath as TraversedPath, index$e_TrieNode as TrieNode, index$e_WriteableNodesDb as WriteableNodesDb, index$e_createSubtreeForBothLeaves as createSubtreeForBothLeaves, index$e_findNodeToReplace as findNodeToReplace, index$e_getBit as getBit, index$e_leafComparator as leafComparator, index$e_parseInputKey as parseInputKey, index$e_trieInsert as trieInsert, index$e_trieStringify as trieStringify };
+  export type { index$e_InputKey as InputKey, StateKey$1 as StateKey, index$e_TRUNCATED_KEY_BYTES as TRUNCATED_KEY_BYTES, index$e_TrieHasher as TrieHasher, index$e_TrieNodeHash as TrieNodeHash, index$e_TruncatedStateKey as TruncatedStateKey, index$e_ValueHash as ValueHash };
 }
 
 /**
@@ -8743,6 +8919,20 @@ declare class AccumulationOutput {
   ) {}
 }
 
+declare function accumulationOutputComparator(a: AccumulationOutput, b: AccumulationOutput) {
+  const result = a.serviceId - b.serviceId;
+
+  if (result < 0) {
+    return Ordering.Less;
+  }
+
+  if (result > 0) {
+    return Ordering.Greater;
+  }
+
+  return Ordering.Equal;
+}
+
 declare const codecWithHash = <T, V, H extends OpaqueHash>(val: Descriptor<T, V>): Descriptor<WithHash<H, T>, V> =>
   Descriptor.withView(
     val.name,
@@ -9115,16 +9305,16 @@ declare class Mountain<H extends OpaqueHash> {
   }
 }
 
-type index$e_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
-declare const index$e_MerkleMountainRange: typeof MerkleMountainRange;
-type index$e_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
-type index$e_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
-type index$e_Mountain<H extends OpaqueHash> = Mountain<H>;
-declare const index$e_Mountain: typeof Mountain;
-declare const index$e_SUPER_PEAK_STRING: typeof SUPER_PEAK_STRING;
-declare namespace index$e {
-  export { index$e_MerkleMountainRange as MerkleMountainRange, index$e_Mountain as Mountain, index$e_SUPER_PEAK_STRING as SUPER_PEAK_STRING };
-  export type { index$e_MmrHasher as MmrHasher, index$e_MmrPeaks as MmrPeaks };
+type index$d_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
+declare const index$d_MerkleMountainRange: typeof MerkleMountainRange;
+type index$d_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
+type index$d_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
+type index$d_Mountain<H extends OpaqueHash> = Mountain<H>;
+declare const index$d_Mountain: typeof Mountain;
+declare const index$d_SUPER_PEAK_STRING: typeof SUPER_PEAK_STRING;
+declare namespace index$d {
+  export { index$d_MerkleMountainRange as MerkleMountainRange, index$d_Mountain as Mountain, index$d_SUPER_PEAK_STRING as SUPER_PEAK_STRING };
+  export type { index$d_MmrHasher as MmrHasher, index$d_MmrPeaks as MmrPeaks };
 }
 
 /**
@@ -10043,7 +10233,7 @@ type State = {
    *
    * NOTE Maximum size of this array is unspecified in GP
    */
-  readonly accumulationOutputLog: AccumulationOutput[];
+  readonly accumulationOutputLog: SortedArray<AccumulationOutput>;
 
   /**
    * Retrieve details about single service.
@@ -10631,7 +10821,7 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
   sealingKeySeries: SafroleSealingKeys;
   epochRoot: BandersnatchRingRoot;
   privilegedServices: PrivilegedServices;
-  accumulationOutputLog: AccumulationOutput[];
+  accumulationOutputLog: SortedArray<AccumulationOutput>;
   services: Map<ServiceId, InMemoryService>;
 
   recentServiceIds(): readonly ServiceId[] {
@@ -10775,7 +10965,7 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
         validatorsManager: tryAsServiceId(0),
         autoAccumulateServices: [],
       }),
-      accumulationOutputLog: [],
+      accumulationOutputLog: SortedArray.fromArray(accumulationOutputComparator, []),
       services: new Map(),
     });
   }
@@ -10822,102 +11012,103 @@ type FieldNames<T> = {
   [K in keyof T]: T[K] extends Function ? never : K;
 }[keyof T];
 
-type index$d_AccumulationOutput = AccumulationOutput;
-declare const index$d_AccumulationOutput: typeof AccumulationOutput;
-type index$d_AutoAccumulate = AutoAccumulate;
-declare const index$d_AutoAccumulate: typeof AutoAccumulate;
-type index$d_AvailabilityAssignment = AvailabilityAssignment;
-declare const index$d_AvailabilityAssignment: typeof AvailabilityAssignment;
-declare const index$d_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
-type index$d_BlockState = BlockState;
-declare const index$d_BlockState: typeof BlockState;
-type index$d_BlocksState = BlocksState;
-type index$d_CoreStatistics = CoreStatistics;
-declare const index$d_CoreStatistics: typeof CoreStatistics;
-type index$d_DisputesRecords = DisputesRecords;
-declare const index$d_DisputesRecords: typeof DisputesRecords;
-declare const index$d_ELECTIVE_BYTE_BALANCE: typeof ELECTIVE_BYTE_BALANCE;
-declare const index$d_ELECTIVE_ITEM_BALANCE: typeof ELECTIVE_ITEM_BALANCE;
-type index$d_ENTROPY_ENTRIES = ENTROPY_ENTRIES;
-type index$d_EnumerableState = EnumerableState;
-type index$d_FieldNames<T> = FieldNames<T>;
-type index$d_InMemoryService = InMemoryService;
-declare const index$d_InMemoryService: typeof InMemoryService;
-type index$d_InMemoryState = InMemoryState;
-declare const index$d_InMemoryState: typeof InMemoryState;
-type index$d_InMemoryStateFields = InMemoryStateFields;
-type index$d_LookupHistoryItem = LookupHistoryItem;
-declare const index$d_LookupHistoryItem: typeof LookupHistoryItem;
-type index$d_LookupHistorySlots = LookupHistorySlots;
-declare const index$d_MAX_LOOKUP_HISTORY_SLOTS: typeof MAX_LOOKUP_HISTORY_SLOTS;
-type index$d_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
-type index$d_PerCore<T> = PerCore<T>;
-type index$d_PreimageItem = PreimageItem;
-declare const index$d_PreimageItem: typeof PreimageItem;
-type index$d_PrivilegedServices = PrivilegedServices;
-declare const index$d_PrivilegedServices: typeof PrivilegedServices;
-type index$d_RecentBlocks = RecentBlocks;
-declare const index$d_RecentBlocks: typeof RecentBlocks;
-type index$d_RecentBlocksHistory = RecentBlocksHistory;
-declare const index$d_RecentBlocksHistory: typeof RecentBlocksHistory;
-type index$d_SafroleData = SafroleData;
-declare const index$d_SafroleData: typeof SafroleData;
-type index$d_SafroleSealingKeys = SafroleSealingKeys;
-type index$d_SafroleSealingKeysData = SafroleSealingKeysData;
-declare const index$d_SafroleSealingKeysData: typeof SafroleSealingKeysData;
-type index$d_SafroleSealingKeysKind = SafroleSealingKeysKind;
-declare const index$d_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
-type index$d_Service = Service;
-type index$d_ServiceAccountInfo = ServiceAccountInfo;
-declare const index$d_ServiceAccountInfo: typeof ServiceAccountInfo;
-type index$d_ServiceData = ServiceData;
-type index$d_ServiceEntries = ServiceEntries;
-type index$d_ServiceStatistics = ServiceStatistics;
-declare const index$d_ServiceStatistics: typeof ServiceStatistics;
-type index$d_ServicesUpdate = ServicesUpdate;
-type index$d_State = State;
-type index$d_StatisticsData = StatisticsData;
-declare const index$d_StatisticsData: typeof StatisticsData;
-type index$d_StorageItem = StorageItem;
-declare const index$d_StorageItem: typeof StorageItem;
-type index$d_StorageKey = StorageKey;
-type index$d_UpdateError = UpdateError;
-declare const index$d_UpdateError: typeof UpdateError;
-type index$d_UpdatePreimage = UpdatePreimage;
-declare const index$d_UpdatePreimage: typeof UpdatePreimage;
-type index$d_UpdatePreimageKind = UpdatePreimageKind;
-declare const index$d_UpdatePreimageKind: typeof UpdatePreimageKind;
-type index$d_UpdateService = UpdateService;
-declare const index$d_UpdateService: typeof UpdateService;
-type index$d_UpdateServiceKind = UpdateServiceKind;
-declare const index$d_UpdateServiceKind: typeof UpdateServiceKind;
-type index$d_UpdateStorage = UpdateStorage;
-declare const index$d_UpdateStorage: typeof UpdateStorage;
-type index$d_UpdateStorageKind = UpdateStorageKind;
-declare const index$d_UpdateStorageKind: typeof UpdateStorageKind;
-type index$d_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
-type index$d_ValidatorData = ValidatorData;
-declare const index$d_ValidatorData: typeof ValidatorData;
-type index$d_ValidatorStatistics = ValidatorStatistics;
-declare const index$d_ValidatorStatistics: typeof ValidatorStatistics;
-declare const index$d_codecBandersnatchKey: typeof codecBandersnatchKey;
-declare const index$d_codecPerCore: typeof codecPerCore;
-declare const index$d_codecServiceId: typeof codecServiceId;
-declare const index$d_codecVarGas: typeof codecVarGas;
-declare const index$d_codecVarU16: typeof codecVarU16;
-declare const index$d_codecWithHash: typeof codecWithHash;
-declare const index$d_hashComparator: typeof hashComparator;
-declare const index$d_ignoreValueWithDefault: typeof ignoreValueWithDefault;
-declare const index$d_serviceDataCodec: typeof serviceDataCodec;
-declare const index$d_serviceEntriesCodec: typeof serviceEntriesCodec;
-declare const index$d_sortedSetCodec: typeof sortedSetCodec;
-declare const index$d_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
-declare const index$d_tryAsPerCore: typeof tryAsPerCore;
-declare const index$d_workReportsSortedSetCodec: typeof workReportsSortedSetCodec;
-declare const index$d_zeroSizeHint: typeof zeroSizeHint;
-declare namespace index$d {
-  export { index$d_AccumulationOutput as AccumulationOutput, index$d_AutoAccumulate as AutoAccumulate, index$d_AvailabilityAssignment as AvailabilityAssignment, index$d_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$d_BlockState as BlockState, index$d_CoreStatistics as CoreStatistics, index$d_DisputesRecords as DisputesRecords, index$d_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$d_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$d_InMemoryService as InMemoryService, index$d_InMemoryState as InMemoryState, index$d_LookupHistoryItem as LookupHistoryItem, index$d_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$d_PreimageItem as PreimageItem, index$d_PrivilegedServices as PrivilegedServices, index$d_RecentBlocks as RecentBlocks, index$d_RecentBlocksHistory as RecentBlocksHistory, index$d_SafroleData as SafroleData, index$d_SafroleSealingKeysData as SafroleSealingKeysData, index$d_SafroleSealingKeysKind as SafroleSealingKeysKind, index$d_ServiceAccountInfo as ServiceAccountInfo, index$d_ServiceStatistics as ServiceStatistics, index$d_StatisticsData as StatisticsData, index$d_StorageItem as StorageItem, index$d_UpdateError as UpdateError, index$d_UpdatePreimage as UpdatePreimage, index$d_UpdatePreimageKind as UpdatePreimageKind, index$d_UpdateService as UpdateService, index$d_UpdateServiceKind as UpdateServiceKind, index$d_UpdateStorage as UpdateStorage, index$d_UpdateStorageKind as UpdateStorageKind, index$d_ValidatorData as ValidatorData, index$d_ValidatorStatistics as ValidatorStatistics, index$d_codecBandersnatchKey as codecBandersnatchKey, index$d_codecPerCore as codecPerCore, index$d_codecServiceId as codecServiceId, index$d_codecVarGas as codecVarGas, index$d_codecVarU16 as codecVarU16, index$d_codecWithHash as codecWithHash, index$d_hashComparator as hashComparator, index$d_ignoreValueWithDefault as ignoreValueWithDefault, index$d_serviceDataCodec as serviceDataCodec, index$d_serviceEntriesCodec as serviceEntriesCodec, index$d_sortedSetCodec as sortedSetCodec, index$d_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$d_tryAsPerCore as tryAsPerCore, index$d_workReportsSortedSetCodec as workReportsSortedSetCodec, index$d_zeroSizeHint as zeroSizeHint };
-  export type { index$d_BlocksState as BlocksState, index$d_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$d_EnumerableState as EnumerableState, index$d_FieldNames as FieldNames, index$d_InMemoryStateFields as InMemoryStateFields, index$d_LookupHistorySlots as LookupHistorySlots, index$d_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$d_PerCore as PerCore, index$d_SafroleSealingKeys as SafroleSealingKeys, index$d_Service as Service, index$d_ServiceData as ServiceData, index$d_ServiceEntries as ServiceEntries, index$d_ServicesUpdate as ServicesUpdate, index$d_State as State, index$d_StorageKey as StorageKey, index$d_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES };
+type index$c_AccumulationOutput = AccumulationOutput;
+declare const index$c_AccumulationOutput: typeof AccumulationOutput;
+type index$c_AutoAccumulate = AutoAccumulate;
+declare const index$c_AutoAccumulate: typeof AutoAccumulate;
+type index$c_AvailabilityAssignment = AvailabilityAssignment;
+declare const index$c_AvailabilityAssignment: typeof AvailabilityAssignment;
+declare const index$c_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
+type index$c_BlockState = BlockState;
+declare const index$c_BlockState: typeof BlockState;
+type index$c_BlocksState = BlocksState;
+type index$c_CoreStatistics = CoreStatistics;
+declare const index$c_CoreStatistics: typeof CoreStatistics;
+type index$c_DisputesRecords = DisputesRecords;
+declare const index$c_DisputesRecords: typeof DisputesRecords;
+declare const index$c_ELECTIVE_BYTE_BALANCE: typeof ELECTIVE_BYTE_BALANCE;
+declare const index$c_ELECTIVE_ITEM_BALANCE: typeof ELECTIVE_ITEM_BALANCE;
+type index$c_ENTROPY_ENTRIES = ENTROPY_ENTRIES;
+type index$c_EnumerableState = EnumerableState;
+type index$c_FieldNames<T> = FieldNames<T>;
+type index$c_InMemoryService = InMemoryService;
+declare const index$c_InMemoryService: typeof InMemoryService;
+type index$c_InMemoryState = InMemoryState;
+declare const index$c_InMemoryState: typeof InMemoryState;
+type index$c_InMemoryStateFields = InMemoryStateFields;
+type index$c_LookupHistoryItem = LookupHistoryItem;
+declare const index$c_LookupHistoryItem: typeof LookupHistoryItem;
+type index$c_LookupHistorySlots = LookupHistorySlots;
+declare const index$c_MAX_LOOKUP_HISTORY_SLOTS: typeof MAX_LOOKUP_HISTORY_SLOTS;
+type index$c_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
+type index$c_PerCore<T> = PerCore<T>;
+type index$c_PreimageItem = PreimageItem;
+declare const index$c_PreimageItem: typeof PreimageItem;
+type index$c_PrivilegedServices = PrivilegedServices;
+declare const index$c_PrivilegedServices: typeof PrivilegedServices;
+type index$c_RecentBlocks = RecentBlocks;
+declare const index$c_RecentBlocks: typeof RecentBlocks;
+type index$c_RecentBlocksHistory = RecentBlocksHistory;
+declare const index$c_RecentBlocksHistory: typeof RecentBlocksHistory;
+type index$c_SafroleData = SafroleData;
+declare const index$c_SafroleData: typeof SafroleData;
+type index$c_SafroleSealingKeys = SafroleSealingKeys;
+type index$c_SafroleSealingKeysData = SafroleSealingKeysData;
+declare const index$c_SafroleSealingKeysData: typeof SafroleSealingKeysData;
+type index$c_SafroleSealingKeysKind = SafroleSealingKeysKind;
+declare const index$c_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
+type index$c_Service = Service;
+type index$c_ServiceAccountInfo = ServiceAccountInfo;
+declare const index$c_ServiceAccountInfo: typeof ServiceAccountInfo;
+type index$c_ServiceData = ServiceData;
+type index$c_ServiceEntries = ServiceEntries;
+type index$c_ServiceStatistics = ServiceStatistics;
+declare const index$c_ServiceStatistics: typeof ServiceStatistics;
+type index$c_ServicesUpdate = ServicesUpdate;
+type index$c_State = State;
+type index$c_StatisticsData = StatisticsData;
+declare const index$c_StatisticsData: typeof StatisticsData;
+type index$c_StorageItem = StorageItem;
+declare const index$c_StorageItem: typeof StorageItem;
+type index$c_StorageKey = StorageKey;
+type index$c_UpdateError = UpdateError;
+declare const index$c_UpdateError: typeof UpdateError;
+type index$c_UpdatePreimage = UpdatePreimage;
+declare const index$c_UpdatePreimage: typeof UpdatePreimage;
+type index$c_UpdatePreimageKind = UpdatePreimageKind;
+declare const index$c_UpdatePreimageKind: typeof UpdatePreimageKind;
+type index$c_UpdateService = UpdateService;
+declare const index$c_UpdateService: typeof UpdateService;
+type index$c_UpdateServiceKind = UpdateServiceKind;
+declare const index$c_UpdateServiceKind: typeof UpdateServiceKind;
+type index$c_UpdateStorage = UpdateStorage;
+declare const index$c_UpdateStorage: typeof UpdateStorage;
+type index$c_UpdateStorageKind = UpdateStorageKind;
+declare const index$c_UpdateStorageKind: typeof UpdateStorageKind;
+type index$c_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
+type index$c_ValidatorData = ValidatorData;
+declare const index$c_ValidatorData: typeof ValidatorData;
+type index$c_ValidatorStatistics = ValidatorStatistics;
+declare const index$c_ValidatorStatistics: typeof ValidatorStatistics;
+declare const index$c_accumulationOutputComparator: typeof accumulationOutputComparator;
+declare const index$c_codecBandersnatchKey: typeof codecBandersnatchKey;
+declare const index$c_codecPerCore: typeof codecPerCore;
+declare const index$c_codecServiceId: typeof codecServiceId;
+declare const index$c_codecVarGas: typeof codecVarGas;
+declare const index$c_codecVarU16: typeof codecVarU16;
+declare const index$c_codecWithHash: typeof codecWithHash;
+declare const index$c_hashComparator: typeof hashComparator;
+declare const index$c_ignoreValueWithDefault: typeof ignoreValueWithDefault;
+declare const index$c_serviceDataCodec: typeof serviceDataCodec;
+declare const index$c_serviceEntriesCodec: typeof serviceEntriesCodec;
+declare const index$c_sortedSetCodec: typeof sortedSetCodec;
+declare const index$c_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
+declare const index$c_tryAsPerCore: typeof tryAsPerCore;
+declare const index$c_workReportsSortedSetCodec: typeof workReportsSortedSetCodec;
+declare const index$c_zeroSizeHint: typeof zeroSizeHint;
+declare namespace index$c {
+  export { index$c_AccumulationOutput as AccumulationOutput, index$c_AutoAccumulate as AutoAccumulate, index$c_AvailabilityAssignment as AvailabilityAssignment, index$c_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$c_BlockState as BlockState, index$c_CoreStatistics as CoreStatistics, index$c_DisputesRecords as DisputesRecords, index$c_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$c_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$c_InMemoryService as InMemoryService, index$c_InMemoryState as InMemoryState, index$c_LookupHistoryItem as LookupHistoryItem, index$c_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$c_PreimageItem as PreimageItem, index$c_PrivilegedServices as PrivilegedServices, index$c_RecentBlocks as RecentBlocks, index$c_RecentBlocksHistory as RecentBlocksHistory, index$c_SafroleData as SafroleData, index$c_SafroleSealingKeysData as SafroleSealingKeysData, index$c_SafroleSealingKeysKind as SafroleSealingKeysKind, index$c_ServiceAccountInfo as ServiceAccountInfo, index$c_ServiceStatistics as ServiceStatistics, index$c_StatisticsData as StatisticsData, index$c_StorageItem as StorageItem, index$c_UpdateError as UpdateError, index$c_UpdatePreimage as UpdatePreimage, index$c_UpdatePreimageKind as UpdatePreimageKind, index$c_UpdateService as UpdateService, index$c_UpdateServiceKind as UpdateServiceKind, index$c_UpdateStorage as UpdateStorage, index$c_UpdateStorageKind as UpdateStorageKind, index$c_ValidatorData as ValidatorData, index$c_ValidatorStatistics as ValidatorStatistics, index$c_accumulationOutputComparator as accumulationOutputComparator, index$c_codecBandersnatchKey as codecBandersnatchKey, index$c_codecPerCore as codecPerCore, index$c_codecServiceId as codecServiceId, index$c_codecVarGas as codecVarGas, index$c_codecVarU16 as codecVarU16, index$c_codecWithHash as codecWithHash, index$c_hashComparator as hashComparator, index$c_ignoreValueWithDefault as ignoreValueWithDefault, index$c_serviceDataCodec as serviceDataCodec, index$c_serviceEntriesCodec as serviceEntriesCodec, index$c_sortedSetCodec as sortedSetCodec, index$c_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$c_tryAsPerCore as tryAsPerCore, index$c_workReportsSortedSetCodec as workReportsSortedSetCodec, index$c_zeroSizeHint as zeroSizeHint };
+  export type { index$c_BlocksState as BlocksState, index$c_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$c_EnumerableState as EnumerableState, index$c_FieldNames as FieldNames, index$c_InMemoryStateFields as InMemoryStateFields, index$c_LookupHistorySlots as LookupHistorySlots, index$c_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$c_PerCore as PerCore, index$c_SafroleSealingKeys as SafroleSealingKeys, index$c_Service as Service, index$c_ServiceData as ServiceData, index$c_ServiceEntries as ServiceEntries, index$c_ServicesUpdate as ServicesUpdate, index$c_State as State, index$c_StorageKey as StorageKey, index$c_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES };
 }
 
 type StateKey = Opaque<OpaqueHash, "stateKey">;
@@ -11191,7 +11382,10 @@ declare namespace serialize {
   /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
   export const accumulationOutputLog: StateCodec<State["accumulationOutputLog"]> = {
     key: stateKeys.index(StateKeyIdx.Theta),
-    Codec: codec.sequenceVarLen(AccumulationOutput.Codec),
+    Codec: codec.sequenceVarLen(AccumulationOutput.Codec).convert(
+      (i) => i.array,
+      (o) => SortedArray.fromSortedArray(accumulationOutputComparator, o),
+    ),
     extract: (s) => s.accumulationOutputLog,
   };
 
@@ -11866,44 +12060,44 @@ declare function loadState(spec: ChainSpec, entries: Iterable<[StateKey | Trunca
  *        hashmap of `key -> value` entries.
  */
 
-declare const index$c_EMPTY_BLOB: typeof EMPTY_BLOB;
-type index$c_EncodeFun = EncodeFun;
-type index$c_KeyAndCodec<T> = KeyAndCodec<T>;
-type index$c_SerializedService = SerializedService;
-declare const index$c_SerializedService: typeof SerializedService;
-type index$c_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
-declare const index$c_SerializedState: typeof SerializedState;
-type index$c_SerializedStateBackend = SerializedStateBackend;
-type index$c_StateCodec<T> = StateCodec<T>;
-type index$c_StateEntries = StateEntries;
-declare const index$c_StateEntries: typeof StateEntries;
-type index$c_StateEntryUpdate = StateEntryUpdate;
-type index$c_StateEntryUpdateAction = StateEntryUpdateAction;
-declare const index$c_StateEntryUpdateAction: typeof StateEntryUpdateAction;
-type index$c_StateKey = StateKey;
-type index$c_StateKeyIdx = StateKeyIdx;
-declare const index$c_StateKeyIdx: typeof StateKeyIdx;
-declare const index$c_TYPICAL_STATE_ITEMS: typeof TYPICAL_STATE_ITEMS;
-declare const index$c_TYPICAL_STATE_ITEM_LEN: typeof TYPICAL_STATE_ITEM_LEN;
-declare const index$c_U32_BYTES: typeof U32_BYTES;
-declare const index$c_binaryMerkleization: typeof binaryMerkleization;
-declare const index$c_convertInMemoryStateToDictionary: typeof convertInMemoryStateToDictionary;
-declare const index$c_dumpCodec: typeof dumpCodec;
-declare const index$c_getSafroleData: typeof getSafroleData;
-declare const index$c_legacyServiceNested: typeof legacyServiceNested;
-declare const index$c_loadState: typeof loadState;
-import index$c_serialize = serialize;
-declare const index$c_serializeBasicKeys: typeof serializeBasicKeys;
-declare const index$c_serializePreimages: typeof serializePreimages;
-declare const index$c_serializeRemovedServices: typeof serializeRemovedServices;
-declare const index$c_serializeServiceUpdates: typeof serializeServiceUpdates;
-declare const index$c_serializeStateUpdate: typeof serializeStateUpdate;
-declare const index$c_serializeStorage: typeof serializeStorage;
-declare const index$c_stateEntriesSequenceCodec: typeof stateEntriesSequenceCodec;
-import index$c_stateKeys = stateKeys;
-declare namespace index$c {
-  export { index$c_EMPTY_BLOB as EMPTY_BLOB, index$c_SerializedService as SerializedService, index$c_SerializedState as SerializedState, index$c_StateEntries as StateEntries, index$c_StateEntryUpdateAction as StateEntryUpdateAction, index$c_StateKeyIdx as StateKeyIdx, index$c_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$c_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$c_U32_BYTES as U32_BYTES, index$c_binaryMerkleization as binaryMerkleization, index$c_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$c_dumpCodec as dumpCodec, index$c_getSafroleData as getSafroleData, index$c_legacyServiceNested as legacyServiceNested, index$c_loadState as loadState, index$c_serialize as serialize, index$c_serializeBasicKeys as serializeBasicKeys, index$c_serializePreimages as serializePreimages, index$c_serializeRemovedServices as serializeRemovedServices, index$c_serializeServiceUpdates as serializeServiceUpdates, index$c_serializeStateUpdate as serializeStateUpdate, index$c_serializeStorage as serializeStorage, index$c_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$c_stateKeys as stateKeys };
-  export type { index$c_EncodeFun as EncodeFun, index$c_KeyAndCodec as KeyAndCodec, index$c_SerializedStateBackend as SerializedStateBackend, index$c_StateCodec as StateCodec, index$c_StateEntryUpdate as StateEntryUpdate, index$c_StateKey as StateKey };
+declare const index$b_EMPTY_BLOB: typeof EMPTY_BLOB;
+type index$b_EncodeFun = EncodeFun;
+type index$b_KeyAndCodec<T> = KeyAndCodec<T>;
+type index$b_SerializedService = SerializedService;
+declare const index$b_SerializedService: typeof SerializedService;
+type index$b_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
+declare const index$b_SerializedState: typeof SerializedState;
+type index$b_SerializedStateBackend = SerializedStateBackend;
+type index$b_StateCodec<T> = StateCodec<T>;
+type index$b_StateEntries = StateEntries;
+declare const index$b_StateEntries: typeof StateEntries;
+type index$b_StateEntryUpdate = StateEntryUpdate;
+type index$b_StateEntryUpdateAction = StateEntryUpdateAction;
+declare const index$b_StateEntryUpdateAction: typeof StateEntryUpdateAction;
+type index$b_StateKey = StateKey;
+type index$b_StateKeyIdx = StateKeyIdx;
+declare const index$b_StateKeyIdx: typeof StateKeyIdx;
+declare const index$b_TYPICAL_STATE_ITEMS: typeof TYPICAL_STATE_ITEMS;
+declare const index$b_TYPICAL_STATE_ITEM_LEN: typeof TYPICAL_STATE_ITEM_LEN;
+declare const index$b_U32_BYTES: typeof U32_BYTES;
+declare const index$b_binaryMerkleization: typeof binaryMerkleization;
+declare const index$b_convertInMemoryStateToDictionary: typeof convertInMemoryStateToDictionary;
+declare const index$b_dumpCodec: typeof dumpCodec;
+declare const index$b_getSafroleData: typeof getSafroleData;
+declare const index$b_legacyServiceNested: typeof legacyServiceNested;
+declare const index$b_loadState: typeof loadState;
+import index$b_serialize = serialize;
+declare const index$b_serializeBasicKeys: typeof serializeBasicKeys;
+declare const index$b_serializePreimages: typeof serializePreimages;
+declare const index$b_serializeRemovedServices: typeof serializeRemovedServices;
+declare const index$b_serializeServiceUpdates: typeof serializeServiceUpdates;
+declare const index$b_serializeStateUpdate: typeof serializeStateUpdate;
+declare const index$b_serializeStorage: typeof serializeStorage;
+declare const index$b_stateEntriesSequenceCodec: typeof stateEntriesSequenceCodec;
+import index$b_stateKeys = stateKeys;
+declare namespace index$b {
+  export { index$b_EMPTY_BLOB as EMPTY_BLOB, index$b_SerializedService as SerializedService, index$b_SerializedState as SerializedState, index$b_StateEntries as StateEntries, index$b_StateEntryUpdateAction as StateEntryUpdateAction, index$b_StateKeyIdx as StateKeyIdx, index$b_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$b_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$b_U32_BYTES as U32_BYTES, index$b_binaryMerkleization as binaryMerkleization, index$b_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$b_dumpCodec as dumpCodec, index$b_getSafroleData as getSafroleData, index$b_legacyServiceNested as legacyServiceNested, index$b_loadState as loadState, index$b_serialize as serialize, index$b_serializeBasicKeys as serializeBasicKeys, index$b_serializePreimages as serializePreimages, index$b_serializeRemovedServices as serializeRemovedServices, index$b_serializeServiceUpdates as serializeServiceUpdates, index$b_serializeStateUpdate as serializeStateUpdate, index$b_serializeStorage as serializeStorage, index$b_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$b_stateKeys as stateKeys };
+  export type { index$b_EncodeFun as EncodeFun, index$b_KeyAndCodec as KeyAndCodec, index$b_SerializedStateBackend as SerializedStateBackend, index$b_StateCodec as StateCodec, index$b_StateEntryUpdate as StateEntryUpdate, index$b_StateKey as StateKey };
 }
 
 /** Error during `LeafDb` creation. */
@@ -12111,25 +12305,25 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
   }
 }
 
-type index$b_BlocksDb = BlocksDb;
-type index$b_InMemoryBlocks = InMemoryBlocks;
-declare const index$b_InMemoryBlocks: typeof InMemoryBlocks;
-type index$b_InMemoryStates = InMemoryStates;
-declare const index$b_InMemoryStates: typeof InMemoryStates;
-type index$b_LeafDb = LeafDb;
-declare const index$b_LeafDb: typeof LeafDb;
-type index$b_LeafDbError = LeafDbError;
-declare const index$b_LeafDbError: typeof LeafDbError;
-type index$b_Lookup = Lookup;
-type index$b_LookupKind = LookupKind;
-declare const index$b_LookupKind: typeof LookupKind;
-type index$b_StateUpdateError = StateUpdateError;
-declare const index$b_StateUpdateError: typeof StateUpdateError;
-type index$b_StatesDb<T extends State = State> = StatesDb<T>;
-type index$b_ValuesDb = ValuesDb;
-declare namespace index$b {
-  export { index$b_InMemoryBlocks as InMemoryBlocks, index$b_InMemoryStates as InMemoryStates, index$b_LeafDb as LeafDb, index$b_LeafDbError as LeafDbError, index$b_LookupKind as LookupKind, index$b_StateUpdateError as StateUpdateError };
-  export type { index$b_BlocksDb as BlocksDb, index$b_Lookup as Lookup, index$b_StatesDb as StatesDb, index$b_ValuesDb as ValuesDb };
+type index$a_BlocksDb = BlocksDb;
+type index$a_InMemoryBlocks = InMemoryBlocks;
+declare const index$a_InMemoryBlocks: typeof InMemoryBlocks;
+type index$a_InMemoryStates = InMemoryStates;
+declare const index$a_InMemoryStates: typeof InMemoryStates;
+type index$a_LeafDb = LeafDb;
+declare const index$a_LeafDb: typeof LeafDb;
+type index$a_LeafDbError = LeafDbError;
+declare const index$a_LeafDbError: typeof LeafDbError;
+type index$a_Lookup = Lookup;
+type index$a_LookupKind = LookupKind;
+declare const index$a_LookupKind: typeof LookupKind;
+type index$a_StateUpdateError = StateUpdateError;
+declare const index$a_StateUpdateError: typeof StateUpdateError;
+type index$a_StatesDb<T extends State = State> = StatesDb<T>;
+type index$a_ValuesDb = ValuesDb;
+declare namespace index$a {
+  export { index$a_InMemoryBlocks as InMemoryBlocks, index$a_InMemoryStates as InMemoryStates, index$a_LeafDb as LeafDb, index$a_LeafDbError as LeafDbError, index$a_LookupKind as LookupKind, index$a_StateUpdateError as StateUpdateError };
+  export type { index$a_BlocksDb as BlocksDb, index$a_Lookup as Lookup, index$a_StatesDb as StatesDb, index$a_ValuesDb as ValuesDb };
 }
 
 /**
@@ -12548,30 +12742,30 @@ declare const initEc = async () => {
   await init.reedSolomon();
 };
 
-declare const index$a_HALF_POINT_SIZE: typeof HALF_POINT_SIZE;
-declare const index$a_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
-type index$a_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
-type index$a_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
-type index$a_PIECE_SIZE = PIECE_SIZE;
-declare const index$a_POINT_ALIGNMENT: typeof POINT_ALIGNMENT;
-type index$a_POINT_LENGTH = POINT_LENGTH;
-declare const index$a_chunkingFunction: typeof chunkingFunction;
-declare const index$a_chunksToShards: typeof chunksToShards;
-declare const index$a_decodeData: typeof decodeData;
-declare const index$a_decodeDataAndTrim: typeof decodeDataAndTrim;
-declare const index$a_decodePiece: typeof decodePiece;
-declare const index$a_encodePoints: typeof encodePoints;
-declare const index$a_initEc: typeof initEc;
-declare const index$a_join: typeof join;
-declare const index$a_lace: typeof lace;
-declare const index$a_padAndEncodeData: typeof padAndEncodeData;
-declare const index$a_shardsToChunks: typeof shardsToChunks;
-declare const index$a_split: typeof split;
-declare const index$a_transpose: typeof transpose;
-declare const index$a_unzip: typeof unzip;
-declare namespace index$a {
-  export { index$a_HALF_POINT_SIZE as HALF_POINT_SIZE, index$a_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$a_POINT_ALIGNMENT as POINT_ALIGNMENT, index$a_chunkingFunction as chunkingFunction, index$a_chunksToShards as chunksToShards, index$a_decodeData as decodeData, index$a_decodeDataAndTrim as decodeDataAndTrim, index$a_decodePiece as decodePiece, index$a_encodePoints as encodePoints, index$a_initEc as initEc, index$a_join as join, index$a_lace as lace, index$a_padAndEncodeData as padAndEncodeData, index$a_shardsToChunks as shardsToChunks, index$a_split as split, index$a_transpose as transpose, index$a_unzip as unzip };
-  export type { index$a_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$a_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$a_PIECE_SIZE as PIECE_SIZE, index$a_POINT_LENGTH as POINT_LENGTH };
+declare const index$9_HALF_POINT_SIZE: typeof HALF_POINT_SIZE;
+declare const index$9_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
+type index$9_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
+type index$9_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
+type index$9_PIECE_SIZE = PIECE_SIZE;
+declare const index$9_POINT_ALIGNMENT: typeof POINT_ALIGNMENT;
+type index$9_POINT_LENGTH = POINT_LENGTH;
+declare const index$9_chunkingFunction: typeof chunkingFunction;
+declare const index$9_chunksToShards: typeof chunksToShards;
+declare const index$9_decodeData: typeof decodeData;
+declare const index$9_decodeDataAndTrim: typeof decodeDataAndTrim;
+declare const index$9_decodePiece: typeof decodePiece;
+declare const index$9_encodePoints: typeof encodePoints;
+declare const index$9_initEc: typeof initEc;
+declare const index$9_join: typeof join;
+declare const index$9_lace: typeof lace;
+declare const index$9_padAndEncodeData: typeof padAndEncodeData;
+declare const index$9_shardsToChunks: typeof shardsToChunks;
+declare const index$9_split: typeof split;
+declare const index$9_transpose: typeof transpose;
+declare const index$9_unzip: typeof unzip;
+declare namespace index$9 {
+  export { index$9_HALF_POINT_SIZE as HALF_POINT_SIZE, index$9_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$9_POINT_ALIGNMENT as POINT_ALIGNMENT, index$9_chunkingFunction as chunkingFunction, index$9_chunksToShards as chunksToShards, index$9_decodeData as decodeData, index$9_decodeDataAndTrim as decodeDataAndTrim, index$9_decodePiece as decodePiece, index$9_encodePoints as encodePoints, index$9_initEc as initEc, index$9_join as join, index$9_lace as lace, index$9_padAndEncodeData as padAndEncodeData, index$9_shardsToChunks as shardsToChunks, index$9_split as split, index$9_transpose as transpose, index$9_unzip as unzip };
+  export type { index$9_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$9_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$9_PIECE_SIZE as PIECE_SIZE, index$9_POINT_LENGTH as POINT_LENGTH };
 }
 
 /** Size of the transfer memo. */
@@ -12914,173 +13108,6 @@ interface GasCounter {
   sub(g: Gas): boolean;
 }
 
-declare enum Level {
-  INSANE = 1,
-  TRACE = 2,
-  LOG = 3,
-  INFO = 4,
-  WARN = 5,
-  ERROR = 6,
-}
-
-type Options = {
-  defaultLevel: Level;
-  workingDir: string;
-  modules: Map<string, Level>;
-};
-
-/**
- * A function to parse logger definition (including modules) given as a string.
- *
- * Examples
- *  - `info` - setup default logging level to `info`.
- *  - `trace` - default logging level set to `trace`.
- *  - `debug;consensus=trace` - default level is set to `debug/log`, but consensus is in trace mode.
- */
-declare function parseLoggerOptions(input: string, defaultLevel: Level, workingDir?: string): Options {
-  const modules = new Map<string, Level>();
-  const parts = input.toLowerCase().split(",");
-  let defLevel = defaultLevel;
-
-  for (const p of parts) {
-    const clean = p.trim();
-    // skip empty objects (forgotten `,` removed)
-    if (clean.length === 0) {
-      continue;
-    }
-    // we just have the default level
-    if (clean.includes("=")) {
-      const [mod, lvl] = clean.split("=");
-      modules.set(mod.trim(), parseLevel(lvl.trim()));
-    } else {
-      defLevel = parseLevel(clean);
-    }
-  }
-
-  // TODO [ToDr] Fix dirname for workers.
-  const myDir = (import.meta.dirname ?? "").split("/");
-  myDir.pop();
-  myDir.pop();
-  return {
-    defaultLevel: defLevel,
-    modules,
-    workingDir: workingDir ?? myDir.join("/"),
-  };
-}
-
-declare const GLOBAL_CONFIG = {
-  options: DEFAULT_OPTIONS,
-  transport: ConsoleTransport.create(DEFAULT_OPTIONS.defaultLevel, DEFAULT_OPTIONS),
-};
-
-/**
- * A logger instance.
- */
-declare class Logger {
-  /**
-   * Create a new logger instance given filename and an optional module name.
-   *
-   * If the module name is not given, `fileName` becomes the module name.
-   * The module name can be composed from multiple parts separated with `/`.
-   *
-   * The logger will use a global configuration which can be changed using
-   * [`configureLogger`] function.
-   */
-  static new(fileName?: string, moduleName?: string) {
-    const fName = fileName ?? "unknown";
-    return new Logger(moduleName ?? fName, fName, GLOBAL_CONFIG);
-  }
-
-  /**
-   * Return currently configured level for given module. */
-  static getLevel(moduleName: string): Level {
-    return findLevel(GLOBAL_CONFIG.options, moduleName);
-  }
-
-  /**
-   * Global configuration of all loggers.
-   *
-   * One can specify a default logging level (only logs with level >= default will be printed).
-   * It's also possible to configure per-module logging level that takes precedence
-   * over the default one.
-   *
-   * Changing the options affects all previously created loggers.
-   */
-  static configureAllFromOptions(options: Options) {
-    // find minimal level to optimise logging in case
-    // we don't care about low-level logs.
-    const minimalLevel = Array.from(options.modules.values()).reduce((level, modLevel) => {
-      return level < modLevel ? level : modLevel;
-    }, options.defaultLevel);
-
-    const transport = ConsoleTransport.create(minimalLevel, options);
-
-    // set the global config
-    GLOBAL_CONFIG.options = options;
-    GLOBAL_CONFIG.transport = transport;
-  }
-
-  /**
-   * Global configuration of all loggers.
-   *
-   * Parse configuration options from an input string typically obtained
-   * from environment variable `JAM_LOG`.
-   */
-  static configureAll(input: string, defaultLevel: Level, workingDir?: string) {
-    const options = parseLoggerOptions(input, defaultLevel, workingDir);
-    Logger.configureAllFromOptions(options);
-  }
-
-  constructor(
-    private readonly moduleName: string,
-    private readonly fileName: string,
-    private readonly config: typeof GLOBAL_CONFIG,
-  ) {}
-
-  /** Log a message with `INSANE` level. */
-  insane(val: string) {
-    this.config.transport.insane(this.moduleName, val);
-  }
-
-  /** Log a message with `TRACE` level. */
-  trace(val: string) {
-    this.config.transport.trace(this.moduleName, val);
-  }
-
-  /** Log a message with `DEBUG`/`LOG` level. */
-  log(val: string) {
-    this.config.transport.log(this.moduleName, val);
-  }
-
-  /** Log a message with `INFO` level. */
-  info(val: string) {
-    this.config.transport.info(this.moduleName, val);
-  }
-
-  /** Log a message with `WARN` level. */
-  warn(val: string) {
-    this.config.transport.warn(this.moduleName, val);
-  }
-
-  /** Log a message with `ERROR` level. */
-  error(val: string) {
-    this.config.transport.error(this.moduleName, val);
-  }
-}
-
-type index$9_Level = Level;
-declare const index$9_Level: typeof Level;
-type index$9_Logger = Logger;
-declare const index$9_Logger: typeof Logger;
-declare const index$9_parseLoggerOptions: typeof parseLoggerOptions;
-declare namespace index$9 {
-  export {
-    index$9_Level as Level,
-    index$9_Logger as Logger,
-    index$9_parseLoggerOptions as parseLoggerOptions,
-  };
-}
-
 /**
  * Mask class is an implementation of skip function defined in GP.
  *
@@ -18630,7 +18657,7 @@ type JsonStateDump = {
   pi: JsonStatisticsData;
   omega: State["accumulationQueue"];
   xi: PerEpochBlock<WorkPackageHash[]>;
-  theta: State["accumulationOutputLog"] | null;
+  theta: AccumulationOutput[] | null;
   accounts: InMemoryService[];
 };
 
@@ -18732,7 +18759,7 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
           xi.map((x) => HashSet.from(x)),
           spec,
         ),
-        accumulationOutputLog: theta ?? [],
+        accumulationOutputLog: SortedArray.fromArray(accumulationOutputComparator, theta ?? []),
         services: new Map(accounts.map((x) => [x.serviceId, x])),
       });
     },
@@ -19090,4 +19117,4 @@ declare namespace index {
   export type { index_PreimagesInput as PreimagesInput, index_PreimagesState as PreimagesState, index_PreimagesStateUpdate as PreimagesStateUpdate };
 }
 
-export { index$j as block, index$h as block_json, index$q as bytes, index$o as codec, index$m as collections, index$k as config, index$g as config_node, index$l as crypto, index$b as database, index$a as erasure_coding, index$n as hash, index$6 as jam_host_calls, index$i as json_parser, index$9 as logger, index$e as mmr, index$p as numbers, index$r as ordering, index$3 as pvm, index$7 as pvm_host_calls, index$8 as pvm_interpreter, index$4 as pvm_program, index$5 as pvm_spi_decoder, index$2 as shuffling, index$d as state, index$1 as state_json, index$c as state_merkleization, index as transition, index$f as trie, index$s as utils };
+export { index$j as block, index$h as block_json, index$q as bytes, index$o as codec, index$m as collections, index$k as config, index$f as config_node, index$l as crypto, index$a as database, index$9 as erasure_coding, index$n as hash, index$6 as jam_host_calls, index$i as json_parser, index$g as logger, index$d as mmr, index$p as numbers, index$r as ordering, index$3 as pvm, index$7 as pvm_host_calls, index$8 as pvm_interpreter, index$4 as pvm_program, index$5 as pvm_spi_decoder, index$2 as shuffling, index$c as state, index$1 as state_json, index$b as state_merkleization, index as transition, index$e as trie, index$s as utils };