@aztec/foundation 0.16.3 → 0.16.5

package/src/retry/index.ts

@@ -1,99 +0,0 @@
-import { createDebugLogger } from '../log/index.js';
-import { sleep } from '../sleep/index.js';
-import { Timer } from '../timer/index.js';
-
-/** An error that indicates that the operation should not be retried. */
-export class NoRetryError extends Error {}
-
-/**
- * Generates a backoff sequence for retrying operations with an increasing delay.
- * The backoff sequence follows this pattern: 1, 1, 1, 2, 4, 8, 16, 32, 64, ...
- * This generator can be used in combination with the `retry` function to perform
- * retries with exponential backoff and capped at 64 seconds between attempts.
- *
- * @returns A generator that yields the next backoff value in seconds as an integer.
- */
-export function* backoffGenerator() {
-  const v = [1, 1, 1, 2, 4, 8, 16, 32, 64];
-  let i = 0;
-  while (true) {
-    yield v[Math.min(i++, v.length - 1)];
-  }
-}
-
-/**
- * Generates a backoff sequence based on the array of retry intervals to use with the `retry` function.
- * @param retries - Intervals to retry (in seconds).
- * @returns A generator sequence.
- */
-export function* makeBackoff(retries: number[]) {
-  for (const retry of retries) {
-    yield retry;
-  }
-}
-
-/**
- * Retry a given asynchronous function with a specific backoff strategy, until it succeeds or backoff generator ends.
- * It logs the error and retry interval in case an error is caught. The function can be named for better log output.
- *
- * @param fn - The asynchronous function to be retried.
- * @param name - The optional name of the operation, used for logging purposes.
- * @param backoff - The optional backoff generator providing the intervals in seconds between retries. Defaults to a predefined series.
- * @param log - Logger to use for logging.
- * @param failSilently - Do not log errors while retrying.
- * @returns A Promise that resolves with the successful result of the provided function, or rejects if backoff generator ends.
- * @throws If `NoRetryError` is thrown by the `fn`, it is rethrown.
- */
-export async function retry<Result>(
-  fn: () => Promise<Result>,
-  name = 'Operation',
-  backoff = backoffGenerator(),
-  log = createDebugLogger('aztec:foundation:retry'),
-  failSilently = false,
-) {
-  while (true) {
-    try {
-      return await fn();
-    } catch (err: any) {
-      if (err instanceof NoRetryError) {
-        // A special error that indicates that the operation should not be retried. Rethrow it.
-        throw err;
-      }
-      const s = backoff.next().value;
-      if (s === undefined) {
-        throw err;
-      }
-      log(`${name} failed. Will retry in ${s}s...`);
-      !failSilently && log.error(err);
-      await sleep(s * 1000);
-      continue;
-    }
-  }
-}
-
-/**
- * Retry an asynchronous function until it returns a truthy value or the specified timeout is exceeded.
- * The function is retried periodically with a fixed interval between attempts. The operation can be named for better error messages.
- * Will never timeout if the value is 0.
- *
- * @param fn - The asynchronous function to be retried, which should return a truthy value upon success or undefined otherwise.
- * @param name - The optional name of the operation, used for generating timeout error message.
- * @param timeout - The optional maximum time, in seconds, to keep retrying before throwing a timeout error. Defaults to 0 (never timeout).
- * @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) {
-  const timer = new Timer();
-  while (true) {
-    const result = await fn();
-    if (result) {
-      return result;
-    }
-
-    await sleep(interval * 1000);
-
-    if (timeout && timer.s() > timeout) {
-      throw new Error(name ? `Timeout awaiting ${name}` : 'Timeout');
-    }
-  }
-}

package/src/running-promise/index.ts

@@ -1,60 +0,0 @@
-/**
- * RunningPromise is a utility class that helps manage the execution of an asynchronous function
- * at a specified polling interval. It allows starting, stopping, and checking the status of the
- * internally managed promise. The class also supports interrupting the polling process when stopped.
- */
-export class RunningPromise {
-  private running = false;
-  private runningPromise = Promise.resolve();
-  private interruptPromise = Promise.resolve();
-  private interruptResolve = () => {};
-  constructor(private fn: () => Promise<void>, private pollingInterval = 10000) {}
-
-  /**
-   * Starts the running promise.
-   */
-  public start() {
-    this.running = true;
-    this.interruptPromise = new Promise(resolve => (this.interruptResolve = resolve));
-
-    const poll = async () => {
-      while (this.running) {
-        await this.fn();
-        await this.interruptibleSleep(this.pollingInterval);
-      }
-    };
-    this.runningPromise = poll();
-  }
-
-  /**
-   * Stops the running promise, resolves any pending interruptible sleep,
-   * and waits for the currently executing function to complete.
-   */
-  async stop(): Promise<void> {
-    this.running = false;
-    this.interruptResolve();
-    await this.runningPromise;
-  }
-
-  /**
-   * A sleep function that can be interrupted before the specified time.
-   * The sleep duration is determined by 'timeInMs', and it can be terminated early if the 'interruptPromise' is resolved.
-   * @param timeInMs - The time in milliseconds.
-   */
-  private async interruptibleSleep(timeInMs: number) {
-    let timeout!: NodeJS.Timeout;
-    const sleepPromise = new Promise(resolve => {
-      timeout = setTimeout(resolve, timeInMs);
-    });
-    await Promise.race([sleepPromise, this.interruptPromise]);
-    clearTimeout(timeout);
-  }
-
-  /**
-   * Checks if the running promise is currently active.
-   * @returns True if the promise is running.
-   */
-  public isRunning() {
-    return this.running;
-  }
-}

