@aztec/end-to-end 1.2.0 → 2.0.0-nightly.20250813

package/src/spartan/setup_test_wallets.ts

@@ -5,9 +5,11 @@ import {
   type AztecAddress,
   type AztecNode,
   FeeJuicePaymentMethodWithClaim,
+  type FeePaymentMethod,
   Fr,
   L1FeeJuicePortalManager,
   type PXE,
+  SponsoredFeePaymentMethod,
   createAztecNodeClient,
   createCompatibleClient,
   retryUntil,
@@ -15,14 +17,21 @@ import {
 import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
 import type { Logger } from '@aztec/foundation/log';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { createPXEService } from '@aztec/pxe/server';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 
+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;
+  tokenAdminAddress: AztecAddress;
   tokenName: string;
   recipientWallet: AccountWalletWithSecretKey;
+  recipientAddress: AztecAddress;
   tokenAddress: AztecAddress;
 }
 
@@ -42,10 +51,68 @@ export async function setupTestWalletsWithTokens(
   const [recipientWallet, ...wallets] = (await getDeployedTestAccountsWallets(pxe)).slice(0, WALLET_COUNT + 1);
 
   const tokenAdmin = wallets[0];
-  const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, logger);
+  const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, undefined, logger);
   const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
 
-  return { pxe, wallets, tokenAdminWallet, tokenName: TOKEN_NAME, tokenAddress, recipientWallet };
+  return {
+    pxe,
+    wallets,
+    tokenAdminWallet,
+    tokenAdminAddress: tokenAdmin.getAddress(),
+    tokenName: TOKEN_NAME,
+    tokenAddress,
+    recipientAddress: recipientWallet.getAddress(),
+    recipientWallet,
+  };
+}
+
+export async function deploySponsoredTestWallets(
+  pxe: PXE,
+  mintAmount: bigint,
+  logger: Logger,
+  numberOfFundedWallets = 1,
+): Promise<TestWallets> {
+  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)));
+
+  await registerSponsoredFPC(pxe);
+
+  const wallets = 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 tokenAdmin = wallets[0];
+  const tokenAddress = await deployTokenAndMint(
+    wallets,
+    tokenAdmin.getAddress(),
+    mintAmount,
+    new SponsoredFeePaymentMethod(await getSponsoredFPCAddress()),
+    logger,
+  );
+  const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
+
+  return {
+    pxe,
+    wallets,
+    tokenAdminAddress: tokenAdmin.getAddress(),
+    tokenAdminWallet,
+    tokenName: TOKEN_NAME,
+    tokenAddress,
+    recipientWallet,
+    recipientAddress: recipientWallet.getAddress(),
+  };
 }
 
 export async function deployTestWalletWithTokens(
@@ -89,10 +156,19 @@ export async function deployTestWalletWithTokens(
   );
 
   const tokenAdmin = wallets[0];
-  const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, logger);
+  const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, undefined, logger);
   const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
 
