@aztec/end-to-end 0.0.1-commit.04852196a → 0.0.1-commit.04d373f

package/src/e2e_epochs/epochs_test.ts

@@ -1,5 +1,7 @@
+import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { Archiver } from '@aztec/archiver';
 import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { getAccountContractAddress } from '@aztec/aztec.js/account';
 import { getTimestampRangeForEpoch } from '@aztec/aztec.js/block';
 import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
 import { Fr } from '@aztec/aztec.js/fields';
@@ -28,11 +30,16 @@ import { type SequencerClient, type SequencerEvents, SequencerState } from '@azt
 import { type BlockParameter, EthAddress } from '@aztec/stdlib/block';
 import { type L1RollupConstants, getProofSubmissionDeadlineTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
+import type { SlashingProtectionDatabase } from '@aztec/validator-ha-signer/types';
 
 import { join } from 'path';
 import type { Hex } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 
+import {
+  SCHNORR_HARDCODED_PRIVATE_KEY,
+  SchnorrHardcodedKeyAccountContract,
+} from '../fixtures/schnorr_hardcoded_account_contract.js';
 import {
   type EndToEndContext,
   type SetupOptions,
@@ -40,6 +47,7 @@ import {
   getPrivateKeyFromIndex,
   setup,
 } from '../fixtures/utils.js';
+import type { TestWallet } from '../test-wallet/test_wallet.js';
 
 export const WORLD_STATE_CHECKPOINT_HISTORY = 2;
 export const WORLD_STATE_BLOCK_CHECK_INTERVAL = 50;
@@ -50,6 +58,13 @@ export type EpochsTestOpts = Partial<SetupOptions> & {
   numberOfAccounts?: number;
   pxeOpts?: Partial<PXEConfig>;
   aztecSlotDurationInL1Slots?: number;
+  /** Skip creating/registering the hardcoded account during setup (for tests that handle accounts themselves). */
+  skipHardcodedAccount?: boolean;
+  /**
+   * Force the hardcoded-account fast-path even when an initial sequencer is running. Useful for
+   * tests with tight per-block gas budgets that can't fit a full account-deploy tx.
+   */
+  useHardcodedAccount?: boolean;
 };
 
 export type TrackedSequencerEvent = {
@@ -120,10 +135,20 @@ export class EpochsTestContext {
     this.L1_BLOCK_TIME_IN_S = ethereumSlotDuration;
     this.L2_SLOT_DURATION_IN_S = aztecSlotDuration;
 
+    // Auto-create a hardcoded account funded via genesis when:
+    //  - skipInitialSequencer is set (no sequencer to deploy on-chain), or
+    //  - useHardcodedAccount is explicitly requested (e.g. tight per-block gas budgets that
+    //    can't fit a full account-deploy tx).
+    const useHardcodedAccount = (opts.skipInitialSequencer || opts.useHardcodedAccount) && !opts.skipHardcodedAccount;
+    let hardcodedAccountData: InitialAccountData | undefined;
+    if (useHardcodedAccount) {
+      hardcodedAccountData = await EpochsTestContext.getHardcodedAccountData(Fr.random(), Fr.random());
+    }
+
     // Set up system without any account nor protocol contracts
     // and with faster block times and shorter epochs.
     const context = await setup(
-      opts.numberOfAccounts ?? 0,
+      useHardcodedAccount ? 0 : (opts.numberOfAccounts ?? 0),
       {
         automineL1Setup: true,
         checkIntervalMs: 50,
@@ -138,15 +163,13 @@ export class EpochsTestContext {
         realProofs: false,
         startProverNode: true,
         proverTestDelayMs: opts.proverTestDelayMs ?? 0,
-        // We use numeric incremental prover ids for simplicity, but we can switch to
-        // using the prover's eth address if the proverId is used for something in the rollup contract
-        // Use numeric EthAddress for deterministic prover id
         proverId: EthAddress.fromNumber(1),
         worldStateCheckpointHistory: WORLD_STATE_CHECKPOINT_HISTORY,
         exitDelaySeconds: DefaultL1ContractsConfig.exitDelaySeconds,
-        slasherFlavor: 'none',
+        slasherEnabled: false,
         l1PublishingTime,
         ...opts,
+        ...(hardcodedAccountData ? { initialFundedAccounts: [hardcodedAccountData], numberOfAccounts: 0 } : {}),
       },
       // Use checkpointed chain tip for PXE by default to avoid issues with blocks being dropped due to pruned anchor blocks.
       // Can be overridden via opts.pxeOpts.
@@ -154,6 +177,11 @@ export class EpochsTestContext {
     );
 
     this.context = context;
+
+    // Register the hardcoded account in PXE (local only, no on-chain deployment needed).
+    if (hardcodedAccountData) {
+      await this.registerHardcodedAccount(hardcodedAccountData);
+    }
     this.proverNodes = context.proverNode ? [context.proverNode] : [];
     this.nodes = context.aztecNode ? [context.aztecNode as AztecNodeService] : [];
     this.logger = context.logger;
@@ -181,6 +209,7 @@ export class EpochsTestContext {
       ethereumSlotDuration,
       proofSubmissionEpochs: Number(await this.rollup.getProofSubmissionEpochs()),
       targetCommitteeSize: await this.rollup.getTargetCommitteeSize(),
+      rollupManaLimit: Number(await this.rollup.getManaLimit()),
     };
 
     this.logger.info(
@@ -195,6 +224,35 @@ export class EpochsTestContext {
     await this.context.teardown();
   }
 
+  /**
+   * Computes InitialAccountData for a SchnorrHardcodedKeyAccountContract.
+   * This contract has a hardcoded signing key and no initializer, so it can be used without
+   * on-chain deployment. Pass the returned data in `initialFundedAccounts` so the address
+   * gets funded with fee juice in genesis.
+   */
+  public static async getHardcodedAccountData(secret: Fr, salt: Fr): Promise<InitialAccountData> {
+    const contract = new SchnorrHardcodedKeyAccountContract();
+    const address = await getAccountContractAddress(contract, secret, salt);
+    const signingKey = SCHNORR_HARDCODED_PRIVATE_KEY;
+    return { secret, salt, signingKey, address };
+  }
+
+  /**
+   * Registers a SchnorrHardcodedKeyAccountContract in PXE. The account must have been funded
+   * at genesis (via getHardcodedAccountData). No on-chain deployment or block mining needed.
+   */
+  public async registerHardcodedAccount(accountData: InitialAccountData) {
+    const contract = new SchnorrHardcodedKeyAccountContract();
+    const wallet = this.context.wallet;
+    const accountManager = await (wallet as TestWallet).createAccount({
+      secret: accountData.secret,
+      salt: accountData.salt,
+      contract,
+    });
+    this.context.accounts = [accountManager.address];
+    return accountManager.address;
+  }
+
   public async createProverNode(opts: { dontStart?: boolean } & Partial<ProverNodeConfig> = {}) {
     this.logger.warn('Creating and syncing a simulated prover node...');
     const proverNodePrivateKey = this.getNextPrivateKey();
@@ -221,7 +279,7 @@ export class EpochsTestContext {
           },
         },
         {
-          prefilledPublicData: this.context.prefilledPublicData ?? [],
+          genesis: this.context.genesis,
           dontStart: opts.dontStart,
         },
       ),
@@ -237,13 +295,21 @@ export class EpochsTestContext {
 
   public createValidatorNode(
     privateKeys: `0x${string}`[],
-    opts: Partial<AztecNodeConfig> & { dontStartSequencer?: boolean } = {},
+    opts: Partial<AztecNodeConfig> & {
+      dontStartSequencer?: boolean;
+      slashingProtectionDb?: SlashingProtectionDatabase;
+    } = {},
   ) {
     this.logger.warn('Creating and syncing a validator node...');
     return this.createNode({ ...opts, disableValidator: false, validatorPrivateKeys: new SecretValue(privateKeys) });
   }
 
-  private async createNode(opts: Partial<AztecNodeConfig> & { dontStartSequencer?: boolean } = {}) {
+  private async createNode(
+    opts: Partial<AztecNodeConfig> & {
+      dontStartSequencer?: boolean;
+      slashingProtectionDb?: SlashingProtectionDatabase;
+    } = {},
+  ) {
     const nodeIndex = this.nodes.length + 1;
     const actorPrefix = opts.disableValidator ? 'node' : 'validator';
     const { mockGossipSubNetwork } = this.context;
@@ -256,6 +322,7 @@ export class EpochsTestContext {
           ...resolvedConfig,
           dataDirectory: join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')),
           validatorPrivateKeys: opts.validatorPrivateKeys ?? new SecretValue([]),
+          nodeId: resolvedConfig.nodeId || `${actorPrefix}-${nodeIndex}`,
           p2pEnabled,
           p2pIp,
         },
@@ -264,9 +331,10 @@ export class EpochsTestContext {
           p2pClientDeps: {
             p2pServiceFactory: mockGossipSubNetwork ? getMockPubSubP2PServiceFactory(mockGossipSubNetwork) : undefined,
           },
+          slashingProtectionDb: opts.slashingProtectionDb,
         },
         {
-          prefilledPublicData: this.context.prefilledPublicData,
+          genesis: this.context.genesis,
           ...opts,
         },
       ),
@@ -337,7 +405,7 @@ export class EpochsTestContext {
       await sleep(waitTime);
       const [syncState, tips] = await Promise.all([
         this.context.aztecNode.getWorldStateSyncStatus(),
-        await this.context.aztecNode.getL2Tips(),
+        await this.context.aztecNode.getChainTips(),
       ]);
       this.logger.info(`Wait for node synch ${blockNumber} ${type}`, { blockNumber, type, syncState, tips });
       if (type === 'proven') {
@@ -404,7 +472,7 @@ export class EpochsTestContext {
   /** Verifies at least one checkpoint has the target number of blocks (for MBPS validation). */
   public async assertMultipleBlocksPerSlot(targetBlockCount: number) {
     const archiver = (this.context.aztecNode as AztecNodeService).getBlockSource() as Archiver;
-    const checkpoints = await archiver.getCheckpoints(CheckpointNumber(1), 50);
+    const checkpoints = await archiver.getCheckpoints({ from: CheckpointNumber(1), limit: 50 });
 
     this.logger.warn(`Retrieved ${checkpoints.length} checkpoints from archiver`, {
       checkpoints: checkpoints.map(pc => pc.checkpoint.getStats()),
@@ -436,6 +504,7 @@ export class EpochsTestContext {
   public watchSequencerEvents(
     sequencers: SequencerClient[],
     getMetadata: (i: number) => Record<string, any> = () => ({}),
+    additionalFailEventKeys: (keyof SequencerEvents)[] = [],
   ) {
     const stateChanges: TrackedSequencerEvent[] = [];
     const failEvents: TrackedSequencerEvent[] = [];
@@ -446,6 +515,11 @@ export class EpochsTestContext {
       'block-build-failed',
       'checkpoint-publish-failed',
       'proposer-rollup-check-failed',
+      'checkpoint-error',
+      'checkpoint-publish-failed',
+      'header-validation-failed',
+      'pipelined-checkpoint-discarded',
+      ...additionalFailEventKeys,
     ];
 
     const makeEvent = (
@@ -475,6 +549,13 @@ export class EpochsTestContext {
       });
       failEventsKeys.forEach(eventName => {
         sequencer.getSequencer().on(eventName, (args: Parameters<SequencerEvents[typeof eventName]>[0]) => {
+          // Skip benign block-build-failed events where the builder rejected the block because it
+          // could not collect enough valid txs. This is the same "not enough txs" case as
+          // block-tx-count-check-failed (which is already excluded above), just detected after we
+          // started processing txs rather than before.
+          if (eventName === 'block-build-failed' && (args as { reason?: string }).reason === 'Insufficient valid txs') {
+            return;
+          }
           const evt = makeEvent(i, eventName, args);
           failEvents.push(evt);
           this.logger.error(`Failed event ${eventName} from sequencer ${sequencerIndex}`, undefined, evt);
@@ -484,4 +565,11 @@ export class EpochsTestContext {
 
     return { failEvents, stateChanges };
   }
+
+  public assertNoFailuresFromSequencers(failEvents: TrackedSequencerEvent[]) {
+    if (failEvents.length > 0) {
+      this.logger.error(`Failed events from sequencers`, failEvents);
+    }
+    expect(failEvents).toEqual([]);
+  }
 }

package/src/e2e_fees/fees_test.ts

@@ -23,11 +23,12 @@ import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 
 import { getContract } from 'viem';
 
-import { MNEMONIC } from '../fixtures/fixtures.js';
+import { MNEMONIC, getPaddedMaxFeesPerGas } from '../fixtures/fixtures.js';
 import {
   type EndToEndContext,
   type SetupOptions,
   deployAccounts,
+  ensureAuthRegistryPublished,
   publicDeployAccounts,
   setup,
   teardown,
@@ -84,6 +85,8 @@ export class FeesTest {
   public getBananaPublicBalanceFn!: BalancesFn;
   public getBananaPrivateBalanceFn!: BalancesFn;
   public getProverFee!: (blockNumber: BlockNumber) => Promise<bigint>;
+  public getCommittedProverFee!: (blockNumber: BlockNumber) => Promise<bigint>;
+  public getCommittedBurn!: (blockNumber: BlockNumber) => Promise<bigint>;
 
   public readonly ALICE_INITIAL_BANANAS = BigInt(1e22);
   public readonly SUBSCRIPTION_AMOUNT = BigInt(1e19);
@@ -102,13 +105,14 @@ export class FeesTest {
     this.logger = createLogger(`e2e:e2e_fees:${testName}`);
   }
 
-  async setup() {
+  async setup(opts: Partial<SetupOptions> = {}) {
     this.logger.verbose('Setting up fresh context...');
     // Token allowlist entries are test-only: FPC-based fee payment with custom tokens won't work on mainnet alpha.
     const tokenAllowList = await getTokenAllowedSetupFunctions();
     this.context = await setup(0, {
       startProverNode: true,
       ...this.setupOptions,
+      ...opts,
       fundSponsoredFPC: true,
       skipAccountDeployment: true,
       l1ContractsArgs: { ...this.setupOptions },
@@ -134,7 +138,7 @@ export class FeesTest {
 
   async catchUpProvenChain() {
     const bn = await this.aztecNode.getBlockNumber();
-    while ((await this.aztecNode.getProvenBlockNumber()) < bn) {
+    while ((await this.aztecNode.getBlockNumber('proven')) < bn) {
       await sleep(1000);
     }
   }
@@ -174,11 +178,17 @@ export class FeesTest {
 
   public async applyBaseSetup() {
     await this.applyInitialAccounts();
+    await this.applyEnsureAuthRegistryPublished();
     await this.applyPublicDeployAccounts();
     await this.applySetupFeeJuice();
     await this.applyDeployBananaToken();
   }
 
+  async applyEnsureAuthRegistryPublished() {
+    this.logger.info('Ensuring AuthRegistry published');
+    await ensureAuthRegistryPublished(this.wallet, this.aliceAddress);
+  }
+
   async applyInitialAccounts() {
     this.logger.info('Applying initial accounts setup');
 
@@ -193,7 +203,9 @@ export class FeesTest {
     this.wallet = this.context.wallet;
     this.aztecNode = this.context.aztecNodeService;
     this.aztecNodeAdmin = this.context.aztecNodeService;
-    this.gasSettings = GasSettings.default({ maxFeesPerGas: (await this.aztecNode.getCurrentMinFees()).mul(2) });
+    this.gasSettings = GasSettings.fallback({
+      maxFeesPerGas: await getPaddedMaxFeesPerGas(this.aztecNode),
+    });
     this.cheatCodes = this.context.cheatCodes;
     this.accounts = deployedAccounts.map(a => a.address);
     this.accounts.forEach((a, i) => this.logger.verbose(`Account ${i} address: ${a}`));
@@ -300,6 +312,27 @@ export class FeesTest {
       const mana = block!.header.totalManaUsed.toBigInt();
       return mulDiv(mana * proverCost, 10n ** 12n, price);
     };
+
+    /**
+     * Reads the prover fee that the rollup actually committed for the block's checkpoint, which is what
+     * RewardLib uses to pay prover rewards. Unlike `getProverFee`, this does not re-derive the value
+     * from current L1 fees or current eth-per-fee-asset price, so it is robust to pipelined fee-asset-price
+     * drift between propose-time and reward-payout-time.
+     */
+    this.getCommittedProverFee = async (blockNumber: BlockNumber) => {
+      const block = await this.aztecNode.getBlock(blockNumber);
+      const feeHeader = await this.rollupContract.getFeeHeader(BigInt(block!.checkpointNumber));
+      return feeHeader.manaUsed * feeHeader.proverCost;
+    };
+
+    // RewardLib computes sequencerFee = checkpointFee - burn - proverFee where burn = manaUsed * congestionCost.
+    // The fixture's typical case keeps congestionCost at zero, but reading it explicitly avoids latent bugs
+    // when test load changes excess mana.
+    this.getCommittedBurn = async (blockNumber: BlockNumber) => {
+      const block = await this.aztecNode.getBlock(blockNumber);
+      const feeHeader = await this.rollupContract.getFeeHeader(BigInt(block!.checkpointNumber));
+      return feeHeader.manaUsed * feeHeader.congestionCost;
+    };
   }
 
   public async applySponsoredFPCSetup() {

package/src/e2e_nested_contract/nested_contract_test.ts

@@ -7,6 +7,7 @@ import { ParentContract } from '@aztec/noir-test-contracts.js/Parent';
 
 import {
   type EndToEndContext,
+  type SetupOptions,
   deployAccounts,
   publicDeployAccounts,
   setup,
@@ -50,9 +51,10 @@ export class NestedContractTest {
     await publicDeployAccounts(this.wallet, [this.defaultAccountAddress]);
   }
 
-  async setup() {
+  async setup(opts: Partial<SetupOptions> = {}) {
     this.logger.info('Setting up fresh subsystems');
     this.context = await setup(0, {
+      ...opts,
       fundSponsoredFPC: true,
       skipAccountDeployment: true,
     });

package/src/e2e_p2p/inactivity_slash_test.ts

@@ -58,6 +58,9 @@ export class P2PInactivityTest {
       basePort: BOOT_NODE_UDP_PORT,
       startProverNode: true,
       initialConfig: {
+        enableProposerPipelining: true,
+        inboxLag: 2,
+        anvilSlotsInAnEpoch: 4,
         proverNodeConfig: { proverNodeEpochProvingDelayMs: AZTEC_SLOT_DURATION * 1000 },
         aztecTargetCommitteeSize: COMMITTEE_SIZE,
         aztecSlotDuration: AZTEC_SLOT_DURATION,
@@ -66,7 +69,6 @@ export class P2PInactivityTest {
         listenAddress: '127.0.0.1',
         minTxsPerBlock: 0,
         aztecEpochDuration: EPOCH_DURATION,
-        validatorReexecute: false,
         sentinelEnabled: true,
         slashingQuorum: SLASHING_QUORUM,
         slashingRoundSizeInEpochs: SLASHING_ROUND_SIZE_IN_EPOCHS,
@@ -108,7 +110,7 @@ export class P2PInactivityTest {
       this.test.bootstrapNodeEnr,
       NUM_NODES - this.inactiveNodeCount - Number(this.keepInitialNode),
       BOOT_NODE_UDP_PORT,
-      this.test.prefilledPublicData,
+      this.test.genesis,
       this.dataDir,
       undefined,
       Number(this.keepInitialNode),
@@ -122,7 +124,7 @@ export class P2PInactivityTest {
       this.test.bootstrapNodeEnr,
       this.inactiveNodeCount,
       BOOT_NODE_UDP_PORT,
-      this.test.prefilledPublicData,
+      this.test.genesis,
       this.dataDir,
       undefined,
       NUM_NODES - this.inactiveNodeCount,

package/src/e2e_p2p/p2p_network.ts

@@ -1,14 +1,10 @@
-import type { InitialAccountData } from '@aztec/accounts/testing';
+import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
 import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { getAccountContractAddress } from '@aztec/aztec.js/account';
 import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
 import { Fr } from '@aztec/aztec.js/fields';
 import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
-import {
-  type EmpireSlashingProposerContract,
-  GSEContract,
-  RollupContract,
-  type TallySlashingProposerContract,
-} from '@aztec/ethereum/contracts';
+import { GSEContract, RollupContract, type SlashingProposerContract } from '@aztec/ethereum/contracts';
 import type { Operator } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
 import { MultiAdderArtifact } from '@aztec/ethereum/l1-artifacts';
@@ -24,9 +20,8 @@ import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import type { BootstrapNode } from '@aztec/p2p/bootstrap';
 import { createBootstrapNodeFromPrivateKey, getBootstrapNodeEnr } from '@aztec/p2p/test-helpers';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
-import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 import { TopicType } from '@aztec/stdlib/p2p';
-import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 import { ZkPassportProofParams } from '@aztec/stdlib/zkpassport';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
@@ -34,10 +29,13 @@ import getPort from 'get-port';
 import { type GetContractReturnType, getAddress, getContract } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 
+import {
+  SCHNORR_HARDCODED_PRIVATE_KEY,
+  SchnorrHardcodedKeyAccountContract,
+} from '../fixtures/schnorr_hardcoded_account_contract.js';
 import {
   type EndToEndContext,
   type SetupOptions,
-  deployAccounts,
   getPrivateKeyFromIndex,
   getSponsoredFPCAddress,
   setup,
@@ -76,8 +74,8 @@ export class P2PNetworkTest {
   public peerIdPrivateKeys: string[] = [];
   public validators: Operator[] = [];
 
-  public deployedAccounts: InitialAccountData[] = [];
-  public prefilledPublicData: PublicDataTreeLeaf[] = [];
+  public hardcodedAccountData!: InitialAccountData;
+  public genesis: GenesisData | undefined;
 
   // The re-execution test needs a wallet and a spam contract
   public wallet?: TestWallet;
@@ -124,12 +122,11 @@ export class P2PNetworkTest {
         initialValidatorConfig.aztecProofSubmissionEpochs ?? l1ContractsConfig.aztecProofSubmissionEpochs,
       slashingRoundSizeInEpochs:
         initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
-      slasherFlavor: initialValidatorConfig.slasherFlavor ?? 'tally',
+      slasherEnabled: initialValidatorConfig.slasherEnabled ?? true,
       aztecTargetCommitteeSize: numberOfValidators,
       metricsPort: metricsPort,
       numberOfInitialFundedAccounts: 2,
       startProverNode,
-      walletMinFeePadding: 2.0,
     };
 
     this.deployL1ContractsArgs = {
@@ -137,7 +134,7 @@ export class P2PNetworkTest {
       aztecEpochDuration: initialValidatorConfig.aztecEpochDuration ?? l1ContractsConfig.aztecEpochDuration,
       slashingRoundSizeInEpochs:
         initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
-      slasherFlavor: initialValidatorConfig.slasherFlavor ?? 'tally',
+      slasherEnabled: initialValidatorConfig.slasherEnabled ?? true,
 
       ethereumSlotDuration: initialValidatorConfig.ethereumSlotDuration ?? l1ContractsConfig.ethereumSlotDuration,
       aztecSlotDuration: initialValidatorConfig.aztecSlotDuration ?? l1ContractsConfig.aztecSlotDuration,
@@ -192,10 +189,10 @@ export class P2PNetworkTest {
   }
 
   get fundedAccount() {
-    if (!this.deployedAccounts[0]) {
-      throw new Error('Call setupAccount to create a funded account.');
+    if (!this.hardcodedAccountData) {
+      throw new Error('Call setup to initialize the hardcoded account.');
     }
-    return this.deployedAccounts[0];
+    return this.hardcodedAccountData;
   }
 
   async addBootstrapNode() {
@@ -303,17 +300,22 @@ export class P2PNetworkTest {
     await this._sendDummyTx(this.context.deployL1ContractsValues.l1Client);
   }
 
+  /** Points the wallet to a P2P-enabled node so transactions can propagate through the network. */
+  setupWalletOnNode(node: AztecNodeService) {
+    this.logger.info('Pointing wallet to a P2P-enabled node');
+    this.context.wallet.updateNode(node);
+  }
+
+  /** Registers the hardcoded account in PXE without on-chain deployment. No sequencer needed. */
   async setupAccount() {
-    this.logger.info('Setting up account');
-    const { deployedAccounts } = await deployAccounts(
-      1,
-      this.logger,
-    )({
-      wallet: this.context.wallet,
-      initialFundedAccounts: this.context.initialFundedAccounts,
+    this.logger.info('Registering hardcoded account (no deployment)');
+    const contract = new SchnorrHardcodedKeyAccountContract();
+    const accountManager = await (this.context.wallet as TestWallet).createAccount({
+      secret: this.hardcodedAccountData.secret,
+      salt: this.hardcodedAccountData.salt,
+      contract,
     });
-    this.deployedAccounts = deployedAccounts;
-    [{ address: this.defaultAccountAddress }] = deployedAccounts;
+    this.defaultAccountAddress = accountManager.address;
     this.wallet = this.context.wallet;
   }
 
@@ -354,13 +356,30 @@ export class P2PNetworkTest {
 
   async setup() {
     this.logger.info('Setting up subsystems from fresh');
+
+    // Pre-compute hardcoded account data so it gets funded in genesis.
+    const contract = new SchnorrHardcodedKeyAccountContract();
+    const secret = Fr.random();
+    const salt = Fr.random();
+    this.hardcodedAccountData = {
+      secret,
+      salt,
+      signingKey: SCHNORR_HARDCODED_PRIVATE_KEY,
+      address: await getAccountContractAddress(contract, secret, salt),
+    };
+
+    // Generate regular Schnorr accounts for tests that need deployable accounts (e.g. add_rollup).
+    const regularAccounts = await generateSchnorrAccounts(this.setupOptions.numberOfInitialFundedAccounts ?? 2);
+
     this.context = await setup(
       0,
       {
         ...this.setupOptions,
         fundSponsoredFPC: true,
         skipAccountDeployment: true,
-        slasherFlavor: this.setupOptions.slasherFlavor ?? this.deployL1ContractsArgs.slasherFlavor ?? 'none',
+        skipInitialSequencer: true,
+        initialFundedAccounts: [...regularAccounts, this.hardcodedAccountData],
+        slasherEnabled: this.setupOptions.slasherEnabled ?? this.deployL1ContractsArgs.slasherEnabled ?? false,
         aztecTargetCommitteeSize: 0,
         l1ContractsArgs: this.deployL1ContractsArgs,
       },
@@ -372,8 +391,13 @@ export class P2PNetworkTest {
     const sponsoredFPCAddress = await getSponsoredFPCAddress();
     const initialFundedAccounts = [...this.context.initialFundedAccounts.map(a => a.address), sponsoredFPCAddress];
 
-    const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
-    this.prefilledPublicData = prefilledPublicData;
+    const { genesis } = await getGenesisValues(
+      initialFundedAccounts,
+      undefined,
+      undefined,
+      this.context.genesis!.genesisTimestamp,
+    );
+    this.genesis = genesis;
 
     const rollupContract = RollupContract.getFromL1ContractsValues(this.context.deployL1ContractsValues);
     this.monitor = new ChainMonitor(rollupContract, this.context.dateProvider).start();
@@ -468,8 +492,7 @@ export class P2PNetworkTest {
   async getContracts(): Promise<{
     rollup: RollupContract;
     slasherContract: GetContractReturnType<typeof SlasherAbi, ViemClient>;
-    slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
-    slashFactory: SlashFactoryContract;
+    slashingProposer: SlashingProposerContract | undefined;
   }> {
     if (!this.ctx.deployL1ContractsValues) {
       throw new Error('DeployAztecL1ContractsValues not set');
@@ -486,14 +509,9 @@ export class P2PNetworkTest {
       client: this.ctx.deployL1ContractsValues.l1Client,
     });
 
-    // Get the actual slashing proposer from rollup (which handles both empire and tally)
+    // Get the actual slashing proposer from rollup
     const slashingProposer = await rollup.getSlashingProposer();
 
-    const slashFactory = new SlashFactoryContract(
-      this.ctx.deployL1ContractsValues.l1Client,
-      getAddress(this.ctx.deployL1ContractsValues.l1ContractAddresses.slashFactoryAddress!.toString()),
-    );
-
-    return { rollup, slasherContract, slashingProposer, slashFactory };
+    return { rollup, slasherContract, slashingProposer };
   }
 }