Prover/setup of beta v1.4 for mainnet (#875)

* chores(cfg): create the config-mainnet-full.toml

* feat(contracts): adds PlonkVerifierMainnetFull contract

* dropme(cfg): points to the mainnet test files

* chores(contract): adds a tarball with all the inputs for the contract testing

* move betav1 test

* got to executing rollup case

* minor edit

* did boilerplate for migration test

* new

* fix: update betav1.4 migrations tests

* fix: remove .only in tests

* minor edits

* add new unit test and fix testverifierindex variable

---------

Co-authored-by: kyzooghost <jeffersonzjtang@gmail.com>
Co-authored-by: VGau <victorien.gauch@consensys.net>

contracts/deploy/01_deploy_PlonkVerifier.ts

@@ -38,7 +38,7 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
     ethers.AbiCoder.defaultAbiCoder().encode(["address", "uint256"], [contractAddress, verifierIndex]),
   ]);
 
-  console.log("", setVerifierAddress);
+  console.log("setVerifierAddress calldata:", setVerifierAddress);
 
   await tryVerifyContract(contractAddress);
 };

contracts/test/hardhat/_testData/betaV1_4/postRelease/proof/17865638-17865747-getZkAggregatedProof.json

@@ -0,0 +1,44 @@
+{
+  "finalShnarf": "0xc6bd71cc98f5ff2c1efffaf749b13cf7d1b13b86f9b4074da60079cab9c7f068",
+  "parentAggregationFinalShnarf": "0x34e6f29838a27a3621773b58efc778ada8ad0626a660f8bbcf7f2315f97fcd14",
+  "aggregatedProof": "0x1a1fc4101b83d093cb5547d909c1de5464f3b2aa12b2040f8de33f8358caf0c71a7b6177c2d2010dec09541eea7c665c2dabd0c0005fde862917bef43de1dd1625798f450eaf4a8271fefdb762a0a2d0113fadea8190181ee9040dcd4dccdc8c29f40f06b1ae60df4fa1f1f4f0f67035b82695699d79f596fc17c2fad7f6d4ac2b6fe21cfe8922f83cb6d05e9012a9c85dd0f30cf82a4af885e47abc028ee7990f19363737210b70a91017c118103bfe83990176bd747fbb149ed28c08d8567d171a871a47a566aba5d9353d0be6d589da4951ee8ed9a104d93e2c5d3cc8aa3e05eec8e44d1e2abbe355fe500acdb50855488c3ba59019d3b77fb9eaae5cb3b0035c8f14e2d7cb10f3d5892f34bd9193939688907935cacc2d383b35e869539321fd9227aebb4f87d6efc10edb7e72a5b6ac890bbacbaaea056f24e8d5e009151f2dfa8e346da714c2b4b785927ddb2f830d128f1edc9085c88ea9d5bfe040d508eeb8d3b149418e416b8ac03db1c3e652e0d7be0cdc3da2cb6a5d1caa6b80522e41edd4eef3aa3632f55da78d32f2573cc7892ca77b166cf20ccd39635b195a1e280a8b26642df465cdedfecdef416ec62316cca8f52d93031c86aa2787381f02a80cc97178727fc8b7779f721f250b6ce1930ffa615662e479c7e89eb2abc025ef2e00672d93a85554c562cf5fe3861d106d9d2f7769c0ff79196b970541722953e7411257e826e9be62d67fbe7540256ace84998201bc0b1f81d74d1b77a125e05509651dacb90bd5ee7a6aceeb3bcdfe422b48dfdd807847dda2c0bbc3491bd05ee349d2c78219fcdbaa489545c5c5d11af4b30685c1b06ad20e9eaad93b28074bb7b1d3173275347e537c0672b021c334cb4a3e568f55f6154afff733ab27ade7044f6ef43b2de54592ba27035e25844c2e550f4957858ef614c61c0900236d40a58ee0edd904eb1527b02d8c01a43c55507909a5e5c9c2465a5cad7db10f34aa8a2626310c93d8f17253ceda8f259b4fe71bc03621564c49ce86c718e21fe96f4fd599ae79574de2fff3ba8d5e9549fc433f7c2134d2cdfc6989e7f34e2d02d93ddeb0ba05dc56c31ae36f5ef59b88db465a1c5793ee063b091bb64a231c3c95a3dcdb9e08b1b274aeab2e61bb33525e2d091d8070f71cdb7edcb256131a6b96a605dcca291ff285568ad2a63c992d63f0b1aaea1245e0c7677378ce25",
+  "aggregatedProverVersion": "5.0.2",
+  "aggregatedVerifierIndex": 1,
+  "aggregatedProofPublicInput": "0x183bc76cd3a4282e86cc93d62b2b2527bdbcd60f3c13b32ed599f2e8bb9bfc65",
+  "dataHashes": [
+    "0x019e44b475cf05ca347516891e17260dff2412275509aef778c024a497c7e2a4",
+    "0x01fa1a8d120e026e6377cdfb9632bbd68456bf2ecc23af50450d20a7c01dc41a",
+    "0x01d162e6ecf3bcf28ae4f881c333477b00353b17bcb31b8f3334b1a9acafd8a1",
+    "0x01d715d0e82b6e86a879eac16ace09a1e94b96931b630c4356bd10df0f00a6c9",
+    "0x019a910e87c05baa04238585af6060788328470fb4593acba1f2ce9e19222600",
+    "0x01330f4997c36a73900d0e9342ad51824995229fa51c7a6b5c9ddf9281fe5716",
+    "0x018272c603f97c2033c4b30f52d87a896f0787580a61be50b116ee66bc2619e4",
+    "0x018a4625acdc76c4545068a3e7e57a10e7106b7ed811bcb2eed76b946cb28047",
+    "0x0184a7ce85f4f376e7abde1640680cfaf9f90b6b6466e5c3ada9850ecf65fdd7",
+    "0x010621dcac35228ed31399e848dc2f1219ff8df85c86212004a37870890309b9",
+    "0x01c1ff87d5e8189b456513f40da2f35843ec4349aca460f499b1d1660a0bde4e",
+    "0x01c491ac4c44bf3f3ca3dce3eb538314de834003d7065ae75f438957bca3f54d",
+    "0x018d54800edc45d622454c6237624842de3f278642cce52ed67f5484b008f7ba",
+    "0x01a03ddeb3bca9a6f2e8c840111982fccf41eae9e9658c918a79c89cfd86dbab",
+    "0x01d32e99f8f2b1c8bff3146a2a1436dca70d5671bdf19ead3abdaacf64ee6b56",
+    "0x01732fdd98bc572032135ba9aeaf293b0f8066d51ca33bbf2369e68bcad587e0",
+    "0x01a3013d06d4cdbf3be3010ef1c1277b57acfcf4471e54313e5834319af4fd42",
+    "0x0122304911d6cd6d501b4ee49c5703cfd4bd06669c81fda2cf7b840cd940780d",
+    "0x017a3f3a158e514c2054803f510fb3eeaaa010e3f76fd6b58c2fc31296d42723",
+    "0x019213dfa9c3ad91bf7e3ba15296e06e4128a476234cf876dd5ae6fd0cbc566e",
+    "0x01b789c8b27d3c02656ed95117e1efa39f4a5a0e312200b7a2ae7c7b7a1f149a"
+  ],
+  "dataParentHash": "0x0103e5484c3b431ba5b51cd097739a8da2a37d97bff0b9a932739369d02a57a8",
+  "parentStateRootHash": "0x00f63f481879c7682c1eacfcca3626e0e9b3bc26d38d734925c2706c4d6fd2ac",
+  "parentAggregationLastBlockTimestamp": 1744196722,
+  "lastFinalizedBlockNumber": 17865637,
+  "finalTimestamp": 1744196953,
+  "finalBlockNumber": 17865747,
+  "l1RollingHash": "0x14b1f596bf51d4cfcaf194c498f53c40a94bcebddb5a892c52c3fc5e713c46ed",
+  "l1RollingHashMessageNumber": 737506,
+  "l2MerkleRoots": [],
+  "l2MerkleTreesDepth": 5,
+  "l2MessagingBlocksOffsets": "0x",
+  "parentAggregationLastL1RollingHash": "0x14b1f596bf51d4cfcaf194c498f53c40a94bcebddb5a892c52c3fc5e713c46ed",
+  "parentAggregationLastL1RollingHashMessageNumber": 737506
+}

