@aztec/end-to-end 0.82.2 → 0.82.3

package/src/e2e_p2p/p2p_network.ts

@@ -29,7 +29,7 @@ import {
   createSnapshotManager,
   deployAccounts,
 } from '../fixtures/snapshot_manager.js';
-import { getPrivateKeyFromIndex } from '../fixtures/utils.js';
+import { getPrivateKeyFromIndex, getSponsoredFPCAddress } from '../fixtures/utils.js';
 import { getEndToEndTestTelemetryClient } from '../fixtures/with_telemetry_utils.js';
 
 // Use a fixed bootstrap node private key so that we can re-use the same snapshot and the nodes can find each other
@@ -54,6 +54,7 @@ export class P2PNetworkTest {
   public attesterPublicKeys: string[] = [];
   public proposerPrivateKeys: `0x${string}`[] = [];
   public peerIdPrivateKeys: string[] = [];
+  public validators: { attester: `0x${string}`; proposer: `0x${string}`; withdrawer: `0x${string}` }[] = [];
 
   public deployedAccounts: InitialAccountData[] = [];
   public prefilledPublicData: PublicDataTreeLeaf[] = [];
@@ -230,9 +231,10 @@ export class P2PNetworkTest {
             amount: l1ContractsConfig.minimumStake,
           } as const);
 
-          this.logger.verbose(`Adding (attester, proposer) pair: (${attester.address}, ${forwarder}) as validator`);
+          this.logger.info(`Adding attester ${attester.address} proposer ${forwarder} as validator`);
         }
 
+        this.validators = validators;
         await deployL1ContractsValues.publicClient.waitForTransactionReceipt({
           hash: await rollup.write.cheat__InitialiseValidatorSet([validators]),
         });
