@aztec/end-to-end 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/src/fixtures/setup_p2p_test.ts

@@ -1,14 +1,13 @@
 /**
  * Test fixtures and utilities to set up and run a test using multiple validators
  */
-import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { type AztecNodeConfig, AztecNodeService, createAztecNodeService } from '@aztec/aztec-node';
 import { range } from '@aztec/foundation/array';
 import { SecretValue } from '@aztec/foundation/config';
 import { withLoggerBindings } from '@aztec/foundation/log/server';
 import { bufferToHex } from '@aztec/foundation/string';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { ProverNodeConfig, ProverNodeDeps } from '@aztec/prover-node';
-import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 
 import getPort from 'get-port';
 
@@ -41,7 +40,7 @@ export async function createNodes(
   bootstrapNodeEnr: string,
   numNodes: number,
   bootNodePort: number,
-  prefilledPublicData?: PublicDataTreeLeaf[],
+  genesis?: GenesisData,
   dataDirectory?: string,
   metricsPort?: number,
   indexOffset = 0,
@@ -66,7 +65,7 @@ export async function createNodes(
       port,
       bootstrapNodeEnr,
       validatorIndices,
-      prefilledPublicData,
+      genesis,
       dataDir,
       metricsPort,
     );
@@ -89,6 +88,10 @@ export type CreateNodeConfig = AztecNodeConfig & {
   dontStartSequencer?: boolean;
   /** Override the private key (instead of deriving from addressIndex). */
   validatorPrivateKey?: `0x${string}`;
+  /** Corrupt only the block proposal at this indexWithinCheckpoint (testing only). */
+  invalidBlockProposalIndexWithinCheckpoint?: number;
+  /** Accept proposal gossip regardless of slot timing (testing only). */
+  skipProposalSlotValidation?: boolean;
 };
 
 /** Creates a P2P enabled instance of Aztec Node Service with a validator. */
@@ -98,7 +101,7 @@ export async function createNode(
   tcpPort: number,
   bootstrapNode: string | undefined,
   addressIndex: number | number[],
-  prefilledPublicData?: PublicDataTreeLeaf[],
+  genesis?: GenesisData,
   dataDirectory?: string,
   metricsPort?: number,
 ) {
@@ -106,10 +109,10 @@ export async function createNode(
   return await withLoggerBindings({ actor: `validator-${actorIndex}` }, async () => {
     const validatorConfig = await createValidatorConfig(config, bootstrapNode, tcpPort, addressIndex, dataDirectory);
     const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
-    return await AztecNodeService.createAndSync(
+    return await createAztecNodeService(
       validatorConfig,
       { telemetry, dateProvider },
-      { prefilledPublicData, dontStartSequencer: config.dontStartSequencer },
+      { genesis, dontStartSequencer: config.dontStartSequencer },
     );
   });
 }
@@ -120,7 +123,7 @@ export async function createNonValidatorNode(
   dateProvider: DateProvider,
   tcpPort: number,
   bootstrapNode: string | undefined,
-  prefilledPublicData?: PublicDataTreeLeaf[],
+  genesis?: GenesisData,
   dataDirectory?: string,
   metricsPort?: number,
 ) {
@@ -131,10 +134,10 @@ export async function createNonValidatorNode(
       ...p2pConfig,
       disableValidator: true,
       validatorPrivateKeys: undefined,
-      publisherPrivateKeys: [],
+      sequencerPublisherPrivateKeys: [],
     };
     const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
-    return await AztecNodeService.createAndSync(config, { telemetry, dateProvider }, { prefilledPublicData });
+    return await createAztecNodeService(config, { telemetry, dateProvider }, { genesis });
   });
 }
 
@@ -143,31 +146,24 @@ export async function createProverNode(
   tcpPort: number,
   bootstrapNode: string | undefined,
   addressIndex: number,
-  proverNodeDeps: ProverNodeDeps & Required<Pick<ProverNodeDeps, 'dateProvider'>>,
-  prefilledPublicData?: PublicDataTreeLeaf[],
+  deps: { dateProvider: DateProvider },
+  genesis?: GenesisData,
   dataDirectory?: string,
   metricsPort?: number,
-) {
+): Promise<{ proverNode: AztecNodeService }> {
   const actorIndex = proverCounter++;
   return await withLoggerBindings({ actor: `prover-${actorIndex}` }, async () => {
     const proverNodePrivateKey = getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + addressIndex)!;
     const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
 
-    const proverConfig: Partial<ProverNodeConfig> = await createP2PConfig(
-      config,
-      bootstrapNode,
-      tcpPort,
-      dataDirectory,
-    );
+    const p2pConfig = await createP2PConfig(config, bootstrapNode, tcpPort, dataDirectory);
 
-    const aztecNodeRpcTxProvider = undefined;
     return await createAndSyncProverNode(
       bufferToHex(proverNodePrivateKey),
-      config,
-      { ...proverConfig, dataDirectory },
-      aztecNodeRpcTxProvider,
-      prefilledPublicData,
-      { ...proverNodeDeps, telemetry },
+      { ...config, ...p2pConfig },
+      { dataDirectory },
+      { ...deps, telemetry },
+      { genesis },
     );
   });
 }
