@aztec/end-to-end 3.0.0-canary.a9708bd → 3.0.0-devnet.20251212

package/src/spartan/setup_test_wallets.ts

@@ -1,202 +1,233 @@
-import { getSchnorrAccount, getSchnorrWalletWithSecretKey } from '@aztec/accounts/schnorr';
-import { generateSchnorrAccounts, getDeployedTestAccountsWallets } from '@aztec/accounts/testing';
-import {
-  type AccountWalletWithSecretKey,
-  type AztecAddress,
-  type AztecNode,
-  FeeJuicePaymentMethodWithClaim,
-  type FeePaymentMethod,
-  Fr,
-  L1FeeJuicePortalManager,
-  type PXE,
-  SponsoredFeePaymentMethod,
-  createAztecNodeClient,
-  createCompatibleClient,
-  retryUntil,
-} from '@aztec/aztec.js';
-import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
+import { generateSchnorrAccounts } from '@aztec/accounts/testing';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
+import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
+import { type FeePaymentMethod, SponsoredFeePaymentMethod } from '@aztec/aztec.js/fee';
+import { Fr } from '@aztec/aztec.js/fields';
+import { type AztecNode, createAztecNodeClient } from '@aztec/aztec.js/node';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
 import type { Logger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
-import { createPXEService } from '@aztec/pxe/server';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import { TestWallet, proveInteraction, registerInitialLocalNetworkAccountsInWallet } from '@aztec/test-wallet/server';
 
 import { getACVMConfig } from '../fixtures/get_acvm_config.js';
 import { getBBConfig } from '../fixtures/get_bb_config.js';
 import { getSponsoredFPCAddress, registerSponsoredFPC } from '../fixtures/utils.js';
 
-export interface TestWallets {
-  pxe: PXE;
-  wallets: AccountWalletWithSecretKey[];
-  tokenAdminWallet: TokenContract;
+export interface TestAccounts {
+  aztecNode: AztecNode;
+  wallet: TestWallet;
+  accounts: AztecAddress[];
+  tokenContract: TokenContract;
   tokenAdminAddress: AztecAddress;
   tokenName: string;
-  recipientWallet: AccountWalletWithSecretKey;
   recipientAddress: AztecAddress;
   tokenAddress: AztecAddress;
 }
 
+export type TestAccountsWithoutTokens = Omit<
+  TestAccounts,
+  'tokenAddress' | 'tokenContract' | 'tokenName' | 'tokenAdminAddress'
+>;
+
 const TOKEN_NAME = 'USDC';
 const TOKEN_SYMBOL = 'USD';
 const TOKEN_DECIMALS = 18n;
 
-export async function setupTestWalletsWithTokens(
-  pxeUrl: string,
+export async function setupTestAccountsWithTokens(
+  nodeUrl: string,
   mintAmount: bigint,
   logger: Logger,
-): Promise<TestWallets> {
-  const WALLET_COUNT = 1; // TODO fix this to allow for 16 wallets again
+): Promise<TestAccounts> {
+  const ACCOUNT_COUNT = 1; // TODO fix this to allow for 16 wallets again
 
-  const pxe = await createCompatibleClient(pxeUrl, logger);
+  const aztecNode = createAztecNodeClient(nodeUrl);
+  const wallet = await TestWallet.create(aztecNode);
 
-  const [recipientWallet, ...wallets] = (await getDeployedTestAccountsWallets(pxe)).slice(0, WALLET_COUNT + 1);
+  const [recipientAccount, ...accounts] = (await registerInitialLocalNetworkAccountsInWallet(wallet)).slice(
+    0,
+    ACCOUNT_COUNT + 1,
+  );
 
-  const tokenAdmin = wallets[0];
-  const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, undefined, logger);
-  const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
+  const tokenAdmin = accounts[0];
+  const tokenAddress = await deployTokenAndMint(wallet, accounts, tokenAdmin, mintAmount, undefined, logger);
+  const tokenContract = TokenContract.at(tokenAddress, wallet);
 
   return {
-    pxe,
-    wallets,
-    tokenAdminWallet,
-    tokenAdminAddress: tokenAdmin.getAddress(),
+    aztecNode,
+    accounts,
+    wallet,
+    tokenAdminAddress: tokenAdmin,
     tokenName: TOKEN_NAME,
     tokenAddress,
-    recipientAddress: recipientWallet.getAddress(),
-    recipientWallet,
+    tokenContract,
+    recipientAddress: recipientAccount,
   };
 }
 
-export async function deploySponsoredTestWallets(
-  pxe: PXE,
+export async function deploySponsoredTestAccountsWithTokens(
+  wallet: TestWallet,
+  aztecNode: AztecNode,
   mintAmount: bigint,
   logger: Logger,
   numberOfFundedWallets = 1,
-): Promise<TestWallets> {
+): Promise<TestAccounts> {
   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 recipientAccount = await wallet.createSchnorrAccount(recipient.secret, recipient.salt);
+  const fundedAccounts = await Promise.all(funded.map(a => wallet.createSchnorrAccount(a.secret, a.salt)));
 
-  await registerSponsoredFPC(pxe);
+  await registerSponsoredFPC(wallet);
 
-  const wallets = await Promise.all(
+  const paymentMethod = new SponsoredFeePaymentMethod(await getSponsoredFPCAddress());
+  const recipientDeployMethod = await recipientAccount.getDeployMethod();
+  await recipientDeployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod } }).wait({ timeout: 2400 });
+  await Promise.all(
     fundedAccounts.map(async a => {
-      const wallet = await a.getWallet();
-      const paymentMethod = new SponsoredFeePaymentMethod(await getSponsoredFPCAddress());
-      await a.deploy({ fee: { paymentMethod } }).wait({ timeout: 2400 }); // increase timeout on purpose in order to account for two empty epochs
-      logger.info(`Account deployed at ${a.getAddress()}`);
-      return wallet;
+      const deployMethod = await a.getDeployMethod();
+      await deployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod } }).wait({ timeout: 2400 }); // increase timeout on purpose in order to account for two empty epochs
+      logger.info(`Account deployed at ${a.address}`);
     }),
   );
 
