perf(e2e): seed standard contracts at genesis (#24568)

spalladino · aztec-bot · commit a176d96b1d0f · 2026-07-21T16:19:59.000Z
Round-4 e2e speedup, PR 1b (adoption half of the AuthRegistry prize). **Stacked on #24567** (`spl/genesis-prefilled-nullifiers`, the genesis-nullifier mechanism). This PR targets that branch; retarget to `merge-train/spartan-v5` once #24567 merges. ## What Make e2e environments start with the standard contracts (AuthRegistry, PublicChecks, HandshakeRegistry) already "published", so `ensureAuthRegistryPublished` and its two siblings skip their two publish txs each. At production cadence `setup:auth-registry` alone was ~16 min/run (2 sequential txs per process, paid per-process across the suite). This collapses that span to sub-second. ## Mechanism (three parts, all default-off outside e2e) - **Genesis nullifiers.** Per standard contract, seed `siloNullifier(ContractClassRegistry, classId)` and `siloNullifier(ContractInstanceRegistry, instanceAddress)` (the real derived address — standard contracts are not magic-address protocol contracts) into the fixtures' `getGenesisValues` call, via PR 1a's new 5th param. These are exactly the nullifiers the publish txs would emit, so the AVM's deployment-nullifier check passes when the contracts are called publicly. A single helper (`getStandardContractGenesisNullifiers`) feeds all four e2e genesis builders (`fixtures/setup.ts`, `e2e_prover_test.ts`, `p2p/p2p_network.ts`, `multi-node/governance/add_rollup.test.ts`) — the latter three recompute a genesis that must reproduce the L1-deployed archive root, so they must seed the identical set. Non-e2e callers (cli, sandbox/local-network) are untouched. - **Archiver preload.** `registerStandardContracts` mirrors `registerProtocolContracts`: it seeds each contract's class (with recomputed `publicBytecodeCommitment`), instance, and public-function signatures into the contract store at block 0, reading the bundled `@aztec/standard-contracts` artifacts. It is idempotent (skips already-registered classes on restart) and gated behind a new archiver config flag `testPreloadStandardContracts` (env `TEST_PRELOAD_STANDARD_CONTRACTS`, default **false**). The flag is set from the e2e node config so every spawned node (validators, prover nodes) picks it up through the normal config path. This adds `@aztec/standard-contracts` as an archiver dependency. - **Guard short-circuit.** The `ensure*Published` helpers are unchanged. Their guards read `wallet.getContractClassMetadata(id).isContractClassPubliclyRegistered` (to `aztecNode.getContractClass`) and `wallet.getContractMetadata(addr).isContractPublished` (to `aztecNode.getContract`) — both are archiver-store reads, not nullifier-tree reads. The store preload alone makes both short-circuit; the genesis nullifiers are what make the contract actually callable in the AVM afterwards. Keeping the helpers doubles as a regression check: if seeding ever breaks, the tx path re-engages and tests still pass, just slow. ## Why the flag is test-only (A-1257 rationale) Preloading unconditionally in production would recreate the A-1257 collision #24254 fixed: a real on-chain publish of a preloaded class would collide with the block-0 preload, because production genesis will **not** carry the matching nullifiers. The flag is only set by the e2e fixtures, which also seed the nullifiers, keeping the store and the nullifier tree consistent. A single source of truth (`getPublishableStandardContracts`) drives both the preloaded set and the seeded-nullifier set so they cannot drift. ## State-write verification Inspected the two publish txs on this base: - `ContractClassRegistry.publish` pushes one nullifier (`classId`, siloed to the class-registry address) and broadcasts a `ContractClassPublished` contract-class log carrying the packed bytecode. No public-data writes. - `ContractInstanceRegistry.publish_for_public_execution` asserts the class-registration nullifier exists, then pushes one nullifier (`address`, siloed to the instance-registry address) and broadcasts a `ContractInstancePublished` private log. No public-data writes. So the full state-write set is two nullifiers + two broadcast logs. The nullifiers are replicated via genesis `prefilledNullifiers`; the archiver normally learns the class/instance from those two logs (`data_store_updater.ts`), and the block-0 preload replaces that path exactly. No `genesisPublicData` is required. PXE-side registration (`wallet.registerContract`) is unaffected and still runs in the helpers. ## Local verification - `automine/accounts/authwit.test.ts` (public-authwit path against the standard AuthRegistry), timing on: passes; `setup:auth-registry` span = **10 ms** (was ~33 s at production cadence). No on-chain AuthRegistry publish (the only `ContractClassRegistry.publish` executions are the test's own AuthWitTest/GenericProxy deploys); the public AuthRegistry contract executes fine against the seeded nullifier. `testPreloadStandardContracts: true` confirmed in the node config dump. - `single-node/fees/account_init.test.ts` (production sequencer + simulated prover node), timing on: 5/5 pass; `setup:auth-registry` span = **10 ms**. Prover node syncs against the seeded genesis (no root divergence), and the flag propagates to it. No duplicate-nullifier errors. - New unit test in `archiver/src/modules/data_store_updater.test.ts`: `registerStandardContracts` preloads each publishable standard contract's class + instance into the store and is idempotent on a second call. ## Expected impact ~14–16 min/run from auth-registry alone, plus more from the two untagged siblings (PublicChecks / HandshakeRegistry) wherever used. ## Measured impact `setup:auth-registry` collapses from 702.2s of setup time run-wide (39 occurrences, 5–35s each) to 482ms total (max 87ms per occurrence) — sub-second run-wide, every shard clean, no seeding or flag-propagation slow path. - The measured beforeHooks reduction is larger than the auth-registry span alone, because the two untagged sibling publishes (PublicChecks, HandshakeRegistry) are removed too. Example: account_init beforeHooks −49.6s vs a 30.9s tagged auth-registry span; the extra ~19s is the two siblings. - Per-suite beforeHooks deltas: account_init −49.6s, fee_settings −49.5s, failures −48.7s, private_payments.parallel −41.8s/shard (×8), gas_estimation.parallel −41.5s/shard (×3), l1_to_l2 −38.1s, l2_to_l1 −37.5s, l1_to_l2_inbox_drift −38.2s, token_bridge −37.7s, fee_juice_payments −37.4s, bot −34.3s; automine/parallel suites shed 5–15s each (their fast-cadence publishes). - Total beforeHooks reduction over the suites present in both runs: −1,649.7s summed across shards (wall-clock benefit is smaller, since shards run in parallel across workers). Baseline CI run 1783389062016888 (#24567 `ci/x-fast`; mechanism-only, so timing-neutral vs merge-base). PR CI run 1783391194852197 (#24568 `ci/x-fast`). ## Notes for downstream - **PR 6 (fees harness):** `applyEnsureAuthRegistryPublished` now short-circuits; the fees setup chain loses the ~32 s/shard auth-registry step, so rebase the overlap/batch shape onto what remains (token deploy, FPC, mints). - **Fix phase / timing capture:** expected span assertion is `setup:auth-registry` around sub-second across the run (10 ms observed locally per process). Any shard still showing tens of seconds means the guards took the slow path (a seeding or flag-propagation bug), not noise. Fixes A-1404 (cherry picked from commit f320049)
diff --git a/yarn-project/archiver/package.json b/yarn-project/archiver/package.json
@@ -75,6 +75,7 @@
     "@aztec/l1-artifacts": "portal:../../l1-contracts/l1-artifacts",
     "@aztec/noir-protocol-circuits-types": "workspace:^",
     "@aztec/protocol-contracts": "workspace:^",
+    "@aztec/standard-contracts": "workspace:^",
     "@aztec/stdlib": "workspace:^",
     "@aztec/telemetry-client": "workspace:^",
     "lodash.groupby": "^4.6.0",
diff --git a/yarn-project/archiver/src/config.ts b/yarn-project/archiver/src/config.ts
@@ -90,6 +90,14 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description: 'Skip pruning orphan proposed blocks that have no matching proposed checkpoint.',
     ...booleanConfigHelper(false),
   },
