@aztec/end-to-end 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.77.0-testnet-ignition.21

package/src/shared/gas_portal_test_harness.ts

@@ -2,18 +2,19 @@ import {
   type AztecAddress,
   type AztecNode,
   EthAddress,
+  Fr,
   L1FeeJuicePortalManager,
   type L1TokenManager,
   type L2AmountClaim,
   type Logger,
   type PXE,
   type Wallet,
+  retryUntil,
 } from '@aztec/aztec.js';
+import type { ViemPublicClient, ViemWalletClient } from '@aztec/ethereum';
 import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 
-import { type Account, type Chain, type HttpTransport, type PublicClient, type WalletClient } from 'viem';
-
 export interface IGasBridgingTestHarness {
   getL1FeeJuiceBalance(address: EthAddress): Promise<bigint>;
   prepareTokensOnL1(bridgeAmount: bigint, owner: AztecAddress): Promise<L2AmountClaim>;
@@ -25,8 +26,8 @@ export interface IGasBridgingTestHarness {
 export interface FeeJuicePortalTestingHarnessFactoryConfig {
   aztecNode: AztecNode;
   pxeService: PXE;
-  publicClient: PublicClient<HttpTransport, Chain>;
-  walletClient: WalletClient<HttpTransport, Chain, Account>;
+  publicClient: ViemPublicClient;
+  walletClient: ViemWalletClient;
   wallet: Wallet;
   logger: Logger;
   mockL1?: boolean;
@@ -74,8 +75,8 @@ export class FeeJuicePortalTestingHarnessFactory {
  * shared between cross chain tests.
  */
 export class GasBridgingTestHarness implements IGasBridgingTestHarness {
-  private readonly l1TokenManager: L1TokenManager;
-  private readonly feeJuicePortalManager: L1FeeJuicePortalManager;
+  public readonly l1TokenManager: L1TokenManager;
+  public readonly feeJuicePortalManager: L1FeeJuicePortalManager;
 
   constructor(
     /** Aztec node */
@@ -96,9 +97,9 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
     /** Underlying token for portal tests. */
     public l1FeeJuiceAddress: EthAddress,
     /** Viem Public client instance. */
-    public publicClient: PublicClient<HttpTransport, Chain>,
+    public publicClient: ViemPublicClient,
     /** Viem Wallet Client instance. */
-    public walletClient: WalletClient<HttpTransport, Chain, Account>,
+    public walletClient: ViemWalletClient,
   ) {
     this.feeJuicePortalManager = new L1FeeJuicePortalManager(
       this.feeJuicePortalAddress,
@@ -143,9 +144,12 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
   async prepareTokensOnL1(bridgeAmount: bigint, owner: AztecAddress) {
     const claim = await this.sendTokensToPortalPublic(bridgeAmount, owner, true);
 
-    // Perform an unrelated transactions on L2 to progress the rollup by 2 blocks.
-    await this.feeJuice.methods.check_balance(0).send().wait();
-    await this.feeJuice.methods.check_balance(0).send().wait();
+    const isSynced = async () => await this.aztecNode.isL1ToL2MessageSynced(Fr.fromHexString(claim.messageHash));
+    await retryUntil(isSynced, `message ${claim.messageHash} sync`, 24, 1);
+
+    // Progress by 2 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
+    await this.advanceL2Block();
+    await this.advanceL2Block();
 
     return claim;
   }
@@ -158,5 +162,11 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
     await this.consumeMessageOnAztecAndClaimPrivately(owner, claim);
     await this.expectPublicBalanceOnL2(owner, bridgeAmount);
   }
+
+  private async advanceL2Block() {
+    const initialBlockNumber = await this.aztecNode.getBlockNumber();
+    await this.aztecNode.flushTxs();
+    await retryUntil(async () => (await this.aztecNode.getBlockNumber()) >= initialBlockNumber + 1);
+  }
 }
 // docs:end:cross_chain_test_harness

package/src/shared/index.ts

@@ -1,2 +1 @@
-export { browserTestSuite } from './browser.js';
 export { uniswapL1L2TestSuite, type UniswapSetupContext } from './uniswap_l1_l2.js';

package/src/shared/submit-transactions.ts

@@ -1,24 +1,20 @@
 import { getSchnorrAccount } from '@aztec/accounts/schnorr';
-import { type Logger, TxStatus } from '@aztec/aztec.js';
-import { Fr, GrumpkinScalar, type PXEService } from '@aztec/pxe';
+import { Fr, GrumpkinScalar, type Logger, type SentTx, TxStatus, type Wallet } from '@aztec/aztec.js';
+import { times } from '@aztec/foundation/collection';
+import type { PXEService } from '@aztec/pxe';
 
 // submits a set of transactions to the provided Private eXecution Environment (PXE)
-export const submitTxsTo = async (pxe: PXEService, numTxs: number, logger: Logger) => {
-  const provenTxs = [];
-  for (let i = 0; i < numTxs; i++) {
-    const accountManager = await getSchnorrAccount(pxe, Fr.random(), GrumpkinScalar.random(), Fr.random());
-    const deployMethod = await accountManager.getDeployMethod();
-    const tx = await deployMethod.prove({
-      contractAddressSalt: new Fr(accountManager.salt),
-      skipClassRegistration: true,
-      skipPublicDeployment: true,
-      universalDeploy: true,
-    });
-    provenTxs.push(tx);
-  }
-  const sentTxs = await Promise.all(
-    provenTxs.map(async provenTx => {
-      const tx = provenTx.send();
+export const submitTxsTo = async (
+  pxe: PXEService,
+  numTxs: number,
+  wallet: Wallet,
+  logger: Logger,
+): Promise<SentTx[]> => {
+  const txs: SentTx[] = [];
+  await Promise.all(
+    times(numTxs, async () => {
+      const accountManager = await getSchnorrAccount(pxe, Fr.random(), GrumpkinScalar.random(), Fr.random());
+      const tx = accountManager.deploy({ deployWallet: wallet });
       const txHash = await tx.getTxHash();
 
       logger.info(`Tx sent with hash ${txHash}`);
@@ -30,8 +26,8 @@ export const submitTxsTo = async (pxe: PXEService, numTxs: number, logger: Logge
         }),
       );
       logger.info(`Receipt received for ${txHash}`);
-      return tx;
+      txs.push(tx);
     }),
   );
-  return sentTxs;
+  return txs;
 };

package/src/shared/uniswap_l1_l2.ts

@@ -2,6 +2,7 @@ import {
   type AccountWallet,
   AztecAddress,
   type AztecNode,
+  type CheatCodes,
   EthAddress,
   Fr,
   type Logger,
@@ -9,24 +10,19 @@ import {
   computeAuthWitMessageHash,
   generateClaimSecret,
 } from '@aztec/aztec.js';
-import { type DeployL1Contracts, deployL1Contract, extractEvent } from '@aztec/ethereum';
+import {
+  type DeployL1ContractsReturnType,
+  type ViemPublicClient,
+  type ViemWalletClient,
+  deployL1Contract,
+  extractEvent,
+} from '@aztec/ethereum';
 import { sha256ToField } from '@aztec/foundation/crypto';
 import { InboxAbi, RollupAbi, UniswapPortalAbi, UniswapPortalBytecode } from '@aztec/l1-artifacts';
 import { UniswapContract } from '@aztec/noir-contracts.js/Uniswap';
 
 import { jest } from '@jest/globals';
-import {
-  type Account,
-  type Chain,
-  type GetContractReturnType,
-  type HttpTransport,
-  type PublicClient,
-  type WalletClient,
-  getContract,
-  parseEther,
-  toFunctionSelector,
-} from 'viem';
-import type * as chains from 'viem/chains';
+import { type GetContractReturnType, getContract, parseEther, toFunctionSelector } from 'viem';
 
 import { ensureAccountsPubliclyDeployed } from '../fixtures/utils.js';
 import { CrossChainTestHarness } from './cross_chain_test_harness.js';
@@ -50,15 +46,17 @@ export type UniswapSetupContext = {
   /** Logger instance named as the current test. */
   logger: Logger;
   /** Viem Public client instance. */
-  publicClient: PublicClient<HttpTransport, Chain>;
+  publicClient: ViemPublicClient;
   /** Viem Wallet Client instance. */
-  walletClient: WalletClient<HttpTransport, Chain, Account>;
+  walletClient: ViemWalletClient;
   /** The owner wallet. */
   ownerWallet: AccountWallet;
   /** The sponsor wallet. */
   sponsorWallet: AccountWallet;
   /**  */
-  deployL1ContractsValues: DeployL1Contracts;
+  deployL1ContractsValues: DeployL1ContractsReturnType;
+  /** Cheat codes instance. */
+  cheatCodes: CheatCodes;
 };
 // docs:end:uniswap_l1_l2_test_setup_const
 
@@ -78,8 +76,8 @@ export const uniswapL1L2TestSuite = (
     let pxe: PXE;
     let logger: Logger;
 
-    let walletClient: WalletClient<HttpTransport, Chain, Account>;
-    let publicClient: PublicClient<HttpTransport, Chain>;
+    let walletClient: ViemWalletClient;
+    let publicClient: ViemPublicClient;
 
     let ownerWallet: AccountWallet;
     let ownerAddress: AztecAddress;
@@ -91,9 +89,9 @@ export const uniswapL1L2TestSuite = (
     let daiCrossChainHarness: CrossChainTestHarness;
     let wethCrossChainHarness: CrossChainTestHarness;
 
-    let deployL1ContractsValues: DeployL1Contracts;
-    let rollup: GetContractReturnType<typeof RollupAbi, WalletClient<HttpTransport, chains.Chain, Account>>;
-    let uniswapPortal: GetContractReturnType<typeof UniswapPortalAbi, WalletClient<HttpTransport, Chain, Account>>;
+    let deployL1ContractsValues: DeployL1ContractsReturnType;
+    let rollup: GetContractReturnType<typeof RollupAbi, ViemWalletClient>;
+    let uniswapPortal: GetContractReturnType<typeof UniswapPortalAbi, ViemWalletClient>;
     let uniswapPortalAddress: EthAddress;
     let uniswapL2Contract: UniswapContract;
 
@@ -101,9 +99,20 @@ export const uniswapL1L2TestSuite = (
     const uniswapFeeTier = 3000n;
     const minimumOutputAmount = 0n;
 
+    let cheatCodes: CheatCodes;
+
     beforeAll(async () => {
-      ({ aztecNode, pxe, logger, publicClient, walletClient, ownerWallet, sponsorWallet, deployL1ContractsValues } =
-        await setup());
+      ({
+        aztecNode,
+        pxe,
+        logger,
+        publicClient,
+        walletClient,
+        ownerWallet,
+        sponsorWallet,
+        deployL1ContractsValues,
+        cheatCodes,
+      } = await setup());
 
       if (Number(await publicClient.getBlockNumber()) < expectedForkBlockNumber) {
         throw new Error('This test must be run on a fork of mainnet with the expected fork block');
@@ -279,7 +288,7 @@ export const uniswapL1L2TestSuite = (
       await wethCrossChainHarness.expectPublicBalanceOnL2(uniswapL2Contract.address, 0n);
 
       // Since the outbox is only consumable when the block is proven, we need to set the block to be proven
-      await rollup.write.setAssumeProvenThroughBlockNumber([await rollup.read.getPendingBlockNumber()]);
+      await cheatCodes.rollup.markAsProven(await rollup.read.getPendingBlockNumber());
 
       // 5. Consume L2 to L1 message by calling uniswapPortal.swap_private()
       logger.info('Execute withdraw and swap on the uniswapPortal!');
@@ -890,7 +899,7 @@ export const uniswapL1L2TestSuite = (
       await wethCrossChainHarness.expectPrivateBalanceOnL2(ownerAddress, wethL2BalanceBeforeSwap - wethAmountToBridge);
 
       // Since the outbox is only consumable when the block is proven, we need to set the block to be proven
-      await rollup.write.setAssumeProvenThroughBlockNumber([await rollup.read.getPendingBlockNumber()]);
+      await cheatCodes.rollup.markAsProven(await rollup.read.getPendingBlockNumber());
 
       // On L1 call swap_public!
       logger.info('call swap_public on L1');
@@ -1020,7 +1029,7 @@ export const uniswapL1L2TestSuite = (
       await wethCrossChainHarness.expectPublicBalanceOnL2(ownerAddress, 0n);
 
       // Since the outbox is only consumable when the block is proven, we need to set the block to be proven
-      await rollup.write.setAssumeProvenThroughBlockNumber([await rollup.read.getPendingBlockNumber()]);
+      await cheatCodes.rollup.markAsProven(await rollup.read.getPendingBlockNumber());
 
       // Call swap_private on L1
       logger.info('Execute withdraw and swap on the uniswapPortal!');

package/src/simulators/lending_simulator.ts

@@ -2,13 +2,13 @@
 import { AztecAddress, type CheatCodes, Fr } from '@aztec/aztec.js';
 import { pedersenHash } from '@aztec/foundation/crypto';
 import type { TestDateProvider } from '@aztec/foundation/timer';
-import { type RollupAbi } from '@aztec/l1-artifacts';
-import { type LendingContract } from '@aztec/noir-contracts.js/Lending';
+import type { RollupAbi } from '@aztec/l1-artifacts';
+import type { LendingContract } from '@aztec/noir-contracts.js/Lending';
 
-import { type Account, type GetContractReturnType, type HttpTransport, type WalletClient } from 'viem';
+import type { Account, GetContractReturnType, HttpTransport, WalletClient } from 'viem';
 import type * as chains from 'viem/chains';
 
-import { type TokenSimulator } from './token_simulator.js';
+import type { TokenSimulator } from './token_simulator.js';
 
 /**
  * Contains utilities to compute the "key" for private holdings in the public state.
@@ -115,8 +115,7 @@ export class LendingSimulator {
     if (dateProvider) {
       dateProvider.setTime(this.time * 1000);
     }
-
-    await this.rollup.write.setAssumeProvenThroughBlockNumber([(await this.rollup.read.getPendingBlockNumber()) + 1n]);
+    await this.cc.rollup.markAsProven(await this.rollup.read.getPendingBlockNumber());
     this.accumulator = muldivDown(this.accumulator, computeMultiplier(this.rate, BigInt(timeDiff)), BASE);
   }
 

package/src/simulators/token_simulator.ts

@@ -1,6 +1,6 @@
 /* eslint-disable jsdoc/require-jsdoc */
 import { type AztecAddress, BatchCall, type Logger, type Wallet } from '@aztec/aztec.js';
-import { type TokenContract } from '@aztec/noir-contracts.js/Token';
+import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 
 import chunk from 'lodash.chunk';
 

package/src/spartan/setup_test_wallets.ts

@@ -1,10 +1,21 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
-import { type AccountWalletWithSecretKey, type AztecAddress, type PXE, createCompatibleClient } from '@aztec/aztec.js';
-import { type Logger } from '@aztec/foundation/log';
+import { getSchnorrAccount, getSchnorrWalletWithSecretKey } from '@aztec/accounts/schnorr';
+import { generateSchnorrAccounts, getDeployedTestAccountsWallets } from '@aztec/accounts/testing';
+import {
+  type AccountWalletWithSecretKey,
+  type AztecAddress,
+  type AztecNode,
+  FeeJuicePaymentMethodWithClaim,
+  Fr,
+  L1FeeJuicePortalManager,
+  type PXE,
+  createAztecNodeClient,
+  createCompatibleClient,
+  retryUntil,
+} from '@aztec/aztec.js';
+import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import type { Logger } from '@aztec/foundation/log';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
-import { addAccounts } from '../fixtures/snapshot_manager.js';
-
 export interface TestWallets {
   pxe: PXE;
   wallets: AccountWalletWithSecretKey[];
@@ -14,69 +25,132 @@ export interface TestWallets {
   tokenAddress: AztecAddress;
 }
 
+const TOKEN_NAME = 'USDC';
+const TOKEN_SYMBOL = 'USD';
+const TOKEN_DECIMALS = 18n;
+
 export async function setupTestWalletsWithTokens(
   pxeUrl: string,
   mintAmount: bigint,
   logger: Logger,
 ): Promise<TestWallets> {
-  const TOKEN_NAME = 'USDC';
-  const TOKEN_SYMBOL = 'USD';
-  const TOKEN_DECIMALS = 18n;
-
   const WALLET_COUNT = 1; // TODO fix this to allow for 16 wallets again
 
-  let recipientWallet: AccountWalletWithSecretKey;
-
   const pxe = await createCompatibleClient(pxeUrl, logger);
 
-  {
-    const { accountKeys } = await addAccounts(1, logger, false)({ pxe });
-    const accountManagers = await Promise.all(accountKeys.map(ak => getSchnorrAccount(pxe, ak[0], ak[1], 1)));
+  const [recipientWallet, ...wallets] = (await getDeployedTestAccountsWallets(pxe)).slice(0, WALLET_COUNT + 1);
 
-    const completeAddress = await accountManagers[0].getCompleteAddress();
-    const partialAddress = completeAddress.partialAddress;
-    await pxe.registerAccount(accountKeys[0][0], partialAddress);
-    recipientWallet = await accountManagers[0].getWallet();
-    logger.verbose(`Recipient Wallet address: ${recipientWallet.getAddress()} registered`);
-  }
+  const tokenAdmin = wallets[0];
+  const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, logger);
+  const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
+
+  return { pxe, wallets, tokenAdminWallet, tokenName: TOKEN_NAME, tokenAddress, recipientWallet };
+}
+
+export async function deployTestWalletWithTokens(
+  pxeUrl: string,
+  nodeUrl: string,
+  l1RpcUrl: string,
+  mnemonicOrPrivateKey: string,
+  mintAmount: bigint,
+  logger: Logger,
+  numberOfFundedWallets = 1,
+  initialFeeJuice = 10n ** 22n,
+): Promise<TestWallets> {
+  const pxe = await createCompatibleClient(pxeUrl, logger);
+  const node = createAztecNodeClient(nodeUrl);
+
+  const [recipient, ...funded] = await generateSchnorrAccounts(numberOfFundedWallets + 1);
+  const recipientWallet = await getSchnorrWalletWithSecretKey(
+    pxe,
+    recipient.secret,
+    recipient.signingKey,
+    recipient.salt,
+  );
+  const fundedAccounts = await Promise.all(funded.map(a => getSchnorrAccount(pxe, a.secret, a.signingKey, a.salt)));
+
+  const claims = await Promise.all(
+    fundedAccounts.map(a =>
+      bridgeL1FeeJuice(l1RpcUrl, mnemonicOrPrivateKey, pxe, a.getAddress(), initialFeeJuice, logger),
+    ),
+  );
 
-  const { accountKeys } = await addAccounts(WALLET_COUNT, logger, false)({ pxe });
-  const accountManagers = await Promise.all(accountKeys.map(ak => getSchnorrAccount(pxe, ak[0], ak[1], 1)));
+  // Progress by 2 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
+  await advanceL2Block(node);
+  await advanceL2Block(node);
 
   const wallets = await Promise.all(
-    accountManagers.map(async (a, i) => {
-      const completeAddress = await a.getCompleteAddress();
-      const partialAddress = completeAddress.partialAddress;
-      await pxe.registerAccount(accountKeys[i][0], partialAddress);
+    fundedAccounts.map(async (a, i) => {
       const wallet = await a.getWallet();
-      logger.verbose(`Wallet ${i} address: ${wallet.getAddress()} registered`);
+      const paymentMethod = new FeeJuicePaymentMethodWithClaim(wallet, claims[i]);
+      await a.deploy({ fee: { paymentMethod } }).wait();
+      logger.info(`Account deployed at ${a.getAddress()}`);
       return wallet;
     }),
   );
 
+  const tokenAdmin = wallets[0];
+  const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, logger);
+  const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
+
+  return { pxe, wallets, tokenAdminWallet, tokenName: TOKEN_NAME, tokenAddress, recipientWallet };
+}
+
+async function bridgeL1FeeJuice(
+  l1RpcUrl: string,
+  mnemonicOrPrivateKey: string,
+  pxe: PXE,
+  recipient: AztecAddress,
+  amount: bigint,
+  log: Logger,
+) {
+  const { l1ChainId } = await pxe.getNodeInfo();
+  const chain = createEthereumChain([l1RpcUrl], l1ChainId);
+  const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
+
+  const portal = await L1FeeJuicePortalManager.new(pxe, publicClient, walletClient, log);
+  const claim = await portal.bridgeTokensPublic(recipient, amount, true /* mint */);
+
+  const isSynced = async () => await pxe.isL1ToL2MessageSynced(Fr.fromHexString(claim.messageHash));
+  await retryUntil(isSynced, `message ${claim.messageHash} sync`, 24, 0.5);
+
+  log.info(`Created a claim for ${amount} L1 fee juice to ${recipient}.`, claim);
+  return claim;
+}
+
+async function advanceL2Block(node: AztecNode) {
+  const initialBlockNumber = await node.getBlockNumber();
+  await node!.flushTxs();
+  await retryUntil(async () => (await node.getBlockNumber()) >= initialBlockNumber + 1);
+}
+
+async function deployTokenAndMint(
+  wallets: AccountWalletWithSecretKey[],
+  admin: AztecAddress,
+  mintAmount: bigint,
+  logger: Logger,
+) {
   logger.verbose(`Deploying TokenContract...`);
-  const tokenContract = await TokenContract.deploy(
-    wallets[0],
-    wallets[0].getAddress(),
-    TOKEN_NAME,
-    TOKEN_SYMBOL,
-    TOKEN_DECIMALS,
-  )
+  const tokenContract = await TokenContract.deploy(wallets[0], admin, TOKEN_NAME, TOKEN_SYMBOL, TOKEN_DECIMALS)
     .send()
     .deployed({ timeout: 600 });
 
   const tokenAddress = tokenContract.address;
-  const tokenAdminWallet = await TokenContract.at(tokenAddress, wallets[0]);
 
   logger.verbose(`Minting ${mintAmount} public assets to the ${wallets.length} wallets...`);
 
   await Promise.all(
-    wallets.map(w => tokenAdminWallet.methods.mint_to_public(w.getAddress(), mintAmount).send().wait({ timeout: 600 })),
+    wallets.map(async w =>
+      (await TokenContract.at(tokenAddress, w)).methods
+        .mint_to_public(w.getAddress(), mintAmount)
+        .send()
+        .wait({ timeout: 600 }),
+    ),
   );
 
   logger.verbose(`Minting complete.`);
 
-  return { pxe, wallets, tokenAdminWallet, tokenName: TOKEN_NAME, tokenAddress, recipientWallet };
+  return tokenAddress;
 }
 
 export async function performTransfers({