@aztec/pxe 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/src/contract_function_simulator/anchored_contract_data.ts

@@ -0,0 +1,74 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { FunctionArtifactWithContractName, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstancePreimageWithAddress } from '@aztec/stdlib/contract';
+import type { BlockHeader, ContractOverrides } from '@aztec/stdlib/tx';
+
+import type { ContractClassService } from '../contract/contract_class_service.js';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+
+/**
+ * Per-run view of contract data for a single simulation, bound to its anchor block.
+ *
+ * The {@link ContractStore} is pure class-id-keyed storage and has no notion of which class an address runs. This
+ * class bridges that gap: it resolves an address to its current class id (via the {@link ContractClassService}
+ * at the run's anchor block) and then serves artifacts from the store. It is also the single place contract
+ * overrides are applied — when an address is overridden, both its instance and its class id come from the override
+ * rather than the chain, so a simulation can execute different bytecode at that address. Overrides are only set for
+ * `simulateTx` (which skips the kernels), so the override path never reaches proving.
+ */
+export class AnchoredContractData {
+  constructor(
+    private readonly store: ContractStore,
+    private readonly contractClassService: ContractClassService,
+    private readonly anchorBlockHeader: BlockHeader,
+    private readonly overrides?: ContractOverrides,
+  ) {}
+
+  /** Returns the address preimage of the instance at `address`, from the override if any, else from storage. */
+  getContractInstance(address: AztecAddress): Promise<ContractInstancePreimageWithAddress | undefined> {
+    const override = this.overrides?.[address.toString()];
+    if (override) {
+      return Promise.resolve(override.instance);
+    }
+    return this.store.getContractInstance(address);
+  }
+
+  /**
+   * Resolves the class id `address` runs in this simulation: the override's class if overridden, else resolved against
+   * the chain at the anchor block.
+   */
+  getCurrentClassId(address: AztecAddress): Promise<Fr | undefined> {
+    const override = this.overrides?.[address.toString()];
+    if (override) {
+      return Promise.resolve(override.instance.currentContractClassId);
+    }
+    return this.contractClassService.getCurrentClassId(address, this.anchorBlockHeader);
+  }
+
+  async getFunctionArtifact(
+    address: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<FunctionArtifactWithContractName | undefined> {
+    const classId = await this.getCurrentClassId(address);
+    return classId ? this.store.getFunctionArtifact(classId, selector) : undefined;
+  }
+
+  async getFunctionArtifactWithDebugMetadata(
+    address: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<FunctionArtifactWithContractName | undefined> {
+    const classId = await this.getCurrentClassId(address);
+    return classId ? this.store.getFunctionArtifactWithDebugMetadata(classId, selector) : undefined;
+  }
+
+  async getDebugContractName(address: AztecAddress): Promise<string | undefined> {
+    const classId = await this.getCurrentClassId(address);
+    return classId ? this.store.getDebugContractName(classId) : undefined;
+  }
+
+  async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string> {
+    const classId = await this.getCurrentClassId(address);
+    return classId ? this.store.getDebugFunctionName(classId, selector) : `${address}:${selector}`;
+  }
+}

package/src/contract_function_simulator/benchmarked_node.ts

@@ -0,0 +1,103 @@
+import { Timer } from '@aztec/foundation/timer';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { NodeStats, RoundTripStats } from '@aztec/stdlib/tx';
+
+/*
+ * Proxy generator for an AztecNode that tracks the time taken for each RPC call and the number of round trips (actual
+ * blocking waits for node responses).
+ *
+ * A round trip is counted when we transition from 0 to 1 in-flight calls, and ends when all concurrent calls complete.
+ * This means parallel calls in Promise.all count as a single round trip.
+ *
+ * Note that batching of RPC calls in `safe_json_rpc_client.ts` could affect the round trip counts but in places we
+ * currently use this information we do not even use HTTP as we have direct access to the Aztec Node instance in TS
+ * (i.e. not running against external node) so this is not a problem for now.
+ *
+ * If you want to use this against external node and the info gets skewed by batching you can set the `maxBatchSize`
+ * value in `safe_json_rpc_client.ts` to 1 (the main motivation for batching was to get around parallel http requests
+ * limits in web browsers which is not a problem when debugging in node.js).
+ */
+export type BenchmarkedNode = AztecNode & { getStats(): NodeStats };
+
+export class BenchmarkedNodeFactory {
+  static create(node: AztecNode): BenchmarkedNode {
+    // Per-method call stats
+    const perMethod: Partial<Record<keyof AztecNode, { times: number[] }>> = {};
+
+    // Round trip tracking
+    let inFlightCount = 0;
+    let currentRoundTripTimer: Timer | null = null;
+    let currentRoundTripMethods: string[] = [];
+    const roundTrips: RoundTripStats = {
+      roundTrips: 0,
+      totalBlockingTime: 0,
+      roundTripDurations: [],
+      roundTripMethods: [],
+    };
+
+    return new Proxy(node, {
+      get(target, prop: keyof BenchmarkedNode) {
+        if (prop === 'getStats') {
+          return (): NodeStats => {
+            return { perMethod, roundTrips };
+          };
+        } else {
+          return function (...args: any[]) {
+            // Track per-method stats
+            if (!perMethod[prop]) {
+              perMethod[prop] = { times: [] };
+            }
+
+            // Start of a new round trip batch?
+            if (inFlightCount === 0) {
+              roundTrips.roundTrips++;
+              currentRoundTripTimer = new Timer();
+              currentRoundTripMethods = [];
+            }
+            inFlightCount++;
+            currentRoundTripMethods.push(prop);
+
+            const callTimer = new Timer();
+            const result = (target[prop] as any).apply(target, args);
+
+            // Handle completion - called when the call finishes (after Promise resolves)
+            const handleCompletion = () => {
+              const callTime = callTimer.ms();
+              perMethod[prop]!.times.push(callTime);
+
+              inFlightCount--;
+
+              // End of round trip batch - all concurrent calls completed
+              if (inFlightCount === 0 && currentRoundTripTimer) {
+                const roundTripTime = currentRoundTripTimer.ms();
+                roundTrips.totalBlockingTime += roundTripTime;
+                roundTrips.roundTripDurations.push(roundTripTime);
+                roundTrips.roundTripMethods.push(currentRoundTripMethods);
+                currentRoundTripTimer = null;
+                currentRoundTripMethods = [];
+              }
+            };
+
+            // If the result is a Promise, chain the completion handler
+            if (result && typeof result.then === 'function') {
+              return result.then(
+                (value: any) => {
+                  handleCompletion();
+                  return value;
+                },
+                (error: any) => {
+                  handleCompletion();
+                  throw error;
+                },
+              );
+            } else {
+              // Synchronous method - handle completion immediately
+              handleCompletion();
+              return result;
+            }
+          };
+        }
+      },
+    }) as BenchmarkedNode;
+  }
+}