@aztec/foundation 0.72.1 → 0.73.0

package/src/crypto/sync/poseidon/index.ts

@@ -0,0 +1,76 @@
+import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+
+import { Fr } from '../../../fields/fields.js';
+import { type Fieldable, serializeToFields } from '../../../serialize/serialize.js';
+
+/**
+ * Create a poseidon hash (field) from an array of input fields.
+ * @param input - The input fields to hash.
+ * @returns The poseidon hash.
+ */
+export function poseidon2Hash(input: Fieldable[]): Fr {
+  const inputFields = serializeToFields(input);
+  const hash = BarretenbergSync.getSingleton().poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+  );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+
+/**
+ * Create a poseidon hash (field) from an array of input fields and a domain separator.
+ * @param input - The input fields to hash.
+ * @param separator - The domain separator.
+ * @returns The poseidon hash.
+ */
+export function poseidon2HashWithSeparator(input: Fieldable[], separator: number): Fr {
+  const inputFields = serializeToFields(input);
+  inputFields.unshift(new Fr(separator));
+
+  const hash = BarretenbergSync.getSingleton().poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+  );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+
+export function poseidon2HashAccumulate(input: Fieldable[]): Fr {
+  const inputFields = serializeToFields(input);
+  const result = BarretenbergSync.getSingleton().poseidon2HashAccumulate(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())),
+  );
+  return Fr.fromBuffer(Buffer.from(result.toBuffer()));
+}
+
+/**
+ * Runs a Poseidon2 permutation.
+ * @param input the input state. Expected to be of size 4.
+ * @returns the output state, size 4.
+ */
+export function poseidon2Permutation(input: Fieldable[]): Fr[] {
+  const inputFields = serializeToFields(input);
+  // We'd like this assertion but it's not possible to use it in the browser.
+  // assert(input.length === 4, 'Input state must be of size 4');
+  const res = BarretenbergSync.getSingleton().poseidon2Permutation(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())),
+  );
+  // We'd like this assertion but it's not possible to use it in the browser.
+  // assert(res.length === 4, 'Output state must be of size 4');
+  return res.map(o => Fr.fromBuffer(Buffer.from(o.toBuffer())));
+}
+
+export function poseidon2HashBytes(input: Buffer): Fr {
+  const inputFields = [];
+  for (let i = 0; i < input.length; i += 31) {
+    const fieldBytes = Buffer.alloc(32, 0);
+    input.slice(i, i + 31).copy(fieldBytes);
+
+    // Noir builds the bytes as little-endian, so we need to reverse them.
+    fieldBytes.reverse();
+    inputFields.push(Fr.fromBuffer(fieldBytes));
+  }
+
+  const res = BarretenbergSync.getSingleton().poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+  );
+
+  return Fr.fromBuffer(Buffer.from(res.toBuffer()));
+}

package/src/fields/fields.ts

@@ -1,4 +1,4 @@
-import { BarretenbergLazy } from '@aztec/bb.js';
+import { BarretenbergSync } from '@aztec/bb.js';
 
 import { inspect } from 'util';
 