@@ -215,7 +211,7 @@ export async function createValidatorConfig(
     ...config,
     ...p2pConfig,
     validatorPrivateKeys: new SecretValue(attesterPrivateKeys),
-    publisherPrivateKeys: [new SecretValue(attesterPrivateKeys[0])],
+    sequencerPublisherPrivateKeys: [new SecretValue(attesterPrivateKeys[0])],
   };
 
   return nodeConfig;

package/src/fixtures/standard_contracts_genesis.ts

@@ -0,0 +1,28 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { getPublishableStandardContracts } from '@aztec/standard-contracts';
+import { siloNullifier } from '@aztec/stdlib/hash';
+
+/**
+ * Computes the genesis nullifiers that pre-publish the standard contracts (AuthRegistry, PublicChecks,
+ * HandshakeRegistry) in e2e environments, mirroring the nullifiers their on-chain publish txs would emit. Per contract:
+ * - `siloNullifier(ContractClassRegistry, classId)` — the class-registration nullifier that `ContractClassRegistry.publish` pushes.
+ * - `siloNullifier(ContractInstanceRegistry, instanceAddress)` — the instance-deployment nullifier that
+ *   `ContractInstanceRegistry.publish_for_public_execution` pushes, using the contract's real derived address (standard
+ *   contracts are deployed at artifact-derived addresses, not magic protocol addresses).
+ *
+ * Seed these into the genesis nullifier tree (as the 5th `getGenesisValues` arg) alongside the archiver's
+ * `testPreloadStandardContracts` preload: the store preload makes the `ensure*Published` guards short-circuit, and these
+ * nullifiers make the AVM's deployment-nullifier check pass when the contracts are called. Every e2e node genesis that
+ * feeds an L1 `genesisArchiveRoot` must seed the same set, or the world-state root diverges from the deployed rollup.
+ */
+export async function getStandardContractGenesisNullifiers(): Promise<Fr[]> {
+  const classRegistry = ProtocolContractAddress.ContractClassRegistry;
+  const instanceRegistry = ProtocolContractAddress.ContractInstanceRegistry;
+  const nullifiers: Fr[] = [];
+  for (const { contractClass, address } of await getPublishableStandardContracts()) {
+    nullifiers.push(await siloNullifier(classRegistry, contractClass.id));
+    nullifiers.push(await siloNullifier(instanceRegistry, address.toField()));
+  }
+  return nullifiers;
+}

package/src/fixtures/timing.ts

