@aztec/foundation 2.1.0-rc.9 → 3.0.0-devnet.2

package/src/crypto/sync/poseidon/index.ts

@@ -1,4 +1,4 @@
-import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+import { BarretenbergSync } from '@aztec/bb.js';
 
 import { Fr } from '../../../fields/fields.js';
 import { type Fieldable, serializeToFields } from '../../../serialize/serialize.js';
@@ -10,10 +10,11 @@ import { type Fieldable, serializeToFields } from '../../../serialize/serialize.
  */
 export function poseidon2Hash(input: Fieldable[]): Fr {
   const inputFields = serializeToFields(input);
-  const hash = BarretenbergSync.getSingleton().poseidon2Hash(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-  );
-  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2Hash({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
+  return Fr.fromBuffer(Buffer.from(response.hash));
 }
 
 /**
@@ -26,18 +27,20 @@ export function poseidon2HashWithSeparator(input: Fieldable[], separator: number
   const inputFields = serializeToFields(input);
   inputFields.unshift(new Fr(separator));
 
-  const hash = BarretenbergSync.getSingleton().poseidon2Hash(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-  );
-  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2Hash({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
+  return Fr.fromBuffer(Buffer.from(response.hash));
 }
 
 export function poseidon2HashAccumulate(input: Fieldable[]): Fr {
   const inputFields = serializeToFields(input);
-  const result = BarretenbergSync.getSingleton().poseidon2HashAccumulate(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())),
-  );
-  return Fr.fromBuffer(Buffer.from(result.toBuffer()));
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2HashAccumulate({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
+  return Fr.fromBuffer(Buffer.from(response.hash));
 }
 
 /**
@@ -49,12 +52,13 @@ export function poseidon2Permutation(input: Fieldable[]): Fr[] {
   const inputFields = serializeToFields(input);
   // We'd like this assertion but it's not possible to use it in the browser.
   // assert(input.length === 4, 'Input state must be of size 4');
-  const res = BarretenbergSync.getSingleton().poseidon2Permutation(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())),
-  );
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2Permutation({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
   // We'd like this assertion but it's not possible to use it in the browser.
-  // assert(res.length === 4, 'Output state must be of size 4');
-  return res.map(o => Fr.fromBuffer(Buffer.from(o.toBuffer())));
+  // assert(response.outputs.length === 4, 'Output state must be of size 4');
+  return response.outputs.map(o => Fr.fromBuffer(Buffer.from(o)));
 }
 
 export function poseidon2HashBytes(input: Buffer): Fr {
@@ -68,9 +72,10 @@ export function poseidon2HashBytes(input: Buffer): Fr {
     inputFields.push(Fr.fromBuffer(fieldBytes));
   }
 
-  const res = BarretenbergSync.getSingleton().poseidon2Hash(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-  );
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2Hash({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
 
-  return Fr.fromBuffer(Buffer.from(res.toBuffer()));
+  return Fr.fromBuffer(Buffer.from(response.hash));
 }

package/src/fields/bls12_point.ts

@@ -158,13 +158,13 @@ export class BLS12Point {
   }
 
   /**
-   * Converts a Point to two BN254 Fr elements by storing its compressed form as:
-   * +------------------+------------------+
-   * | Field Element 1  | Field Element 2  |
-   * | [bytes 0-31]     | [bytes 32-47]   |
-   * +------------------+------------------+
-   * |     32 bytes     |     16 bytes    |
-   * +------------------+------------------+
+   * Converts a Point to two BN254 Fr elements by storing its compressed form (48 bytes) as:
+   * +-------------------+------------------------+
+   * |      31 bytes     |         17 bytes       |
+   * +-------------------+------------------------+
+   * |  Field Element 1  |     Field Element 2    |
+   * |  [0][bytes 0-30]  |  [0...0][bytes 31-47]  |
+   * +-------------------+------------------------+
    * Used in the rollup circuits to store blob commitments in the native field type. See blob.ts.
    * @param point - A BLS12Point instance.
    * @returns The point fields.

package/src/fields/fields.ts

@@ -321,15 +321,14 @@ export class Fr extends BaseField {
    * @returns A square root of the field element (null if it does not exist).
    */
   async sqrt(): Promise<Fr | null> {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const wasm = api.getWasm();
-    const [buf] = wasm.callWasmExport('bn254_fr_sqrt', [this.toBuffer()], [Fr.SIZE_IN_BYTES + 1]);
-    const isSqrt = buf[0] === 1;
-    if (!isSqrt) {
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.bn254FrSqrt({ input: this.toBuffer() });
+    if (!response.isSquareRoot) {
       // Field element is not a quadratic residue mod p so it has no square root.
       return null;
     }
-    return new Fr(Buffer.from(buf.slice(1)));
+    return Fr.fromBuffer(Buffer.from(response.value));
   }
 
   toJSON() {

package/src/index.ts

@@ -24,6 +24,7 @@ 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/json-rpc/client/safe_json_rpc_client.ts

@@ -178,6 +178,15 @@ export function createSafeJsonRpcClient<T extends object>(
         }
       }
     } catch (err) {
+      // Re-throw ComponentsVersionsError immediately without converting to JSON-RPC error
+      // This ensures version mismatch errors are surfaced to the user instead of being hidden
+      if (err && typeof err === 'object' && 'name' in err && err.name === 'ComponentsVersionsError') {
+        // Reject all pending requests with the version error
+        for (let i = 0; i < rpcCalls.length; i++) {
+          rpcCalls[i].deferred.reject(err);
+        }
+        return; // Return early, the promises are already rejected
+      }
       log.warn(`Failed to fetch from the remote server`, err);
       for (let i = 0; i < rpcCalls.length; i++) {
         const { request, deferred } = rpcCalls[i];

package/src/log/pino-logger.ts

@@ -111,7 +111,6 @@ const redactedPaths = [
   // bot keys
   'l1PrivateKey',
   'senderPrivateKey',
-  'recipientEncryptionSecret',
   // blob sink
   'l1ConsensusHostApiKeys',
   // sensitive options used in the CLI

package/src/profiler/index.ts

@@ -0,0 +1 @@
+export * from './profiler.js';

package/src/profiler/profiler.ts

@@ -0,0 +1,125 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { performance } from 'node:perf_hooks';
+
+interface Span {
+  label: string;
+  start: number;
+  dur: number;
+  count: number;
+  children: Span[];
+  parent: Span | undefined;
+}
+
+interface ProfileData {
+  spans: SerializedSpan[];
+  timestamp: string;
+  totalTime: number;
+}
+
+interface SerializedSpan {
+  label: string;
+  dur: number;
+  count: number;
+  children: SerializedSpan[];
+}
+
+const als = new AsyncLocalStorage<Span>();
+const roots: Span[] = [];
+
+function reset(): void {
+  roots.length = 0;
+}
+
+// Strip out circular references (parent) and unused fields (start) for JSON serialization
+function serializeSpans(spans: Span[]): SerializedSpan[] {
+  return spans.map(span => ({
+    label: span.label,
+    dur: span.dur,
+    count: span.count,
+    children: serializeSpans(span.children),
+  }));
+}
+
+let i = 0;
+function save(): void {
+  if (roots.length === 0) {
+    return;
+  }
+
+  // Find max single execution time across all spans (dur/count since dur is accumulated)
+  const findMaxSingleDuration = (spans: Span[]): number => {
+    let max = 0;
+    for (const span of spans) {
+      const singleDur = span.dur / span.count;
+      max = Math.max(max, singleDur);
+      if (span.children.length > 0) {
+        max = Math.max(max, findMaxSingleDuration(span.children));
+      }
+    }
+    return max;
+  };
+
+  const profileData: ProfileData = {
+    spans: serializeSpans(roots),
+    timestamp: new Date().toISOString(),
+    totalTime: findMaxSingleDuration(roots),
+  };
+
+  const profilePath = path.join(process.cwd(), `profile-${i++}.json`);
+  process.stdout.write(`Writing profile data to ${profilePath}\n`);
+  fs.writeFileSync(profilePath, JSON.stringify(profileData, null, 2));
+}
+
+// Hook into Jest to save after each test
+if (typeof afterEach === 'function') {
+  afterEach(() => {
+    save();
+    reset();
+  });
+}
+
+// Also save on process exit for non-Jest environments
+process.on('exit', () => {
+  save();
+});
+
+// Wrapper for async functions to maintain context properly
+async function runAsync<ReturnType>(label: string, fn: () => Promise<ReturnType>): Promise<ReturnType> {
+  const parent = als.getStore();
+
+  // Check if we already have a span with this label in the current context
+  let existingSpan: Span | undefined;
+  if (parent) {
+    existingSpan = parent.children.find(c => c.label === label);
+  } else {
+    existingSpan = roots.find(r => r.label === label);
+  }
+
+  let span: Span;
+  if (existingSpan) {
+    // Reuse existing span and increment count
+    span = existingSpan;
+    span.count++;
+  } else {
+    // Create new span
+    span = { label, start: performance.now(), dur: 0, count: 1, children: [], parent };
+    if (parent) {
+      parent.children.push(span);
+    } else {
+      roots.push(span);
+    }
+  }
+
+  const startTime = performance.now();
+  const result: ReturnType = await als.run(span, fn);
+  const elapsed = performance.now() - startTime;
+
+  // Add to total duration (for averaging)
+  span.dur += elapsed;
+
+  return result;
+}
+
+export const profiler = { reset, runAsync };

package/src/testing/formatting.ts

@@ -0,0 +1,3 @@
+export function toInlineStrArray(arr: { toString: () => string }[]): string {
+  return `[${arr.map(f => f.toString()).join(',')}]`;
+}

package/src/testing/index.ts

@@ -1,3 +1,4 @@
+export * from './formatting.js';
 export * from './snapshot_serializer.js';
 export * from './port_allocator.js';
 export * from './test_data.js';

package/src/trees/unbalanced_merkle_tree.ts

@@ -63,7 +63,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,53 @@
-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 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),
+  hasher?: Hasher['hash'],
+): Buffer {
+  const calculator = UnbalancedMerkleTreeCalculator.create(leaves, valueToCompress, 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 hasher: Hasher['hash'],
+  ) {
+    if (leaves.length === 0) {
+      throw Error('Cannot create a compressed unbalanced tree with 0 leaves.');
+    }
+
+    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),
+    hasher = (left: Buffer, right: Buffer) => sha256Trunc(Buffer.concat([left, right])) as Buffer<ArrayBuffer>,
   ) {
-    return new UnbalancedMerkleTreeCalculator(height, hasher);
+    return new UnbalancedMerkleTreeCalculator(leaves, valueToCompress, hasher);
   }
 
   /**
@@ -39,108 +55,140 @@ 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 0 to the root.
+      this.store.setNode({ level: 0, index: 0 }, { value: Buffer.alloc(32) });
+      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.
+          const isLeaf = this.shiftNodeUp(location, parentLocation);
+          if (!isLeaf) {
+            this.shiftChildrenUp(location);
+          }
         } 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;
     }
+  }
+
+  private shiftNodeUp(fromLocation: TreeNodeLocation, toLocation: TreeNodeLocation): boolean {
+    const node = this.store.getNode(fromLocation)!;
 
-    // return the root
-    return thisLayer[0];
+    this.store.setNode(toLocation, node);
+
+    const isLeaf = node.leafIndex !== undefined;
+    if (isLeaf) {
+      // Update the location if the node is a leaf.
+      this.leafLocations[node.leafIndex!] = toLocation;
+    }
+
+    return isLeaf;
   }
 
-  private storeNode(value: Buffer, depth: number, index: bigint) {
-    const key = indexToKeyHash(depth, index);
-    this.cache[key] = value;
-    this.valueCache[value.toString('hex')] = key;
+  private shiftChildrenUp(parent: TreeNodeLocation) {
+    const [left, right] = this.store.getChildLocations(parent);
+
+    const level = parent.level;
+    const groupSize = 2 ** level;
+    const computeNewLocation = (index: number) => ({
+      level,
+      index: Math.floor(index / (groupSize * 2)) * groupSize + (index % groupSize),
+    });
+
+    const isLeftLeaf = this.shiftNodeUp(left, computeNewLocation(left.index));
+    const isRightLeaf = this.shiftNodeUp(right, computeNewLocation(right.index));
+
+    if (!isLeftLeaf) {
+      this.shiftChildrenUp(left);
+    }
+    if (!isRightLeaf) {
+      this.shiftChildrenUp(right);
+    }
   }
 }

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