test: update updateExecutor and arbOwner test to anvil

alxdca · alxdca · commit 1dcdf2a92051 · 2026-03-26T15:48:28.000+01:00
diff --git a/src/decorators/arbOwnerPublicActions.integration.test.ts b/src/decorators/arbOwnerPublicActions.integration.test.ts
@@ -5,58 +5,67 @@ import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 import { nitroTestnodeL2 } from '../chains';
 import { arbOwnerPublicActions } from './arbOwnerPublicActions';
 import { getNitroTestnodePrivateKeyAccounts } from '../testHelpers';
+import { getAnvilTestStack, isAnvilTestMode } from '../integrationTestHelpers/injectedMode';
+import { PrivateKeyAccount } from 'viem/accounts';
 
-// l2 owner private key
-const devPrivateKey = getNitroTestnodePrivateKeyAccounts().l2RollupOwner.privateKey;
+const env = isAnvilTestMode() ? getAnvilTestStack() : undefined;
 
-const owner = privateKeyToAccount(devPrivateKey);
 const randomAccount = privateKeyToAccount(generatePrivateKey());
 
-const client = createPublicClient({
-  chain: nitroTestnodeL2,
+let l2RollupOwner: PrivateKeyAccount;
+
+if (env) {
+  l2RollupOwner = env.l2.accounts.rollupOwner;
+} else {
+  const devPrivateKey = getNitroTestnodePrivateKeyAccounts().l2RollupOwner.privateKey;
+  l2RollupOwner = privateKeyToAccount(devPrivateKey);
+}
+
+const l2Client = createPublicClient({
+  chain: env ? env.l2.chain : nitroTestnodeL2,
   transport: http(),
 }).extend(arbOwnerPublicActions);
 
 it('successfully fetches network fee receiver', async () => {
-  const result = await client.arbOwnerReadContract({
+  const result = await l2Client.arbOwnerReadContract({
     functionName: 'getNetworkFeeAccount',
   });
 
-  expect(result).toEqual(owner.address);
+  expect(result).toEqual(l2RollupOwner.address);
 });
 
 it('succesfully fetches chain owners', async () => {
-  const result = await client.arbOwnerReadContract({
+  const result = await l2Client.arbOwnerReadContract({
     functionName: 'getAllChainOwners',
   });
 
-  expect(result).toContain(owner.address);
+  expect(result).toContain(l2RollupOwner.address);
 });
 
 it('succesfully adds chain owner', async () => {
-  const isOwnerInitially = await client.arbOwnerReadContract({
+  const isOwnerInitially = await l2Client.arbOwnerReadContract({
     functionName: 'isChainOwner',
     args: [randomAccount.address],
   });
 
   // assert account is not already an owner
   expect(isOwnerInitially).toEqual(false);
 
-  const transactionRequest = await client.arbOwnerPrepareTransactionRequest({
+  const transactionRequest = await l2Client.arbOwnerPrepareTransactionRequest({
     functionName: 'addChainOwner',
     args: [randomAccount.address],
     upgradeExecutor: false,
-    account: owner.address,
+    account: l2RollupOwner.address,
   });
 
   // submit tx to add chain owner
-  const txHash = await client.sendRawTransaction({
-    serializedTransaction: await owner.signTransaction(transactionRequest),
+  const txHash = await l2Client.sendRawTransaction({
+    serializedTransaction: await l2RollupOwner.signTransaction(transactionRequest),
   });
 
-  await client.waitForTransactionReceipt({ hash: txHash });
+  await l2Client.waitForTransactionReceipt({ hash: txHash });
 
-  const isOwner = await client.arbOwnerReadContract({
+  const isOwner = await l2Client.arbOwnerReadContract({
     functionName: 'isChainOwner',
     args: [randomAccount.address],
   });
@@ -66,29 +75,29 @@ it('succesfully adds chain owner', async () => {
 });
 
 it('succesfully removes chain owner', async () => {
-  const isOwnerInitially = await client.arbOwnerReadContract({
+  const isOwnerInitially = await l2Client.arbOwnerReadContract({
     functionName: 'isChainOwner',
     args: [randomAccount.address],
   });
 
   // assert account is an owner
   expect(isOwnerInitially).toEqual(true);
 
-  const transactionRequest = await client.arbOwnerPrepareTransactionRequest({
+  const transactionRequest = await l2Client.arbOwnerPrepareTransactionRequest({
     functionName: 'removeChainOwner',
     args: [randomAccount.address],
     upgradeExecutor: false,
-    account: owner.address,
+    account: l2RollupOwner.address,
   });
 
   // submit tx to remove chain owner
-  const txHash = await client.sendRawTransaction({
-    serializedTransaction: await owner.signTransaction(transactionRequest),
+  const txHash = await l2Client.sendRawTransaction({
+    serializedTransaction: await l2RollupOwner.signTransaction(transactionRequest),
   });
 
-  await client.waitForTransactionReceipt({ hash: txHash });
+  await l2Client.waitForTransactionReceipt({ hash: txHash });
 
-  const isOwner = await client.arbOwnerReadContract({
+  const isOwner = await l2Client.arbOwnerReadContract({
     functionName: 'isChainOwner',
     args: [randomAccount.address],
   });
@@ -98,28 +107,28 @@ it('succesfully removes chain owner', async () => {
 });
 
 it('succesfully updates infra fee receiver', async () => {
-  const initialInfraFeeReceiver = await client.arbOwnerReadContract({
+  const initialInfraFeeReceiver = await l2Client.arbOwnerReadContract({
     functionName: 'getInfraFeeAccount',
   });
 
   // assert account is not already infra fee receiver
   expect(initialInfraFeeReceiver).not.toEqual(randomAccount.address);
 
-  const transactionRequest = await client.arbOwnerPrepareTransactionRequest({
+  const transactionRequest = await l2Client.arbOwnerPrepareTransactionRequest({
     functionName: 'setInfraFeeAccount',
     args: [randomAccount.address],
     upgradeExecutor: false,
-    account: owner.address,
+    account: l2RollupOwner.address,
   });
 
   // submit tx to update infra fee receiver
-  const txHash = await client.sendRawTransaction({
-    serializedTransaction: await owner.signTransaction(transactionRequest),
+  const txHash = await l2Client.sendRawTransaction({
+    serializedTransaction: await l2RollupOwner.signTransaction(transactionRequest),
   });
 
-  await client.waitForTransactionReceipt({ hash: txHash });
+  await l2Client.waitForTransactionReceipt({ hash: txHash });
 
-  const infraFeeReceiver = await client.arbOwnerReadContract({
+  const infraFeeReceiver = await l2Client.arbOwnerReadContract({
     functionName: 'getInfraFeeAccount',
   });
 
diff --git a/src/integrationTestHelpers/anvilHarness.ts b/src/integrationTestHelpers/anvilHarness.ts
@@ -60,12 +60,17 @@ import type { CustomTimingParams, PrivateKeyAccountWithPrivateKey } from '../tes
 type RegisteredParentChain = Parameters<typeof registerCustomParentChain>[0];
 
 type BaseStack<L2Accounts, L3Accounts> = {
+  l1: {
+    rpcUrl: string;
+    chain: Chain;
+  };
   l2: {
     rpcUrl: string;
     chain: Chain;
     accounts: L2Accounts;
     timingParams: CustomTimingParams;
     rollupCreatorVersion: RollupCreatorSupportedVersion;
+    upgradeExecutor: Address;
   };
   l3: {
     accounts: L3Accounts;
@@ -81,6 +86,7 @@ type BaseStack<L2Accounts, L3Accounts> = {
 
 export type AnvilTestStack = BaseStack<
   {
+    rollupOwner: PrivateKeyAccountWithPrivateKey;
     deployer: PrivateKeyAccountWithPrivateKey;
   },
   {
@@ -91,6 +97,7 @@ export type AnvilTestStack = BaseStack<
 
 export type InjectedAnvilTestStack = BaseStack<
   {
+    rollupOwnerPrivateKey: Hex;
     deployerPrivateKey: Hex;
   },
   {
@@ -150,6 +157,7 @@ export function dehydrateAnvilTestStack(env: AnvilTestStack): InjectedAnvilTestS
     l2: {
       ...env.l2,
       accounts: {
+        rollupOwnerPrivateKey: env.l2.accounts.rollupOwner.privateKey,
         deployerPrivateKey: env.l2.accounts.deployer.privateKey,
       },
     },
@@ -173,6 +181,7 @@ export function hydrateAnvilTestStack(env: InjectedAnvilTestStack): AnvilTestSta
       ...env.l2,
       chain: l2Chain,
       accounts: {
+        rollupOwner: createAccount(env.l2.accounts.rollupOwnerPrivateKey),
         deployer: createAccount(env.l2.accounts.deployerPrivateKey),
       },
     },
@@ -258,8 +267,15 @@ export async function setupAnvilTestStack(): Promise<AnvilTestStack> {
     });
 
     const l1RpcUrl = `http://127.0.0.1:${l1RpcPort}`;
+    const l1Chain = defineChain({
+      ...sepolia,
+      rpcUrls: {
+        default: { http: [l1RpcUrl] },
+        public: { http: [l1RpcUrl] },
+      },
+    });
     const l1Client = createPublicClient({
-      chain: sepolia,
+      chain: l1Chain,
       transport: http(l1RpcUrl),
     });
 
@@ -537,14 +553,20 @@ export async function setupAnvilTestStack(): Promise<AnvilTestStack> {
     console.log('L3 rollup contracts deployed on L2\n');
 
     initializedEnv = {
+      l1: {
+        rpcUrl: l1RpcUrl,
+        chain: l1Chain,
+      },
       l2: {
         rpcUrl: l2RpcUrl,
         chain: l2Chain,
         accounts: {
+          rollupOwner: harnessDeployer,
           deployer: harnessDeployer,
         },
         timingParams: rollupTimingParams,
         rollupCreatorVersion,
+        upgradeExecutor: l2Rollup.coreContracts.upgradeExecutor,
       },
       l3: {
         accounts: {
diff --git a/src/upgradeExecutor.integration.test.ts b/src/upgradeExecutor.integration.test.ts
@@ -1,26 +1,38 @@
 import { describe, it, expect } from 'vitest';
-import { createPublicClient, http, PublicClient } from 'viem';
+import { Address, createPublicClient, http, PublicClient } from 'viem';
 
 import { nitroTestnodeL1 } from './chains';
-import { getInformationFromTestnode, getNitroTestnodePrivateKeyAccounts } from './testHelpers';
+import {
+  getInformationFromTestnode,
+  getNitroTestnodePrivateKeyAccounts,
+  PrivateKeyAccountWithPrivateKey,
+} from './testHelpers';
 import { upgradeExecutorPrepareAddExecutorTransactionRequest } from './upgradeExecutorPrepareAddExecutorTransactionRequest';
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 import { createRollupFetchTransactionHash } from './createRollupFetchTransactionHash';
 import { createRollupPrepareTransactionReceipt } from './createRollupPrepareTransactionReceipt';
 import { upgradeExecutorFetchPrivilegedAccounts } from './upgradeExecutorFetchPrivilegedAccounts';
 import { UPGRADE_EXECUTOR_ROLE_EXECUTOR } from './upgradeExecutorEncodeFunctionData';
 import { upgradeExecutorPrepareRemoveExecutorTransactionRequest } from './upgradeExecutorPrepareRemoveExecutorTransactionRequest';
+import { isAnvilTestMode, getAnvilTestStack } from './integrationTestHelpers/injectedMode';
+
+const env = isAnvilTestMode() ? getAnvilTestStack() : undefined;
 
 // Generating random account
 const randomAccount = privateKeyToAccount(generatePrivateKey());
 
-// Testnode accounts
-const testnodeAccounts = getNitroTestnodePrivateKeyAccounts();
-const l2RollupOwner = testnodeAccounts.l2RollupOwner;
+let l2RollupOwner: PrivateKeyAccountWithPrivateKey;
+
+if (env) {
+  l2RollupOwner = env.l2.accounts.rollupOwner;
+} else {
+  const testnodeAccounts = getNitroTestnodePrivateKeyAccounts();
+  l2RollupOwner = testnodeAccounts.l2RollupOwner;
+}
 
-const nitroTestnodeL1Client = createPublicClient({
-  chain: nitroTestnodeL1,
-  transport: http(nitroTestnodeL1.rpcUrls.default.http[0]),
+const l1Client = createPublicClient({
+  chain: env ? env.l1.chain : nitroTestnodeL1,
+  transport: env ? http() : http(nitroTestnodeL1.rpcUrls.default.http[0]),
 });
 
 async function getUpgradeExecutorOfRollup(rollup: `0x${string}`, publicClient: PublicClient) {
@@ -37,34 +49,37 @@ async function getUpgradeExecutorOfRollup(rollup: `0x${string}`, publicClient: P
 
 describe('upgradeExecutor role management', () => {
   it(`successfully grants and revokes the executor role to a new account`, async () => {
-    const testnodeInformation = getInformationFromTestnode();
-    const upgradeExecutor = await getUpgradeExecutorOfRollup(
-      testnodeInformation.rollup,
-      nitroTestnodeL1Client,
-    );
+    let upgradeExecutor: Address;
+
+    if (env) {
+      upgradeExecutor = env.l2.upgradeExecutor;
+    } else {
+      const testnodeInformation = getInformationFromTestnode();
+      upgradeExecutor = await getUpgradeExecutorOfRollup(testnodeInformation.rollup, l1Client);
+    }
 
     // prepare the transaction to add the executor role
     const addExecutorTransactionRequest = await upgradeExecutorPrepareAddExecutorTransactionRequest(
       {
         account: randomAccount.address,
         upgradeExecutorAddress: upgradeExecutor,
         executorAccountAddress: l2RollupOwner.address,
-        publicClient: nitroTestnodeL1Client,
+        publicClient: l1Client,
       },
     );
 
     // sign and send the transaction
-    const addExecutorTransactionHash = await nitroTestnodeL1Client.sendRawTransaction({
+    const addExecutorTransactionHash = await l1Client.sendRawTransaction({
       serializedTransaction: await l2RollupOwner.signTransaction(addExecutorTransactionRequest),
     });
 
     // wait for transaction receipt
-    await nitroTestnodeL1Client.waitForTransactionReceipt({ hash: addExecutorTransactionHash });
+    await l1Client.waitForTransactionReceipt({ hash: addExecutorTransactionHash });
 
     // verify that the account has been added to the list of privileged accounts
     const privilegedAccountsAfterAdding = await upgradeExecutorFetchPrivilegedAccounts({
       upgradeExecutorAddress: upgradeExecutor,
-      publicClient: nitroTestnodeL1Client,
+      publicClient: l1Client,
     });
     expect(privilegedAccountsAfterAdding).toHaveProperty(randomAccount.address);
     expect(privilegedAccountsAfterAdding[randomAccount.address]).toEqual([
@@ -77,21 +92,21 @@ describe('upgradeExecutor role management', () => {
         account: randomAccount.address,
         upgradeExecutorAddress: upgradeExecutor,
         executorAccountAddress: l2RollupOwner.address,
-        publicClient: nitroTestnodeL1Client,
+        publicClient: l1Client,
       });
 
     // sign and send the transaction
-    const removeExecutorTransactionHash = await nitroTestnodeL1Client.sendRawTransaction({
+    const removeExecutorTransactionHash = await l1Client.sendRawTransaction({
       serializedTransaction: await l2RollupOwner.signTransaction(removeExecutorTransactionRequest),
     });
 
     // wait for transaction receipt
-    await nitroTestnodeL1Client.waitForTransactionReceipt({ hash: removeExecutorTransactionHash });
+    await l1Client.waitForTransactionReceipt({ hash: removeExecutorTransactionHash });
 
     // verify that the account has been removed from the list of privileged accounts
     const privilegedAccountsAfterRemoving = await upgradeExecutorFetchPrivilegedAccounts({
       upgradeExecutorAddress: upgradeExecutor,
-      publicClient: nitroTestnodeL1Client,
+      publicClient: l1Client,
     });
     expect(privilegedAccountsAfterRemoving).to.not.have.property(randomAccount.address);
   });
diff --git a/vitest.integration.anvil.config.ts b/vitest.integration.anvil.config.ts
@@ -23,6 +23,8 @@ export default mergeConfig(
         './src/getKeysets.integration.test.ts',
         './src/decorators/rollupAdminLogicPublicActions.integration.test.ts',
         './src/actions/sequencerInbox.integration.test.ts',
+        './src/decorators/arbOwnerPublicActions.integration.test.ts',
+        './src/upgradeExecutor.integration.test.ts',
       ],
       fileParallelism: false,
     },