package/src/serialize/buffer_reader.ts

@@ -1,250 +0,0 @@
-import { Tuple } from './types.js';
-
-/**
- * The BufferReader class provides a utility for reading various data types from a buffer.
- * It supports reading numbers, booleans, byte arrays, Fr and Fq field elements,
- * vectors, arrays, objects, strings, and maps. It maintains an internal index to
- * keep track of the current reading position in the buffer.
- *
- * Usage:
- * Create a new instance of BufferReader with a buffer and an optional offset.
- * Use the provided methods to read desired data types from the buffer.
- * The reading methods automatically advance the internal index.
- *
- * @example
- * const reader = new BufferReader(someBuffer);
- * const num = reader.readNumber();
- * const bool = reader.readBoolean();
- * const byteArray = reader.readBytes(4);
- */
-export class BufferReader {
-  private index: number;
-  constructor(private buffer: Buffer, offset = 0) {
-    this.index = offset;
-  }
-
-  /**
-   * Creates a BufferReader instance from either a Buffer or an existing BufferReader.
-   * If the input is a Buffer, it creates a new BufferReader with the given buffer.
-   * If the input is already a BufferReader, it returns the input unchanged.
-   *
-   * @param bufferOrReader - A Buffer or BufferReader to initialize the BufferReader.
-   * @returns An instance of BufferReader.
-   */
-  public static asReader(bufferOrReader: Buffer | BufferReader) {
-    return Buffer.isBuffer(bufferOrReader) ? new BufferReader(bufferOrReader) : bufferOrReader;
-  }
-
-  /**
-   * Reads a 32-bit unsigned integer from the buffer at the current index position.
-   * Updates the index position by 4 bytes after reading the number.
-   *
-   * @returns The read 32-bit unsigned integer value.
-   */
-  public readNumber(): number {
-    this.index += 4;
-    return this.buffer.readUint32BE(this.index - 4);
-  }
-
-  /**
-   * 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.
-   *
-   * @returns The read 16 bit value.
-   */
-  public readUInt16(): number {
-    this.index += 2;
-    return this.buffer.readUInt16BE(this.index - 2);
-  }
-
-  /**
-   * Reads and returns the next boolean value from the buffer.
-   * Advances the internal index by 1, treating the byte at the current index as a boolean value.
-   * Returns true if the byte is non-zero, false otherwise.
-   *
-   * @returns A boolean value representing the byte at the current index.
-   */
-  public readBoolean(): boolean {
-    this.index += 1;
-    return Boolean(this.buffer.at(this.index - 1));
-  }
-
-  /**
-   * Reads a specified number of bytes from the buffer and returns a new Buffer containing those bytes.
-   * Advances the reader's index by the number of bytes read. Throws an error if there are not enough
-   * bytes left in the buffer to satisfy the requested number of bytes.
-   *
-   * @param n - The number of bytes to read from the buffer.
-   * @returns A new Buffer containing the read bytes.
-   */
-  public readBytes(n: number): Buffer {
-    this.index += n;
-    return Buffer.from(this.buffer.subarray(this.index - n, this.index));
-  }
-
-  /**
-   * Reads a vector of numbers from the buffer and returns it as an array of numbers.
-   * The method utilizes the 'readVector' method, passing a deserializer that reads numbers.
-   *
-   * @returns An array of numbers representing the vector read from the buffer.
-   */
-  public readNumberVector(): number[] {
-    return this.readVector({
-      fromBuffer: (reader: BufferReader) => reader.readNumber(),
-    });
-  }
-
-  /**
-   * 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.
-   * The method first reads the size of the vector (a number) from the buffer, then iterates through its elements,
-   * deserializing each one using the 'fromBuffer' method of 'itemDeserializer'.
-   *
-   * @param itemDeserializer - Object with 'fromBuffer' method to deserialize vector elements.
-   * @returns An array of deserialized elements of type T.
-   */
-  public readVector<T>(itemDeserializer: {
-    /**
-     * A method to deserialize data from a buffer.
-     */
-    fromBuffer: (reader: BufferReader) => T;
-  }): T[] {
-    const size = this.readNumber();
-    const result = new Array<T>(size);
-    for (let i = 0; i < size; i++) {
-      result[i] = itemDeserializer.fromBuffer(this);
-    }
-    return result;
-  }
-
-  /**
-   * Read an array of a fixed size with elements of type T from the buffer.
-   * The 'itemDeserializer' object should have a 'fromBuffer' method that takes a BufferReader instance as input,
-   * and returns an instance of the desired deserialized data type T.
-   * This method will call the 'fromBuffer' method for each element in the array and return the resulting array.
-   *
-   * @param size - The fixed number of elements in the array.
-   * @param itemDeserializer - An object with a 'fromBuffer' method to deserialize individual elements of type T.
-   * @returns An array of instances of type T.
-   */
-  public readArray<T, N extends number>(
-    size: N,
-    itemDeserializer: {
-      /**
-       * A function for deserializing data from a BufferReader instance.
-       */
-      fromBuffer: (reader: BufferReader) => T;
-    },
-  ): Tuple<T, N> {
-    const result = Array.from({ length: size }, () => itemDeserializer.fromBuffer(this));
-    return result as Tuple<T, N>;
-  }
-
-  /**
-   * Read a variable sized Buffer array where elements are represented by length + data.
-   * The method consecutively looks for a number which is the size of the proceeding buffer,
-   * then reads the bytes until it reaches the end of the reader's internal buffer.
-   * NOTE: if `size` is not provided, this will run to the end of the reader's buffer.
-   * @param size - Size of the buffer array in bytes (full remaining buffer length if left empty).
-   * @returns An array of variable sized buffers.
-   */
-  public readBufferArray(size = -1): Buffer[] {
-    const result: Buffer[] = [];
-    const end = size >= 0 ? this.index + size : this.buffer.length;
-    while (this.index < end) {
-      const item = this.readBuffer();
-      result.push(item);
-    }
-    // Ensure that all bytes have been read.
-    if (this.index !== end) {
-      throw new Error(
-        `Reader buffer was not fully consumed. Consumed up to ${this.index} bytes. End of data: ${end} bytes.`,
-      );
-    }
-    return result;
-  }
-
-  /**
-   * Reads a serialized object from a buffer and returns the deserialized object using the given deserializer.
-   *
-   * @typeparam T - The type of the deserialized object.
-   * @param deserializer - An object with a 'fromBuffer' method that takes a BufferReader instance and returns an instance of the deserialized object.
-   * @returns The deserialized object of type T.
-   */
-  public readObject<T>(deserializer: {
-    /**
-     * A method that takes a BufferReader instance and returns an instance of the deserialized data type.
-     */
-    fromBuffer: (reader: BufferReader) => T;
-  }): T {
-    return deserializer.fromBuffer(this);
-  }
-
-  /**
-   * Returns a Buffer containing the next n bytes from the current buffer without modifying the reader's index position.
-   * If n is not provided or exceeds the remaining length of the buffer, it returns all bytes from the current position till the end of the buffer.
-   *
-   * @param n - The number of bytes to peek from the current buffer. (Optional).
-   * @returns A Buffer with the next n bytes or the remaining bytes if n is not provided or exceeds the buffer length.
-   */
-  public peekBytes(n?: number): Buffer {
-    return this.buffer.subarray(this.index, n ? this.index + n : undefined);
-  }
-
-  /**
-   * Reads a string from the buffer and returns it.
-   * The method first reads the size of the string, then reads the corresponding
-   * number of bytes from the buffer and converts them to a string.
-   *
-   * @returns The read string from the buffer.
-   */
-  public readString(): string {
-    return this.readBuffer().toString();
-  }
-
-  /**
-   * Reads a buffer from the current position of the reader and advances the index.
-   * The method first reads the size (number) of bytes to be read, and then returns
-   * a Buffer with that size containing the bytes. Useful for reading variable-length
-   * binary data encoded as (size, data) format.
-   *
-   * @returns A Buffer containing the read bytes.
-   */
-  public readBuffer(): Buffer {
-    const size = this.readNumber();
-    return this.readBytes(size);
-  }
-
-  /**
-   * Reads and constructs a map object from the current buffer using the provided deserializer.
-   * The method reads the number of entries in the map, followed by iterating through each key-value pair.
-   * The key is read as a string, while the value is obtained using the passed deserializer's `fromBuffer` method.
-   * The resulting map object is returned, containing all the key-value pairs read from the buffer.
-   *
-   * @param deserializer - An object with a `fromBuffer` method to deserialize the values in the map.
-   * @returns A map object with string keys and deserialized values based on the provided deserializer.
-   */
-  public readMap<T>(deserializer: {
-    /**
-     * Deserializes an element of type T from a BufferReader instance.
-     */
-    fromBuffer: (reader: BufferReader) => T;
-  }): { [key: string]: T } {
-    const numEntries = this.readNumber();
-    const map: { [key: string]: T } = {};
-    for (let i = 0; i < numEntries; i++) {
-      const key = this.readString();
-      const value = this.readObject<T>(deserializer);
-      map[key] = value;
-    }
-    return map;
-  }
-
-  /**
-   * Get the length of the reader's buffer.
-   * @returns The length of the underlying reader's buffer.
-   */
-  public getLength(): number {
-    return this.buffer.length;
-  }
-}

