@typeberry/lib 0.0.5 → 0.1.0-3c30204

package/index.d.ts

@@ -369,7 +369,7 @@ type Result$2<Ok, Error> = OkResult<Ok> | ErrorResult<Error>;
 /** An indication of two possible outcomes returned from a function. */
 declare const Result$2 = {
   /** Create new [`Result`] with `Ok` status. */
-  ok: <Ok, Error>(ok: Ok): Result<Ok, Error> => {
+  ok: <Ok>(ok: Ok): OkResult<Ok> => {
     check(ok !== undefined, "`Ok` type cannot be undefined.");
     return {
       isOk: true,
@@ -379,7 +379,7 @@ declare const Result$2 = {
   },
 
   /** Create new [`Result`] with `Error` status. */
-  error: <Ok, Error>(error: Error, details = ""): Result<Ok, Error> => {
+  error: <Error>(error: Error, details = ""): ErrorResult<Error> => {
     check(error !== undefined, "`Error` type cannot be undefined.");
     return {
       isOk: false,
@@ -3447,6 +3447,8 @@ type KeccakHash = Bytes<HASH_SIZE>;
 /** Truncated hash. */
 type TruncatedHash = Bytes<TRUNCATED_HASH_SIZE>;
 
+declare const ZERO_HASH = Bytes.zero(HASH_SIZE);
+
 /**
  * Container for some object with a hash that is related to this object.
  *
@@ -3655,11 +3657,12 @@ type index$n_WithHash<THash extends OpaqueHash, TData> = WithHash<THash, TData>;
 declare const index$n_WithHash: typeof WithHash;
 type index$n_WithHashAndBytes<THash extends OpaqueHash, TData> = WithHashAndBytes<THash, TData>;
 declare const index$n_WithHashAndBytes: typeof WithHashAndBytes;
+declare const index$n_ZERO_HASH: typeof ZERO_HASH;
 declare const index$n_blake2b: typeof blake2b;
 declare const index$n_defaultAllocator: typeof defaultAllocator;
 declare const index$n_keccak: typeof keccak;
 declare namespace index$n {
-  export { index$n_PageAllocator as PageAllocator, index$n_SimpleAllocator as SimpleAllocator, index$n_WithHash as WithHash, index$n_WithHashAndBytes as WithHashAndBytes, index$n_blake2b as blake2b, index$n_defaultAllocator as defaultAllocator, index$n_keccak as keccak };
+  export { index$n_PageAllocator as PageAllocator, index$n_SimpleAllocator as SimpleAllocator, index$n_WithHash as WithHash, index$n_WithHashAndBytes as WithHashAndBytes, index$n_ZERO_HASH as ZERO_HASH, index$n_blake2b as blake2b, index$n_defaultAllocator as defaultAllocator, index$n_keccak as keccak };
   export type { index$n_Blake2bHash as Blake2bHash, index$n_HASH_SIZE as HASH_SIZE, index$n_HashAllocator as HashAllocator, index$n_KeccakHash as KeccakHash, index$n_OpaqueHash as OpaqueHash, index$n_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, index$n_TruncatedHash as TruncatedHash };
 }
 
@@ -4474,6 +4477,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 +4493,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 +7858,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 +8044,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 +8107,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 +8126,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,
   };
 }
 
@@ -8357,7 +8536,9 @@ declare class WriteableNodesDb extends NodesDb {
   }
 }
 
-declare const leafComparator = (x: LeafNode, y: LeafNode) => y.getKey().compare(x.getKey());
+/** Compare two trie `LeafNode`s only by their key. */
+declare const leafComparator = (x: LeafNode, y: LeafNode) => x.getKey().compare(y.getKey());
+declare const zero = Bytes.zero(HASH_SIZE).asOpaque();
 
 declare class InMemoryTrie {
   /** Create an empty in-memory trie. */
@@ -8366,10 +8547,87 @@ declare class InMemoryTrie {
   }
 
   /** Given a collection of leaves, compute the state root. */
-  static computeStateRoot(hasher: TrieHasher, leaves: readonly LeafNode[]) {
-    // TODO [ToDr] [opti] Simple loop to just compute the root hash instead of
-    // constructing the entire trie.
-    return InMemoryTrie.fromLeaves(hasher, leaves).getRootHash();
+  static computeStateRoot(hasher: TrieHasher, leaves: SortedSet<LeafNode>): TrieNodeHash {
+    const sorted = leaves.slice();
+    const firstSorted = sorted.shift();
+    if (firstSorted === undefined) {
+      return zero;
+    }
+
+    const nodes = [
+      {
+        leaf: firstSorted,
+        sharedBitsWithPrev: 0,
+      },
+    ];
+    let last = nodes[0];
+    // first we go through all of the sorted leaves and figure out how much in common
+    // they have with the previous node.
+    // If the shared-prefix drops, it means we are going up in depth (i.e. we are in different branch).
+    for (const leaf of sorted) {
+      const sharedBitsCount = findSharedPrefix(leaf.getKey(), last.leaf.getKey());
+      last = {
+        leaf,
+        sharedBitsWithPrev: sharedBitsCount,
+      };
+      nodes.push(last);
+    }
+    // Now we will go backwards and hash them together (or create branch nodes).
+    nodes.reverse();
+    const stack: TrieNodeHash[] = [];
+    let currentDepth = 0;
+    const lastNode = nodes.length === 1 ? undefined : nodes[nodes.length - 1];
+    for (const node of nodes) {
+      const isLastNode = node === lastNode;
+      const key = node.leaf.getKey();
+      const prevDepth = currentDepth;
+      currentDepth = node.sharedBitsWithPrev;
+
+      // first push all missing right-hand zero nodes.
+      // Handle the case if all nodes are on the left side and we need one more top-level
+      // extra.
+      const startDepth = isLastNode ? prevDepth : prevDepth + 1;
+      for (let i = startDepth; i <= currentDepth; i++) {
+        if (getBit(key, i) === false) {
+          stack.push(zero);
+        }
+      }
+
+      // now let's push the hash of the current leaf
+      const hash = hasher.hashConcat(node.leaf.node.raw);
+      stack.push(hash);
+      // we are going further down, so no need to merge anything
+      if (prevDepth < currentDepth) {
+        continue;
+      }
+      // jumping back to some lower depth, we need to merge what we have on the stack.
+      // we need to handle a case where we have no nodes on the top-most left side.
+      // in such case we just add extra zero on the left.
+      const endDepth = isLastNode ? currentDepth - 1 : currentDepth;
+      for (let i = prevDepth; i > endDepth; i--) {
+        if (getBit(key, i) === true) {
+          stack.push(zero);
+        }
+        const current = stack.pop() ?? zero;
+        const next = stack.pop() ?? zero;
+        const branchNode = BranchNode.fromSubNodes(current, next);
+        const hash = hasher.hashConcat(branchNode.node.raw);
+        stack.push(hash);
+      }
+    }
+
+    return stack.pop() ?? zero;
+  }
+
+  /**
+   * Construct a `LeafNode` from given `key` and `value`.
+   *
+   * NOTE: for large value it WILL NOT be embedded in the leaf node,
+   * and should rather be stored separately.
+   */
+  static constructLeaf(hasher: TrieHasher, key: InputKey, value: BytesBlob, maybeValueHash?: ValueHash) {
+    const valueHash = () => maybeValueHash ?? hasher.hashConcat(value.raw).asOpaque();
+    return LeafNode.fromValue(key, value, valueHash);
   }
 
   /**
@@ -8387,11 +8645,6 @@ declare class InMemoryTrie {
     return new InMemoryTrie(nodes, root);
   }
 
-  static constructLeaf(hasher: TrieHasher, key: InputKey, value: BytesBlob, maybeValueHash?: ValueHash) {
-    const valueHash = () => maybeValueHash ?? hasher.hashConcat(value.raw).asOpaque();
-    return LeafNode.fromValue(key, value, valueHash);
-  }
-
   private constructor(
     // Exposed for trie-visualiser
     public readonly nodes: WriteableNodesDb,
@@ -8518,7 +8771,7 @@ declare function findNodeToReplace(root: TrieNode, nodes: NodesDb, key: Truncate
 
     const nextNode = nodes.get(nextHash);
     if (nextNode === null) {
-      if (nextHash.isEqualTo(Bytes.zero(HASH_SIZE))) {
+      if (nextHash.isEqualTo(zero)) {
         return traversedPath;
       }
 
@@ -8654,40 +8907,72 @@ 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 };
+declare function findSharedPrefix(a: TruncatedStateKey, b: TruncatedStateKey) {
+  for (let i = 0; i < TRUNCATED_HASH_SIZE; i++) {
+    const diff = a.raw[i] ^ b.raw[i];
+    if (diff === 0) {
+      continue;
+    }
+    // check how many bits match
+    for (const [mask, matchingBits] of bitLookup) {
+      if ((mask & diff) !== 0) {
+        return i * 8 + matchingBits;
+      }
+    }
+    return i;
+  }
+  return TRUNCATED_HASH_SIZE * 8;
+}
+
+declare const bitLookup = [
+  [0b10000000, 0],
+  [0b01000000, 1],
+  [0b00100000, 2],
+  [0b00010000, 3],
+  [0b00001000, 4],
+  [0b00000100, 5],
+  [0b00000010, 6],
+  [0b00000001, 7],
+  [0b00000000, 8],
+];
+
+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_bitLookup: typeof bitLookup;
+declare const index$e_createSubtreeForBothLeaves: typeof createSubtreeForBothLeaves;
+declare const index$e_findNodeToReplace: typeof findNodeToReplace;
+declare const index$e_findSharedPrefix: typeof findSharedPrefix;
+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 const index$e_zero: typeof zero;
+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_bitLookup as bitLookup, index$e_createSubtreeForBothLeaves as createSubtreeForBothLeaves, index$e_findNodeToReplace as findNodeToReplace, index$e_findSharedPrefix as findSharedPrefix, 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, index$e_zero as zero };
+  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 +9028,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 +9414,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 +10342,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 +10930,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 +11074,7 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
         validatorsManager: tryAsServiceId(0),
         autoAccumulateServices: [],
       }),
-      accumulationOutputLog: [],
+      accumulationOutputLog: SortedArray.fromArray(accumulationOutputComparator, []),
       services: new Map(),
     });
   }
@@ -10822,102 +11121,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 +11491,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,
   };
 
@@ -11503,8 +11806,6 @@ declare class StateEntries {
     return new StateEntries(TruncatedHashDictionary.fromEntries(entries));
   }
 
-  private trieCache: InMemoryTrie | null = null;
-
   private constructor(private readonly entries: TruncatedHashDictionary<StateKey, BytesBlob>) {}
 
   /** When comparing, we can safely ignore `trieCache` and just use entries. */
@@ -11516,18 +11817,6 @@ declare class StateEntries {
     return this.entries[Symbol.iterator]();
   }
 
-  /** Construct the trie from given set of state entries. */
-  public getTrie(): InMemoryTrie {
-    if (this.trieCache === null) {
-      const trie = InMemoryTrie.empty(blake2bTrieHasher);
-      for (const [key, value] of this.entries) {
-        trie.set(key.asOpaque(), value);
-      }
-      this.trieCache = trie;
-    }
-    return this.trieCache;
-  }
-
   /** Retrieve value of some serialized key (if present). */
   get(key: StateKey): BytesBlob | null {
     return this.entries.get(key) ?? null;
@@ -11535,8 +11824,6 @@ declare class StateEntries {
 
   /** Modify underlying entries dictionary with given update. */
   applyUpdate(stateEntriesUpdate: Iterable<StateEntryUpdate>) {
-    // NOTE since we are altering the structure, we need to reset the cache.
-    this.trieCache = null;
     for (const [action, key, value] of stateEntriesUpdate) {
       if (action === StateEntryUpdateAction.Insert) {
         this.entries.set(key, value);
@@ -11550,10 +11837,12 @@ declare class StateEntries {
 
   /** https://graypaper.fluffylabs.dev/#/68eaa1f/391600391600?v=0.6.4 */
   getRootHash(): StateRootHash {
-    // TODO [ToDr] it should be possible to do this more efficiently
-    // by converting the state entries into leaf nodes and constructing
-    // the trie from the trie nodes.
-    return this.getTrie().getRootHash().asOpaque();
+    const leaves: SortedSet<LeafNode> = SortedSet.fromArray(leafComparator);
+    for (const [key, value] of this) {
+      leaves.insert(InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), value));
+    }
+
+    return InMemoryTrie.computeStateRoot(blake2bTrieHasher, leaves).asOpaque();
   }
 }
 
@@ -11866,44 +12155,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. */
@@ -11940,13 +12229,13 @@ declare class LeafDb implements SerializedStateBackend {
       );
     }
 
-    const leaves: LeafNode[] = [];
+    const leaves = SortedSet.fromArray(leafComparator, []);
     for (const nodeData of blob.chunks(TRIE_NODE_BYTES)) {
       const node = new TrieNode(nodeData.raw);
       if (node.getNodeType() === NodeType.Branch) {
         return Result.error(LeafDbError.InvalidLeafData, `Branch node detected: ${nodeData}`);
       }
-      leaves.push(node.asLeafNode());
+      leaves.insert(node.asLeafNode());
     }
 
     return Result.ok(new LeafDb(leaves, db));
@@ -11956,11 +12245,11 @@ declare class LeafDb implements SerializedStateBackend {
   private readonly lookup: TruncatedHashDictionary<StateKey, Lookup>;
 
   private constructor(
-    public readonly leaves: readonly LeafNode[],
+    public readonly leaves: SortedSet<LeafNode>,
     public readonly db: ValuesDb,
   ) {
     this.lookup = TruncatedHashDictionary.fromEntries(
-      leaves.map((leaf) => {
+      leaves.array.map((leaf) => {
         const key: StateKey = leaf.getKey().asOpaque();
         const value: Lookup = leaf.hasEmbeddedValue()
           ? {
@@ -12111,25 +12400,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 +12837,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 +13203,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.
  *
@@ -14324,6 +14446,8 @@ declare enum AccessType {
   WRITE = 1,
 }
 
+// const logger = Logger.new(import.meta.filename, "pvm:mem");
+
 declare class Memory {
   static fromInitialMemory(initialMemoryState: InitialMemoryState) {
     return new Memory(
@@ -14360,7 +14484,7 @@ declare class Memory {
       return Result.ok(OK);
     }
 
-    logger.insane(`MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`);
+    // logger.insane(`MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`);
     const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
 
     if (pagesResult.isError) {
@@ -14449,7 +14573,7 @@ declare class Memory {
       bytesLeft -= bytesToRead;
     }
 
-    logger.insane(`MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`);
+    // logger.insane(`MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`);
     return Result.ok(OK);
   }
 
@@ -18630,7 +18754,7 @@ type JsonStateDump = {
   pi: JsonStatisticsData;
   omega: State["accumulationQueue"];
   xi: PerEpochBlock<WorkPackageHash[]>;
-  theta: State["accumulationOutputLog"] | null;
+  theta: AccumulationOutput[] | null;
   accounts: InMemoryService[];
 };
 
@@ -18732,7 +18856,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 +19214,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 };