@aztec/foundation 0.72.1 → 0.74.0

package/src/config/env_var.ts

@@ -16,6 +16,8 @@ export type EnvVar =
   | 'BB_SKIP_CLEANUP'
   | 'BB_WORKING_DIRECTORY'
   | 'BOOTSTRAP_NODES'
+  | 'BLOB_SINK_PORT'
+  | 'BLOB_SINK_URL'
   | 'BOT_DA_GAS_LIMIT'
   | 'BOT_FEE_PAYMENT_METHOD'
   | 'BOT_FLUSH_SETUP_TRANSACTIONS'
@@ -51,7 +53,9 @@ export type EnvVar =
   | 'GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS'
   | 'INBOX_CONTRACT_ADDRESS'
   | 'L1_CHAIN_ID'
-  | 'L1_CONSENSUS_CLIENT_URL'
+  | 'L1_CONSENSUS_HOST_URL'
+  | 'L1_CONSENSUS_HOST_API_KEY'
+  | 'L1_CONSENSUS_HOST_API_KEY_HEADER'
   | 'L1_PRIVATE_KEY'
   | 'L2_QUEUE_SIZE'
   | 'LOG_ELAPSED_TIME'
@@ -102,7 +106,6 @@ export type EnvVar =
   | 'P2P_UDP_LISTEN_ADDR'
   | 'P2P_ARCHIVED_TX_LIMIT'
   | 'PEER_ID_PRIVATE_KEY'
-  | 'PROVER_BLOB_SINK_URL'
   | 'PROOF_VERIFIER_L1_START_BLOCK'
   | 'PROOF_VERIFIER_POLL_INTERVAL_MS'
   | 'PROVER_AGENT_ENABLED'
@@ -142,7 +145,6 @@ export type EnvVar =
   | 'REGISTRY_CONTRACT_ADDRESS'
   | 'ROLLUP_CONTRACT_ADDRESS'
   | 'SEQ_ALLOWED_SETUP_FN'
-  | 'SEQ_BLOB_SINK_URL'
   | 'SEQ_MAX_BLOCK_SIZE_IN_BYTES'
   | 'SEQ_MAX_TX_PER_BLOCK'
   | 'SEQ_MIN_TX_PER_BLOCK'
@@ -205,4 +207,5 @@ export type EnvVar =
   | 'FAUCET_L1_ASSETS'
   | 'K8S_POD_NAME'
   | 'K8S_POD_UID'
-  | 'K8S_NAMESPACE_NAME';
+  | 'K8S_NAMESPACE_NAME'
+  | 'CUSTOM_FORWARDER_CONTRACT_ADDRESS';

package/src/config/index.ts

