@aztec/foundation 0.76.4 → 0.77.0-testnet-ignition.21

package/src/crypto/schnorr/index.ts

@@ -0,0 +1,55 @@
+import { BarretenbergSync } from '@aztec/bb.js';
+import { type GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import { numToInt32BE } from '@aztec/foundation/serialize';
+
+import { concatenateUint8Arrays } from '../serialize.js';
+import { SchnorrSignature } from './signature.js';
+
+export * from './signature.js';
+
+/**
+ * Schnorr signature construction and helper operations.
+ */
+export class Schnorr {
+  /**
+   * Computes a grumpkin public key from a private key.
+   * @param privateKey - The private key.
+   * @returns A grumpkin public key.
+   */
+  public async computePublicKey(privateKey: GrumpkinScalar): Promise<Point> {
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const [result] = api.getWasm().callWasmExport('schnorr_compute_public_key', [privateKey.toBuffer()], [64]);
+    return Point.fromBuffer(Buffer.from(result));
+  }
+
+  /**
+   * Constructs a Schnorr signature given a msg and a private key.
+   * @param msg - Message over which the signature is constructed.
+   * @param privateKey - The private key of the signer.
+   * @returns A Schnorr signature of the form (s, e).
+   */
+  public async constructSignature(msg: Uint8Array, privateKey: GrumpkinScalar) {
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const messageArray = concatenateUint8Arrays([numToInt32BE(msg.length), msg]);
+    const [s, e] = api
+      .getWasm()
+      .callWasmExport('schnorr_construct_signature', [messageArray, privateKey.toBuffer()], [32, 32]);
+    return new SchnorrSignature(Buffer.from([...s, ...e]));
+  }
+
+  /**
+   * Verifies a Schnorr signature given a Grumpkin public key.
+   * @param msg - Message over which the signature was constructed.
+   * @param pubKey - The Grumpkin public key of the signer.
+   * @param sig - The Schnorr signature.
+   * @returns True or false.
+   */
+  public async verifySignature(msg: Uint8Array, pubKey: Point, sig: SchnorrSignature) {
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const messageArray = concatenateUint8Arrays([numToInt32BE(msg.length), msg]);
+    const [result] = api
+      .getWasm()
+      .callWasmExport('schnorr_verify_signature', [messageArray, pubKey.toBuffer(), sig.s, sig.e], [1]);
+    return result[0] === 1;
+  }
+}

package/src/crypto/schnorr/signature.ts

@@ -0,0 +1,116 @@
+import { randomBytes } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, mapTuple } from '@aztec/foundation/serialize';
+
+import type { Signature } from '../signature/index.js';
+
+/**
+ * Schnorr signature used for transactions.
+ * @see cpp/barretenberg/cpp/src/barretenberg/crypto/schnorr/schnorr.hpp
+ */
+export class SchnorrSignature implements Signature {
+  /**
+   * The size of the signature in bytes.
+   */
+  public static SIZE = 64;
+
+  /**
+   * An empty signature.
+   */
+  public static EMPTY = new SchnorrSignature(Buffer.alloc(64));
+
+  constructor(private buffer: Buffer) {
+    if (buffer.length !== SchnorrSignature.SIZE) {
+      throw new Error(`Invalid signature buffer of length ${buffer.length}.`);
+    }
+  }
+
+  /**
+   * Determines if the provided signature is valid or not.
+   * @param signature - The data to be checked.
+   * @returns Boolean indicating if the provided data is a valid schnorr signature.
+   */
+  public static isSignature(signature: string) {
+    return /^(0x)?[0-9a-f]{128}$/i.test(signature);
+  }
+
+  /**
+   * Constructs a SchnorrSignature from the provided string.
+   * @param signature - The string to be converted to a schnorr signature.
+   * @returns The constructed schnorr signature.
+   */
+  public static fromString(signature: string) {
+    if (!SchnorrSignature.isSignature(signature)) {
+      throw new Error(`Invalid signature string: ${signature}`);
+    }
+    return new SchnorrSignature(Buffer.from(signature.replace(/^0x/i, ''), 'hex'));
+  }
+
+  /**
+   * Generates a random schnorr signature.
+   * @returns The randomly constructed signature.
+   */
+  public static random() {
+    return new SchnorrSignature(randomBytes(64));
+  }
+
+  /**
+   * Returns the 's' component of the signature.
+   * @returns A buffer containing the signature's 's' component.
+   */
+  get s() {
+    return this.buffer.subarray(0, 32);
+  }
+
+  /**
+   * Returns the 'e' component of the signature.
+   * @returns A buffer containing the signature's 'e' component.
+   */
+  get e() {
+    return this.buffer.subarray(32);
+  }
+
+  /**
+   * Returns the full signature as a buffer.
+   * @returns A buffer containing the signature.
+   */
+  toBuffer() {
+    return this.buffer;
+  }
+
+  /**
+   * Deserializes from a buffer.
+   * @param buffer - The buffer representation of the object.
+   * @returns The new object.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): SchnorrSignature {
+    const reader = BufferReader.asReader(buffer);
+    return new SchnorrSignature(reader.readBytes(SchnorrSignature.SIZE));
+  }
+
+  /**
+   * Returns the full signature as a hex string.
+   * @returns A string containing the signature in hex format.
+   */
+  toString() {
+    return `0x${this.buffer.toString('hex')}`;
+  }
+
+  /**
+   * Converts the signature to an array of three fields.
+   * @returns The signature components as an array of three fields
+   */
+  toFields(): Fr[] {
+    const sig = this.toBuffer();
+
+    const buf1 = Buffer.alloc(32);
+    const buf2 = Buffer.alloc(32);
+    const buf3 = Buffer.alloc(32);
+
+    sig.copy(buf1, 1, 0, 31);
+    sig.copy(buf2, 1, 31, 62);
+    sig.copy(buf3, 1, 62, 64);
+
+    return mapTuple([buf1, buf2, buf3], Fr.fromBuffer);
+  }
+}