@@ -0,0 +1,97 @@
+/**
+ * E2e span instrumentation. Wrapping a shared test helper in {@link testSpan} / {@link testSpanSync}
+ * records how long it ran, attributed to the test (or suite) that was executing, so a full CI run can
+ * be aggregated into a ranked list of where the suite spends wall-clock (setup, protocol waits, client
+ * proving, warp scans, ...). See the A-1178 timing environment in `shared/timing_env.mjs`.
+ *
+ * Everything here is gated on the collector installed by that environment, which only exists when
+ * `TEST_TIMING_FILE` is set. When it is unset, {@link testSpan} calls `fn()` directly with no extra work
+ * and no clock reads — instrumentation is exactly zero-cost and cannot change a test's behavior or
+ * timing.
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+/**
+ * Async-context owner override. A span normally attributes itself to the running test
+ * (`collector.current`), but a background producer (e.g. the mempool feeder) runs interleaved with
+ * arbitrary tests, so its spans would smear across whichever test happened to be current when each
+ * round fired. Running such work inside {@link withTestSpanOwner} pins every span in that async call
+ * tree to a fixed owner instead — isolated by async context from concurrent test-body spans.
+ */
+const ownerOverride = new AsyncLocalStorage<string | null>();
+
+/**
+ * Runs `fn` with every {@link testSpan} inside its async call tree attributed to `owner` instead of the
+ * currently running test. Use a non-test sentinel owner (e.g. `other:mempool-feeder`) to keep a
+ * background producer's spans out of the per-test view.
+ */
+export function withTestSpanOwner<T>(owner: string, fn: () => Promise<T>): Promise<T> {
+  return ownerOverride.run(owner, fn);
+}
+
+/** One recorded span occurrence on the process-wide `performance.now()` clock. */
+export type TimingSpan = {
+  /** Full name of the test running when the span started, or `null` if inside a beforeAll/afterAll hook. */
+  owner: string | null;
+  /** Stable `category:label` tag, aggregated across occurrences (e.g. `wait:checkpoint`, `setup:node`). */
+  name: string;
+  /** `performance.now()` at span start. */
+  start: number;
+  /** `performance.now()` at span end. */
+  end: number;
+};
+
+/**
+ * The collector shared by the timing environment on `globalThis.__e2eTimings`. `current` is the full
+ * name of the test currently running (`null` during beforeAll/afterAll); the environment sets it. The
+ * `spans` array accumulates every recorded span until the environment folds it into the per-test /
+ * per-suite JSONL line at flush.
+ */
+export type SpanCollector = {
+  /** Full name of the running test, or `null` during a beforeAll/afterAll hook. */
+  current: string | null;
+  /** All recorded spans, drained by the timing environment at flush time. */
+  spans: TimingSpan[];
+};
+
+function getCollector(): SpanCollector | undefined {
+  return (globalThis as { __e2eTimings?: SpanCollector }).__e2eTimings;
+}
+
+/**
+ * Times `fn` and records a span tagged `name`, attributed to the test (or suite) running when it
+ * started. The span is recorded even when `fn` throws. Pure passthrough: when no collector is
+ * installed (i.e. `TEST_TIMING_FILE` is unset) this calls `fn()` directly with zero overhead.
+ *
+ * Use stable `category:label` tags and prefer wrapping at the leaf wait/setup/tx level — labels are
+ * forever aggregation keys, and leaf-level tagging keeps spans additive. See `SPEEDUP_FOLLOWUPS` and
+ * the A-1179 design doc for the tag taxonomy.
+ */
+export async function testSpan<T>(name: string, fn: () => Promise<T>): Promise<T> {
+  const collector = getCollector();
+  if (!collector) {
+    return fn();
+  }
+  const owner = ownerOverride.getStore() ?? collector.current;
+  const start = performance.now();
+  try {
+    return await fn();
+  } finally {
+    collector.spans.push({ owner, name, start, end: performance.now() });
+  }
+}
+
+/** Synchronous variant of {@link testSpan} for non-async helpers. Same zero-cost guarantee when unset. */
+export function testSpanSync<T>(name: string, fn: () => T): T {
+  const collector = getCollector();
+  if (!collector) {
+    return fn();
+  }
+  const owner = ownerOverride.getStore() ?? collector.current;
+  const start = performance.now();
+  try {
+    return fn();
+  } finally {
+    collector.spans.push({ owner, name, start, end: performance.now() });
+  }
+}

package/src/fixtures/token_utils.ts

