@aztec/foundation 0.0.1-commit.b655e406 → 0.0.1-commit.c0b82b2

package/dest/trees/unbalanced_merkle_tree.js

@@ -1,99 +0,0 @@
-import { sha256Trunc } from '../crypto/sha256/index.js';
-import { MerkleTreeCalculator } from './merkle_tree_calculator.js';
-/**
- * Computes the Merkle root of an unbalanced tree.
- *
- * Unlike a balanced Merkle tree, which requires the number of leaves to be a power of two, an unbalanced tree can have
- * any number of leaves.
- *
- * The tree is constructed by iteratively extracting the smallest power-of-two-sized subtrees from **right to left**.
- * For each such subtree, it computes the subtree root and then combines all subtree roots (again from right to left)
- * into a single root using the provided hash function.
- *
- * Note: We need the final tree to be as shallow as possible, to minimize the size of the sibling path required to prove
- * membership of a leaf. Therefor, the computation proceeds from right to left - smaller subtrees must always be
- * combined before being merged with a larger sibling on their left.
- *
- * For example, consider an unbalanced tree made of three subtrees of sizes 2, 4, and 8. If we combine the size-2 and
- * size-4 subtrees first (producing a subtree of depth 3), and then merge it with the size-8 subtree (also depth 3), the
- * resulting tree has a maximum depth of 4.
- *
- * But if we instead combine the size-4 and size-8 subtrees first (depth 4), and then merge with the size-2 subtree
- * (depth 1), the final tree has a depth of 5.
- */ export function computeUnbalancedMerkleTreeRoot(leaves, hasher = sha256Trunc) {
-    if (!leaves.length) {
-        throw new Error('Cannot compute a Merkle root with no leaves');
-    }
-    if (leaves.length === 1) {
-        return leaves[0];
-    }
-    let numRemainingLeaves = leaves.length;
-    let subtreeSize = 1;
-    let root;
-    while(numRemainingLeaves > 1){
-        if ((numRemainingLeaves & subtreeSize) !== 0) {
-            const subtreeLeaves = leaves.slice(numRemainingLeaves - subtreeSize, numRemainingLeaves);
-            const subtreeRoot = MerkleTreeCalculator.computeTreeRootSync(subtreeLeaves, hasher);
-            if (!root) {
-                root = subtreeRoot;
-            } else {
-                root = hasher(Buffer.concat([
-                    subtreeRoot,
-                    root
-                ]));
-            }
-            numRemainingLeaves -= subtreeSize;
-        }
-        subtreeSize *= 2;
-    }
-    return root;
-}
-/// 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) {
-    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) {
-    return Math.ceil(Math.log2(numLeaves));
-}
-function findPosition(rootLevel, leafLevel, numLeaves, indexOffset, targetIndex) {
-    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, leafIndex) {
-    const maxLevel = getMaxUnbalancedTreeDepth(numLeaves);
-    return findPosition(0, maxLevel, numLeaves, 0, leafIndex);
-}

package/src/crypto/bn254/bn254_utils.ts

@@ -1,64 +0,0 @@
-import { Fr } from '../../fields/fields.js';
-import { Bn254G1Point, Bn254G2Point } from './index.js';
-
-/**
- * BN254 utility functions for point operations.
- * Provides compression, decompression, and public key generation for the BN254 curve.
- * Uses the bb.js Barretenberg backend for point operations.
- */
-
-/**
- * Generate a compressed BN254 G1 public key from a private key.
- *
- * @param privateKeyHex - Private key as 0x-prefixed hex string
- * @returns Compressed G1 point (32 bytes with sign bit in MSB)
- */
-export async function computeBn254G1PublicKeyCompressed(privateKeyHex: string): Promise<string> {
-  const sk = BigInt(privateKeyHex);
-  const skReduced = sk % Fr.MODULUS;
-
-  // Generate G1 point on BN254 curve using bb.js
-  const scalar = Fr.fromString(skReduced.toString());
-  const pk1 = await Bn254G1Point.generator(scalar);
-
-  // Compress the point using the primitive method
-  return '0x' + pk1.compress().toString('hex');
-}
-
-/**
- * Generate uncompressed BN254 G1 public key from a private key.
- *
- * @param privateKeyHex - Private key as 0x-prefixed hex string
- * @returns G1 point in affine coordinates
- */
-export async function computeBn254G1PublicKey(privateKeyHex: string): Promise<{ x: bigint; y: bigint }> {
-  const sk = BigInt(privateKeyHex);
-  const skReduced = sk % Fr.MODULUS;
-
-  const scalar = Fr.fromString(skReduced.toString());
-  const pk1 = await Bn254G1Point.generator(scalar);
-
-  return { x: pk1.x.toBigInt(), y: pk1.y.toBigInt() };
-}
-
-/**
- * Generate BN254 G2 public key from a private key.
- *
- * @param privateKeyHex - Private key as 0x-prefixed hex string
- * @returns G2 point in affine coordinates
- */
-export async function computeBn254G2PublicKey(privateKeyHex: string): Promise<{
-  x: { c0: bigint; c1: bigint };
-  y: { c0: bigint; c1: bigint };
-}> {
-  const sk = BigInt(privateKeyHex);
-  const skReduced = sk % Fr.MODULUS;
-
-  const scalar = Fr.fromString(skReduced.toString());
-  const pk2 = await Bn254G2Point.generator(scalar);
-
-  return {
-    x: { c0: pk2.x[0].toBigInt(), c1: pk2.x[1].toBigInt() },
-    y: { c0: pk2.y[0].toBigInt(), c1: pk2.y[1].toBigInt() },
-  };
-}