package/src/crypto/secp256k1/index.ts

@@ -0,0 +1,57 @@
+import { BarretenbergSync } from '@aztec/bb.js';
+
+/**
+ * Secp256k1 elliptic curve operations.
+ */
+export class Secp256k1 {
+  // prettier-ignore
+  static generator = Buffer.from([
+    0x79, 0xbe, 0x66, 0x7e, 0xf9, 0xdc, 0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b, 0x07,
+    0x02, 0x9b, 0xfc, 0xdb, 0x2d, 0xce, 0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98,
+    0x48, 0x3a, 0xda, 0x77, 0x26, 0xa3, 0xc4, 0x65, 0x5d, 0xa4, 0xfb, 0xfc, 0x0e, 0x11, 0x08, 0xa8,
+    0xfd, 0x17, 0xb4, 0x48, 0xa6, 0x85, 0x54, 0x19, 0x9c, 0x47, 0xd0, 0x8f, 0xfb, 0x10, 0xd4, 0xb8,
+  ]);
+
+  /**
+   * Point generator
+   * @returns The generator for the curve.
+   */
+  public generator(): Buffer {
+    return Secp256k1.generator;
+  }
+
+  /**
+   * Multiplies a point by a scalar (adds the point `scalar` amount of time).
+   * @param point - Point to multiply.
+   * @param scalar - Scalar to multiply by.
+   * @returns Result of the multiplication.
+   */
+  public async mul(point: Uint8Array, scalar: Uint8Array) {
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const [result] = api.getWasm().callWasmExport('ecc_secp256k1__mul', [point, scalar], [64]);
+    return Buffer.from(result);
+  }
+
+  /**
+   * Gets a random field element.
+   * @returns Random field element.
+   */
+  public async getRandomFr() {
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const [result] = api.getWasm().callWasmExport('ecc_secp256k1__get_random_scalar_mod_circuit_modulus', [], [32]);
+    return Buffer.from(result);
+  }
+
+  /**
+   * Converts a 512 bits long buffer to a field.
+   * @param uint512Buf - The buffer to convert.
+   * @returns Buffer representation of the field element.
+   */
+  public async reduce512BufferToFr(uint512Buf: Buffer) {
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const [result] = api
+      .getWasm()
+      .callWasmExport('ecc_secp256k1__reduce512_buffer_mod_circuit_modulus', [uint512Buf], [32]);
+    return Buffer.from(result);
+  }
+}

