@aztec/end-to-end 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/spartan/DEVELOP.md

@@ -0,0 +1,116 @@
+The flow is as follows:
+
+1. Install/start KIND locally
+2. Bootstrap (to build an aztec image)
+3. Load image into kind
+4. Deploy networks
+5. Run tests in `yarn-project/end-to-end/src/spartan`
+
+# Setup KIND
+
+KIND is a kubernetes cluster that runs locally out of docker containers.
+
+You can just
+
+```bash
+spartan/bootstrap.sh kind
+```
+
+You only need to do that once. If you do it again, it will destroy the cluster and recreate it (which you almost never need to do).
+
+Now you’ll likely want some visibility into your cluster. You can
+
+```bash
+spartan/scripts/create_k8s_dashboard.sh
+```
+
+And after ~30 seconds or so you can
+
+```bash
+spartan/scripts/forward_k8s_dashboard.sh
+```
+
+That will run a port forward to your port `8443` . If you’re running in a remote environment (e.g. the mainframe), you’ll need to subsequently forward that back to your local machine. Cursor/VSCode have built in port forwarding (cmd/ctrl shift P, “forward”)
+
+Open the forwarded page, and copy/paste the token that was generated when you forwarded the dashboard.
+
+# Build an aztecprotocol:aztec image
+
+```bash
+./bootstrap.sh
+export AZTEC_DOCKER_IMAGE="aztecprotocol/aztec:$(docker images "aztecprotocol/aztec" --format json | \
+  jq -r 'select(.Tag != "latest") | .Tag' | \
+  head -1)"
+kind load docker-image $AZTEC_DOCKER_IMAGE
+```
+
+If you just changed typescript, you can (after the initial bootstrap)
+
+```bash
+./yarn-project/bootstrap.sh
+./release-image/bootstrap.sh
+export AZTEC_DOCKER_IMAGE="aztecprotocol/aztec:$(docker images "aztecprotocol/aztec" --format json | \
+  jq -r 'select(.Tag != "latest") | .Tag' | \
+  head -1)"
+kind load docker-image $AZTEC_DOCKER_IMAGE
+```
+
+The export is important there. The `AZTEC_DOCKER_IMAGE` env var is used as both:
+
+- the container that runs the rollup contract deployment
+- the containers for the aztec infrastructure (validators, provers, etc)
+
+# Deploy stuff
+
+```bash
+./spartan/bootstrap.sh network_deploy scenario.local.env
+```
+
+That will take 1-3 minutes. But at the end you should have everything you need.
+
+You can (`k` is just an alias over `kubectl`)
+
+```bash
+❯ k get pods -n scenario
+NAME                                              READY   STATUS    RESTARTS   AGE
+deploy-rollup-contracts-2025-08-31-1511-w2dlb   0/1     Completed   0          2m34s
+scenario-eth-beacon-0                           1/1     Running     0          39m
+scenario-eth-execution-0                        1/1     Running     0          39m
+scenario-eth-validator-0                        1/1     Running     0          39m
+scenario-p2p-bootstrap-node-5cbf9658b9-6vd9b    1/1     Running     0          20m
+scenario-prover-agent-59bd96899d-46k5s          1/1     Running     0          116s
+scenario-prover-agent-59bd96899d-vzvkd          1/1     Running     0          116s
+scenario-prover-broker-0                        1/1     Running     0          116s
+scenario-prover-node-0                          1/1     Running     0          116s
+scenario-rpc-aztec-node-0                       1/1     Running     0          116s
+scenario-validator-0                            1/1     Running     0          116s
+scenario-validator-1                            1/1     Running     0          116s
+scenario-validator-2                            1/1     Running     0          116s
+scenario-validator-3                            1/1     Running     0          116s
+```
+
+For example, you can forward back the ethereum node with
+
+```bash
+ k port-forward -n scenario services/eth-devnet-eth-execution 8545:8545
+```
+
+And then do whatever you like with it.
+
+# Run tests
+
+With the cluster running, you can now easily run tests.
+
+```bash
+# run one
+./spartan/bootstrap.sh single_test scenario.local.env spartan/smoke.test.ts
+
+# run all (serially)
+./spartan/bootstrap.sh network_tests scenario.local.env
+```
+
+Right now, I recommend running the smoke test first, always, as it waits for the committee to exist.
+
+# Teardown
+
+You can just `k delete namespace scenario`. That will destroy everything in your kind cluster. To destroy the associated terraform state that was stored locally, just `./spartan/terraform/purge_local_state.sh`.

package/src/spartan/setup_test_wallets.ts

@@ -5,23 +5,33 @@ import {
   type AztecAddress,
   type AztecNode,
   FeeJuicePaymentMethodWithClaim,
+  type FeePaymentMethod,
   Fr,
   L1FeeJuicePortalManager,
   type PXE,
+  SponsoredFeePaymentMethod,
   createAztecNodeClient,
   createCompatibleClient,
   retryUntil,
 } from '@aztec/aztec.js';
-import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+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;
 }
 
@@ -41,21 +51,78 @@ 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(
   pxeUrl: string,
   nodeUrl: string,
-  l1RpcUrl: string,
+  l1RpcUrls: string[],
   mnemonicOrPrivateKey: string,
   mintAmount: bigint,
   logger: Logger,
   numberOfFundedWallets = 1,
-  initialFeeJuice = 10n ** 22n,
 ): Promise<TestWallets> {
   const pxe = await createCompatibleClient(pxeUrl, logger);
   const node = createAztecNodeClient(nodeUrl);
@@ -70,12 +137,11 @@ export async function deployTestWalletWithTokens(
   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),
-    ),
+    fundedAccounts.map(a => bridgeL1FeeJuice(l1RpcUrls, mnemonicOrPrivateKey, pxe, a.getAddress(), undefined, logger)),
   );
 
-  // Progress by 2 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
+  // 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);
 
@@ -90,26 +156,37 @@ 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(
-  l1RpcUrl: string,
+  l1RpcUrls: string[],
   mnemonicOrPrivateKey: string,
   pxe: PXE,
   recipient: AztecAddress,
-  amount: bigint,
+  amount: bigint | undefined,
   log: Logger,
 ) {
   const { l1ChainId } = await pxe.getNodeInfo();
-  const chain = createEthereumChain([l1RpcUrl], l1ChainId);
-  const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
+  const chain = createEthereumChain(l1RpcUrls, l1ChainId);
+  const l1Client = createExtendedL1Client(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
 
-  const portal = await L1FeeJuicePortalManager.new(pxe, publicClient, walletClient, log);
+  // docs:start:bridge_fee_juice
+  const portal = await L1FeeJuicePortalManager.new(pxe, 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));
   await retryUntil(isSynced, `message ${claim.messageHash} sync`, 24, 0.5);
@@ -118,21 +195,37 @@ async function bridgeL1FeeJuice(
   return claim;
 }
 
-async function advanceL2Block(node: AztecNode) {
+async function advanceL2Block(node: AztecNode, nodeAdmin?: AztecNodeAdmin) {
   const initialBlockNumber = await node.getBlockNumber();
-  await node!.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;
@@ -143,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 }),
     ),
   );
@@ -165,20 +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();
+    },
+  };
+}