@aztec-labs/p2p 6.0.0-nightly.20260829

package/src/msg_validators/tx_validator/tx_validation_cache.ts

@@ -0,0 +1,100 @@
+import { LruMap } from '@aztec-labs/foundation/collection';
+import { type Logger, createLogger } from '@aztec-labs/foundation/log';
+import type { Tx, TxValidationResult } from '@aztec-labs/stdlib/tx';
+import { createHash } from 'node:crypto';
+
+/**
+ * Minimal interface consumed by {@link CachedTxValidator}.
+ * Keeping the dependency on an interface lets callers (and tests) substitute any cache implementation.
+ */
+export interface ITxValidationCache {
+  /** Returns the cached promise if present, otherwise calls `validate`, caches its promise, and returns it. */
+  getOrValidate(
+    validatorSymbol: symbol,
+    tx: Tx,
+    validate: () => Promise<TxValidationResult>,
+  ): Promise<TxValidationResult>;
+}
+
+/**
+ * Caches per-validator tx validation results to avoid redundant work across repeated validation calls.
+ *
+ * The cache key is composed from the validator symbol and tx hash, ensuring results are
+ * scoped to the specific validator that produced them.
+ *
+ * Promises are stored before they are awaited, so concurrent calls for the same pair share
+ * a single in-flight validation rather than launching duplicate work.
+ *
+ * Entries are evicted in least-recently-used order once the cache reaches `maxSize`.
+ */
+export class TxValidationCache implements ITxValidationCache {
+  #log: Logger;
+
+  private readonly entries: LruMap<string, Promise<TxValidationResult>>;
+  // Remember hashes for known Tx object references to skip rehashing on subsequent lookups.
+  // WeakMap holds keys weakly, so an entry doesn't keep the Tx alive once nothing else references it.
+  private readonly txHashesCache: WeakMap<Tx, string> = new WeakMap();
+
+  constructor(maxSize: number) {
+    this.entries = new LruMap(maxSize);
+    this.#log = createLogger('p2p:tx_validation_cache');
+  }
+
+  /**
+   * Computes the cache key scoping a validation result to a specific validator and tx.
+   *
+   * @param validatorSymbol - The symbol of the validator.
+   * @param tx - The tx to compute the key for.
+   * @returns The cache key.
+   *
+   * Note: the key should NOT use the tx.hash because it can't be trusted at this point.
+   */
+  public key(validatorSymbol: symbol, tx: Tx): string {
+    // Serializing the tx dominates cost (~5 ms). If we have already hashed this object, skip toBuffer + hash.
+    let hash = this.txHashesCache.get(tx);
+    if (hash === undefined) {
+      hash = createHash('sha256').update(tx.toBuffer()).digest('hex');
+      this.txHashesCache.set(tx, hash);
+    }
+    return `${Symbol.keyFor(validatorSymbol) ?? validatorSymbol.toString()}:${hash}`;
+  }
+
+  /** Returns the cached promise for the given key, or undefined if not cached. Refreshes recency. */
+  public get(key: string): Promise<TxValidationResult> | undefined {
+    return this.entries.get(key);
+  }
+
+  /** Stores a validation promise under the given key, evicting the LRU entry if at capacity. */
+  public set(key: string, result: Promise<TxValidationResult>): void {
+    this.entries.set(key, result);
+  }
+
+  /** Removes the cached validation promise for the given key. */
+  public delete(key: string): void {
+    this.entries.delete(key);
+  }
+
+  /**
+   * Returns the cached promise if present, otherwise calls `validate`, stores its promise
+   * immediately (before awaiting), and returns it.
+   */
+  public getOrValidate(
+    validatorSymbol: symbol,
+    tx: Tx,
+    validate: () => Promise<TxValidationResult>,
+  ): Promise<TxValidationResult> {
+    const key = this.key(validatorSymbol, tx);
+    const cached = this.get(key);
+    if (cached !== undefined) {
+      this.#log.debug('Returning cached tx validation result', {
+        validator: validatorSymbol.toString(),
+        txHash: tx.txHash.toString(),
+        key: key,
+      });
+      return cached;
+    }
+    const promise = validate();
+    this.set(key, promise);
+    return promise;
+  }
+}

package/src/services/data_store.ts