@@ -319,9 +321,11 @@ export class P2PNetworkTest {
   async setup() {
     this.ctx = await this.snapshotManager.setup();
 
-    this.prefilledPublicData = (
-      await getGenesisValues(this.ctx.initialFundedAccounts.map(a => a.address))
-    ).prefilledPublicData;
+    const sponsoredFPCAddress = await getSponsoredFPCAddress();
+    const initialFundedAccounts = [...this.ctx.initialFundedAccounts.map(a => a.address), sponsoredFPCAddress];
+
+    const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
+    this.prefilledPublicData = prefilledPublicData;
 
     this.startSyncMockSystemTimeInterval();
 

package/src/e2e_p2p/shared.ts

@@ -47,6 +47,7 @@ export const createPXEServiceAndSubmitTransactions = async (
   fundedAccount: InitialAccountData,
 ): Promise<NodeContext> => {
   const rpcConfig = getRpcConfig();
+  rpcConfig.proverEnabled = false;
   const pxeService = await createPXEService(node, rpcConfig, true);
 
   const account = await getSchnorrAccount(

package/src/fixtures/token_utils.ts

@@ -1,7 +1,8 @@
-// docs:start:token_utils
-import type { AztecAddress, Logger, Wallet } from '@aztec/aztec.js';
+import { type AztecAddress, BatchCall, type Logger, type Wallet } from '@aztec/aztec.js';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
+// docs:start:token_utils
+
 export async function deployToken(adminWallet: Wallet, initialAdminBalance: bigint, logger: Logger) {
   logger.info(`Deploying Token contract...`);
   const contract = await TokenContract.deploy(adminWallet, adminWallet.getAddress(), 'TokenName', 'TokenSymbol', 18)
@@ -43,3 +44,22 @@ export async function expectTokenBalance(
   logger.info(`Account ${owner} balance: ${balance}`);
   expect(balance).toBe(expectedBalance);
 }
+
+export async function mintNotes(
+  sender: Wallet,
+  recipient: AztecAddress,
+  asset: TokenContract,
+  noteAmounts: bigint[],
+): Promise<bigint> {
+  // We can only mint 4 notes at a time, since that's the maximum number of calls our entrypoints allow
+  // TODO(#13024): mint as many notes as possible in a single tx
+  const notesPerIteration = 4;
+  for (let mintedNotes = 0; mintedNotes < noteAmounts.length; mintedNotes += notesPerIteration) {
+    const toMint = noteAmounts.slice(mintedNotes, mintedNotes + notesPerIteration);
+    const from = sender.getAddress(); // we are setting from to sender here because we need a sender to calculate the tag
+    const actions = toMint.map(amt => asset.methods.mint_to_private(from, recipient, amt));
+    await new BatchCall(sender, actions).send().wait();
+  }
+
+  return noteAmounts.reduce((prev, curr) => prev + curr, 0n);
+}

package/src/sample-dapp/contracts.mjs

@@ -1,14 +1,14 @@
-// docs:start:imports
-import { AztecAddress } from '@aztec/aztec.js';
+import { AztecAddress, Contract } from '@aztec/aztec.js';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
 import { readFileSync } from 'fs';
 
-// docs:end:imports
+// This syntax is helpful for the referencing tutorial
+const TokenContractArtifact = TokenContract.artifact;
 
 // docs:start:get-tokens
 export async function getToken(wallet) {
   const addresses = JSON.parse(readFileSync('addresses.json'));
-  return TokenContract.at(AztecAddress.fromString(addresses.token), wallet);
+  return Contract.at(AztecAddress.fromString(addresses.token), TokenContractArtifact, wallet);
 }
 // docs:end:get-tokens

package/src/shared/capture_private_execution_steps.ts

@@ -2,7 +2,12 @@
  * This module exposes the ability to capture the private exection steps that go into our "Client IVC" prover.
  * These are used for debugging and benchmarking barretenberg (the prover component).
  */
-import type { ContractFunctionInteraction } from '@aztec/aztec.js/contracts';
+import type {
+  ContractFunctionInteraction,
+  DeployMethod,
+  DeployOptions,
+  ProfileMethodOptions,
+} from '@aztec/aztec.js/contracts';
 import { createLogger } from '@aztec/foundation/log';
 import { serializeWitness } from '@aztec/noir-noirc_abi';
 import type { PrivateExecutionStep } from '@aztec/stdlib/kernel';
@@ -17,27 +22,59 @@ const logger = createLogger('e2e:capture-private-execution-steps');
 // Longer term we won't use this hacked together msgpack format
 // Leaving duplicated as this eventually bb will provide a serialization
 // helper for passing to a generic msgpack RPC endpoint.
-async function _createClientIvcProofFiles(directory: string, executionSteps: PrivateExecutionStep[]) {
+async function _createClientIvcProofFiles(
+  directory: string,
+  executionSteps: PrivateExecutionStep[],
+  rawWitnesses: boolean = false,
+) {
   const acirPath = path.join(directory, 'acir.msgpack');
   const witnessPath = path.join(directory, 'witnesses.msgpack');
   await fs.writeFile(acirPath, encode(executionSteps.map(map => map.bytecode)));
   await fs.writeFile(witnessPath, encode(executionSteps.map(map => serializeWitness(map.witness))));
+  let rawWitnessesPath;
+  if (rawWitnesses) {
+    rawWitnessesPath = path.join(directory, 'witnesses.json');
+    await fs.writeFile(rawWitnessesPath, JSON.stringify(executionSteps.map(step => Object.fromEntries(step.witness))));
+  }
   return {
     acirPath,
     witnessPath,
+    rawWitnessesPath,
   };
 }
 
-export async function capturePrivateExecutionStepsIfEnvSet(label: string, interaction: ContractFunctionInteraction) {
+export async function capturePrivateExecutionStepsIfEnvSet(
+  label: string,
+  interaction: ContractFunctionInteraction | DeployMethod,
+  opts?: Omit<ProfileMethodOptions & DeployOptions, 'profileMode'>,
+  expectedSteps?: number,
+) {
   // Not included in env_var.ts as internal to e2e tests.
   const ivcFolder = process.env.CAPTURE_IVC_FOLDER;
   if (ivcFolder) {
-    logger.info(`Capturing client ivc execution steps for ${label}`);
-    const result = await interaction.profile({ profileMode: 'execution-steps' });
+    const profileMode = ['execution-steps', 'full'].includes(process.env.PROFILE_MODE ?? '')
+      ? (process.env.PROFILE_MODE as 'full' | 'execution-steps')
+      : 'execution-steps';
+    logger.info(`Capturing client ivc execution profile for ${label} in mode ${profileMode}`);
+    const result = await interaction.profile({
+      ...opts,
+      profileMode: profileMode,
+    });
+    if (expectedSteps !== undefined && result.executionSteps.length !== expectedSteps) {
+      throw new Error(`Expected ${expectedSteps} execution steps, got ${result.executionSteps.length}`);
+    }
     const resultsDirectory = path.join(ivcFolder, label);
     logger.info(`Writing private execution steps to ${resultsDirectory}`);
     await fs.mkdir(resultsDirectory, { recursive: true });
-    await _createClientIvcProofFiles(resultsDirectory, result.executionSteps);
+    await fs.writeFile(
+      path.join(resultsDirectory, 'steps.json'),
+      JSON.stringify(
+        result.executionSteps.map(step => ({ fnName: step.functionName, gateCount: step.gateCount })),
+        null,
+        2,
+      ),
+    );
+    await _createClientIvcProofFiles(resultsDirectory, result.executionSteps, profileMode === 'full');
     logger.info(`Wrote private execution steps to ${resultsDirectory}`);
   }
 }

package/src/shared/cross_chain_test_harness.ts

@@ -121,6 +121,17 @@ export async function deployAndInitializeTokenAndBridgeContracts(
 }
 // docs:end:deployAndInitializeTokenAndBridgeContracts
 
+export type CrossChainContext = {
+  l2Token: AztecAddress;
+  l2Bridge: AztecAddress;
+  tokenPortal: EthAddress;
+  underlying: EthAddress;
+  ethAccount: EthAddress;
+  ownerAddress: AztecAddress;
+  inbox: EthAddress;
+  outbox: EthAddress;
+};
+
 /**
  * A Class for testing cross chain interactions, contains common interactions
  * shared between cross chain tests.
@@ -363,5 +374,18 @@ export class CrossChainTestHarness {
     await this.mintTokensPublicOnL2(0n);
     await this.mintTokensPublicOnL2(0n);
   }
+
+  toCrossChainContext(): CrossChainContext {
+    return {
+      l2Token: this.l2Token.address,
+      l2Bridge: this.l2Bridge.address,
+      tokenPortal: this.tokenPortalAddress,
+      underlying: this.underlyingERC20Address,
+      ethAccount: this.ethAccount,
+      ownerAddress: this.ownerAddress,
+      inbox: this.l1ContractAddresses.inboxAddress,
+      outbox: this.l1ContractAddresses.outboxAddress,
+    };
+  }
 }
 // docs:end:cross_chain_test_harness