@aztec/end-to-end 0.81.0 → 0.82.0

package/src/e2e_fees/fees_test.ts

@@ -10,10 +10,10 @@ import {
 } from '@aztec/aztec.js';
 import { CheatCodes } from '@aztec/aztec.js/testing';
 import { FEE_FUNDING_FOR_TESTER_ACCOUNT } from '@aztec/constants';
-import { type DeployL1ContractsArgs, RollupContract, createL1Clients } from '@aztec/ethereum';
+import { type DeployL1ContractsArgs, RollupContract, createL1Clients, getPublicClient } from '@aztec/ethereum';
 import { ChainMonitor } from '@aztec/ethereum/test';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+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';
@@ -21,7 +21,6 @@ import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
 import { TokenContract as BananaCoin } from '@aztec/noir-contracts.js/Token';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
-import { computePartialAddress } from '@aztec/stdlib/contract';
 import { GasSettings } from '@aztec/stdlib/gas';
 
 import { getContract } from 'viem';
@@ -165,8 +164,9 @@ export class FeesTest {
     await this.snapshotManager.snapshot(
       'initial_accounts',
       deployAccounts(this.numberOfAccounts, this.logger),
-      async ({ deployedAccounts }, { pxe, aztecNode, aztecNodeConfig }) => {
+      async ({ deployedAccounts }, { pxe, aztecNode, aztecNodeConfig, deployL1ContractsValues }) => {
         this.pxe = pxe;
+
         this.aztecNode = aztecNode;
         this.gasSettings = GasSettings.default({ maxFeesPerGas: (await this.aztecNode.getCurrentBaseFees()).mul(2) });
         this.cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
@@ -180,18 +180,14 @@ export class FeesTest {
 
         const canonicalFeeJuice = await getCanonicalFeeJuice();
         this.feeJuiceContract = await FeeJuiceContract.at(canonicalFeeJuice.address, this.aliceWallet);
-        if (this.numberOfAccounts > 1) {
-          const bobInstance = (await this.bobWallet.getContractMetadata(this.bobAddress)).contractInstance;
-          await this.aliceWallet.registerAccount(deployedAccounts[1].secret, await computePartialAddress(bobInstance!));
-        }
         this.coinbase = EthAddress.random();
 
-        const { publicClient, walletClient } = createL1Clients(aztecNodeConfig.l1RpcUrls, MNEMONIC);
         this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
-          aztecNode: aztecNode,
+          aztecNode,
+          aztecNodeAdmin: aztecNode,
           pxeService: pxe,
-          publicClient: publicClient,
-          walletClient: walletClient,
+          publicClient: deployL1ContractsValues.publicClient,
+          walletClient: deployL1ContractsValues.walletClient,
           wallet: this.aliceWallet,
           logger: this.logger,
         });
@@ -218,12 +214,12 @@ export class FeesTest {
 
         this.getGasBalanceFn = getBalancesFn('⛽', this.feeJuiceContract.methods.balance_of_public, this.logger);
 
-        const { publicClient, walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
         this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
           aztecNode: context.aztecNode,
+          aztecNodeAdmin: context.aztecNode,
           pxeService: context.pxe,
-          publicClient: publicClient,
-          walletClient: walletClient,
+          publicClient: context.deployL1ContractsValues.publicClient,
+          walletClient: context.deployL1ContractsValues.walletClient,
           wallet: this.aliceWallet,
           logger: this.logger,
         });
@@ -293,25 +289,22 @@ export class FeesTest {
         };
 
         this.getCoinbaseSequencerRewards = async () => {
-          const { walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-          const rollup = getContract({
-            address: data.rollupAddress.toString(),
-            abi: RollupAbi,
-            client: walletClient,
+          const publicClient = getPublicClient({
+            l1RpcUrls: context.aztecNodeConfig.l1RpcUrls,
+            l1ChainId: context.aztecNodeConfig.l1ChainId,
           });
-
-          return await rollup.read.getSequencerRewards([this.coinbase.toString()]);
+          const rollup = new RollupContract(publicClient, data.rollupAddress);
+          return await rollup.getSequencerRewards(this.coinbase);
         };
 
         this.getProverFee = async (blockNumber: number) => {
-          const { walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-          const rollup = getContract({
-            address: data.rollupAddress.toString(),
-            abi: RollupAbi,
-            client: walletClient,
+          const publicClient = getPublicClient({
+            l1RpcUrls: context.aztecNodeConfig.l1RpcUrls,
+            l1ChainId: context.aztecNodeConfig.l1ChainId,
           });
+          const rollup = new RollupContract(publicClient, data.rollupAddress);
 
-          const provingCostPerMana = await rollup.read.getProvingCostPerManaInFeeAsset();
+          const provingCostPerMana = await rollup.getProvingCostPerManaInFeeAsset();
 
           const block = await this.pxe.getBlock(blockNumber);
           const mana = block!.header.totalManaUsed.toBigInt();

package/src/e2e_prover/e2e_prover_test.ts

@@ -24,6 +24,7 @@ import { HonkVerifierAbi, HonkVerifierBytecode, RollupAbi, TestERC20Abi } from '
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { type ProverNode, type ProverNodeConfig, createProverNode } from '@aztec/prover-node';
 import type { PXEService } from '@aztec/pxe/server';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import { type Hex, getContract } from 'viem';
@@ -67,6 +68,7 @@ export class FullProverTest {
   fakeProofsAsset!: TokenContract;
   tokenSim!: TokenSimulator;
   aztecNode!: AztecNode;
+  aztecNodeAdmin!: AztecNodeAdmin;
   pxe!: PXEService;
   cheatCodes!: CheatCodes;
   blobSink!: BlobSinkServer;
@@ -121,7 +123,7 @@ export class FullProverTest {
         // Create the token contract state.
         // Move this account thing to addAccounts above?
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 2), false);
+        await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 2));
 
         this.logger.verbose(`Deploying TokenContract...`);
         const asset = await TokenContract.deploy(
@@ -168,6 +170,7 @@ export class FullProverTest {
       cheatCodes: this.cheatCodes,
       blobSink: this.blobSink,
     } = this.context);
+    this.aztecNodeAdmin = this.context.aztecNode;
 
     const blobSinkClient = createBlobSinkClient({ blobSinkUrl: `http://localhost:${this.blobSink.port}` });
 
@@ -190,14 +193,14 @@ export class FullProverTest {
       this.circuitProofVerifier = await BBCircuitVerifier.new(bbConfig);
 
       this.logger.debug(`Configuring the node for real proofs...`);
-      await this.aztecNode.setConfig({
+      await this.aztecNodeAdmin.setConfig({
         realProofs: true,
         minTxsPerBlock: this.minNumberOfTxsPerBlock,
       });
     } else {
       this.logger.debug(`Configuring the node min txs per block ${this.minNumberOfTxsPerBlock}...`);
       this.circuitProofVerifier = new TestCircuitVerifier();
-      await this.aztecNode.setConfig({
+      await this.aztecNodeAdmin.setConfig({
         minTxsPerBlock: this.minNumberOfTxsPerBlock,
       });
     }
@@ -345,16 +348,14 @@ export class FullProverTest {
         const privateAmount = 10000n;
         const publicAmount = 10000n;
 
-        const waitOpts = { proven: false };
-
         this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
         await asset.methods
           .mint_to_public(accounts[0].address, privateAmount + publicAmount)
           .send()
-          .wait(waitOpts);
+          .wait();
 
         this.logger.verbose(`Transferring ${privateAmount} to private...`);
-        await asset.methods.transfer_to_private(accounts[0].address, privateAmount).send().wait(waitOpts);
+        await asset.methods.transfer_to_private(accounts[0].address, privateAmount).send().wait();
 
         this.logger.verbose(`Minting complete.`);
 

package/src/e2e_token_contract/token_contract_test.ts

@@ -1,5 +1,5 @@
 import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { type AccountWallet, type CompleteAddress, type Logger, createLogger } from '@aztec/aztec.js';
+import { type AccountWallet, type AztecNode, type CompleteAddress, type Logger, createLogger } from '@aztec/aztec.js';
 import { DocsExampleContract } from '@aztec/noir-contracts.js/DocsExample';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
@@ -28,6 +28,7 @@ export class TokenContractTest {
   asset!: TokenContract;
   tokenSim!: TokenSimulator;
   badAccount!: DocsExampleContract;
+  node!: AztecNode;
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_token_contract:${testName}`);
@@ -48,7 +49,8 @@ export class TokenContractTest {
     await this.snapshotManager.snapshot(
       '3_accounts',
       deployAccounts(3, this.logger),
-      async ({ deployedAccounts }, { pxe }) => {
+      async ({ deployedAccounts }, { pxe, aztecNode }) => {
+        this.node = aztecNode;
         this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
         this.accounts = this.wallets.map(w => w.getCompleteAddress());
       },

package/src/fixtures/snapshot_manager.ts

@@ -3,13 +3,16 @@ import { type InitialAccountData, deployFundedSchnorrAccounts, generateSchnorrAc
 import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
 import {
   type AztecAddress,
+  type AztecNode,
   BatchCall,
   type CompleteAddress,
   type ContractFunctionInteraction,
+  DefaultWaitForProvenOpts,
   type Logger,
   type PXE,
   type Wallet,
   getContractClassFromArtifact,
+  waitForProven,
 } from '@aztec/aztec.js';
 import { deployInstance, registerContractClass } from '@aztec/aztec.js/deployment';
 import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec.js/testing';
@@ -400,10 +403,8 @@ async function setupFromFresh(
       l1RpcUrls: aztecNodeConfig.l1RpcUrls,
       rollupAddress: aztecNodeConfig.l1Contracts.rollupAddress,
       port: blobSinkPort,
-      dataStoreConfig: {
-        dataDirectory: aztecNodeConfig.dataDirectory,
-        dataStoreMapSizeKB: aztecNodeConfig.dataStoreMapSizeKB,
-      },
+      dataDirectory: aztecNodeConfig.dataDirectory,
+      dataStoreMapSizeKB: aztecNodeConfig.dataStoreMapSizeKB,
     },
     telemetry,
   );
@@ -522,10 +523,8 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
       l1RpcUrls: aztecNodeConfig.l1RpcUrls,
       rollupAddress: aztecNodeConfig.l1Contracts.rollupAddress,
       port: blobSinkPort,
-      dataStoreConfig: {
-        dataDirectory: statePath,
-        dataStoreMapSizeKB: aztecNodeConfig.dataStoreMapSizeKB,
-      },
+      dataDirectory: statePath,
+      dataStoreMapSizeKB: aztecNodeConfig.dataStoreMapSizeKB,
     },
     telemetry,
   );
@@ -594,7 +593,12 @@ export const deployAccounts =
 
     logger.verbose('Deploying accounts funded with fee juice...');
     const deployedAccounts = initialFundedAccounts.slice(0, numberOfAccounts);
-    await deployFundedSchnorrAccounts(pxe, deployedAccounts, { proven: waitUntilProven });
+    await deployFundedSchnorrAccounts(
+      pxe,
+      deployedAccounts,
+      undefined,
+      waitUntilProven ? DefaultWaitForProvenOpts : undefined,
+    );
 
     return { deployedAccounts };
   };
@@ -604,11 +608,14 @@ export const deployAccounts =
  * Use this when you need to make a public call to an account contract, such as for requesting a public authwit.
  * @param sender - Wallet to send the deployment tx.
  * @param accountsToDeploy - Which accounts to publicly deploy.
+ * @param waitUntilProven - Whether to wait for the tx to be proven.
+ * @param pxeOrNode - PXE or AztecNode to wait for proven.
  */
 export async function publicDeployAccounts(
   sender: Wallet,
   accountsToDeploy: (CompleteAddress | AztecAddress)[],
   waitUntilProven = false,
+  pxeOrNode?: PXE | AztecNode,
 ) {
   const accountAddressesToDeploy = accountsToDeploy.map(a => ('address' in a ? a.address : a));
   const instances = (
@@ -625,5 +632,12 @@ export async function publicDeployAccounts(
 
   const batch = new BatchCall(sender, calls);
 
-  await batch.send().wait({ proven: waitUntilProven });
+  const txReceipt = await batch.send().wait();
+  if (waitUntilProven) {
+    if (!pxeOrNode) {
+      throw new Error('Need to provide a PXE or AztecNode to wait for proven.');
+    } else {
+      await waitForProven(pxeOrNode, txReceipt);
+    }
+  }
 }

package/src/fixtures/utils.ts

@@ -27,7 +27,6 @@ import {
 } from '@aztec/aztec.js';
 import { deployInstance, registerContractClass } from '@aztec/aztec.js/deployment';
 import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec.js/testing';
-import type { BBNativePrivateKernelProver } from '@aztec/bb-prover';
 import { createBlobSinkClient } from '@aztec/blob-sink/client';
 import { type BlobSinkServer, createBlobSinkServer } from '@aztec/blob-sink/server';
 import { FEE_JUICE_INITIAL_MINT, GENESIS_ARCHIVE_ROOT, GENESIS_BLOCK_HASH } from '@aztec/constants';
@@ -52,11 +51,19 @@ import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { ProtocolContractAddress, protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import { type ProverNode, type ProverNodeConfig, createProverNode } from '@aztec/prover-node';
-import { type PXEService, type PXEServiceConfig, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import {
+  type PXEService,
+  type PXEServiceConfig,
+  createPXEServiceWithSimulationProvider,
+  getPXEServiceConfig,
+} from '@aztec/pxe/server';
 import type { SequencerClient } from '@aztec/sequencer-client';
 import type { TestSequencerClient } from '@aztec/sequencer-client/test';
+import { WASMSimulator } from '@aztec/simulator/client';
+import { SimulationProviderRecorderWrapper } from '@aztec/simulator/testing';
 import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { Gas } from '@aztec/stdlib/gas';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import {
   type TelemetryClient,
@@ -134,18 +141,15 @@ export const setupL1Contracts = async (
  * Sets up Private eXecution Environment (PXE).
  * @param aztecNode - An instance of Aztec Node.
  * @param opts - Partial configuration for the PXE service.
- * @param firstPrivKey - The private key of the first account to be created.
  * @param logger - The logger to be used.
  * @param useLogSuffix - Whether to add a randomly generated suffix to the PXE debug logs.
- * @param proofCreator - An optional proof creator to use
- * @returns Private eXecution Environment (PXE), accounts, wallets and logger.
+ * @returns Private eXecution Environment (PXE), logger and teardown function.
  */
 export async function setupPXEService(
   aztecNode: AztecNode,
   opts: Partial<PXEServiceConfig> = {},
   logger = getLogger(),
   useLogSuffix = false,
-  proofCreator?: BBNativePrivateKernelProver,
 ): Promise<{
   /**
    * The PXE instance.
@@ -168,7 +172,14 @@ export async function setupPXEService(
     pxeServiceConfig.dataDirectory = path.join(tmpdir(), randomBytes(8).toString('hex'));
   }
 
-  const pxe = await createPXEService(aztecNode, pxeServiceConfig, useLogSuffix, proofCreator);
+  const simulationProvider = new WASMSimulator();
+  const simulationProviderWithRecorder = new SimulationProviderRecorderWrapper(simulationProvider);
+  const pxe = await createPXEServiceWithSimulationProvider(
+    aztecNode,
+    simulationProviderWithRecorder,
+    pxeServiceConfig,
+    useLogSuffix,
+  );
 
   const teardown = async () => {
     if (!configuredDataDirectory) {
@@ -201,7 +212,7 @@ async function setupWithRemoteEnvironment(
   config: AztecNodeConfig,
   logger: Logger,
   numberOfAccounts: number,
-) {
+): Promise<EndToEndContext> {
   // we are setting up against a remote environment, l1 contracts are already deployed
   const aztecNodeUrl = getAztecUrl();
   logger.verbose(`Creating Aztec Node client to remote host ${aztecNodeUrl}`);
@@ -236,11 +247,11 @@ async function setupWithRemoteEnvironment(
 
   return {
     aztecNode,
+    aztecNodeAdmin: undefined,
     sequencer: undefined,
     proverNode: undefined,
     pxe: pxeClient,
     deployL1ContractsValues,
-    accounts: await pxeClient!.getRegisteredAccounts(),
     config,
     initialFundedAccounts,
     wallet: wallets[0],
@@ -293,6 +304,8 @@ export type SetupOptions = {
 export type EndToEndContext = {
   /** The Aztec Node service or client a connected to it. */
   aztecNode: AztecNode;
+  /** Client to the Aztec Node admin interface (undefined if connected to remote environment) */
+  aztecNodeAdmin?: AztecNodeAdmin;
   /** The prover node service (only set if startProverNode is true) */
   proverNode: ProverNode | undefined;
   /** A client to the sequencer service (undefined if connected to remote environment) */
@@ -478,6 +491,8 @@ export async function setup(
       l1RpcUrls: config.l1RpcUrls,
       rollupAddress: config.l1Contracts.rollupAddress,
       port: blobSinkPort,
+      dataDirectory: config.dataDirectory,
+      dataStoreMapSizeKB: config.dataStoreMapSizeKB,
     },
     telemetry,
   );
@@ -583,6 +598,7 @@ export async function setup(
 
   return {
     aztecNode,
+    aztecNodeAdmin: aztecNode,
     blobSink,
     cheatCodes,
     config,

package/src/guides/up_quick_start.sh

@@ -45,9 +45,8 @@ fi
 TRANSFER_AMOUNT=42
 
 aztec-wallet create-authwit transfer_in_private accounts:test0 -ca last --args accounts:alice accounts:bob $TRANSFER_AMOUNT 1 -f alice
-aztec-wallet add-authwit authwits:last alice -f test0
 
-aztec-wallet send transfer_in_private -ca last --args accounts:alice accounts:bob $TRANSFER_AMOUNT 1 -f test0
+aztec-wallet send transfer_in_private -ca last --args accounts:alice accounts:bob $TRANSFER_AMOUNT 1 -aw authwits:last -f test0
 # docs:end:transfer
 
 # Test end result

package/src/shared/capture_private_execution_steps.ts

@@ -0,0 +1,43 @@
+/**
+ * This module exposes the ability to capture the private exection steps that go into our "Client IVC" prover.
+ * These are used for debugging and benchmarking barretenberg (the prover component).
+ */
+import type { ContractFunctionInteraction } from '@aztec/aztec.js/contracts';
+import { createLogger } from '@aztec/foundation/log';
+import { serializeWitness } from '@aztec/noir-noirc_abi';
+import type { PrivateExecutionStep } from '@aztec/stdlib/kernel';
+
+import { encode } from '@msgpack/msgpack';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+const logger = createLogger('e2e:capture-private-execution-steps');
+
+// TODO(#7371): This is duplicated.
+// Longer term we won't use this hacked together msgpack format
+// Leaving duplicated as this eventually bb will provide a serialization
+// helper for passing to a generic msgpack RPC endpoint.
+async function _createClientIvcProofFiles(directory: string, executionSteps: PrivateExecutionStep[]) {
+  const acirPath = path.join(directory, 'acir.msgpack');
+  const witnessPath = path.join(directory, 'witnesses.msgpack');
+  await fs.writeFile(acirPath, encode(executionSteps.map(map => map.bytecode)));
+  await fs.writeFile(witnessPath, encode(executionSteps.map(map => serializeWitness(map.witness))));
+  return {
+    acirPath,
+    witnessPath,
+  };
+}
+
+export async function capturePrivateExecutionStepsIfEnvSet(label: string, interaction: ContractFunctionInteraction) {
+  // Not included in env_var.ts as internal to e2e tests.
+  const ivcFolder = process.env.CAPTURE_IVC_FOLDER;
+  if (ivcFolder) {
+    logger.info(`Capturing client ivc execution steps for ${label}`);
+    const result = await interaction.profile({ profileMode: 'execution-steps' });
+    const resultsDirectory = path.join(ivcFolder, label);
+    logger.info(`Writing private execution steps to ${resultsDirectory}`);
+    await fs.mkdir(resultsDirectory, { recursive: true });
+    await _createClientIvcProofFiles(resultsDirectory, result.executionSteps);
+    logger.info(`Wrote private execution steps to ${resultsDirectory}`);
+  }
+}

package/src/shared/cross_chain_test_harness.ts

@@ -1,6 +1,7 @@
 // docs:start:cross_chain_test_harness
 import {
   type AccountWallet,
+  AuthWitness,
   type AztecAddress,
   type AztecNode,
   EthAddress,
@@ -204,6 +205,7 @@ export class CrossChainTestHarness {
     this.l1TokenPortalManager = new L1TokenPortalManager(
       this.tokenPortalAddress,
       this.underlyingERC20Address,
+      this.l1ContractAddresses.feeAssetHandlerAddress,
       this.l1ContractAddresses.outboxAddress,
       this.publicClient,
       this.walletClient,
@@ -214,7 +216,12 @@ export class CrossChainTestHarness {
   }
 
   async mintTokensOnL1(amount: bigint) {
-    await this.l1TokenManager.mint(amount, this.ethAccount.toString());
+    const contract = getContract({
+      abi: TestERC20Abi,
+      address: this.l1TokenManager.tokenAddress.toString(),
+      client: this.walletClient,
+    });
+    await contract.write.mint([this.ethAccount.toString(), amount]);
     expect(await this.l1TokenManager.getL1TokenBalance(this.ethAccount.toString())).toEqual(amount);
   }
 
@@ -266,10 +273,14 @@ export class CrossChainTestHarness {
       .wait();
   }
 
-  async withdrawPrivateFromAztecToL1(withdrawAmount: bigint, nonce: Fr = Fr.ZERO): Promise<FieldsOf<TxReceipt>> {
+  async withdrawPrivateFromAztecToL1(
+    withdrawAmount: bigint,
+    nonce: Fr = Fr.ZERO,
+    authWitness: AuthWitness,
+  ): Promise<FieldsOf<TxReceipt>> {
     const withdrawReceipt = await this.l2Bridge.methods
       .exit_to_l1_private(this.l2Token.address, this.ethAccount, withdrawAmount, EthAddress.ZERO, nonce)
-      .send()
+      .send({ authWitnesses: [authWitness] })
       .wait();
 
     return withdrawReceipt;

package/src/shared/gas_portal_test_harness.ts

@@ -12,8 +12,12 @@ import {
   retryUntil,
 } from '@aztec/aztec.js';
 import type { ViemPublicClient, ViemWalletClient } from '@aztec/ethereum';
+import { TestERC20Abi } from '@aztec/l1-artifacts/TestERC20Abi';
 import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+
+import { getContract } from 'viem';
 
 export interface IGasBridgingTestHarness {
   getL1FeeJuiceBalance(address: EthAddress): Promise<bigint>;
@@ -25,6 +29,7 @@ export interface IGasBridgingTestHarness {
 
 export interface FeeJuicePortalTestingHarnessFactoryConfig {
   aztecNode: AztecNode;
+  aztecNodeAdmin?: AztecNodeAdmin;
   pxeService: PXE;
   publicClient: ViemPublicClient;
   walletClient: ViemWalletClient;
@@ -37,7 +42,7 @@ export class FeeJuicePortalTestingHarnessFactory {
   private constructor(private config: FeeJuicePortalTestingHarnessFactoryConfig) {}
 
   private async createReal() {
-    const { aztecNode, pxeService, publicClient, walletClient, wallet, logger } = this.config;
+    const { aztecNode, aztecNodeAdmin, pxeService, publicClient, walletClient, wallet, logger } = this.config;
 
     const ethAccount = EthAddress.fromString((await walletClient.getAddresses())[0]);
     const l1ContractAddresses = (await pxeService.getNodeInfo()).l1ContractAddresses;
@@ -53,12 +58,14 @@ export class FeeJuicePortalTestingHarnessFactory {
 
     return new GasBridgingTestHarness(
       aztecNode,
+      aztecNodeAdmin,
       pxeService,
       logger,
       gasL2,
       ethAccount,
       feeJuicePortalAddress,
       feeJuiceAddress,
+      l1ContractAddresses.feeAssetHandlerAddress!,
       publicClient,
       walletClient,
     );
@@ -81,6 +88,8 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
   constructor(
     /** Aztec node */
     public aztecNode: AztecNode,
+    /** Aztec node admin interface */
+    public aztecNodeAdmin: AztecNodeAdmin | undefined,
     /** Private eXecution Environment (PXE). */
     public pxeService: PXE,
     /** Logger. */
@@ -96,6 +105,8 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
     public feeJuicePortalAddress: EthAddress,
     /** Underlying token for portal tests. */
     public l1FeeJuiceAddress: EthAddress,
+    /** Fee asset handler address. */
+    public feeAssetHandlerAddress: EthAddress,
     /** Viem Public client instance. */
     public publicClient: ViemPublicClient,
     /** Viem Wallet Client instance. */
@@ -104,6 +115,7 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
     this.feeJuicePortalManager = new L1FeeJuicePortalManager(
       this.feeJuicePortalAddress,
       this.l1FeeJuiceAddress,
+      this.feeAssetHandlerAddress,
       this.publicClient,
       this.walletClient,
       this.logger,
@@ -113,17 +125,25 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
   }
 
   async mintTokensOnL1(amount: bigint, to: EthAddress = this.ethAccount) {
-    const balanceBefore = await this.l1TokenManager.getL1TokenBalance(to.toString());
-    await this.l1TokenManager.mint(amount, to.toString());
-    expect(await this.l1TokenManager.getL1TokenBalance(to.toString())).toEqual(balanceBefore + amount);
+    // const balanceBefore = await this.l1TokenManager.getL1TokenBalance(to.toString());
+    await this.l1TokenManager.mint(to.toString());
+    const feeAssetL1 = getContract({
+      address: this.l1FeeJuiceAddress.toString(),
+      abi: TestERC20Abi,
+      client: this.walletClient,
+    });
+
+    await feeAssetL1.write.mint([to.toString(), amount]);
+
+    // expect(await this.l1TokenManager.getL1TokenBalance(to.toString())).toEqual(balanceBefore + amount);
   }
 
   async getL1FeeJuiceBalance(address: EthAddress) {
     return await this.l1TokenManager.getL1TokenBalance(address.toString());
   }
 
-  sendTokensToPortalPublic(bridgeAmount: bigint, l2Address: AztecAddress, mint = false) {
-    return this.feeJuicePortalManager.bridgeTokensPublic(l2Address, bridgeAmount, mint);
+  sendTokensToPortalPublic(bridgeAmount: bigint, l2Address: AztecAddress) {
+    return this.feeJuicePortalManager.bridgeTokensPublic(l2Address, bridgeAmount, false);
   }
 
   async consumeMessageOnAztecAndClaimPrivately(owner: AztecAddress, claim: L2AmountClaim) {
@@ -142,7 +162,8 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
   }
 
   async prepareTokensOnL1(bridgeAmount: bigint, owner: AztecAddress) {
-    const claim = await this.sendTokensToPortalPublic(bridgeAmount, owner, true);
+    await this.mintTokensOnL1(bridgeAmount);
+    const claim = await this.sendTokensToPortalPublic(bridgeAmount, owner);
 
     const isSynced = async () => await this.aztecNode.isL1ToL2MessageSynced(Fr.fromHexString(claim.messageHash));
     await retryUntil(isSynced, `message ${claim.messageHash} sync`, 24, 1);
@@ -160,12 +181,11 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
 
     // Consume L1 -> L2 message and claim tokens privately on L2
     await this.consumeMessageOnAztecAndClaimPrivately(owner, claim);
-    await this.expectPublicBalanceOnL2(owner, bridgeAmount);
   }
 
   private async advanceL2Block() {
     const initialBlockNumber = await this.aztecNode.getBlockNumber();
-    await this.aztecNode.flushTxs();
+    await this.aztecNodeAdmin?.flushTxs();
     await retryUntil(async () => (await this.aztecNode.getBlockNumber()) >= initialBlockNumber + 1);
   }
 }