-  const tokenAdmin = wallets[0];
+  const tokenAdmin = fundedAccounts[0];
   const tokenAddress = await deployTokenAndMint(
-    wallets,
-    tokenAdmin.getAddress(),
+    wallet,
+    fundedAccounts.map(acc => acc.address),
+    tokenAdmin.address,
     mintAmount,
     new SponsoredFeePaymentMethod(await getSponsoredFPCAddress()),
     logger,
   );
-  const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
+  const tokenContract = TokenContract.at(tokenAddress, wallet);
 
   return {
-    pxe,
-    wallets,
-    tokenAdminAddress: tokenAdmin.getAddress(),
-    tokenAdminWallet,
+    aztecNode,
+    wallet,
+    accounts: fundedAccounts.map(acc => acc.address),
+    tokenAdminAddress: tokenAdmin.address,
     tokenName: TOKEN_NAME,
     tokenAddress,
-    recipientWallet,
-    recipientAddress: recipientWallet.getAddress(),
+    tokenContract,
+    recipientAddress: recipientAccount.address,
+  };
+}
+
+export async function deploySponsoredTestAccounts(
+  wallet: TestWallet,
+  aztecNode: AztecNode,
+  logger: Logger,
+  numberOfFundedWallets = 1,
+): Promise<TestAccountsWithoutTokens> {
+  const [recipient, ...funded] = await generateSchnorrAccounts(numberOfFundedWallets + 1);
+  const recipientAccount = await wallet.createSchnorrAccount(recipient.secret, recipient.salt);
+  const fundedAccounts = await Promise.all(funded.map(a => wallet.createSchnorrAccount(a.secret, a.salt)));
+
+  await registerSponsoredFPC(wallet);
+
+  const paymentMethod = new SponsoredFeePaymentMethod(await getSponsoredFPCAddress());
+  const recipientDeployMethod = await recipientAccount.getDeployMethod();
+  await recipientDeployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod } }).wait({ timeout: 2400 });
+  await Promise.all(
+    fundedAccounts.map(async a => {
+      const deployMethod = await a.getDeployMethod();
+      await deployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod } }).wait({ timeout: 2400 }); // increase timeout on purpose in order to account for two empty epochs
+      logger.info(`Account deployed at ${a.address}`);
+    }),
+  );
+
+  return {
+    aztecNode,
+    wallet,
+    accounts: fundedAccounts.map(acc => acc.address),
+    recipientAddress: recipientAccount.address,
   };
 }
 