contracts/test/hardhat/_testData/betaV1_4/preRelease/proof/17865582-12865637-getZkAggregatedProof.json

@@ -0,0 +1,35 @@
+{
+  "finalShnarf": "0x34e6f29838a27a3621773b58efc778ada8ad0626a660f8bbcf7f2315f97fcd14",
+  "parentAggregationFinalShnarf": "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "aggregatedProof": "0x08a79afdbd2a920d1cdfabf67314b139fd91ebd64b3e81dca411d1f5231029a22f1581a95074684cafb14375c665967d451365b48b1f706ddbae46c78e5b17aa28bbc9392a57be4caabf494c67a2d051f763e24ab85060ecf4ec6654d0324b091d88b7360857938405fe289bf5994388a64205430c3a35883b1d2955f1274861279d9750ea45d26b271b51116e6f22fcfe7b1c3e186e049bfc2f6e71f74c02891e5f516635c858329c4c2d3d499f419cb41a3fd6310ac44a20c7f7d01438b60e1f7869f8139ef800839e3550a69f1d8ebc29729610f9f465c85319d78a395f330f57c8d58de3f14cce10ea3cdb33d775e2193dee16577d13785456862ace30d82ae3f201af7f65c2bfd83dbfb6e22524e1c74ab4ac27f0438b24735e7926025f0f2a0a3216a622f84b1b3d2b5addbe61484f5b10f776a583067cdf3f4ea4408c044d84acfde2fc226970460c0c5aa4616a2dbf0b8402de47ac90d03e01529b2e1e91a7a8a566d42550459b58fa1832386afcd9f9e6a5a1036ee50f12553d7ca1125ae4c6345cb0948b883dff06940dbc59b2ecac9448bd6ac2eac001a79e9a560814a29cf8cba8c2f6741e30188f4a2338baa648b7fa746a98425c67e8f2ada100fd329fd5eae5e4087ddac17410b19e82302c9ba9009c4341a6ff308bdd8c212dfcee7afa70ea86e63de04476c47c6b453471f0aca3e3f6b500faa621161e2707f2f3089e5b0423e90c0416faa1db1f5173cef5f7aefdd899cfeab08d1e073e04faff37d80174fd3dcc4a6ffdb04ede7d448ac7d74d649435a485203d75ded1133c3b312d22790d9141a5841c4e5144c5405d5299a29a218683b82878a9d80d165125162e1676665059dded233a2561b75a456dac5c14f16ed1695aaed9d2141c6d47b7f2d27cff95a46c6f1b0c485c6d006bc9fc6da3d1bcf55f6b2f8513b02a3eb251e59a06dd9c0965ab23e13eaaedf2daf1cc102e604282139ade9f16460ec6b90edf46752964ae9ac88deed70d0334b796eb40e63c52cdb6773b56a7171a3501d801df83102f4fde12cb139ce96d93df0b6b1ae842c0662bf9857cf55307d61c562cacc02025032535bec8c26f3bc8bb0c698d35423700583cc4bd77bd0b45a1f7d9463c7ad4216ede90548ec7e43ed52ec03548a33955b4a8b396892e2fd1c81e70352a7ab6cff1281fdf4669c9f58c246ceb29e1c8a0c2fc03bcbddd",
+  "aggregatedProverVersion": "5.0.2",
+  "aggregatedVerifierIndex": 1,
+  "aggregatedProofPublicInput": "0x198daa430edb3cd18035f422224be48137e15fbdadb41512d47bd5b51d182417",
+  "dataHashes": [
+    "0x016b3a22f3e6b79d2e94d85cbbdb7c021af907777d1c7b5bbfb44afb5138e8b1",
+    "0x01a4ec6bdb7cf8bd35acb1dc3b69677530206605226df71168312bdb3d88786d",
+    "0x01f4aa00fcdf58a5306b4f8f16b8a4e6a3d88e7a60470f6f3f212f21b3dce20e",
+    "0x0115710bfabe3b9245401cb43ee57e70d1ad1054069243ffb175fd9a9b8cb270",
+    "0x01d8e5df26be29dd873946f45ded98d591e523d871b7708b4e8e4798680f73a0",
+    "0x013f7782a0f1ced8d729cf6c563779707e19b1cdeccf6372178ac40dec442862",
+    "0x01d0d06862d686b8c1dffe7f58e4cec0f14f94a069124ea6305dab2a46586a9b",
+    "0x0120a52599d03f3e4aaa7f782eea3b4d31fdfca658fa8f8ff4d1a3d6ed5f4460",
+    "0x0114875ef15f13f3ed449e5becee5b34035b007827ae86ef12757830e22c6f81",
+    "0x016cca94ae261e5932820129909b118c07d4c510826069197d210ebf1a913fee",
+    "0x015684f83d0ae1ceb1726ccd738120f3c709948727ee5bbe924767e362411047",
+    "0x0103e5484c3b431ba5b51cd097739a8da2a37d97bff0b9a932739369d02a57a8"
+  ],
+  "dataParentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "parentStateRootHash": "0x006548a9cf083362babd2be9c136703e70f5dd1929fc83a978a4e5810b7657b9",
+  "parentAggregationLastBlockTimestamp": 1744196594,
+  "lastFinalizedBlockNumber": 17865581,
+  "finalTimestamp": 1744196722,
+  "finalBlockNumber": 17865637,
+  "l1RollingHash": "0x14b1f596bf51d4cfcaf194c498f53c40a94bcebddb5a892c52c3fc5e713c46ed",
+  "l1RollingHashMessageNumber": 737506,
+  "l2MerkleRoots": [],
+  "l2MerkleTreesDepth": 5,
+  "l2MessagingBlocksOffsets": "0x",
+  "parentAggregationLastL1RollingHash": "0x14b1f596bf51d4cfcaf194c498f53c40a94bcebddb5a892c52c3fc5e713c46ed",
+  "parentAggregationLastL1RollingHashMessageNumber": 737506
+}

contracts/test/hardhat/common/constants/time.ts

@@ -10,3 +10,4 @@ export const GENESIS_L2_TIMESTAMP = 0;
 export const DEFAULT_LAST_FINALIZED_TIMESTAMP = 1683325137n;
 export const SIX_MONTHS_IN_SECONDS = ONE_YEARS_IN_SECONDS / 2;
 export const TEST_PUBLIC_VERIFIER_INDEX = 0;
+export const TEST_NEW_PUBLIC_VERIFIER_INDEX = 1;

contracts/test/hardhat/rollup/LineaRollup/BlobSubmission.ts

@@ -1,35 +1,54 @@
 import { SignerWithAddress } from "@nomicfoundation/hardhat-ethers/signers";
 import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import * as fs from "fs";
 import * as kzg from "c-kzg";
 import { expect } from "chai";
 import { BaseContract, Transaction } from "ethers";
 import { ethers } from "hardhat";
 