@@ -319,8 +319,8 @@ export class Fr extends BaseField {
    * @returns A square root of the field element (null if it does not exist).
    */
   async sqrt(): Promise<Fr | null> {
-    const wasm = (await BarretenbergLazy.getSingleton()).getWasm();
-    const [buf] = await wasm.callWasmExport('bn254_fr_sqrt', [this.toBuffer()], [Fr.SIZE_IN_BYTES + 1]);
+    const wasm = (await BarretenbergSync.initSingleton()).getWasm();
+    const [buf] = wasm.callWasmExport('bn254_fr_sqrt', [this.toBuffer()], [Fr.SIZE_IN_BYTES + 1]);
     const isSqrt = buf[0] === 1;
     if (!isSqrt) {
       // Field element is not a quadratic residue mod p so it has no square root.

package/src/iterable/toArray.ts

@@ -1,4 +1,6 @@
-export async function toArray<T>(iterator: AsyncIterableIterator<T> | IterableIterator<T>): Promise<T[]> {
+export async function toArray<T>(
+  iterator: Iterable<T> | AsyncIterableIterator<T> | AsyncIterable<T> | IterableIterator<T>,
+): Promise<T[]> {
   const arr = [];
   for await (const i of iterator) {
     arr.push(i);

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

@@ -40,7 +40,7 @@ export function createSafeJsonRpcClient<T extends object>(
     if ([null, undefined, 'null', 'undefined'].includes(res.result)) {
       return;
     }
-    return (schema as ApiSchema)[methodName].returnType().parse(res.result);
+    return (schema as ApiSchema)[methodName].returnType().parseAsync(res.result);
   };
 
   const proxy: any = {};

package/src/json-rpc/convert.ts

@@ -8,8 +8,8 @@ import { type ZodFor } from '../schemas/types.js';
  * @param schema - Zod schema.
  * @returns Result of parsing json with schema.
  */
-export function jsonParseWithSchema<T>(json: string, schema: ZodFor<T>): T {
-  return schema.parse(JSON.parse(json));
+export function jsonParseWithSchema<T>(json: string, schema: ZodFor<T>): Promise<T> {
+  return schema.parseAsync(JSON.parse(json));
 }
 
 /**

package/src/json-rpc/server/safe_json_rpc_server.ts

@@ -151,6 +151,7 @@ export class SafeJsonRpcServer {
       throw new Error('Server is already listening');
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
     this.httpServer = http.createServer(this.getApp(prefix).callback());
     this.httpServer.listen(port);
   }
@@ -217,7 +218,7 @@ export class SafeJsonProxy<T extends object = any> implements Proxy {
     assert(schemaHasMethod(this.schema, methodName), `Method ${methodName} not found in schema`);
     const method = this.handler[methodName as keyof T];
     assert(typeof method === 'function', `Method ${methodName} is not a function`);
-    const args = parseWithOptionals(jsonParams, this.schema[methodName].parameters());
+    const args = await parseWithOptionals(jsonParams, this.schema[methodName].parameters());
     const ret = await method.apply(this.handler, args);
     this.log.debug(format('response', methodName, ret));
     return ret;
@@ -355,6 +356,7 @@ export async function startHttpRpcServer(
   const statusRouter = createStatusRouter(rpcServer.isHealthy.bind(rpcServer), options.apiPrefix);
   app.use(statusRouter.routes()).use(statusRouter.allowedMethods());
 
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
   const httpServer = http.createServer(app.callback());
   if (options.timeoutMs) {
     httpServer.timeout = options.timeoutMs;

package/src/message/index.ts

@@ -0,0 +1,43 @@
+export type MessageHeaderInit = {
+  /** The message ID. Optional, if not set defaults to 0 */
+  messageId?: number;
+  /** Identifies the original request. Optional */
+  requestId?: number;
+};
+
+export class MessageHeader {
+  /** An number to identify this message */
+  public readonly messageId: number;
+  /** If this message is a response to a request, the messageId of the request */
+  public readonly requestId: number;
+
+  constructor({ messageId, requestId }: MessageHeaderInit) {
+    this.messageId = messageId ?? 0;
+    this.requestId = requestId ?? 0;
+  }
+
+  static fromMessagePack(data: object): MessageHeader {
+    return new MessageHeader(data as MessageHeaderInit);
+  }
+}
+
+interface TypedMessageLike {
+  msgType: number;
+  header: {
+    messageId?: number;
+    requestId?: number;
+  };
+  value: any;
+}
+
+export class TypedMessage<T, B> {
+  public constructor(public readonly msgType: T, public readonly header: MessageHeader, public readonly value: B) {}
+
+  static fromMessagePack<T, B>(data: TypedMessageLike): TypedMessage<T, B> {
+    return new TypedMessage<T, B>(data['msgType'] as T, MessageHeader.fromMessagePack(data['header']), data['value']);
+  }
+
+  static isTypedMessageLike(obj: any): obj is TypedMessageLike {
+    return typeof obj === 'object' && obj !== null && 'msgType' in obj && 'header' in obj && 'value' in obj;
+  }
+}

package/src/mutex/index.ts

@@ -72,12 +72,13 @@ export class Mutex {
    *
    * @param id - The id of the current lock instance.
    */
-  private async ping(id: number) {
+  private ping(id: number) {
     if (id !== this.id) {
       return;
     }
-
-    await this.db.extendLock(this.name, this.timeout);
-    this.pingTimeout = setTimeout(() => this.ping(id), this.pingInterval);
+    void (async () => {
+      await this.db.extendLock(this.name, this.timeout);
+      this.pingTimeout = setTimeout(() => this.ping(id), this.pingInterval);
+    })();
   }
 }

package/src/promise/running-promise.ts

@@ -17,6 +17,7 @@ export class RunningPromise {
     private fn: () => void | Promise<void>,
     private logger = createLogger('running-promise'),
     private pollingIntervalMS = 10000,
+    private ignoredErrors: (new (...args: any[]) => Error)[] = [],
   ) {}
 
   /**
@@ -35,7 +36,9 @@ export class RunningPromise {
         try {
           await this.fn();
         } catch (err) {
-          this.logger.error('Error in running promise', err);
+          if (err instanceof Error && !this.ignoredErrors.some(ErrorType => err instanceof ErrorType)) {
+            this.logger.error('Error in running promise', err);
+          }
         }
 
         // If an immediate run had been requested *before* the function started running, resolve the request.

package/src/schemas/parse.ts

@@ -11,12 +11,12 @@ export function parse<T extends [] | [z.ZodTypeAny, ...z.ZodTypeAny[]]>(args: IA
  * Parses the given arguments against a tuple, allowing empty for optional items.
  * @dev Zod doesn't like tuplues with optional items. See https://github.com/colinhacks/zod/discussions/949.
  */
-export function parseWithOptionals<T extends z.AnyZodTuple>(args: any[], schema: T): T['_output'] {
+export function parseWithOptionals<T extends z.AnyZodTuple>(args: any[], schema: T): Promise<T['_output']> {
   const missingCount = schema.items.length - args.length;
   const optionalCount = schema.items.filter(isOptional).length;
   const toParse =
     missingCount > 0 && missingCount <= optionalCount ? args.concat(times(missingCount, () => undefined)) : args;
-  return schema.parse(toParse);
+  return schema.parseAsync(toParse);
 }
 
 function isOptional(schema: z.ZodTypeAny) {

package/src/serialize/field_reader.ts

@@ -34,6 +34,27 @@ export class FieldReader {
     return new FieldReader(fields);
   }
 
+  /**
+   * Skips the next n fields.
+   *
+   * @param n - The number of fields to skip.
+   */
+  public skip(n: number) {
+    if (this.index + n > this.length) {
+      throw new Error('Not enough fields to be consumed.');
+    }
+    this.index += n;
+  }
+
+  /**
+   * Returns the current cursor position.
+   *
+   * @returns The current cursor position.
+   */
+  public get cursor() {
+    return this.index;
+  }
+
   /**
    * Reads a single field from the array.
    *
@@ -46,6 +67,18 @@ export class FieldReader {
     return this.fields[this.index++];
   }
 
+  /**
+   * Peeks at the next field without advancing the cursor.
+   *
+   * @returns A field.
+   */
+  public peekField(): Fr {
+    if (this.index === this.length) {
+      throw new Error('Not enough fields to be consumed.');
+    }
+    return this.fields[this.index];
+  }
+
   /**
    * Reads a Fq from the array.
    *
@@ -146,6 +179,6 @@ export class FieldReader {
    * @returns A bool.
    */
   public isFinished(): boolean {
-    return this.index === this.length;
+    return this.index >= this.length;
   }
 }

package/src/worker/browser/start_web_module.ts

@@ -18,6 +18,7 @@ export function startWebModule(module: WasmModule) {
   };
   const transportListener = new WorkerListener(self);
   const transportServer = new TransportServer<DispatchMsg>(transportListener, dispatch);
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
   module.addLogger((...args: any[]) => transportServer.broadcast({ fn: 'emit', args: ['log', ...args] }));
   transportServer.start();
 }

package/src/worker/browser/web_worker.ts

@@ -15,6 +15,7 @@ export async function createWebWorker(url: string, initialMem?: number, maxMem?:
   const transportClient = new TransportClient<DispatchMsg>(transportConnect);
   await transportClient.open();
   const remoteModule = createDispatchProxy(WasmModule, transportClient) as WasmWorker;
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
   remoteModule.destroyWorker = async () => {
     await transportClient.request({ fn: '__destroyWorker__', args: [] });
     transportClient.close();

package/src/worker/node/node_worker.ts

@@ -13,6 +13,7 @@ export async function createNodeWorker(filepath: string, initialMem?: number, ma
   const transportClient = new TransportClient<DispatchMsg>(transportConnect);
   await transportClient.open();
   const remoteModule = createDispatchProxy(WasmModule, transportClient) as WasmWorker;
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
   remoteModule.destroyWorker = async () => {
     await transportClient.request({ fn: '__destroyWorker__', args: [] });
     transportClient.close();

package/src/worker/node/start_node_module.ts

@@ -24,6 +24,7 @@ export function startNodeModule(module: WasmModule) {
   };
   const transportListener = new NodeListener();
   const transportServer = new TransportServer<DispatchMsg>(transportListener, dispatch);
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
   module.addLogger((...args: any[]) => transportServer.broadcast({ fn: 'emit', args: ['log', ...args] }));
   transportServer.start();
 }