-export async function deployTestWalletWithTokens(
-  pxeUrl: string,
+export async function deployTestAccountsWithTokens(
   nodeUrl: string,
   l1RpcUrls: string[],
   mnemonicOrPrivateKey: string,
   mintAmount: bigint,
   logger: Logger,
   numberOfFundedWallets = 1,
-): Promise<TestWallets> {
-  const pxe = await createCompatibleClient(pxeUrl, logger);
-  const node = createAztecNodeClient(nodeUrl);
+): Promise<TestAccounts> {
+  const aztecNode = createAztecNodeClient(nodeUrl);
+  const wallet = await TestWallet.create(aztecNode);
 
   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 recipientAccount = await wallet.createSchnorrAccount(recipient.secret, recipient.salt);
+  const fundedAccounts = await Promise.all(funded.map(a => wallet.createSchnorrAccount(a.secret, a.salt)));
 
   const claims = await Promise.all(
-    fundedAccounts.map(a => bridgeL1FeeJuice(l1RpcUrls, mnemonicOrPrivateKey, pxe, a.getAddress(), undefined, logger)),
+    fundedAccounts.map(a => bridgeL1FeeJuice(l1RpcUrls, mnemonicOrPrivateKey, aztecNode, a.address, undefined, logger)),
   );
 
   // Progress by 3 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
-  await advanceL2Block(node);
-  await advanceL2Block(node);
-  await advanceL2Block(node);
+  await advanceL2Block(aztecNode);
+  await advanceL2Block(aztecNode);
+  await advanceL2Block(aztecNode);
 
-  const wallets = await Promise.all(
+  await Promise.all(
     fundedAccounts.map(async (a, i) => {
-      const wallet = await a.getWallet();
-      const paymentMethod = new FeeJuicePaymentMethodWithClaim(wallet, claims[i]);
-      await a.deploy({ fee: { paymentMethod } }).wait();
-      logger.info(`Account deployed at ${a.getAddress()}`);
-      return wallet;
+      const paymentMethod = new FeeJuicePaymentMethodWithClaim(a.address, claims[i]);
+      const deployMethod = await a.getDeployMethod();
+      await deployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod } }).wait();
+      logger.info(`Account deployed at ${a.address}`);
     }),
   );
 