+import betaV1FinalizationData from "../../_testData/betaV1/proof/7027059-7042723-d2221f5035e3dcbbc46e8a6130fef34fdec33c252b7d31fb8afa6848660260ba-getZkAggregatedProof.json";
+import betaV1_4PreReleaseFinalizationData from "../../_testData/betaV1_4/preRelease/proof/17865582-12865637-getZkAggregatedProof.json";
+import betaV1_4PostReleaseFinalizationData from "../../_testData/betaV1_4/postRelease/proof/17865638-17865747-getZkAggregatedProof.json";
 import blobAggregatedProof1To155 from "../../_testData/compressedDataEip4844/aggregatedProof-1-155.json";
 import blobMultipleAggregatedProof1To81 from "../../_testData/compressedDataEip4844/multipleProofs/aggregatedProof-1-81.json";
 import firstCompressedDataContent from "../../_testData/compressedData/blocks-1-46.json";
 import secondCompressedDataContent from "../../_testData/compressedData/blocks-47-81.json";
 import fourthCompressedDataContent from "../../_testData/compressedData/blocks-115-155.json";
 
+import { LINEA_ROLLUP_PAUSE_TYPES_ROLES, LINEA_ROLLUP_UNPAUSE_TYPES_ROLES } from "contracts/common/constants";
 import { TestLineaRollup } from "contracts/typechain-types";
 import {
   deployLineaRollupFixture,
+  deployPlonkVerifierMainnetFull,
+  deployPlonkVerifierSepoliaFull,
   deployRevertingVerifier,
   expectSuccessfulFinalize,
   getAccountsFixture,
+  getVersionedBlobFiles,
+  getRoleAddressesFixture,
   getWalletForIndex,
   sendBlobTransaction,
+  sendVersionedBlobTransactionFromFile,
+  deployPlonkVerifierDev,
 } from "../helpers";
 import {
+  FALLBACK_OPERATOR_ADDRESS,
   GENERAL_PAUSE_TYPE,
   HASH_ZERO,
+  INITIAL_WITHDRAW_LIMIT,
+  ONE_DAY_IN_SECONDS,
   OPERATOR_ROLE,
   TEST_PUBLIC_VERIFIER_INDEX,
+  TEST_NEW_PUBLIC_VERIFIER_INDEX,
+  LINEA_ROLLUP_INITIALIZE_SIGNATURE,
   BLOB_SUBMISSION_PAUSE_TYPE,
 } from "../../common/constants";
