@aztec/end-to-end 3.0.0-nightly.20251118 → 3.0.0-nightly.20251120

package/src/fixtures/e2e_prover_test.ts

@@ -19,6 +19,7 @@ import { SecretValue } from '@aztec/foundation/config';
 import { FeeAssetHandlerAbi } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { type ProverNode, type ProverNodeConfig, createProverNode } from '@aztec/prover-node';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { TestWallet } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
@@ -63,6 +64,7 @@ export class FullProverTest {
   accounts: AztecAddress[] = [];
   deployedAccounts!: InitialAccountData[];
   fakeProofsAsset!: TokenContract;
+  fakeProofsAssetInstance!: ContractInstanceWithAddress;
   tokenSim!: TokenSimulator;
   aztecNode!: AztecNode;
   aztecNodeAdmin!: AztecNodeAdmin;
@@ -122,7 +124,7 @@ export class FullProverTest {
         await publicDeployAccounts(this.wallet, this.accounts.slice(0, 2));
 
         this.logger.verbose(`Deploying TokenContract...`);
-        const asset = await TokenContract.deploy(
+        const { contract: asset, instance } = await TokenContract.deploy(
           this.wallet,
           this.accounts[0],
           FullProverTest.TOKEN_NAME,
@@ -130,14 +132,15 @@ export class FullProverTest {
           FullProverTest.TOKEN_DECIMALS,
         )
           .send({ from: this.accounts[0] })
-          .deployed();
+          .wait();
         this.logger.verbose(`Token deployed to ${asset.address}`);
 
-        return { tokenContractAddress: asset.address };
+        return { tokenContractAddress: asset.address, tokenContractInstance: instance };
       },
-      async ({ tokenContractAddress }) => {
+      async ({ tokenContractAddress, tokenContractInstance }) => {
         // Restore the token contract state.
-        this.fakeProofsAsset = await TokenContract.at(tokenContractAddress, this.wallet);
+        this.fakeProofsAsset = TokenContract.at(tokenContractAddress, this.wallet);
+        this.fakeProofsAssetInstance = tokenContractInstance;
         this.logger.verbose(`Token contract address: ${this.fakeProofsAsset.address}`);
 
         this.tokenSim = new TokenSimulator(
@@ -216,14 +219,14 @@ export class FullProverTest {
       true,
     );
     this.logger.debug(`Contract address ${this.fakeProofsAsset.address}`);
-    await provenWallet.registerContract(this.fakeProofsAsset);
+    await provenWallet.registerContract(this.fakeProofsAssetInstance, TokenContract.artifact);
 
     for (let i = 0; i < 2; i++) {
       await provenWallet.createSchnorrAccount(this.deployedAccounts[i].secret, this.deployedAccounts[i].salt);
       await this.wallet.createSchnorrAccount(this.deployedAccounts[i].secret, this.deployedAccounts[i].salt);
     }
 
-    const asset = await TokenContract.at(this.fakeProofsAsset.address, provenWallet);
+    const asset = TokenContract.at(this.fakeProofsAsset.address, provenWallet);
     this.provenComponents.push({
       wallet: provenWallet,
       teardown: provenTeardown,

package/src/fixtures/setup_p2p_test.ts

@@ -2,6 +2,7 @@
  * Test fixtures and utilities to set up and run a test using multiple validators
  */
 import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { range } from '@aztec/foundation/array';
 import { SecretValue } from '@aztec/foundation/config';
 import { addLogNameHandler, removeLogNameHandler } from '@aztec/foundation/log';
 import { bufferToHex } from '@aztec/foundation/string';
@@ -40,6 +41,7 @@ export async function createNodes(
   dataDirectory?: string,
   metricsPort?: number,
   indexOffset = 0,
+  validatorsPerNode = 1,
 ): Promise<AztecNodeService[]> {
   const nodePromises: Promise<AztecNodeService>[] = [];
   const loggerIdStorage = new AsyncLocalStorage<string>();
@@ -52,13 +54,18 @@ export async function createNodes(
     // We run on ports from the bootnode upwards
     const port = bootNodePort + 1 + index;
 
+    // Determine validator indices for this node
+    const validatorIndices = validatorsPerNode === 1 ? index : range(validatorsPerNode, validatorsPerNode * index);
+
+    // Assign data directory
     const dataDir = dataDirectory ? `${dataDirectory}-${index}` : undefined;
+
     const nodePromise = createNode(
       config,
       dateProvider,
       port,
       bootstrapNodeEnr,
-      index,
+      validatorIndices,
       prefilledPublicData,
       dataDir,
       metricsPort,
@@ -84,7 +91,7 @@ export async function createNode(
   dateProvider: DateProvider,
   tcpPort: number,
   bootstrapNode: string | undefined,
-  addressIndex: number,
+  addressIndex: number | number[],
   prefilledPublicData?: PublicDataTreeLeaf[],
   dataDirectory?: string,
   metricsPort?: number,
@@ -188,16 +195,23 @@ export async function createValidatorConfig(
   config: AztecNodeConfig,
   bootstrapNodeEnr?: string,
   port?: number,
-  addressIndex: number = 1,
+  addressIndex: number | number[] = 1,
   dataDirectory?: string,
 ) {
-  const attesterPrivateKey = bufferToHex(getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + addressIndex)!);
+  const addressIndices = Array.isArray(addressIndex) ? addressIndex : [addressIndex];
+  if (addressIndices.length === 0) {
+    throw new Error('At least one address index must be provided to create a validator config');
+  }
+
+  const attesterPrivateKeys = addressIndices.map(index =>
+    bufferToHex(getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + index)!),
+  );
   const p2pConfig = await createP2PConfig(config, bootstrapNodeEnr, port, dataDirectory);
   const nodeConfig: AztecNodeConfig = {
     ...config,
     ...p2pConfig,
-    validatorPrivateKeys: new SecretValue([attesterPrivateKey]),
-    publisherPrivateKeys: [new SecretValue(attesterPrivateKey)],
+    validatorPrivateKeys: new SecretValue(attesterPrivateKeys),
+    publisherPrivateKeys: [new SecretValue(attesterPrivateKeys[0])],
   };
 
   return nodeConfig;

package/src/fixtures/token_utils.ts

@@ -6,9 +6,9 @@ import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
 export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger) {
   logger.info(`Deploying Token contract...`);
-  const contract = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18)
+  const { contract, instance } = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18)
     .send({ from: admin })
-    .deployed();
+    .wait();
 
   if (initialAdminBalance > 0n) {
     await mintTokensToPrivate(contract, admin, admin, initialAdminBalance);
@@ -16,7 +16,7 @@ export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAd
 
   logger.info('L2 contract deployed');
 
-  return contract;
+  return { contract, instance };
 }
 
 export async function mintTokensToPrivate(
@@ -36,7 +36,7 @@ export async function expectTokenBalance(
   logger: Logger,
 ) {
   // Then check the balance
-  const contractWithWallet = await TokenContract.at(token.address, wallet);
+  const contractWithWallet = TokenContract.at(token.address, wallet);
   const balance = await contractWithWallet.methods.balance_of_private(owner).simulate({ from: owner });
   logger.info(`Account ${owner} balance: ${balance}`);
   expect(balance).toBe(expectedBalance);

package/src/fixtures/utils.ts

@@ -858,7 +858,7 @@ export async function setupSponsoredFPC(wallet: Wallet) {
     salt: new Fr(SPONSORED_FPC_SALT),
   });
 
-  await wallet.registerContract({ instance, artifact: SponsoredFPCContract.artifact });
+  await wallet.registerContract(instance, SponsoredFPCContract.artifact);
   getLogger().info(`SponsoredFPC: ${instance.address}`);
   return instance;
 }
@@ -868,7 +868,7 @@ export async function setupSponsoredFPC(wallet: Wallet) {
  * @param wallet - The wallet
  */
 export async function registerSponsoredFPC(wallet: Wallet): Promise<void> {
-  await wallet.registerContract({ instance: await getSponsoredFPCInstance(), artifact: SponsoredFPCContract.artifact });
+  await wallet.registerContract(await getSponsoredFPCInstance(), SponsoredFPCContract.artifact);
 }
 
 export async function waitForProvenChain(node: AztecNode, targetBlock?: number, timeoutSec = 60, intervalSec = 1) {

package/src/shared/gas_portal_test_harness.ts

@@ -43,7 +43,7 @@ export class FeeJuicePortalTestingHarnessFactory {
       throw new Error('Fee Juice portal not deployed on L1');
     }
 
-    const gasL2 = await FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, wallet);
+    const gasL2 = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, wallet);
 
     return new GasBridgingTestHarness(
       aztecNode,

package/src/spartan/setup_test_wallets.ts

@@ -49,7 +49,7 @@ export async function setupTestAccountsWithTokens(
 
   const tokenAdmin = accounts[0];
   const tokenAddress = await deployTokenAndMint(wallet, accounts, tokenAdmin, mintAmount, undefined, logger);
-  const tokenContract = await TokenContract.at(tokenAddress, wallet);
+  const tokenContract = TokenContract.at(tokenAddress, wallet);
 
   return {
     aztecNode,
@@ -96,7 +96,7 @@ export async function deploySponsoredTestAccounts(
     new SponsoredFeePaymentMethod(await getSponsoredFPCAddress()),
     logger,
   );
-  const tokenContract = await TokenContract.at(tokenAddress, wallet);
+  const tokenContract = TokenContract.at(tokenAddress, wallet);
 
   return {
     aztecNode,
@@ -152,7 +152,7 @@ export async function deployTestAccountsWithTokens(
     undefined,
     logger,
   );
-  const tokenContract = await TokenContract.at(tokenAddress, wallet);
+  const tokenContract = TokenContract.at(tokenAddress, wallet);
 
   return {
     aztecNode,
@@ -228,9 +228,9 @@ async function deployTokenAndMint(
   logger.verbose(`Minting ${mintAmount} public assets to the ${accounts.length} accounts...`);
 
   await Promise.all(
-    accounts.map(async acc =>
-      (await TokenContract.at(tokenAddress, wallet)).methods
-        .mint_to_public(acc, mintAmount)
+    accounts.map(acc =>
+      TokenContract.at(tokenAddress, wallet)
+        .methods.mint_to_public(acc, mintAmount)
         .send({ from: admin, fee: { paymentMethod } })
         .wait({ timeout: 600 }),
     ),
@@ -260,8 +260,8 @@ export async function performTransfers({
   // 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 = testAccounts.accounts.map(async acc => {
-      const token = await TokenContract.at(testAccounts.tokenAddress, testAccounts.wallet);
+    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: {