-  const tokenAdmin = wallets[0];
-  const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, undefined, logger);
-  const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
+  const tokenAdmin = fundedAccounts[0];
+  const tokenAddress = await deployTokenAndMint(
+    wallet,
+    fundedAccounts.map(acc => acc.address),
+    tokenAdmin.address,
+    mintAmount,
+    undefined,
+    logger,
+  );
+  const tokenContract = TokenContract.at(tokenAddress, wallet);
 
   return {
-    pxe,
-    wallets,
-    tokenAdminAddress: tokenAdmin.getAddress(),
-    tokenAdminWallet,
+    aztecNode,
+    wallet,
+    accounts: fundedAccounts.map(acc => acc.address),
+    tokenAdminAddress: tokenAdmin.address,
     tokenName: TOKEN_NAME,
     tokenAddress,
-    recipientWallet,
-    recipientAddress: recipientWallet.getAddress(),
+    tokenContract,
+    recipientAddress: recipientAccount.address,
   };
 }
 
 async function bridgeL1FeeJuice(
   l1RpcUrls: string[],
   mnemonicOrPrivateKey: string,
-  pxe: PXE,
+  aztecNode: AztecNode,
   recipient: AztecAddress,
   amount: bigint | undefined,
   log: Logger,
 ) {
-  const { l1ChainId } = await pxe.getNodeInfo();
+  const { l1ChainId } = await aztecNode.getNodeInfo();
   const chain = createEthereumChain(l1RpcUrls, l1ChainId);
   const l1Client = createExtendedL1Client(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
 
-  // docs:start:bridge_fee_juice
-  const portal = await L1FeeJuicePortalManager.new(pxe, l1Client, log);
+  const portal = await L1FeeJuicePortalManager.new(aztecNode, l1Client, log);
   const claim = await portal.bridgeTokensPublic(recipient, amount, true /* mint */);
-  // docs:end:bridge_fee_juice
 
-  const isSynced = async () => await pxe.isL1ToL2MessageSynced(Fr.fromHexString(claim.messageHash));
+  const isSynced = async () =>
+    (await aztecNode.getL1ToL2MessageBlock(Fr.fromHexString(claim.messageHash))) !== undefined;
   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, nodeAdmin?: AztecNodeAdmin) {
-  const initialBlockNumber = await node.getBlockNumber();
+async function advanceL2Block(aztecNode: AztecNode, nodeAdmin?: AztecNodeAdmin) {
+  const initialBlockNumber = await aztecNode.getBlockNumber();
 
   let minTxsPerBlock = undefined;
   if (nodeAdmin) {
@@ -204,7 +235,7 @@ async function advanceL2Block(node: AztecNode, nodeAdmin?: AztecNodeAdmin) {
     await nodeAdmin.setConfig({ minTxsPerBlock: 0 }); // Set to 0 to ensure we can advance the block
   }
 
-  await retryUntil(async () => (await node.getBlockNumber()) >= initialBlockNumber + 1);
+  await retryUntil(async () => (await aztecNode.getBlockNumber()) >= initialBlockNumber + 1);
 
   if (nodeAdmin && minTxsPerBlock !== undefined) {
     await nodeAdmin.setConfig({ minTxsPerBlock });
@@ -212,14 +243,15 @@ async function advanceL2Block(node: AztecNode, nodeAdmin?: AztecNodeAdmin) {
 }
 
 async function deployTokenAndMint(
-  wallets: AccountWalletWithSecretKey[],
+  wallet: Wallet,
+  accounts: AztecAddress[],
   admin: AztecAddress,
   mintAmount: bigint,
   paymentMethod: FeePaymentMethod | undefined,
   logger: Logger,
 ) {
   logger.verbose(`Deploying TokenContract...`);
-  const tokenContract = await TokenContract.deploy(wallets[0], admin, TOKEN_NAME, TOKEN_SYMBOL, TOKEN_DECIMALS)
+  const tokenContract = await TokenContract.deploy(wallet, admin, TOKEN_NAME, TOKEN_SYMBOL, TOKEN_DECIMALS)
     .send({
       from: admin,
       fee: {
@@ -230,12 +262,12 @@ async function deployTokenAndMint(
 
   const tokenAddress = tokenContract.address;
 
-  logger.verbose(`Minting ${mintAmount} public assets to the ${wallets.length} wallets...`);
+  logger.verbose(`Minting ${mintAmount} public assets to the ${accounts.length} accounts...`);
 
   await Promise.all(
-    wallets.map(async w =>
-      (await TokenContract.at(tokenAddress, w)).methods
-        .mint_to_public(w.getAddress(), mintAmount)
+    accounts.map(acc =>
+      TokenContract.at(tokenAddress, wallet)
+        .methods.mint_to_public(acc, mintAmount)
         .send({ from: admin, fee: { paymentMethod } })
         .wait({ timeout: 600 }),
     ),
@@ -247,23 +279,33 @@ async function deployTokenAndMint(
 }
 
 export async function performTransfers({
-  testWallets,
+  wallet,
+  testAccounts,
   rounds,
   transferAmount,
   logger,
+  feePaymentMethod,
 }: {
-  testWallets: TestWallets;
+  wallet: TestWallet;
+  testAccounts: TestAccounts;
   rounds: number;
   transferAmount: bigint;
   logger: Logger;
+  feePaymentMethod?: FeePaymentMethod;
 }) {
-  const recipient = testWallets.recipientWallet.getAddress();
+  const recipient = testAccounts.recipientAddress;
+  // Default to sponsored fee payment if no fee method is provided
+  const defaultFeePaymentMethod = feePaymentMethod || new SponsoredFeePaymentMethod(await getSponsoredFPCAddress());
   for (let i = 0; i < rounds; i++) {
-    const txs = testWallets.wallets.map(async w =>
-      (await TokenContract.at(testWallets.tokenAddress, w)).methods
-        .transfer_in_public(w.getAddress(), recipient, transferAmount, 0)
-        .prove({ from: w.getAddress() }),
-    );
+    const txs = testAccounts.accounts.map(acc => {
+      const token = TokenContract.at(testAccounts.tokenAddress, testAccounts.wallet);
+      return proveInteraction(wallet, token.methods.transfer_in_public(acc, recipient, transferAmount, 0), {
+        from: acc,
+        fee: {
+          paymentMethod: defaultFeePaymentMethod,
+        },
+      });
+    });
 
     const provenTxs = await Promise.all(txs);
 
@@ -273,25 +315,27 @@ export async function performTransfers({
   }
 }
 
-export async function startCompatiblePXE(
+export async function createWalletAndAztecNodeClient(
   nodeUrl: string,
   proverEnabled: boolean,
   logger: Logger,
-): Promise<{ pxe: PXE; cleanup: () => Promise<void> }> {
-  const node = createAztecNodeClient(nodeUrl);
+): Promise<{ wallet: TestWallet; aztecNode: AztecNode; cleanup: () => Promise<void> }> {
+  const aztecNode = createAztecNodeClient(nodeUrl);
   const [bbConfig, acvmConfig] = await Promise.all([getBBConfig(logger), getACVMConfig(logger)]);
-  const pxe = await createPXEService(node, {
+  const pxeConfig = {
     dataDirectory: undefined,
-    dataStoreMapSizeKB: 1024 * 1024,
+    dataStoreMapSizeKb: 1024 * 1024,
     ...bbConfig,
     ...acvmConfig,
     proverEnabled,
-  });
+  };
+  const wallet = await TestWallet.create(aztecNode, pxeConfig);
 
   return {
-    pxe,
+    wallet,
+    aztecNode,
     async cleanup() {
-      await pxe.stop();
+      await wallet.stop();
       await bbConfig?.cleanup();
       await acvmConfig?.cleanup();
     },

package/src/spartan/tx_metrics.ts

@@ -0,0 +1,130 @@
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { L2Block } from '@aztec/stdlib/block';
+import { Tx, type TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+
+import { createHistogram } from 'perf_hooks';
+
+export type TxInclusionData = {
+  txHash: string;
+  sentAt: number;
+  minedAt: number;
+  attestedAt: number;
+  blocknumber: number;
+  priorityFee: number;
+  totalFee: number;
+  positionInBlock: number;
+  group: string;
+};
+
+export class TxInclusionMetrics {
+  private data = new Map<string, TxInclusionData>();
+  private groups = new Set<string>();
+  private blocks = new Map<number, Promise<L2Block>>();
+
+  constructor(private aztecNode: AztecNode) {}
+
+  recordSentTx(tx: Tx, group: string): void {
+    const txHash = tx.getTxHash().toString();
+    const priorityFees = tx.getGasSettings().maxPriorityFeesPerGas;
+
+    this.data.set(txHash, {
+      txHash,
+      sentAt: Math.trunc(Date.now() / 1000),
+      minedAt: -1,
+      attestedAt: -1,
+      blocknumber: -1,
+      priorityFee: Number(priorityFees.feePerDaGas + priorityFees.feePerL2Gas),
+      totalFee: -1,
+      positionInBlock: -1,
+      group,
+    });
+    this.groups.add(group);
+  }
+
+  async recordMinedTx(txReceipt: TxReceipt): Promise<void> {
+    const { status, txHash, blockNumber } = txReceipt;
+    if (status !== TxStatus.SUCCESS || !blockNumber) {
+      return;
+    }
+
+    if (!this.blocks.has(blockNumber)) {
+      this.blocks.set(blockNumber, this.aztecNode.getBlock(blockNumber) as Promise<L2Block>);
+    }
+
+    const block = await this.blocks.get(blockNumber)!;
+    const data = this.data.get(txHash.toString())!;
+    data.blocknumber = blockNumber;
+    data.minedAt = Number(block.header.globalVariables.timestamp);
+    data.attestedAt = -1;
+    data.totalFee = Number(txReceipt.transactionFee ?? 0n);
+    data.positionInBlock = block.body.txEffects.findIndex(txEffect => txEffect.txHash.equals(txHash));
+  }
+
+  public inclusionTimeInSeconds(group: string): {
+    count: number;
+    group: string;
+    min: number;
+    mean: number;
+    max: number;
+    median: number;
+    p99: number;
+  } {
+    const histogram = createHistogram({});
+    for (const tx of this.data.values()) {
+      if (!tx.blocknumber || tx.group !== group) {
+        continue;
+      }
+
+      histogram.record(tx.minedAt - tx.sentAt);
+    }
+
+    if (histogram.count === 0) {
+      return {
+        group,
+        count: 0,
+        mean: 0,
+        max: 0,
+        median: 0,
+        min: 0,
+        p99: 0,
+      };
+    }
+
+    return {
+      group,
+      count: histogram.count,
+      mean: histogram.mean,
+      max: histogram.max,
+      median: histogram.percentile(50),
+      min: histogram.min,
+      p99: histogram.percentile(99),
+    };
+  }
+
+  toGithubActionBenchmarkJSON(): Array<{ name: string; unit: string; value: number; range?: number; extra?: string }> {
+    const data: Array<{ name: string; unit: string; value: number; range?: number; extra?: string }> = [];
+    for (const group of this.groups) {
+      const stats = this.inclusionTimeInSeconds(group);
+
+      data.push(
+        {
+          name: `${group}/avg_inclusion`,
+          unit: 's',
+          value: stats.mean,
+        },
+        {
+          name: `${group}/median_inclusion`,
+          unit: 's',
+          value: stats.median,
+        },
+        {
+          name: `${group}/p99_inclusion`,
+          unit: 's',
+          value: stats.p99,
+        },
+      );
+    }
+
+    return data;
+  }
+}