-  return { pxe, wallets, tokenAdminWallet, tokenName: TOKEN_NAME, tokenAddress, recipientWallet };
+  return {
+    pxe,
+    wallets,
+    tokenAdminAddress: tokenAdmin.getAddress(),
+    tokenAdminWallet,
+    tokenName: TOKEN_NAME,
+    tokenAddress,
+    recipientWallet,
+    recipientAddress: recipientWallet.getAddress(),
+  };
 }
 
 async function bridgeL1FeeJuice(
@@ -121,19 +197,35 @@ async function bridgeL1FeeJuice(
 
 async function advanceL2Block(node: AztecNode, nodeAdmin?: AztecNodeAdmin) {
   const initialBlockNumber = await node.getBlockNumber();
-  await nodeAdmin?.flushTxs();
+
+  let minTxsPerBlock = undefined;
+  if (nodeAdmin) {
+    ({ minTxsPerBlock } = await nodeAdmin.getConfig());
+    await nodeAdmin.setConfig({ minTxsPerBlock: 0 }); // Set to 0 to ensure we can advance the block
+  }
+
   await retryUntil(async () => (await node.getBlockNumber()) >= initialBlockNumber + 1);
+
+  if (nodeAdmin && minTxsPerBlock !== undefined) {
+    await nodeAdmin.setConfig({ minTxsPerBlock });
+  }
 }
 
 async function deployTokenAndMint(
   wallets: AccountWalletWithSecretKey[],
   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)
-    .send()
+    .send({
+      from: admin,
+      fee: {
+        paymentMethod,
+      },
+    })
     .deployed({ timeout: 600 });
 
   const tokenAddress = tokenContract.address;
@@ -144,7 +236,7 @@ async function deployTokenAndMint(
     wallets.map(async w =>
       (await TokenContract.at(tokenAddress, w)).methods
         .mint_to_public(w.getAddress(), mintAmount)
-        .send()
+        .send({ from: admin, fee: { paymentMethod } })
         .wait({ timeout: 600 }),
     ),
   );
@@ -166,23 +258,42 @@ export async function performTransfers({
   logger: Logger;
 }) {
   const recipient = testWallets.recipientWallet.getAddress();
-
   for (let i = 0; i < rounds; i++) {
-    const interactions = await Promise.all(
-      testWallets.wallets.map(async w =>
-        (await TokenContract.at(testWallets.tokenAddress, w)).methods.transfer_in_public(
-          w.getAddress(),
-          recipient,
-          transferAmount,
-          0,
-        ),
-      ),
+    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 = await Promise.all(interactions.map(async i => await i.prove()));
+    const provenTxs = await Promise.all(txs);
 
-    await Promise.all(txs.map(t => t.send().wait({ timeout: 600 })));
+    await Promise.all(provenTxs.map(t => t.send().wait({ timeout: 600 })));
 
     logger.info(`Completed round ${i + 1} / ${rounds}`);
   }
 }
+
+export async function startCompatiblePXE(
+  nodeUrl: string,
+  proverEnabled: boolean,
+  logger: Logger,
+): Promise<{ pxe: PXE; cleanup: () => Promise<void> }> {
+  const node = createAztecNodeClient(nodeUrl);
+  const [bbConfig, acvmConfig] = await Promise.all([getBBConfig(logger), getACVMConfig(logger)]);
+  const pxe = await createPXEService(node, {
+    dataDirectory: undefined,
+    dataStoreMapSizeKB: 1024 * 1024,
+    ...bbConfig,
+    ...acvmConfig,
+    proverEnabled,
+  });
+
+  return {
+    pxe,
+    async cleanup() {
+      await pxe.stop();
+      await bbConfig?.cleanup();
+      await acvmConfig?.cleanup();
+    },
+  };
+}

package/src/spartan/utils.ts

@@ -1,5 +1,5 @@
 import { createLogger, sleep } from '@aztec/aztec.js';
-import type { RollupCheatCodes } from '@aztec/aztec.js/testing';
+import type { RollupCheatCodes } from '@aztec/aztec/testing';
 import type { Logger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import type { SequencerConfig } from '@aztec/sequencer-client';
@@ -34,6 +34,7 @@ const k8sLocalConfigSchema = z.object({
   AZTEC_SLOT_DURATION: z.coerce.number().min(1, 'AZTEC_SLOT_DURATION env variable must be set'),
   AZTEC_EPOCH_DURATION: z.coerce.number().min(1, 'AZTEC_EPOCH_DURATION env variable must be set'),
   AZTEC_PROOF_SUBMISSION_WINDOW: z.coerce.number().min(1, 'AZTEC_PROOF_SUBMISSION_WINDOW env variable must be set'),
+  AZTEC_REAL_PROOFS: z.string().default('false'),
   INSTANCE_NAME: z.string().min(1, 'INSTANCE_NAME env variable must be set'),
   NAMESPACE: z.string().min(1, 'NAMESPACE env variable must be set'),
   CONTAINER_NODE_PORT: z.coerce.number().default(8080),
@@ -56,6 +57,7 @@ const k8sGCloudConfigSchema = k8sLocalConfigSchema.extend({
   K8S: z.literal('gcloud'),
   CLUSTER_NAME: z.string().min(1, 'CLUSTER_NAME env variable must be set'),
   REGION: z.string().min(1, 'REGION env variable must be set'),
+  PROJECT_ID: z.string().min(1, 'PROJECT_ID env variable must be set'),
 });
 
 const directConfigSchema = z.object({
@@ -84,7 +86,7 @@ export function isGCloudConfig(config: EnvConfig): config is K8sGCloudConfig {
 export function setupEnvironment(env: unknown): EnvConfig {
   const config = envSchema.parse(env);
   if (isGCloudConfig(config)) {
-    const command = `gcloud container clusters get-credentials ${config.CLUSTER_NAME} --region=${config.REGION}`;
+    const command = `gcloud container clusters get-credentials ${config.CLUSTER_NAME} --region=${config.REGION} --project=${config.PROJECT_ID}`;
     execSync(command);
   }
   return config;
@@ -233,12 +235,14 @@ export async function deleteResourceByLabel({
   resource,
   namespace,
   label,
+  timeout = '5m',
 }: {
   resource: string;
   namespace: string;
   label: string;
+  timeout?: string;
 }) {
-  const command = `kubectl delete ${resource} -l ${label} -n ${namespace} --ignore-not-found=true --wait=true`;
+  const command = `kubectl delete ${resource} -l ${label} -n ${namespace} --ignore-not-found=true --wait=true --timeout=${timeout}`;
   logger.info(`command: ${command}`);
   const { stdout } = await execAsync(command);
   return stdout;
@@ -458,10 +462,12 @@ export function applyValidatorKill({
   namespace,
   spartanDir,
   logger,
+  values,
 }: {
   namespace: string;
   spartanDir: string;
   logger: Logger;
+  values?: Record<string, string | number>;
 }) {
   return installChaosMeshChart({
     instanceName: 'validator-kill',
@@ -469,6 +475,7 @@ export function applyValidatorKill({
     valuesFile: 'validator-kill.yaml',
     helmChartDir: getChartDir(spartanDir, 'aztec-chaos-scenarios'),
     logger,
+    values,
   });
 }