@@ -0,0 +1,229 @@
+import { filter, map, sort, take } from '@aztec-labs/foundation/iterable';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec-labs/kv-store';
+import { type Batch, type Datastore, Key, type KeyQuery, type Pair, type Query } from 'interface-datastore';
+import type { AwaitIterable } from 'interface-store';
+
+type MemoryItem = {
+  lastAccessedMs: number;
+  data: Uint8Array;
+};
+
+type BatchOp = {
+  type: 'put' | 'del';
+  key: Key;
+  value?: Uint8Array;
+};
+
+class KeyNotFoundError extends Error {
+  code: string;
+  constructor(message: string) {
+    super(message);
+    this.code = 'ERR_NOT_FOUND';
+  }
+}
+
+export class AztecDatastore implements Datastore {
+  #db: AztecAsyncKVStore;
+  #memoryDatastore: Map<string, MemoryItem>;
+  #dbDatastore: AztecAsyncMap<string, Uint8Array>;
+
+  private maxMemoryItems: number;
+
+  constructor(db: AztecAsyncKVStore, { maxMemoryItems } = { maxMemoryItems: 50 }) {
+    this.#db = db;
+    this.#memoryDatastore = new Map();
+    this.#dbDatastore = db.openMap('p2p_datastore');
+    this.maxMemoryItems = maxMemoryItems;
+  }
+
+  async has(key: Key): Promise<boolean> {
+    return this.#memoryDatastore.has(key.toString()) || (await this.#dbDatastore.hasAsync(key.toString()));
+  }
+
+  async get(key: Key): Promise<Uint8Array> {
+    const keyStr = key.toString();
+    const memoryItem = this.#memoryDatastore.get(keyStr);
+    if (memoryItem) {
+      memoryItem.lastAccessedMs = Date.now();
+      return memoryItem.data;
+    }
+    const dbItem = await this.#dbDatastore.getAsync(keyStr);
+
+    if (!dbItem) {
+      throw new KeyNotFoundError(`Key not found`);
+    }
+
+    return Uint8Array.from(dbItem);
+  }
+
+  put(key: Key, val: Uint8Array): Promise<Key> {
+    return this._put(key, val);
+  }
+
+  async *putMany(source: AwaitIterable<Pair>): AwaitIterable<Key> {
+    for await (const { key, value } of source) {
+      await this.put(key, value);
+      yield key;
+    }
+  }
+
+  async *getMany(source: AwaitIterable<Key>): AwaitIterable<Pair> {
+    for await (const key of source) {
+      yield {
+        key,
+        value: await this.get(key),
+      };
+    }
+  }
+
+  async *deleteMany(source: AwaitIterable<Key>): AwaitIterable<Key> {
+    for await (const key of source) {
+      await this.delete(key);
+      yield key;
+    }
+  }
+
+  async delete(key: Key): Promise<void> {
+    this.#memoryDatastore.delete(key.toString());
+    await this.#dbDatastore.delete(key.toString());
+  }
+
+  batch(): Batch {
+    const ops: BatchOp[] = [];
+    return {
+      put: (key, value) => {
+        ops.push({ type: 'put', key, value });
+      },
+      delete: key => {
+        ops.push({ type: 'del', key });
+      },
+      commit: async () => {
+        await this.#db.transactionAsync(async () => {
+          for (const op of ops) {
+            if (op.type === 'put' && op.value) {
+              await this.put(op.key, op.value);
+            } else if (op.type === 'del') {
+              await this.delete(op.key);
+            }
+          }
+        });
+        ops.length = 0;
+      },
+    };
+  }
+
+  query(q: Query): AwaitIterable<Pair> {
+    let it = this.all(); //
+    const { prefix, filters, orders, offset, limit } = q;
+
+    if (prefix != null) {
+      it = filter(it, e => e.key.toString().startsWith(`${prefix}`));
+    }
+
+    if (Array.isArray(filters)) {
+      it = filters.reduce((it, f) => filter(it, f), it);
+    }
+
+    if (Array.isArray(orders)) {
+      it = orders.reduce((it, f) => sort(it, f), it);
+    }
+
+    if (offset != null) {
+      let i = 0;
+      it = filter(it, () => i++ >= offset);
+    }
+
+    if (limit != null) {
+      it = take(it, limit);
+    }
+
+    return it;
+  }
+
+  queryKeys(q: KeyQuery): AsyncIterable<Key> {
+    let it = map(this.all(), ({ key }) => key);
+    const { prefix, filters, orders, offset, limit } = q;
+    if (prefix != null) {
+      it = filter(it, e => e.toString().startsWith(`${prefix}`));
+    }
+
+    if (Array.isArray(filters)) {
+      it = filters.reduce((it, f) => filter(it, f), it);
+    }
+
+    if (Array.isArray(orders)) {
+      it = orders.reduce((it, f) => sort(it, f), it);
+    }
+
+    if (offset != null) {
+      let i = 0;
+      it = filter(it, () => i++ >= offset);
+    }
+
+    if (limit != null) {
+      it = take(it, limit);
+    }
+
+    return it;
+  }
+
+  private async _put(key: Key, val: Uint8Array): Promise<Key> {
+    const keyStr = key.toString();
+    while (this.#memoryDatastore.size >= this.maxMemoryItems) {
+      this.pruneMemoryDatastore();
+    }
+    const memoryItem = this.#memoryDatastore.get(keyStr);
+    if (memoryItem) {
+      // update existing
+      memoryItem.lastAccessedMs = Date.now();
+      memoryItem.data = val;
+    } else {
+      // new entry
+      this.#memoryDatastore.set(keyStr, { data: val, lastAccessedMs: Date.now() });
+    }
+
+    // Always add to DB
+    await this.#dbDatastore.set(keyStr, val);
+
+    return key;
+  }
+
+  private async *all(): AsyncIterable<Pair> {
+    for (const [key, value] of this.#memoryDatastore.entries()) {
+      yield {
+        key: new Key(key),
+        value: value.data,
+      };
+    }
+
+    for await (const [key, value] of this.#dbDatastore.entriesAsync()) {
+      if (!this.#memoryDatastore.has(key)) {
+        yield {
+          key: new Key(key),
+          value,
+        };
+      }
+    }
+  }
+
+  /**
+   * Prune memory store
+   */
+  private pruneMemoryDatastore(): void {
+    let oldestAccessedMs = Date.now() + 1000;
+    let oldestKey: string | undefined = undefined;
+    let oldestValue: Uint8Array | undefined = undefined;
+
+    for (const [key, value] of this.#memoryDatastore) {
+      if (value.lastAccessedMs < oldestAccessedMs) {
+        oldestAccessedMs = value.lastAccessedMs;
+        oldestKey = key;
+        oldestValue = value.data;
+      }
+    }
+
+    if (oldestKey && oldestValue) {
+      this.#memoryDatastore.delete(oldestKey);
+    }
+  }
+}