@aztec/foundation 0.86.0 → 0.87.0

package/src/serialize/field_reader.ts

@@ -11,11 +11,15 @@ import type { Tuple } from './types.js';
  */
 export class FieldReader {
   private index: number;
-  private length: number;
-  constructor(private fields: Fr[], offset = 0) {
+  private readonly length: number;
+
+  constructor(
+    private fields: Fr[],
+    offset = 0,
+  ) {
     this.index = offset;
     this.length = fields.length;
-    if (offset >= this.length) {
+    if (offset > this.length) {
       throw new Error('Offset out of bounds.');
     }
   }
@@ -43,6 +47,10 @@ export class FieldReader {
     return this.index;
   }
 
+  public remainingFields(): number {
+    return this.length - this.index;
+  }
+
   /**
    * Skips the next n fields.
    *

package/src/serialize/free_funcs.ts

@@ -56,6 +56,19 @@ export function numToUInt32BE(n: number, bufferSize = 4) {
   return buf;
 }
 
+/**
+ * Convert a bigint to a big-endian unsigned 64-bit integer Buffer.
+ *
+ * @param n - The bigint to be converted to a big-endian unsigned 64-bit integer Buffer.
+ * @param bufferSize - Optional, the size of the output Buffer (default is 8).
+ * @returns A Buffer containing the big-endian unsigned 64-bit integer representation of the input number.
+ */
+export function bigintToUInt64BE(n: bigint, bufferSize = 8) {
+  const buf = Buffer.alloc(bufferSize);
+  buf.writeBigUInt64BE(n, bufferSize - 8);
+  return buf;
+}
+
 /**
  * Serialize a number into a big-endian signed 32-bit integer Buffer with the specified buffer size.
  * This function converts the input number into its binary representation and stores it in a Buffer

package/src/string/index.ts

@@ -19,7 +19,7 @@ export function bufferToHex(buffer: Buffer): `0x${string}` {
 }
 
 export function pluralize(str: string, count: number | bigint, plural?: string): string {
-  return count === 1 || count === 1n ? str : plural ?? `${str}s`;
+  return count === 1 || count === 1n ? str : (plural ?? `${str}s`);
 }
 
 export function count(count: number | bigint, str: string, plural?: string): string {
@@ -29,3 +29,11 @@ export function count(count: number | bigint, str: string, plural?: string): str
 export function truncate(str: string, length: number = 64): string {
   return str.length > length ? str.slice(0, length) + '...' : str;
 }
+
+export function isoDate(date?: Date) {
+  return (date ?? new Date()).toISOString().replace(/[-:T]/g, '').replace(/\..+$/, '');
+}
+
+export function urlJoin(...args: string[]): string {
+  return args.map(arg => arg.replace(/\/+$/, '').replace(/^\/+/, '')).join('/');
+}

package/src/timer/timeout.ts

@@ -12,7 +12,11 @@ export class TimeoutTask<T> {
   private interrupt = () => {};
   private totalTime = 0;
 
-  constructor(private fn: () => Promise<T>, private timeout: number, errorFn: () => any) {
+  constructor(
+    private fn: () => Promise<T>,
+    private timeout: number,
+    errorFn: () => any,
+  ) {
     this.interruptPromise = new Promise<T>((_, reject) => {
       this.interrupt = () => reject(errorFn());
     });

package/src/transport/interface/connector.ts

@@ -4,6 +4,5 @@ import type { Socket } from './socket.js';
  * Opens a socket with corresponding TransportListener.
  */
 export interface Connector {
-  // eslint-disable-next-line jsdoc/require-jsdoc
   createSocket(): Promise<Socket>;
 }

package/src/transport/interface/listener.ts

@@ -7,10 +7,9 @@ import type { Socket } from './socket.js';
  * Possible implementations could include MessageChannels or WebSockets.
  */
 export interface Listener extends EventEmitter {
-  // eslint-disable-next-line jsdoc/require-jsdoc
   open(): void;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   close(): void;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   on(name: 'new_socket', cb: (client: Socket) => void): this;
 }

package/src/transport/interface/socket.ts

@@ -6,10 +6,9 @@
  * If `registerHandler` callback receives `undefined` that signals the other end closed.
  */
 export interface Socket {
-  // eslint-disable-next-line jsdoc/require-jsdoc
   send(msg: any, transfer?: Transferable[]): Promise<void>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   registerHandler(cb: (msg: any) => any): void;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   close(): void;
 }

package/src/transport/transport_client.ts

@@ -18,9 +18,9 @@ interface PendingRequest {
    * The unique message identifier used for tracking and matching request/response pairs.
    */
   msgId: number;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   resolve(data: any): void;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   reject(error: Error): void;
 }
 
@@ -30,9 +30,8 @@ interface PendingRequest {
  * for efficient and concurrent communication with a corresponding TransportServer.
  */
 export interface ITransportClient<Payload> extends EventEmitter {
-  // eslint-disable-next-line jsdoc/require-jsdoc
   on(name: 'event_msg', handler: (payload: Payload) => void): this;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   emit(name: 'event_msg', payload: Payload): boolean;
 }
 

package/src/transport/transport_server.ts

@@ -9,7 +9,10 @@ import { isTransferDescriptor } from './interface/transferable.js';
 export class TransportServer<Payload> {
   private sockets: Socket[] = [];
 
-  constructor(private listener: Listener, private msgHandlerFn: (msg: Payload) => Promise<any>) {}
+  constructor(
+    private listener: Listener,
+    private msgHandlerFn: (msg: Payload) => Promise<any>,
+  ) {}
 
   /**
    * Starts the TransportServer, allowing it to accept new connections and handle incoming messages.

package/src/trees/hasher.ts

@@ -8,14 +8,14 @@ export interface Hasher {
    * @param rhs - The second array.
    * @returns The new 32-byte hash.
    */
-  hash(lhs: Uint8Array, rhs: Uint8Array): Buffer;
+  hash(lhs: Uint8Array, rhs: Uint8Array): Buffer<ArrayBuffer>;
 
   /**
    * Hashes an array of buffers.
    * @param inputs - The array of buffers to hash.
    * @returns The resulting 32-byte hash.
    */
-  hashInputs(inputs: Buffer[]): Buffer;
+  hashInputs(inputs: Buffer[]): Buffer<ArrayBuffer>;
 }
 
 /**
@@ -28,12 +28,12 @@ export interface AsyncHasher {
    * @param rhs - The second array.
    * @returns The new 32-byte hash.
    */
-  hash(lhs: Uint8Array, rhs: Uint8Array): Promise<Buffer>;
+  hash(lhs: Uint8Array, rhs: Uint8Array): Promise<Buffer<ArrayBuffer>>;
 
   /**
    * Hashes an array of buffers.
    * @param inputs - The array of buffers to hash.
    * @returns The resulting 32-byte hash.
    */
-  hashInputs(inputs: Buffer[]): Promise<Buffer>;
+  hashInputs(inputs: Buffer[]): Promise<Buffer<ArrayBuffer>>;
 }

package/src/trees/indexed_merkle_tree.ts

@@ -6,7 +6,11 @@ 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[]) {
+  constructor(
+    height: N,
+    nodes: Buffer[],
+    public readonly leafPreimages: T[],
+  ) {
     super(height, nodes);
   }
 

package/src/trees/indexed_merkle_tree_calculator.ts

@@ -28,7 +28,7 @@ export class IndexedMerkleTreeCalculator<T extends IndexedTreeLeafPreimage, N ex
   ) {
     const zeroHashes = [zeroLeaf];
     for (let i = 0; i < height; i++) {
-      zeroHashes.push(await hasher.hash(zeroHashes[i], zeroHashes[i]));
+      zeroHashes.push((await hasher.hash(zeroHashes[i], zeroHashes[i])) as Buffer<ArrayBuffer>);
     }
     return new IndexedMerkleTreeCalculator(height, zeroHashes, hasher, factory);
   }
@@ -59,7 +59,7 @@ export class IndexedMerkleTreeCalculator<T extends IndexedTreeLeafPreimage, N ex
 
     for (let i = 0; i < this.height; ++i) {
       const numLeaves = 2 ** (this.height - i);
-      const newLeaves: Buffer[] = [];
+      const newLeaves: Buffer<ArrayBuffer>[] = [];
       for (let j = 0; j < leaves.length / 2; ++j) {
         const l = leaves[j * 2];
         const r = leaves[j * 2 + 1] || this.zeroHashes[i];

package/src/trees/merkle_tree.ts

@@ -1,6 +1,9 @@
 /** A simple immutable Merkle tree container. Use a MerkleTreeCalculator to create a new instance from a set of leaves. */
 export class MerkleTree {
-  constructor(public readonly height: number, public readonly nodes: Buffer[]) {
+  constructor(
+    public readonly height: number,
+    public readonly nodes: Buffer[],
+  ) {
     const expectedNodeCount = 2 ** (height + 1) - 1;
     if (nodes.length !== expectedNodeCount) {
       throw new Error(`Invalid node count for Merkle tree: got ${nodes.length} but expected ${expectedNodeCount}`);

package/src/trees/merkle_tree_calculator.ts

@@ -7,18 +7,23 @@ import { MerkleTree } from './merkle_tree.js';
  * Merkle tree calculator.
  */
 export class MerkleTreeCalculator {
-  private constructor(private height: number, private zeroHashes: Buffer[], private hasher: AsyncHasher['hash']) {
+  private constructor(
+    private height: number,
+    private zeroHashes: Buffer[],
+    private hasher: AsyncHasher['hash'],
+  ) {
     this.hasher = hasher;
   }
 
   static async create(
     height: number,
     zeroLeaf = Buffer.alloc(32),
-    hasher = async (left: Buffer, right: Buffer) => (await pedersenHash([left, right])).toBuffer(),
+    hasher = async (left: Buffer, right: Buffer) =>
+      (await pedersenHash([left, right])).toBuffer() as Buffer<ArrayBuffer>,
   ) {
     const zeroHashes = [zeroLeaf];
     for (let i = 0; i < height; i++) {
-      zeroHashes.push(await hasher(zeroHashes[i], zeroHashes[i]));
+      zeroHashes.push((await hasher(zeroHashes[i], zeroHashes[i])) as Buffer<ArrayBuffer>);
     }
     return new MerkleTreeCalculator(height, zeroHashes, hasher);
   }

package/src/types/index.ts

@@ -1,12 +1,10 @@
 /** Strips methods of a type. */
 export type FieldsOf<T> = {
-  // eslint-disable-next-line @typescript-eslint/ban-types
   [P in keyof T as T[P] extends Function ? never : P]: T[P];
 };
 
 /** Extracts methods of a type. */
 export type FunctionsOf<T> = {
-  // eslint-disable-next-line @typescript-eslint/ban-types
   [P in keyof T as T[P] extends Function ? P : never]: T[P];
 };
 
@@ -20,6 +18,3 @@ export type Writeable<T> = { -readonly [P in keyof T]: T[P] };
 export function unfreeze<T>(obj: T): Writeable<T> {
   return obj as Writeable<T>;
 }
-
-/** Maybe exists, maybe not. */
-export type Maybe<T extends object> = T | unknown;

package/src/url/index.ts

@@ -1,4 +1,3 @@
-/* eslint-disable */
 // Copyright (c) 2014 Nathan Rajlich <nathan@tootallnate.net>
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the