package/src/crypto/index.ts

@@ -1,16 +0,0 @@
-export * from './keccak/index.js';
-export * from './random/index.js';
-export * from './sha256/index.js';
-export * from './sha512/index.js';
-export * from './pedersen/index.js';
-export * from './poseidon/index.js';
-export * from './secp256k1-signer/index.js';
-export * from './keys/index.js';
-export * from './aes128/index.js';
-export * from './bn254/index.js';
-export * from './grumpkin/index.js';
-export * from './ecdsa/index.js';
-export * from './secp256k1/index.js';
-export * from './schnorr/index.js';
-export * from './signature/index.js';
-export * from './bls/index.js';

package/src/fields/coordinate.ts

@@ -1,104 +0,0 @@
-import { toBigIntBE } from '../bigint-buffer/index.js';
-import type { Tuple } from '../serialize/types.js';
-import { Fr } from './fields.js';
-
-/**
- * Class to wrap a single point coordinate.
- * This class handles the complexities of representing point coordinates as 32 byte buffers as well as fields.
- * The coordinate value is split across 2 fields to ensure that the max size of a field is not breached.
- * This is achieved by placing the most significant byte of the lower field into the least significant byte of the higher field.
- * Calls to 'toBuffer' or 'toBigInt' undo this change and simply return the original 32 byte value.
- * Calls to 'toFieldsBuffer' will return a 64 bytes buffer containing the serialized fields.
- */
-export class Coordinate {
-  static ZERO = new Coordinate([Fr.ZERO, Fr.ZERO]);
-
-  constructor(
-    /**
-     * The fields of the coordinate value. Least significant limb at index 0.
-     */
-    public fields: Tuple<Fr, 2>,
-  ) {}
-
-  /**
-   * Converts the coordinate data into a tuple of fields
-   * @returns A tuple of the coordinate fields
-   */
-  toFields(): Tuple<Fr, 2> {
-    return this.fields;
-  }
-
-  /**
-   * Generates a random coordinate value
-   * @returns The random coordinate
-   */
-  static random(): Coordinate {
-    return this.fromField(Fr.random());
-  }
-
-  /**
-   * serializes the object to buffer of 2 fields.
-   * @returns A buffer serialization of the object.
-   */
-  toFieldsBuffer(): Buffer {
-    return Buffer.concat([this.fields[0].toBuffer(), this.fields[1].toBuffer()]);
-  }
-
-  /**
-   * serializes the coordinate to a single 32 byte buffer.
-   * @returns A buffer serialization of the object.
-   */
-  toBuffer(): Buffer {
-    const buf0 = this.fields[0].toBuffer();
-    const buf1 = this.fields[1].toBuffer();
-    buf0[0] = buf1[31];
-    return buf0;
-  }
-
-  /**
-   * Returns true if this coordinate is equal to the one provided
-   * @param other - The coordinate against which to compare
-   * @returns True if the coordinates are the same, false otherwise
-   */
-  equals(other: Coordinate): boolean {
-    return this.toBigInt() === other.toBigInt();
-  }
-
-  /**
-   * Returns the coordinate's value as a bigint
-   * @returns The coordinate value as a bigint
-   */
-  toBigInt(): bigint {
-    return toBigIntBE(this.toBuffer());
-  }
-
-  /**
-   * Creates a coordinate object from a 32 byte coordinate value
-   * @param coordinate - A buffer containing the 32 byte coordinate value
-   * @returns The new coordinate object
-   */
-  static fromBuffer(coordinate: Buffer) {
-    if (coordinate.length != 32) {
-      throw new Error(`Invalid size of coordinate buffer`);
-    }
-    const buf0 = Buffer.alloc(32);
-    coordinate.copy(buf0, 0, 0, 32);
-    const buf1 = Buffer.alloc(32);
-    buf1[31] = buf0[0];
-    buf0[0] = 0;
-    return new Coordinate([Fr.fromBuffer(buf0), Fr.fromBuffer(buf1)]);
-  }
-
-  /**
-   * Creates a coordinate object from a field
-   * @param coordinate - The field containing the coordinate
-   * @returns The new coordinate object
-   */
-  static fromField(coordinate: Fr) {
-    const buf0 = coordinate.toBuffer();
-    const buf1 = Buffer.alloc(32);
-    buf1[31] = buf0[0];
-    buf0[0] = 0;
-    return new Coordinate([Fr.fromBuffer(buf0), Fr.fromBuffer(buf1)]);
-  }
-}

