@aztec/foundation 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/profiler/profiler.ts

@@ -0,0 +1,125 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { performance } from 'node:perf_hooks';
+
+interface Span {
+  label: string;
+  start: number;
+  dur: number;
+  count: number;
+  children: Span[];
+  parent: Span | undefined;
+}
+
+interface ProfileData {
+  spans: SerializedSpan[];
+  timestamp: string;
+  totalTime: number;
+}
+
+interface SerializedSpan {
+  label: string;
+  dur: number;
+  count: number;
+  children: SerializedSpan[];
+}
+
+const als = new AsyncLocalStorage<Span>();
+const roots: Span[] = [];
+
+function reset(): void {
+  roots.length = 0;
+}
+
+// Strip out circular references (parent) and unused fields (start) for JSON serialization
+function serializeSpans(spans: Span[]): SerializedSpan[] {
+  return spans.map(span => ({
+    label: span.label,
+    dur: span.dur,
+    count: span.count,
+    children: serializeSpans(span.children),
+  }));
+}
+
+let i = 0;
+function save(): void {
+  if (roots.length === 0) {
+    return;
+  }
+
+  // Find max single execution time across all spans (dur/count since dur is accumulated)
+  const findMaxSingleDuration = (spans: Span[]): number => {
+    let max = 0;
+    for (const span of spans) {
+      const singleDur = span.dur / span.count;
+      max = Math.max(max, singleDur);
+      if (span.children.length > 0) {
+        max = Math.max(max, findMaxSingleDuration(span.children));
+      }
+    }
+    return max;
+  };
+
+  const profileData: ProfileData = {
+    spans: serializeSpans(roots),
+    timestamp: new Date().toISOString(),
+    totalTime: findMaxSingleDuration(roots),
+  };
+
+  const profilePath = path.join(process.cwd(), `profile-${i++}.json`);
+  process.stdout.write(`Writing profile data to ${profilePath}\n`);
+  fs.writeFileSync(profilePath, JSON.stringify(profileData, null, 2));
+}
+
+// Hook into Jest to save after each test
+if (typeof afterEach === 'function') {
+  afterEach(() => {
+    save();
+    reset();
+  });
+}
+
+// Also save on process exit for non-Jest environments
+process.on('exit', () => {
+  save();
+});
+
+// Wrapper for async functions to maintain context properly
+async function runAsync<ReturnType>(label: string, fn: () => Promise<ReturnType>): Promise<ReturnType> {
+  const parent = als.getStore();
+
+  // Check if we already have a span with this label in the current context
+  let existingSpan: Span | undefined;
+  if (parent) {
+    existingSpan = parent.children.find(c => c.label === label);
+  } else {
+    existingSpan = roots.find(r => r.label === label);
+  }
+
+  let span: Span;
+  if (existingSpan) {
+    // Reuse existing span and increment count
+    span = existingSpan;
+    span.count++;
+  } else {
+    // Create new span
+    span = { label, start: performance.now(), dur: 0, count: 1, children: [], parent };
+    if (parent) {
+      parent.children.push(span);
+    } else {
+      roots.push(span);
+    }
+  }
+
+  const startTime = performance.now();
+  const result: ReturnType = await als.run(span, fn);
+  const elapsed = performance.now() - startTime;
+
+  // Add to total duration (for averaging)
+  span.dur += elapsed;
+
+  return result;
+}
+
+export const profiler = { reset, runAsync };

package/src/promise/running-promise.ts