package/src/serialize/free_funcs.ts

@@ -1,279 +0,0 @@
-import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
-
-/**
- * Convert a boolean value to its corresponding byte representation in a Buffer of size 1.
- * The function takes a boolean value and writes it into a new buffer as either 1 (true) or 0 (false).
- * This method is useful for converting a boolean value into a binary format that can be stored or transmitted easily.
- *
- * @param b - The boolean value to be converted.
- * @returns A Buffer containing the byte representation of the input boolean value.
- */
-export function boolToByte(b: boolean) {
-  const buf = Buffer.alloc(1);
-  buf.writeUInt8(b ? 1 : 0);
-  return buf;
-}
-
-/**
- * @param n - The input number to be converted to a big-endian unsigned 16-bit integer Buffer.
- * @param bufferSize - Optional, the size of the output Buffer (default is 2).
- * @returns A Buffer containing the big-endian unsigned 16-bit integer representation of the input number.
- */
-export function numToUInt16BE(n: number, bufferSize = 2) {
-  const buf = Buffer.alloc(bufferSize);
-  buf.writeUInt16BE(n, bufferSize - 2);
-  return buf;
-}
-
-/**
- * Convert a number into a 4-byte little-endian unsigned integer buffer.
- * The input number is serialized as an unsigned 32-bit integer in little-endian byte order,
- * and returned as a Buffer of specified size (defaults to 4).
- * If the provided bufferSize is greater than 4, the additional bytes will be padded with zeros.
- *
- * @param n - The number to be converted into a little-endian unsigned integer buffer.
- * @param bufferSize - Optional, the size of the output buffer (default value is 4).
- * @returns A Buffer containing the serialized little-endian unsigned integer representation of the input number.
- */
-export function numToUInt32LE(n: number, bufferSize = 4) {
-  const buf = Buffer.alloc(bufferSize);
-  buf.writeUInt32LE(n, bufferSize - 4);
-  return buf;
-}
-
-/**
- * Convert a number to a big-endian unsigned 32-bit integer Buffer.
- * This function takes a number and an optional buffer size as input and creates a Buffer with the specified size (defaults to 4) containing the big-endian representation of the input number as an unsigned 32-bit integer. Note that the bufferSize should be greater than or equal to 4, otherwise the output Buffer might truncate the serialized value.
- *
- * @param n - The input number to be converted to a big-endian unsigned 32-bit integer Buffer.
- * @param bufferSize - Optional, the size of the output Buffer (default is 4).
- * @returns A Buffer containing the big-endian unsigned 32-bit integer representation of the input number.
- */
-export function numToUInt32BE(n: number, bufferSize = 4) {
-  const buf = Buffer.alloc(bufferSize);
-  buf.writeUInt32BE(n, bufferSize - 4);
-  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
- * with the provided buffer size. By default, the buffer size is set to 4 bytes which represents a 32-bit integer.
- * The function will use the last 4 bytes of the buffer to store the serialized number. If the input number
- * is outside the range of a 32-bit signed integer, the resulting serialization may be incorrect due to truncation.
- *
- * @param n - The number to be serialized as a signed 32-bit integer.
- * @param bufferSize - Optional, the size of the output Buffer (default is 4 bytes).
- * @returns A Buffer containing the serialized big-endian signed 32-bit integer.
- */
-export function numToInt32BE(n: number, bufferSize = 4) {
-  const buf = Buffer.alloc(bufferSize);
-  buf.writeInt32BE(n, bufferSize - 4);
-  return buf;
-}
-
-/**
- * Convert a number to an 8-bit unsigned integer and return it as a Buffer of length 1.
- * The input number is written as an 8-bit unsigned integer into the buffer. This function
- * is useful for converting small numeric values to a standardized binary format that can be
- * easily stored or transmitted.
- *
- * @param n - The number to be converted to an 8-bit unsigned integer.
- * @returns A Buffer containing the 8-bit unsigned integer representation of the input number.
- */
-export function numToUInt8(n: number) {
-  const bufferSize = 1;
-  const buf = Buffer.alloc(bufferSize);
-  buf.writeUInt8(n, 0);
-  return buf;
-}
-
-/**
- * Adds a 4-byte byte-length prefix to a buffer.
- * @param buf - The input Buffer to be prefixed
- * @returns A Buffer with 4-byte byte-length prefix.
- */
-export function prefixBufferWithLength(buf: Buffer) {
-  const lengthBuf = Buffer.alloc(4);
-  lengthBuf.writeUInt32BE(buf.length, 0);
-  return Buffer.concat([lengthBuf, buf]);
-}
-
-/**
- * Serialize a BigInt value into a Buffer of specified width.
- * The function converts the input BigInt into its big-endian representation and stores it in a Buffer of the given width.
- * If the width is not provided, a default value of 32 bytes will be used. It is important to provide an appropriate width
- * to avoid truncation or incorrect serialization of large BigInt values.
- *
- * @param n - The BigInt value to be serialized.
- * @param width - The width (in bytes) of the output Buffer, optional with default value 32.
- * @returns A Buffer containing the serialized BigInt value in big-endian format.
- */
-export function serializeBigInt(n: bigint, width = 32) {
-  return toBufferBE(n, width);
-}
-
-/**
- * Deserialize a big integer from a buffer, given an offset and width.
- * Reads the specified number of bytes from the buffer starting at the offset, converts it to a big integer, and returns the deserialized result along with the number of bytes read (advanced).
- *
- * @param buf - The buffer containing the big integer to be deserialized.
- * @param offset - The position in the buffer where the big integer starts. Defaults to 0.
- * @param width - The number of bytes to read from the buffer for the big integer. Defaults to 32.
- * @returns An object containing the deserialized big integer value ('elem') and the number of bytes advanced ('adv').
- */
-export function deserializeBigInt(buf: Buffer, offset = 0, width = 32) {
-  return { elem: toBigIntBE(buf.subarray(offset, offset + width)), adv: width };
-}
-
-/**
- * Serializes a Date object into a Buffer containing its timestamp as a big integer value.
- * The resulting Buffer has a fixed width of 8 bytes, representing a 64-bit big-endian integer.
- * This function is useful for converting date values into a binary format that can be stored or transmitted easily.
- *
- * @param date - The Date object to be serialized.
- * @returns A Buffer containing the serialized timestamp of the input Date object.
- */
-export function serializeDate(date: Date) {
-  return serializeBigInt(BigInt(date.getTime()), 8);
-}
-
-/**
- * Deserialize a boolean value from a given buffer at the specified offset.
- * Reads a single byte at the provided offset in the buffer and returns
- * the deserialized boolean value along with the number of bytes read (adv).
- *
- * @param buf - The buffer containing the serialized boolean value.
- * @param offset - The position in the buffer to start reading the boolean value.
- * @returns An object containing the deserialized boolean value (elem) and the number of bytes read (adv).
- */
-export function deserializeBool(buf: Buffer, offset = 0) {
-  const adv = 1;
-  return { elem: buf.readUInt8(offset), adv };
-}
-
-/**
- * Deserialize a 4-byte unsigned integer from a buffer, starting at the specified offset.
- * The deserialization reads 4 bytes from the given buffer and converts it into a number.
- * Returns an object containing the deserialized unsigned integer and the number of bytes advanced (4).
- *
- * @param buf - The buffer containing the serialized unsigned integer.
- * @param offset - The starting position in the buffer to deserialize from (default is 0).
- * @returns An object with the deserialized unsigned integer as 'elem' and the number of bytes advanced ('adv') as 4.
- */
-export function deserializeUInt32(buf: Buffer, offset = 0) {
-  const adv = 4;
-  return { elem: buf.readUInt32BE(offset), adv };
-}
-
-/**
- * Deserialize a signed 32-bit integer from a buffer at the given offset.
- * The input 'buf' should be a Buffer containing binary data, and 'offset' should be the position in the buffer
- * where the signed 32-bit integer starts. Returns an object with both the deserialized integer (elem) and the
- * number of bytes advanced in the buffer (adv, always equal to 4).
- *
- * @param buf - The buffer containing the binary data.
- * @param offset - Optional, the position in the buffer where the signed 32-bit integer starts (default is 0).
- * @returns An object with the deserialized integer as 'elem' and the number of bytes advanced as 'adv'.
- */
-export function deserializeInt32(buf: Buffer, offset = 0) {
-  const adv = 4;
-  return { elem: buf.readInt32BE(offset), adv };
-}
-
-/**
- * Deserialize a field element from a buffer, starting at the given offset.
- * The function reads 32 bytes from the buffer and converts it into a field element using Fr.fromBuffer.
- * It returns an object containing the deserialized field element and the number of bytes read (adv).
- *
- * @param buf - The buffer containing the serialized field element.
- * @param offset - The position in the buffer where the field element starts. Default is 0.
- * @returns An object with 'elem' as the deserialized field element and 'adv' as the number of bytes read.
- */
-export function deserializeField(buf: Buffer, offset = 0) {
-  const adv = 32;
-  return { elem: Fr.fromBuffer(buf.subarray(offset, offset + adv)), adv };
-}
-
-/**
- * Serialize an array of Buffer instances into a single Buffer by concatenating the array length as a 4-byte unsigned integer
- * and then the individual Buffer elements. The function is useful for storing or transmitting an array of binary data chunks
- * (e.g., file parts) in a compact format.
- *
- * @param arr - An array of Buffer instances to be serialized into a single vector-like Buffer.
- * @returns A Buffer containing the serialized array length followed by the concatenated elements of the input Buffer array.
- */
-export function serializeBufferArrayToVector(arr: Buffer[]) {
-  const lengthBuf = Buffer.alloc(4);
-  lengthBuf.writeUInt32BE(arr.length, 0);
-  return Buffer.concat([lengthBuf, ...arr]);
-}
-
-/**
- * Deserialize an array of fixed length elements from a given buffer using a custom deserializer function.
- * The deserializer function should take the buffer and an offset as arguments, and return an object containing
- * the deserialized element and the number of bytes used to deserialize it (adv).
- *
- * @param deserialize - A custom deserializer function to extract individual elements from the buffer.
- * @param vector - The input buffer containing the serialized array.
- * @param offset - An optional starting position in the buffer for deserializing the array.
- * @returns An object containing the deserialized array and the total number of bytes used during deserialization (adv).
- * @deprecated User BufferReader instead.
- */
-export function deserializeArrayFromVector<T>(
-  deserialize: (
-    buf: Buffer,
-    offset: number,
-  ) => {
-    /**
-     * The element.
-     */
-    elem: T;
-    /**
-     * The advancement offset.
-     */
-    adv: number;
-  },
-  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 };
-}
-
-/**
- * Parse a buffer as a big integer.
- */
-export function toBigInt(buf: Buffer): bigint {
-  const hex = buf.toString('hex');
-  if (hex.length === 0) {
-    return BigInt(0);
-  }
-  return BigInt(`0x${hex}`);
-}
-
-/**
- * Stores full 256 bits of information in 2 fields.
- * @param buf - 32 bytes of data
- * @returns 2 field elements
- */
-export function to2Fields(buf: Buffer): [Fr, Fr] {
-  if (buf.length !== 32) {
-    throw new Error('Buffer must be 32 bytes');
-  }
-
-  // Split the hash into two fields, a high and a low
-  const buf1 = Buffer.concat([Buffer.alloc(16), buf.subarray(0, 16)]);
-  const buf2 = Buffer.concat([Buffer.alloc(16), buf.subarray(16, 32)]);
-
-  return [Fr.fromBuffer(buf1), Fr.fromBuffer(buf2)];
-}

package/src/serialize/index.ts

@@ -1,3 +0,0 @@
-export * from './free_funcs.js';
-export * from './buffer_reader.js';
-export * from './types.js';