@aztec/foundation 0.0.1-commit.3fd054f6 → 0.0.1-commit.431c48d

package/src/curves/grumpkin/point.ts

@@ -1,5 +1,4 @@
 import { toBigIntBE } from '../../bigint-buffer/index.js';
-import { poseidon2Hash } from '../../crypto/poseidon/index.js';
 import { randomBoolean } from '../../crypto/random/index.js';
 import { hexSchemaFor } from '../../schemas/utils.js';
 import { BufferReader, FieldReader, serializeToBuffer } from '../../serialize/index.js';
@@ -13,13 +12,16 @@ import { Fr } from '../bn254/field.js';
  * TODO(#7386): Clean up this class.
  */
 export class Point {
-  static ZERO = new Point(Fr.ZERO, Fr.ZERO, false);
+  static INFINITY = new Point(Fr.ZERO, Fr.ZERO);
   static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * 2;
   static COMPRESSED_SIZE_IN_BYTES = Fr.SIZE_IN_BYTES;
 
   /** Used to differentiate this class from AztecAddress */
   public readonly kind = 'point';
 
+  /** Whether the point is at infinity */
+  public readonly isInfinite: boolean;
+
   constructor(
     /**
      * The point's x coordinate
@@ -29,12 +31,10 @@ export class Point {
      * The point's y coordinate
      */
     public readonly y: Fr,
-    /**
-     * Whether the point is at infinity
-     */
-    public readonly isInfinite: boolean,
   ) {
     // TODO(#7386): check if on curve
+    // NOTE: now there is no isInfinite in the struct, empty == inf, so an empty class would pass an on-curve check. This may be fine depending on the usage.
+    this.isInfinite = x.isZero() && y.isZero();
   }
 
   toJSON() {
@@ -61,11 +61,11 @@ export class Point {
     if (obj instanceof Buffer || Buffer.isBuffer(obj)) {
       return Point.fromBuffer(obj);
     }
-    return new Point(Fr.fromPlainObject(obj.x), Fr.fromPlainObject(obj.y), obj.isInfinite ?? false);
+    return new this(Fr.fromPlainObject(obj.x), Fr.fromPlainObject(obj.y));
   }
 
   /**
-   * Generate a random Point instance.
+   * Generate a random Point instance that is on the curve.
    *
    * @returns A randomly generated Point instance.
    */
@@ -92,7 +92,7 @@ export class Point {
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new this(Fr.fromBuffer(reader), Fr.fromBuffer(reader), false);
+    return new this(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
   }
 
   /**
@@ -129,12 +129,13 @@ export class Point {
    * @returns The point as an array of 2 fields
    */
   toFields() {
-    return [this.x, this.y, new Fr(this.isInfinite)];
+    return [this.x, this.y];
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new this(reader.readField(), reader.readField(), reader.readBoolean());
+    const [x, y] = [reader.readField(), reader.readField()];
+    return new this(x, y);
   }
 
   /**
@@ -159,11 +160,12 @@ export class Point {
     const finalY = sign ? new Fr(yPositiveBigInt) : new Fr(yNegativeBigInt);
 
     // Create and return the new Point
-    return new this(x, finalY, false);
+    return new this(x, finalY);
   }
 
   /**
-   * @returns
+   * @param x - The x coordinate of the point
+   * @returns y^2 such that y^2 = x^3 - 17
    */
   static YFromX(x: Fr): Promise<Fr | null> {
     // Calculate y^2 = x^3 - 17 (i.e. the Grumpkin curve equation)
@@ -191,24 +193,15 @@ export class Point {
     return {
       x: this.x.toBigInt(),
       y: this.y.toBigInt(),
-      isInfinite: this.isInfinite ? 1n : 0n,
     };
   }
 
   /**
    * Converts the Point instance to a Buffer representation of the coordinates.
    * @returns A Buffer representation of the Point instance.
-   * @dev Note that toBuffer does not include the isInfinite flag and other serialization methods do (e.g. toFields).
-   * This is because currently when we work with point as bytes we don't want to populate the extra bytes for
-   * isInfinite flag because:
-   * 1. Our Grumpkin BB API currently does not handle point at infinity,
-   * 2. we use toBuffer when serializing notes and events and there we only work with public keys and point at infinity
-   *   is not considered a valid public key and the extra byte would raise DA cost.
+   * @dev Note that toBuffer does not include the isInfinite flag. The point at infinity is serialized as (0, 0).
    */
   toBuffer() {
-    if (this.isInfinite) {
-      throw new Error('Cannot serialize infinite point with isInfinite flag');
-    }
     const buf = serializeToBuffer([this.x, this.y]);
     if (buf.length !== Point.SIZE_IN_BYTES) {
       throw new Error(`Invalid buffer length for Point: ${buf.length}`);
@@ -258,12 +251,10 @@ export class Point {
   }
 
   toNoirStruct() {
-    /* eslint-disable camelcase */
-    return { x: this.x, y: this.y, is_infinite: this.isInfinite };
-    /* eslint-enable camelcase */
+    return { x: this.x, y: this.y };
   }
 
-  // Used for IvpkM, OvpkM, NpkM and TpkM. TODO(#8124): Consider removing this method.
+  // Used for IvpkM. TODO(#8124): Consider removing this method.
   toWrappedNoirStruct() {
     return { inner: this.toNoirStruct() };
   }
@@ -283,21 +274,13 @@ export class Point {
     return this.x.isZero() && this.y.isZero();
   }
 
-  hash() {
-    return poseidon2Hash(this.toFields());
-  }
-
   /**
-   * Check if this is point at infinity.
-   * Check this is consistent with how bb is encoding the point at infinity
+   * @param x - The x coordinate of the point
+   * @param y - The y coordinate of the point
+   * @returns Whether the point exists on Grumpkin
    */
-  public get inf() {
-    return this.isInfinite;
-  }
-
-  isOnGrumpkin() {
-    // TODO: Check this against how bb handles curve check and infinity point check
-    if (this.inf) {
+  isOnCurve() {
+    if (this.isInfinite) {
       return true;
     }
 

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/fifo_set/fifo_set.ts

@@ -0,0 +1,52 @@
+/** A Set capped to a fixed number of entries, evicting the oldest inserted value when full. */
+export class FifoSet<T> extends Set<T> {
+  private _limit: number | undefined;
+
+  private constructor(values?: Iterable<T>) {
+    super(values);
+  }
+
+  /** Creates a bounded set with a positive integer limit. */
+  static withLimit<T>(limit: number, values?: Iterable<T>): FifoSet<T> {
+    if (!Number.isSafeInteger(limit) || limit <= 0) {
+      throw new TypeError(`FifoSet limit must be a positive safe integer: ${limit}`);
+    }
+
+    const set = new FifoSet(values);
+    set._limit = limit;
+    set.compact();
+
+    return set;
+  }
+
+  override add(value: T): this {
+    super.add(value);
+    this.compact();
+    return this;
+  }
+
+  /** Maximum number of entries retained by this set. */
+  public get limit(): number {
+    return this._limit ?? Infinity;
+  }
+
+  /** Evicts oldest entries until the set is within its limit. */
+  public compact(): void {
+    while (this.size > this.limit) {
+      const head = this.values().next();
+      if (head.done) {
+        return;
+      }
+      this.delete(head.value);
+    }
+  }
+
+  /** Adds a value only if it is absent, returning whether the set changed. */
+  public addIfAbsent(value: T): boolean {
+    if (this.has(value)) {
+      return false;
+    }
+    this.add(value);
+    return true;
+  }
+}

package/src/fifo_set/index.ts

@@ -0,0 +1 @@
+export * from './fifo_set.js';

package/src/iterable/first.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns the first entry of an iterable, or undefined if it yields none, closing the underlying
+ * iterator either way. Use this instead of calling `.next()` once and abandoning the iterator:
+ * an abandoned generator never runs its finally blocks, so any resource it holds is leaked — e.g.
+ * a kv-store iterator's LMDB cursor, where enough leaks deadlock the store.
+ */
+export async function first<T>(
+  iterator: Iterable<T> | AsyncIterableIterator<T> | AsyncIterable<T> | IterableIterator<T>,
+): Promise<T | undefined> {
+  for await (const i of iterator) {
+    return i;
+  }
+  return undefined;
+}

package/src/iterable/index.ts

@@ -3,5 +3,6 @@ export * from './filter.js';
 export * from './sort.js';
 export * from './take.js';
 export * from './all.js';
+export * from './first.js';
 export * from './peek.js';
 export * from './toArray.js';

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

@@ -13,6 +13,10 @@ export type JsonRpcFetch = (
   noRetry?: boolean,
 ) => Promise<{ response: any; headers: { get: (header: string) => string | null | undefined } }>;
 
+export type JsonRpcFetchConfig = {
+  credentials?: RequestCredentials;
+};
+
 /**
  * A normal fetch function that does not retry.
  * Alternatives are a fetch function with retries, or a mocked fetch.
@@ -21,6 +25,7 @@ export type JsonRpcFetch = (
  * @param body - The RPC payload.
  * @param noRetry - Whether to throw a `NoRetryError` in case the response is a 5xx error and the body contains an error
  *                  message (see `retry` function for more details).
+ * @param config - Fetch transport configuration.
  * @returns The parsed JSON response, or throws an error.
  */
 export async function defaultFetch(
@@ -28,6 +33,7 @@ export async function defaultFetch(
   body: unknown,
   extraHeaders: Record<string, string> = {},
   noRetry = false,
+  config: JsonRpcFetchConfig = {},
 ): Promise<{ response: any; headers: { get: (header: string) => string | null | undefined } }> {
   log.debug(format(`JsonRpcClient.fetch`, host, '->', body));
   let resp: Response;
@@ -36,6 +42,7 @@ export async function defaultFetch(
       method: 'POST',
       body: jsonStringify(body),
       headers: { 'content-type': 'application/json', ...extraHeaders },
+      credentials: config.credentials,
     });
   } catch (err) {
     const errorMessage = `Error fetching from host ${host}: ${inspect(err)}`;
@@ -43,17 +50,18 @@ export async function defaultFetch(
   }
 
   let responseJson;
+  const responseText = await resp.text();
   try {
-    responseJson = await resp.json();
+    responseJson = JSON.parse(responseText);
   } catch {
     if (!resp.ok) {
       throw new Error(resp.statusText);
     }
-    throw new Error(`Failed to parse body as JSON: ${await resp.text()}`);
+    throw new Error(`Failed to parse body as JSON: ${responseText}`);
   }
 
   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 {
@@ -69,12 +77,18 @@ export async function defaultFetch(
  * @param retries - Sequence of intervals (in seconds) to retry.
  * @param noRetry - Whether to stop retries on server errors.
  * @param log - Optional logger for logging attempts.
+ * @param config - Fetch transport configuration.
  * @returns A fetch function.
  */
-export function makeFetch(retries: number[], defaultNoRetry: boolean, log?: Logger): typeof defaultFetch {
+export function makeFetch(
+  retries: number[],
+  defaultNoRetry: boolean,
+  log?: Logger,
+  config: JsonRpcFetchConfig = {},
+): JsonRpcFetch {
   return async (host: string, body: unknown, extraHeaders: Record<string, string> = {}, noRetry?: boolean) => {
     return await retry(
-      () => defaultFetch(host, body, extraHeaders, noRetry ?? defaultNoRetry),
+      () => defaultFetch(host, body, extraHeaders, noRetry ?? defaultNoRetry, config),
       `JsonRpcClient request to ${host}`,
       makeBackoff(retries),
       log,

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

@@ -2,7 +2,7 @@ import { format } from 'util';
 
 import { type Logger, createLogger } from '../../log/pino-logger.js';
 import { type PromiseWithResolvers, promiseWithResolvers } from '../../promise/utils.js';
-import { type ApiSchema, type ApiSchemaFor, schemaHasMethod } from '../../schemas/api.js';
+import { type ApiSchema, type ApiSchemaFor, getSchemaReturnType, schemaHasMethod } from '../../schemas/api.js';
 import { jsonStringify } from '../convert.js';
 import { type JsonRpcFetch, defaultFetch } from './fetch.js';
 
@@ -236,7 +236,7 @@ export function createSafeJsonRpcClient<T extends object>(
     if ([null, undefined, 'null', 'undefined'].includes(response.result)) {
       return;
     }
-    return (schema as ApiSchema)[methodName].returnType().parseAsync(response.result);
+    return getSchemaReturnType((schema as ApiSchema)[methodName]).parseAsync(response.result);
   };
 
   const clientId = nextClientId++;

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

@@ -17,24 +17,48 @@ const COMPRESSION_THRESHOLD = 1024;
 
 export { Agent };
 
-export function makeUndiciFetch(client = new Agent()): JsonRpcFetch {
+/** Asynchronous cookie storage. */
+export interface CookieJar {
+  getCookieString(url: string): Promise<string>;
+  setCookie(cookie: string, url: string): Promise<unknown>;
+}
+
+/**
+ * Creates an Undici JSON-RPC transport.
+ * @param client - Dispatcher used to make requests.
+ * @param cookieJar - Optional application-owned cookie storage. Cookies are ignored when omitted.
+ * @returns A JSON-RPC fetch implementation.
+ */
+export function makeUndiciFetch(client: Dispatcher = new Agent(), cookieJar?: CookieJar): JsonRpcFetch {
   return async (host: string, body: unknown, extraHeaders: Record<string, string> = {}, noRetry = false) => {
     log.trace(`JsonRpcClient.fetch: ${host}`, { host, body });
+    const requestUrl = new URL(host);
+    requestUrl.hash = '';
     let resp: Dispatcher.ResponseData;
     try {
+      const headers = new Headers();
+      for (const [name, value] of Object.entries(extraHeaders)) {
+        headers.append(name, value);
+      }
+      const cookie = await cookieJar?.getCookieString(requestUrl.href);
+      if (cookie) {
+        headers.append('cookie', cookie);
+      }
       const jsonBody = Buffer.from(jsonStringify(body));
       const shouldCompress = jsonBody.length >= COMPRESSION_THRESHOLD;
+      headers.set('content-type', 'application/json');
+      if (shouldCompress) {
+        headers.set('content-encoding', 'gzip');
+      }
+      headers.set('accept-encoding', 'gzip');
+      const requestHeaders: string[] = [];
+      headers.forEach((value, name) => requestHeaders.push(name, value));
       resp = await client.request({
         method: 'POST',
-        origin: new URL(host),
-        path: '/',
+        origin: requestUrl.origin,
+        path: `${requestUrl.pathname}${requestUrl.search}`,
         body: shouldCompress ? await gzip(jsonBody) : jsonBody,
-        headers: {
-          ...extraHeaders,
-          'content-type': 'application/json',
-          ...(shouldCompress && { 'content-encoding': 'gzip' }),
-          'accept-encoding': 'gzip',
-        },
+        headers: requestHeaders,
       });
     } catch (err) {
       const errorMessage = `Error fetching from host ${host}: ${String(err)}`;
@@ -44,18 +68,36 @@ 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();
       }
+    } catch (err) {
+      if (!responseOk) {
+        throw new Error('HTTP ' + resp.statusCode);
+      }
+      throw new Error(`Failed to read response body. encoding: ${contentEncoding}, error: ${String(err)}`);
+    }
+
+    if (cookieJar) {
+      const setCookieHeaders = resp.headers['set-cookie'];
+      const cookies = typeof setCookieHeaders === 'string' ? [setCookieHeaders] : (setCookieHeaders ?? []);
+      for (const cookie of cookies) {
+        await cookieJar.setCookie(cookie, requestUrl.href);
+      }
+    }
+
+    try {
+      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/json-rpc/fixtures/test_state.ts

@@ -130,14 +130,14 @@ export class TestState implements TestStateApi {
 }
 
 export const TestStateSchema: ApiSchemaFor<TestStateApi> = {
-  getNote: z.function().args(z.number()).returns(TestNote.schema.optional()),
-  getNotes: z.function().args(optional(schemas.Integer)).returns(z.array(TestNote.schema)),
-  getNotes2: z.function().args(optional(schemas.BigInt)).returns(z.array(TestNote.schema)),
-  getNotes3: z.function().args(optional(schemas.Integer)).returns(z.array(TestNote.schema)),
-  clear: z.function().returns(z.void()),
-  addNotes: z.function().args(z.array(TestNote.schema)).returns(z.array(TestNote.schema)),
-  fail: z.function().returns(z.void()),
-  count: z.function().returns(z.number()),
-  getStatus: z.function().returns(z.object({ status: z.string(), count: schemas.BigInt })),
-  getTuple: z.function().returns(z.tuple([z.string(), optional(z.string()), z.number()])),
+  getNote: z.function({ input: z.tuple([z.number()]), output: TestNote.schema.optional() }),
+  getNotes: z.function({ input: z.tuple([optional(schemas.Integer)]), output: z.array(TestNote.schema) }),
+  getNotes2: z.function({ input: z.tuple([optional(schemas.BigInt)]), output: z.array(TestNote.schema) }),
+  getNotes3: z.function({ input: z.tuple([optional(schemas.Integer)]), output: z.array(TestNote.schema) }),
+  clear: z.function({ input: z.tuple([]), output: z.void() }),
+  addNotes: z.function({ input: z.tuple([z.array(TestNote.schema)]), output: z.array(TestNote.schema) }),
+  fail: z.function({ input: z.tuple([]), output: z.void() }),
+  count: z.function({ input: z.tuple([]), output: z.number() }),
+  getStatus: z.function({ input: z.tuple([]), output: z.object({ status: z.string(), count: schemas.BigInt }) }),
+  getTuple: z.function({ input: z.tuple([]), output: z.tuple([z.string(), optional(z.string()), z.number()]) }),
 };