package/src/crypto/secp256k1-signer/secp256k1_signer.ts

@@ -1,6 +1,6 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { type EthAddress } from '@aztec/foundation/eth-address';
-import { type Signature } from '@aztec/foundation/eth-signature';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Signature } from '@aztec/foundation/eth-signature';
 
 import { addressFromPrivateKey, makeEthSignDigest, signMessage } from './utils.js';
 

package/src/crypto/serialize.ts

@@ -0,0 +1,85 @@
+// TODO find a new home for this as we move to external bb.js
+// See https://github.com/AztecProtocol/aztec-packages/issues/782
+import { Buffer } from 'buffer';
+
+/**
+ * For serializing an array of fixed length buffers.
+ * TODO move to foundation pkg.
+ * @param arr - Array of bufffers.
+ * @returns The serialized buffers.
+ */
+export function serializeBufferArrayToVector(arr: Buffer[]) {
+  const lengthBuf = Buffer.alloc(4);
+  lengthBuf.writeUInt32BE(arr.length, 0);
+  return Buffer.concat([lengthBuf, ...arr]);
+}
+
+/**
+ * Helper function for deserializeArrayFromVector.
+ */
+type DeserializeFn<T> = (
+  buf: Buffer,
+  offset: number,
+) => {
+  /**
+   * The deserialized type.
+   */
+  elem: T;
+  /**
+   * How many bytes to advance by.
+   */
+  adv: number;
+};
+
+/**
+ * For deserializing numbers to 32-bit little-endian form.
+ * TODO move to foundation pkg.
+ * @param n - The number.
+ * @returns The endian-corrected number.
+ */
+export function deserializeArrayFromVector<T>(deserialize: DeserializeFn<T>, vector: Buffer, offset = 0) {
+  let pos = offset;
+  const size = vector.readUInt32BE(pos);
+  pos += 4;
+  const arr = new Array<T>(size);
+  for (let i = 0; i < size; ++i) {
+    const { elem, adv } = deserialize(vector, pos);
+    pos += adv;
+    arr[i] = elem;
+  }
+  return { elem: arr, adv: pos - offset };
+}
+
+/**
+ * For serializing numbers to 32 bit little-endian form.
+ * TODO move to foundation pkg.
+ * @param n - The number.
+ * @returns The endian-corrected number.
+ */
+export function numToUInt32LE(n: number, bufferSize = 4) {
+  const buf = Buffer.alloc(bufferSize);
+  buf.writeUInt32LE(n, bufferSize - 4);
+  return buf;
+}
+
+/**
+ * Deserialize the 256-bit number at address `offset`.
+ * @param buf - The buffer.
+ * @param offset - The address.
+ * @returns The derserialized 256-bit field.
+ */
+export function deserializeField(buf: Buffer, offset = 0) {
+  const adv = 32;
+  return { elem: buf.slice(offset, offset + adv), adv };
+}
+
+export function concatenateUint8Arrays(arrayOfUint8Arrays: Uint8Array[]) {
+  const totalLength = arrayOfUint8Arrays.reduce((prev, curr) => prev + curr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let length = 0;
+  for (const array of arrayOfUint8Arrays) {
+    result.set(array, length);
+    length += array.length;
+  }
+  return result;
+}

package/src/crypto/signature/index.ts

@@ -0,0 +1,17 @@
+import type { Fr } from '@aztec/foundation/fields';
+
+/**
+ * Interface to represent a signature.
+ */
+export interface Signature {
+  /**
+   * Serializes to a buffer.
+   * @returns A buffer.
+   */
+  toBuffer(): Buffer;
+  /**
+   * Serializes to an array of fields.
+   * @returns Fields.
+   */
+  toFields(): Fr[];
+}

package/src/crypto/sync/index.ts

@@ -3,4 +3,4 @@ import { BarretenbergSync } from '@aztec/bb.js';
 export * from './poseidon/index.js';
 export * from './pedersen/index.js';
 
-await BarretenbergSync.initSingleton();
+await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);