@@ -43,7 +43,7 @@ export class RunningPromise {
   public start() {
     if (this.running) {
       this.logger.warn(`Attempted to start running promise that was already started`);
-      return;
+      return this;
     }
     this.running = true;
 
@@ -73,6 +73,7 @@ export class RunningPromise {
       }
     };
     this.runningPromise = poll();
+    return this;
   }
 
   /**
@@ -81,7 +82,6 @@ export class RunningPromise {
    */
   async stop(): Promise<void> {
     if (!this.running) {
-      this.logger.warn(`Running promise was not started`);
       return;
     }
     this.running = false;

package/src/queue/batch_queue.ts

@@ -13,7 +13,7 @@ type Batch<T, K> = {
  * A queue that groups items into batches based on a group key.
  *
  * The batching algorithm is greedy, meaning that as long as consecutive items have the same group key then they will
- * be batvched together. As soon as an item with a different group key is encountered, the old batch is flushed to the
+ * be batched together. As soon as an item with a different group key is encountered, the old batch is flushed to the
  * queue and a new batch is started.
  *
  * A batch can also be flushed to the queue if:

package/src/queue/bounded_serial_queue.ts

@@ -10,7 +10,10 @@ export class BoundedSerialQueue {
   private readonly queue = new SerialQueue();
   private semaphore: Semaphore;
 
-  constructor(maxQueueSize: number, private log = createLogger('foundation:bounded_serial_queue')) {
+  constructor(
+    maxQueueSize: number,
+    private log = createLogger('foundation:bounded_serial_queue'),
+  ) {
     this.semaphore = new Semaphore(maxQueueSize);
   }
 

package/src/queue/serial_queue.ts

@@ -5,7 +5,7 @@ import { FifoMemoryQueue } from './fifo_memory_queue.js';
  */
 export class SerialQueue {
   private readonly queue = new FifoMemoryQueue<() => Promise<void>>();
-  private runningPromise!: Promise<void>;
+  private runningPromises: Promise<void>[] = [];
   private started = false;
 
   /**
@@ -14,11 +14,11 @@ export class SerialQueue {
    * waiting for the completion of the previous one before starting its execution.
    * This method should be called once to start processing the queue.
    */
-  public start() {
+  public start(numWorkers = 1) {
     if (this.started) {
       return;
     }
-    this.runningPromise = this.queue.process(fn => fn());
+    this.runningPromises = Array.from({ length: numWorkers }, () => this.queue.process(fn => fn()));
     this.started = true;
   }
 
@@ -41,7 +41,7 @@ export class SerialQueue {
    */
   public cancel() {
     this.queue.cancel();
-    return this.runningPromise;
+    return Promise.all(this.runningPromises).then(() => {});
   }
 
   /**
@@ -52,7 +52,7 @@ export class SerialQueue {
    */
   public end() {
     this.queue.end();
-    return this.runningPromise;
+    return Promise.all(this.runningPromises).then(() => {});
   }
 
   /**

package/src/retry/index.ts

@@ -1,5 +1,5 @@
 import { TimeoutError } from '../error/index.js';
-import { createLogger } from '../log/index.js';
+import { type Logger, createLogger } from '../log/index.js';
 import { sleep } from '../sleep/index.js';
 import { Timer } from '../timer/index.js';
 
@@ -49,7 +49,7 @@ export async function retry<Result>(
   fn: () => Promise<Result>,
   name = 'Operation',
   backoff = backoffGenerator(),
-  log = createLogger('foundation:retry'),
+  log: Logger = createLogger('foundation:retry'),
   failSilently = false,
 ) {
   while (true) {
@@ -64,8 +64,8 @@ export async function retry<Result>(
       if (s === undefined) {
         throw err;
       }
-      log.verbose(`${name} failed. Will retry in ${s}s...`);
-      !failSilently && log.error(`Error while retrying ${name}`, err);
+      log?.debug(`${name} failed. Will retry in ${s}s...`);
+      !failSilently && log?.error(`Error while retrying ${name}`, err);
       await sleep(s * 1000);
       continue;
     }
@@ -83,7 +83,12 @@ export async function retry<Result>(
  * @param interval - The optional interval, in seconds, between retry attempts. Defaults to 1 second.
  * @returns A Promise that resolves with the successful (truthy) result of the provided function, or rejects if timeout is exceeded.
  */
-export async function retryUntil<T>(fn: () => Promise<T | undefined>, name = '', timeout = 0, interval = 1) {
+export async function retryUntil<T>(
+  fn: () => (T | undefined) | Promise<T | undefined>,
+  name = '',
+  timeout = 0,
+  interval = 1,
+) {
   const timer = new Timer();
   while (true) {
     const result = await fn();

package/src/schemas/api.ts

@@ -19,10 +19,10 @@ type ZodReturnTypeFor<T> = z.ZodType<T, z.ZodTypeDef, any>;
 type ZodMapParameterTypes<T> = T extends []
   ? []
   : T extends [item: infer Head, ...infer Rest]
-  ? [ZodParameterTypeFor<Head>, ...{ [K in keyof Rest]: ZodParameterTypeFor<Rest[K]> }]
-  : T extends [item?: infer Head, ...infer Rest]
-  ? [ZodNullableOptional<ZodParameterTypeFor<Head>>, ...{ [K in keyof Rest]: ZodParameterTypeFor<Rest[K]> }]
-  : never;
+    ? [ZodParameterTypeFor<Head>, ...{ [K in keyof Rest]: ZodParameterTypeFor<Rest[K]> }]
+    : T extends [item?: infer Head, ...infer Rest]
+      ? [ZodNullableOptional<ZodParameterTypeFor<Head>>, ...{ [K in keyof Rest]: ZodParameterTypeFor<Rest[K]> }]
+      : never;
 
 /** Maps all functions in an interface to their schema representation. */
 export type ApiSchemaFor<T> = {

package/src/schemas/parse.ts

@@ -22,7 +22,7 @@ export function parseWithOptionals<T extends z.AnyZodTuple>(args: any[], schema:
 function isOptional(schema: z.ZodTypeAny) {
   try {
     return schema.isOptional();
-  } catch (err) {
+  } catch {
     // See https://github.com/colinhacks/zod/issues/1911
     return schema._def.typeName === 'ZodOptional';
   }

package/src/schemas/schemas.ts

@@ -1,13 +1,22 @@
 import { z } from 'zod';
 
+import { EpochNumber, EpochNumberSchema } from '../branded-types/epoch.js';
+import { SlotNumber, SlotNumberSchema } from '../branded-types/slot.js';
 import { Buffer32 } from '../buffer/buffer32.js';
+import { SecretValue } from '../config/secret_value.js';
+import { Fq, Fr } from '../curves/bn254/field.js';
+import { Point } from '../curves/grumpkin/point.js';
 import { EthAddress } from '../eth-address/index.js';
-import { Fq, Fr } from '../fields/fields.js';
-import { Point } from '../fields/point.js';
-import { isHex, withoutHexPrefix } from '../string/index.js';
+import { isHex, withHexPrefix, withoutHexPrefix } from '../string/index.js';
 import { bufferSchema, hexSchema } from './utils.js';
 
 export const schemas = {
+  /** Accepts a number, bigint, or string as an EpochNumber. */
+  EpochNumber: EpochNumberSchema,
+
+  /** Accepts a number, bigint, or string as a SlotNumber. */
+  SlotNumber: SlotNumberSchema,
+
   /** Accepts a hex string. */
   EthAddress: EthAddress.schema,
 
@@ -20,6 +29,20 @@ export const schemas = {
   /** Point. Serialized as a hex string. */
   Point: Point.schema,
 
+  /** Coerces truthy-like string values to boolean. */
+  Boolean: z.union([
+    z.boolean(),
+    z
+      .number()
+      .refine(arg => arg === 0 || arg === 1, { message: `Numeric value for a boolean variable must be 0 or 1` })
+      .transform(arg => arg === 1),
+    z
+      .string()
+      .transform(arg => arg.trim().toLowerCase())
+      .refine(arg => ['true', 'false', '1', '0'].includes(arg))
+      .transform(arg => arg === '1' || arg === 'true'),
+  ]),
+
   /** Coerces any input to bigint. */
   BigInt: z.union([z.bigint(), z.number(), z.string()]).pipe(z.coerce.bigint()),
 
@@ -35,19 +58,19 @@ export const schemas = {
       .max(2 ** 32 - 1),
   ),
 
+  /** Coerces input to UInt64. */
+  UInt64: z.union([z.bigint(), z.number(), z.string()]).pipe(
+    z.coerce
+      .bigint()
+      .min(0n)
+      .max(2n ** 64n - 1n),
+  ),
+
   /** Accepts a hex string as a Buffer32 type. */
   Buffer32: z.string().refine(isHex, 'Not a valid hex string').transform(Buffer32.fromString),
 
   /** Accepts a base64 string or an object `{ type: 'Buffer', data: [byte, byte...] }` as a buffer. */
-  Buffer: z.union([
-    bufferSchema,
-    z
-      .object({
-        type: z.literal('Buffer'),
-        data: z.array(z.number().int().min(0).max(255)),
-      })
-      .transform(({ data }) => Buffer.from(data)),
-  ]),
+  Buffer: bufferSchema,
 
   /** Accepts a hex string as a buffer. */
   BufferHex: z
@@ -58,7 +81,13 @@ export const schemas = {
 
   /** Hex string with an optional 0x prefix which gets removed as part of the parsing. */
   HexString: hexSchema,
+
+  /** Hex string with an optional 0x prefix which gets enforced as part of the parsing. */
+  HexStringWith0x: z.string().refine(isHex, 'Not a valid hex string').transform(withHexPrefix),
+
+  /** A secret config value */
+  SecretValue: SecretValue.schema,
 };
 
 // These are needed to avoid errors such as: "The inferred type of 'YourClassSchema' cannot be named without a reference to..."
-export type { EthAddress, Point, Fr, Fq };
+export type { EpochNumber, EthAddress, Fq, Fr, Point, SlotNumber };

package/src/schemas/types.ts

@@ -1,3 +1,36 @@
 import type { ZodType } from 'zod';
 
 export type ZodFor<T> = ZodType<T, any, any>;
+
+/**
+ * Creates a schema validator that enforces all properties of type T are present in the schema.
+ * This provides compile-time safety to ensure schemas don't miss optional properties.
+ *
+ * @example
+ * ```ts
+ * interface MyConfig {
+ *   foo: string;
+ *   bar?: number;
+ * }
+ *
+ * // ✅ This will work - all keys present
+ * const schema1 = zodFor<MyConfig>()(z.object({
+ *   foo: z.string(),
+ *   bar: z.number().optional(),
+ * }));
+ *
+ * // ❌ This will error - 'bar' is missing
+ * const schema2 = zodFor<MyConfig>()(z.object({
+ *   foo: z.string(),
+ * }));
+ * ```
+ */
+export function zodFor<T>() {
+  return (schema => schema) as <S extends ZodType<any, any, any>>(
+    schema: keyof T extends keyof S['_output']
+      ? keyof S['_output'] extends keyof T
+        ? S
+        : S & { __error__: 'Schema has extra keys not in type'; __extra__: Exclude<keyof S['_output'], keyof T> }
+      : S & { __error__: 'Schema is missing keys from type'; __missing__: Exclude<keyof T, keyof S['_output']> },
+  ) => S;
+}

package/src/schemas/utils.ts

@@ -21,13 +21,25 @@ export const hexSchema = z.string().refine(isHex, 'Not a valid hex string').tran
 // Copied from zod internals, which was copied from https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript
 const base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
 
-/** Schema for a buffer represented as a base64 string. */
-export const bufferSchema = z
-  .string()
-  // We only test the str for base64 if it's shorter than 1024 bytes, otherwise we've run into maximum
-  // stack size exceeded errors when trying to validate excessively long strings (such as contract bytecode).
-  .refine(str => str.length > 1024 || base64Regex.test(str), 'Not a valid base64 string')
-  .transform(data => Buffer.from(data, 'base64'));
+/** Schema for a buffer represented as a base64 string or a Buffer object. */
+export const bufferSchema: ZodFor<Buffer> = z.union([
+  // Serialization from base64 string.
+  z
+    .string()
+    // We only test the str for base64 if it's shorter than 1024 bytes, otherwise we've run into maximum
+    // stack size exceeded errors when trying to validate excessively long strings (such as contract bytecode).
+    .refine(str => str.length > 1024 || base64Regex.test(str), 'Not a valid base64 string')
+    .transform(data => Buffer.from(data, 'base64')),
+  // Serialization from Buffer-annotated object.
+  z
+    .object({
+      type: z.literal('Buffer'),
+      data: z.array(z.number().int().min(0).max(255)),
+    })
+    .transform(({ data }) => Buffer.from(data)),
+  // Serialization from Buffer
+  z.instanceof(Buffer),
+]);
 
 export class ZodNullableOptional<T extends ZodTypeAny> extends ZodOptional<T> {
   _isNullableOptional = true;
@@ -88,12 +100,13 @@ export function hexSchemaFor<TClass extends { fromString(str: string): any } | {
  */
 export function bufferSchemaFor<TClass extends { fromBuffer(buf: Buffer): any }>(
   klazz: TClass,
+  refinement?: (buf: Buffer) => boolean,
 ): ZodType<
   TClass extends { fromBuffer(buf: Buffer): infer TInstance } ? ToJsonIs<TInstance, Buffer> : never,
   any,
   string
 > {
-  return bufferSchema.transform(klazz.fromBuffer.bind(klazz));
+  return bufferSchema.refine(refinement ?? (() => true), 'Not a valid buffer').transform(klazz.fromBuffer.bind(klazz));
 }
 
 /** Creates a schema for a js Map type that matches the serialization used in jsonStringify. */

package/src/serialize/buffer_reader.ts

@@ -19,7 +19,10 @@ import type { Tuple } from './types.js';
  */
 export class BufferReader {
   private index: number;
-  constructor(private buffer: Buffer, offset = 0) {
+  constructor(
+    private buffer: Buffer,
+    offset = 0,
+  ) {
     this.index = offset;
   }
 
@@ -70,6 +73,43 @@ export class BufferReader {
     return result as Tuple<number, N>;
   }
 
+  /**
+   * Reads a 256-bit unsigned integer from the buffer at the current index position.
+   * Updates the index position by 32 bytes after reading the number.
+   *
+   * Assumes the number is stored in big-endian format.
+   *
+   * @returns The read 256 bit value as a bigint.
+   */
+  public readUInt64(): bigint {
+    this.#rangeCheck(8);
+
+    const result = this.buffer.readBigUInt64BE(this.index);
+
+    this.index += 8;
+    return result;
+  }
+
+  /**
+   * Reads a 128-bit unsigned integer from the buffer at the current index position.
+   * Updates the index position by 16 bytes after reading the number.
+   *
+   * Assumes the number is stored in big-endian format.
+   *
+   * @returns The read 128 bit value as a bigint.
+   */
+  public readUInt128(): bigint {
+    this.#rangeCheck(16);
+
+    let result = BigInt(0);
+    for (let i = 0; i < 2; i++) {
+      result = (result << BigInt(64)) | this.buffer.readBigUInt64BE(this.index + i * 8);
+    }
+
+    this.index += 16;
+    return result;
+  }
+
   /**
    * Reads a 256-bit unsigned integer from the buffer at the current index position.
    * Updates the index position by 32 bytes after reading the number.
@@ -82,14 +122,19 @@ export class BufferReader {
     this.#rangeCheck(32);
 
     let result = BigInt(0);
-    for (let i = 0; i < 32; i++) {
-      result = (result << BigInt(8)) | BigInt(this.buffer[this.index + i]);
+    for (let i = 0; i < 4; i++) {
+      result = (result << BigInt(64)) | this.buffer.readBigUInt64BE(this.index + i * 8);
     }
 
     this.index += 32;
     return result;
   }
 
+  /** Alias for readUInt256 */
+  public readBigInt(): bigint {
+    return this.readUInt256();
+  }
+
   /**
    * Reads a 16-bit unsigned integer from the buffer at the current index position.
    * Updates the index position by 2 bytes after reading the number.
@@ -160,6 +205,18 @@ export class BufferReader {
     });
   }
 
+  /**
+   * Reads a vector of 256-bit unsigned integers from the buffer and returns it as an array of bigints.
+   * The method utilizes the 'readVector' method, passing a deserializer that reads bigints.
+   *
+   * @returns An array of bigints representing the vector read from the buffer.
+   */
+  public readUint256Vector(): bigint[] {
+    return this.readVector({
+      fromBuffer: (reader: BufferReader) => reader.readUInt256(),
+    });
+  }
+
   /**
    * Reads a vector of fixed size from the buffer and deserializes its elements using the provided itemDeserializer object.
    * The 'itemDeserializer' object should have a 'fromBuffer' method that takes a BufferReader instance and returns the deserialized element.

package/src/serialize/field_reader.ts

@@ -1,4 +1,4 @@
-import { Fq, type Fr } from '../fields/fields.js';
+import { Fq, type Fr } from '../curves/bn254/field.js';
 import type { Tuple } from './types.js';
 
 /**
@@ -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.
    *
@@ -121,6 +129,22 @@ export class FieldReader {
     return Number(value);
   }
 
+  /**
+   * Reads a 64-bit unsigned integer from the field array at the current index position.
+   * Updates the index position by 1 after reading the number.
+   * Throw if the value is greater than 2 ** 64.
+   *
+   * @returns The read 64-bit unsigned integer value as a bigint.
+   */
+  public readU64(): bigint {
+    const field = this.readField();
+    const value = field.toBigInt();
+    if (value >= 1n << 64n) {
+      throw new Error('Field is not a u64.');
+    }
+    return value;
+  }
+
   /**
    * Read an array of a fixed size field array.
    *

package/src/serialize/free_funcs.ts

@@ -1,4 +1,5 @@
-import { Fr } from '../fields/fields.js';
+import { toBufferBE } from '../bigint-buffer/index.js';
+import { Fr } from '../curves/bn254/field.js';
 import type { Tuple } from './types.js';
 
 /**
@@ -56,6 +57,30 @@ 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;
+}
+
+/**
+ * Convert a bigint to a big-endian unsigned 128-bit integer Buffer.
+ *
+ * @param n - The bigint to be converted to a big-endian unsigned 128-bit integer Buffer.
+ * @param bufferSize - Optional, the size of the output Buffer (default is 16).
+ * @returns A Buffer containing the big-endian unsigned 128-bit integer representation of the input number.
+ */
+export function bigintToUInt128BE(n: bigint, bufferSize = 16) {
+  return toBufferBE(n, bufferSize);
+}
+
 /**
  * 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
@@ -160,37 +185,6 @@ export function truncateAndPad(buf: Buffer): Buffer {
   return Buffer.concat([Buffer.alloc(1), buf.subarray(0, 31)]);
 }
 
-/**
- * Stores 248 bits of information in 1 field.
- * @param buf - 32 or 31 bytes of data
- * @returns 1 field element
- */
-export function toTruncField(buf: Buffer): Fr {
-  if (buf.length !== 32 && buf.length !== 31) {
-    throw new Error('Buffer must be 31 or 32 bytes');
-  }
-  if ((buf.length == 32 && buf[0] == 0) || buf.length == 31) {
-    return Fr.fromBuffer(buf);
-  } else {
-    // Note: safer to NOT truncate here, all inputs are expected to be truncated
-    // from Noir or L1 Contracts or Class.hash() methods
-    throw new Error(`Number ${toBigInt(buf)} does not fit in 31 byte truncated buffer`);
-  }
-}
-
-/**
- * Reconstructs the original 31 bytes of data from 1 truncated field element.
- * @param field - field element
- * @returns 31 bytes of data as a Buffer
- */
-export function fromTruncField(field: Fr): Buffer {
-  const buffer = field.toBuffer();
-  if (buffer[0] != 0) {
-    throw new Error(`Number ${field} does not fit in 31 byte truncated buffer`);
-  }
-  return buffer;
-}
-
 export function fromFieldsTuple(fields: Tuple<Fr, 2>): Buffer {
   return from2Fields(fields[0], fields[1]);
 }