@aztec/foundation 0.0.1-commit.0c875d939 → 0.0.1-commit.0ec55a70b

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

@@ -1,5 +1,7 @@
 import type { pino } from 'pino';
 
+import { convertBigintsToStrings } from './bigint-utils.js';
+
 /* eslint-disable camelcase */
 
 const GOOGLE_CLOUD_TRACE_ID = 'logging.googleapis.com/trace';
@@ -15,6 +17,9 @@ export const GoogleCloudLoggerConfig = {
   messageKey: 'message',
   formatters: {
     log(object: Record<string, unknown>): Record<string, unknown> {
+      // Convert bigints to strings recursively to avoid serialization issues
+      object = convertBigintsToStrings(object) as Record<string, unknown>;
+
       // Add trace context attributes following Cloud Logging structured log format described
       // in https://cloud.google.com/logging/docs/structured-logging#special-payload-fields
       const { trace_id, span_id, trace_flags, ...rest } = object;

package/src/log/pino-logger.ts

@@ -7,6 +7,7 @@ import { inspect } from 'util';
 import { compactArray } from '../collection/array.js';
 import type { EnvVar } from '../config/index.js';
 import { parseBooleanEnv } from '../config/parse-env.js';
+import { convertBigintsToStrings } from './bigint-utils.js';
 import { GoogleCloudLoggerConfig } from './gcloud-logger-config.js';
 import { getLogLevelFromFilters, parseLogLevelEnvVar } from './log-filters.js';
 import type { LogLevel } from './log-levels.js';
@@ -20,6 +21,8 @@ export type LoggerBindings = {
   instanceId?: string;
 };
 
+const MAX_MODULE_NAME_LENGTH = 256;
+
 // Allow global hooks for providing default bindings.
 // Used by withLoggerBindings in pino-logger-server to propagate bindings via AsyncLocalStorage.
 type LogBindingsHandler = () => LoggerBindings | undefined;
@@ -47,7 +50,7 @@ function getBindingsFromHandlers(): LoggerBindings | undefined {
 }
 
 export function createLogger(module: string, bindings?: LoggerBindings): Logger {
-  module = module.replace(/^aztec:/, '');
+  module = module.slice(0, MAX_MODULE_NAME_LENGTH).replace(/^aztec:/, '');
 
   const resolvedBindings = { ...getBindingsFromHandlers(), ...bindings };
   const actor = resolvedBindings?.actor;
@@ -165,6 +168,9 @@ const pinoOpts: pino.LoggerOptions<keyof typeof customLevels> = {
       ...redactedPaths.map(p => `opts.${p}`),
     ],
   },
+  formatters: {
+    log: obj => convertBigintsToStrings(obj) as Record<string, unknown>,
+  },
   ...(useGcloudLogging ? GoogleCloudLoggerConfig : {}),
 };
 
@@ -371,5 +377,20 @@ export type Logger = { [K in LogLevel]: LogFn } & { /** Error log function */ er
  * @returns A string with both the log message and the error message.
  */
 function formatErr(msg: string, err?: unknown): string {
-  return err ? `${msg}: ${inspect(err)}` : msg;
+  if (!err) {
+    return msg;
+  }
+
+  try {
+    return `${msg}: ${inspect(err)}`;
+  } catch {
+    // inspect can crash on error objects with broken property descriptors
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-base-to-string
+      return `${msg}: ${err instanceof Error ? `${err.name}: ${err.message}` : String(err)}`;
+    } catch {
+      // if even String(err) fails, return the original message with a note about the error
+      return `${msg}: [unserializable error]`;
+    }
+  }
 }

package/src/queue/batch_queue.ts

@@ -105,6 +105,7 @@ export class BatchQueue<T, K extends string | number> {
       return Promise.resolve();
     }
 
+    this.flushCurrentBatch();
     this.container.end();
     return runningPromise;
   }

package/src/retry/index.ts

@@ -104,6 +104,36 @@ export async function retryUntil<T>(
   }
 }
 
