@aztec/foundation 0.0.1-commit.e588bc7e5 → 0.0.1-commit.e5a3663dd

package/src/curves/grumpkin/point.ts

@@ -125,9 +125,12 @@ export class Point {
   }
 
   /**
-   * Returns the contents of the point as an array of 2 fields.
-   * @returns The point as an array of 2 fields
+   * Returns the contents of the point as an array of 3 fields.
+   * @returns The point as an array of 3 fields
    */
+  // TODO(F-553): Once we take the breaking change and drop the custom Noir `Point` wrapper in
+  // `noir-projects/noir-protocol-circuits/crates/types/src/point.nr`, revert this to serialize as `[x, y]` (2 fields)
+  // and drop the `is_infinite` flag from `fromFields` / `toNoirStruct` below.
   toFields() {
     return [this.x, this.y, new Fr(this.isInfinite)];
   }

package/src/eth-address/index.ts

@@ -5,7 +5,6 @@ import { randomBytes } from '../crypto/random/index.js';
 import { Fr } from '../curves/bn254/index.js';
 import { hexSchemaFor } from '../schemas/utils.js';
 import { BufferReader, FieldReader } from '../serialize/index.js';
-import { TypeRegistry } from '../serialize/type_registry.js';
 import { bufferToHex } from '../string/index.js';
 
 /**
@@ -268,6 +267,3 @@ export class EthAddress {
     return addrA.equals(addrB);
   }
 }
-
-// For deserializing JSON.
-TypeRegistry.register('EthAddress', EthAddress);

package/src/json-rpc/client/fetch.ts

@@ -54,7 +54,7 @@ export async function defaultFetch(
   }
 
   if (!resp.ok) {
-    const errorMessage = `Error ${resp.status} from server ${host}: ${responseJson.error.message}`;
+    const errorMessage = `Error ${resp.status} from server ${host}: ${responseJson?.error?.message ?? JSON.stringify(responseJson)}`;
     if (noRetry || (resp.status >= 400 && resp.status < 500)) {
       throw new NoRetryError(errorMessage);
     } else {

package/src/json-rpc/client/undici.ts

@@ -44,18 +44,20 @@ export function makeUndiciFetch(client = new Agent()): JsonRpcFetch {
     let responseJson: any;
     const responseOk = resp.statusCode >= 200 && resp.statusCode <= 299;
     const contentEncoding = resp.headers['content-encoding'];
+    let responseText: string;
     try {
       if (contentEncoding === 'gzip') {
         const jsonBuffer = await gunzip(await resp.body.arrayBuffer());
-        responseJson = JSON.parse(jsonBuffer.toString('utf-8'));
+        responseText = jsonBuffer.toString('utf-8');
       } else {
-        responseJson = await resp.body.json();
+        responseText = await resp.body.text();
       }
+      responseJson = JSON.parse(responseText);
     } catch {
       if (!responseOk) {
         throw new Error('HTTP ' + resp.statusCode);
       }
-      throw new Error(`Failed to parse body as JSON. encoding: ${contentEncoding}, body: ${await resp.body.text()}`);
+      throw new Error(`Failed to parse body as JSON. encoding: ${contentEncoding}, body: ${responseText!}`);
     }
 
     if (!responseOk) {

package/src/log/pino-logger.ts

@@ -377,5 +377,20 @@ export type Logger = { [K in LogLevel]: LogFn } & { /** Error log function */ er
  * @returns A string with both the log message and the error message.
  */
 function formatErr(msg: string, err?: unknown): string {
-  return err ? `${msg}: ${inspect(err)}` : msg;
+  if (!err) {
+    return msg;
+  }
+
+  try {
+    return `${msg}: ${inspect(err)}`;
+  } catch {
+    // inspect can crash on error objects with broken property descriptors
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-base-to-string
+      return `${msg}: ${err instanceof Error ? `${err.name}: ${err.message}` : String(err)}`;
+    } catch {
+      // if even String(err) fails, return the original message with a note about the error
+      return `${msg}: [unserializable error]`;
+    }
+  }
 }

package/src/queue/batch_queue.ts

@@ -105,6 +105,7 @@ export class BatchQueue<T, K extends string | number> {
       return Promise.resolve();
     }
 
+    this.flushCurrentBatch();
     this.container.end();
     return runningPromise;
   }

package/src/string/index.ts

@@ -58,7 +58,7 @@ export function urlJoin(...args: string[]): string {
       end--;
     }
 
-    if (start < end) {
+    if (start <= end) {
       processed.push(arg.slice(start, end + 1));
     }
   }

package/src/trees/balanced_merkle_tree_root.ts

@@ -1,10 +1,7 @@
-import { poseidonMerkleHash, shaMerkleHash } from './hasher.js';
+import { shaMerkleHash } from './hasher.js';
 
 export const computeBalancedShaRoot = (leaves: Buffer[]) => computeBalancedMerkleTreeRoot(leaves);
 
