test: update get validators test to anvil

alxdca · alxdca · commit ef7101e7d3a6 · 2026-03-26T15:32:09.000+01:00
diff --git a/src/getValidators.integration.test.ts b/src/getValidators.integration.test.ts
@@ -7,21 +7,38 @@ import { rollupAdminLogicPublicActions } from './decorators/rollupAdminLogicPubl
 import {
   getInformationFromTestnode,
   getNitroTestnodePrivateKeyAccounts,
+  PrivateKeyAccountWithPrivateKey,
   testHelper_getRollupCreatorVersionFromEnv,
 } from './testHelpers';
 import { getValidators } from './getValidators';
+import { getAnvilTestStack, isAnvilTestMode } from './integrationTestHelpers/injectedMode';
 
-const { l3RollupOwner } = getNitroTestnodePrivateKeyAccounts();
-const { l3Rollup, l3UpgradeExecutor } = getInformationFromTestnode();
+const env = isAnvilTestMode() ? getAnvilTestStack() : undefined;
 
 const rollupCreatorVersion = testHelper_getRollupCreatorVersionFromEnv();
 // https://github.com/OffchainLabs/nitro-testnode/blob/release/test-node.bash#L634
 // https://github.com/OffchainLabs/nitro-contracts/blob/v3.2.0/scripts/rollupCreation.ts#L254-L261
 // https://github.com/OffchainLabs/nitro-contracts/blob/v2.1.3/scripts/rollupCreation.ts#L237-L243
 const expectedInitialValidators = rollupCreatorVersion === 'v3.2' ? 11 : 10;
 
