@aztec/end-to-end 0.86.0 → 0.87.0-nightly.20250521

package/src/bench/client_flows/config.ts

@@ -6,13 +6,17 @@ export type ClientFlowConfig = {
   recursions?: number[];
 };
 
-type ClientFlows = 'deployments' | 'transfers' | 'bridging' | 'amm';
+type ClientFlows = 'accountDeployments' | 'deployments' | 'transfers' | 'bridging' | 'amm';
 
 export type ClientFlowsConfig = {
   [key in ClientFlows]: ClientFlowConfig;
 };
 
 export const KEY_FLOWS_CONFIG: ClientFlowsConfig = {
+  accountDeployments: {
+    accounts: ['ecdsar1', 'schnorr'],
+    feePaymentMethods: ['sponsored_fpc'],
+  },
   deployments: {
     accounts: ['ecdsar1', 'schnorr'],
     feePaymentMethods: ['sponsored_fpc'],
@@ -26,13 +30,17 @@ export const KEY_FLOWS_CONFIG: ClientFlowsConfig = {
     feePaymentMethods: ['sponsored_fpc'],
   },
   transfers: {
-    accounts: ['ecdsar1', 'schnorr'],
-    feePaymentMethods: ['sponsored_fpc', 'fee_juice'],
-    recursions: [1],
+    accounts: ['ecdsar1'],
+    feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
+    recursions: [0, 1],
   },
 };
 
 export const FULL_FLOWS_CONFIG: ClientFlowsConfig = {
+  accountDeployments: {
+    accounts: ['ecdsar1', 'schnorr'],
+    feePaymentMethods: ['bridged_fee_juice', 'sponsored_fpc'],
+  },
   deployments: {
     accounts: ['ecdsar1', 'schnorr'],
     feePaymentMethods: ['bridged_fee_juice', 'sponsored_fpc'],

package/src/bench/client_flows/data_extractor.ts

@@ -2,6 +2,7 @@ import type { Logger } from '@aztec/aztec.js';
 import { BBNativePrivateKernelProver } from '@aztec/bb-prover/client/native';
 import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/client/wasm/bundle';
 import { createLogger, logger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
 import { WASMSimulator } from '@aztec/simulator/client';
 import type { PrivateExecutionStep } from '@aztec/stdlib/kernel';
 
@@ -18,7 +19,7 @@ type Log = {
   timestamp: number;
   prefix: string;
   message: string;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
   data: any;
 };
 
@@ -105,18 +106,18 @@ async function createProver(config: NativeProverConfig = {}, log: Logger) {
   }
 }
 
-function getMinimumTrace(logs: Log[], proverType: ProverType): StructuredTrace {
-  const minimumMessage = 'Minimum required block sizes for structured trace:';
+function getMinimumTrace(logs: Log[]): StructuredTrace {
+  const minimumMessage = 'Trace details:';
   const minimumMessageIndex = logs.findIndex(log => log.message.includes(minimumMessage));
   const candidateLogs = logs.slice(minimumMessageIndex - GATE_TYPES.length, minimumMessageIndex);
-  const traceLogs =
-    proverType === 'wasm'
-      ? candidateLogs.map(log => log.message)
-      : logs
-          .slice(minimumMessageIndex - GATE_TYPES.length, minimumMessageIndex)
-          .filter(log => GATE_TYPES.some(type => log.message.includes(`bb - ${type}`)))
-          .map(log => log.message.split('\n'))
-          .flat();
+
+  const traceLogs = candidateLogs
+    .filter(log => GATE_TYPES.some(type => log.message.includes(type)))
+    .map(log => log.message.split(/\t|\n/))
+    .flat()
+    .map(log => log.replace(/\(mem: .*\)/, '').trim())
+    .filter(Boolean);
+
   const traceSizes = traceLogs.map(log => {
     const [gateType, gateSizeStr] = log
       .replace(/\n.*\)$/, '')
@@ -127,6 +128,7 @@ function getMinimumTrace(logs: Log[], proverType: ProverType): StructuredTrace {
     assert(GATE_TYPES.includes(gateType as GateType), `Gate type ${gateType} is not recognized`);
     return { [gateType]: gateSize };
   });
+
   assert(traceSizes.length === GATE_TYPES.length, 'Decoded trace sizes do not match expected amount of gate types');
   return traceSizes.reduce((acc, curr) => ({ ...acc, ...curr }), {}) as StructuredTrace;
 }
@@ -156,23 +158,36 @@ async function main() {
     const witnessStack = JSON.parse(witnesses.toString()).map((witnessMap: Record<string, string>) => {
       return new Map<number, string>(Object.entries(witnessMap).map(([k, v]) => [Number(k), v]));
     });
-    const stepsFile = await readFile(join(ivcFolder, flow, 'steps.json'));
-    const executionSteps = JSON.parse(stepsFile.toString()) as { fnName: string; gateCount: number }[];
-    const privateExecutionSteps: PrivateExecutionStep[] = executionSteps.map((step, i) => ({
+    const profileFile = await readFile(join(ivcFolder, flow, 'profile.json'));
+    const profile = JSON.parse(profileFile.toString()) as {
+      syncTime: number;
+      steps: {
+        fnName: string;
+        gateCount: number;
+        timings: { witgen: number; gateCount: number };
+      }[];
+    };
+    const privateExecutionSteps: PrivateExecutionStep[] = profile.steps.map((step, i) => ({
       functionName: step.fnName,
       gateCount: step.gateCount,
       bytecode: stepsFromFile[i].bytecode,
       // TODO(AD) do we still want to take this from witness.json?
       witness: witnessStack[i],
-      // This can be left empty. If so, the prover will generate a vk on the fly (~25% slower).
-      vk: Buffer.from([]),
+      vk: stepsFromFile[i].vk,
+      timings: {
+        witgen: step.timings.witgen,
+        gateCount: step.timings.witgen,
+      },
     }));
     let stats: { duration: number; eventName: string; proofSize: number } | undefined;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let error: any | undefined;
+
+    let error: any;
     let currentLogs: Log[] = [];
+    let provingTime;
     try {
+      const provingTimer = new Timer();
       await prover.createClientIvcProof(privateExecutionSteps);
+      provingTime = provingTimer.ms();
     } catch (e) {
       userLog.error(`Failed to generate client ivc proof for ${flow}`, e);
       error = (e as Error).message;
@@ -185,9 +200,9 @@ async function main() {
       stats = currentLogs[0].data as { duration: number; eventName: string; proofSize: number };
     }
 
-    const minimumTrace = getMinimumTrace(currentLogs, proverType);
+    const minimumTrace = getMinimumTrace(currentLogs);
 
-    const steps = executionSteps.reduce<Step[]>((acc, step, i) => {
+    const steps = profile.steps.reduce<Step[]>((acc, step, i) => {
       const previousAccGateCount = i === 0 ? 0 : acc[i - 1].accGateCount!;
       return [
         ...acc,
@@ -195,11 +210,16 @@ async function main() {
           fnName: step.fnName,
           gateCount: step.gateCount,
           accGateCount: previousAccGateCount + step.gateCount,
+          timings: {
+            witgen: step.timings.witgen,
+          },
         },
       ];
     }, []);
     const totalGateCount = steps[steps.length - 1].accGateCount;
     const benchmark = {
+      syncTime: profile.syncTime,
+      provingTime,
       proverType,
       minimumTrace: minimumTrace,
       totalGateCount,

package/src/bench/utils.ts

@@ -1,12 +1,13 @@
 import type { AztecNodeService } from '@aztec/aztec-node';
 import { type AztecNode, BatchCall, type SentTx, type WaitOpts } from '@aztec/aztec.js';
 import { mean, stdDev, times } from '@aztec/foundation/collection';
-import { BenchmarkingContract } from '@aztec/noir-contracts.js/Benchmarking';
+import { BenchmarkingContract } from '@aztec/noir-test-contracts.js/Benchmarking';
 import { type PXEService, type PXEServiceConfig, createPXEService } from '@aztec/pxe/server';
 import type { MetricsType } from '@aztec/telemetry-client';
 import type { BenchmarkDataPoint, BenchmarkMetricsType, BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
 
-import { writeFileSync } from 'fs';
+import { mkdirSync, writeFileSync } from 'fs';
+import path from 'path';
 
 import { type EndToEndContext, type SetupOptions, setup } from '../fixtures/utils.js';
 
@@ -36,6 +37,7 @@ export async function benchmarkSetup(
       throw new Error(`No benchmark data generated. Please review your test setup.`);
     }
     const benchOutput = opts.benchOutput ?? process.env.BENCH_OUTPUT ?? 'bench.json';
+    mkdirSync(path.dirname(benchOutput), { recursive: true });
     writeFileSync(benchOutput, JSON.stringify(formatted));
     context.logger.info(`Wrote ${data.length} metrics to ${benchOutput}`);
     await origTeardown();
@@ -136,7 +138,7 @@ export async function sendTxs(
 ): Promise<SentTx[]> {
   const calls = times(txCount, index => makeCall(index, context, contract, heavyPublicCompute));
   context.logger.info(`Creating ${txCount} txs`);
-  const provenTxs = await Promise.all(calls.map(call => call.prove({ skipPublicSimulation: true })));
+  const provenTxs = await Promise.all(calls.map(call => call.prove()));
   context.logger.info(`Sending ${txCount} txs`);
   return provenTxs.map(tx => tx.send());
 }
@@ -166,7 +168,9 @@ export async function createNewPXE(node: AztecNode, contract: BenchmarkingContra
     l1ChainId,
     rollupVersion,
   } as PXEServiceConfig;
+  // docs:start:PXEcreate
   const pxe = await createPXEService(node, pxeConfig);
+  // docs:end:PXEcreate
   await pxe.registerContract(contract);
   return pxe;
 }

package/src/e2e_blacklist_token_contract/blacklist_token_contract_test.ts

@@ -11,9 +11,9 @@ import {
   createLogger,
 } from '@aztec/aztec.js';
 import { MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
-import { InvalidAccountContract } from '@aztec/noir-contracts.js/InvalidAccount';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBlacklistContract } from '@aztec/noir-contracts.js/TokenBlacklist';
+import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
 
 import { jest } from '@jest/globals';
 

package/src/e2e_cross_chain_messaging/cross_chain_messaging_test.ts

@@ -11,10 +11,16 @@ import {
   createLogger,
 } from '@aztec/aztec.js';
 import { CheatCodes } from '@aztec/aztec.js/testing';
-import { type ExtendedViemWalletClient, createExtendedL1Client, deployL1Contract } from '@aztec/ethereum';
+import {
+  type DeployL1ContractsReturnType,
+  type ExtendedViemWalletClient,
+  createExtendedL1Client,
+  deployL1Contract,
+} from '@aztec/ethereum';
 import { InboxAbi, OutboxAbi, TestERC20Abi, TestERC20Bytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 
 import { getContract } from 'viem';
 
@@ -38,6 +44,7 @@ export class CrossChainMessagingTest {
   aztecNode!: AztecNode;
   pxe!: PXE;
   aztecNodeConfig!: AztecNodeConfig;
+  aztecNodeAdmin!: AztecNodeAdmin;
 
   l1Client!: ExtendedViemWalletClient | undefined;
 
@@ -51,7 +58,9 @@ export class CrossChainMessagingTest {
 
   inbox!: any; // GetContractReturnType<typeof InboxAbi> | undefined;
   outbox!: any; // GetContractReturnType<typeof OutboxAbi> | undefined;
-  cheatcodes!: CheatCodes;
+  cheatCodes!: CheatCodes;
+
+  deployL1ContractsValues!: DeployL1ContractsReturnType;
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${testName}`);
@@ -59,15 +68,17 @@ export class CrossChainMessagingTest {
   }
 
   async assumeProven() {
-    await this.cheatcodes.rollup.markAsProven();
+    await this.cheatCodes.rollup.markAsProven();
   }
 
   async setup() {
-    const { aztecNode, pxe, aztecNodeConfig } = await this.snapshotManager.setup();
+    const { aztecNode, pxe, aztecNodeConfig, deployL1ContractsValues } = await this.snapshotManager.setup();
     this.aztecNode = aztecNode;
     this.pxe = pxe;
     this.aztecNodeConfig = aztecNodeConfig;
-    this.cheatcodes = await CheatCodes.create(this.aztecNodeConfig.l1RpcUrls, this.pxe);
+    this.cheatCodes = await CheatCodes.create(this.aztecNodeConfig.l1RpcUrls, this.pxe);
+    this.deployL1ContractsValues = deployL1ContractsValues;
+    this.aztecNodeAdmin = aztecNode;
   }
 
   snapshot = <T>(

package/src/e2e_deploy_contract/deploy_test.ts

@@ -13,7 +13,7 @@ import {
   createLogger,
   getContractInstanceFromDeployParams,
 } from '@aztec/aztec.js';
-import type { StatefulTestContract } from '@aztec/noir-contracts.js/StatefulTest';
+import type { StatefulTestContract } from '@aztec/noir-test-contracts.js/StatefulTest';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 
 import { type ISnapshotManager, createSnapshotManager, deployAccounts } from '../fixtures/snapshot_manager.js';

package/src/e2e_epochs/epochs_test.ts

@@ -10,7 +10,7 @@ import type { TestProverNode } from '@aztec/prover-node/test';
 import type { SequencerPublisher } from '@aztec/sequencer-client';
 import type { TestSequencerClient } from '@aztec/sequencer-client/test';
 import type { L2BlockNumber } from '@aztec/stdlib/block';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { type L1RollupConstants, getProofSubmissionDeadlineTimestamp } from '@aztec/stdlib/epoch-helpers';
 
 import { join } from 'path';
 import type { Hex } from 'viem';
@@ -23,15 +23,23 @@ import {
   setup,
 } from '../fixtures/utils.js';
 
-// This can be lowered to as much as 2s in non-CI
-export const L1_BLOCK_TIME_IN_S = process.env.L1_BLOCK_TIME ? parseInt(process.env.L1_BLOCK_TIME) : 8;
-export const L2_SLOT_DURATION_IN_L1_SLOTS = 2;
 export const WORLD_STATE_BLOCK_HISTORY = 2;
 export const WORLD_STATE_BLOCK_CHECK_INTERVAL = 50;
 export const ARCHIVER_POLL_INTERVAL = 50;
 
 export type EpochsTestOpts = Partial<
-  Pick<SetupOptions, 'startProverNode' | 'aztecProofSubmissionWindow' | 'aztecEpochDuration' | 'proverTestDelayMs'>
+  Pick<
+    SetupOptions,
+    | 'startProverNode'
+    | 'aztecProofSubmissionWindow'
+    | 'aztecEpochDuration'
+    | 'proverTestDelayMs'
+    | 'l1PublishRetryIntervalMS'
+    | 'txPropagationMaxQueryAttempts'
+    | 'proverNodeConfig'
+    | 'ethereumSlotDuration'
+    | 'aztecSlotDuration'
+  >
 >;
 
 /**
@@ -54,17 +62,33 @@ export class EpochsTestContext {
 
   public epochDuration!: number;
 
+  public L1_BLOCK_TIME_IN_S!: number;
+  public L2_SLOT_DURATION_IN_S!: number;
+
   public static async setup(opts: EpochsTestOpts = {}) {
     const test = new EpochsTestContext();
     await test.setup(opts);
     return test;
   }
 
+  public static getSlotDurations(opts: EpochsTestOpts = {}) {
+    const envEthereumSlotDuration = process.env.L1_BLOCK_TIME ? parseInt(process.env.L1_BLOCK_TIME) : 8;
+    const ethereumSlotDuration = opts.ethereumSlotDuration ?? envEthereumSlotDuration;
+    const aztecSlotDuration = opts.aztecSlotDuration ?? ethereumSlotDuration * 2;
+    const aztecEpochDuration = opts.aztecEpochDuration ?? 4;
+    const aztecProofSubmissionWindow = opts.aztecProofSubmissionWindow ?? aztecEpochDuration * 2 - 1;
+    return { ethereumSlotDuration, aztecSlotDuration, aztecEpochDuration, aztecProofSubmissionWindow };
+  }
+
   public async setup(opts: EpochsTestOpts = {}) {
+    const { ethereumSlotDuration, aztecSlotDuration, aztecEpochDuration, aztecProofSubmissionWindow } =
+      EpochsTestContext.getSlotDurations(opts);
+
+    this.L1_BLOCK_TIME_IN_S = ethereumSlotDuration;
+    this.L2_SLOT_DURATION_IN_S = aztecSlotDuration;
+
     // Set up system without any account nor protocol contracts
     // and with faster block times and shorter epochs.
-    const aztecEpochDuration = opts.aztecEpochDuration ?? 4;
-    const proofSubmissionWindow = opts.aztecProofSubmissionWindow ?? aztecEpochDuration * 2 - 1;
     const context = await setup(0, {
       checkIntervalMs: 50,
       archiverPollingIntervalMS: ARCHIVER_POLL_INTERVAL,
@@ -72,9 +96,9 @@ export class EpochsTestContext {
       skipProtocolContracts: true,
       salt: 1,
       aztecEpochDuration,
-      aztecSlotDuration: L1_BLOCK_TIME_IN_S * L2_SLOT_DURATION_IN_L1_SLOTS,
-      ethereumSlotDuration: L1_BLOCK_TIME_IN_S,
-      aztecProofSubmissionWindow: proofSubmissionWindow,
+      aztecSlotDuration,
+      ethereumSlotDuration,
+      aztecProofSubmissionWindow,
       minTxsPerBlock: 0,
       realProofs: false,
       startProverNode: true,
@@ -84,7 +108,7 @@ export class EpochsTestContext {
       proverId: Fr.fromString('1'),
       // This must be enough so that the tx from the prover is delayed properly,
       // but not so much to hang the sequencer and timeout the teardown
-      txPropagationMaxQueryAttempts: 12,
+      txPropagationMaxQueryAttempts: opts.txPropagationMaxQueryAttempts ?? 12,
       worldStateBlockHistory: WORLD_STATE_BLOCK_HISTORY,
       ...opts,
     });
@@ -116,11 +140,11 @@ export class EpochsTestContext {
     this.epochDuration = aztecEpochDuration;
     this.constants = {
       epochDuration: aztecEpochDuration,
-      slotDuration: L1_BLOCK_TIME_IN_S * L2_SLOT_DURATION_IN_L1_SLOTS,
+      slotDuration: aztecSlotDuration,
       l1StartBlock: await this.rollup.getL1StartBlock(),
       l1GenesisTime: await this.rollup.getL1GenesisTime(),
-      ethereumSlotDuration: L1_BLOCK_TIME_IN_S,
-      proofSubmissionWindow,
+      ethereumSlotDuration,
+      proofSubmissionWindow: aztecProofSubmissionWindow,
     };
 
     this.logger.info(
@@ -143,8 +167,8 @@ export class EpochsTestContext {
       createAndSyncProverNode(
         proverNodePrivateKey,
         { ...this.context.config, proverId: Fr.fromString(suffix) },
+        { dataDirectory: join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')) },
         this.context.aztecNode,
-        join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')),
       ),
     );
     this.proverNodes.push(proverNode);
@@ -174,14 +198,14 @@ export class EpochsTestContext {
   public async waitUntilEpochStarts(epoch: number) {
     const [start] = getTimestampRangeForEpoch(BigInt(epoch), this.constants);
     this.logger.info(`Waiting until L1 timestamp ${start} is reached as the start of epoch ${epoch}`);
-    await waitUntilL1Timestamp(this.l1Client, start - BigInt(L1_BLOCK_TIME_IN_S));
+    await waitUntilL1Timestamp(this.l1Client, start - BigInt(this.L1_BLOCK_TIME_IN_S));
     return start;
   }
 
   /** Waits until the given L2 block number is mined. */
   public async waitUntilL2BlockNumber(target: number, timeout = 60) {
     await retryUntil(
-      () => Promise.resolve(target === this.monitor.l2BlockNumber),
+      () => Promise.resolve(target <= this.monitor.l2BlockNumber),
       `Wait until L2 block ${target}`,
       timeout,
       0.1,
@@ -191,11 +215,20 @@ export class EpochsTestContext {
   /** Waits until the given L2 block number is marked as proven. */
   public async waitUntilProvenL2BlockNumber(t: number, timeout = 60) {
     await retryUntil(
-      () => Promise.resolve(t === this.monitor.l2ProvenBlockNumber),
+      () => Promise.resolve(t <= this.monitor.l2ProvenBlockNumber),
       `Wait proven L2 block ${t}`,
       timeout,
       0.1,
     );
+    return this.monitor.l2ProvenBlockNumber;
+  }
+
+  /** Waits until the end of the proof submission window for a given epoch. */
+  public async waitUntilEndOfProofSubmissionWindow(epochNumber: number | bigint) {
+    const deadline = getProofSubmissionDeadlineTimestamp(BigInt(epochNumber), this.constants);
+    const date = new Date(Number(deadline) * 1000);
+    this.logger.info(`Waiting until end of submission window for epoch ${epochNumber} at ${date}`, { deadline });
+    await waitUntilL1Timestamp(this.l1Client, deadline);
   }
 
   /** Waits for the aztec node to sync to the target block number. */

package/src/e2e_fees/bridging_race.notest.ts

@@ -0,0 +1,74 @@
+import { getSchnorrAccount } from '@aztec/accounts/schnorr';
+import { Fr, type Logger, type PXE, sleep } from '@aztec/aztec.js';
+import { FEE_FUNDING_FOR_TESTER_ACCOUNT } from '@aztec/constants';
+import { Fq } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import { jest } from '@jest/globals';
+import type { Hex } from 'viem';
+
+import { FeesTest } from './fees_test.js';
+
+jest.setTimeout(300_000);
+
+// Regression for https://github.com/AztecProtocol/aztec-packages/issues/12366
+// Similar to e2e_fees/account_init but with no automine
+describe('e2e_fees bridging_race', () => {
+  const ETHEREUM_SLOT_DURATION = 4;
+  const AZTEC_SLOT_DURATION = ETHEREUM_SLOT_DURATION * 2;
+
+  const t = new FeesTest('bridging_race', 1, {
+    ethereumSlotDuration: ETHEREUM_SLOT_DURATION,
+    aztecSlotDuration: AZTEC_SLOT_DURATION,
+    minTxsPerBlock: 0,
+  });
+
+  beforeAll(async () => {
+    await t.applyInitialAccountsSnapshot();
+    await t.applyPublicDeployAccountsSnapshot();
+    await t.applySetupFeeJuiceSnapshot();
+
+    ({ pxe, logger } = await t.setup());
+  });
+
+  afterAll(async () => {
+    await t.teardown();
+  });
+
+  let logger: Logger;
+  let pxe: PXE;
+  let bobsAddress: AztecAddress;
+
+  beforeEach(async () => {
+    const bobsSecretKey = Fr.random();
+    const bobsPrivateSigningKey = Fq.random();
+    const bobsAccountManager = await getSchnorrAccount(pxe, bobsSecretKey, bobsPrivateSigningKey, Fr.random());
+    const bobsCompleteAddress = await bobsAccountManager.getCompleteAddress();
+    bobsAddress = bobsCompleteAddress.address;
+    await bobsAccountManager.getWallet();
+    await bobsAccountManager.register();
+  });
+
+  it('Alice bridges funds to Bob', async () => {
+    // Tweak the token manager so the bridging happens immediately before the end of the current L2 slot
+    // This caused the message to be "not in state" when tried to be used
+    const l1TokenManager = t.feeJuiceBridgeTestHarness.l1TokenManager;
+    const origApprove = l1TokenManager.approve.bind(l1TokenManager);
+    l1TokenManager.approve = async (amount: bigint, address: Hex, addressName = '') => {
+      await origApprove(amount, address, addressName);
+      const sleepTime = (Number(t.chainMonitor.l2BlockTimestamp) + AZTEC_SLOT_DURATION) * 1000 - Date.now() - 500;
+      logger.info(`Sleeping for ${sleepTime}ms until near end of L2 slot before sending L1 fee juice to L2 inbox`);
+      await sleep(sleepTime);
+    };
+
+    // Waiting for the archiver to sync the message _before_ waiting for the mandatory 2 L2 blocks to pass fixed it
+    // This was added everywhere we wait for two blocks, which is spread across three different places in the codebase
+    // Yes, we need to REFACTOR it at some point
+    const amount = FEE_FUNDING_FOR_TESTER_ACCOUNT;
+    const claim = await t.feeJuiceBridgeTestHarness.prepareTokensOnL1(amount, bobsAddress);
+    const { claimSecret: secret, messageLeafIndex: index } = claim;
+    await t.feeJuiceContract.methods.claim(bobsAddress, amount, secret, index).send().wait();
+    const [balance] = await t.getGasBalanceFn(bobsAddress);
+    expect(balance).toEqual(amount);
+  });
+});

package/src/e2e_fees/fees_test.ts

@@ -21,11 +21,11 @@ import { ChainMonitor } from '@aztec/ethereum/test';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { TestERC20Abi } from '@aztec/l1-artifacts';
 import { AppSubscriptionContract } from '@aztec/noir-contracts.js/AppSubscription';
-import { CounterContract } from '@aztec/noir-contracts.js/Counter';
 import { FPCContract } from '@aztec/noir-contracts.js/FPC';
 import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
 import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
 import { TokenContract as BananaCoin } from '@aztec/noir-contracts.js/Token';
+import { CounterContract } from '@aztec/noir-test-contracts.js/Counter';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
 import { GasSettings } from '@aztec/stdlib/gas';
@@ -310,17 +310,33 @@ export class FeesTest {
         };
 
         this.getProverFee = async (blockNumber: number) => {
+          const block = await this.pxe.getBlock(blockNumber);
+
           const publicClient = getPublicClient({
             l1RpcUrls: context.aztecNodeConfig.l1RpcUrls,
             l1ChainId: context.aztecNodeConfig.l1ChainId,
           });
           const rollup = new RollupContract(publicClient, data.rollupAddress);
 
-          const provingCostPerMana = await rollup.getProvingCostPerManaInFeeAsset();
+          // @todo @lherskind As we deal with #13601
+          // Right now the value is from `FeeLib.sol`
+          const L1_GAS_PER_EPOCH_VERIFIED = 1000000n;
+
+          // We round up
+          const mulDiv = (a: bigint, b: bigint, c: bigint) => (a * b) / c + ((a * b) % c > 0n ? 1n : 0n);
+
+          const { baseFee } = await rollup.getL1FeesAt(block!.header.globalVariables.timestamp.toBigInt());
+          const proverCost =
+            mulDiv(
+              mulDiv(L1_GAS_PER_EPOCH_VERIFIED, baseFee, await rollup.getEpochDuration()),
+              1n,
+              await rollup.getManaTarget(),
+            ) + (await rollup.getProvingCostPerMana());
+
+          const price = await rollup.getFeeAssetPerEth();
 
-          const block = await this.pxe.getBlock(blockNumber);
           const mana = block!.header.totalManaUsed.toBigInt();
-          return mana * provingCostPerMana;
+          return mulDiv(mana * proverCost, price, 10n ** 9n);
         };
       },
     );
@@ -333,16 +349,15 @@ export class FeesTest {
         const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
         expect((await context.pxe.getContractMetadata(feeJuiceContract.address)).isContractPubliclyDeployed).toBe(true);
 
-        this.sponsoredFPC = await setupSponsoredFPC(context.pxe);
-        this.logger.info(`SponsoredFPC deployed at ${this.sponsoredFPC.address}`);
+        const sponsoredFPC = await setupSponsoredFPC(context.pxe);
+        this.logger.info(`SponsoredFPC at ${sponsoredFPC.address}`);
 
         return {
-          sponsoredFPCAddress: this.sponsoredFPC.address,
+          sponsoredFPCAddress: sponsoredFPC.address,
         };
       },
       async data => {
-        const sponsoredFPC = await SponsoredFPCContract.at(data.sponsoredFPCAddress, this.aliceWallet);
-        this.sponsoredFPC = sponsoredFPC;
+        this.sponsoredFPC = await SponsoredFPCContract.at(data.sponsoredFPCAddress, this.aliceWallet);
       },
     );
   }

package/src/e2e_nested_contract/nested_contract_test.ts

@@ -1,7 +1,7 @@
 import { getSchnorrWallet } from '@aztec/accounts/schnorr';
 import { type AccountWallet, type CompleteAddress, type Logger, type PXE, createLogger } from '@aztec/aztec.js';
-import { ChildContract } from '@aztec/noir-contracts.js/Child';
-import { ParentContract } from '@aztec/noir-contracts.js/Parent';
+import { ChildContract } from '@aztec/noir-test-contracts.js/Child';
+import { ParentContract } from '@aztec/noir-test-contracts.js/Parent';
 
 import {
   type ISnapshotManager,
@@ -23,7 +23,10 @@ export class NestedContractTest {
   parentContract!: ParentContract;
   childContract!: ChildContract;
 
-  constructor(testName: string, private numberOfAccounts = 1) {
+  constructor(
+    testName: string,
+    private numberOfAccounts = 1,
+  ) {
     this.logger = createLogger(`e2e:e2e_nested_contract:${testName}`);
     this.snapshotManager = createSnapshotManager(`e2e_nested_contract/${testName}-${numberOfAccounts}`, dataPath);
   }