+import { deployUpgradableFromFactory } from "../../common/deployment";
 import {
   generateFinalizationData,
   generateRandomBytes,
+  generateKeccak256,
+  expectEvent,
   buildAccessErrorMessage,
   expectRevertWithCustomError,
   expectRevertWithReason,
@@ -46,11 +65,12 @@ describe("Linea Rollup contract: EIP-4844 Blob submission tests", () => {
   let securityCouncil: SignerWithAddress;
   let operator: SignerWithAddress;
   let nonAuthorizedAccount: SignerWithAddress;
-
+  let roleAddresses: { addressWithRole: string; role: string }[];
   const { prevShnarf } = firstCompressedDataContent;
 
   before(async () => {
     ({ securityCouncil, operator, nonAuthorizedAccount } = await loadFixture(getAccountsFixture));
+    roleAddresses = await loadFixture(getRoleAddressesFixture);
   });
 
   beforeEach(async () => {
@@ -255,6 +275,7 @@ describe("Linea Rollup contract: EIP-4844 Blob submission tests", () => {
       [1n],
     );
   });
+
   it("Should fail if the final state root hash is empty", async () => {
     const operatorHDSigner = getWalletForIndex(2);
 
@@ -711,4 +732,541 @@ describe("Linea Rollup contract: EIP-4844 Blob submission tests", () => {
       "InvalidProof",
     );
   });
+
+  describe("Prover Beta V1", () => {
+    it("Can submit blobs and finalize with Prover Beta V1", async () => {
+      // *** ARRANGE ***
+      const sepoliaFullVerifier = await deployPlonkVerifierSepoliaFull();
+
+      // Deploy and initialize LineaRollup
+      const initializationData = {
+        initialStateRootHash: betaV1FinalizationData.parentStateRootHash,
+        initialL2BlockNumber: betaV1FinalizationData.lastFinalizedBlockNumber,
+        genesisTimestamp: betaV1FinalizationData.parentAggregationLastBlockTimestamp,
+        defaultVerifier: sepoliaFullVerifier,
+        rateLimitPeriodInSeconds: ONE_DAY_IN_SECONDS,
+        rateLimitAmountInWei: INITIAL_WITHDRAW_LIMIT,
+        roleAddresses,
+        pauseTypeRoles: LINEA_ROLLUP_PAUSE_TYPES_ROLES,
+        unpauseTypeRoles: LINEA_ROLLUP_UNPAUSE_TYPES_ROLES,
+        fallbackOperator: FALLBACK_OPERATOR_ADDRESS,
+        defaultAdmin: securityCouncil.address,
+      };
+
+      const betaV1LineaRollup = (await deployUpgradableFromFactory("TestLineaRollup", [initializationData], {
+        initializer: LINEA_ROLLUP_INITIALIZE_SIGNATURE,
+        unsafeAllow: ["constructor", "incorrect-initializer-order"],
+      })) as unknown as TestLineaRollup;
+
+      await betaV1LineaRollup.setupParentShnarf(betaV1FinalizationData.parentAggregationFinalShnarf);
+
+      // Send blobs
+      const blobFiles = getVersionedBlobFiles("betaV1");
+
+      for (let i = 0; i < blobFiles.length; i++) {
+        await sendVersionedBlobTransactionFromFile(lineaRollup, blobFiles[i], betaV1LineaRollup, "betaV1");
+      }
+
+      const finalBlobFile = JSON.parse(
+        fs.readFileSync(`${__dirname}/../../_testData/betaV1/${blobFiles.slice(-1)[0]}`, "utf-8"),
+      );
+
+      // Setup finalize call
+      const finalizationData = await generateFinalizationData({
+        l1RollingHash: betaV1FinalizationData.l1RollingHash,
+        l1RollingHashMessageNumber: BigInt(betaV1FinalizationData.l1RollingHashMessageNumber),
+        lastFinalizedTimestamp: BigInt(betaV1FinalizationData.parentAggregationLastBlockTimestamp),
+        endBlockNumber: BigInt(betaV1FinalizationData.finalBlockNumber),
+        parentStateRootHash: betaV1FinalizationData.parentStateRootHash,
+        finalTimestamp: BigInt(betaV1FinalizationData.finalTimestamp),
+        l2MerkleRoots: betaV1FinalizationData.l2MerkleRoots,
+        l2MerkleTreesDepth: BigInt(betaV1FinalizationData.l2MerkleTreesDepth),
+        l2MessagingBlocksOffsets: betaV1FinalizationData.l2MessagingBlocksOffsets,
+        aggregatedProof: betaV1FinalizationData.aggregatedProof,
+        shnarfData: {
+          parentShnarf: finalBlobFile.prevShnarf,
+          snarkHash: finalBlobFile.snarkHash,
+          finalStateRootHash: finalBlobFile.finalStateRootHash,
+          dataEvaluationPoint: finalBlobFile.expectedX,
+          dataEvaluationClaim: finalBlobFile.expectedY,
+        },
+      });
+
+      finalizationData.lastFinalizedL1RollingHash = betaV1FinalizationData.parentAggregationLastL1RollingHash;
+      finalizationData.lastFinalizedL1RollingHashMessageNumber = BigInt(
+        betaV1FinalizationData.parentAggregationLastL1RollingHashMessageNumber,
+      );
+
+      // Setup LineaRollup state so that its references to past state, mirror the references in the finalization proof
+      await betaV1LineaRollup.setLastFinalizedShnarf(betaV1FinalizationData.parentAggregationFinalShnarf);
+      await betaV1LineaRollup.setLastFinalizedState(
+        betaV1FinalizationData.parentAggregationLastL1RollingHashMessageNumber,
+        betaV1FinalizationData.parentAggregationLastL1RollingHash,
+        betaV1FinalizationData.parentAggregationLastBlockTimestamp,
+      );
+      await betaV1LineaRollup.setRollingHash(
+        betaV1FinalizationData.l1RollingHashMessageNumber,
+        betaV1FinalizationData.l1RollingHash,
+      );
+
+      // *** ACT ***
+      const finalizeCompressedCall = betaV1LineaRollup
+        .connect(operator)
+        .finalizeBlocks(betaV1FinalizationData.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData);
+
+      // *** ASSERT ***
+      const eventArgs = [
+        BigInt(betaV1FinalizationData.lastFinalizedBlockNumber) + 1n,
+        finalizationData.endBlockNumber,
+        betaV1FinalizationData.finalShnarf,
+        finalizationData.parentStateRootHash,
+        finalBlobFile.finalStateRootHash,
+      ];
+
+      await expectEvent(betaV1LineaRollup, finalizeCompressedCall, "DataFinalizedV3", eventArgs);
+
+      const [expectedFinalStateRootHash, lastFinalizedBlockNumber, lastFinalizedState] = await Promise.all([
+        betaV1LineaRollup.stateRootHashes(finalizationData.endBlockNumber),
+        betaV1LineaRollup.currentL2BlockNumber(),
+        betaV1LineaRollup.currentFinalizedState(),
+      ]);
+
+      expect(expectedFinalStateRootHash).to.equal(finalizationData.shnarfData.finalStateRootHash);
+      expect(lastFinalizedBlockNumber).to.equal(finalizationData.endBlockNumber);
+      expect(lastFinalizedState).to.equal(
+        generateKeccak256(
+          ["uint256", "bytes32", "uint256"],
+          [
+            finalizationData.l1RollingHashMessageNumber,
+            finalizationData.l1RollingHash,
+            finalizationData.finalTimestamp,
+          ],
+        ),
+      );
+    });
+  });
+
+  describe("Prover Beta V1.4", () => {
+    it("Can submit blobs and finalize with Prover Beta V1.4", async () => {
+      // *** ARRANGE ***
+      const mainnetFullVerifier = await deployPlonkVerifierMainnetFull();
+
+      // Deploy and initialize LineaRollup
+      const initializationData = {
+        initialStateRootHash: betaV1_4PostReleaseFinalizationData.parentStateRootHash,
+        initialL2BlockNumber: betaV1_4PostReleaseFinalizationData.lastFinalizedBlockNumber,
+        genesisTimestamp: betaV1_4PostReleaseFinalizationData.parentAggregationLastBlockTimestamp,
+        defaultVerifier: mainnetFullVerifier,
+        rateLimitPeriodInSeconds: ONE_DAY_IN_SECONDS,
+        rateLimitAmountInWei: INITIAL_WITHDRAW_LIMIT,
+        roleAddresses,
+        pauseTypeRoles: LINEA_ROLLUP_PAUSE_TYPES_ROLES,
+        unpauseTypeRoles: LINEA_ROLLUP_UNPAUSE_TYPES_ROLES,
+        fallbackOperator: FALLBACK_OPERATOR_ADDRESS,
+        defaultAdmin: securityCouncil.address,
+      };
+
+      const betaV1_4LineaRollup = (await deployUpgradableFromFactory("TestLineaRollup", [initializationData], {
+        initializer: LINEA_ROLLUP_INITIALIZE_SIGNATURE,
+        unsafeAllow: ["constructor", "incorrect-initializer-order"],
+      })) as unknown as TestLineaRollup;
+
+      await betaV1_4LineaRollup.setupParentShnarf(betaV1_4PostReleaseFinalizationData.parentAggregationFinalShnarf);
+
+      // Send blobs
+      const blobFiles = getVersionedBlobFiles("betaV1_4/postRelease");
+
+      for (let i = 0; i < blobFiles.length; i++) {
+        await sendVersionedBlobTransactionFromFile(
+          lineaRollup,
+          blobFiles[i],
+          betaV1_4LineaRollup,
+          "betaV1_4/postRelease",
+        );
+      }
+
+      const finalBlobFile = JSON.parse(
+        fs.readFileSync(`${__dirname}/../../_testData/betaV1_4/postRelease/${blobFiles.slice(-1)[0]}`, "utf-8"),
+      );
+
+      // Setup finalize call
+      const finalizationData = await generateFinalizationData({
+        l1RollingHash: betaV1_4PostReleaseFinalizationData.l1RollingHash,
+        l1RollingHashMessageNumber: BigInt(betaV1_4PostReleaseFinalizationData.l1RollingHashMessageNumber),
+        lastFinalizedTimestamp: BigInt(betaV1_4PostReleaseFinalizationData.parentAggregationLastBlockTimestamp),
+        endBlockNumber: BigInt(betaV1_4PostReleaseFinalizationData.finalBlockNumber),
+        parentStateRootHash: betaV1_4PostReleaseFinalizationData.parentStateRootHash,
+        finalTimestamp: BigInt(betaV1_4PostReleaseFinalizationData.finalTimestamp),
+        l2MerkleRoots: betaV1_4PostReleaseFinalizationData.l2MerkleRoots,
+        l2MerkleTreesDepth: BigInt(betaV1_4PostReleaseFinalizationData.l2MerkleTreesDepth),
+        l2MessagingBlocksOffsets: betaV1_4PostReleaseFinalizationData.l2MessagingBlocksOffsets,
+        aggregatedProof: betaV1_4PostReleaseFinalizationData.aggregatedProof,
+        shnarfData: {
+          parentShnarf: finalBlobFile.prevShnarf,
+          snarkHash: finalBlobFile.snarkHash,
+          finalStateRootHash: finalBlobFile.finalStateRootHash,
+          dataEvaluationPoint: finalBlobFile.expectedX,
+          dataEvaluationClaim: finalBlobFile.expectedY,
+        },
+      });
+
+      finalizationData.lastFinalizedL1RollingHash =
+        betaV1_4PostReleaseFinalizationData.parentAggregationLastL1RollingHash;
+      finalizationData.lastFinalizedL1RollingHashMessageNumber = BigInt(
+        betaV1_4PostReleaseFinalizationData.parentAggregationLastL1RollingHashMessageNumber,
+      );
+
+      // Setup LineaRollup state so that its references to past state, mirror the references in the finalization proof
+      await betaV1_4LineaRollup.setLastFinalizedShnarf(
+        betaV1_4PostReleaseFinalizationData.parentAggregationFinalShnarf,
+      );
+      await betaV1_4LineaRollup.setLastFinalizedState(
+        betaV1_4PostReleaseFinalizationData.parentAggregationLastL1RollingHashMessageNumber,
+        betaV1_4PostReleaseFinalizationData.parentAggregationLastL1RollingHash,
+        betaV1_4PostReleaseFinalizationData.parentAggregationLastBlockTimestamp,
+      );
+      await betaV1_4LineaRollup.setRollingHash(
+        betaV1_4PostReleaseFinalizationData.l1RollingHashMessageNumber,
+        betaV1_4PostReleaseFinalizationData.l1RollingHash,
+      );
+
+      // *** ACT ***
+      const finalizeCompressedCall = betaV1_4LineaRollup
+        .connect(operator)
+        .finalizeBlocks(
+          betaV1_4PostReleaseFinalizationData.aggregatedProof,
+          TEST_PUBLIC_VERIFIER_INDEX,
+          finalizationData,
+        );
+
+      // *** ASSERT ***
+      const eventArgs = [
+        BigInt(betaV1_4PostReleaseFinalizationData.lastFinalizedBlockNumber) + 1n,
+        finalizationData.endBlockNumber,
+        betaV1_4PostReleaseFinalizationData.finalShnarf,
+        finalizationData.parentStateRootHash,
+        finalBlobFile.finalStateRootHash,
+      ];
+
+      await expectEvent(betaV1_4LineaRollup, finalizeCompressedCall, "DataFinalizedV3", eventArgs);
+
+      const [expectedFinalStateRootHash, lastFinalizedBlockNumber, lastFinalizedState] = await Promise.all([
+        betaV1_4LineaRollup.stateRootHashes(finalizationData.endBlockNumber),
+        betaV1_4LineaRollup.currentL2BlockNumber(),
+        betaV1_4LineaRollup.currentFinalizedState(),
+      ]);
+
+      expect(expectedFinalStateRootHash).to.equal(finalizationData.shnarfData.finalStateRootHash);
+      expect(lastFinalizedBlockNumber).to.equal(finalizationData.endBlockNumber);
+      expect(lastFinalizedState).to.equal(
+        generateKeccak256(
+          ["uint256", "bytes32", "uint256"],
+          [
+            finalizationData.l1RollingHashMessageNumber,
+            finalizationData.l1RollingHash,
+            finalizationData.finalTimestamp,
+          ],
+        ),
+      );
+    });
+
+    it("Should fail to finalize Prover Beta V1.4 blobs with Dev Verifier", async () => {
+      // *** ARRANGE ***
+      const devVerifier = await deployPlonkVerifierDev();
+
+      // Deploy and initialize LineaRollup
+      const initializationData = {
+        initialStateRootHash: betaV1_4PostReleaseFinalizationData.parentStateRootHash,
+        initialL2BlockNumber: betaV1_4PostReleaseFinalizationData.lastFinalizedBlockNumber,
+        genesisTimestamp: betaV1_4PostReleaseFinalizationData.parentAggregationLastBlockTimestamp,
+        defaultVerifier: devVerifier,
+        rateLimitPeriodInSeconds: ONE_DAY_IN_SECONDS,
+        rateLimitAmountInWei: INITIAL_WITHDRAW_LIMIT,
+        roleAddresses,
+        pauseTypeRoles: LINEA_ROLLUP_PAUSE_TYPES_ROLES,
+        unpauseTypeRoles: LINEA_ROLLUP_UNPAUSE_TYPES_ROLES,
+        fallbackOperator: FALLBACK_OPERATOR_ADDRESS,
+        defaultAdmin: securityCouncil.address,
+      };
+
+      const betaV1_4LineaRollup = (await deployUpgradableFromFactory("TestLineaRollup", [initializationData], {
+        initializer: LINEA_ROLLUP_INITIALIZE_SIGNATURE,
+        unsafeAllow: ["constructor", "incorrect-initializer-order"],
+      })) as unknown as TestLineaRollup;
+
+      await betaV1_4LineaRollup.setupParentShnarf(betaV1_4PostReleaseFinalizationData.parentAggregationFinalShnarf);
+
+      // Send blobs
+      const blobFiles = getVersionedBlobFiles("betaV1_4/postRelease");
+
+      for (let i = 0; i < blobFiles.length; i++) {
+        await sendVersionedBlobTransactionFromFile(
+          lineaRollup,
+          blobFiles[i],
+          betaV1_4LineaRollup,
+          "betaV1_4/postRelease",
+        );
+      }
+
+      const finalBlobFile = JSON.parse(
+        fs.readFileSync(`${__dirname}/../../_testData/betaV1_4/postRelease/${blobFiles.slice(-1)[0]}`, "utf-8"),
+      );
+
+      // Setup finalize call
+      const finalizationData = await generateFinalizationData({
+        l1RollingHash: betaV1_4PostReleaseFinalizationData.l1RollingHash,
+        l1RollingHashMessageNumber: BigInt(betaV1_4PostReleaseFinalizationData.l1RollingHashMessageNumber),
+        lastFinalizedTimestamp: BigInt(betaV1_4PostReleaseFinalizationData.parentAggregationLastBlockTimestamp),
+        endBlockNumber: BigInt(betaV1_4PostReleaseFinalizationData.finalBlockNumber),
+        parentStateRootHash: betaV1_4PostReleaseFinalizationData.parentStateRootHash,
+        finalTimestamp: BigInt(betaV1_4PostReleaseFinalizationData.finalTimestamp),
+        l2MerkleRoots: betaV1_4PostReleaseFinalizationData.l2MerkleRoots,
+        l2MerkleTreesDepth: BigInt(betaV1_4PostReleaseFinalizationData.l2MerkleTreesDepth),
+        l2MessagingBlocksOffsets: betaV1_4PostReleaseFinalizationData.l2MessagingBlocksOffsets,
+        aggregatedProof: betaV1_4PostReleaseFinalizationData.aggregatedProof,
+        shnarfData: {
+          parentShnarf: finalBlobFile.prevShnarf,
+          snarkHash: finalBlobFile.snarkHash,
+          finalStateRootHash: finalBlobFile.finalStateRootHash,
+          dataEvaluationPoint: finalBlobFile.expectedX,
+          dataEvaluationClaim: finalBlobFile.expectedY,
+        },
+      });
+
+      finalizationData.lastFinalizedL1RollingHash =
+        betaV1_4PostReleaseFinalizationData.parentAggregationLastL1RollingHash;
+      finalizationData.lastFinalizedL1RollingHashMessageNumber = BigInt(
+        betaV1_4PostReleaseFinalizationData.parentAggregationLastL1RollingHashMessageNumber,
+      );
+
+      // Setup LineaRollup state so that its references to past state, mirror the references in the finalization proof
+      await betaV1_4LineaRollup.setLastFinalizedShnarf(
+        betaV1_4PostReleaseFinalizationData.parentAggregationFinalShnarf,
+      );
+      await betaV1_4LineaRollup.setLastFinalizedState(
+        betaV1_4PostReleaseFinalizationData.parentAggregationLastL1RollingHashMessageNumber,
+        betaV1_4PostReleaseFinalizationData.parentAggregationLastL1RollingHash,
+        betaV1_4PostReleaseFinalizationData.parentAggregationLastBlockTimestamp,
+      );
+      await betaV1_4LineaRollup.setRollingHash(
+        betaV1_4PostReleaseFinalizationData.l1RollingHashMessageNumber,
+        betaV1_4PostReleaseFinalizationData.l1RollingHash,
+      );
+
+      // *** ACT ***
+      const finalizeCompressedCall = betaV1_4LineaRollup
+        .connect(operator)
+        .finalizeBlocks(
+          betaV1_4PostReleaseFinalizationData.aggregatedProof,
+          TEST_PUBLIC_VERIFIER_INDEX,
+          finalizationData,
+        );
+
+      // *** ASSERT ***
+      await expectRevertWithCustomError(betaV1_4LineaRollup, finalizeCompressedCall, "InvalidProof");
+    });
+
+    it("Can migrate Dev Verifier to Prover Beta V1.4 successfully", async () => {
+      /**
+       * Test outline
+       * 1. Submit blob and finalize with old verifier
+       * 2. Set to new verifier
+       * 3. Submit blob and finalize with new verifier
+       */
+
+      const devVerifier = await deployPlonkVerifierDev();
+      const newMainnetFullVerifier = await deployPlonkVerifierMainnetFull();
+
+      const initializationData = {
+        initialStateRootHash: betaV1_4PreReleaseFinalizationData.parentStateRootHash,
+        initialL2BlockNumber: betaV1_4PreReleaseFinalizationData.lastFinalizedBlockNumber,
+        genesisTimestamp: betaV1_4PreReleaseFinalizationData.parentAggregationLastBlockTimestamp,
+        defaultVerifier: devVerifier,
+        rateLimitPeriodInSeconds: ONE_DAY_IN_SECONDS,
+        rateLimitAmountInWei: INITIAL_WITHDRAW_LIMIT,
+        roleAddresses,
+        pauseTypeRoles: LINEA_ROLLUP_PAUSE_TYPES_ROLES,
+        unpauseTypeRoles: LINEA_ROLLUP_UNPAUSE_TYPES_ROLES,
+        fallbackOperator: FALLBACK_OPERATOR_ADDRESS,
+        defaultAdmin: securityCouncil.address,
+      };
+
+      const lineaRollup = (await deployUpgradableFromFactory("TestLineaRollup", [initializationData], {
+        initializer: LINEA_ROLLUP_INITIALIZE_SIGNATURE,
+        unsafeAllow: ["constructor", "incorrect-initializer-order"],
+      })) as unknown as TestLineaRollup;
+
+      /**
+       * PHASE 1 - Submit blobs and finalize with old verifier
+       */
+
+      // Submit blobs
+      await lineaRollup.setupParentShnarf(betaV1_4PreReleaseFinalizationData.parentAggregationFinalShnarf);
+      const blobFiles = getVersionedBlobFiles("betaV1_4/preRelease");
+      for (let i = 0; i < blobFiles.length; i++) {
+        await sendVersionedBlobTransactionFromFile(lineaRollup, blobFiles[i], lineaRollup, "betaV1_4/preRelease");
+      }
+      const finalBlobFile = JSON.parse(
+        fs.readFileSync(`${__dirname}/../../_testData/betaV1_4/preRelease/${blobFiles.slice(-1)[0]}`, "utf-8"),
+      );
+
+      // Finalize
+      const finalizationData = await generateFinalizationData({
+        l1RollingHash: betaV1_4PreReleaseFinalizationData.l1RollingHash,
+        l1RollingHashMessageNumber: BigInt(betaV1_4PreReleaseFinalizationData.l1RollingHashMessageNumber),
+        lastFinalizedTimestamp: BigInt(betaV1_4PreReleaseFinalizationData.parentAggregationLastBlockTimestamp),
+        endBlockNumber: BigInt(betaV1_4PreReleaseFinalizationData.finalBlockNumber),
+        parentStateRootHash: betaV1_4PreReleaseFinalizationData.parentStateRootHash,
+        finalTimestamp: BigInt(betaV1_4PreReleaseFinalizationData.finalTimestamp),
+        l2MerkleRoots: betaV1_4PreReleaseFinalizationData.l2MerkleRoots,
+        l2MerkleTreesDepth: BigInt(betaV1_4PreReleaseFinalizationData.l2MerkleTreesDepth),
+        l2MessagingBlocksOffsets: betaV1_4PreReleaseFinalizationData.l2MessagingBlocksOffsets,
+        aggregatedProof: betaV1_4PreReleaseFinalizationData.aggregatedProof,
+        shnarfData: {
+          parentShnarf: finalBlobFile.prevShnarf,
+          snarkHash: finalBlobFile.snarkHash,
+          finalStateRootHash: finalBlobFile.finalStateRootHash,
+          dataEvaluationPoint: finalBlobFile.expectedX,
+          dataEvaluationClaim: finalBlobFile.expectedY,
+        },
+      });
+      finalizationData.lastFinalizedL1RollingHash =
+        betaV1_4PreReleaseFinalizationData.parentAggregationLastL1RollingHash;
+      finalizationData.lastFinalizedL1RollingHashMessageNumber = BigInt(
+        betaV1_4PreReleaseFinalizationData.parentAggregationLastL1RollingHashMessageNumber,
+      );
+
+      await lineaRollup.setLastFinalizedShnarf(betaV1_4PreReleaseFinalizationData.parentAggregationFinalShnarf);
+      await lineaRollup.setLastFinalizedState(
+        betaV1_4PreReleaseFinalizationData.parentAggregationLastL1RollingHashMessageNumber,
+        betaV1_4PreReleaseFinalizationData.parentAggregationLastL1RollingHash,
+        betaV1_4PreReleaseFinalizationData.parentAggregationLastBlockTimestamp,
+      );
+      await lineaRollup.setRollingHash(
+        betaV1_4PreReleaseFinalizationData.l1RollingHashMessageNumber,
+        betaV1_4PreReleaseFinalizationData.l1RollingHash,
+      );
+
+      const finalizeCompressedCall = lineaRollup
+        .connect(operator)
+        .finalizeBlocks(
+          betaV1_4PreReleaseFinalizationData.aggregatedProof,
+          TEST_PUBLIC_VERIFIER_INDEX,
+          finalizationData,
+        );
+
+      const eventArgs = [
+        BigInt(betaV1_4PreReleaseFinalizationData.lastFinalizedBlockNumber) + 1n,
+        finalizationData.endBlockNumber,
+        betaV1_4PreReleaseFinalizationData.finalShnarf,
+        finalizationData.parentStateRootHash,
+        finalBlobFile.finalStateRootHash,
+      ];
+
+      await expectEvent(lineaRollup, finalizeCompressedCall, "DataFinalizedV3", eventArgs);
+
+      const [expectedFinalStateRootHash, lastFinalizedBlockNumber, lastFinalizedState] = await Promise.all([
+        lineaRollup.stateRootHashes(finalizationData.endBlockNumber),
+        lineaRollup.currentL2BlockNumber(),
+        lineaRollup.currentFinalizedState(),
+      ]);
+
+      expect(expectedFinalStateRootHash).to.equal(finalizationData.shnarfData.finalStateRootHash);
+      expect(lastFinalizedBlockNumber).to.equal(finalizationData.endBlockNumber);
+      expect(lastFinalizedState).to.equal(
+        generateKeccak256(
+          ["uint256", "bytes32", "uint256"],
+          [
+            finalizationData.l1RollingHashMessageNumber,
+            finalizationData.l1RollingHash,
+            finalizationData.finalTimestamp,
+          ],
+        ),
+      );
+
+      /**
+       * PHASE 2 - Set to new verifier
+       */
+
+      await lineaRollup
+        .connect(securityCouncil)
+        .setVerifierAddress(newMainnetFullVerifier, TEST_NEW_PUBLIC_VERIFIER_INDEX);
+
+      /**
+       * PHASE 3 - Submit blobs and finalize with new verifier
+       */
+
+      // Submit blobs
+      const newBlobFiles = getVersionedBlobFiles("betaV1_4/postRelease");
+      for (let i = 0; i < newBlobFiles.length; i++) {
+        await sendVersionedBlobTransactionFromFile(lineaRollup, newBlobFiles[i], lineaRollup, "betaV1_4/postRelease");
+      }
+      const newFinalBlobFile = JSON.parse(
+        fs.readFileSync(`${__dirname}/../../_testData/betaV1_4/postRelease/${newBlobFiles.slice(-1)[0]}`, "utf-8"),
+      );
+
+      // Finalize
+      const newFinalizationData = await generateFinalizationData({
+        l1RollingHash: betaV1_4PostReleaseFinalizationData.l1RollingHash,
+        l1RollingHashMessageNumber: BigInt(betaV1_4PostReleaseFinalizationData.l1RollingHashMessageNumber),
+        lastFinalizedTimestamp: BigInt(betaV1_4PostReleaseFinalizationData.parentAggregationLastBlockTimestamp),
+        endBlockNumber: BigInt(betaV1_4PostReleaseFinalizationData.finalBlockNumber),
+        parentStateRootHash: betaV1_4PostReleaseFinalizationData.parentStateRootHash,
+        finalTimestamp: BigInt(betaV1_4PostReleaseFinalizationData.finalTimestamp),
+        l2MerkleRoots: betaV1_4PostReleaseFinalizationData.l2MerkleRoots,
+        l2MerkleTreesDepth: BigInt(betaV1_4PostReleaseFinalizationData.l2MerkleTreesDepth),
+        l2MessagingBlocksOffsets: betaV1_4PostReleaseFinalizationData.l2MessagingBlocksOffsets,
+        aggregatedProof: betaV1_4PostReleaseFinalizationData.aggregatedProof,
+        shnarfData: {
+          parentShnarf: newFinalBlobFile.prevShnarf,
+          snarkHash: newFinalBlobFile.snarkHash,
+          finalStateRootHash: newFinalBlobFile.finalStateRootHash,
+          dataEvaluationPoint: newFinalBlobFile.expectedX,
+          dataEvaluationClaim: newFinalBlobFile.expectedY,
+        },
+      });
+      newFinalizationData.lastFinalizedL1RollingHash =
+        betaV1_4PostReleaseFinalizationData.parentAggregationLastL1RollingHash;
+      newFinalizationData.lastFinalizedL1RollingHashMessageNumber = BigInt(
+        betaV1_4PostReleaseFinalizationData.parentAggregationLastL1RollingHashMessageNumber,
+      );
+
+      const newFinalizeCompressedCall = lineaRollup
+        .connect(operator)
+        .finalizeBlocks(
+          betaV1_4PostReleaseFinalizationData.aggregatedProof,
+          TEST_NEW_PUBLIC_VERIFIER_INDEX,
+          newFinalizationData,
+        );
+
+      const newEventArgs = [
+        BigInt(betaV1_4PostReleaseFinalizationData.lastFinalizedBlockNumber) + 1n,
+        newFinalizationData.endBlockNumber,
+        betaV1_4PostReleaseFinalizationData.finalShnarf,
+        newFinalizationData.parentStateRootHash,
+        newFinalBlobFile.finalStateRootHash,
+      ];
+
+      await expectEvent(lineaRollup, newFinalizeCompressedCall, "DataFinalizedV3", newEventArgs);
+
+      const [newExpectedFinalStateRootHash, newLastFinalizedBlockNumber, newLastFinalizedState] = await Promise.all([
+        lineaRollup.stateRootHashes(newFinalizationData.endBlockNumber),
+        lineaRollup.currentL2BlockNumber(),
+        lineaRollup.currentFinalizedState(),
+      ]);
+
+      expect(newExpectedFinalStateRootHash).to.equal(newFinalizationData.shnarfData.finalStateRootHash);
+      expect(newLastFinalizedBlockNumber).to.equal(newFinalizationData.endBlockNumber);
+      expect(newLastFinalizedState).to.equal(
+        generateKeccak256(
+          ["uint256", "bytes32", "uint256"],
+          [
+            newFinalizationData.l1RollingHashMessageNumber,
+            newFinalizationData.l1RollingHash,
+            newFinalizationData.finalTimestamp,
+          ],
+        ),
+      );
+    });
+  });
 });

contracts/test/hardhat/rollup/LineaRollup/Finalization.ts

@@ -1,42 +1,26 @@
 import { SignerWithAddress } from "@nomicfoundation/hardhat-ethers/signers";
 import { loadFixture, time as networkTime } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
-import * as fs from "fs";
 import { ethers } from "hardhat";
 
 import aggregatedProof1To81 from "../../_testData/compressedData/multipleProofs/aggregatedProof-1-81.json";
 import aggregatedProof82To153 from "../../_testData/compressedData/multipleProofs/aggregatedProof-82-153.json";
-import betaV1FinalizationData from "../../_testData/betaV1/proof/7027059-7042723-d2221f5035e3dcbbc46e8a6130fef34fdec33c252b7d31fb8afa6848660260ba-getZkAggregatedProof.json";
 import calldataAggregatedProof1To155 from "../../_testData/compressedData/aggregatedProof-1-155.json";
 import secondCompressedDataContent from "../../_testData/compressedData/blocks-47-81.json";
 import fourthCompressedDataContent from "../../_testData/compressedData/blocks-115-155.json";
 import fourthMultipleCompressedDataContent from "../../_testData/compressedData/multipleProofs/blocks-120-153.json";
 
-import { LINEA_ROLLUP_PAUSE_TYPES_ROLES, LINEA_ROLLUP_UNPAUSE_TYPES_ROLES } from "contracts/common/constants";
 import { TestLineaRollup } from "contracts/typechain-types";
+import { expectSuccessfulFinalize, getAccountsFixture, deployLineaRollupFixture } from "./../helpers";
 import {
-  deployPlonkVerifierSepoliaFull,
-  expectSuccessfulFinalize,
-  getAccountsFixture,
-  getBetaV1BlobFiles,
-  getRoleAddressesFixture,
-  deployLineaRollupFixture,
-  sendBlobTransactionFromFile,
-} from "./../helpers";
-import {
-  FALLBACK_OPERATOR_ADDRESS,
   GENERAL_PAUSE_TYPE,
   HASH_ZERO,
-  INITIAL_WITHDRAW_LIMIT,
-  ONE_DAY_IN_SECONDS,
   OPERATOR_ROLE,
   TEST_PUBLIC_VERIFIER_INDEX,
   EMPTY_CALLDATA,
   FINALIZATION_PAUSE_TYPE,
   DEFAULT_LAST_FINALIZED_TIMESTAMP,
-  LINEA_ROLLUP_INITIALIZE_SIGNATURE,
 } from "../../common/constants";
-import { deployUpgradableFromFactory } from "../../common/deployment";
 import {
   calculateRollingHash,
   generateFinalizationData,
@@ -44,7 +28,6 @@ import {
   generateCallDataSubmission,
   generateCallDataSubmissionMultipleProofs,
   generateKeccak256,
-  expectEvent,
   buildAccessErrorMessage,
   expectRevertWithCustomError,
   expectRevertWithReason,
@@ -55,17 +38,14 @@ import {
 
 describe("Linea Rollup contract: Finalization", () => {
   let lineaRollup: TestLineaRollup;
-  let sepoliaFullVerifier: string;
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   let securityCouncil: SignerWithAddress;
   let operator: SignerWithAddress;
   let nonAuthorizedAccount: SignerWithAddress;
-  let roleAddresses: { addressWithRole: string; role: string }[];
 
   before(async () => {
     ({ securityCouncil, operator, nonAuthorizedAccount } = await loadFixture(getAccountsFixture));
-    roleAddresses = await loadFixture(getRoleAddressesFixture);
   });
 
   beforeEach(async () => {
@@ -342,108 +322,6 @@ describe("Linea Rollup contract: Finalization", () => {
         await expectRevertWithCustomError(lineaRollup, finalizeCall, "FinalBlockStateEqualsZeroHash");
       });
     });
-
-    it("Can submit blobs and finalize with Prover Beta V1", async () => {
-      const blobFiles = getBetaV1BlobFiles();
-      const finalBlobFile = JSON.parse(
-        fs.readFileSync(`${__dirname}/../../_testData/betaV1/${blobFiles.slice(-1)[0]}`, "utf-8"),
-      );
-      sepoliaFullVerifier = await deployPlonkVerifierSepoliaFull();
-
-      const initializationData = {
-        initialStateRootHash: betaV1FinalizationData.parentStateRootHash,
-        initialL2BlockNumber: betaV1FinalizationData.lastFinalizedBlockNumber,
-        genesisTimestamp: betaV1FinalizationData.parentAggregationLastBlockTimestamp,
-        defaultVerifier: sepoliaFullVerifier,
-        rateLimitPeriodInSeconds: ONE_DAY_IN_SECONDS,
-        rateLimitAmountInWei: INITIAL_WITHDRAW_LIMIT,
-        roleAddresses,
-        pauseTypeRoles: LINEA_ROLLUP_PAUSE_TYPES_ROLES,
-        unpauseTypeRoles: LINEA_ROLLUP_UNPAUSE_TYPES_ROLES,
-        fallbackOperator: FALLBACK_OPERATOR_ADDRESS,
-        defaultAdmin: securityCouncil.address,
-      };
-
-      const betaV1LineaRollup = (await deployUpgradableFromFactory("TestLineaRollup", [initializationData], {
-        initializer: LINEA_ROLLUP_INITIALIZE_SIGNATURE,
-        unsafeAllow: ["constructor", "incorrect-initializer-order"],
-      })) as unknown as TestLineaRollup;
-
-      await betaV1LineaRollup.setupParentShnarf(betaV1FinalizationData.parentAggregationFinalShnarf);
-      await betaV1LineaRollup.setLastFinalizedShnarf(betaV1FinalizationData.parentAggregationFinalShnarf);
-
-      for (let i = 0; i < blobFiles.length; i++) {
-        await sendBlobTransactionFromFile(lineaRollup, blobFiles[i], betaV1LineaRollup);
-      }
-
-      const finalizationData = await generateFinalizationData({
-        l1RollingHash: betaV1FinalizationData.l1RollingHash,
-        l1RollingHashMessageNumber: BigInt(betaV1FinalizationData.l1RollingHashMessageNumber),
-        lastFinalizedTimestamp: BigInt(betaV1FinalizationData.parentAggregationLastBlockTimestamp),
-        endBlockNumber: BigInt(betaV1FinalizationData.finalBlockNumber),
-        parentStateRootHash: betaV1FinalizationData.parentStateRootHash,
-        finalTimestamp: BigInt(betaV1FinalizationData.finalTimestamp),
-        l2MerkleRoots: betaV1FinalizationData.l2MerkleRoots,
-        l2MerkleTreesDepth: BigInt(betaV1FinalizationData.l2MerkleTreesDepth),
-        l2MessagingBlocksOffsets: betaV1FinalizationData.l2MessagingBlocksOffsets,
-        aggregatedProof: betaV1FinalizationData.aggregatedProof,
-        shnarfData: {
-          parentShnarf: finalBlobFile.prevShnarf,
-          snarkHash: finalBlobFile.snarkHash,
-          finalStateRootHash: finalBlobFile.finalStateRootHash,
-          dataEvaluationPoint: finalBlobFile.expectedX,
-          dataEvaluationClaim: finalBlobFile.expectedY,
-        },
-      });
-
-      finalizationData.lastFinalizedL1RollingHash = betaV1FinalizationData.parentAggregationLastL1RollingHash;
-      finalizationData.lastFinalizedL1RollingHashMessageNumber = BigInt(
-        betaV1FinalizationData.parentAggregationLastL1RollingHashMessageNumber,
-      );
-
-      await betaV1LineaRollup.setLastFinalizedState(
-        betaV1FinalizationData.parentAggregationLastL1RollingHashMessageNumber,
-        betaV1FinalizationData.parentAggregationLastL1RollingHash,
-        betaV1FinalizationData.parentAggregationLastBlockTimestamp,
-      );
-      await betaV1LineaRollup.setRollingHash(
-        betaV1FinalizationData.l1RollingHashMessageNumber,
-        betaV1FinalizationData.l1RollingHash,
-      );
-
-      const finalizeCompressedCall = betaV1LineaRollup
-        .connect(operator)
-        .finalizeBlocks(betaV1FinalizationData.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData);
-
-      const eventArgs = [
-        BigInt(betaV1FinalizationData.lastFinalizedBlockNumber) + 1n,
-        finalizationData.endBlockNumber,
-        betaV1FinalizationData.finalShnarf,
-        finalizationData.parentStateRootHash,
-        finalBlobFile.finalStateRootHash,
-      ];
-
-      await expectEvent(betaV1LineaRollup, finalizeCompressedCall, "DataFinalizedV3", eventArgs);
-
-      const [expectedFinalStateRootHash, lastFinalizedBlockNumber, lastFinalizedState] = await Promise.all([
-        betaV1LineaRollup.stateRootHashes(finalizationData.endBlockNumber),
-        betaV1LineaRollup.currentL2BlockNumber(),
-        betaV1LineaRollup.currentFinalizedState(),
-      ]);
-
-      expect(expectedFinalStateRootHash).to.equal(finalizationData.shnarfData.finalStateRootHash);
-      expect(lastFinalizedBlockNumber).to.equal(finalizationData.endBlockNumber);
-      expect(lastFinalizedState).to.equal(
-        generateKeccak256(
-          ["uint256", "bytes32", "uint256"],
-          [
-            finalizationData.l1RollingHashMessageNumber,
-            finalizationData.l1RollingHash,
-            finalizationData.finalTimestamp,
-          ],
-        ),
-      );
-    });
   });
 
   describe("Compressed data finalization with proof", () => {

contracts/test/hardhat/rollup/helpers/blob.ts

@@ -62,20 +62,21 @@ export async function sendBlobTransaction(
   expectEventDirectFromReceiptData(lineaRollup as BaseContract, receipt!, "DataSubmittedV3", expectedEventArgs);
 }
 
-export async function sendBlobTransactionFromFile(
+export async function sendVersionedBlobTransactionFromFile(
   lineaRollup: TestLineaRollup,
   filePath: string,
-  betaV1LineaRollup: TestLineaRollup,
+  versionedLineaRollup: TestLineaRollup,
+  versionFolderName: string,
 ) {
   const operatorHDSigner = getWalletForIndex(2);
-  const lineaRollupAddress = await betaV1LineaRollup.getAddress();
+  const lineaRollupAddress = await versionedLineaRollup.getAddress();
 
   const {
     blobDataSubmission: blobSubmission,
     compressedBlobs: compressedBlobs,
     parentShnarf: parentShnarf,
     finalShnarf: finalShnarf,
-  } = generateBlobDataSubmissionFromFile(path.resolve(__dirname, "../../_testData/betaV1", filePath));
+  } = generateBlobDataSubmissionFromFile(path.resolve(__dirname, `../../_testData/${versionFolderName}`, filePath));
 
   const encodedCall = lineaRollup.interface.encodeFunctionData("submitBlobs", [
     blobSubmission,
@@ -157,9 +158,10 @@ export async function sendBlobTransactionViaCallForwarder(
   expectEventDirectFromReceiptData(lineaRollupUpgraded as BaseContract, receipt!, "DataSubmittedV3", expectedEventArgs);
 }
 
-export function getBetaV1BlobFiles(): string[] {
+// "betaV1" getBetaV1BlobFiles
+export function getVersionedBlobFiles(versionFolderName: string): string[] {
   // Read all files in the folder
-  const files = fs.readdirSync(path.resolve(__dirname, "../../_testData/betaV1"));
+  const files = fs.readdirSync(path.resolve(__dirname, `../../_testData/${versionFolderName}`));
 
   // Map files to their ranges and filter invalid ones
   const filesWithRanges = files

contracts/test/hardhat/rollup/helpers/deploy.ts

@@ -29,6 +29,27 @@ export async function deployPlonkVerifierSepoliaFull(): Promise<string> {
   return await verifier.getAddress();
 }
 
+export async function deployPlonkVerifierMainnetFull(): Promise<string> {
+  const plonkVerifierMainnetFull = await ethers.getContractFactory("PlonkVerifierMainnetFull");
+  const verifier = await plonkVerifierMainnetFull.deploy();
+  await verifier.waitForDeployment();
+  return await verifier.getAddress();
+}
+
+export async function deployPlonkVerifierDev(): Promise<string> {
+  const plonkVerifierDev = await ethers.getContractFactory("PlonkVerifierDev");
+  const verifier = await plonkVerifierDev.deploy();
+  await verifier.waitForDeployment();
+  return await verifier.getAddress();
+}
+
+export async function deployPlonkVerifierForMultiTypeDataAggregation(): Promise<string> {
+  const plonkVerifier = await ethers.getContractFactory("PlonkVerifierForMultiTypeDataAggregation");
+  const verifier = await plonkVerifier.deploy();
+  await verifier.waitForDeployment();
+  return await verifier.getAddress();
+}
+
 export async function deployCallForwardingProxy(target: string): Promise<CallForwardingProxy> {
   const callForwardingProxyFactory = await ethers.getContractFactory("CallForwardingProxy");
   const callForwardingProxy = await callForwardingProxyFactory.deploy(target);