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

package/src/e2e_token_contract/token_contract_test.ts

@@ -1,5 +1,5 @@
 import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { type AccountWallet, type AztecNode, type CompleteAddress, type Logger, createLogger } from '@aztec/aztec.js';
+import { type AccountWallet, AztecAddress, type AztecNode, type Logger, createLogger } from '@aztec/aztec.js';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
 
@@ -23,13 +23,18 @@ export class TokenContractTest {
   static TOKEN_DECIMALS = 18n;
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  wallets: AccountWallet[] = [];
-  accounts: CompleteAddress[] = [];
   asset!: TokenContract;
   tokenSim!: TokenSimulator;
-  badAccount!: InvalidAccountContract;
   node!: AztecNode;
 
+  badAccount!: InvalidAccountContract;
+  admin!: AccountWallet;
+  adminAddress!: AztecAddress;
+  account1!: AccountWallet;
+  account1Address!: AztecAddress;
+  account2!: AccountWallet;
+  account2Address!: AztecAddress;
+
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_token_contract:${testName}`);
     this.snapshotManager = createSnapshotManager(`e2e_token_contract/${testName}`, dataPath, {
@@ -51,8 +56,9 @@ export class TokenContractTest {
       deployAccounts(3, this.logger),
       async ({ deployedAccounts }, { pxe, aztecNode }) => {
         this.node = aztecNode;
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.accounts = this.wallets.map(w => w.getCompleteAddress());
+        const wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
+        [this.admin, this.account1, this.account2] = wallets;
+        [this.adminAddress, this.account1Address, this.account2Address] = wallets.map(w => w.getAddress());
       },
     );
 
@@ -62,42 +68,42 @@ export class TokenContractTest {
         // Create the token contract state.
         // Move this account thing to addAccounts above?
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 2));
+        await publicDeployAccounts(this.admin, [this.adminAddress, this.account1Address]);
 
         this.logger.verbose(`Deploying TokenContract...`);
         const asset = await TokenContract.deploy(
-          this.wallets[0],
-          this.accounts[0],
+          this.admin,
+          this.adminAddress,
           TokenContractTest.TOKEN_NAME,
           TokenContractTest.TOKEN_SYMBOL,
           TokenContractTest.TOKEN_DECIMALS,
         )
-          .send()
+          .send({ from: this.adminAddress })
           .deployed();
         this.logger.verbose(`Token deployed to ${asset.address}`);
 
         this.logger.verbose(`Deploying bad account...`);
-        this.badAccount = await InvalidAccountContract.deploy(this.wallets[0]).send().deployed();
+        this.badAccount = await InvalidAccountContract.deploy(this.admin).send({ from: this.adminAddress }).deployed();
         this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
 
         return { tokenContractAddress: asset.address, badAccountAddress: this.badAccount.address };
       },
       async ({ tokenContractAddress, badAccountAddress }) => {
         // Restore the token contract state.
-        this.asset = await TokenContract.at(tokenContractAddress, this.wallets[0]);
+        this.asset = await TokenContract.at(tokenContractAddress, this.admin);
         this.logger.verbose(`Token contract address: ${this.asset.address}`);
 
-        this.tokenSim = new TokenSimulator(
-          this.asset,
-          this.wallets[0],
-          this.logger,
-          this.accounts.map(a => a.address),
-        );
+        this.tokenSim = new TokenSimulator(this.asset, this.admin, this.adminAddress, this.logger, [
+          this.adminAddress,
+          this.account1Address,
+        ]);
 
-        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallets[0]);
+        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.admin);
         this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
 
-        expect(await this.asset.methods.get_admin().simulate()).toBe(this.accounts[0].address.toBigInt());
+        expect(await this.asset.methods.get_admin().simulate({ from: this.adminAddress })).toBe(
+          this.adminAddress.toBigInt(),
+        );
       },
     );
 
@@ -125,36 +131,32 @@ export class TokenContractTest {
     await this.snapshotManager.snapshot(
       'mint',
       async () => {
-        const { asset, wallets } = this;
+        const { asset, admin, adminAddress } = this;
         const amount = 10000n;
 
         this.logger.verbose(`Minting ${amount} publicly...`);
-        await asset.methods.mint_to_public(wallets[0].getAddress(), amount).send().wait();
+        await asset.methods.mint_to_public(adminAddress, amount).send({ from: adminAddress }).wait();
 
         this.logger.verbose(`Minting ${amount} privately...`);
-        await mintTokensToPrivate(asset, wallets[0], wallets[0].getAddress(), amount);
+        await mintTokensToPrivate(asset, adminAddress, admin, adminAddress, amount);
         this.logger.verbose(`Minting complete.`);
 
         return { amount };
       },
       async ({ amount }) => {
-        const {
-          asset,
-          accounts: [{ address }],
-          tokenSim,
-        } = this;
-        tokenSim.mintPublic(address, amount);
-
-        const publicBalance = await asset.methods.balance_of_public(address).simulate();
+        const { asset, adminAddress, tokenSim } = this;
+        tokenSim.mintPublic(adminAddress, amount);
+
+        const publicBalance = await asset.methods.balance_of_public(adminAddress).simulate({ from: adminAddress });
         this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
-        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
+        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(adminAddress));
 
-        tokenSim.mintPrivate(address, amount);
-        const privateBalance = await asset.methods.balance_of_private(address).simulate();
+        tokenSim.mintPrivate(adminAddress, amount);
+        const privateBalance = await asset.methods.balance_of_private(adminAddress).simulate({ from: adminAddress });
         this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
-        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
+        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(adminAddress));
 
-        const totalSupply = await asset.methods.total_supply().simulate();
+        const totalSupply = await asset.methods.total_supply().simulate({ from: adminAddress });
         this.logger.verbose(`Total supply: ${totalSupply}`);
         expect(totalSupply).toEqual(tokenSim.totalSupply);
 

package/src/fixtures/e2e_prover_test.ts

@@ -14,7 +14,7 @@ import {
   type PXE,
   createLogger,
 } from '@aztec/aztec.js';
-import { CheatCodes } from '@aztec/aztec.js/testing';
+import { CheatCodes } from '@aztec/aztec/testing';
 import {
   BBCircuitVerifier,
   type ClientProtocolCircuitVerifier,
@@ -141,7 +141,7 @@ export class FullProverTest {
           FullProverTest.TOKEN_SYMBOL,
           FullProverTest.TOKEN_DECIMALS,
         )
-          .send()
+          .send({ from: this.wallets[0].getAddress() })
           .deployed();
         this.logger.verbose(`Token deployed to ${asset.address}`);
 
@@ -155,11 +155,14 @@ export class FullProverTest {
         this.tokenSim = new TokenSimulator(
           this.fakeProofsAsset,
           this.wallets[0],
+          this.wallets[0].getAddress(),
           this.logger,
           this.accounts.map(a => a.address),
         );
 
-        expect(await this.fakeProofsAsset.methods.get_admin().simulate()).toBe(this.accounts[0].address.toBigInt());
+        expect(await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0].address })).toBe(
+          this.accounts[0].address.toBigInt(),
+        );
       },
     );
   }
@@ -276,7 +279,7 @@ export class FullProverTest {
     this.logger.verbose('Starting archiver for new prover node');
     const archiver = await createArchiver(
       { ...this.context.aztecNodeConfig, dataDirectory: undefined },
-      blobSinkClient,
+      { blobSinkClient },
       { blockUntilSync: true },
     );
 
@@ -291,7 +294,7 @@ export class FullProverTest {
     this.logger.verbose('Starting prover node');
     const proverConfig: ProverNodeConfig = {
       ...this.context.aztecNodeConfig,
-      proverCoordinationNodeUrls: [],
+      txCollectionNodeRpcUrls: [],
       dataDirectory: undefined,
       proverId: this.proverAddress.toField(),
       realProofs: this.realProofs,
@@ -303,6 +306,7 @@ export class FullProverTest {
       txGatheringIntervalMs: 1000,
       txGatheringBatchSize: 10,
       txGatheringMaxParallelRequestsPerNode: 100,
+      txGatheringTimeoutMs: 24_000,
       proverNodeFailedEpochStore: undefined,
     };
     const sponsoredFPCAddress = await getSponsoredFPCAddress();
@@ -364,11 +368,14 @@ export class FullProverTest {
         this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
         await asset.methods
           .mint_to_public(accounts[0].address, privateAmount + publicAmount)
-          .send()
+          .send({ from: accounts[0].address })
           .wait();
 
         this.logger.verbose(`Transferring ${privateAmount} to private...`);
-        await asset.methods.transfer_to_private(accounts[0].address, privateAmount).send().wait();
+        await asset.methods
+          .transfer_to_private(accounts[0].address, privateAmount)
+          .send({ from: accounts[0].address })
+          .wait();
 
         this.logger.verbose(`Minting complete.`);
 
@@ -382,16 +389,16 @@ export class FullProverTest {
         } = this;
         tokenSim.mintPublic(address, amount);
 
-        const publicBalance = await asset.methods.balance_of_public(address).simulate();
+        const publicBalance = await asset.methods.balance_of_public(address).simulate({ from: address });
         this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
         expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
 
         tokenSim.mintPrivate(address, amount);
-        const privateBalance = await asset.methods.balance_of_private(address).simulate();
+        const privateBalance = await asset.methods.balance_of_private(address).simulate({ from: address });
         this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
         expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
 
-        const totalSupply = await asset.methods.total_supply().simulate();
+        const totalSupply = await asset.methods.total_supply().simulate({ from: address });
         this.logger.verbose(`Total supply: ${totalSupply}`);
         expect(totalSupply).toEqual(tokenSim.totalSupply);
 

package/src/fixtures/setup_p2p_test.ts

@@ -5,7 +5,9 @@ import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
 import type { SentTx } from '@aztec/aztec.js';
 import { SecretValue } from '@aztec/foundation/config';
 import { addLogNameHandler, removeLogNameHandler } from '@aztec/foundation/log';
+import { bufferToHex } from '@aztec/foundation/string';
 import type { DateProvider } from '@aztec/foundation/timer';
+import type { ProverNodeConfig, ProverNodeDeps } from '@aztec/prover-node';
 import type { PXEService } from '@aztec/pxe/server';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 
@@ -13,12 +15,14 @@ import getPort from 'get-port';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
 import { TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
-import { getPrivateKeyFromIndex } from './utils.js';
+import { createAndSyncProverNode, getPrivateKeyFromIndex } from './utils.js';
 import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 
 // Setup snapshots will create a node with index 0, and run extra bootstrap with
 // index 1, so all of our loops here need to start from 2 to avoid running validators with the same key
 export const ATTESTER_PRIVATE_KEYS_START_INDEX = 2;
+// We use slasher keys after the first 10 anvil keys, note that this requires anvil to be started with more than the default 10 accounts
+export const SLASHER_PRIVATE_KEYS_START_INDEX = 12;
 
 export interface NodeContext {
   node: AztecNodeService;
@@ -44,6 +48,7 @@ export async function createNodes(
   prefilledPublicData?: PublicDataTreeLeaf[],
   dataDirectory?: string,
   metricsPort?: number,
+  indexOffset = 0,
 ): Promise<AztecNodeService[]> {
   const nodePromises: Promise<AztecNodeService>[] = [];
   const loggerIdStorage = new AsyncLocalStorage<string>();
@@ -52,16 +57,17 @@ export async function createNodes(
   addLogNameHandler(logNameHandler);
 
   for (let i = 0; i < numNodes; i++) {
+    const index = indexOffset + i;
     // We run on ports from the bootnode upwards
-    const port = bootNodePort + i + 1;
+    const port = bootNodePort + 1 + index;
 
-    const dataDir = dataDirectory ? `${dataDirectory}-${i}` : undefined;
+    const dataDir = dataDirectory ? `${dataDirectory}-${index}` : undefined;
     const nodePromise = createNode(
       config,
       dateProvider,
       port,
       bootstrapNodeEnr,
-      i,
+      index,
       prefilledPublicData,
       dataDir,
       metricsPort,
@@ -71,9 +77,9 @@ export async function createNodes(
   }
   const nodes = await Promise.all(nodePromises);
 
-  // Sanity check that we have a sequencer
+  // Sanity check that we have a sequencer if required
   const seqClient = nodes[0].getSequencer();
-  if (!seqClient) {
+  if (!seqClient && config.disableValidator === false) {
     throw new Error('Sequencer not found');
   }
 
@@ -101,6 +107,42 @@ export async function createNode(
   return loggerIdStorage ? await loggerIdStorage.run(tcpPort.toString(), createNode) : createNode();
 }
 
+export async function createProverNode(
+  config: AztecNodeConfig,
+  tcpPort: number,
+  bootstrapNode: string | undefined,
+  addressIndex: number,
+  proverNodeDeps: ProverNodeDeps & Required<Pick<ProverNodeDeps, 'dateProvider'>>,
+  prefilledPublicData?: PublicDataTreeLeaf[],
+  dataDirectory?: string,
+  metricsPort?: number,
+  loggerIdStorage?: AsyncLocalStorage<string>,
+) {
+  const createProverNode = async () => {
+    const proverNodePrivateKey = getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + addressIndex)!;
+    const telemetry = getEndToEndTestTelemetryClient(metricsPort);
+
+    const proverConfig: Partial<ProverNodeConfig> = {
+      p2pIp: `127.0.0.1`,
+      p2pPort: tcpPort ?? (await getPort()),
+      p2pEnabled: true,
+      peerCheckIntervalMS: TEST_PEER_CHECK_INTERVAL_MS,
+      blockCheckIntervalMS: 1000,
+      bootstrapNodes: bootstrapNode ? [bootstrapNode] : [],
+    };
+    const aztecNodeRpcTxProvider = undefined;
+    return await createAndSyncProverNode(
+      bufferToHex(proverNodePrivateKey),
+      config,
+      { ...proverConfig, dataDirectory },
+      aztecNodeRpcTxProvider,
+      prefilledPublicData,
+      { ...proverNodeDeps, telemetry },
+    );
+  };
+  return loggerIdStorage ? await loggerIdStorage.run(tcpPort.toString(), createProverNode) : createProverNode();
+}
+
 export async function createValidatorConfig(
   config: AztecNodeConfig,
   bootstrapNodeEnr?: string,
@@ -110,12 +152,12 @@ export async function createValidatorConfig(
 ) {
   port = port ?? (await getPort());
 
-  const attesterPrivateKey: `0x${string}` = `0x${getPrivateKeyFromIndex(
-    ATTESTER_PRIVATE_KEYS_START_INDEX + addressIndex,
-  )!.toString('hex')}`;
+  const attesterPrivateKey = bufferToHex(getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + addressIndex)!);
+  const slasherPrivateKey = bufferToHex(getPrivateKeyFromIndex(SLASHER_PRIVATE_KEYS_START_INDEX + addressIndex)!);
 
   config.validatorPrivateKeys = new SecretValue([attesterPrivateKey]);
   config.publisherPrivateKey = new SecretValue(attesterPrivateKey);
+  config.slasherPrivateKey = new SecretValue(slasherPrivateKey);
 
   const nodeConfig: AztecNodeConfig = {
     ...config,

package/src/fixtures/snapshot_manager.ts

@@ -14,16 +14,17 @@ import {
   getContractClassFromArtifact,
   waitForProven,
 } from '@aztec/aztec.js';
-import { deployInstance, registerContractClass } from '@aztec/aztec.js/deployment';
-import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec.js/testing';
+import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
+import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec/testing';
 import { type BlobSinkServer, createBlobSinkServer } from '@aztec/blob-sink/server';
 import {
   type DeployL1ContractsArgs,
   type DeployL1ContractsReturnType,
+  FeeAssetArtifact,
+  RollupContract,
   createExtendedL1Client,
   deployMulticall3,
   getL1ContractsConfigEnvVars,
-  l1Artifacts,
 } from '@aztec/ethereum';
 import { EthCheatCodesWithState, startAnvil } from '@aztec/ethereum/test';
 import { asyncMap } from '@aztec/foundation/async-map';
@@ -35,6 +36,7 @@ import { resolver, reviver } from '@aztec/foundation/serialize';
 import { TestDateProvider } from '@aztec/foundation/timer';
 import type { ProverNode } from '@aztec/prover-node';
 import { type PXEService, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import type { SequencerClient } from '@aztec/sequencer-client';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { getConfigEnvVars as getTelemetryConfig, initTelemetryClient } from '@aztec/telemetry-client';
 import { getGenesisValues } from '@aztec/world-state/testing';
@@ -74,6 +76,7 @@ export type SubsystemsContext = {
   proverNode?: ProverNode;
   watcher: AnvilTestWatcher;
   cheatCodes: CheatCodes;
+  sequencer: SequencerClient;
   dateProvider: TestDateProvider;
   blobSink: BlobSinkServer;
   initialFundedAccounts: InitialAccountData[];
@@ -348,7 +351,7 @@ async function setupFromFresh(
   const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls);
 
   if (opts.l1StartTime) {
-    await ethCheatCodes.warp(opts.l1StartTime);
+    await ethCheatCodes.warp(opts.l1StartTime, { resetBlockInterval: true });
   }
 
   const initialFundedAccounts = await generateSchnorrAccounts(numberOfInitialFundedAccounts);
@@ -376,22 +379,24 @@ async function setupFromFresh(
   if (opts.fundRewardDistributor) {
     // Mints block rewards for 10000 blocks to the rewardDistributor contract
 
-    const rewardDistributor = getContract({
-      address: deployL1ContractsValues.l1ContractAddresses.rewardDistributorAddress.toString(),
-      abi: l1Artifacts.rewardDistributor.contractAbi,
-      client: deployL1ContractsValues.l1Client,
-    });
+    const rollup = new RollupContract(
+      deployL1ContractsValues.l1Client,
+      deployL1ContractsValues.l1ContractAddresses.rollupAddress,
+    );
 
-    const blockReward = await rewardDistributor.read.BLOCK_REWARD();
+    const blockReward = await rollup.getBlockReward();
     const mintAmount = 10_000n * (blockReward as bigint);
 
     const feeJuice = getContract({
       address: deployL1ContractsValues.l1ContractAddresses.feeJuiceAddress.toString(),
-      abi: l1Artifacts.feeAsset.contractAbi,
+      abi: FeeAssetArtifact.contractAbi,
       client: deployL1ContractsValues.l1Client,
     });
 
-    const rewardDistributorMintTxHash = await feeJuice.write.mint([rewardDistributor.address, mintAmount], {} as any);
+    const rewardDistributorMintTxHash = await feeJuice.write.mint(
+      [deployL1ContractsValues.l1ContractAddresses.rewardDistributorAddress.toString(), mintAmount],
+      {} as any,
+    );
     await deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: rewardDistributorMintTxHash });
     logger.info(`Funding rewardDistributor in ${rewardDistributorMintTxHash}`);
   }
@@ -443,11 +448,11 @@ async function setupFromFresh(
 
   let proverNode: ProverNode | undefined = undefined;
   if (opts.startProverNode) {
-    logger.verbose('Creating and syncing a simulated prover node...');
+    logger.verbose('Creating and syncing a simulated prover node with p2p disabled...');
     proverNode = await createAndSyncProverNode(
       `0x${proverNodePrivateKey!.toString('hex')}`,
       aztecNodeConfig,
-      { dataDirectory: path.join(directoryToCleanup, randomBytes(8).toString('hex')) },
+      { dataDirectory: path.join(directoryToCleanup, randomBytes(8).toString('hex')), p2pEnabled: false },
       aztecNode,
       prefilledPublicData,
     );
@@ -472,6 +477,7 @@ async function setupFromFresh(
     anvil,
     aztecNode,
     pxe,
+    sequencer: aztecNode.getSequencer()!,
     acvmConfig,
     bbConfig,
     deployL1ContractsValues,
@@ -590,6 +596,7 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
     anvil,
     aztecNode,
     pxe,
+    sequencer: aztecNode.getSequencer()!,
     acvmConfig,
     bbConfig,
     proverNode,
@@ -653,13 +660,13 @@ export async function publicDeployAccounts(
   const alreadyRegistered = (await sender.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered;
 
   const calls: ContractFunctionInteraction[] = await Promise.all([
-    ...(!alreadyRegistered ? [registerContractClass(sender, SchnorrAccountContractArtifact)] : []),
-    ...instances.map(instance => deployInstance(sender, instance!)),
+    ...(!alreadyRegistered ? [publishContractClass(sender, SchnorrAccountContractArtifact)] : []),
+    ...instances.map(instance => publishInstance(sender, instance!)),
   ]);
 
   const batch = new BatchCall(sender, calls);
 
-  const txReceipt = await batch.send().wait();
+  const txReceipt = await batch.send({ from: accountAddressesToDeploy[0] }).wait();
   if (waitUntilProven) {
     if (!pxeOrNode) {
       throw new Error('Need to provide a PXE or AztecNode to wait for proven.');

package/src/fixtures/token_utils.ts

@@ -3,15 +3,20 @@ import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
 // docs:start:token_utils
 
-export async function deployToken(adminWallet: Wallet, initialAdminBalance: bigint, logger: Logger) {
+export async function deployToken(
+  adminWallet: Wallet,
+  deployerAddress: AztecAddress,
+  initialAdminBalance: bigint,
+  logger: Logger,
+) {
   logger.info(`Deploying Token contract...`);
-  const contract = await TokenContract.deploy(adminWallet, adminWallet.getAddress(), 'TokenName', 'TokenSymbol', 18)
-    .send()
+  const contract = await TokenContract.deploy(adminWallet, deployerAddress, 'TokenName', 'TokenSymbol', 18)
+    .send({ from: deployerAddress })
     .deployed();
 
   if (initialAdminBalance > 0n) {
     // Minter is minting to herself so contract as minter is the same as contract as recipient
-    await mintTokensToPrivate(contract, adminWallet, adminWallet.getAddress(), initialAdminBalance);
+    await mintTokensToPrivate(contract, deployerAddress, adminWallet, deployerAddress, initialAdminBalance);
   }
 
   logger.info('L2 contract deployed');
@@ -21,13 +26,13 @@ export async function deployToken(adminWallet: Wallet, initialAdminBalance: bigi
 
 export async function mintTokensToPrivate(
   token: TokenContract,
+  minter: AztecAddress,
   minterWallet: Wallet,
   recipient: AztecAddress,
   amount: bigint,
 ) {
   const tokenAsMinter = await TokenContract.at(token.address, minterWallet);
-  const from = minterWallet.getAddress(); // we are setting from to minter here because we need a sender to calculate the tag
-  await tokenAsMinter.methods.mint_to_private(from, recipient, amount).send().wait();
+  await tokenAsMinter.methods.mint_to_private(recipient, amount).send({ from: minter }).wait();
 }
 // docs:end:token_utils
 
@@ -47,6 +52,7 @@ export async function expectTokenBalance(
 
 export async function mintNotes(
   sender: Wallet,
+  minter: AztecAddress,
   recipient: AztecAddress,
   asset: TokenContract,
   noteAmounts: bigint[],
@@ -56,9 +62,8 @@ export async function mintNotes(
   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();
+    const actions = toMint.map(amt => asset.methods.mint_to_private(recipient, amt));
+    await new BatchCall(sender, actions).send({ from: minter }).wait();
   }
 
   return noteAmounts.reduce((prev, curr) => prev + curr, 0n);