+/**
+ * Retry an asynchronous function until it returns a truthy value or the maximum number of retries is exceeded.
+ * The function is retried periodically with a fixed interval between attempts.
+ *
+ * @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 error messages.
+ * @param maxRetries - The maximum number of retry attempts before throwing an error.
+ * @param retryInterval - 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 retries are exhausted.
+ */
+export async function retryTimes<T>(
+  fn: () => (T | undefined) | Promise<T | undefined>,
+  name = '',
+  maxRetries: number,
+  retryInterval = 1,
+) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const result = await fn();
+    if (result) {
+      return result;
+    }
+
+    if (attempt < maxRetries) {
+      await sleep(retryInterval * 1000);
+    }
+  }
+
+  throw new Error(name ? `Retries exhausted awaiting ${name}` : 'Retries exhausted');
+}
+
 /**
  * Convenience wrapper around retryUntil with fast polling for tests.
  * Uses 10s timeout and 100ms polling interval by default.

package/src/schemas/api.ts

@@ -37,7 +37,10 @@ export type ApiSchema = {
 };
 
 /** Return whether an API schema defines a valid function schema for a given method name. */
-export function schemaHasMethod(schema: ApiSchema, methodName: string) {
+export function schemaHasMethod<T extends ApiSchema>(
+  schema: T,
+  methodName: string,
+): methodName is Extract<keyof T, string> {
   return (
     typeof methodName === 'string' &&
     Object.hasOwn(schema, methodName) &&

package/src/sleep/index.ts

@@ -22,6 +22,7 @@ import { InterruptError } from '../error/index.js';
  */
 export class InterruptibleSleep {
   private interrupts: Array<(shouldThrow: boolean) => void> = [];
+  private timeoutIds: NodeJS.Timeout[] = [];
 
   /**
    * Sleep for a specified amount of time in milliseconds.
@@ -38,9 +39,15 @@ export class InterruptibleSleep {
       this.interrupts.push(resolve);
     });
 
-    const timeoutPromise = new Promise<boolean>(resolve => setTimeout(() => resolve(false), ms));
+    let timeoutId: NodeJS.Timeout;
+    const timeoutPromise = new Promise<boolean>(resolve => {
+      timeoutId = setTimeout(() => resolve(false), ms);
+      this.timeoutIds.push(timeoutId);
+    });
     const shouldThrow = await Promise.race([interruptPromise, timeoutPromise]);
 
+    clearTimeout(timeoutId!);
+    this.timeoutIds = this.timeoutIds.filter(id => id !== timeoutId);
     this.interrupts = this.interrupts.filter(res => res !== interruptResolve);
 
     if (shouldThrow) {
@@ -58,6 +65,8 @@ export class InterruptibleSleep {
   public interrupt(sleepShouldThrow = false): void {
     this.interrupts.forEach(resolve => resolve(sleepShouldThrow));
     this.interrupts = [];
+    this.timeoutIds.forEach(id => clearTimeout(id));
+    this.timeoutIds = [];
   }
 }
 

package/src/string/index.ts

@@ -58,7 +58,7 @@ export function urlJoin(...args: string[]): string {
       end--;
     }
 
-    if (start < end) {
+    if (start <= end) {
       processed.push(arg.slice(start, end + 1));
     }
   }

package/src/timer/date.ts

@@ -32,6 +32,12 @@ export class TestDateProvider extends DateProvider {
     this.logger.warn(`Time set to ${new Date(timeMs).toISOString()}`, { offset: this.offset, timeMs });
   }
 
+  /** Resets the time back to real time (offset = 0). */
+  public reset() {
+    this.offset = 0;
+    this.logger.warn('Time reset to real time');
+  }
+
   /** Advances the time by the given number of seconds. */
   public advanceTime(seconds: number) {
     this.offset += seconds * 1000;

package/src/transport/dispatch/create_dispatch_proxy.ts

@@ -2,7 +2,17 @@ import { EventEmitter } from 'events';
 
 import { type TransferDescriptor, isTransferDescriptor } from '../interface/transferable.js';
 import type { TransportClient } from '../transport_client.js';
-import type { DispatchMsg } from './create_dispatch_fn.js';
+
+/**
+ * Represents a message object for dispatching function calls.
+ * Contains the function name ('fn') and an array of arguments ('args') required to call the target method.
+ */
+export interface DispatchMsg {
+  /** Name of the target method to be called. */
+  fn: string;
+  /** An array of arguments to be passed to the target method. */
+  args: any[];
+}
 
 /**
  * FilterOutAttributes type filters out all non-method properties of an object, leaving only the attributes

package/src/transport/index.ts

@@ -1,4 +1,3 @@
-export * from './dispatch/create_dispatch_fn.js';
 export * from './dispatch/create_dispatch_proxy.js';
 export * from './dispatch/messages.js';
 export * from './interface/connector.js';

package/src/transport/transport_client.ts

@@ -91,7 +91,7 @@ export class TransportClient<Payload> extends EventEmitter {
     }
     const msgId = this.msgId++;
     const msg = { msgId, payload };
-    log.debug(format(`->`, msg));
+    log.trace(format(`->`, msg));
     return new Promise<any>((resolve, reject) => {
       this.pendingRequests.push({ resolve, reject, msgId });
       this.socket!.send(msg, transfer).catch(reject);
@@ -111,7 +111,7 @@ export class TransportClient<Payload> extends EventEmitter {
       this.close();
       return;
     }
-    log.debug(format(`<-`, msg));
+    log.trace(format(`<-`, msg));
     if (isEventMessage(msg)) {
       this.emit('event_msg', msg.payload);
       return;

package/src/trees/balanced_merkle_tree_root.ts

@@ -1,10 +1,7 @@
-import { poseidonMerkleHash, shaMerkleHash } from './hasher.js';
+import { shaMerkleHash } from './hasher.js';
 
 export const computeBalancedShaRoot = (leaves: Buffer[]) => computeBalancedMerkleTreeRoot(leaves);
 
-export const computeBalancedPoseidonRoot = async (leaves: Buffer[]) =>
-  await computeBalancedMerkleTreeRootAsync(leaves, poseidonMerkleHash);
-
 /**
  * Computes the Merkle root with the provided leaves **synchronously**.
  * This method uses a synchronous hash function (defaults to `sha256Trunc`).
@@ -36,7 +33,7 @@ export function computeBalancedMerkleTreeRoot(leaves: Buffer[], hasher = shaMerk
  */
 export async function computeBalancedMerkleTreeRootAsync(
   leaves: Buffer[],
-  hasher = poseidonMerkleHash,
+  hasher: (left: Buffer, right: Buffer) => Promise<Buffer<ArrayBuffer>>,
 ): Promise<Buffer> {
   const height = getTreeHeight(leaves);
   let nodes = leaves.slice();

package/src/trees/hasher.ts

@@ -1,4 +1,4 @@
-import { poseidon2Hash } from '../crypto/poseidon/index.js';
+import { poseidon2HashWithSeparator } from '../crypto/poseidon/index.js';
 import { sha256Trunc } from '../crypto/sha256/index.js';
 
 /**
@@ -44,5 +44,8 @@ export interface AsyncHasher {
 export const shaMerkleHash: Hasher['hash'] = (left: Buffer, right: Buffer) =>
   sha256Trunc(Buffer.concat([left, right])) as Buffer<ArrayBuffer>;
 
-export const poseidonMerkleHash: AsyncHasher['hash'] = async (left: Buffer, right: Buffer) =>
-  (await poseidon2Hash([left, right])).toBuffer() as Buffer<ArrayBuffer>;
+/** Creates a poseidon2 merkle hasher with the given domain separator. */
+export const makePoseidonMerkleHash =
+  (separator: number): AsyncHasher['hash'] =>
+  async (left: Buffer, right: Buffer) =>
+    (await poseidon2HashWithSeparator([left, right], separator)).toBuffer() as Buffer<ArrayBuffer>;

package/src/trees/indexed_merkle_tree_calculator.ts

@@ -40,7 +40,11 @@ export class IndexedMerkleTreeCalculator<T extends IndexedTreeLeafPreimage, N ex
     }
     const sorted = values
       .map((v, i) => ({ value: v, index: i }))
-      .sort((a, b) => Number(toBigIntBE(b.value) - toBigIntBE(a.value)));
+      .sort((a, b): -1 | 0 | 1 => {
+        const aBigInt = toBigIntBE(a.value);
+        const bBigInt = toBigIntBE(b.value);
+        return aBigInt < bBigInt ? 1 : aBigInt > bBigInt ? -1 : 0;
+      });
     const indexedLeaves = sorted.map((item, i) => ({
       leaf: this.factory.fromBuffer(
         Buffer.concat([

package/src/trees/merkle_tree_calculator.ts

@@ -1,8 +1,7 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
-
-import type { AsyncHasher } from './hasher.js';
 import { MerkleTree } from './merkle_tree.js';
 
+type MerkleHashFn = (left: Buffer, right: Buffer) => Promise<Buffer<ArrayBuffer>>;
+
 /**
  * Merkle tree calculator.
  */
@@ -10,17 +9,12 @@ export class MerkleTreeCalculator {
   private constructor(
     private height: number,
     private zeroHashes: Buffer[],
-    private hasher: AsyncHasher['hash'],
+    private hasher: MerkleHashFn,
   ) {
     this.hasher = hasher;
   }
 
-  static async create(
-    height: number,
-    zeroLeaf: Buffer = Buffer.alloc(32),
-    hasher = async (left: Buffer, right: Buffer) =>
-      (await poseidon2Hash([left, right])).toBuffer() as Buffer<ArrayBuffer>,
-  ) {
+  static async create(height: number, zeroLeaf: Buffer = Buffer.alloc(32), hasher: MerkleHashFn) {
     const zeroHashes = [zeroLeaf];
     for (let i = 0; i < height; i++) {
       zeroHashes.push((await hasher(zeroHashes[i], zeroHashes[i])) as Buffer<ArrayBuffer>);

package/src/trees/sibling_path.ts

@@ -1,5 +1,4 @@
 import { makeTuple } from '../array/array.js';
-import { poseidon2Hash } from '../crypto/poseidon/index.js';
 import { Fr } from '../curves/bn254/index.js';
 import { schemas } from '../schemas/index.js';
 import {
@@ -172,7 +171,7 @@ export async function computeRootFromSiblingPath(
   leaf: Buffer,
   siblingPath: Buffer[],
   index: number,
-  hasher = async (left: Buffer, right: Buffer) => (await poseidon2Hash([left, right])).toBuffer(),
+  hasher: (left: Buffer, right: Buffer) => Promise<Buffer>,
 ) {
   let result = leaf;
   for (const sibling of siblingPath) {

package/src/trees/unbalanced_merkle_tree_root.ts

@@ -1,12 +1,9 @@
 import { computeBalancedMerkleTreeRoot, computeBalancedMerkleTreeRootAsync } from './balanced_merkle_tree_root.js';
-import { poseidonMerkleHash, shaMerkleHash } from './hasher.js';
+import { shaMerkleHash } from './hasher.js';
 import { UnbalancedMerkleTreeCalculator } from './unbalanced_merkle_tree_calculator.js';
 
 export const computeUnbalancedShaRoot = (leaves: Buffer[]) => computeUnbalancedMerkleTreeRoot(leaves, shaMerkleHash);
 
-export const computeUnbalancedPoseidonRoot = async (leaves: Buffer[]) =>
-  await computeUnbalancedMerkleTreeRootAsync(leaves, poseidonMerkleHash);
-
 export const computeWonkyShaRoot = (leaves: Buffer[]) => computeWonkyMerkleTreeRoot(leaves);
 
 /**
@@ -67,7 +64,7 @@ export function computeUnbalancedMerkleTreeRoot(
 
 export async function computeUnbalancedMerkleTreeRootAsync(
   leaves: Buffer[],
-  hasher = poseidonMerkleHash,
+  hasher: (left: Uint8Array, right: Uint8Array) => Promise<Buffer<ArrayBuffer>>,
   emptyRoot = Buffer.alloc(32),
 ): Promise<Buffer> {
   if (!leaves.length) {

package/src/types/index.ts

@@ -34,6 +34,20 @@ export type Prettify<T> = {
   [K in keyof T]: T[K];
 } & {};
 
+/** Returns a type with fields conditionally required based on a flag */
+export type IfFlag<
+  OptsSchema,
+  Opts extends OptsSchema,
+  Key extends keyof OptsSchema,
+  Field extends object,
+> = Opts extends { [K in Key]: true }
+  ? Field
+  : Opts extends { [K in Key]: false }
+    ? {}
+    : Opts extends { [K in Key]?: boolean }
+      ? Partial<Field>
+      : {};
+
 /**
  * Type-safe Event Emitter type
  * @example

package/dest/crypto/serialize.d.ts

@@ -1,51 +0,0 @@
-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 declare function serializeBufferArrayToVector(arr: Buffer[]): Buffer<ArrayBuffer>;
-/**
- * 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 declare function deserializeArrayFromVector<T>(deserialize: DeserializeFn<T>, vector: Buffer, offset?: number): {
-    elem: T[];
-    adv: number;
-};
-/**
- * For serializing numbers to 32 bit little-endian form.
- * TODO move to foundation pkg.
- * @param n - The number.
- * @returns The endian-corrected number.
- */
-export declare function numToUInt32LE(n: number, bufferSize?: number): Buffer<ArrayBuffer>;
-/**
- * Deserialize the 256-bit number at address `offset`.
- * @param buf - The buffer.
- * @param offset - The address.
- * @returns The derserialized 256-bit field.
- */
-export declare function deserializeField(buf: Buffer, offset?: number): {
-    elem: Buffer<ArrayBuffer>;
-    adv: number;
-};
-export declare function concatenateUint8Arrays(arrayOfUint8Arrays: Uint8Array[]): Uint8Array<ArrayBuffer>;
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VyaWFsaXplLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY3J5cHRvL3NlcmlhbGl6ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBRWhDOzs7OztHQUtHO0FBQ0gsd0JBQWdCLDRCQUE0QixDQUFDLEdBQUcsRUFBRSxNQUFNLEVBQUUsdUJBSXpEO0FBRUQ7O0dBRUc7QUFDSCxLQUFLLGFBQWEsQ0FBQyxDQUFDLElBQUksQ0FDdEIsR0FBRyxFQUFFLE1BQU0sRUFDWCxNQUFNLEVBQUUsTUFBTSxLQUNYO0lBQ0g7O09BRUc7SUFDSCxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQ1I7O09BRUc7SUFDSCxHQUFHLEVBQUUsTUFBTSxDQUFDO0NBQ2IsQ0FBQztBQUVGOzs7OztHQUtHO0FBQ0gsd0JBQWdCLDBCQUEwQixDQUFDLENBQUMsRUFBRSxXQUFXLEVBQUUsYUFBYSxDQUFDLENBQUMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTSxTQUFJOzs7RUFXdEc7QUFFRDs7Ozs7R0FLRztBQUNILHdCQUFnQixhQUFhLENBQUMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxVQUFVLFNBQUksdUJBSXREO0FBRUQ7Ozs7O0dBS0c7QUFDSCx3QkFBZ0IsZ0JBQWdCLENBQUMsR0FBRyxFQUFFLE1BQU0sRUFBRSxNQUFNLFNBQUk7OztFQUd2RDtBQUVELHdCQUFnQixzQkFBc0IsQ0FBQyxrQkFBa0IsRUFBRSxVQUFVLEVBQUUsMkJBU3RFIn0=

package/dest/crypto/serialize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/crypto/serialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,EAAE,uBAIzD;AAED;;GAEG;AACH,KAAK,aAAa,CAAC,CAAC,IAAI,CACtB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,KACX;IACH;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC;IACR;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,SAAI;;;EAWtG;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,SAAI,uBAItD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI;;;EAGvD;AAED,wBAAgB,sBAAsB,CAAC,kBAAkB,EAAE,UAAU,EAAE,2BAStE"}

package/dest/crypto/serialize.js

@@ -1,68 +0,0 @@
-// 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) {
-    const lengthBuf = Buffer.alloc(4);
-    lengthBuf.writeUInt32BE(arr.length, 0);
-    return Buffer.concat([
-        lengthBuf,
-        ...arr
-    ]);
-}
-/**
- * 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(deserialize, vector, offset = 0) {
-    let pos = offset;
-    const size = vector.readUInt32BE(pos);
-    pos += 4;
-    const arr = new Array(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, 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, offset = 0) {
-    const adv = 32;
-    return {
-        elem: buf.slice(offset, offset + adv),
-        adv
-    };
-}
-export function concatenateUint8Arrays(arrayOfUint8Arrays) {
-    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/dest/transport/dispatch/create_dispatch_fn.d.ts

@@ -1,25 +0,0 @@
-/**
- * Represents a message object for dispatching function calls.
- * Contains the function name ('fn') and an array of arguments ('args') required to call the target method.
- */
-export interface DispatchMsg {
-    /**
-     * Name of the target method to be called.
-     */
-    fn: string;
-    /**
-     * An array of arguments to be passed to the target method.
-     */
-    args: any[];
-}
-/**
- * Creates a dispatch function that calls the target's specified method with provided arguments.
- * The created dispatch function takes a DispatchMsg object as input, which contains the name of
- * the method to be called ('fn') and an array of arguments to be passed to the method ('args').
- *
- * @param targetFn - A function that returns the target object containing the methods to be dispatched.
- * @param log - Optional logging function for debugging purposes.
- * @returns A dispatch function that accepts a DispatchMsg object and calls the target's method with provided arguments.
- */
-export declare function createDispatchFn(targetFn: () => any, log?: import("../../log/pino-logger.js").Logger): ({ fn, args }: DispatchMsg) => Promise<any>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlX2Rpc3BhdGNoX2ZuLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNwb3J0L2Rpc3BhdGNoL2NyZWF0ZV9kaXNwYXRjaF9mbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQTs7O0dBR0c7QUFDSCxNQUFNLFdBQVcsV0FBVztJQUMxQjs7T0FFRztJQUNILEVBQUUsRUFBRSxNQUFNLENBQUM7SUFDWDs7T0FFRztJQUNILElBQUksRUFBRSxHQUFHLEVBQUUsQ0FBQztDQUNiO0FBRUQ7Ozs7Ozs7O0dBUUc7QUFDSCx3QkFBZ0IsZ0JBQWdCLENBQUMsUUFBUSxFQUFFLE1BQU0sR0FBRyxFQUFFLEdBQUcsNENBQXNDLCtDQU05RiJ9

package/dest/transport/dispatch/create_dispatch_fn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create_dispatch_fn.d.ts","sourceRoot":"","sources":["../../../src/transport/dispatch/create_dispatch_fn.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;OAEG;IACH,IAAI,EAAE,GAAG,EAAE,CAAC;CACb;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE,GAAG,4CAAsC,+CAM9F"}

package/dest/transport/dispatch/create_dispatch_fn.js

@@ -1,17 +0,0 @@
-import { format } from 'util';
-import { createLogger } from '../../log/index.js';
-/**
- * Creates a dispatch function that calls the target's specified method with provided arguments.
- * The created dispatch function takes a DispatchMsg object as input, which contains the name of
- * the method to be called ('fn') and an array of arguments to be passed to the method ('args').
- *
- * @param targetFn - A function that returns the target object containing the methods to be dispatched.
- * @param log - Optional logging function for debugging purposes.
- * @returns A dispatch function that accepts a DispatchMsg object and calls the target's method with provided arguments.
- */ export function createDispatchFn(targetFn, log = createLogger('foundation:dispatch')) {
-    return async ({ fn, args })=>{
-        const target = targetFn();
-        log.debug(format(`dispatching to ${target}: ${fn}`, args));
-        return await target[fn](...args);
-    };
-}

package/src/crypto/serialize.ts

@@ -1,85 +0,0 @@
-// 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;
-}