@aztec/pxe 0.0.0-test.0

package/src/pxe_oracle_interface/tagging_utils.ts

@@ -0,0 +1,32 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { IndexedTaggingSecret } from '@aztec/stdlib/logs';
+
+// Half the size of the window we slide over the tagging secret indexes.
+export const WINDOW_HALF_SIZE = 10;
+
+export function getIndexedTaggingSecretsForTheWindow(
+  secretsAndWindows: { appTaggingSecret: Fr; leftMostIndex: number; rightMostIndex: number }[],
+): IndexedTaggingSecret[] {
+  const secrets: IndexedTaggingSecret[] = [];
+  for (const secretAndWindow of secretsAndWindows) {
+    for (let i = secretAndWindow.leftMostIndex; i <= secretAndWindow.rightMostIndex; i++) {
+      secrets.push(new IndexedTaggingSecret(secretAndWindow.appTaggingSecret, i));
+    }
+  }
+  return secrets;
+}
+
+/**
+ * Creates a map from app tagging secret to initial index.
+ * @param indexedTaggingSecrets - The indexed tagging secrets to get the initial indexes from.
+ * @returns The map from app tagging secret to initial index.
+ */
+export function getInitialIndexesMap(indexedTaggingSecrets: IndexedTaggingSecret[]): { [k: string]: number } {
+  const initialIndexes: { [k: string]: number } = {};
+
+  for (const indexedTaggingSecret of indexedTaggingSecrets) {
+    initialIndexes[indexedTaggingSecret.appTaggingSecret.toString()] = indexedTaggingSecret.index;
+  }
+
+  return initialIndexes;
+}

package/src/pxe_service/error_enriching.ts

@@ -0,0 +1,106 @@
+import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import { resolveAssertionMessageFromRevertData, resolveOpcodeLocations } from '@aztec/simulator/client';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type SimulationError, isNoirCallStackUnresolved } from '@aztec/stdlib/errors';
+
+import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
+
+/**
+ * Adds contract and function names to a simulation error, if they
+ * can be found in the PXE database
+ * @param err - The error to enrich.
+ */
+export async function enrichSimulationError(
+  err: SimulationError,
+  contractDataProvider: ContractDataProvider,
+  logger: Logger,
+) {
+  // Maps contract addresses to the set of function names that were in error.
+  // Map and Set do reference equality for their keys instead of value equality, so we store the string
+  // representation to get e.g. different contract address objects with the same address value to match.
+  const mentionedFunctions: Map<string, Set<string>> = new Map();
+
+  err.getCallStack().forEach(({ contractAddress, functionName }) => {
+    if (!mentionedFunctions.has(contractAddress.toString())) {
+      mentionedFunctions.set(contractAddress.toString(), new Set());
+    }
+    mentionedFunctions.get(contractAddress.toString())!.add(functionName?.toString() ?? '');
+  });
+
+  await Promise.all(
+    [...mentionedFunctions.entries()].map(async ([contractAddress, fnNames]) => {
+      const parsedContractAddress = AztecAddress.fromString(contractAddress);
+      const contract = await contractDataProvider.getContract(parsedContractAddress);
+      if (contract) {
+        err.enrichWithContractName(parsedContractAddress, contract.name);
+        for (const fnName of fnNames) {
+          const functionArtifact = contract.functions.find(f => fnName === f.name);
+          if (functionArtifact) {
+            err.enrichWithFunctionName(
+              parsedContractAddress,
+              await FunctionSelector.fromNameAndParameters(functionArtifact),
+              functionArtifact.name,
+            );
+          } else {
+            logger.warn(
+              `Could not find function artifact in contract ${contract.name} for function '${fnName}' when enriching error callstack`,
+            );
+          }
+        }
+      } else {
+        logger.warn(
+          `Could not find contract in database for address: ${parsedContractAddress} when enriching error callstack`,
+        );
+      }
+    }),
+  );
+}
+
+export async function enrichPublicSimulationError(
+  err: SimulationError,
+  contractDataProvider: ContractDataProvider,
+  logger: Logger,
+) {
+  const callStack = err.getCallStack();
+  const originalFailingFunction = callStack[callStack.length - 1];
+  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Properly fix this.
+  // To be able to resolve the assertion message, we need to use the information from the public dispatch function,
+  // no matter what the call stack selector points to (since we've modified it to point to the target function).
+  // We should remove this because the AVM (or public protocol) shouldn't be aware of the public dispatch calling convention.
+
+  const artifact = await contractDataProvider.getFunctionArtifact(
+    originalFailingFunction.contractAddress,
+    FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
+  );
+  const assertionMessage = resolveAssertionMessageFromRevertData(err.revertData, artifact);
+  if (assertionMessage) {
+    err.setOriginalMessage(err.getOriginalMessage() + `${assertionMessage}`);
+  }
+
+  const debugInfo = await contractDataProvider.getFunctionDebugMetadata(
+    originalFailingFunction.contractAddress,
+    FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
+  );
+
+  const noirCallStack = err.getNoirCallStack();
+  if (debugInfo) {
+    if (isNoirCallStackUnresolved(noirCallStack)) {
+      try {
+        // Public functions are simulated as a single Brillig entry point.
+        // Thus, we can safely assume here that the Brillig function id is `0`.
+        const parsedCallStack = resolveOpcodeLocations(noirCallStack, debugInfo, 0);
+        err.setNoirCallStack(parsedCallStack);
+      } catch (err) {
+        logger.warn(
+          `Could not resolve noir call stack for ${originalFailingFunction.contractAddress.toString()}:${
+            originalFailingFunction.functionName?.toString() ?? ''
+          }: ${err}`,
+        );
+      }
+    }
+    await enrichSimulationError(err, contractDataProvider, logger);
+  }
+}

package/src/pxe_service/index.ts

@@ -0,0 +1,2 @@
+export * from './pxe_service.js';
+export { enrichPublicSimulationError } from './error_enriching.js';