package/src/fields/coordinate.ts

@@ -1,5 +1,5 @@
 import { toBigIntBE } from '../bigint-buffer/index.js';
-import { type Tuple } from '../serialize/types.js';
+import type { Tuple } from '../serialize/types.js';
 import { Fr } from './fields.js';
 
 /**

package/src/fields/fields.ts

@@ -319,7 +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 BarretenbergSync.initSingleton()).getWasm();
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const wasm = api.getWasm();
     const [buf] = wasm.callWasmExport('bn254_fr_sqrt', [this.toBuffer()], [Fr.SIZE_IN_BYTES + 1]);
     const isSqrt = buf[0] === 1;
     if (!isSqrt) {

package/src/fs/run_in_dir.ts

@@ -1,12 +1,15 @@
 import { promises as fs } from 'fs';
 import * as path from 'path';
 
+import { createLogger } from '../log/pino-logger.js';
+
 // Create a random directory underneath a 'base' directory
 // Calls a provided method, ensures the random directory is cleaned up afterwards unless the operation fails
 export async function runInDirectory<T>(
   workingDirBase: string,
   fn: (dir: string) => Promise<T>,
   skipCleanup: boolean | undefined,
+  logger = createLogger('foundation:run-in-directory'),
 ): Promise<T> {
   // Create random directory to be used for temp files
   const workingDirectory = await fs.mkdtemp(path.join(workingDirBase, 'tmp-'));
@@ -20,7 +23,11 @@ export async function runInDirectory<T>(
     throw err;
   } finally {
     if (!skipCleanup) {
-      await fs.rm(workingDirectory, { recursive: true, force: true });
+      try {
+        await fs.rm(workingDirectory, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      } catch (err) {
+        logger.warn(`Failed to cleanup temporary directory ${workingDirectory}: ${err}`, { err });
+      }
     }
   }
 }

package/src/index.ts

@@ -1,7 +1,5 @@
 // Reexport all folders at the root for packages targeting CommonJS
-export * as abi from './abi/index.js';
 export * as asyncMap from './async-map/index.js';
-export * as aztecAddress from './aztec-address/index.js';
 export * as bigintBuffer from './bigint-buffer/index.js';
 export * as collection from './collection/index.js';
 export * as committable from './committable/index.js';

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

@@ -3,7 +3,7 @@ import { Agent, type Dispatcher } from 'undici';
 import { createLogger } from '../../log/pino-logger.js';
 import { NoRetryError } from '../../retry/index.js';
 import { jsonStringify } from '../convert.js';
-import { type JsonRpcFetch } from './fetch.js';
+import type { JsonRpcFetch } from './fetch.js';
 
 const log = createLogger('json-rpc:json_rpc_client:undici');
 

package/src/json-rpc/convert.ts

@@ -1,6 +1,6 @@
 import { Buffer } from 'buffer';
 
-import { type ZodFor } from '../schemas/types.js';
+import type { ZodFor } from '../schemas/types.js';
 
 /**
  * Parses a json string and then feeds it to a zod schema.

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

@@ -4,7 +4,7 @@ import { type default as Application, default as Koa } from 'koa';
 import bodyParser from 'koa-bodyparser';
 import compress from 'koa-compress';
 import Router from 'koa-router';
-import { type AddressInfo } from 'net';
+import type { AddressInfo } from 'net';
 import { format, inspect } from 'util';
 import { ZodError } from 'zod';
 

package/src/json-rpc/test/integration.ts

@@ -1,6 +1,6 @@
 import type http from 'http';
 
-import { type ApiSchemaFor } from '../../schemas/api.js';
+import type { ApiSchemaFor } from '../../schemas/api.js';
 import { makeFetch } from '../client/fetch.js';
 import { type SafeJsonRpcClientOptions, createSafeJsonRpcClient } from '../client/safe_json_rpc_client.js';
 import {

package/src/log/console.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-console */
-import { type LogFn } from './log_fn.js';
+import type { LogFn } from './log_fn.js';
 
 /**
  * ConsoleLogger is a utility class that provides customizable console logging functionality.

package/src/log/debug.ts

@@ -1,6 +1,6 @@
 import debug from 'debug';
 
-import { type LogFn } from './log_fn.js';
+import type { LogFn } from './log_fn.js';
 
 let preLogHook: ((...args: any[]) => void) | undefined;
 let postLogHook: ((...args: any[]) => void) | undefined;

package/src/log/gcloud-logger-config.ts

@@ -1,4 +1,4 @@
-import { type pino } from 'pino';
+import type { pino } from 'pino';
 
 /* eslint-disable camelcase */
 

