diff --git a/src/actions/sequencerInbox.integration.test.ts b/src/actions/sequencerInbox.integration.test.ts
index 56ad1074..300b62e4 100644
--- a/src/actions/sequencerInbox.integration.test.ts
+++ b/src/actions/sequencerInbox.integration.test.ts
@@ -3,8 +3,9 @@ import {
   createRollupHelper,
   getInformationFromTestnode,
   getNitroTestnodePrivateKeyAccounts,
+  PrivateKeyAccountWithPrivateKey,
 } from '../testHelpers';
-import { Hex, createPublicClient, http, zeroAddress } from 'viem';
+import { Address, Hex, createPublicClient, http, zeroAddress } from 'viem';
 import { nitroTestnodeL2 } from '../chains';
 import { getMaxTimeVariation } from './getMaxTimeVariation';
 import { isBatchPoster } from './isBatchPoster';
@@ -15,12 +16,46 @@ import { buildSetMaxTimeVariation } from './buildSetMaxTimeVariation';
 import { buildDisableBatchPoster, buildEnableBatchPoster } from './buildSetIsBatchPoster';
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 import { buildInvalidateKeysetHash } from './buildInvalidateKeysetHash';
+import { getAnvilTestStack, isAnvilTestMode } from '../integrationTestHelpers/injectedMode';
 
-const { l3SequencerInbox, l3BatchPoster, l3UpgradeExecutor } = getInformationFromTestnode();
-const { l3TokenBridgeDeployer, deployer, l3RollupOwner } = getNitroTestnodePrivateKeyAccounts();
+// const { l3SequencerInbox, l3BatchPoster, l3UpgradeExecutor } = getInformationFromTestnode();
+// const { l3TokenBridgeDeployer, deployer, l3RollupOwner } = getNitroTestnodePrivateKeyAccounts();
 