package/src/fields/index.ts

@@ -1,5 +0,0 @@
-export * from './fields.js';
-export * from './point.js';
-export * from './coordinate.js';
-export * from './bls12_fields.js';
-export * from './bls12_point.js';

package/src/index.ts

@@ -1,30 +0,0 @@
-// Reexport all folders at the root for packages targeting CommonJS
-export * as asyncMap from './async-map/index.js';
-export * as bigintBuffer from './bigint-buffer/index.js';
-export * as collection from './collection/index.js';
-export * as committable from './committable/index.js';
-export * as crypto from './crypto/index.js';
-export * as errors from './error/index.js';
-export * as ethAddress from './eth-address/index.js';
-export * as fields from './fields/index.js';
-export * as fifo from './queue/index.js';
-export * as fs from './fs/index.js';
-export * as jsonRpc from './json-rpc/index.js';
-export * as jsonRpcClient from './json-rpc/client/index.js';
-export * as jsonRpcServer from './json-rpc/server/index.js';
-export * as log from './log/index.js';
-export * as mutex from './mutex/index.js';
-export * as retry from './retry/index.js';
-export * as runningPromise from './running-promise/index.js';
-export * as serialize from './serialize/index.js';
-export * as sleep from './sleep/index.js';
-export * as timer from './timer/index.js';
-export * as transport from './transport/index.js';
-export * as trees from './trees/index.js';
-export * as types from './types/index.js';
-export * as url from './url/index.js';
-export * as testing from './testing/index.js';
-export * as profiler from './profiler/index.js';
-export * as config from './config/index.js';
-export * as buffer from './buffer/index.js';
-export * as ethSignature from './eth-signature/index.js';

package/src/trees/unbalanced_merkle_tree.ts

@@ -1,111 +0,0 @@
-import { sha256Trunc } from '../crypto/sha256/index.js';
-import { MerkleTreeCalculator } from './merkle_tree_calculator.js';
-
-/**
- * Computes the Merkle root of an unbalanced tree.
- *
- * Unlike a balanced Merkle tree, which requires the number of leaves to be a power of two, an unbalanced tree can have
- * any number of leaves.
- *
- * The tree is constructed by iteratively extracting the smallest power-of-two-sized subtrees from **right to left**.
- * For each such subtree, it computes the subtree root and then combines all subtree roots (again from right to left)
- * into a single root using the provided hash function.
- *
- * Note: We need the final tree to be as shallow as possible, to minimize the size of the sibling path required to prove
- * membership of a leaf. Therefor, the computation proceeds from right to left - smaller subtrees must always be
- * combined before being merged with a larger sibling on their left.
- *
- * For example, consider an unbalanced tree made of three subtrees of sizes 2, 4, and 8. If we combine the size-2 and
- * size-4 subtrees first (producing a subtree of depth 3), and then merge it with the size-8 subtree (also depth 3), the
- * resulting tree has a maximum depth of 4.
- *
- * But if we instead combine the size-4 and size-8 subtrees first (depth 4), and then merge with the size-2 subtree
- * (depth 1), the final tree has a depth of 5.
- */
-export function computeUnbalancedMerkleTreeRoot(leaves: Buffer[], hasher = sha256Trunc): Buffer {
-  if (!leaves.length) {
-    throw new Error('Cannot compute a Merkle root with no leaves');
-  }
-
-  if (leaves.length === 1) {
-    return leaves[0];
-  }
-
-  let numRemainingLeaves = leaves.length;
-  let subtreeSize = 1;
-  let root: Buffer | undefined;
-  while (numRemainingLeaves > 1) {
-    if ((numRemainingLeaves & subtreeSize) !== 0) {
-      const subtreeLeaves = leaves.slice(numRemainingLeaves - subtreeSize, numRemainingLeaves);
-      const subtreeRoot = MerkleTreeCalculator.computeTreeRootSync(subtreeLeaves, hasher);
-      if (!root) {
-        root = subtreeRoot;
-      } else {
-        root = hasher(Buffer.concat([subtreeRoot, root]));
-      }
-
-      numRemainingLeaves -= subtreeSize;
-    }
-
-    subtreeSize *= 2;
-  }
-
-  return root!;
-}
-
-/// 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);
-}