@@ -9,6 +9,7 @@ export interface ConfigMapping {
   printDefault?: (val: any) => string;
   description: string;
   isBoolean?: boolean;
+  nested?: Record<string, ConfigMapping>;
 }
 
 export function isBooleanConfigValue<T>(obj: T, key: keyof T): boolean {
@@ -21,18 +22,15 @@ export function getConfigFromMappings<T>(configMappings: ConfigMappingsType<T>):
   const config = {} as T;
 
   for (const key in configMappings) {
-    if (configMappings[key]) {
-      const { env, parseEnv, defaultValue: def } = configMappings[key];
-      // Special case for L1 contract addresses which is an object of config values
-      if (key === 'l1Contracts' && def) {
-        (config as any)[key] = getConfigFromMappings(def);
-      } else {
-        const val = env ? process.env[env] : undefined;
-        if (val !== undefined) {
-          (config as any)[key] = parseEnv ? parseEnv(val) : val;
-        } else if (def !== undefined) {
-          (config as any)[key] = def;
-        }
+    const { env, parseEnv, defaultValue: def, nested } = configMappings[key];
+    if (nested) {
+      (config as any)[key] = getConfigFromMappings(nested);
+    } else {
+      const val = env ? process.env[env] : undefined;
+      if (val !== undefined) {
+        (config as any)[key] = parseEnv ? parseEnv(val) : val;
+      } else if (def !== undefined) {
+        (config as any)[key] = def;
       }
     }
   }

package/src/crypto/index.ts

@@ -1,5 +1,3 @@
-import { BarretenbergSync } from '@aztec/bb.js';
-
 export * from './keccak/index.js';
 export * from './random/index.js';
 export * from './sha256/index.js';
@@ -8,13 +6,3 @@ export * from './pedersen/index.js';
 export * from './poseidon/index.js';
 export * from './secp256k1-signer/index.js';
 export * from './keys/index.js';
-
-/**
- * Init the bb singleton. This constructs (if not already) the barretenberg sync api within bb.js itself.
- * It takes about 100-200ms to initialize. It may not seem like much, but when in conjunction with many other things
- * initializing, developers may want to pick precisely when to incur this cost.
- * If in a test environment, we'll just do it on module load.
- */
-export async function init() {
-  await BarretenbergSync.initSingleton();
-}

package/src/crypto/keys/index.ts

@@ -2,8 +2,9 @@ import { BarretenbergSync, RawBuffer } from '@aztec/bb.js';
 
 import { Fr } from '../../fields/fields.js';
 
-export function vkAsFieldsMegaHonk(input: Buffer): Fr[] {
-  return BarretenbergSync.getSingleton()
-    .acirVkAsFieldsMegaHonk(new RawBuffer(input))
-    .map(bbFr => Fr.fromBuffer(Buffer.from(bbFr.toBuffer()))); // TODO(#4189): remove this conversion
+export async function vkAsFieldsMegaHonk(input: Buffer): Promise<Fr[]> {
+  const api = await BarretenbergSync.initSingleton();
+  const result = api.acirVkAsFieldsMegaHonk(new RawBuffer(input));
+
+  return result.map(bbFr => Fr.fromBuffer(Buffer.from(bbFr.toBuffer()))); // TODO(#4189): remove this conversion
 }

package/src/crypto/pedersen/pedersen.wasm.ts

@@ -7,12 +7,13 @@ import { type Fieldable, serializeToFields } from '../../serialize/serialize.js'
  * Create a pedersen commitment (point) from an array of input fields.
  * Left pads any inputs less than 32 bytes.
  */
-export function pedersenCommit(input: Buffer[], offset = 0) {
+export async function pedersenCommit(input: Buffer[], offset = 0) {
   if (!input.every(i => i.length <= 32)) {
     throw new Error('All Pedersen Commit input buffers must be <= 32 bytes.');
   }
   input = input.map(i => (i.length < 32 ? Buffer.concat([Buffer.alloc(32 - i.length, 0), i]) : i));
-  const point = BarretenbergSync.getSingleton().pedersenCommit(
+  const api = await BarretenbergSync.initSingleton();
+  const point = api.pedersenCommit(
     input.map(i => new FrBarretenberg(i)),
     offset,
   );
@@ -27,23 +28,21 @@ export function pedersenCommit(input: Buffer[], offset = 0) {
  * @param index - The separator index to use for the hash.
  * @returns The pedersen hash.
  */
-export function pedersenHash(input: Fieldable[], index = 0): Fr {
+export async function pedersenHash(input: Fieldable[], index = 0): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .pedersenHash(
-          inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-          index,
-        )
-        .toBuffer(),
-    ),
+  const api = await BarretenbergSync.initSingleton();
+  const hash = api.pedersenHash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+    index,
   );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
 }
 
 /**
  * Create a pedersen hash from an arbitrary length buffer.
  */
-export function pedersenHashBuffer(input: Buffer, index = 0) {
-  return Buffer.from(BarretenbergSync.getSingleton().pedersenHashBuffer(input, index).toBuffer());
+export async function pedersenHashBuffer(input: Buffer, index = 0) {
+  const api = await BarretenbergSync.initSingleton();
+  const result = api.pedersenHashBuffer(input, index);
+  return Buffer.from(result.toBuffer());
 }

package/src/crypto/poseidon/index.ts

@@ -8,17 +8,13 @@ import { type Fieldable, serializeToFields } from '../../serialize/serialize.js'
  * @param input - The input fields to hash.
  * @returns The poseidon hash.
  */
-export function poseidon2Hash(input: Fieldable[]): Fr {
+export async function poseidon2Hash(input: Fieldable[]): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .poseidon2Hash(
-          inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-        )
-        .toBuffer(),
-    ),
+  const api = await BarretenbergSync.initSingleton();
+  const hash = api.poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
   );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
 }
 
 /**
@@ -27,29 +23,22 @@ export function poseidon2Hash(input: Fieldable[]): Fr {
  * @param separator - The domain separator.
  * @returns The poseidon hash.
  */
-export function poseidon2HashWithSeparator(input: Fieldable[], separator: number): Fr {
+export async function poseidon2HashWithSeparator(input: Fieldable[], separator: number): Promise<Fr> {
   const inputFields = serializeToFields(input);
   inputFields.unshift(new Fr(separator));
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .poseidon2Hash(
-          inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-        )
-        .toBuffer(),
-    ),
+  const api = await BarretenbergSync.initSingleton();
+
+  const hash = api.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 {
+export async function poseidon2HashAccumulate(input: Fieldable[]): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .poseidon2HashAccumulate(inputFields.map(i => new FrBarretenberg(i.toBuffer())))
-        .toBuffer(),
-    ),
-  );
+  const api = await BarretenbergSync.initSingleton();
+  const result = api.poseidon2HashAccumulate(inputFields.map(i => new FrBarretenberg(i.toBuffer())));
+  return Fr.fromBuffer(Buffer.from(result.toBuffer()));
 }
 
 /**
@@ -57,19 +46,18 @@ export function poseidon2HashAccumulate(input: Fieldable[]): Fr {
  * @param input the input state. Expected to be of size 4.
  * @returns the output state, size 4.
  */
-export function poseidon2Permutation(input: Fieldable[]): Fr[] {
+export async function poseidon2Permutation(input: Fieldable[]): Promise<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())),
-  );
+  const api = await BarretenbergSync.initSingleton();
+  const res = api.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 {
+export async function poseidon2HashBytes(input: Buffer): Promise<Fr> {
   const inputFields = [];
   for (let i = 0; i < input.length; i += 31) {
     const fieldBytes = Buffer.alloc(32, 0);
@@ -80,13 +68,10 @@ export function poseidon2HashBytes(input: Buffer): Fr {
     inputFields.push(Fr.fromBuffer(fieldBytes));
   }
 
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .poseidon2Hash(
-          inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-        )
-        .toBuffer(),
-    ),
+  const api = await BarretenbergSync.initSingleton();
+  const res = api.poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
   );
+
+  return Fr.fromBuffer(Buffer.from(res.toBuffer()));
 }

package/src/crypto/sync/index.ts

@@ -0,0 +1,6 @@
+import { BarretenbergSync } from '@aztec/bb.js';
+
+export * from './poseidon/index.js';
+export * from './pedersen/index.js';
+
+await BarretenbergSync.initSingleton();

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

@@ -0,0 +1,45 @@
+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 pedersen commitment (point) from an array of input fields.
+ * Left pads any inputs less than 32 bytes.
+ */
+export function pedersenCommit(input: Buffer[], offset = 0) {
+  if (!input.every(i => i.length <= 32)) {
+    throw new Error('All Pedersen Commit input buffers must be <= 32 bytes.');
+  }
+  input = input.map(i => (i.length < 32 ? Buffer.concat([Buffer.alloc(32 - i.length, 0), i]) : i));
+  const point = BarretenbergSync.getSingleton().pedersenCommit(
+    input.map(i => new FrBarretenberg(i)),
+    offset,
+  );
+  // toBuffer returns Uint8Arrays (browser/worker-boundary friendly).
+  // TODO: rename toTypedArray()?
+  return [Buffer.from(point.x.toBuffer()), Buffer.from(point.y.toBuffer())];
+}
+
+/**
+ * Create a pedersen hash (field) from an array of input fields.
+ * @param input - The input fieldables to hash.
+ * @param index - The separator index to use for the hash.
+ * @returns The pedersen hash.
+ */
+export function pedersenHash(input: Fieldable[], index = 0): Fr {
+  const inputFields = serializeToFields(input);
+  const hash = BarretenbergSync.getSingleton().pedersenHash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+    index,
+  );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+
+/**
+ * Create a pedersen hash from an arbitrary length buffer.
+ */
+export function pedersenHashBuffer(input: Buffer, index = 0) {
+  const result = BarretenbergSync.getSingleton().pedersenHashBuffer(input, index);
+  return Buffer.from(result.toBuffer());
+}

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();