package/src/log/index.ts

@@ -3,3 +3,4 @@ export * from './debug.js';
 export * from './pino-logger.js';
 export * from './log_history.js';
 export * from './log_fn.js';
+export * from './libp2p_logger.js';

package/src/log/libp2p_logger.ts

@@ -0,0 +1,67 @@
+import type { ComponentLogger, Logger } from '@libp2p/interface';
+
+import { getLogLevelFromFilters } from './log-filters.js';
+import type { LogLevel } from './log-levels.js';
+import { logFilters, logger } from './pino-logger.js';
+
+/**
+ * Creates a libp2p compatible logger that wraps our pino logger.
+ * This adapter implements the ComponentLogger interface required by libp2p.
+ */
+export function createLibp2pComponentLogger(namespace: string): ComponentLogger {
+  return {
+    forComponent: (component: string) => createLibp2pLogger(`${namespace}:${component}`),
+  };
+}
+
+// Lipp2p libraries use arbitrary string substitutions, so we need to replace them with %s, this is slow so avoid doing it unless trace debugging
+function replaceFormatting(message: string) {
+  // Message can sometimes not be a string, e.g. an error object, just return it as is
+  if (!message?.replace) {
+    return message;
+  }
+
+  return message.replace(/(%p|%a)/g, '%s');
+}
+
+function createLibp2pLogger(component: string): Logger {
+  // Create a direct pino logger instance for libp2p that supports string interpolation
+  const log = logger.child({ module: component }, { level: getLogLevelFromFilters(logFilters, component) });
+
+  const logIfEnabled = (level: LogLevel, message: string, ...args: unknown[]) => {
+    if (!log.isLevelEnabled(level)) {
+      return;
+    }
+
+    log[level](replaceFormatting(message), ...args);
+  };
+
+  // Default log level is trace as this is super super noisy
+  const logFn = (message: string, ...args: unknown[]) => {
+    logIfEnabled('trace', message, ...args);
+  };
+
+  return Object.assign(logFn, {
+    enabled: log.isLevelEnabled('debug'),
+    error(message: string, ...args: unknown[]) {
+      // We write error outputs as debug as they are often expected, e.g. connection errors can happen in happy paths
+      logIfEnabled('debug', message, ...args);
+    },
+
+    debug(message: string, ...args: unknown[]) {
+      logIfEnabled('debug', message, ...args);
+    },
+
+    info(message: string, ...args: unknown[]) {
+      logIfEnabled('info', message, ...args);
+    },
+
+    warn(message: string, ...args: unknown[]) {
+      logIfEnabled('warn', message, ...args);
+    },
+
+    trace(message: string, ...args: unknown[]) {
+      logIfEnabled('trace', message, ...args);
+    },
+  });
+}