+  testPreloadStandardContracts: {
+    env: 'TEST_PRELOAD_STANDARD_CONTRACTS',
+    description:
+      'Preload the standard contracts (AuthRegistry, PublicChecks, HandshakeRegistry) into the contract store at ' +
+      'block 0. For test environments only, and only safe when genesis seeds the matching registration/deployment ' +
+      'nullifiers; otherwise a later on-chain publish would collide with the block-0 preload.',
+    ...booleanConfigHelper(false),
+  },
   ...chainConfigMappings,
   ...l1ReaderConfigMappings,
   viemPollingIntervalMS: {
diff --git a/yarn-project/archiver/src/factory.ts b/yarn-project/archiver/src/factory.ts
@@ -12,6 +12,7 @@ import { DateProvider } from '@aztec/foundation/timer';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { protocolContractNames } from '@aztec/protocol-contracts';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { getPublishableStandardContracts } from '@aztec/standard-contracts';
 import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
 import type { ArchiverEmitter, BlockHash } from '@aztec/stdlib/block';
 import { DEFAULT_BLOCK_DURATION_MS } from '@aztec/stdlib/config';
@@ -68,6 +69,9 @@ export async function createArchiver(
 ): Promise<Archiver> {
   const archiverStore = await createArchiverStore(config, initialBlockHash);
   await registerProtocolContracts(archiverStore);
+  if (config.testPreloadStandardContracts) {
+    await registerStandardContracts(archiverStore);
+  }
 
   // Create Ethereum clients
   const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
@@ -227,3 +231,33 @@ export async function registerProtocolContracts(stores: ArchiverDataStores) {
     await stores.contractInstances.addContractInstances([contract.instance], BlockNumber(blockNumber));
   }
 }
+
+/**
+ * Preloads the standard contracts (AuthRegistry, PublicChecks, HandshakeRegistry) into the archiver store at block 0,
+ * mirroring {@link registerProtocolContracts}. Only invoked for test environments (via `testPreloadStandardContracts`),
+ * which also seed the matching registration/deployment nullifiers into the genesis nullifier tree so the store and tree
+ * stay consistent. Idempotent — skips contracts that already exist (e.g. on node restart).
+ */
+export async function registerStandardContracts(stores: ArchiverDataStores) {
+  const blockNumber = 0;
+  for (const contract of await getPublishableStandardContracts()) {
+    // Skip if already registered (happens on node restart with a persisted store).
+    if (await stores.contractClasses.getContractClass(contract.contractClass.id)) {
+      continue;
+    }
+
+    const publicBytecodeCommitment = await computePublicBytecodeCommitment(contract.contractClass.packedBytecode);
+    const contractClassPublic: ContractClassPublicWithCommitment = {
+      ...contract.contractClass,
+      publicBytecodeCommitment,
+    };
+
+    const publicFunctionSignatures = contract.artifact.functions
+      .filter(fn => fn.functionType === FunctionType.PUBLIC)
+      .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
+
+    await stores.functionNames.register(publicFunctionSignatures);
+    await stores.contractClasses.addContractClasses([contractClassPublic], BlockNumber(blockNumber));
+    await stores.contractInstances.addContractInstances([contract.instance], BlockNumber(blockNumber));
+  }
+}
diff --git a/yarn-project/archiver/src/modules/data_store_updater.test.ts b/yarn-project/archiver/src/modules/data_store_updater.test.ts
@@ -6,6 +6,7 @@ import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
 import { ContractInstancePublishedEvent } from '@aztec/protocol-contracts/instance-registry';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { getPublishableStandardContracts } from '@aztec/standard-contracts';
 import { bufferAsFields } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { GENESIS_BLOCK_HEADER_HASH, L2Block } from '@aztec/stdlib/block';
@@ -19,7 +20,7 @@ import { readFileSync } from 'fs';
 import { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 
-import { registerProtocolContracts } from '../factory.js';
+import { registerProtocolContracts, registerStandardContracts } from '../factory.js';
 import { type ArchiverDataStores, createArchiverDataStores } from '../store/data_stores.js';
 import { L2TipsCache } from '../store/l2_tips_cache.js';
 import { makeCheckpoint, makePublishedCheckpoint } from '../test/mock_structs.js';
@@ -149,6 +150,32 @@ describe('ArchiverDataStoreUpdater', () => {
       expect(await store.contractClasses.getContractClass(protocolClassId)).toBeDefined();
     });
 
+    it('preloads standard contract classes and instances via registerStandardContracts', async () => {
+      const standardContracts = await getPublishableStandardContracts();
+      expect(standardContracts.length).toBeGreaterThan(0);
+
+      // Not present before the preload.
+      for (const { contractClass } of standardContracts) {
+        expect(await store.contractClasses.getContractClass(contractClass.id)).toBeUndefined();
+      }
+
+      await registerStandardContracts(store);
+
+      // Both the class and the instance are queryable from the block-0 preload.
+      for (const { contractClass, address } of standardContracts) {
+        const retrievedClass = await store.contractClasses.getContractClass(contractClass.id);
+        expect(retrievedClass?.id.equals(contractClass.id)).toBe(true);
+        const retrievedInstance = await store.contractInstances.getContractInstance(address, 1n);
+        expect(retrievedInstance?.address.equals(address)).toBe(true);
+      }
+
+      // Calling again (e.g. on node restart with a persisted store) is idempotent and must not throw.
+      await expect(registerStandardContracts(store)).resolves.not.toThrow();
+      for (const { contractClass } of standardContracts) {
+        expect(await store.contractClasses.getContractClass(contractClass.id)).toBeDefined();
+      }
+    });
+
     it('removes contract class and instance data when blocks are pruned via setCheckpointData', async () => {
       // First, add a local provisional block with contract data
       const localBlock = await L2Block.random(BlockNumber(1), {
diff --git a/yarn-project/archiver/tsconfig.json b/yarn-project/archiver/tsconfig.json
@@ -33,6 +33,9 @@
     {
       "path": "../protocol-contracts"
     },
+    {
+      "path": "../standard-contracts"
+    },
     {
       "path": "../stdlib"
     },
diff --git a/yarn-project/end-to-end/src/fixtures/e2e_prover_test.ts b/yarn-project/end-to-end/src/fixtures/e2e_prover_test.ts
@@ -24,6 +24,7 @@ import { TestWallet } from '../test-wallet/test_wallet.js';
 import { getACVMConfig } from './get_acvm_config.js';
 import { getBBConfig } from './get_bb_config.js';
 import { getPrivateKeyFromIndex, getSponsoredFPCAddress, setup, setupPXEAndGetWallet } from './setup.js';
+import { getStandardContractGenesisNullifiers } from './standard_contracts_genesis.js';
 
 type ProvenSetup = {
   wallet: TestWallet;
@@ -229,6 +230,7 @@ export class FullProverTest extends SingleNodeTestContext {
       undefined,
       undefined,
       this.context.genesis!.genesisTimestamp,
+      await getStandardContractGenesisNullifiers(),
     );
 
     const proverNodeConfig: Parameters<typeof createAztecNodeService>[0] = {
diff --git a/yarn-project/end-to-end/src/fixtures/setup.ts b/yarn-project/end-to-end/src/fixtures/setup.ts
@@ -77,6 +77,7 @@ import { MNEMONIC, TEST_MAX_PENDING_TX_POOL_COUNT, TEST_PEER_CHECK_INTERVAL_MS }
 import { getACVMConfig } from './get_acvm_config.js';
 import { getBBConfig } from './get_bb_config.js';
 import { isMetricsLoggingRequested, setupMetricsLogger } from './logging.js';
+import { getStandardContractGenesisNullifiers } from './standard_contracts_genesis.js';
 import { testSpan } from './timing.js';
 import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 
@@ -474,12 +475,20 @@ async function setupInner<TDeployExtraL1ContractsReturnType = unknown>(
     }
     logger.trace('Generated test accounts to fund at genesis');
 
+    // Preload the standard contracts (AuthRegistry, PublicChecks, HandshakeRegistry) so their `ensure*Published` setup
+    // helpers short-circuit their publish txs. The archiver flag seeds the bytecode/instance into every spawned node's
+    // contract store; the genesis nullifiers make the AVM's deployment-nullifier check pass when they are called. Both
+    // must go together (flag alone would recreate the publish-collision bug), so the flag lives here beside the seeding.
+    config.testPreloadStandardContracts = true;
+    const standardContractNullifiers = await getStandardContractGenesisNullifiers();
+
     const genesisTimestamp = BigInt(Math.floor(Date.now() / 1000));
     const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(
       addressesToFund,
       opts.initialAccountFeeJuice,
       opts.genesisPublicData,
       genesisTimestamp,
+      standardContractNullifiers,
     );
     logger.trace('Computed genesis values');
 
diff --git a/yarn-project/end-to-end/src/fixtures/standard_contracts_genesis.ts b/yarn-project/end-to-end/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;
+}
diff --git a/yarn-project/end-to-end/src/multi-node/governance/add_rollup.test.ts b/yarn-project/end-to-end/src/multi-node/governance/add_rollup.test.ts
@@ -34,6 +34,7 @@ import { type Hex, decodeEventLog, encodeFunctionData, getAddress, getContract }
 import { foundry } from 'viem/chains';
 
 import { sendL1ToL2Message } from '../../fixtures/l1_to_l2_messaging.js';
+import { getStandardContractGenesisNullifiers } from '../../fixtures/standard_contracts_genesis.js';
 import { getPrivateKeyFromIndex, getSponsoredFPCAddress } from '../../fixtures/utils.js';
 import { TestWallet } from '../../test-wallet/test_wallet.js';
 import {
@@ -136,7 +137,13 @@ describe('multi-node/governance/add_rollup', () => {
       genesisArchiveRoot,
       fundingNeeded,
       genesis: newGenesis,
-    } = await getGenesisValues(genesisFundedAddresses, undefined, undefined, context.genesis!.genesisTimestamp + 1n);
+    } = await getGenesisValues(
+      genesisFundedAddresses,
+      undefined,
+      undefined,
+      context.genesis!.genesisTimestamp + 1n,
+      await getStandardContractGenesisNullifiers(),
+    );
 
     const { rollup: newRollup } = await deployRollupForUpgrade(
       deployerPrivateKey,
diff --git a/yarn-project/end-to-end/src/p2p/p2p_network.ts b/yarn-project/end-to-end/src/p2p/p2p_network.ts
@@ -49,6 +49,7 @@ import {
   createValidatorConfig,
   generatePrivateKeys,
 } from '../fixtures/setup_p2p_test.js';
+import { getStandardContractGenesisNullifiers } from '../fixtures/standard_contracts_genesis.js';
 import { getEndToEndTestTelemetryClient } from '../fixtures/with_telemetry_utils.js';
 import type { TestWallet } from '../test-wallet/test_wallet.js';
 
@@ -415,6 +416,7 @@ export class P2PNetworkTest {
       undefined,
       undefined,
       this.context.genesis!.genesisTimestamp,
+      await getStandardContractGenesisNullifiers(),
     );
     this.genesis = genesis;
 
diff --git a/yarn-project/foundation/src/config/env_var.ts b/yarn-project/foundation/src/config/env_var.ts
@@ -279,6 +279,7 @@ export type EnvVar =
   | 'SYNC_SNAPSHOTS_URL'
   | 'TELEMETRY'
   | 'TEST_ACCOUNTS'
+  | 'TEST_PRELOAD_STANDARD_CONTRACTS'
   | 'SPONSORED_FPC'
   | 'PREFUND_ADDRESSES'
   | 'TX_COLLECTION_FAST_NODES_TIMEOUT_BEFORE_REQ_RESP_MS'
diff --git a/yarn-project/standard-contracts/src/index.ts b/yarn-project/standard-contracts/src/index.ts
@@ -2,3 +2,4 @@ export * from './auth-registry/index.js';
 export * from './handshake-registry/index.js';
 export * from './multi-call-entrypoint/index.js';
 export * from './public-checks/index.js';
+export * from './publishable_standard_contracts.js';
diff --git a/yarn-project/standard-contracts/src/publishable_standard_contracts.ts b/yarn-project/standard-contracts/src/publishable_standard_contracts.ts
@@ -0,0 +1,22 @@
+import { getStandardAuthRegistry } from './auth-registry/index.js';
+import { getStandardHandshakeRegistry } from './handshake-registry/index.js';
+import { getStandardPublicChecks } from './public-checks/index.js';
+import type { StandardContract } from './standard_contract.js';
+
+/**
+ * Returns the standard contracts that are published on-chain (class registration + instance
+ * publication) before their public functions can be called: AuthRegistry, PublicChecks, and
+ * HandshakeRegistry. These are exactly the contracts guarded by the `ensure*Published` e2e setup
+ * helpers.
+ *
+ * MultiCallEntrypoint is deliberately excluded: it is a client-side entrypoint used to encode
+ * batched private calls and is never published for public execution.
+ *
+ * This is the single source of truth for the set of standard contracts that test environments seed
+ * at genesis (registration/deployment nullifiers) and preload into the archiver contract store, so
+ * the two stay consistent — preloading a class whose nullifier is not seeded would recreate the
+ * publish-collision bug that genesis seeding avoids.
+ */
+export function getPublishableStandardContracts(): Promise<StandardContract[]> {
+  return Promise.all([getStandardAuthRegistry(), getStandardPublicChecks(), getStandardHandshakeRegistry()]);
+}
diff --git a/yarn-project/stdlib/src/interfaces/archiver.ts b/yarn-project/stdlib/src/interfaces/archiver.ts
@@ -68,6 +68,13 @@ export type ArchiverSpecificConfig = {
 
   /** Skip pruning orphan proposed blocks that have no matching proposed checkpoint. */
   skipOrphanProposedBlockPruning?: boolean;
+
+  /**
+   * Preload the standard contracts (AuthRegistry, PublicChecks, HandshakeRegistry) into the contract store at block 0.
+   * For test environments only: it must only be set when genesis also seeds the matching registration/deployment
+   * nullifiers, otherwise a later on-chain publish of a preloaded class would collide with the block-0 preload.
+   */
+  testPreloadStandardContracts?: boolean;
 };
 
 export const ArchiverSpecificConfigSchema = z.object({
@@ -82,6 +89,7 @@ export const ArchiverSpecificConfigSchema = z.object({
   skipPromoteProposedCheckpointDuringL1Sync: z.boolean().optional(),
   orphanPruneNoProposalTolerance: schemas.Integer.optional(),
   skipOrphanProposedBlockPruning: z.boolean().optional(),
+  testPreloadStandardContracts: z.boolean().optional(),
 });
 
 export type ArchiverApi = Omit<
diff --git a/yarn-project/yarn.lock b/yarn-project/yarn.lock
@@ -727,6 +727,7 @@ __metadata:
     "@aztec/l1-artifacts": "portal:../../l1-contracts/l1-artifacts"
     "@aztec/noir-protocol-circuits-types": "workspace:^"
     "@aztec/protocol-contracts": "workspace:^"
+    "@aztec/standard-contracts": "workspace:^"
     "@aztec/stdlib": "workspace:^"
     "@aztec/telemetry-client": "workspace:^"
     "@jest/globals": "npm:^30.0.0"

Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,9 @@`
`33`	`33`	`{`
`34`	`34`	`"path": "../protocol-contracts"`
`35`	`35`	`},`
	`36`	`+ {`
	`37`	`+ "path": "../standard-contracts"`
	`38`	`+ },`
`36`	`39`	`{`
`37`	`40`	`"path": "../stdlib"`
`38`	`41`	`},`