@aztec/foundation 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/src/trees/indexed_merkle_tree.ts

@@ -1,4 +1,4 @@
-import { Fr } from '../fields/index.js';
+import { Fr } from '../curves/bn254/index.js';
 import { assertLength } from '../serialize/index.js';
 import type { IndexedTreeLeafPreimage } from './indexed_tree_leaf.js';
 import { MembershipWitness } from './membership_witness.js';

package/src/trees/membership_witness.ts

@@ -1,6 +1,6 @@
 import { assertMemberLength } from '../array/array.js';
 import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
-import { Fr } from '../fields/fields.js';
+import { Fr } from '../curves/bn254/field.js';
 import { schemas } from '../schemas/schemas.js';
 import { BufferReader, type Tuple, serializeToBuffer } from '../serialize/index.js';
 import type { SiblingPath } from './sibling_path.js';

package/src/trees/merkle_tree_calculator.ts

@@ -1,4 +1,4 @@
-import { pedersenHash, sha256Trunc } from '@aztec/foundation/crypto';
+import { pedersenHash } from '@aztec/foundation/crypto/pedersen';
 
 import type { AsyncHasher } from './hasher.js';
 import { MerkleTree } from './merkle_tree.js';
@@ -69,37 +69,4 @@ export class MerkleTreeCalculator {
 
     return leaves[0];
   }
-
-  /**
-   * Computes the Merkle root with the provided leaves **synchronously**.
-   *
-   * This method uses a synchronous hash function (defaults to `sha256Trunc`) and **does not** allow for padding.
-   * If the number of leaves is not a power of two, it throws an error.
-   * This contrasts with the above non-static async method `computeTreeRoot`, which can handle any number of leaves by
-   * padding with zero hashes.
-   */
-  static computeTreeRootSync(leaves: Buffer[], hasher = sha256Trunc): Buffer {
-    if (leaves.length === 0) {
-      throw new Error('Cannot compute a Merkle root with no leaves');
-    }
-
-    const height = Math.log2(leaves.length);
-    if (!Number.isInteger(height)) {
-      throw new Error('Cannot compute a Merkle root with a non-power-of-two number of leaves');
-    }
-
-    let nodes = leaves.slice();
-
-    for (let i = 0; i < height; ++i) {
-      let j = 0;
-      for (; j < nodes.length / 2; ++j) {
-        const l = nodes[j * 2];
-        const r = nodes[j * 2 + 1];
-        nodes[j] = hasher(Buffer.concat([l, r]));
-      }
-      nodes = nodes.slice(0, j);
-    }
-
-    return nodes[0];
-  }
 }

package/src/trees/sibling_path.ts

@@ -1,6 +1,6 @@
 import { makeTuple } from '../array/array.js';