-const client = createPublicClient({
-  chain: nitroTestnodeL2,
+let l3RollupOwner: PrivateKeyAccountWithPrivateKey;
+let l3Rollup: Address;
+let l3UpgradeExecutor: Address;
+
+if (env) {
+  l3RollupOwner = env.l3.accounts.rollupOwner;
+  l3Rollup = env.l3.rollup;
+  l3UpgradeExecutor = env.l3.upgradeExecutor;
+} else {
+  l3RollupOwner = getNitroTestnodePrivateKeyAccounts().l3RollupOwner;
+
+  const testNodeInformation = getInformationFromTestnode();
+  l3Rollup = testNodeInformation.l3Rollup;
+  l3UpgradeExecutor = testNodeInformation.l3UpgradeExecutor;
+}
+
+const l2Client = createPublicClient({
+  chain: env ? env.l2.chain : nitroTestnodeL2,
   transport: http(),
 }).extend(
   rollupAdminLogicPublicActions({
@@ -30,19 +47,19 @@ const client = createPublicClient({
 );
 
 async function setValidator(validator: Address, state: boolean) {
-  const tx = await client.rollupAdminLogicPrepareTransactionRequest({
+  const tx = await l2Client.rollupAdminLogicPrepareTransactionRequest({
     functionName: 'setValidator',
     args: [[validator], [state]],
     account: l3RollupOwner.address,
     upgradeExecutor: l3UpgradeExecutor,
     rollup: l3Rollup,
   });
 
-  const txHash = await client.sendRawTransaction({
+  const txHash = await l2Client.sendRawTransaction({
     serializedTransaction: await l3RollupOwner.signTransaction(tx),
   });
 
-  await client.waitForTransactionReceipt({
+  await l2Client.waitForTransactionReceipt({
     hash: txHash,
   });
 }
@@ -53,7 +70,7 @@ describe('successfully get validators', () => {
     const randomAccount = privateKeyToAccount(generatePrivateKey()).address;
 
     const { isAccurate: isAccurateInitially, validators: initialValidators } = await getValidators(
-      client,
+      l2Client,
       {
         rollup: l3Rollup,
       },
@@ -65,22 +82,25 @@ describe('successfully get validators', () => {
     await setValidator(randomAccount, false);
     await setValidator(randomAccount, false);
 
-    const { isAccurate: isStillAccurate, validators: newValidators } = await getValidators(client, {
-      rollup: l3Rollup,
-    });
+    const { isAccurate: isStillAccurate, validators: newValidators } = await getValidators(
+      l2Client,
+      {
+        rollup: l3Rollup,
+      },
+    );
     // Setting the same validator multiple time to false doesn't add new validators
     expect(newValidators).toEqual(initialValidators);
     expect(isStillAccurate).toBeTruthy();
 
     await setValidator(randomAccount, true);
-    const { validators, isAccurate } = await getValidators(client, { rollup: l3Rollup });
+    const { validators, isAccurate } = await getValidators(l2Client, { rollup: l3Rollup });
     expect(validators).toEqual(initialValidators.concat(randomAccount));
     expect(isAccurate).toBeTruthy();
 
     // Reset state for future tests
     await setValidator(randomAccount, false);
     const { isAccurate: isAccurateFinal, validators: validatorsFinal } = await getValidators(
-      client,
+      l2Client,
       {
         rollup: l3Rollup,
       },
@@ -93,7 +113,7 @@ describe('successfully get validators', () => {
     const randomAccount = privateKeyToAccount(generatePrivateKey()).address;
 
     const { isAccurate: isAccurateInitially, validators: initialValidators } = await getValidators(
-      client,
+      l2Client,
       {
         rollup: l3Rollup,
       },
@@ -104,23 +124,26 @@ describe('successfully get validators', () => {
 
     await setValidator(randomAccount, true);
     await setValidator(randomAccount, true);
-    const { isAccurate: isStillAccurate, validators: newValidators } = await getValidators(client, {
-      rollup: l3Rollup,
-    });
+    const { isAccurate: isStillAccurate, validators: newValidators } = await getValidators(
+      l2Client,
+      {
+        rollup: l3Rollup,
+      },
+    );
 
     expect(newValidators).toEqual(initialValidators.concat(randomAccount));
     expect(isStillAccurate).toBeTruthy();
 
     // Reset state for futures tests
     await setValidator(randomAccount, false);
-    const { validators, isAccurate } = await getValidators(client, { rollup: l3Rollup });
+    const { validators, isAccurate } = await getValidators(l2Client, { rollup: l3Rollup });
     expect(validators).toEqual(initialValidators);
     expect(isAccurate).toBeTruthy();
   });
 
   it('when adding an existing validator', async () => {
     const { isAccurate: isAccurateInitially, validators: initialValidators } = await getValidators(
-      client,
+      l2Client,
       { rollup: l3Rollup },
     );
 
@@ -130,14 +153,14 @@ describe('successfully get validators', () => {
     const firstValidator = initialValidators[0];
     await setValidator(firstValidator, true);
 
-    const { isAccurate, validators } = await getValidators(client, { rollup: l3Rollup });
+    const { isAccurate, validators } = await getValidators(l2Client, { rollup: l3Rollup });
     expect(validators).toEqual(initialValidators);
     expect(isAccurate).toBeTruthy();
   });
 
   it('when removing an existing validator', async () => {
     const { isAccurate: isAccurateInitially, validators: initialValidators } = await getValidators(
-      client,
+      l2Client,
       { rollup: l3Rollup },
     );
 
@@ -146,13 +169,13 @@ describe('successfully get validators', () => {
 
     const lastValidator = initialValidators[initialValidators.length - 1];
     await setValidator(lastValidator, false);
-    const { isAccurate, validators } = await getValidators(client, { rollup: l3Rollup });
+    const { isAccurate, validators } = await getValidators(l2Client, { rollup: l3Rollup });
     expect(validators).toEqual(initialValidators.slice(0, -1));
     expect(isAccurate).toBeTruthy();
 
     await setValidator(lastValidator, true);
     const { isAccurate: isAccurateFinal, validators: validatorsFinal } = await getValidators(
-      client,
+      l2Client,
       { rollup: l3Rollup },
     );
     expect(validatorsFinal).toEqual(initialValidators);
diff --git a/src/integrationTestHelpers/anvilHarness.ts b/src/integrationTestHelpers/anvilHarness.ts
@@ -22,6 +22,10 @@ import { ethers } from 'ethers';
 import TestWETH9 from '@arbitrum/token-bridge-contracts/build/contracts/contracts/tokenbridge/test/TestWETH9.sol/TestWETH9.json';
 
 import { registerCustomParentChain } from '../chains';
+import {
+  rollupCreatorABI,
+  rollupCreatorAddress as rollupCreatorV3Dot2Address,
+} from '../contracts/RollupCreator/v3.2';
 import { createRollup } from '../createRollup';
 import { createRollupPrepareDeploymentParamsConfig } from '../createRollupPrepareDeploymentParamsConfig';
 import { prepareChainConfig } from '../prepareChainConfig';
@@ -104,12 +108,41 @@ let cleanupHookRegistered = false;
 let teardownStarted = false;
 let l1RpcCachingProxy: RpcCachingProxy | undefined;
 
+const NITRO_TESTNODE_AUTHORIZED_VALIDATORS = 10;
+const NITRO_TESTNODE_VALIDATOR_SIGNER = '0x6A568afe0f82d34759347bb36F14A6bB171d2CBe' as Address;
+
 function prepareNitroRuntimeDir(runtimeDir: string) {
   chmodSync(runtimeDir, 0o777);
   mkdirSync(join(runtimeDir, 'nitro-data'), { recursive: true, mode: 0o777 });
   chmodSync(join(runtimeDir, 'nitro-data'), 0o777);
 }
 
+async function getNitroTestnodeStyleValidators(
+  publicClient: PublicClient<Transport, Chain>,
+  rollupCreator: Address,
+): Promise<Address[]> {
+  const validatorWalletCreator = await publicClient.readContract({
+    address: rollupCreator,
+    abi: rollupCreatorABI,
+    functionName: 'validatorWalletCreator',
+  });
+
+  const validators: Address[] = [];
+
+  for (let i = 1; i <= NITRO_TESTNODE_AUTHORIZED_VALIDATORS; i++) {
+    validators.push(
+      ethers.utils.getContractAddress({
+        from: validatorWalletCreator,
+        nonce: ethers.BigNumber.from(i).toHexString(),
+      }) as Address,
+    );
+  }
+
+  validators.push(NITRO_TESTNODE_VALIDATOR_SIGNER);
+
+  return validators;
+}
+
 export function dehydrateAnvilTestStack(env: AnvilTestStack): InjectedAnvilTestStack {
   return {
     ...env,
@@ -224,6 +257,11 @@ export async function setupAnvilTestStack(): Promise<AnvilTestStack> {
     });
 
     const l1RpcUrl = `http://127.0.0.1:${l1RpcPort}`;
+    const l1Client = createPublicClient({
+      chain: sepolia,
+      transport: http(l1RpcUrl),
+    });
+
     await waitForRpc({
       rpcUrl: l1RpcUrl,
       timeoutMs: 60_000,
@@ -242,7 +280,7 @@ export async function setupAnvilTestStack(): Promise<AnvilTestStack> {
     // Deploying L2 rollup contracts on L1
     console.log('Deploying L2 rollup contracts on L1...');
     const l2RollupConfig = createRollupPrepareDeploymentParamsConfig(
-      createPublicClient({ chain: sepolia, transport: http(l1RpcUrl) }),
+      l1Client,
       {
         chainId: BigInt(l2ChainId),
         owner: harnessDeployer.address,
@@ -266,15 +304,15 @@ export async function setupAnvilTestStack(): Promise<AnvilTestStack> {
       params: {
         config: l2RollupConfig,
         batchPosters: [harnessDeployer.address],
-        validators: [harnessDeployer.address],
+        validators: await getNitroTestnodeStyleValidators(
+          l1Client,
+          rollupCreatorV3Dot2Address[sepolia.id],
+        ),
         nativeToken: zeroAddress,
         maxFeePerGasForRetryables: parseGwei('0.1'),
       } as CreateRollupParams<'v3.2'>,
       account: harnessDeployer,
-      parentChainPublicClient: createPublicClient({
-        chain: sepolia,
-        transport: http(l1RpcUrl),
-      }),
+      parentChainPublicClient: l1Client,
       rollupCreatorVersion: 'v3.2',
     });
     console.log('L2 rollup contracts deployed on L1\n');
@@ -471,7 +509,7 @@ export async function setupAnvilTestStack(): Promise<AnvilTestStack> {
       params: {
         config: l3RollupConfig,
         batchPosters: [harnessDeployer.address],
-        validators: [harnessDeployer.address],
+        validators: await getNitroTestnodeStyleValidators(l2Client, l2RollupCreator),
         nativeToken: customGasToken.address as Address,
         maxDataSize: 104_857n,
       } as CreateRollupParams<'v3.2'>,
diff --git a/vitest.integration.anvil.config.ts b/vitest.integration.anvil.config.ts
@@ -18,6 +18,7 @@ export default mergeConfig(
         './src/createRollup.integration.test.ts',
         './src/decorators/arbAggregatorActions.integration.test.ts',
         './src/getBatchPosters.integration.test.ts',
+        './src/getValidators.integration.test.ts',
       ],
       fileParallelism: false,
     },
