@aztec/end-to-end 0.0.1-commit.2ed92850 → 0.0.1-commit.3d8f95d

package/src/e2e_deploy_contract/deploy_test.ts

@@ -30,9 +30,9 @@ export class DeployTest {
       fundSponsoredFPC: true,
       skipAccountDeployment: true,
     });
-    this.aztecNode = this.context.aztecNodeService!;
+    this.aztecNode = this.context.aztecNodeService;
     this.wallet = this.context.wallet;
-    this.aztecNodeAdmin = this.context.aztecNodeService!;
+    this.aztecNodeAdmin = this.context.aztecNodeService;
     await this.applyInitialAccount();
     return this;
   }

package/src/e2e_epochs/epochs_test.ts

@@ -14,13 +14,15 @@ import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto/random';
-import { withLogNameSuffix } from '@aztec/foundation/log';
+import { withLoggerBindings } from '@aztec/foundation/log/server';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
+import { TestContract } from '@aztec/noir-test-contracts.js/Test';
 import { getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
 import { ProverNode, type ProverNodeConfig, ProverNodePublisher } from '@aztec/prover-node';
 import type { TestProverNode } from '@aztec/prover-node/test';
+import type { PXEConfig } from '@aztec/pxe/config';
 import {
   type SequencerClient,
   type SequencerEvents,
@@ -49,7 +51,11 @@ export const WORLD_STATE_BLOCK_CHECK_INTERVAL = 50;
 export const ARCHIVER_POLL_INTERVAL = 50;
 export const DEFAULT_L1_BLOCK_TIME = process.env.CI ? 12 : 8;
 
-export type EpochsTestOpts = Partial<SetupOptions> & { numberOfAccounts?: number };
+export type EpochsTestOpts = Partial<SetupOptions> & {
+  numberOfAccounts?: number;
+  pxeOpts?: Partial<PXEConfig>;
+  aztecSlotDurationInL1Slots?: number;
+};
 
 export type TrackedSequencerEvent = {
   [K in keyof SequencerEvents]: Parameters<SequencerEvents[K]>[0] & {
@@ -94,7 +100,7 @@ export class EpochsTestContext {
       ? parseInt(process.env.L1_BLOCK_TIME)
       : DEFAULT_L1_BLOCK_TIME;
     const ethereumSlotDuration = opts.ethereumSlotDuration ?? envEthereumSlotDuration;
-    const aztecSlotDuration = opts.aztecSlotDuration ?? ethereumSlotDuration * 2;
+    const aztecSlotDuration = opts.aztecSlotDuration ?? (opts.aztecSlotDurationInL1Slots ?? 2) * ethereumSlotDuration;
     const aztecEpochDuration = opts.aztecEpochDuration ?? 6;
     const aztecProofSubmissionEpochs = opts.aztecProofSubmissionEpochs ?? 1;
     const l1PublishingTime = opts.l1PublishingTime ?? 1;
@@ -147,8 +153,9 @@ export class EpochsTestContext {
         l1PublishingTime,
         ...opts,
       },
-      // Use checkpointed chain tip for PXE to avoid issues with blocks being dropped due to pruned anchor blocks.
-      { syncChainTip: 'checkpointed' },
+      // Use checkpointed chain tip for PXE by default to avoid issues with blocks being dropped due to pruned anchor blocks.
+      // Can be overridden via opts.pxeOpts.
+      { syncChainTip: 'checkpointed', ...opts.pxeOpts },
     );
 
     this.context = context;
@@ -187,6 +194,7 @@ export class EpochsTestContext {
       l1GenesisTime: await this.rollup.getL1GenesisTime(),
       ethereumSlotDuration,
       proofSubmissionEpochs: Number(await this.rollup.getProofSubmissionEpochs()),
+      targetCommitteeSize: await this.rollup.getTargetCommitteeSize(),
     };
 
     this.logger.info(
@@ -204,20 +212,29 @@ export class EpochsTestContext {
   public async createProverNode(opts: { dontStart?: boolean } & Partial<ProverNodeConfig> = {}) {
     this.logger.warn('Creating and syncing a simulated prover node...');
     const proverNodePrivateKey = this.getNextPrivateKey();
-    const suffix = (this.proverNodes.length + 1).toString();
-    const proverNode = await withLogNameSuffix(suffix, () =>
+    const proverIndex = this.proverNodes.length + 1;
+    const { mockGossipSubNetwork } = this.context;
+    const proverNode = await withLoggerBindings({ actor: `prover-${proverIndex}` }, () =>
       createAndSyncProverNode(
         proverNodePrivateKey,
-        { ...this.context.config },
+        {
+          ...this.context.config,
+          p2pEnabled: this.context.config.p2pEnabled || mockGossipSubNetwork !== undefined,
+        },
         {
           dataDirectory: join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')),
-          proverId: EthAddress.fromNumber(parseInt(suffix, 10)),
+          proverId: EthAddress.fromNumber(proverIndex),
           dontStart: opts.dontStart,
           ...opts,
         },
         this.context.aztecNode,
         this.context.prefilledPublicData ?? [],
-        { dateProvider: this.context.dateProvider },
+        {
+          dateProvider: this.context.dateProvider,
+          p2pClientDeps: mockGossipSubNetwork
+            ? { p2pServiceFactory: getMockPubSubP2PServiceFactory(mockGossipSubNetwork) }
+            : undefined,
+        },
       ),
     );
     this.proverNodes.push(proverNode);
@@ -240,12 +257,13 @@ export class EpochsTestContext {
   private async createNode(
     opts: Partial<AztecNodeConfig> & { txDelayerMaxInclusionTimeIntoSlot?: number; dontStartSequencer?: boolean } = {},
   ) {
-    const suffix = (this.nodes.length + 1).toString();
+    const nodeIndex = this.nodes.length + 1;
+    const actorPrefix = opts.disableValidator ? 'node' : 'validator';
     const { mockGossipSubNetwork } = this.context;
     const resolvedConfig = { ...this.context.config, ...opts };
     const p2pEnabled = resolvedConfig.p2pEnabled || mockGossipSubNetwork !== undefined;
     const p2pIp = resolvedConfig.p2pIp ?? (p2pEnabled ? '127.0.0.1' : undefined);
-    const node = await withLogNameSuffix(suffix, () =>
+    const node = await withLoggerBindings({ actor: `${actorPrefix}-${nodeIndex}` }, () =>
       AztecNodeService.createAndSync(
         {
           ...resolvedConfig,
@@ -375,6 +393,19 @@ export class EpochsTestContext {
     return SpamContract.at(instance.address, wallet);
   }
 
+  /** Registers the TestContract on the given wallet. */
+  public async registerTestContract(wallet: Wallet, salt = Fr.ZERO) {
+    const instance = await getContractInstanceFromInstantiationParams(TestContract.artifact, {
+      constructorArgs: [],
+      constructorArtifact: undefined,
+      salt,
+      publicKeys: undefined,
+      deployer: undefined,
+    });
+    await wallet.registerContract(instance, TestContract.artifact);
+    return TestContract.at(instance.address, wallet);
+  }
+
   /** Creates an L1 client using a fresh account with funds from anvil, with a tx delayer already set up. */
   public async createL1Client() {
     const { client, delayer } = withDelayer(
@@ -383,7 +414,7 @@ export class EpochsTestContext {
         privateKeyToAccount(this.getNextPrivateKey()),
         this.l1Client.chain,
       ),
-      this.context.dateProvider!,
+      this.context.dateProvider,
       { ethereumSlotDuration: this.L1_BLOCK_TIME_IN_S },
     );
     expect(await client.getBalance({ address: client.account.address })).toBeGreaterThan(0n);

package/src/e2e_fees/fees_test.ts

@@ -113,7 +113,7 @@ export class FeesTest {
     });
 
     this.rollupContract = RollupContract.getFromConfig(this.context.config);
-    this.chainMonitor = new ChainMonitor(this.rollupContract, this.context.dateProvider!, this.logger, 200).start();
+    this.chainMonitor = new ChainMonitor(this.rollupContract, this.context.dateProvider, this.logger, 200).start();
 
     await this.applyBaseSetup();
 
@@ -126,7 +126,7 @@ export class FeesTest {
   }
 
   setIsMarkingAsProven(b: boolean) {
-    this.context.watcher!.setIsMarkingAsProven(b);
+    this.context.watcher.setIsMarkingAsProven(b);
   }
 
   async catchUpProvenChain() {
@@ -188,8 +188,8 @@ export class FeesTest {
     });
 
     this.wallet = this.context.wallet;
-    this.aztecNode = this.context.aztecNodeService!;
-    this.aztecNodeAdmin = this.context.aztecNodeService!;
+    this.aztecNode = this.context.aztecNodeService;
+    this.aztecNodeAdmin = this.context.aztecNodeService;
     this.gasSettings = GasSettings.default({ maxFeesPerGas: (await this.aztecNode.getCurrentMinFees()).mul(2) });
     this.cheatCodes = this.context.cheatCodes;
     this.accounts = deployedAccounts.map(a => a.address);
@@ -221,8 +221,8 @@ export class FeesTest {
     );
 
     this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
-      aztecNode: this.context.aztecNodeService!,
-      aztecNodeAdmin: this.context.aztecNodeService!,
+      aztecNode: this.context.aztecNodeService,
+      aztecNodeAdmin: this.context.aztecNodeService,
       l1Client: this.context.deployL1ContractsValues.l1Client,
       wallet: this.wallet,
       logger: this.logger,

package/src/e2e_l1_publisher/write_json.ts

@@ -15,6 +15,7 @@ const AZTEC_GENERATE_TEST_DATA = !!process.env.AZTEC_GENERATE_TEST_DATA;
  */
 export async function writeJson(
   fileName: string,
+  checkpointHeader: CheckpointHeader,
   block: L2Block,
   l1ToL2Content: Fr[],
   blobs: Blob[],
@@ -33,12 +34,6 @@ export async function writeJson(
     return `0x${buffer.toString('hex').padStart(size, '0')}`;
   };
 
-  // Create a checkpoint header for this block
-  const checkpointHeader = CheckpointHeader.random({
-    slotNumber: block.slot,
-    timestamp: block.timestamp,
-  });
-
   const jsonObject = {
     populate: {
       l1ToL2Content: l1ToL2Content.map(value => asHex(value)),

package/src/e2e_nested_contract/nested_contract_test.ts

@@ -44,7 +44,7 @@ export class NestedContractTest {
     });
     this.wallet = this.context.wallet;
     [{ address: this.defaultAccountAddress }] = deployedAccounts;
-    this.aztecNode = this.context.aztecNodeService!;
+    this.aztecNode = this.context.aztecNodeService;
 
     this.logger.info('Public deploy accounts');
     await publicDeployAccounts(this.wallet, [this.defaultAccountAddress]);

package/src/e2e_p2p/inactivity_slash_test.ts

@@ -98,13 +98,13 @@ export class P2PInactivityTest {
     this.rollup = rollup;
 
     if (!this.keepInitialNode) {
-      await this.test.ctx.aztecNodeService!.stop();
+      await this.test.ctx.aztecNodeService.stop();
     }
 
     // Create all active nodes
     this.activeNodes = await createNodes(
       this.test.ctx.aztecNodeConfig,
-      this.test.ctx.dateProvider!,
+      this.test.ctx.dateProvider,
       this.test.bootstrapNodeEnr,
       NUM_NODES - this.inactiveNodeCount - Number(this.keepInitialNode),
       BOOT_NODE_UDP_PORT,
@@ -118,7 +118,7 @@ export class P2PInactivityTest {
     const inactiveConfig = { ...this.test.ctx.aztecNodeConfig, dontStartSequencer: true };
     this.inactiveNodes = await createNodes(
       inactiveConfig,
-      this.test.ctx.dateProvider!,
+      this.test.ctx.dateProvider,
       this.test.bootstrapNodeEnr,
       this.inactiveNodeCount,
       BOOT_NODE_UDP_PORT,
@@ -129,7 +129,7 @@ export class P2PInactivityTest {
     );
 
     this.nodes = [
-      ...(this.keepInitialNode ? [this.test.ctx.aztecNodeService!] : []),
+      ...(this.keepInitialNode ? [this.test.ctx.aztecNodeService] : []),
       ...this.activeNodes,
       ...this.inactiveNodes,
     ];

package/src/e2e_p2p/p2p_network.ts

@@ -333,9 +333,9 @@ export class P2PNetworkTest {
     const block = await this.context.deployL1ContractsValues.l1Client.getBlock({
       blockNumber: receipt.blockNumber,
     });
-    this.context.dateProvider!.setTime(Number(block.timestamp) * 1000);
+    this.context.dateProvider.setTime(Number(block.timestamp) * 1000);
 
-    await this.context.aztecNodeService!.stop();
+    await this.context.aztecNodeService.stop();
   }
 
   async sendDummyTx() {
@@ -374,8 +374,8 @@ export class P2PNetworkTest {
     this.prefilledPublicData = prefilledPublicData;
 
     const rollupContract = RollupContract.getFromL1ContractsValues(this.context.deployL1ContractsValues);
-    this.monitor = new ChainMonitor(rollupContract, this.context.dateProvider!).start();
-    this.monitor.on('l1-block', ({ timestamp }) => this.context.dateProvider!.setTime(Number(timestamp) * 1000));
+    this.monitor = new ChainMonitor(rollupContract, this.context.dateProvider).start();
+    this.monitor.on('l1-block', ({ timestamp }) => this.context.dateProvider.setTime(Number(timestamp) * 1000));
   }
 
   async stopNodes(nodes: AztecNodeService[]) {

package/src/e2e_p2p/reqresp/utils.ts

@@ -0,0 +1,207 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import { createLogger } from '@aztec/aztec.js/log';
+import { waitForTx } from '@aztec/aztec.js/node';
+import { Tx } from '@aztec/aztec.js/tx';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { timesAsync } from '@aztec/foundation/collection';
+import { retryUntil } from '@aztec/foundation/retry';
+
+import { jest } from '@jest/globals';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { shouldCollectMetrics } from '../../fixtures/fixtures.js';
+import { createNodes } from '../../fixtures/setup_p2p_test.js';
+import { P2PNetworkTest, SHORTENED_BLOCK_TIME_CONFIG_NO_PRUNES, WAIT_FOR_TX_TIMEOUT } from '../p2p_network.js';
+import { prepareTransactions } from '../shared.js';
+
+// Don't set this to a higher value than 9 because each node will use a different L1 publisher account and anvil seeds
+export const NUM_VALIDATORS = 6;
+export const NUM_TXS_PER_NODE = 2;
+export const BOOT_NODE_UDP_PORT = 4500;
+
+export const createReqrespDataDir = () => fs.mkdtempSync(path.join(os.tmpdir(), 'reqresp-'));
+
+type ReqrespOptions = {
+  disableStatusHandshake?: boolean;
+};
+
+export async function createReqrespTest(options: ReqrespOptions = {}): Promise<P2PNetworkTest> {
+  const { disableStatusHandshake = false } = options;
+  const t = await P2PNetworkTest.create({
+    testName: 'e2e_p2p_reqresp_tx',
+    numberOfNodes: 0,
+    numberOfValidators: NUM_VALIDATORS,
+    basePort: BOOT_NODE_UDP_PORT,
+    // To collect metrics - run in aztec-packages `docker compose --profile metrics up`
+    metricsPort: shouldCollectMetrics(),
+    initialConfig: {
+      ...SHORTENED_BLOCK_TIME_CONFIG_NO_PRUNES,
+      aztecSlotDuration: 24,
+      ...(disableStatusHandshake ? { p2pDisableStatusHandshake: true } : {}),
+      listenAddress: '127.0.0.1',
+      aztecEpochDuration: 64, // stable committee
+    },
+  });
+  await t.setup();
+  await t.applyBaseSetup();
+  return t;
+}
+
+export async function cleanupReqrespTest(params: { t: P2PNetworkTest; nodes?: AztecNodeService[]; dataDir: string }) {
+  const { t, nodes, dataDir } = params;
+  if (nodes) {
+    await t.stopNodes(nodes);
+  }
+  await t.teardown();
+  for (let i = 0; i < NUM_VALIDATORS; i++) {
+    fs.rmSync(`${dataDir}-${i}`, { recursive: true, force: true, maxRetries: 3 });
+  }
+}
+
+const getNodePort = (nodeIndex: number) => BOOT_NODE_UDP_PORT + 1 + nodeIndex;
+
+export async function runReqrespTxTest(params: {
+  t: P2PNetworkTest;
+  dataDir: string;
+  disableStatusHandshake?: boolean;
+}): Promise<AztecNodeService[]> {
+  const { t, dataDir, disableStatusHandshake = false } = params;
+
+  if (!t.bootstrapNodeEnr) {
+    throw new Error('Bootstrap node ENR is not available');
+  }
+
+  t.logger.info('Creating nodes');
+  const aztecNodeConfig = disableStatusHandshake
+    ? { ...t.ctx.aztecNodeConfig, p2pDisableStatusHandshake: true }
+    : t.ctx.aztecNodeConfig;
+
+  const nodes = await createNodes(
+    aztecNodeConfig,
+    t.ctx.dateProvider,
+    t.bootstrapNodeEnr,
+    NUM_VALIDATORS,
+    BOOT_NODE_UDP_PORT,
+    t.prefilledPublicData,
+    dataDir,
+    shouldCollectMetrics(),
+  );
+
+  t.logger.info('Waiting for nodes to connect');
+  await t.waitForP2PMeshConnectivity(nodes, NUM_VALIDATORS);
+
+  await t.setupAccount();
+
+  const targetBlockNumber = await t.ctx.aztecNodeService.getBlockNumber();
+  await retryUntil(
+    async () => {
+      const blockNumbers = await Promise.all(nodes.map(node => node.getBlockNumber()));
+      return blockNumbers.every(blockNumber => blockNumber >= targetBlockNumber) ? true : undefined;
+    },
+    `validators to sync to L2 block ${targetBlockNumber}`,
+    60,
+    0.5,
+  );
+
+  t.logger.info('Preparing transactions to send');
+  const txBatches = await timesAsync(2, () =>
+    prepareTransactions(t.logger, t.ctx.aztecNodeService, NUM_TXS_PER_NODE, t.fundedAccount),
+  );
+
+  t.logger.info('Removing initial node');
+  await t.removeInitialNode();
+
+  t.logger.info('Starting fresh slot');
+  const [timestamp] = await t.ctx.cheatCodes.rollup.advanceToNextSlot();
+  t.ctx.dateProvider.setTime(Number(timestamp) * 1000);
+  const startSlotTimestamp = BigInt(timestamp);
+
+  const { proposerIndexes, nodesToTurnOffTxGossip } = await getProposerIndexes(t, startSlotTimestamp);
+  t.logger.info(`Turning off tx gossip for nodes: ${nodesToTurnOffTxGossip.map(getNodePort)}`);
+  t.logger.info(`Sending txs to proposer nodes: ${proposerIndexes.map(getNodePort)}`);
+
+  // Replace the p2p node implementation of some of the nodes with a spy such that it does not store transactions that are gossiped to it
+  // Original implementation of `handleGossipedTx` will store received transactions in the tx pool.
+  // We chose the first 2 nodes that will be the proposers for the next few slots
+  for (const nodeIndex of nodesToTurnOffTxGossip) {
+    const logger = createLogger(`p2p:${getNodePort(nodeIndex)}`);
+    jest.spyOn((nodes[nodeIndex] as any).p2pClient.p2pService, 'handleGossipedTx').mockImplementation(((
+      payloadData: Buffer,
+    ) => {
+      const txHash = Tx.fromBuffer(payloadData).getTxHash();
+      logger.info(`Skipping storage of gossiped transaction ${txHash.toString()}`);
+      return Promise.resolve();
+    }) as any);
+  }
+
+  // We send the tx to the proposer nodes directly, ignoring the pxe and node in each context
+  // We cannot just call tx.send since they were created using a pxe wired to the first node which is now stopped
+  t.logger.info('Sending transactions through proposer nodes');
+  const submittedTxs = await Promise.all(
+    txBatches.map(async (batch, batchIndex) => {
+      const proposerNode = nodes[proposerIndexes[batchIndex]];
+      await Promise.all(
+        batch.map(async tx => {
+          try {
+            await proposerNode.sendTx(tx);
+          } catch (err) {
+            t.logger.error(`Error sending tx: ${err}`);
+            throw err;
+          }
+        }),
+      );
+      return batch.map(tx => ({ node: proposerNode, txHash: tx.getTxHash() }));
+    }),
+  );
+
+  t.logger.info('Waiting for all transactions to be mined');
+  await Promise.all(
+    submittedTxs.flatMap((batch, batchIndex) =>
+      batch.map(async (submittedTx, txIndex) => {
+        t.logger.info(`Waiting for tx ${batchIndex}-${txIndex} ${submittedTx.txHash.toString()} to be mined`);
+        await waitForTx(submittedTx.node, submittedTx.txHash, { timeout: WAIT_FOR_TX_TIMEOUT * 1.5 });
+        t.logger.info(`Tx ${batchIndex}-${txIndex} ${submittedTx.txHash.toString()} has been mined`);
+      }),
+    ),
+  );
+
+  t.logger.info('All transactions mined');
+
+  return nodes;
+}
+
+async function getProposerIndexes(t: P2PNetworkTest, startSlotTimestamp: bigint) {
+  // Get the nodes for the next set of slots
+  const rollupContract = new RollupContract(
+    t.ctx.deployL1ContractsValues.l1Client,
+    t.ctx.deployL1ContractsValues.l1ContractAddresses.rollupAddress,
+  );
+
+  const attesters = await rollupContract.getAttesters();
+  const startSlot = await rollupContract.getSlotAt(startSlotTimestamp);
+
+  const proposers = await Promise.all(
+    Array.from({ length: 3 }, async (_, i) => {
+      const slot = SlotNumber(startSlot + i);
+      const slotTimestamp = await rollupContract.getTimestampForSlot(slot);
+      return await rollupContract.getProposerAt(slotTimestamp);
+    }),
+  );
+  // Get the indexes of the nodes that are responsible for the next two slots
+  const proposerIndexes = proposers.map(proposer => attesters.findIndex(a => a.equals(proposer)));
+
+  if (proposerIndexes.some(i => i === -1)) {
+    throw new Error(
+      `Proposer index not found for proposer ` +
+        `(proposers=${proposers.map(p => p.toString()).join(',')}, indices=${proposerIndexes.join(',')})`,
+    );
+  }
+
+  const nodesToTurnOffTxGossip = Array.from({ length: NUM_VALIDATORS }, (_, i) => i).filter(
+    i => !proposerIndexes.includes(i),
+  );
+  return { proposerIndexes, nodesToTurnOffTxGossip };
+}

package/src/e2e_p2p/shared.ts

@@ -56,7 +56,11 @@ export const submitTransactions = async (
 ): Promise<TxHash[]> => {
   const rpcConfig = getRpcConfig();
   rpcConfig.proverEnabled = false;
-  const wallet = await TestWallet.create(node, { ...getPXEConfig(), proverEnabled: false }, { useLogSuffix: true });
+  const wallet = await TestWallet.create(
+    node,
+    { ...getPXEConfig(), proverEnabled: false },
+    { loggerActorLabel: 'pxe-tx' },
+  );
   const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
   return submitTxsTo(wallet, fundedAccountManager.address, numTxs, logger);
 };
@@ -70,7 +74,11 @@ export async function prepareTransactions(
   const rpcConfig = getRpcConfig();
   rpcConfig.proverEnabled = false;
 
-  const wallet = await TestWallet.create(node, { ...getPXEConfig(), proverEnabled: false }, { useLogSuffix: true });
+  const wallet = await TestWallet.create(
+    node,
+    { ...getPXEConfig(), proverEnabled: false },
+    { loggerActorLabel: 'pxe-tx' },
+  );
   const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
 
   const testContractInstance = await getContractInstanceFromInstantiationParams(TestContractArtifact, {
@@ -137,6 +145,7 @@ export async function awaitCommitteeExists({
     'non-empty committee',
     60,
   );
+  logger.warn(`Committee has been formed`, { committee: committee!.map(c => c.toString()) });
   return committee!.map(c => c.toString() as `0x${string}`);
 }