@aztec/foundation 0.0.1-commit.96bb3f7 → 0.0.1-commit.993d240

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

@@ -38,6 +38,14 @@ export class MembershipWitness<N extends number> {
     return [new Fr(this.leafIndex), ...this.siblingPath];
   }
 
+  /**
+   * Returns a representation of the membership witness as expected by intrinsic Noir deserialization.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [new Fr(this.leafIndex).toString() as string, this.siblingPath.map(fr => fr.toString()) as string[]];
+  }
+
   static schemaFor<N extends number>(size: N) {
     return schemas.Buffer.transform(b => MembershipWitness.fromBuffer(b, size));
   }

package/src/trees/merkle_tree_calculator.ts

@@ -1,8 +1,7 @@
-import { pedersenHash } from '@aztec/foundation/crypto/pedersen';
-
-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 pedersenHash([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,6 @@
+import { z } from 'zod';
+
 import { makeTuple } from '../array/array.js';
-import { pedersenHash } from '../crypto/pedersen/index.js';
 import { Fr } from '../curves/bn254/index.js';
 import { schemas } from '../schemas/index.js';
 import {
@@ -43,10 +44,14 @@ export class SiblingPath<N extends number> {
   }
 
   static schemaFor<N extends number>(size: N) {
-    return schemas.Buffer.transform(b => SiblingPath.fromBuffer(b) as SiblingPath<N>).refine(
-      path => path.pathSize === size,
-      path => ({ message: `Expected sibling path size ${size} but got ${path.pathSize}` }),
-    );
+    return schemas.Buffer.transform(b => SiblingPath.fromBuffer(b) as SiblingPath<N>).superRefine((path, ctx) => {
+      if (path.pathSize !== size) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Expected sibling path size ${size} but got ${path.pathSize}`,
+        });
+      }
+    });
   }
 
   toJSON() {
@@ -172,7 +177,7 @@ export async function computeRootFromSiblingPath(
   leaf: Buffer,
   siblingPath: Buffer[],
   index: number,
-  hasher = async (left: Buffer, right: Buffer) => (await pedersenHash([left, right])).toBuffer(),
+  hasher: (left: Buffer, right: Buffer) => Promise<Buffer>,
 ) {
   let result = leaf;
   for (const sibling of siblingPath) {

package/src/trees/unbalanced_merkle_tree_calculator.ts

@@ -1,5 +1,4 @@
-import { shaMerkleHash } from './balanced_merkle_tree.js';
-import type { Hasher } from './hasher.js';
+import { type Hasher, shaMerkleHash } from './hasher.js';
 import { SiblingPath } from './sibling_path.js';
 import { type TreeNodeLocation, UnbalancedTreeStore } from './unbalanced_tree_store.js';
 

package/src/trees/{unbalanced_merkle_tree.ts → unbalanced_merkle_tree_root.ts}

@@ -1,18 +1,10 @@
-import {
-  computeBalancedMerkleTreeRoot,
-  computeBalancedMerkleTreeRootAsync,
-  poseidonMerkleHash,
-  shaMerkleHash,
-} from './balanced_merkle_tree.js';
+import { computeBalancedMerkleTreeRoot, computeBalancedMerkleTreeRootAsync } from './balanced_merkle_tree_root.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 computeCompressedUnbalancedShaRoot = (leaves: Buffer[]) =>
-  computeCompressedUnbalancedMerkleTreeRoot(leaves);
+export const computeWonkyShaRoot = (leaves: Buffer[]) => computeWonkyMerkleTreeRoot(leaves);
 
 /**
  * Computes the Merkle root of an unbalanced tree.
@@ -72,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) {
@@ -105,7 +97,11 @@ export async function computeUnbalancedMerkleTreeRootAsync(
   return root!;
 }
 
-export function computeCompressedUnbalancedMerkleTreeRoot(
+// A **wonky** tree is a "compressed" unbalanced Merkle tree.
+// It is constructed in the same way as an unbalanced tree: by first creating the largest possible left subtree, with
+// the remaining leaves forming a right subtree that follows the same process recursively.
+// During construction, leaves equal to `valueToCompress` are skipped (compressed) and do not contribute to the tree.
+export function computeWonkyMerkleTreeRoot(
   leaves: Buffer[],
   valueToCompress = Buffer.alloc(32),
   emptyRoot = Buffer.alloc(32),
@@ -114,60 +110,3 @@ export function computeCompressedUnbalancedMerkleTreeRoot(
   const calculator = UnbalancedMerkleTreeCalculator.create(leaves, valueToCompress, emptyRoot, hasher);
   return calculator.getRoot();
 }
-
-/// Get the depth of the maximum balanced tree that can be created with the given number of leaves. The subtree will be
-/// the left most subtree of the wonky tree with a total of `numLeaves` leaves.
-///
-/// Note: All the leaves may not be used to form the tree. For example, if there are 5 leaves, the maximum depth is 2,
-/// only 4 leaves are used to form a balanced tree.
-function getMaxBalancedSubtreeDepth(numLeaves: number) {
-  return Math.floor(Math.log2(numLeaves));
-}
-
-/// Get the maximum depth of an unbalanced tree that can be created with the given number of leaves.
-function getMaxUnbalancedTreeDepth(numLeaves: number) {
-  return Math.ceil(Math.log2(numLeaves));
-}
-
-function findPosition(
-  rootLevel: number,
-  leafLevel: number,
-  numLeaves: number,
-  indexOffset: number,
-  targetIndex: number,
-): { level: number; indexAtLevel: number } {
-  if (numLeaves <= 1) {
-    // Single leaf.
-    return { level: rootLevel, indexAtLevel: indexOffset };
-  }
-
-  // The largest balanced tree that can be created with the given number of leaves.
-  const maxBalancedTreeDepth = getMaxBalancedSubtreeDepth(numLeaves);
-  const numBalancedLeaves = 2 ** maxBalancedTreeDepth;
-  const numRemainingLeaves = numLeaves - numBalancedLeaves;
-
-  if (targetIndex < numBalancedLeaves) {
-    // Target is in the balanced tree.
-
-    // - If numRemainingLeaves is 0: this balanced tree is grown from the current root.
-    // - If numRemainingLeaves is not 0: the remaining leaves will form another tree, which will become the right child of the root.
-    //   And the balanced tree will be the left child of the root.
-    //   There will be an extra level between the root of the balanced tree and the current root.
-    const extraLevel = numRemainingLeaves ? 1 : 0;
-
-    return { level: rootLevel + maxBalancedTreeDepth + extraLevel, indexAtLevel: indexOffset + targetIndex };
-  } else {
-    // Target is in the right branch.
-    const rightBranchMaxLevel = getMaxUnbalancedTreeDepth(numRemainingLeaves);
-    const shiftedUp = leafLevel - rootLevel - rightBranchMaxLevel - 1;
-    const nextLeafLevel = leafLevel - shiftedUp;
-    const newIndexOffset = (indexOffset + numBalancedLeaves) >> shiftedUp;
-    const shiftedTargetIndex = targetIndex - numBalancedLeaves;
-    return findPosition(rootLevel + 1, nextLeafLevel, numRemainingLeaves, newIndexOffset, shiftedTargetIndex);
-  }
-}
-
-export function findLeafLevelAndIndex(numLeaves: number, leafIndex: number) {
-  const maxLevel = getMaxUnbalancedTreeDepth(numLeaves);
-  return findPosition(0, maxLevel, numLeaves, 0, leafIndex);
-}

package/src/trees/unbalanced_tree_store.ts

@@ -1,5 +1,3 @@
-import { findLeafLevelAndIndex } from './unbalanced_merkle_tree.js';
-
 export interface TreeNodeLocation {
   level: number;
   index: number;
@@ -104,3 +102,60 @@ export class UnbalancedTreeStore<T> {
     return `${location.level}-${location.index}`;
   }
 }
+
+/// Get the depth of the maximum balanced tree that can be created with the given number of leaves. The subtree will be
+/// the left most subtree of the unbalanced tree with a total of `numLeaves` leaves.
+///
+/// Note: All the leaves may not be used to form the tree. For example, if there are 5 leaves, the maximum depth is 2,
+/// only 4 leaves are used to form a balanced tree.
+function getMaxBalancedSubtreeDepth(numLeaves: number) {
+  return Math.floor(Math.log2(numLeaves));
+}
+
+/// Get the maximum depth of an unbalanced tree that can be created with the given number of leaves.
+function getMaxUnbalancedTreeDepth(numLeaves: number) {
+  return Math.ceil(Math.log2(numLeaves));
+}
+
+function findPosition(
+  rootLevel: number,
+  leafLevel: number,
+  numLeaves: number,
+  indexOffset: number,
+  targetIndex: number,
+): { level: number; indexAtLevel: number } {
+  if (numLeaves <= 1) {
+    // Single leaf.
+    return { level: rootLevel, indexAtLevel: indexOffset };
+  }
+
+  // The largest balanced tree that can be created with the given number of leaves.
+  const maxBalancedTreeDepth = getMaxBalancedSubtreeDepth(numLeaves);
+  const numBalancedLeaves = 2 ** maxBalancedTreeDepth;
+  const numRemainingLeaves = numLeaves - numBalancedLeaves;
+
+  if (targetIndex < numBalancedLeaves) {
+    // Target is in the balanced tree.
+
+    // - If numRemainingLeaves is 0: this balanced tree is grown from the current root.
+    // - If numRemainingLeaves is not 0: the remaining leaves will form another tree, which will become the right child of the root.
+    //   And the balanced tree will be the left child of the root.
+    //   There will be an extra level between the root of the balanced tree and the current root.
+    const extraLevel = numRemainingLeaves ? 1 : 0;
+
+    return { level: rootLevel + maxBalancedTreeDepth + extraLevel, indexAtLevel: indexOffset + targetIndex };
+  } else {
+    // Target is in the right branch.
+    const rightBranchMaxLevel = getMaxUnbalancedTreeDepth(numRemainingLeaves);
+    const shiftedUp = leafLevel - rootLevel - rightBranchMaxLevel - 1;
+    const nextLeafLevel = leafLevel - shiftedUp;
+    const newIndexOffset = (indexOffset + numBalancedLeaves) >> shiftedUp;
+    const shiftedTargetIndex = targetIndex - numBalancedLeaves;
+    return findPosition(rootLevel + 1, nextLeafLevel, numRemainingLeaves, newIndexOffset, shiftedTargetIndex);
+  }
+}
+
+export function findLeafLevelAndIndex(numLeaves: number, leafIndex: number) {
+  const maxLevel = getMaxUnbalancedTreeDepth(numLeaves);
+  return findPosition(0, maxLevel, numLeaves, 0, leafIndex);
+}

package/src/types/index.ts

@@ -24,16 +24,35 @@ export function isDefined<T>(value: T | undefined): value is T {
   return value !== undefined;
 }
 
+/** Type guard for error classes */
+export function isErrorClass<T extends Error>(value: unknown, errorClass: new (...args: any[]) => T): value is T {
+  return value instanceof errorClass || (value instanceof Error && value.name === errorClass.name);
+}
+
 /** Resolves a record-like type. Lifted from viem. */
 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
  * export type ArchiverEmitter = TypedEventEmitter<{
- *  [L2BlockSourceEvents.L2PruneDetected]: (args: L2BlockSourceEvent) => void;
+ *  [L2BlockSourceEvents.L2PruneUnproven]: (args: L2BlockSourceEvent) => void;
  *  [L2BlockSourceEvents.L2BlockProven]: (args: L2BlockSourceEvent) => void;
  * }>;
  * class Archiver extends (EventEmitter as new () => ArchiverEmitter) {

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/dest/trees/balanced_merkle_tree.d.ts

@@ -1,22 +0,0 @@
-import type { AsyncHasher, Hasher } from './hasher.js';
-export declare const shaMerkleHash: Hasher['hash'];
-export declare const pedersenMerkleHash: AsyncHasher['hash'];
-export declare const poseidonMerkleHash: AsyncHasher['hash'];
-export declare const computeBalancedShaRoot: (leaves: Buffer<ArrayBufferLike>[]) => Buffer<ArrayBufferLike>;
-export declare const computeBalancedPedersenRoot: (leaves: Buffer<ArrayBufferLike>[]) => Promise<Buffer<ArrayBufferLike>>;
-export declare const computeBalancedPoseidonRoot: (leaves: Buffer<ArrayBufferLike>[]) => Promise<Buffer<ArrayBufferLike>>;
-/**
- * Computes the Merkle root with the provided leaves **synchronously**.
- * This method uses a synchronous hash function (defaults to `sha256Trunc`).
- *
- * @throws If the number of leaves is not a power of two.
- */
-export declare function computeBalancedMerkleTreeRoot(leaves: Buffer[], hasher?: (lhs: Uint8Array<ArrayBufferLike>, rhs: Uint8Array<ArrayBufferLike>) => Buffer<ArrayBuffer>): Buffer;
-/**
- * Computes the Merkle root with the provided leaves **asynchronously**.
- * This method uses an asynchronous hash function (defaults to `pedersenHash`).
- *
- * @throws If the number of leaves is not a power of two.
- */
-export declare function computeBalancedMerkleTreeRootAsync(leaves: Buffer[], hasher?: (lhs: Uint8Array<ArrayBufferLike>, rhs: Uint8Array<ArrayBufferLike>) => Promise<Buffer<ArrayBuffer>>): Promise<Buffer>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFsYW5jZWRfbWVya2xlX3RyZWUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90cmVlcy9iYWxhbmNlZF9tZXJrbGVfdHJlZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRXZELGVBQU8sTUFBTSxhQUFhLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FDeUIsQ0FBQztBQUVuRSxlQUFPLE1BQU0sa0JBQWtCLEVBQUUsV0FBVyxDQUFDLE1BQU0sQ0FDeUIsQ0FBQztBQUU3RSxlQUFPLE1BQU0sa0JBQWtCLEVBQUUsV0FBVyxDQUFDLE1BQU0sQ0FDcUIsQ0FBQztBQUV6RSxlQUFPLE1BQU0sc0JBQXNCLGdFQUE4RCxDQUFDO0FBRWxHLGVBQU8sTUFBTSwyQkFBMkIseUVBQzhCLENBQUM7QUFFdkUsZUFBTyxNQUFNLDJCQUEyQix5RUFDOEIsQ0FBQztBQUV2RTs7Ozs7R0FLRztBQUNILHdCQUFnQiw2QkFBNkIsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLEVBQUUsTUFBTSw4RkFBZ0IsR0FBRyxNQUFNLENBZTlGO0FBRUQ7Ozs7O0dBS0c7QUFDSCx3QkFBc0Isa0NBQWtDLENBQ3RELE1BQU0sRUFBRSxNQUFNLEVBQUUsRUFDaEIsTUFBTSx1R0FBcUIsR0FDMUIsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQWVqQiJ9

package/dest/trees/balanced_merkle_tree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"balanced_merkle_tree.d.ts","sourceRoot":"","sources":["../../src/trees/balanced_merkle_tree.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAEvD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,CACyB,CAAC;AAEnE,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CACyB,CAAC;AAE7E,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CACqB,CAAC;AAEzE,eAAO,MAAM,sBAAsB,gEAA8D,CAAC;AAElG,eAAO,MAAM,2BAA2B,yEAC8B,CAAC;AAEvE,eAAO,MAAM,2BAA2B,yEAC8B,CAAC;AAEvE;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,8FAAgB,GAAG,MAAM,CAe9F;AAED;;;;;GAKG;AACH,wBAAsB,kCAAkC,CACtD,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,uGAAqB,GAC1B,OAAO,CAAC,MAAM,CAAC,CAejB"}

package/dest/trees/unbalanced_merkle_tree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unbalanced_merkle_tree.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_merkle_tree.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,wBAAwB,gEAA+E,CAAC;AAErH,eAAO,MAAM,6BAA6B,yEAC8B,CAAC;AAEzE,eAAO,MAAM,kCAAkC,gEACI,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,8FAAgB,EACtB,SAAS,sBAAmB,GAC3B,MAAM,CA6BR;AAED,wBAAsB,oCAAoC,CACxD,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,uGAAqB,EAC3B,SAAS,sBAAmB,GAC3B,OAAO,CAAC,MAAM,CAAC,CA6BjB;AAED,wBAAgB,yCAAyC,CACvD,MAAM,EAAE,MAAM,EAAE,EAChB,eAAe,sBAAmB,EAClC,SAAS,sBAAmB,EAC5B,MAAM,8FAAgB,GACrB,MAAM,CAGR;AAsDD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;EAGzE"}

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;
-}

package/src/transport/dispatch/create_dispatch_fn.ts

@@ -1,35 +0,0 @@
-import { format } from 'util';
-
-import { createLogger } from '../../log/index.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[];
-}
-
-/**
- * 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: () => any, log = createLogger('foundation:dispatch')) {
-  return async ({ fn, args }: DispatchMsg) => {
-    const target = targetFn();
-    log.debug(format(`dispatching to ${target}: ${fn}`, args));
-    return await target[fn](...args);
-  };
-}