@typeberry/lib 0.0.5-d373345 → 0.0.5-dbd8e5a

package/index.d.ts

@@ -4474,9 +4474,6 @@ 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
@@ -4490,21 +4487,21 @@ declare function derive_public_key(seed: Uint8Array): Uint8Array;
  * or
  * https://graypaper.fluffylabs.dev/#/68eaa1f/0e54010e5401?v=0.6.4
  */
-declare function verify_seal(signer_key: Uint8Array, seal_data: Uint8Array, payload: Uint8Array, aux_data: Uint8Array): Uint8Array;
+declare function verify_seal(keys: Uint8Array, signer_key_index: number, 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(ring_size: number, commitment: Uint8Array, tickets_data: Uint8Array, vrf_input_data_len: number): Uint8Array;
+declare function batch_verify_tickets(keys: 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) => [number, number];
-  readonly batch_verify_tickets: (a: number, b: number, c: number, d: number, e: number, f: 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 __wbindgen_export_0: WebAssembly.Table;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
@@ -8533,9 +8530,7 @@ declare class WriteableNodesDb extends NodesDb {
   }
 }
 
-/** 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 const leafComparator = (x: LeafNode, y: LeafNode) => y.getKey().compare(x.getKey());
 
 declare class InMemoryTrie {
   /** Create an empty in-memory trie. */
@@ -8544,87 +8539,10 @@ declare class InMemoryTrie {
   }
 
   /** Given a collection of leaves, compute the state root. */
-  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);
+  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();
   }
 
   /**
@@ -8642,6 +8560,11 @@ 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,
@@ -8768,7 +8691,7 @@ declare function findNodeToReplace(root: TrieNode, nodes: NodesDb, key: Truncate
 
     const nextNode = nodes.get(nextHash);
     if (nextNode === null) {
-      if (nextHash.isEqualTo(zero)) {
+      if (nextHash.isEqualTo(Bytes.zero(HASH_SIZE))) {
         return traversedPath;
       }
 
@@ -8904,35 +8827,6 @@ declare function trieStringify(root: TrieNode | null, nodes: NodesDb): string {
   return `\nLeaf('${leaf.getKey().toString()}',${value})`;
 }
 
-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;
@@ -8957,18 +8851,15 @@ 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 { 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 };
 }
 
@@ -11803,6 +11694,8 @@ 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. */
@@ -11814,6 +11707,18 @@ 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;
@@ -11821,6 +11726,8 @@ 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);
@@ -11834,12 +11741,10 @@ declare class StateEntries {
 
   /** https://graypaper.fluffylabs.dev/#/68eaa1f/391600391600?v=0.6.4 */
   getRootHash(): StateRootHash {
-    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();
+    // 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();
   }
 }
 
@@ -12226,13 +12131,13 @@ declare class LeafDb implements SerializedStateBackend {
       );
     }
 
-    const leaves = SortedSet.fromArray(leafComparator, []);
+    const leaves: LeafNode[] = [];
     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.insert(node.asLeafNode());
+      leaves.push(node.asLeafNode());
     }
 
     return Result.ok(new LeafDb(leaves, db));
@@ -12242,11 +12147,11 @@ declare class LeafDb implements SerializedStateBackend {
   private readonly lookup: TruncatedHashDictionary<StateKey, Lookup>;
 
   private constructor(
-    public readonly leaves: SortedSet<LeafNode>,
+    public readonly leaves: readonly LeafNode[],
     public readonly db: ValuesDb,
   ) {
     this.lookup = TruncatedHashDictionary.fromEntries(
-      leaves.array.map((leaf) => {
+      leaves.map((leaf) => {
         const key: StateKey = leaf.getKey().asOpaque();
         const value: Lookup = leaf.hasEmbeddedValue()
           ? {