@typeberry/lib 0.0.5-ab52154 → 0.0.5-d373345

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;
@@ -8530,7 +8533,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. */
@@ -8539,10 +8544,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);
   }
 
   /**
@@ -8560,11 +8642,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,
@@ -8691,7 +8768,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;
       }
 
@@ -8827,6 +8904,35 @@ 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;
@@ -8851,15 +8957,18 @@ 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_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 { 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 };
 }
 
@@ -11694,8 +11803,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. */
@@ -11707,18 +11814,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;
@@ -11726,8 +11821,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);
@@ -11741,10 +11834,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();
   }
 }
 
@@ -12131,13 +12226,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));
@@ -12147,11 +12242,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()
           ? {