@@ -3,12 +3,46 @@ import { BatchCall } from '@aztec/aztec.js/contracts';
 import type { Logger } from '@aztec/aztec.js/log';
 import type { Wallet } from '@aztec/aztec.js/wallet';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { TestTokenContract } from '@aztec/noir-test-contracts.js/TestToken';
+
+/**
+ * Either token flavour. Canonical `TokenContract` uses constrained message delivery (production / docs
+ * source of truth); `TestTokenContract` is its codegen'd unconstrained-delivery sibling, used by tests
+ * where a token is just a unit-of-account vehicle. The two share an identical ABI, so helpers that only
+ * read balances or mint accept either.
+ */
+export type AnyTokenContract = TokenContract | TestTokenContract;
 
 export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger) {
   logger.info(`Deploying Token contract...`);
   const { contract, instance } = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18).send({
     from: admin,
-    wait: { returnReceipt: true },
+  });
+
+  if (initialAdminBalance > 0n) {
+    await mintTokensToPrivate(contract, admin, admin, initialAdminBalance);
+  }
+
+  logger.info('L2 contract deployed');
+
+  return { contract, instance };
+}
+
+/**
+ * Deploys the unconstrained-delivery `TestTokenContract`. Use this in tests where the token is a
+ * unit-of-account vehicle rather than the subject, so they don't pay constrained delivery's first-send
+ * handshake cost (which distorts step/log counts that benches assert on). Use {@link deployToken} when a
+ * test exercises canonical Token semantics or note discovery.
+ */
+export async function deployTestToken(
+  wallet: Wallet,
+  admin: AztecAddress,
+  initialAdminBalance: bigint,
+  logger: Logger,
+) {
+  logger.info(`Deploying TestToken contract...`);
+  const { contract, instance } = await TestTokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18).send({
+    from: admin,
   });
 
   if (initialAdminBalance > 0n) {
@@ -21,24 +55,25 @@ export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAd
 }
 
 export async function mintTokensToPrivate(
-  token: TokenContract,
+  token: AnyTokenContract,
   minter: AztecAddress,
   recipient: AztecAddress,
   amount: bigint,
+  additionalScopes?: AztecAddress[],
 ) {
-  await token.methods.mint_to_private(recipient, amount).send({ from: minter });
+  await token.methods.mint_to_private(recipient, amount).send({ from: minter, additionalScopes });
 }
 
 export async function expectTokenBalance(
   wallet: Wallet,
-  token: TokenContract,
+  token: AnyTokenContract,
   owner: AztecAddress,
   expectedBalance: bigint,
   logger: Logger,
 ) {
   // Then check the balance
-  const contractWithWallet = TokenContract.at(token.address, wallet);
-  const balance = await contractWithWallet.methods.balance_of_private(owner).simulate({ from: owner });
+  const contractWithWallet = token.withWallet(wallet);
+  const { result: balance } = await contractWithWallet.methods.balance_of_private(owner).simulate({ from: owner });
   logger.info(`Account ${owner} balance: ${balance}`);
   expect(balance).toBe(expectedBalance);
 }
@@ -47,7 +82,7 @@ export async function mintNotes(
   wallet: Wallet,
   minter: AztecAddress,
   recipient: AztecAddress,
-  asset: TokenContract,
+  asset: AnyTokenContract,
   noteAmounts: bigint[],
 ): Promise<bigint> {
   // We can only mint 5 notes at a time, since that's the maximum number of calls our entrypoints allow

package/src/fixtures/utils.ts

@@ -7,8 +7,8 @@ export {
   type EndToEndContext,
   type SetupOptions,
   createAndSyncProverNode,
-  deployAccounts,
-  ensureAccountContractsPublished,
+  ensureAuthRegistryPublished,
+  ensurePublicChecksPublished,
   expectMapping,
   expectMappingDelta,
   getBalancesFn,
@@ -16,7 +16,6 @@ export {
   getPrivateKeyFromIndex,
   getSponsoredFPCAddress,
   getSponsoredFPCInstance,
-  publicDeployAccounts,
   registerSponsoredFPC,
   setup,
   setupPXEAndGetWallet,