package/src/log/pino-logger.ts

@@ -1,33 +1,24 @@
 import { createColors, isColorSupported } from 'colorette';
 import isNode from 'detect-node';
 import { pino, symbols } from 'pino';
-import { type Writable } from 'stream';
+import type { Writable } from 'stream';
 import { inspect } from 'util';
 
 import { compactArray } from '../collection/array.js';
 import { type EnvVar, parseBooleanEnv } from '../config/index.js';
 import { GoogleCloudLoggerConfig } from './gcloud-logger-config.js';
 import { getLogLevelFromFilters, parseEnv } from './log-filters.js';
-import { type LogLevel } from './log-levels.js';
-import { type LogData, type LogFn } from './log_fn.js';
+import type { LogLevel } from './log-levels.js';
+import type { LogData, LogFn } from './log_fn.js';
 
-export function createLogger(module: string, fixedTerms = {}): Logger {
+export function createLogger(module: string): Logger {
   module = logNameHandlers.reduce((moduleName, handler) => handler(moduleName), module.replace(/^aztec:/, ''));
   const pinoLogger = logger.child({ module }, { level: getLogLevelFromFilters(logFilters, module) });
 
-  // Only perform copy of data if fixed terms are provided
-  const hasFixedTerms = Object.keys(fixedTerms).length > 0;
-
   // We check manually for isLevelEnabled to avoid calling processLogData unnecessarily.
   // Note that isLevelEnabled is missing from the browser version of pino.
   const logFn = (level: LogLevel, msg: string, data?: unknown) =>
-    isLevelEnabled(pinoLogger, level) &&
-    pinoLogger[level](
-      hasFixedTerms
-        ? processLogData({ ...fixedTerms, ...(data ?? {}) } as LogData)
-        : processLogData((data as LogData) ?? {}),
-      msg,
-    );
+    isLevelEnabled(pinoLogger, level) && pinoLogger[level](processLogData((data as LogData) ?? {}), msg);
 
   return {
     silent: () => {},
@@ -83,6 +74,15 @@ export function removeLogNameHandler(handler: LogNameHandler) {
   }
 }
 
+/** Creates all loggers within the given callback with the suffix appended to the module name. */
+export async function withLogNameSuffix<T>(suffix: string, callback: () => Promise<T>): Promise<T> {
+  const logNameHandler = (module: string) => `${module}:${suffix}`;
+  addLogNameHandler(logNameHandler);
+  const result = await callback();
+  removeLogNameHandler(logNameHandler);
+  return result;
+}
+
 // Patch isLevelEnabled missing from pino/browser.
 function isLevelEnabled(logger: pino.Logger<'verbose', boolean>, level: LogLevel): boolean {
   return typeof logger.isLevelEnabled === 'function'
@@ -92,7 +92,7 @@ function isLevelEnabled(logger: pino.Logger<'verbose', boolean>, level: LogLevel
 
 // Load log levels from environment variables.
 const defaultLogLevel = process.env.NODE_ENV === 'test' ? 'silent' : 'info';
-const [logLevel, logFilters] = parseEnv(process.env.LOG_LEVEL, defaultLogLevel);
+export const [logLevel, logFilters] = parseEnv(process.env.LOG_LEVEL, defaultLogLevel);
 
 // Define custom logging levels for pino.
 const customLevels = { verbose: 25 };
@@ -178,7 +178,7 @@ function makeLogger() {
   }
 }
 
-const logger = makeLogger();
+export const logger = makeLogger();
 
 // Log the logger configuration.
 logger.verbose(

package/src/mutex/index.ts

@@ -1,4 +1,4 @@
-import { type MutexDatabase } from './mutex_database.js';
+import type { MutexDatabase } from './mutex_database.js';
 
 export * from './mutex_database.js';