-import { pedersenHash } from '../crypto/index.js';
-import { Fr } from '../fields/index.js';
+import { pedersenHash } from '../crypto/pedersen/index.js';
+import { Fr } from '../curves/bn254/index.js';
 import { schemas } from '../schemas/index.js';
 import {
   type Tuple,

package/src/trees/unbalanced_merkle_tree.ts

@@ -1,5 +1,14 @@
-import { sha256Trunc } from '../crypto/sha256/index.js';
-import { MerkleTreeCalculator } from './merkle_tree_calculator.js';
+import {
+  computeBalancedMerkleTreeRoot,
+  computeBalancedMerkleTreeRootAsync,
+  poseidonMerkleHash,
+  shaMerkleHash,
+} from './balanced_merkle_tree.js';
+
+export const computeUnbalancedShaRoot = (leaves: Buffer[]) => computeUnbalancedMerkleTreeRoot(leaves, shaMerkleHash);
+
+export const computeUnbalancedPoseidonRoot = async (leaves: Buffer[]) =>
+  await computeUnbalancedMerkleTreeRootAsync(leaves, poseidonMerkleHash);
 
 /**
  * Computes the Merkle root of an unbalanced tree.
@@ -22,9 +31,48 @@ import { MerkleTreeCalculator } from './merkle_tree_calculator.js';
  * 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 {
+export function computeUnbalancedMerkleTreeRoot(
+  leaves: Buffer[],
+  hasher = shaMerkleHash,
+  emptyRoot = Buffer.alloc(32),
+): Buffer {
+  if (!leaves.length) {
+    return emptyRoot;
+  }
+
+  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 = computeBalancedMerkleTreeRoot(subtreeLeaves, hasher);
+      if (!root) {
+        root = subtreeRoot;
+      } else {
+        root = hasher(subtreeRoot, root);
+      }
+
+      numRemainingLeaves -= subtreeSize;
+    }
+
+    subtreeSize *= 2;
+  }
+
+  return root!;
+}
+
+export async function computeUnbalancedMerkleTreeRootAsync(
+  leaves: Buffer[],
+  hasher = poseidonMerkleHash,
+  emptyRoot = Buffer.alloc(32),
+): Promise<Buffer> {
   if (!leaves.length) {
-    throw new Error('Cannot compute a Merkle root with no leaves');
+    return emptyRoot;
   }
 
   if (leaves.length === 1) {
@@ -37,11 +85,11 @@ export function computeUnbalancedMerkleTreeRoot(leaves: Buffer[], hasher = sha25
   while (numRemainingLeaves > 1) {
     if ((numRemainingLeaves & subtreeSize) !== 0) {
       const subtreeLeaves = leaves.slice(numRemainingLeaves - subtreeSize, numRemainingLeaves);
-      const subtreeRoot = MerkleTreeCalculator.computeTreeRootSync(subtreeLeaves, hasher);
+      const subtreeRoot = await computeBalancedMerkleTreeRootAsync(subtreeLeaves, hasher);
       if (!root) {
         root = subtreeRoot;
       } else {
-        root = hasher(Buffer.concat([subtreeRoot, root]));
+        root = await hasher(subtreeRoot, root);
       }
 
       numRemainingLeaves -= subtreeSize;
@@ -63,7 +111,7 @@ function getMaxBalancedSubtreeDepth(numLeaves: number) {
 }
 
 /// Get the maximum depth of an unbalanced tree that can be created with the given number of leaves.
-export function getMaxUnbalancedTreeDepth(numLeaves: number) {
+function getMaxUnbalancedTreeDepth(numLeaves: number) {
   return Math.ceil(Math.log2(numLeaves));
 }
 

package/src/trees/unbalanced_merkle_tree_calculator.ts

@@ -1,37 +1,52 @@
-import { type Bufferable, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { AsyncHasher } from '@aztec/foundation/trees';
-import { SiblingPath } from '@aztec/foundation/trees';
-
-import { sha256Trunc } from '../crypto/index.js';
+import { shaMerkleHash } from './balanced_merkle_tree.js';
+import type { Hasher } from './hasher.js';
+import { SiblingPath } from './sibling_path.js';
+import { type TreeNodeLocation, UnbalancedTreeStore } from './unbalanced_tree_store.js';
+
+export function computeCompressedUnbalancedMerkleTreeRoot(
+  leaves: Buffer[],
+  valueToCompress = Buffer.alloc(32),
+  emptyRoot = Buffer.alloc(32),
+  hasher?: Hasher['hash'],
+): Buffer {
+  const calculator = UnbalancedMerkleTreeCalculator.create(leaves, valueToCompress, emptyRoot, hasher);
+  return calculator.getRoot();
+}
 
-const indexToKeyHash = (level: number, index: bigint) => `${level}:${index}`;
+interface TreeNode {
+  value: Buffer;
+  leafIndex?: number;
+}
 
 /**
  * An ephemeral unbalanced Merkle tree implementation.
  * Follows the rollup implementation which greedily hashes pairs of nodes up the tree.
  * Remaining rightmost nodes are shifted up until they can be paired.
+ * The values that match the `valueToCompress` are skipped and the sibling of the compressed leaf are shifted up until
+ * they can be paired.
  * If there is only one leaf, the root is the leaf.
  */
 export class UnbalancedMerkleTreeCalculator {
-  // This map stores index and depth -> value
-  private cache: { [key: string]: Buffer } = {};
-  // This map stores value -> index and depth, since we have variable depth
-  private valueCache: { [key: string]: string } = {};
-  protected size: bigint = 0n;
-
-  root: Buffer = Buffer.alloc(32);
+  private store: UnbalancedTreeStore<TreeNode>;
+  private leafLocations: TreeNodeLocation[] = [];
 
   public constructor(
-    private maxDepth: number,
-    private hasher: AsyncHasher['hash'],
-  ) {}
+    private readonly leaves: Buffer[],
+    private readonly valueToCompress: Buffer,
+    private readonly emptyRoot: Buffer,
+    private readonly hasher: Hasher['hash'],
+  ) {
+    this.store = new UnbalancedTreeStore(leaves.length);
+    this.buildTree();
+  }
 
   static create(
-    height: number,
-    hasher = (left: Buffer, right: Buffer) =>
-      Promise.resolve(sha256Trunc(Buffer.concat([left, right])) as Buffer<ArrayBuffer>),
+    leaves: Buffer[],
+    valueToCompress = Buffer.alloc(0),
+    emptyRoot = Buffer.alloc(32),
+    hasher = shaMerkleHash,
   ) {
-    return new UnbalancedMerkleTreeCalculator(height, hasher);
+    return new UnbalancedMerkleTreeCalculator(leaves, valueToCompress, emptyRoot, hasher);
   }
 
   /**
@@ -39,108 +54,134 @@ export class UnbalancedMerkleTreeCalculator {
    * @returns The root of the tree.
    */
   public getRoot(): Buffer {
-    return this.root;
+    return this.store.getRoot()!.value;
   }
 
   /**
-   * Returns a sibling path for the element at the given index.
+   * Returns a sibling path for the element.
    * @param value - The value of the element.
    * @returns A sibling path for the element.
    * Note: The sibling path is an array of sibling hashes, with the lowest hash (leaf hash) first, and the highest hash last.
    */
-  public getSiblingPath<N extends number>(value: Bufferable): Promise<SiblingPath<N>> {
-    if (this.size === 1n) {
-      return Promise.resolve(new SiblingPath<N>(0 as N, []));
+  public getSiblingPath<N extends number>(value: Buffer): SiblingPath<N> {
+    const leafIndex = this.leaves.findIndex(leaf => leaf.equals(value));
+    if (leafIndex === -1) {
+      throw Error(`Leaf value ${value.toString('hex')} not found in tree.`);
     }
 
-    const path: Buffer[] = [];
-    const [depth, _index] = this.valueCache[serializeToBuffer(value).toString('hex')].split(':');
-    let level = parseInt(depth, 10);
-    let index = BigInt(_index);
-    while (level > 0) {
-      const isRight = index & 0x01n;
-      const key = indexToKeyHash(level, isRight ? index - 1n : index + 1n);
-      const sibling = this.cache[key];
-      path.push(sibling);
-      level -= 1;
-      index >>= 1n;
-    }
-    return Promise.resolve(new SiblingPath<N>(parseInt(depth, 10) as N, path));
+    return this.getSiblingPathByLeafIndex(leafIndex);
   }
 
   /**
-   * Appends the given leaves to the tree.
-   * @param leaves - The leaves to append.
-   * @returns Empty promise.
+   * Returns a sibling path for the leaf at the given index.
+   * @param leafIndex - The index of the leaf.
+   * @returns A sibling path for the leaf.
    */
-  public async appendLeaves(leaves: Buffer[]): Promise<void> {
-    if (this.size != BigInt(0)) {
-      throw Error(`Can't re-append to an unbalanced tree. Current has ${this.size} leaves.`);
+  public getSiblingPathByLeafIndex<N extends number>(leafIndex: number): SiblingPath<N> {
+    if (leafIndex >= this.leaves.length) {
+      throw Error(`Leaf index ${leafIndex} out of bounds. Tree has ${this.leaves.length} leaves.`);
     }
-    if (leaves.length === 0) {
-      throw Error(`Can't append 0 leaves to an unbalanced tree.`);
+
+    const leaf = this.leaves[leafIndex];
+    if (leaf.equals(this.valueToCompress)) {
+      throw Error(`Leaf at index ${leafIndex} has been compressed.`);
     }
 
-    if (leaves.length === 1) {
-      this.root = leaves[0];
-    } else {
-      this.root = await this.batchInsert(leaves);
+    const path: Buffer[] = [];
+    let location = this.leafLocations[leafIndex];
+    while (location.level > 0) {
+      const sibling = this.store.getSibling(location)!;
+      path.push(sibling.value);
+      location = this.store.getParentLocation(location);
     }
 
-    this.size = BigInt(leaves.length);
+    return new SiblingPath<N>(path.length as N, path);
+  }
 
-    return Promise.resolve();
+  public getLeafLocation(leafIndex: number) {
+    return this.leafLocations[leafIndex];
   }
 
   /**
-   * Calculates root while adding leaves and nodes to the cache.
-   * @param leaves - The leaves to append.
-   * @returns Resulting root of the tree.
+   * Adds leaves and nodes to the store. Updates the leafLocations.
+   * @param leaves - The leaves of the tree.
    */
-  private async batchInsert(_leaves: Buffer[]): Promise<Buffer> {
-    // If we have an even number of leaves, hash them all in pairs
-    // Otherwise, store the final leaf to be shifted up to the next odd sized level
-    let [layerWidth, nodeToShift] =
-      _leaves.length & 1
-        ? [_leaves.length - 1, serializeToBuffer(_leaves[_leaves.length - 1])]
-        : [_leaves.length, Buffer.alloc(0)];
-    // Allocate this layer's leaves and init the next layer up
-    let thisLayer = _leaves.slice(0, layerWidth).map(l => serializeToBuffer(l));
-    let nextLayer = [];
-    // Store the bottom level leaves
-    thisLayer.forEach((leaf, i) => this.storeNode(leaf, this.maxDepth, BigInt(i)));
-    for (let i = 0; i < this.maxDepth; i++) {
-      for (let j = 0; j < layerWidth; j += 2) {
-        // Store the hash of each pair one layer up
-        nextLayer[j / 2] = await this.hasher(serializeToBuffer(thisLayer[j]), serializeToBuffer(thisLayer[j + 1]));
-        this.storeNode(nextLayer[j / 2], this.maxDepth - i - 1, BigInt(j >> 1));
-      }
-      layerWidth /= 2;
-      if (layerWidth & 1) {
-        if (nodeToShift.length) {
-          // If the next layer has odd length, and we have a node that needs to be shifted up, add it here
-          nextLayer.push(serializeToBuffer(nodeToShift));
-          this.storeNode(nodeToShift, this.maxDepth - i - 1, BigInt((layerWidth * 2) >> 1));
-          layerWidth += 1;
-          nodeToShift = Buffer.alloc(0);
+  private buildTree() {
+    this.leafLocations = this.leaves.map((value, i) => this.store.setLeaf(i, { value, leafIndex: i }));
+
+    // Start with the leaves that are not compressed.
+    let toProcess = this.leafLocations.filter((_, i) => !this.leaves[i].equals(this.valueToCompress));
+    if (!toProcess.length) {
+      // All leaves are compressed. Set empty root to the root.
+      this.store.setNode({ level: 0, index: 0 }, { value: this.emptyRoot });
+      return;
+    }
+
+    const level = toProcess[0].level;
+    for (let i = level; i > 0; i--) {
+      const toProcessNext = [];
+      for (const location of toProcess) {
+        if (location.level !== i) {
+          toProcessNext.push(location);
+          continue;
+        }
+
+        const parentLocation = this.store.getParentLocation(location);
+        if (this.store.getNode(parentLocation)) {
+          // Parent has been updated by its (left) sibling.
+          continue;
+        }
+
+        const sibling = this.store.getSibling(location);
+        // If sibling is undefined, all its children are compressed.
+        const shouldShiftUp = !sibling || sibling.value.equals(this.valueToCompress);
+        if (shouldShiftUp) {
+          // The node becomes the parent if the sibling is a compressed leaf.
+          this.shiftNodeUp(location, parentLocation);
         } else {
-          // If we don't have a node waiting to be shifted, store the next layer's final node to be shifted
-          layerWidth -= 1;
-          nodeToShift = nextLayer[layerWidth];
+          // Hash the value with the (right) sibling and update the parent node.
+          const node = this.store.getNode(location)!;
+          const parentValue = this.hasher(node.value, sibling.value);
+          this.store.setNode(parentLocation, { value: parentValue });
         }
+
+        // Add the parent location to be processed next.
+        toProcessNext.push(parentLocation);
       }
-      // reset the layers
-      thisLayer = nextLayer;
-      nextLayer = [];
+
+      toProcess = toProcessNext;
     }
+  }
 
-    // return the root
-    return thisLayer[0];
+  private shiftNodeUp(from: TreeNodeLocation, to: TreeNodeLocation) {
+    // Collect all nodes that need to shift.
+    const nodesToShift = this.collectNodesToShift(from, to);
+    // Move all nodes to their new locations.
+    for (const { node, newLocation } of nodesToShift) {
+      this.store.setNode(newLocation, node);
+      if (node.leafIndex !== undefined) {
+        this.leafLocations[node.leafIndex] = newLocation;
+      }
+    }
   }
 
-  private storeNode(value: Buffer, depth: number, index: bigint) {
-    const key = indexToKeyHash(depth, index);
-    this.cache[key] = value;
-    this.valueCache[value.toString('hex')] = key;
+  private collectNodesToShift(from: TreeNodeLocation, to: TreeNodeLocation) {
+    const node = this.store.getNode(from);
+    if (!node) {
+      return [];
+    }
+
+    let result = [{ node, newLocation: to }];
+
+    // If not a leaf, collect its children.
+    if (node.leafIndex === undefined) {
+      const [leftChild, rightChild] = this.store.getChildLocations(from);
+      const [leftChildNew, rightChildNew] = this.store.getChildLocations(to);
+      result = result
+        .concat(this.collectNodesToShift(leftChild, leftChildNew))
+        .concat(this.collectNodesToShift(rightChild, rightChildNew));
+    }
+
+    return result;
   }
 }

package/src/trees/unbalanced_tree_store.ts

@@ -68,7 +68,7 @@ export class UnbalancedTreeStore<T> {
     return [left, right];
   }
 
-  getLeaf(leafIndex: number) {
+  getLeaf(leafIndex: number): T | undefined {
     const { level, indexAtLevel } = findLeafLevelAndIndex(this.#numLeaves, leafIndex);
     const location = {
       level,
@@ -81,6 +81,10 @@ export class UnbalancedTreeStore<T> {
     return this.#nodeMapping.get(this.#getKey(location))?.value;
   }
 
+  getRoot(): T | undefined {
+    return this.getNode({ level: 0, index: 0 });
+  }
+
   getParent(location: TreeNodeLocation): T | undefined {
     const parentLocation = this.getParentLocation(location);
     return this.getNode(parentLocation);

package/src/types/index.ts

@@ -19,6 +19,11 @@ export function unfreeze<T>(obj: T): Writeable<T> {
   return obj as Writeable<T>;
 }
 
+/** Is defined type guard */
+export function isDefined<T>(value: T | undefined): value is T {
+  return value !== undefined;
+}
+
 /** Resolves a record-like type. Lifted from viem. */
 export type Prettify<T> = {
   [K in keyof T]: T[K];

package/dest/crypto/index.d.ts

@@ -1,15 +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 './grumpkin/index.js';
-export * from './ecdsa/index.js';
-export * from './secp256k1/index.js';
-export * from './schnorr/index.js';
-export * from './signature/index.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/crypto/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC"}

package/dest/crypto/index.js

@@ -1,14 +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 './grumpkin/index.js';
-export * from './ecdsa/index.js';
-export * from './secp256k1/index.js';
-export * from './schnorr/index.js';
-export * from './signature/index.js';

package/dest/fields/bls12_fields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bls12_fields.d.ts","sourceRoot":"","sources":["../../src/fields/bls12_fields.ts"],"names":[],"mappings":"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"}

package/dest/fields/bls12_point.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bls12_point.d.ts","sourceRoot":"","sources":["../../src/fields/bls12_point.ts"],"names":[],"mappings":"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"}

package/dest/fields/coordinate.d.ts

@@ -1,66 +0,0 @@
-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 declare class Coordinate {
-    /**
-     * The fields of the coordinate value. Least significant limb at index 0.
-     */
-    fields: Tuple<Fr, 2>;
-    static ZERO: Coordinate;
-    constructor(
-    /**
-     * The fields of the coordinate value. Least significant limb at index 0.
-     */
-    fields: Tuple<Fr, 2>);
-    /**
-     * Converts the coordinate data into a tuple of fields
-     * @returns A tuple of the coordinate fields
-     */
-    toFields(): Tuple<Fr, 2>;
-    /**
-     * Generates a random coordinate value
-     * @returns The random coordinate
-     */
-    static random(): Coordinate;
-    /**
-     * serializes the object to buffer of 2 fields.
-     * @returns A buffer serialization of the object.
-     */
-    toFieldsBuffer(): Buffer;
-    /**
-     * serializes the coordinate to a single 32 byte buffer.
-     * @returns A buffer serialization of the object.
-     */
-    toBuffer(): Buffer;
-    /**
-     * 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;
-    /**
-     * Returns the coordinate's value as a bigint
-     * @returns The coordinate value as a bigint
-     */
-    toBigInt(): bigint;
-    /**
-     * 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): Coordinate;
-    /**
-     * Creates a coordinate object from a field
-     * @param coordinate - The field containing the coordinate
-     * @returns The new coordinate object
-     */
-    static fromField(coordinate: Fr): Coordinate;
-}
-//# sourceMappingURL=coordinate.d.ts.map

package/dest/fields/coordinate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"coordinate.d.ts","sourceRoot":"","sources":["../../src/fields/coordinate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEjC;;;;;;;GAOG;AACH,qBAAa,UAAU;IAInB;;OAEG;IACI,MAAM,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IAN7B,MAAM,CAAC,IAAI,aAAsC;;IAG/C;;OAEG;IACI,MAAM,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IAG7B;;;OAGG;IACH,QAAQ,IAAI,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IAIxB;;;OAGG;IACH,MAAM,CAAC,MAAM,IAAI,UAAU;IAI3B;;;OAGG;IACH,cAAc,IAAI,MAAM;IAIxB;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAOlB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAIlC;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,MAAM;IAYpC;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,UAAU,EAAE,EAAE;CAOhC"}