@aztec/foundation 0.86.0-starknet.1 → 0.87.0

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