-export const computeBalancedPoseidonRoot = async (leaves: Buffer[]) =>
-  await computeBalancedMerkleTreeRootAsync(leaves, poseidonMerkleHash);
-
 /**
  * Computes the Merkle root with the provided leaves **synchronously**.
  * This method uses a synchronous hash function (defaults to `sha256Trunc`).
@@ -36,7 +33,7 @@ export function computeBalancedMerkleTreeRoot(leaves: Buffer[], hasher = shaMerk
  */
 export async function computeBalancedMerkleTreeRootAsync(
   leaves: Buffer[],
-  hasher = poseidonMerkleHash,
+  hasher: (left: Buffer, right: Buffer) => Promise<Buffer<ArrayBuffer>>,
 ): Promise<Buffer> {
   const height = getTreeHeight(leaves);
   let nodes = leaves.slice();

package/src/trees/hasher.ts

@@ -1,4 +1,4 @@
-import { poseidon2Hash } from '../crypto/poseidon/index.js';
+import { poseidon2HashWithSeparator } from '../crypto/poseidon/index.js';
 import { sha256Trunc } from '../crypto/sha256/index.js';
 
 /**
@@ -44,5 +44,8 @@ export interface AsyncHasher {
 export const shaMerkleHash: Hasher['hash'] = (left: Buffer, right: Buffer) =>
   sha256Trunc(Buffer.concat([left, right])) as Buffer<ArrayBuffer>;
 
-export const poseidonMerkleHash: AsyncHasher['hash'] = async (left: Buffer, right: Buffer) =>
-  (await poseidon2Hash([left, right])).toBuffer() as Buffer<ArrayBuffer>;
+/** Creates a poseidon2 merkle hasher with the given domain separator. */
+export const makePoseidonMerkleHash =
+  (separator: number): AsyncHasher['hash'] =>
+  async (left: Buffer, right: Buffer) =>
+    (await poseidon2HashWithSeparator([left, right], separator)).toBuffer() as Buffer<ArrayBuffer>;

package/src/trees/merkle_tree_calculator.ts

@@ -1,8 +1,7 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
-
-import type { AsyncHasher } from './hasher.js';
 import { MerkleTree } from './merkle_tree.js';
 
+type MerkleHashFn = (left: Buffer, right: Buffer) => Promise<Buffer<ArrayBuffer>>;
+
 /**
  * Merkle tree calculator.
  */
@@ -10,17 +9,12 @@ export class MerkleTreeCalculator {
   private constructor(
     private height: number,
     private zeroHashes: Buffer[],
-    private hasher: AsyncHasher['hash'],
+    private hasher: MerkleHashFn,
   ) {
     this.hasher = hasher;
   }
 
-  static async create(
-    height: number,
-    zeroLeaf: Buffer = Buffer.alloc(32),
-    hasher = async (left: Buffer, right: Buffer) =>
-      (await poseidon2Hash([left, right])).toBuffer() as Buffer<ArrayBuffer>,
-  ) {
+  static async create(height: number, zeroLeaf: Buffer = Buffer.alloc(32), hasher: MerkleHashFn) {
     const zeroHashes = [zeroLeaf];
     for (let i = 0; i < height; i++) {
       zeroHashes.push((await hasher(zeroHashes[i], zeroHashes[i])) as Buffer<ArrayBuffer>);

package/src/trees/sibling_path.ts

@@ -1,5 +1,4 @@
 import { makeTuple } from '../array/array.js';
-import { poseidon2Hash } from '../crypto/poseidon/index.js';
 import { Fr } from '../curves/bn254/index.js';
 import { schemas } from '../schemas/index.js';
 import {
@@ -172,7 +171,7 @@ export async function computeRootFromSiblingPath(
   leaf: Buffer,
   siblingPath: Buffer[],
   index: number,
-  hasher = async (left: Buffer, right: Buffer) => (await poseidon2Hash([left, right])).toBuffer(),
+  hasher: (left: Buffer, right: Buffer) => Promise<Buffer>,
 ) {
   let result = leaf;
   for (const sibling of siblingPath) {

package/src/trees/unbalanced_merkle_tree_root.ts

@@ -1,12 +1,9 @@
 import { computeBalancedMerkleTreeRoot, computeBalancedMerkleTreeRootAsync } from './balanced_merkle_tree_root.js';
-import { poseidonMerkleHash, shaMerkleHash } from './hasher.js';
+import { shaMerkleHash } from './hasher.js';
 import { UnbalancedMerkleTreeCalculator } from './unbalanced_merkle_tree_calculator.js';
 
 export const computeUnbalancedShaRoot = (leaves: Buffer[]) => computeUnbalancedMerkleTreeRoot(leaves, shaMerkleHash);
 
-export const computeUnbalancedPoseidonRoot = async (leaves: Buffer[]) =>
-  await computeUnbalancedMerkleTreeRootAsync(leaves, poseidonMerkleHash);
-
 export const computeWonkyShaRoot = (leaves: Buffer[]) => computeWonkyMerkleTreeRoot(leaves);
 
 /**
@@ -67,7 +64,7 @@ export function computeUnbalancedMerkleTreeRoot(
 
 export async function computeUnbalancedMerkleTreeRootAsync(
   leaves: Buffer[],
-  hasher = poseidonMerkleHash,
+  hasher: (left: Uint8Array, right: Uint8Array) => Promise<Buffer<ArrayBuffer>>,
   emptyRoot = Buffer.alloc(32),
 ): Promise<Buffer> {
   if (!leaves.length) {

package/src/types/index.ts

@@ -34,6 +34,20 @@ export type Prettify<T> = {
   [K in keyof T]: T[K];
 } & {};
 
+/** Returns a type with fields conditionally required based on a flag */
+export type IfFlag<
+  OptsSchema,
+  Opts extends OptsSchema,
+  Key extends keyof OptsSchema,
+  Field extends object,
+> = Opts extends { [K in Key]: true }
+  ? Field
+  : Opts extends { [K in Key]: false }
+    ? {}
+    : Opts extends { [K in Key]?: boolean }
+      ? Partial<Field>
+      : {};
+
 /**
  * Type-safe Event Emitter type
  * @example