-const client = createPublicClient({
-  chain: nitroTestnodeL2,
+// const client = createPublicClient({
+//   chain: nitroTestnodeL2,
+//   transport: http(),
+// });
+
+const env = isAnvilTestMode() ? getAnvilTestStack() : undefined;
+
+let l3RollupOwner: PrivateKeyAccountWithPrivateKey;
+let l3TokenBridgeDeployer: PrivateKeyAccountWithPrivateKey;
+let deployer: PrivateKeyAccountWithPrivateKey;
+let l3SequencerInbox: Address;
+let l3BatchPoster: Address;
+let l3UpgradeExecutor: Address;
+
+if (env) {
+  l3RollupOwner = env.l3.accounts.rollupOwner;
+  l3TokenBridgeDeployer = env.l3.accounts.tokenBridgeDeployer;
+  deployer = env.l2.accounts.deployer;
+  l3SequencerInbox = env.l3.sequencerInbox;
+  l3BatchPoster = env.l3.batchPoster;
+  l3UpgradeExecutor = env.l3.upgradeExecutor;
+} else {
+  const testnodeAccounts = getNitroTestnodePrivateKeyAccounts();
+  l3RollupOwner = testnodeAccounts.l3RollupOwner;
+  l3TokenBridgeDeployer = testnodeAccounts.l3TokenBridgeDeployer;
+  deployer = testnodeAccounts.deployer;
+
+  const testNodeInformation = getInformationFromTestnode();
+  l3SequencerInbox = testNodeInformation.l3SequencerInbox;
+  l3BatchPoster = testNodeInformation.l3BatchPoster;
+  l3UpgradeExecutor = testNodeInformation.l3UpgradeExecutor;
+}
+
+const l2Client = createPublicClient({
+  chain: env ? env.l2.chain : nitroTestnodeL2,
   transport: http(),
 });
 
@@ -32,7 +67,7 @@ describe('max time variation management', () => {
     futureSeconds: 3_600n,
   };
   it('getMaxTimeVariation successfully fetches max time variation', async () => {
-    const result = await getMaxTimeVariation(client, {
+    const result = await getMaxTimeVariation(l2Client, {
       sequencerInbox: l3SequencerInbox,
     });
     expect(result).toEqual(defaultMaxTimeVariation);
@@ -45,17 +80,17 @@ describe('max time variation management', () => {
       delaySeconds: bigint;
       futureSeconds: bigint;
     }) {
-      const transactionRequest = await buildSetMaxTimeVariation(client, {
+      const transactionRequest = await buildSetMaxTimeVariation(l2Client, {
         sequencerInbox: l3SequencerInbox,
         upgradeExecutor: l3UpgradeExecutor,
         account: l3RollupOwner.address,
         params: changes,
       });
-      const txHash = await client.sendRawTransaction({
+      const txHash = await l2Client.sendRawTransaction({
         serializedTransaction: await l3RollupOwner.signTransaction(transactionRequest),
       });
 
-      await client.waitForTransactionReceipt({ hash: txHash });
+      await l2Client.waitForTransactionReceipt({ hash: txHash });
     }
 
     const changes = {
@@ -65,13 +100,13 @@ describe('max time variation management', () => {
       futureSeconds: 1_800n,
     };
     await setMaxTimeVariation(changes);
-    const newResult = await getMaxTimeVariation(client, {
+    const newResult = await getMaxTimeVariation(l2Client, {
       sequencerInbox: l3SequencerInbox,
     });
     expect(newResult).toEqual(changes);
 
     await setMaxTimeVariation(defaultMaxTimeVariation);
-    const finalResult = await getMaxTimeVariation(client, {
+    const finalResult = await getMaxTimeVariation(l2Client, {
       sequencerInbox: l3SequencerInbox,
     });
     expect(finalResult).toEqual(defaultMaxTimeVariation);
@@ -80,14 +115,14 @@ describe('max time variation management', () => {
 
 describe('batch poster management', () => {
   it('isBatchPoster successfully fetches whether or an address is a batch poster', async () => {
-    const isNotBatchPosterAddress = await isBatchPoster(client, {
+    const isNotBatchPosterAddress = await isBatchPoster(l2Client, {
       sequencerInbox: l3SequencerInbox,
       params: {
         batchPoster: zeroAddress,
       },
     });
     expect(isNotBatchPosterAddress).toBeFalsy();
-    const isBatchPosterAddress = await isBatchPoster(client, {
+    const isBatchPosterAddress = await isBatchPoster(l2Client, {
       sequencerInbox: l3SequencerInbox,
       params: {
         batchPoster: l3BatchPoster,
@@ -98,7 +133,7 @@ describe('batch poster management', () => {
 
   it('successfully enable or disable an address as batch poster', async () => {
     const randomAddress = privateKeyToAccount(generatePrivateKey()).address;
-    const isRandomAddressBatchPoster = await isBatchPoster(client, {
+    const isRandomAddressBatchPoster = await isBatchPoster(l2Client, {
       sequencerInbox: l3SequencerInbox,
       params: {
         batchPoster: randomAddress,
@@ -106,7 +141,7 @@ describe('batch poster management', () => {
     });
     expect(isRandomAddressBatchPoster).toBeFalsy();
 
-    const enableTransactionRequest = await buildEnableBatchPoster(client, {
+    const enableTransactionRequest = await buildEnableBatchPoster(l2Client, {
       sequencerInbox: l3SequencerInbox,
       upgradeExecutor: l3UpgradeExecutor,
       account: l3RollupOwner.address,
@@ -114,11 +149,11 @@ describe('batch poster management', () => {
         batchPoster: randomAddress,
       },
     });
-    const enableTxHash = await client.sendRawTransaction({
+    const enableTxHash = await l2Client.sendRawTransaction({
       serializedTransaction: await l3RollupOwner.signTransaction(enableTransactionRequest),
     });
-    await client.waitForTransactionReceipt({ hash: enableTxHash });
-    const isRandomAddressBatchPosterAfterEnabling = await isBatchPoster(client, {
+    await l2Client.waitForTransactionReceipt({ hash: enableTxHash });
+    const isRandomAddressBatchPosterAfterEnabling = await isBatchPoster(l2Client, {
       sequencerInbox: l3SequencerInbox,
       params: {
         batchPoster: randomAddress,
@@ -126,7 +161,7 @@ describe('batch poster management', () => {
     });
     expect(isRandomAddressBatchPosterAfterEnabling).toBeTruthy();
 
-    const disableTransactionRequest = await buildDisableBatchPoster(client, {
+    const disableTransactionRequest = await buildDisableBatchPoster(l2Client, {
       sequencerInbox: l3SequencerInbox,
       upgradeExecutor: l3UpgradeExecutor,
       account: l3RollupOwner.address,
@@ -134,11 +169,11 @@ describe('batch poster management', () => {
         batchPoster: randomAddress,
       },
     });
-    const disableTxHash = await client.sendRawTransaction({
+    const disableTxHash = await l2Client.sendRawTransaction({
       serializedTransaction: await l3RollupOwner.signTransaction(disableTransactionRequest),
     });
-    await client.waitForTransactionReceipt({ hash: disableTxHash });
-    const isRandomAddressBatchPosterAfterDisabling = await isBatchPoster(client, {
+    await l2Client.waitForTransactionReceipt({ hash: disableTxHash });
+    const isRandomAddressBatchPosterAfterDisabling = await isBatchPoster(l2Client, {
       sequencerInbox: l3SequencerInbox,
       params: {
         batchPoster: randomAddress,
@@ -160,11 +195,13 @@ describe('keyset management', () => {
       batchPosters,
       validators,
       nativeToken: zeroAddress,
-      client,
+      client: l2Client,
+      customParentTimingParams: env ? env.l2.timingParams : undefined,
+      maxDataSize: env ? 104_857n : undefined,
     });
 
     const { sequencerInbox, upgradeExecutor } = createRollupInformation.coreContracts;
-    const transactionRequest = await buildSetValidKeyset(client, {
+    const transactionRequest = await buildSetValidKeyset(l2Client, {
       sequencerInbox: sequencerInbox,
       account: l3TokenBridgeDeployer.address,
       upgradeExecutor,
@@ -172,11 +209,11 @@ describe('keyset management', () => {
         keyset,
       },
     });
-    const transactionHash = await client.sendRawTransaction({
+    const transactionHash = await l2Client.sendRawTransaction({
       serializedTransaction: await l3TokenBridgeDeployer.signTransaction(transactionRequest),
     });
-    await client.waitForTransactionReceipt({ hash: transactionHash });
-    const logs = await client.getContractEvents({
+    await l2Client.waitForTransactionReceipt({ hash: transactionHash });
+    const logs = await l2Client.getContractEvents({
       address: sequencerInbox,
       abi: sequencerInboxABI,
       eventName: 'SetValidKeyset',
@@ -192,7 +229,7 @@ describe('keyset management', () => {
   }
 
   it('isValidKeysetHash successfully fetches whether a hash is a valid keyset hash', async () => {
-    const invalidKeysetHash = await isValidKeysetHash(client, {
+    const invalidKeysetHash = await isValidKeysetHash(l2Client, {
       sequencerInbox: l3SequencerInbox,
       params: {
         keysetHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
@@ -202,7 +239,7 @@ describe('keyset management', () => {
 
     const { sequencerInbox, keysetHash } = await deployAnyTrustChainWithKeyset(keysetBytes);
 
-    const result = await isValidKeysetHash(client, {
+    const result = await isValidKeysetHash(l2Client, {
       sequencerInbox,
       params: {
         keysetHash: keysetHash!,
@@ -216,7 +253,7 @@ describe('keyset management', () => {
       keysetBytes,
     );
 
-    const result = await isValidKeysetHash(client, {
+    const result = await isValidKeysetHash(l2Client, {
       sequencerInbox,
       params: {
         keysetHash: keysetHash!,
@@ -224,7 +261,7 @@ describe('keyset management', () => {
     });
     expect(result).toBeTruthy();
 
-    const transactionRequest = await buildInvalidateKeysetHash(client, {
+    const transactionRequest = await buildInvalidateKeysetHash(l2Client, {
       sequencerInbox,
       account: l3TokenBridgeDeployer.address,
       upgradeExecutor,
@@ -232,12 +269,12 @@ describe('keyset management', () => {
         keysetHash: keysetHash!,
       },
     });
-    const txHash = await client.sendRawTransaction({
+    const txHash = await l2Client.sendRawTransaction({
       serializedTransaction: await l3TokenBridgeDeployer.signTransaction(transactionRequest),
     });
-    await client.waitForTransactionReceipt({ hash: txHash });
+    await l2Client.waitForTransactionReceipt({ hash: txHash });
 
-    const resultAfterChange = await isValidKeysetHash(client, {
+    const resultAfterChange = await isValidKeysetHash(l2Client, {
       sequencerInbox,
       params: {
         keysetHash: keysetHash!,
diff --git a/src/decorators/rollupAdminLogicPublicActions.integration.test.ts b/src/decorators/rollupAdminLogicPublicActions.integration.test.ts
index bb3ad822..50f01a9d 100644
--- a/src/decorators/rollupAdminLogicPublicActions.integration.test.ts
+++ b/src/decorators/rollupAdminLogicPublicActions.integration.test.ts
@@ -1,5 +1,5 @@
 import { it, expect } from 'vitest';
-import { createPublicClient, http } from 'viem';
+import { Address, createPublicClient, http } from 'viem';
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 
 import { nitroTestnodeL2 } from '../chains';
@@ -7,12 +7,16 @@ import { rollupAdminLogicPublicActions } from './rollupAdminLogicPublicActions';
 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 { 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
@@ -20,8 +24,24 @@ const rollupCreatorVersion = testHelper_getRollupCreatorVersionFromEnv();
 // 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({
@@ -29,6 +49,15 @@ const client = createPublicClient({
   }),
 );
 
+// const client = createPublicClient({
+//   chain: nitroTestnodeL2,
+//   transport: http(),
+// }).extend(
+//   rollupAdminLogicPublicActions({
+//     rollup: l3Rollup,
+//   }),
+// );
+
 it('successfully set validators', async () => {
   const randomAccounts = [
     privateKeyToAccount(generatePrivateKey()).address,
@@ -36,7 +65,7 @@ it('successfully set validators', async () => {
   ];
 
   const { validators: initialValidators, isAccurate: isAccurateInitially } = await getValidators(
-    client,
+    l2Client,
     {
       rollup: l3Rollup,
     },
@@ -45,7 +74,7 @@ it('successfully set validators', async () => {
   expect(initialValidators).toHaveLength(expectedInitialValidators);
   expect(isAccurateInitially).toBeTruthy();
 
-  const tx = await client.rollupAdminLogicPrepareTransactionRequest({
+  const tx = await l2Client.rollupAdminLogicPrepareTransactionRequest({
     functionName: 'setValidator',
     args: [randomAccounts, [true, false]],
     account: l3RollupOwner.address,
@@ -53,21 +82,21 @@ it('successfully set validators', async () => {
     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,
   });
 
   const validators = await Promise.all([
-    client.rollupAdminLogicReadContract({
+    l2Client.rollupAdminLogicReadContract({
       functionName: 'isValidator',
       args: [randomAccounts[0]],
       rollup: l3Rollup,
     }),
-    client.rollupAdminLogicReadContract({
+    l2Client.rollupAdminLogicReadContract({
       functionName: 'isValidator',
       args: [randomAccounts[1]],
       rollup: l3Rollup,
@@ -75,14 +104,14 @@ it('successfully set validators', async () => {
   ]);
 
   const { validators: currentValidators, isAccurate: currentIsAccurate } = await getValidators(
-    client,
+    l2Client,
     { rollup: l3Rollup },
   );
   expect(validators).toEqual([true, false]);
   expect(currentValidators).toEqual(initialValidators.concat(randomAccounts[0]));
   expect(currentIsAccurate).toBeTruthy();
 
-  const revertTx = await client.rollupAdminLogicPrepareTransactionRequest({
+  const revertTx = await l2Client.rollupAdminLogicPrepareTransactionRequest({
     functionName: 'setValidator',
     args: [randomAccounts, [false, false]],
     account: l3RollupOwner.address,
@@ -90,15 +119,15 @@ it('successfully set validators', async () => {
     rollup: l3Rollup,
   });
 
-  const revertTxHash = await client.sendRawTransaction({
+  const revertTxHash = await l2Client.sendRawTransaction({
     serializedTransaction: await l3RollupOwner.signTransaction(revertTx),
   });
-  await client.waitForTransactionReceipt({
+  await l2Client.waitForTransactionReceipt({
     hash: revertTxHash,
   });
 
   const { validators: revertedValidators, isAccurate: revertedIsAccurate } = await getValidators(
-    client,
+    l2Client,
     {
       rollup: l3Rollup,
     },
@@ -108,14 +137,14 @@ it('successfully set validators', async () => {
 });
 
 it('successfully enable/disable whitelist', async () => {
-  const whitelistDisabledBefore = await client.rollupAdminLogicReadContract({
+  const whitelistDisabledBefore = await l2Client.rollupAdminLogicReadContract({
     functionName: 'validatorWhitelistDisabled',
   });
 
   // By default whitelist is not disabled
   expect(whitelistDisabledBefore).toEqual(false);
 
-  const tx = await client.rollupAdminLogicPrepareTransactionRequest({
+  const tx = await l2Client.rollupAdminLogicPrepareTransactionRequest({
     functionName: 'setValidatorWhitelistDisabled',
     args: [true],
     account: l3RollupOwner.address,
@@ -123,14 +152,14 @@ it('successfully enable/disable whitelist', async () => {
     upgradeExecutor: l3UpgradeExecutor,
   });
 
-  const txHash = await client.sendRawTransaction({
+  const txHash = await l2Client.sendRawTransaction({
     serializedTransaction: await l3RollupOwner.signTransaction(tx),
   });
-  await client.waitForTransactionReceipt({
+  await l2Client.waitForTransactionReceipt({
     hash: txHash,
   });
 
-  const whitelistDisabled = await client.rollupAdminLogicReadContract({
+  const whitelistDisabled = await l2Client.rollupAdminLogicReadContract({
     functionName: 'validatorWhitelistDisabled',
     rollup: l3Rollup,
   });
@@ -138,7 +167,7 @@ it('successfully enable/disable whitelist', async () => {
   expect(whitelistDisabled).toEqual(true);
 
   // Revert changes, so test can be run multiple time without issues
-  const revertTx = await client.rollupAdminLogicPrepareTransactionRequest({
+  const revertTx = await l2Client.rollupAdminLogicPrepareTransactionRequest({
     functionName: 'setValidatorWhitelistDisabled',
     args: [false],
     account: l3RollupOwner.address,
@@ -146,10 +175,10 @@ it('successfully enable/disable whitelist', async () => {
     upgradeExecutor: l3UpgradeExecutor,
   });
 
-  const revertTxHash = await client.sendRawTransaction({
+  const revertTxHash = await l2Client.sendRawTransaction({
     serializedTransaction: await l3RollupOwner.signTransaction(revertTx),
   });
-  await client.waitForTransactionReceipt({
+  await l2Client.waitForTransactionReceipt({
     hash: revertTxHash,
   });
 });
diff --git a/src/getKeysets.integration.test.ts b/src/getKeysets.integration.test.ts
index e839f499..40c8fb7e 100644
--- a/src/getKeysets.integration.test.ts
+++ b/src/getKeysets.integration.test.ts
@@ -15,20 +15,34 @@ import {
   createRollupHelper,
   getInformationFromTestnode,
   getNitroTestnodePrivateKeyAccounts,
+  PrivateKeyAccountWithPrivateKey,
 } from './testHelpers';
 import { getKeysets } from './getKeysets';
+import { getAnvilTestStack, isAnvilTestMode } from './integrationTestHelpers/injectedMode';
 
-const { l3SequencerInbox } = getInformationFromTestnode();
-const { l3TokenBridgeDeployer, deployer } = getNitroTestnodePrivateKeyAccounts();
+const env = isAnvilTestMode() ? getAnvilTestStack() : undefined;
 
-const client = createPublicClient({
-  chain: nitroTestnodeL2,
+let l3TokenBridgeDeployer: PrivateKeyAccountWithPrivateKey;
+let deployer: PrivateKeyAccountWithPrivateKey;
+let l3SequencerInbox: Address;
+
+if (env) {
+  l3TokenBridgeDeployer = env.l3.accounts.tokenBridgeDeployer;
+  deployer = env.l2.accounts.deployer;
+  l3SequencerInbox = env.l3.sequencerInbox;
+} else {
+  const testnodeAccounts = getNitroTestnodePrivateKeyAccounts();
+  l3TokenBridgeDeployer = testnodeAccounts.l3TokenBridgeDeployer;
+  deployer = testnodeAccounts.deployer;
+
+  const testNodeInformation = getInformationFromTestnode();
+  l3SequencerInbox = testNodeInformation.l3SequencerInbox;
+}
+
+const l2Client = createPublicClient({
+  chain: env ? env.l2.chain : nitroTestnodeL2,
   transport: http(),
-}).extend(
-  sequencerInboxActions({
-    sequencerInbox: l3SequencerInbox,
-  }),
-);
+}).extend(sequencerInboxActions({ sequencerInbox: l3SequencerInbox }));
 
 async function sendKeysetTransaction({
   account,
@@ -37,10 +51,10 @@ async function sendKeysetTransaction({
   account: PrivateKeyAccount;
   tx: TransactionSerializable;
 }) {
-  const txHash = await client.sendRawTransaction({
+  const txHash = await l2Client.sendRawTransaction({
     serializedTransaction: await account.signTransaction(tx),
   });
-  await client.waitForTransactionReceipt({
+  await l2Client.waitForTransactionReceipt({
     hash: txHash,
   });
 }
@@ -55,7 +69,7 @@ async function setValidKeyset({
   upgradeExecutor: Address;
   account: PrivateKeyAccount;
 }) {
-  const tx = await client.sequencerInboxPrepareTransactionRequest({
+  const tx = await l2Client.sequencerInboxPrepareTransactionRequest({
     functionName: 'setValidKeyset',
     args: [keysetBytes],
     account: account.address,
@@ -75,7 +89,7 @@ async function invalidateKeyset({
   upgradeExecutor: Address;
   account: PrivateKeyAccount;
 }) {
-  const tx = await client.sequencerInboxPrepareTransactionRequest({
+  const tx = await l2Client.sequencerInboxPrepareTransactionRequest({
     functionName: 'invalidateKeysetHash',
     args: [keysetHash],
     account: account.address,
@@ -102,7 +116,9 @@ async function createAnytrustRollup() {
     batchPosters,
     validators,
     nativeToken: zeroAddress,
-    client,
+    client: l2Client,
+    customParentTimingParams: env ? env.l2.timingParams : undefined,
+    maxDataSize: env ? 104_857n : undefined,
   });
 }
 
@@ -111,7 +127,7 @@ describe('successfully get valid keysets', () => {
   it('when disabling the same keyset multiple time', async () => {
     const { createRollupInformation } = await createAnytrustRollup();
     const { sequencerInbox, upgradeExecutor } = createRollupInformation.coreContracts;
-    const { keysets: initialKeysets } = await getKeysets(client, {
+    const { keysets: initialKeysets } = await getKeysets(l2Client, {
       sequencerInbox,
     });
 
@@ -139,7 +155,7 @@ describe('successfully get valid keysets', () => {
       account: l3TokenBridgeDeployer,
     });
 
-    const { keysets } = await getKeysets(client, {
+    const { keysets } = await getKeysets(l2Client, {
       sequencerInbox,
     });
 
@@ -154,7 +170,7 @@ describe('successfully get valid keysets', () => {
       account: l3TokenBridgeDeployer,
     });
 
-    const { keysets: emptyKeysets } = await getKeysets(client, {
+    const { keysets: emptyKeysets } = await getKeysets(l2Client, {
       sequencerInbox,
     });
 
@@ -167,7 +183,7 @@ describe('successfully get valid keysets', () => {
       account: l3TokenBridgeDeployer,
     });
 
-    const { keysets: finalKeysets } = await getKeysets(client, {
+    const { keysets: finalKeysets } = await getKeysets(l2Client, {
       sequencerInbox,
     });
 
diff --git a/vitest.integration.anvil.config.ts b/vitest.integration.anvil.config.ts
index 2b60187f..e8737988 100644
--- a/vitest.integration.anvil.config.ts
+++ b/vitest.integration.anvil.config.ts
@@ -20,6 +20,9 @@ export default mergeConfig(
         './src/getBatchPosters.integration.test.ts',
         './src/getValidators.integration.test.ts',
         './src/decorators/sequencerInboxActions.integration.test.ts',
+        './src/getKeysets.integration.test.ts',
+        './src/decorators/rollupAdminLogicPublicActions.integration.test.ts',
+        './src/actions/sequencerInbox.integration.test.ts',
       ],
       fileParallelism: false,
     },