@aztec/foundation 0.76.4 → 0.77.0-testnet-ignition.21

package/src/promise/running-promise.ts

@@ -1,7 +1,22 @@
-import { createLogger } from '../log/pino-logger.js';
+import { type Logger, createLogger } from '../log/pino-logger.js';
 import { InterruptibleSleep } from '../sleep/index.js';
 import { type PromiseWithResolvers, promiseWithResolvers } from './utils.js';
 
+const EXIT = Symbol.for('RunningPromise.EXIT');
+
+export type ErrorHandler = (err: unknown) => typeof EXIT | void | Promise<typeof EXIT | void>;
+
+export function makeLoggingErrorHandler(
+  logger: Logger,
+  ...ignoredErrors: (new (...args: any[]) => Error)[]
+): ErrorHandler {
+  return err => {
+    if (err instanceof Error && !ignoredErrors.some(ErrorType => err instanceof ErrorType)) {
+      logger.error('Error in running promise', err);
+    }
+  };
+}
+
 /**
  * RunningPromise is a utility class that helps manage the execution of an asynchronous function
  * at a specified polling interval. It allows starting, stopping, and checking the status of the
@@ -13,11 +28,13 @@ export class RunningPromise {
   private interruptibleSleep = new InterruptibleSleep();
   private requested: PromiseWithResolvers<void> | undefined = undefined;
 
+  public static readonly EXIT: typeof EXIT = EXIT;
+
   constructor(
     private fn: () => void | Promise<void>,
     private logger = createLogger('running-promise'),
     private pollingIntervalMS = 10000,
-    private ignoredErrors: (new (...args: any[]) => Error)[] = [],
+    private handleError: ErrorHandler = makeLoggingErrorHandler(logger),
   ) {}
 
   /**
@@ -36,8 +53,10 @@ export class RunningPromise {
         try {
           await this.fn();
         } catch (err) {
-          if (err instanceof Error && !this.ignoredErrors.some(ErrorType => err instanceof ErrorType)) {
-            this.logger.error('Error in running promise', err);
+          const code = await this.handleError(err);
+          if (code === RunningPromise.EXIT) {
+            this.logger.warn('Error handler has requested to exit', { err });
+            this.running = false;
           }
         }
 
@@ -48,7 +67,7 @@ export class RunningPromise {
         }
 
         // If no immediate run was requested, sleep for the polling interval.
-        if (this.requested === undefined) {
+        if (this.requested === undefined && this.running) {
           await this.interruptibleSleep.sleep(this.pollingIntervalMS);
         }
       }

package/src/queue/fifo_memory_queue.ts

@@ -1,4 +1,4 @@
-import { type Logger } from '../log/index.js';
+import type { Logger } from '../log/index.js';
 import { BaseMemoryQueue } from './base_memory_queue.js';
 
 /**

package/src/schemas/api.ts

@@ -1,6 +1,6 @@
-import { type z } from 'zod';
+import type { z } from 'zod';
 
-import { type ZodNullableOptional } from './utils.js';
+import type { ZodNullableOptional } from './utils.js';
 
 // Forces usage of ZodNullableOptional in parameters schemas so we properly accept nulls for optional parameters.
 type ZodParameterTypeFor<T> = undefined extends T

package/src/schemas/index.ts

@@ -1,5 +1,5 @@
 export * from './api.js';
 export * from './parse.js';
-export * from './schemas.js';
 export * from './utils.js';
 export * from './types.js';
+export * from './schemas.js';

package/src/schemas/schemas.ts

@@ -1,35 +1,16 @@
 import { z } from 'zod';
 
-import { type AbiDecoded } from '../abi/decoder.js';
-import { EventSelector } from '../abi/event_selector.js';
-import { FunctionSelector } from '../abi/function_selector.js';
-import { NoteSelector } from '../abi/note_selector.js';
-import { AztecAddress } from '../aztec-address/index.js';
 import { Buffer32 } from '../buffer/buffer32.js';
 import { EthAddress } from '../eth-address/index.js';
 import { Fq, Fr } from '../fields/fields.js';
 import { Point } from '../fields/point.js';
 import { isHex, withoutHexPrefix } from '../string/index.js';
-import { type ZodFor } from './types.js';
 import { bufferSchema, hexSchema } from './utils.js';
 
-/** Validation schemas for common types. Every schema must match its toJSON. */
 export const schemas = {
   /** Accepts a hex string. */
   EthAddress: EthAddress.schema,
 
-  /** Accepts a hex string. */
-  AztecAddress: AztecAddress.schema,
-
-  /** Accepts a hex string. */
-  FunctionSelector: FunctionSelector.schema,
-
-  /** Accepts a hex string. */
-  NoteSelector: NoteSelector.schema,
-
-  /** Accepts a hex string. */
-  EventSelector: EventSelector.schema,
-
   /** Accepts a hex string. */
   Fr: Fr.schema,
 
@@ -79,10 +60,5 @@ export const schemas = {
   HexString: hexSchema,
 };
 
-export const AbiDecodedSchema: ZodFor<AbiDecoded> = z.union([
-  schemas.BigInt,
-  z.boolean(),
-  schemas.AztecAddress,
-  z.array(z.lazy(() => AbiDecodedSchema)),
-  z.record(z.lazy(() => AbiDecodedSchema)),
-]);
+// These are needed to avoid errors such as: "The inferred type of 'YourClassSchema' cannot be named without a reference to..."
+export { EthAddress, Point, Fr, Fq };

package/src/schemas/types.ts

@@ -1,3 +1,3 @@
-import { type ZodType } from 'zod';
+import type { ZodType } from 'zod';
 
 export type ZodFor<T> = ZodType<T, any, any>;

package/src/schemas/utils.ts

@@ -14,7 +14,7 @@ import {
 
 import { pick } from '../collection/object.js';
 import { isHex, withoutHexPrefix } from '../string/index.js';
-import { type ZodFor } from './types.js';
+import type { ZodFor } from './types.js';
 
 export const hexSchema = z.string().refine(isHex, 'Not a valid hex string').transform(withoutHexPrefix);
 

package/src/serialize/buffer_reader.ts

@@ -1,4 +1,4 @@
-import { type Tuple } from './types.js';
+import type { Tuple } from './types.js';
 
 /**
  * The BufferReader class provides a utility for reading various data types from a buffer.

package/src/serialize/field_reader.ts

@@ -1,5 +1,5 @@
 import { Fq, type Fr } from '../fields/fields.js';
-import { type Tuple } from './types.js';
+import type { Tuple } from './types.js';
 
 /**
  * The FieldReader class provides a utility for reading various data types from a field array.

package/src/serialize/free_funcs.ts

@@ -1,5 +1,5 @@
 import { Fr } from '../fields/fields.js';
-import { type Tuple } from './types.js';
+import type { Tuple } from './types.js';
 
 /**
  * Convert a boolean value to its corresponding byte representation in a Buffer of size 1.

package/src/testing/snapshot_serializer.ts

@@ -1,4 +1,4 @@
-import { type NewPlugin } from 'pretty-format';
+import type { NewPlugin } from 'pretty-format';
 import { inspect } from 'util';
 
 function makeSerializerForCustomInspect(prefix: string): NewPlugin {

package/src/transport/browser/message_port_socket.ts

@@ -1,4 +1,4 @@
-import { type Socket } from '../interface/socket.js';
+import type { Socket } from '../interface/socket.js';
 
 /**
  * An implementation of a TransportSocket using MessagePorts.

package/src/transport/browser/shared_worker_connector.ts

@@ -1,4 +1,4 @@
-import { type Connector } from '../interface/connector.js';
+import type { Connector } from '../interface/connector.js';
 import { MessagePortSocket } from './message_port_socket.js';
 
 /**

package/src/transport/browser/shared_worker_listener.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'events';
 
-import { type Listener } from '../interface/listener.js';
+import type { Listener } from '../interface/listener.js';
 import { MessagePortSocket } from './message_port_socket.js';
 
 /**

package/src/transport/browser/worker_connector.ts

@@ -1,4 +1,4 @@
-import { type Connector } from '../interface/connector.js';
+import type { Connector } from '../interface/connector.js';
 import { MessagePortSocket } from './message_port_socket.js';
 
 /**

package/src/transport/browser/worker_listener.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'events';
 
-import { type Listener } from '../interface/listener.js';
+import type { Listener } from '../interface/listener.js';
 import { MessagePortSocket } from './message_port_socket.js';
 
 /**

package/src/transport/dispatch/create_dispatch_proxy.ts

@@ -1,8 +1,8 @@
 import { EventEmitter } from 'events';
 
 import { type TransferDescriptor, isTransferDescriptor } from '../interface/transferable.js';
-import { type TransportClient } from '../transport_client.js';
-import { type DispatchMsg } from './create_dispatch_fn.js';
+import type { TransportClient } from '../transport_client.js';
+import type { DispatchMsg } from './create_dispatch_fn.js';
 
 /**
  * FilterOutAttributes type filters out all non-method properties of an object, leaving only the attributes

package/src/transport/interface/connector.ts

@@ -1,4 +1,4 @@
-import { type Socket } from './socket.js';
+import type { Socket } from './socket.js';
 
 /**
  * Opens a socket with corresponding TransportListener.

package/src/transport/interface/listener.ts

@@ -1,6 +1,6 @@
 import type EventEmitter from 'events';
 
-import { type Socket } from './socket.js';
+import type { Socket } from './socket.js';
 
 /**
  * Once opened, an implementation of a TransportListener will emit `new_socket` events as new clients connect.

package/src/transport/node/node_connector.ts

@@ -1,6 +1,6 @@
-import { type Worker } from 'worker_threads';
+import type { Worker } from 'worker_threads';
 
-import { type Connector } from '../interface/connector.js';
+import type { Connector } from '../interface/connector.js';
 import { NodeConnectorSocket } from './node_connector_socket.js';
 
 /**

package/src/transport/node/node_connector_socket.ts

@@ -1,6 +1,6 @@
-import { type TransferListItem, type Worker } from 'worker_threads';
+import type { TransferListItem, Worker } from 'worker_threads';
 
-import { type Socket } from '../interface/socket.js';
+import type { Socket } from '../interface/socket.js';
 
 /**
  * NodeConnectorSocket is a wrapper class that implements the Socket interface for messaging between

package/src/transport/node/node_listener.ts

@@ -1,7 +1,7 @@
 import EventEmitter from 'events';
 import { parentPort } from 'worker_threads';
 
-import { type Listener } from '../interface/listener.js';
+import type { Listener } from '../interface/listener.js';
 import { NodeListenerSocket } from './node_listener_socket.js';
 
 /**

package/src/transport/node/node_listener_socket.ts

@@ -1,6 +1,6 @@
-import { type MessagePort, type TransferListItem } from 'worker_threads';
+import type { MessagePort, TransferListItem } from 'worker_threads';
 
-import { type Socket } from '../interface/socket.js';
+import type { Socket } from '../interface/socket.js';
 
 /**
  * An implementation of a TransportSocket using MessagePorts.

package/src/transport/transport_client.ts

@@ -3,8 +3,8 @@ import { format } from 'util';
 
 import { createLogger } from '../log/index.js';
 import { type EventMessage, type ResponseMessage, isEventMessage } from './dispatch/messages.js';
-import { type Connector } from './interface/connector.js';
-import { type Socket } from './interface/socket.js';
+import type { Connector } from './interface/connector.js';
+import type { Socket } from './interface/socket.js';
 
 const log = createLogger('foundation:transport_client');
 

package/src/transport/transport_server.ts

@@ -1,6 +1,6 @@
-import { type RequestMessage, type ResponseMessage } from './dispatch/messages.js';
-import { type Listener } from './interface/listener.js';
-import { type Socket } from './interface/socket.js';
+import type { RequestMessage, ResponseMessage } from './dispatch/messages.js';
+import type { Listener } from './interface/listener.js';
+import type { Socket } from './interface/socket.js';
 import { isTransferDescriptor } from './interface/transferable.js';
 
 /**

package/src/trees/hasher.ts

@@ -0,0 +1,39 @@
+/**
+ * Defines hasher interface used by Merkle trees.
+ */
+export interface Hasher {
+  /**
+   * Hash two arrays.
+   * @param lhs - The first array.
+   * @param rhs - The second array.
+   * @returns The new 32-byte hash.
+   */
+  hash(lhs: Uint8Array, rhs: Uint8Array): Buffer;
+
+  /**
+   * Hashes an array of buffers.
+   * @param inputs - The array of buffers to hash.
+   * @returns The resulting 32-byte hash.
+   */
+  hashInputs(inputs: Buffer[]): Buffer;
+}
+
+/**
+ * Defines an async hasher interface used by Merkle trees.
+ */
+export interface AsyncHasher {
+  /**
+   * Hash two arrays.
+   * @param lhs - The first array.
+   * @param rhs - The second array.
+   * @returns The new 32-byte hash.
+   */
+  hash(lhs: Uint8Array, rhs: Uint8Array): Promise<Buffer>;
+
+  /**
+   * Hashes an array of buffers.
+   * @param inputs - The array of buffers to hash.
+   * @returns The resulting 32-byte hash.
+   */
+  hashInputs(inputs: Buffer[]): Promise<Buffer>;
+}

package/src/trees/index.ts

@@ -1,59 +1,10 @@
 export * from './unbalanced_merkle_tree.js';
 export * from './unbalanced_tree_store.js';
-
-/**
- * A leaf of an indexed merkle tree.
- */
-export interface IndexedTreeLeaf {
-  /**
-   * Returns key of the leaf. It's used for indexing.
-   */
-  getKey(): bigint;
-  /**
-   * Serializes the leaf into a buffer.
-   */
-  toBuffer(): Buffer;
-  /**
-   * Returns true if the leaf is empty.
-   */
-  isEmpty(): boolean;
-  /**
-   * Updates the leaf with the data of another leaf.
-   * @param another - The leaf to update to.
-   * @returns The updated leaf.
-   */
-  updateTo(another: IndexedTreeLeaf): IndexedTreeLeaf;
-}
-
-/**
- * Preimage of a merkle tree leaf.
- */
-export interface TreeLeafPreimage {
-  /**
-   * Returns key of the leaf corresponding to this preimage.
-   */
-  getKey(): bigint;
-  /**
-   * Returns the preimage as a leaf.
-   */
-  asLeaf(): IndexedTreeLeaf;
-  /**
-   * Serializes the preimage into a buffer.
-   */
-  toBuffer(): Buffer;
-  /**
-   * Serializes the preimage to an array of buffers for hashing.
-   */
-  toHashInputs(): Buffer[];
-}
-
-/**
- * Preimage of an indexed merkle tree leaf.
- */
-export interface IndexedTreeLeafPreimage extends TreeLeafPreimage {
-  getNextKey(): bigint;
-  /**
-   * Returns the index of the next leaf.
-   */
-  getNextIndex(): bigint;
-}
+export * from './merkle_tree_calculator.js';
+export * from './merkle_tree.js';
+export * from './indexed_merkle_tree_calculator.js';
+export * from './indexed_merkle_tree.js';
+export * from './sibling_path.js';
+export * from './membership_witness.js';
+export * from './hasher.js';
+export * from './indexed_tree_leaf.js';

package/src/trees/indexed_merkle_tree.ts

@@ -0,0 +1,36 @@
+import { Fr } from '../fields/index.js';
+import { assertLength } from '../serialize/index.js';
+import type { IndexedTreeLeafPreimage } from './indexed_tree_leaf.js';
+import { MembershipWitness } from './membership_witness.js';
+import { MerkleTree } from './merkle_tree.js';
+
+/** A simple immutable indexed merkle tree container. Use a IndexedMerkleTreeCalculator to create a new instance from a set of leaves. */
+export class IndexedMerkleTree<T extends IndexedTreeLeafPreimage, N extends number> extends MerkleTree {
+  constructor(height: N, nodes: Buffer[], public readonly leafPreimages: T[]) {
+    super(height, nodes);
+  }
+
+  public getLowLeaf(value: bigint): T {
+    let lowLeaf: T | undefined;
+    this.leafPreimages.forEach(leaf => {
+      if (leaf.getKey() < value && (leaf.getNextKey() > value || leaf.getNextKey() == BigInt(0))) {
+        lowLeaf = leaf;
+      }
+    });
+    if (!lowLeaf) {
+      throw new Error(`Couldn't find low leaf for ${value}`);
+    }
+
+    return lowLeaf;
+  }
+
+  public getMembershipWitness(leafIndexOrLeaf: number | Buffer): MembershipWitness<N> {
+    const index = Buffer.isBuffer(leafIndexOrLeaf) ? this.getIndex(leafIndexOrLeaf) : leafIndexOrLeaf;
+    const siblingPath = this.getSiblingPath(index);
+    return new MembershipWitness<N>(
+      this.height as N,
+      BigInt(index),
+      assertLength<Fr, N>(siblingPath.map(Fr.fromBuffer), this.height as N),
+    );
+  }
+}

package/src/trees/indexed_merkle_tree_calculator.ts

@@ -0,0 +1,94 @@
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { numToUInt32BE } from '@aztec/foundation/serialize';
+import type { IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
+
+import type { AsyncHasher } from './hasher.js';
+import { IndexedMerkleTree } from './indexed_merkle_tree.js';
+
+interface LeafPreimageFactory<T extends IndexedTreeLeafPreimage> {
+  fromBuffer(buffer: Buffer): T;
+}
+
+/**
+ * Indexed merkle tree calculator.
+ */
+export class IndexedMerkleTreeCalculator<T extends IndexedTreeLeafPreimage, N extends number> {
+  private constructor(
+    private height: N,
+    private zeroHashes: Buffer[],
+    private hasher: AsyncHasher,
+    private factory: LeafPreimageFactory<T>,
+  ) {}
+
+  static async create<T extends IndexedTreeLeafPreimage, N extends number>(
+    height: N,
+    hasher: AsyncHasher,
+    factory: LeafPreimageFactory<T>,
+    zeroLeaf = Buffer.alloc(32),
+  ) {
+    const zeroHashes = [zeroLeaf];
+    for (let i = 0; i < height; i++) {
+      zeroHashes.push(await hasher.hash(zeroHashes[i], zeroHashes[i]));
+    }
+    return new IndexedMerkleTreeCalculator(height, zeroHashes, hasher, factory);
+  }
+
+  async computeTree(values: Buffer[]): Promise<IndexedMerkleTree<T, N>> {
+    if (!values.find(v => toBigIntBE(v) == BigInt(0))) {
+      // If we have no zero value, add one to form the zero leaf
+      values = [Buffer.alloc(32), ...values];
+    }
+    const sorted = values
+      .map((v, i) => ({ value: v, index: i }))
+      .sort((a, b) => Number(toBigIntBE(b.value) - toBigIntBE(a.value)));
+    const indexedLeaves = sorted.map((item, i) => ({
+      leaf: this.factory.fromBuffer(
+        Buffer.concat([
+          item.value,
+          ...(i == 0
+            ? [Buffer.alloc(32), Buffer.alloc(32)]
+            : [sorted[i - 1].value, numToUInt32BE(sorted[i - 1].index, 32)]),
+        ]),
+      ),
+      index: item.index,
+    }));
+    const resortedIndexedLeaves = indexedLeaves.sort((a, b) => a.index - b.index).map(item => item.leaf);
+    let leaves = await Promise.all(resortedIndexedLeaves.map(l => this.hasher.hashInputs(l.toHashInputs())));
+
+    let result = leaves.slice();
+
+    for (let i = 0; i < this.height; ++i) {
+      const numLeaves = 2 ** (this.height - i);
+      const newLeaves: Buffer[] = [];
+      for (let j = 0; j < leaves.length / 2; ++j) {
+        const l = leaves[j * 2];
+        const r = leaves[j * 2 + 1] || this.zeroHashes[i];
+        newLeaves[j] = await this.hasher.hash(l, r);
+      }
+      result = result.concat(new Array(numLeaves - leaves.length).fill(this.zeroHashes[i]), newLeaves);
+      leaves = newLeaves;
+    }
+
+    return new IndexedMerkleTree(this.height, result, resortedIndexedLeaves);
+  }
+
+  async computeTreeRoot(leaves: Buffer[] = []): Promise<Buffer> {
+    if (leaves.length === 0) {
+      return this.zeroHashes[this.zeroHashes.length - 1];
+    }
+
+    leaves = leaves.slice();
+
+    for (let i = 0; i < this.height; ++i) {
+      let j = 0;
+      for (; j < leaves.length / 2; ++j) {
+        const l = leaves[j * 2];
+        const r = leaves[j * 2 + 1] || this.zeroHashes[i];
+        leaves[j] = await this.hasher.hash(l, r);
+      }
+      leaves = leaves.slice(0, j);
+    }
+
+    return leaves[0];
+  }
+}

package/src/trees/indexed_tree_leaf.ts

@@ -0,0 +1,56 @@
+/**
+ * A leaf of an indexed merkle tree.
+ */
+export interface IndexedTreeLeaf {
+  /**
+   * Returns key of the leaf. It's used for indexing.
+   */
+  getKey(): bigint;
+  /**
+   * Serializes the leaf into a buffer.
+   */
+  toBuffer(): Buffer;
+  /**
+   * Returns true if the leaf is empty.
+   */
+  isEmpty(): boolean;
+  /**
+   * Updates the leaf with the data of another leaf.
+   * @param another - The leaf to update to.
+   * @returns The updated leaf.
+   */
+  updateTo(another: IndexedTreeLeaf): IndexedTreeLeaf;
+}
+
+/**
+ * Preimage of a merkle tree leaf.
+ */
+export interface TreeLeafPreimage {
+  /**
+   * Returns key of the leaf corresponding to this preimage.
+   */
+  getKey(): bigint;
+  /**
+   * Returns the preimage as a leaf.
+   */
+  asLeaf(): IndexedTreeLeaf;
+  /**
+   * Serializes the preimage into a buffer.
+   */
+  toBuffer(): Buffer;
+  /**
+   * Serializes the preimage to an array of buffers for hashing.
+   */
+  toHashInputs(): Buffer[];
+}
+
+/**
+ * Preimage of an indexed merkle tree leaf.
+ */
+export interface IndexedTreeLeafPreimage extends TreeLeafPreimage {
+  getNextKey(): bigint;
+  /**
+   * Returns the index of the next leaf.
+   */
+  getNextIndex(): bigint;
+}