add a new script

common/types/constructing-target-payload-tx-in-different-chunks/main.go

@@ -0,0 +1,133 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"math/big"
+	"time"
+
+	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
+	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/crypto"
+	"github.com/scroll-tech/go-ethereum/ethclient"
+	"github.com/scroll-tech/go-ethereum/rlp"
+)
+
+const targetTxSize = 126914
+
+func main() {
+	privateKeyHex := "0000000000000000000000000000000000000000000000000000000000000042"
+	privateKey, err := crypto.HexToECDSA(privateKeyHex)
+	if err != nil {
+		log.Fatalf("Invalid private key: %v", err)
+	}
+
+	client, err := ethclient.Dial("http://localhost:9999")
+	if err != nil {
+		log.Fatalf("Failed to connect to the Ethereum client: %v", err)
+	}
+
+	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(222222))
+	if err != nil {
+		log.Fatalf("Failed to create transactor with chain ID 222222: %v", err)
+	}
+
+	nonce, err := client.PendingNonceAt(context.Background(), auth.From)
+	if err != nil {
+		log.Fatalf("Failed to retrieve account nonce: %v", err)
+	}
+
+	totalTxNum := []uint64{2, 3, 4, 5, 6}
+	for _, num := range totalTxNum {
+		prepareAndSendTransactions(client, auth, nonce, num)
+		nonce += num
+	}
+}
+
+func prepareAndSendTransactions(client *ethclient.Client, auth *bind.TransactOpts, initialNonce uint64, totalTxNum uint64) error {
+	gasLimit := uint64(5000000)
+	gasPrice := big.NewInt(1000000000)
+
+	var signedTxs []*types.Transaction
+	payloadSum := 0
+
+	dataPayload := make([]byte, targetTxSize/totalTxNum)
+	for i := range dataPayload {
+		dataPayload[i] = 0xff
+	}
+
+	for i := uint64(0); i < totalTxNum-1; i++ {
+		txData := &types.LegacyTx{
+			Nonce:    initialNonce + i,
+			GasPrice: gasPrice,
+			Gas:      gasLimit,
+			To:       &auth.From,
+			Data:     dataPayload,
+		}
+
+		signedTx, err := auth.Signer(auth.From, types.NewTx(txData))
+		if err != nil {
+			log.Fatalf("Failed to sign tx: %v", err)
+		}
+
+		rlpTxData, err := rlp.EncodeToBytes(signedTx)
+		if err != nil {
+			log.Fatalf("Failed to RLP encode the tx: %v", err)
+		}
+
+		payloadSum += len(rlpTxData)
+		signedTxs = append(signedTxs, signedTx)
+	}
+
+	fmt.Println("payload sum", payloadSum)
+
+	lowerBound := 0
+	upperBound := targetTxSize
+	for lowerBound <= upperBound {
+		mid := (lowerBound + upperBound) / 2
+		data := make([]byte, mid)
+		for i := range data {
+			data[i] = 0xff
+		}
+
+		txData := &types.LegacyTx{
+			Nonce:    initialNonce + totalTxNum - 1,
+			GasPrice: gasPrice,
+			Gas:      gasLimit,
+			To:       &auth.From,
+			Data:     data,
+		}
+
+		signedTx, err := auth.Signer(auth.From, types.NewTx(txData))
+		if err != nil {
+			log.Fatalf("Failed to sign tx: %v", err)
+		}
+
+		rlpTxData, err := rlp.EncodeToBytes(signedTx)
+		if err != nil {
+			log.Fatalf("Failed to RLP encode the tx: %v", err)
+		}
+		txSize := len(rlpTxData)
+
+		if payloadSum+txSize < targetTxSize {
+			lowerBound = mid + 1
+		} else if payloadSum+txSize > targetTxSize {
+			upperBound = mid - 1
+		} else {
+			fmt.Println("payloadSum+txSize", payloadSum+txSize)
+			signedTxs = append(signedTxs, signedTx)
+			break
+		}
+	}
+
+	for _, signedTx := range signedTxs {
+		if err := client.SendTransaction(context.Background(), signedTx); err != nil {
+			return fmt.Errorf("failed to send transaction: %v", err)
+		}
+		fmt.Printf("Transaction with nonce %d sent\n", signedTx.Nonce())
+		time.Sleep(10 * time.Second)
+	}
+
+	return nil
+}

common/types/constructing-target-payload-tx/main.go

@@ -0,0 +1,131 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"math/big"
+
+	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
+	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/crypto"
+	"github.com/scroll-tech/go-ethereum/ethclient"
+	"github.com/scroll-tech/go-ethereum/rlp"
+)
+
+const targetTxSize = 120568
+
+func main() {
+	privateKeyHex := "0000000000000000000000000000000000000000000000000000000000000042"
+	privateKey, err := crypto.HexToECDSA(privateKeyHex)
+	if err != nil {
+		log.Fatalf("Invalid private key: %v", err)
+	}
+
+	client, err := ethclient.Dial("http://localhost:9999")
+	if err != nil {
+		log.Fatalf("Failed to connect to the Ethereum client: %v", err)
+	}
+
+	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(222222))
+	if err != nil {
+		log.Fatalf("Failed to create transactor with chain ID 222222: %v", err)
+	}
+
+	nonce, err := client.PendingNonceAt(context.Background(), auth.From)
+	if err != nil {
+		log.Fatalf("Failed to retrieve account nonce: %v", err)
+	}
+	prepareAndSendTransactions(client, auth, nonce, 1)
+	prepareAndSendTransactions(client, auth, nonce+1, 2)
+	prepareAndSendTransactions(client, auth, nonce+1+2, 3)
+	prepareAndSendTransactions(client, auth, nonce+1+2+3, 4)
+	prepareAndSendTransactions(client, auth, nonce+1+2+3+4, 5)
+	prepareAndSendTransactions(client, auth, nonce+1+2+3+4+5, 6)
+}
+
+func prepareAndSendTransactions(client *ethclient.Client, auth *bind.TransactOpts, initialNonce uint64, totalTxNum uint64) error {
+	gasLimit := uint64(5000000)
+	gasPrice := big.NewInt(1000000000)
+
+	var signedTxs []*types.Transaction
+	payloadSum := 0
+
+	dataPayload := make([]byte, targetTxSize/totalTxNum)
+	for i := range dataPayload {
+		dataPayload[i] = 0xff
+	}
+
+	for i := uint64(0); i < totalTxNum-1; i++ {
+		txData := &types.LegacyTx{
+			Nonce:    initialNonce + i,
+			GasPrice: gasPrice,
+			Gas:      gasLimit,
+			To:       &auth.From,
+			Data:     dataPayload,
+		}
+
+		signedTx, err := auth.Signer(auth.From, types.NewTx(txData))
+		if err != nil {
+			log.Fatalf("Failed to sign tx: %v", err)
+		}
+
+		rlpTxData, err := rlp.EncodeToBytes(signedTx)
+		if err != nil {
+			log.Fatalf("Failed to RLP encode the tx: %v", err)
+		}
+
+		payloadSum += len(rlpTxData)
+		signedTxs = append(signedTxs, signedTx)
+	}
+
+	fmt.Println("payload sum", payloadSum)
+
+	lowerBound := 0
+	upperBound := targetTxSize
+	for lowerBound <= upperBound {
+		mid := (lowerBound + upperBound) / 2
+		data := make([]byte, mid)
+		for i := range data {
+			data[i] = 0xff
+		}
+
+		txData := &types.LegacyTx{
+			Nonce:    initialNonce + totalTxNum - 1,
+			GasPrice: gasPrice,
+			Gas:      gasLimit,
+			To:       &auth.From,
+			Data:     data,
+		}
+
+		signedTx, err := auth.Signer(auth.From, types.NewTx(txData))
+		if err != nil {
+			log.Fatalf("Failed to sign tx: %v", err)
+		}
+
+		rlpTxData, err := rlp.EncodeToBytes(signedTx)
+		if err != nil {
+			log.Fatalf("Failed to RLP encode the tx: %v", err)
+		}
+		txSize := len(rlpTxData)
+
+		if payloadSum+txSize < targetTxSize {
+			lowerBound = mid + 1
+		} else if payloadSum+txSize > targetTxSize {
+			upperBound = mid - 1
+		} else {
+			fmt.Println("payloadSum+txSize", payloadSum+txSize)
+			signedTxs = append(signedTxs, signedTx)
+			break
+		}
+	}
+
+	for i := len(signedTxs) - 1; i >= 0; i-- {
+		if err := client.SendTransaction(context.Background(), signedTxs[i]); err != nil {
+			return fmt.Errorf("failed to send transaction: %v", err)
+		}
+		fmt.Printf("Transaction with nonce %d sent\n", signedTxs[i].Nonce())
+	}
+
+	return nil
+}

contracts/docs/apis/ScrollChain.md

@@ -67,7 +67,7 @@ Commit a batch of transactions on layer 1.
 function committedBatches(uint256) external view returns (bytes32)
 ```
 
-
+Return the batch hash of a committed batch.
 
 
 
@@ -81,46 +81,7 @@ function committedBatches(uint256) external view returns (bytes32)
 
 | Name | Type | Description |
 |---|---|---|
-| _0 | bytes32 | The batch hash of a committed batch. |
-
-### finalizeBatch
-
-```solidity
-function finalizeBatch(bytes _batchHeader, bytes32 _prevStateRoot, bytes32 _postStateRoot, bytes32 _withdrawRoot) external nonpayable
-```
-
-Finalize a committed batch on layer 1.
-
-*We keep this function to upgrade to 4844 more smoothly.*
-
-#### Parameters
-
-| Name | Type | Description |
-|---|---|---|
-| _batchHeader | bytes | undefined |
-| _prevStateRoot | bytes32 | undefined |
-| _postStateRoot | bytes32 | undefined |
-| _withdrawRoot | bytes32 | undefined |
-
-### finalizeBatch4844
-
-```solidity
-function finalizeBatch4844(bytes _batchHeader, bytes32 _prevStateRoot, bytes32 _postStateRoot, bytes32 _withdrawRoot, bytes _blobDataProof) external nonpayable
-```
-
-Finalize a committed batch (with blob) on layer 1.
-
-*Memory layout of `_blobDataProof`: ```text | z       | y       | kzg_commitment | kzg_proof | |---------|---------|----------------|-----------| | bytes32 | bytes32 | bytes48        | bytes48   | ```*
-
-#### Parameters
-
-| Name | Type | Description |
-|---|---|---|
-| _batchHeader | bytes | undefined |
-| _prevStateRoot | bytes32 | undefined |
-| _postStateRoot | bytes32 | undefined |
-| _withdrawRoot | bytes32 | undefined |
-| _blobDataProof | bytes | undefined |
+| _0 | bytes32 | undefined |
 
 ### finalizeBatchWithProof
 
@@ -169,7 +130,7 @@ Finalize a committed batch (with blob) on layer 1.
 function finalizedStateRoots(uint256) external view returns (bytes32)
 ```
 
-
+Return the state root of a committed batch.
 
 
 
@@ -183,7 +144,7 @@ function finalizedStateRoots(uint256) external view returns (bytes32)
 
 | Name | Type | Description |
 |---|---|---|
-| _0 | bytes32 | The state root of a committed batch. |
+| _0 | bytes32 | undefined |
 
 ### importGenesisBatch
 
@@ -199,8 +160,8 @@ Import layer 2 genesis block
 
 | Name | Type | Description |
 |---|---|---|
-| _batchHeader | bytes | The header of the genesis batch. |
-| _stateRoot | bytes32 | The state root of the genesis block. |
+| _batchHeader | bytes | undefined |
+| _stateRoot | bytes32 | undefined |
 
 ### initialize
 
@@ -226,7 +187,7 @@ Initialize the storage of ScrollChain.
 function isBatchFinalized(uint256 _batchIndex) external view returns (bool)
 ```
 
-
+Return whether the batch is finalized by batch index.
 
 
 
@@ -240,7 +201,7 @@ function isBatchFinalized(uint256 _batchIndex) external view returns (bool)
 
 | Name | Type | Description |
 |---|---|---|
-| _0 | bool | Whether the batch is finalized by batch index. |
+| _0 | bool | undefined |
 
 ### isProver
 
@@ -292,7 +253,7 @@ Whether an account is a sequencer.
 function lastFinalizedBatchIndex() external view returns (uint256)
 ```
 
-
+The latest finalized batch index.
 
 
 
@@ -301,7 +262,7 @@ function lastFinalizedBatchIndex() external view returns (uint256)
 
 | Name | Type | Description |
 |---|---|---|
-| _0 | uint256 | The latest finalized batch index. |
+| _0 | uint256 | undefined |
 
 ### layer2ChainId
 
@@ -519,7 +480,7 @@ The address of RollupVerifier.
 function withdrawRoots(uint256) external view returns (bytes32)
 ```
 
-
+Return the message root of a committed batch.
 
 
 
@@ -533,7 +494,7 @@ function withdrawRoots(uint256) external view returns (bytes32)
 
 | Name | Type | Description |
 |---|---|---|
-| _0 | bytes32 | The message root of a committed batch. |
+| _0 | bytes32 | undefined |
 
 
 

contracts/scripts/foundry/DeployEcc.s.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.8.24;
+
+import {Script} from "forge-std/Script.sol";
+import {console} from "forge-std/console.sol";
+
+import {Ecc} from "../../src/misc/ecc.sol";
+
+contract DeployEcc is Script {
+    function run() external {
+        uint256 L2_DEPLOYER_PRIVATE_KEY = vm.envUint("L2_DEPLOYER_PRIVATE_KEY");
+        vm.startBroadcast(L2_DEPLOYER_PRIVATE_KEY);
+        Ecc ecc = new Ecc();
+        address L2_ECC_ADDR = address(ecc);
+        vm.stopBroadcast();
+
+        logAddress("L2_ECC_ADDR", L2_ECC_ADDR);
+    }
+
+    function logAddress(string memory name, address addr) internal view {
+        console.log(string(abi.encodePacked(name, "=", vm.toString(address(addr)))));
+    }
+}

contracts/scripts/foundry/DeployHash.s.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.8.24;
+
+import {Script} from "forge-std/Script.sol";
+import {console} from "forge-std/console.sol";
+
+import {Hash} from "../../src/misc/hash.sol";
+
+contract DeployHash is Script {
+    function run() external {
+        uint256 L2_DEPLOYER_PRIVATE_KEY = vm.envUint("L2_DEPLOYER_PRIVATE_KEY");
+        vm.startBroadcast(L2_DEPLOYER_PRIVATE_KEY);
+        Hash hash = new Hash();
+        address L2_HASH_ADDR = address(hash);
+        vm.stopBroadcast();
+
+        logAddress("L2_HASH_ADDR", L2_HASH_ADDR);
+    }
+
+    function logAddress(string memory name, address addr) internal view {
+        console.log(string(abi.encodePacked(name, "=", vm.toString(address(addr)))));
+    }
+}

contracts/scripts/relay-skipped-tx.ts

@@ -0,0 +1,34 @@
+/* eslint-disable node/no-missing-import */
+import * as dotenv from "dotenv";
+
+import { ethers } from "hardhat";
+
+dotenv.config();
+
+async function main() {
+  const [deployer] = await ethers.getSigners();
+
+  const l1ScrollMessengerAddress = process.env.L1_SCROLL_MESSENGER_PROXY_ADDR!;
+  const l2EccContractAddress = process.env.L2_ECC_ADDR!;
+  const payload = process.env.SKIPPED_TX_PAYLOAD!; // TODO: calc the payload, parse as bytes
+
+  const L1ScrollMessenger = await ethers.getContractAt("L1ScrollMessenger", l1ScrollMessengerAddress, deployer);
+
+  const tx = await L1ScrollMessenger.sendMessage(
+    l2EccContractAddress, // address _to
+    0, // uint256 _value
+    payload, // bytes memory _message
+    100000000 // uint256 _gasLimit
+  );
+
+  console.log(`calling ${l2EccContractAddress} with payload from l1, hash:`, tx.hash);
+  const receipt = await tx.wait();
+  console.log(`✅ Done, gas used: ${receipt.gasUsed}`);
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

contracts/src/L1/rollup/IScrollChain.sol

@@ -87,18 +87,6 @@ interface IScrollChain {
     /// @param count The number of subsequent batches to revert, including current batch.
     function revertBatch(bytes calldata batchHeader, uint256 count) external;
 
-    /// @notice Finalize a committed batch on layer 1.
-    /// @param batchHeader The header of current batch, see the encoding in comments of `commitBatch.
-    /// @param prevStateRoot The state root of parent batch.
-    /// @param postStateRoot The state root of current batch.
-    /// @param withdrawRoot The withdraw trie root of current batch
-    function finalizeBatch(
-        bytes calldata batchHeader,
-        bytes32 prevStateRoot,
-        bytes32 postStateRoot,
-        bytes32 withdrawRoot
-    ) external;
-
     /// @notice Finalize a committed batch on layer 1.
     /// @param batchHeader The header of current batch, see the encoding in comments of `commitBatch.
     /// @param prevStateRoot The state root of parent batch.
@@ -113,26 +101,6 @@ interface IScrollChain {
         bytes calldata aggrProof
     ) external;
 
-    /// @notice Finalize a committed batch (with blob) on layer 1.
-    ///
-    /// @dev Memory layout of `blobDataProof`:
-    /// |    z    |    y    | kzg_commitment | kzg_proof |
-    /// |---------|---------|----------------|-----------|
-    /// | bytes32 | bytes32 |    bytes48     |  bytes48  |
-    ///
-    /// @param batchHeader The header of current batch, see the encoding in comments of `commitBatch.
-    /// @param prevStateRoot The state root of parent batch.
-    /// @param postStateRoot The state root of current batch.
-    /// @param withdrawRoot The withdraw trie root of current batch.
-    /// @param blobDataProof The proof for blob data.
-    function finalizeBatch4844(
-        bytes calldata batchHeader,
-        bytes32 prevStateRoot,
-        bytes32 postStateRoot,
-        bytes32 withdrawRoot,
-        bytes calldata blobDataProof
-    ) external;
-
     /// @notice Finalize a committed batch (with blob) on layer 1.
     ///
     /// @dev Memory layout of `blobDataProof`:

contracts/src/L1/rollup/L1MessageQueue.sol

@@ -402,13 +402,6 @@ contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
         emit UpdateMaxGasLimit(_oldMaxGasLimit, _newMaxGasLimit);
     }
 
-    function appendHashes(uint256 _fromQueueIndex, bytes32[] memory _hashes) external {
-        require(_fromQueueIndex == messageQueue.length, "messageQueue index mismatch");
-        for (uint256 i = 0; i < _hashes.length; i++) {
-            messageQueue.push(_hashes[i]);
-        }
-    }
-
     /**********************
      * Internal Functions *
      **********************/

contracts/src/L1/rollup/ScrollChain.sol

@@ -119,8 +119,7 @@ contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain {
 
     /// @dev BLS Modulus value defined in EIP-4844 and the magic value returned from a successful call to the
     /// point evaluation precompile
-    uint256 private constant BLS_MODULUS =
-        52435875175126190479447740508185965837690552500527637822603658699938581184513;
+    uint256 private constant BLS_MODULUS = 52435875175126190479447740508185965837690552500527637822603658699938581184513;
 
     /// @notice The chain id of the corresponding layer 2 chain.
     uint64 public immutable layer2ChainId;
@@ -379,55 +378,6 @@ contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain {
         }
     }
 
-    /// @inheritdoc IScrollChain
-    /// @dev We keep this function to upgrade to 4844 more smoothly.
-    function finalizeBatch(
-        bytes calldata _batchHeader,
-        bytes32 _prevStateRoot,
-        bytes32 _postStateRoot,
-        bytes32 _withdrawRoot
-    ) external override OnlyProver whenNotPaused {
-        if (_prevStateRoot == bytes32(0)) revert ErrorPreviousStateRootIsZero();
-        if (_postStateRoot == bytes32(0)) revert ErrorStateRootIsZero();
-
-        // compute batch hash and verify
-        (uint256 memPtr, bytes32 _batchHash, uint256 _batchIndex, ) = _loadBatchHeader(_batchHeader);
-        // bytes32 _dataHash = BatchHeaderV0Codec.getDataHash(memPtr);
-
-        // verify previous state root.
-        if (finalizedStateRoots[_batchIndex - 1] != _prevStateRoot) revert ErrorIncorrectPreviousStateRoot();
-
-        // avoid duplicated verification
-        if (finalizedStateRoots[_batchIndex] != bytes32(0)) revert ErrorBatchIsAlreadyVerified();
-
-        // // compute public input hash
-        // bytes32 _publicInputHash = keccak256(
-        //     abi.encodePacked(layer2ChainId, _prevStateRoot, _postStateRoot, _withdrawRoot, _dataHash)
-        // );
-
-        // // verify batch
-        // IRollupVerifier(verifier).verifyAggregateProof(0, _batchIndex, _aggrProof, _publicInputHash);
-
-        // check and update lastFinalizedBatchIndex
-        unchecked {
-            if (lastFinalizedBatchIndex + 1 != _batchIndex) revert ErrorIncorrectBatchIndex();
-            lastFinalizedBatchIndex = _batchIndex;
-        }
-
-        // record state root and withdraw root
-        finalizedStateRoots[_batchIndex] = _postStateRoot;
-        withdrawRoots[_batchIndex] = _withdrawRoot;
-
-        // Pop finalized and non-skipped message from L1MessageQueue.
-        _popL1Messages(
-            BatchHeaderV0Codec.getSkippedBitmapPtr(memPtr),
-            BatchHeaderV0Codec.getTotalL1MessagePopped(memPtr),
-            BatchHeaderV0Codec.getL1MessagePopped(memPtr)
-        );
-
-        emit FinalizeBatch(_batchIndex, _batchHash, _postStateRoot, _withdrawRoot);
-    }
-
     /// @inheritdoc IScrollChain
     /// @dev We keep this function to upgrade to 4844 more smoothly.
     function finalizeBatchWithProof(
@@ -478,87 +428,6 @@ contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain {
         emit FinalizeBatch(_batchIndex, _batchHash, _postStateRoot, _withdrawRoot);
     }
 
-    /// @inheritdoc IScrollChain
-    /// @dev Memory layout of `_blobDataProof`:
-    /// ```text
-    /// | z       | y       | kzg_commitment | kzg_proof |
-    /// |---------|---------|----------------|-----------|
-    /// | bytes32 | bytes32 | bytes48        | bytes48   |
-    /// ```
-    function finalizeBatch4844(
-        bytes calldata _batchHeader,
-        bytes32 _prevStateRoot,
-        bytes32 _postStateRoot,
-        bytes32 _withdrawRoot,
-        bytes calldata _blobDataProof
-    ) external override OnlyProver whenNotPaused {
-        if (_prevStateRoot == bytes32(0)) revert ErrorPreviousStateRootIsZero();
-        if (_postStateRoot == bytes32(0)) revert ErrorStateRootIsZero();
-
-        // compute batch hash and verify
-        (uint256 memPtr, bytes32 _batchHash, uint256 _batchIndex, ) = _loadBatchHeader(_batchHeader);
-        // bytes32 _dataHash = BatchHeaderV1Codec.getDataHash(memPtr);
-        bytes32 _blobVersionedHash = BatchHeaderV1Codec.getBlobVersionedHash(memPtr);
-
-        // Calls the point evaluation precompile and verifies the output
-        {
-            (bool success, bytes memory data) = POINT_EVALUATION_PRECOMPILE_ADDR.staticcall(
-                abi.encodePacked(_blobVersionedHash, _blobDataProof)
-            );
-            // We verify that the point evaluation precompile call was successful by testing the latter 32 bytes of the
-            // response is equal to BLS_MODULUS as defined in https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
-            if (!success) revert ErrorCallPointEvaluationPrecompileFailed();
-            (, uint256 result) = abi.decode(data, (uint256, uint256));
-            if (result != BLS_MODULUS) revert ErrorUnexpectedPointEvaluationPrecompileOutput();
-        }
-
-        // verify previous state root.
-        if (finalizedStateRoots[_batchIndex - 1] != _prevStateRoot) revert ErrorIncorrectPreviousStateRoot();
-
-        // avoid duplicated verification
-        if (finalizedStateRoots[_batchIndex] != bytes32(0)) revert ErrorBatchIsAlreadyVerified();
-
-        // // compute public input hash
-        // bytes32 _publicInputHash = keccak256(
-        //     abi.encodePacked(
-        //         layer2ChainId,
-        //         _prevStateRoot,
-        //         _postStateRoot,
-        //         _withdrawRoot,
-        //         _dataHash,
-        //         _blobDataProof[0:64],
-        //         _blobVersionedHash
-        //     )
-        // );
-
-        // // load version from batch header, it is always the first byte.
-        // uint256 batchVersion;
-        // assembly {
-        //     batchVersion := shr(248, calldataload(_batchHeader.offset))
-        // }
-        // // verify batch
-        // IRollupVerifier(verifier).verifyAggregateProof(batchVersion, _batchIndex, _aggrProof, _publicInputHash);
-
-        // check and update lastFinalizedBatchIndex
-        unchecked {
-            if (lastFinalizedBatchIndex + 1 != _batchIndex) revert ErrorIncorrectBatchIndex();
-            lastFinalizedBatchIndex = _batchIndex;
-        }
-
-        // record state root and withdraw root
-        finalizedStateRoots[_batchIndex] = _postStateRoot;
-        withdrawRoots[_batchIndex] = _withdrawRoot;
-
-        // Pop finalized and non-skipped message from L1MessageQueue.
-        _popL1Messages(
-            BatchHeaderV1Codec.getSkippedBitmapPtr(memPtr),
-            BatchHeaderV1Codec.getTotalL1MessagePopped(memPtr),
-            BatchHeaderV1Codec.getL1MessagePopped(memPtr)
-        );
-
-        emit FinalizeBatch(_batchIndex, _batchHash, _postStateRoot, _withdrawRoot);
-    }
-
     /// @inheritdoc IScrollChain
     /// @dev Memory layout of `_blobDataProof`:
     /// ```text

contracts/src/misc/ecc.sol

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity =0.8.24;
+
+contract Ecc {
+    /* ECC Functions */
+    // https://etherscan.io/address/0x41bf00f080ed41fa86201eac56b8afb170d9e36d#code
+    function ecAdd(uint256[2] memory p0, uint256[2] memory p1) public view returns (uint256[2] memory retP) {
+        uint256[4] memory i = [p0[0], p0[1], p1[0], p1[1]];
+
+        assembly {
+            // call ecadd precompile
+            // inputs are: x1, y1, x2, y2
+            if iszero(staticcall(not(0), 0x06, i, 0x80, retP, 0x40)) {
+                revert(0, 0)
+            }
+        }
+    }
+
+    // https://etherscan.io/address/0x41bf00f080ed41fa86201eac56b8afb170d9e36d#code
+    function ecMul(uint256[2] memory p, uint256 s) public view returns (uint256[2] memory retP) {
+        // With a public key (x, y), this computes p = scalar * (x, y).
+        uint256[3] memory i = [p[0], p[1], s];
+
+        assembly {
+            // call ecmul precompile
+            // inputs are: x, y, scalar
+            if iszero(staticcall(not(0), 0x07, i, 0x60, retP, 0x40)) {
+                revert(0, 0)
+            }
+        }
+    }
+
+    // scroll-tech/scroll/contracts/src/libraries/verifier/RollupVerifier.sol
+    struct G1Point {
+        uint256 x;
+        uint256 y;
+    }
+    struct G2Point {
+        uint256[2] x;
+        uint256[2] y;
+    }
+
+    function ecPairing(G1Point[] memory p1, G2Point[] memory p2) internal view returns (bool) {
+        uint256 length = p1.length * 6;
+        uint256[] memory input = new uint256[](length);
+        uint256[1] memory result;
+        bool ret;
+
+        require(p1.length == p2.length);
+
+        for (uint256 i = 0; i < p1.length; i++) {
+            input[0 + i * 6] = p1[i].x;
+            input[1 + i * 6] = p1[i].y;
+            input[2 + i * 6] = p2[i].x[0];
+            input[3 + i * 6] = p2[i].x[1];
+            input[4 + i * 6] = p2[i].y[0];
+            input[5 + i * 6] = p2[i].y[1];
+        }
+
+        assembly {
+            ret := staticcall(gas(), 8, add(input, 0x20), mul(length, 0x20), result, 0x20)
+        }
+        require(ret);
+        return result[0] != 0;
+    }
+
+    /* Bench */
+    function ecAdds(uint256 n) public {
+        uint256[2] memory p0;
+        p0[0] = 1;
+        p0[1] = 2;
+        uint256[2] memory p1;
+        p1[0] = 1;
+        p1[1] = 2;
+
+        for (uint256 i = 0; i < n; i++) {
+            ecAdd(p0, p1);
+        }
+    }
+
+    function ecMuls(uint256 n) public {
+        uint256[2] memory p0;
+        p0[0] = 1;
+        p0[1] = 2;
+
+        for (uint256 i = 0; i < n; i++) {
+            ecMul(p0, 3);
+        }
+    }
+
+    function ecPairings(uint256 n) public {
+        G1Point[] memory g1_points = new G1Point[](2);
+        G2Point[] memory g2_points = new G2Point[](2);
+        g1_points[0].x = 0x0000000000000000000000000000000000000000000000000000000000000001;
+        g1_points[0].y = 0x0000000000000000000000000000000000000000000000000000000000000002;
+        g2_points[0].x[1] = 0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed;
+        g2_points[0].x[0] = 0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2;
+        g2_points[0].y[1] = 0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa;
+        g2_points[0].y[0] = 0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b;
+        g1_points[1].x = 0x1aa125a22bd902874034e67868aed40267e5575d5919677987e3bc6dd42a32fe;
+        g1_points[1].y = 0x1bacc186725464068956d9a191455c2d6f6db282d83645c610510d8d4efbaee0;
+        g2_points[1].x[1] = 0x1b7734c80605f71f1e2de61e998ce5854ff2abebb76537c3d67e50d71422a852;
+        g2_points[1].x[0] = 0x10d5a1e34b2388a5ebe266033a5e0e63c89084203784da0c6bd9b052a78a2cac;
+        g2_points[1].y[1] = 0x275739c5c2cdbc72e37c689e2ab441ea76c1d284b9c46ae8f5c42ead937819e1;
+        g2_points[1].y[0] = 0x018de34c5b7c3d3d75428bbe050f1449ea3d9961d563291f307a1874f7332e65;
+
+        for (uint256 i = 0; i < n; i++) {
+            ecPairing(g1_points, g2_points);
+            // bool checked = false;
+            // checked = ecPairing(g1_points, g2_points);
+            // require(checked);
+        }
+    }
+
+    // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/8a0b7bed82d6b8053872c3fd40703efd58f5699d/test/utils/cryptography/ECDSA.test.js#L230
+    function ecRecovers(uint256 n) public {
+        bytes32 hash = 0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9;
+        bytes32 r = 0xe742ff452d41413616a5bf43fe15dd88294e983d3d36206c2712f39083d638bd;
+        uint8 v = 0x1b;
+        bytes32 s = 0xe0a0fc89be718fbc1033e1d30d78be1c68081562ed2e97af876f286f3453231d;
+
+        for (uint256 i = 0; i < n; i++) {
+            ecrecover(hash, v, r, s);
+        }
+    }
+}

contracts/src/misc/hash.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity =0.8.24;
+
+contract Hash {
+    function sha256(bytes memory input) public view returns (bytes memory out) {
+        (bool ok, bytes memory out) = address(2).staticcall(input);
+        require(ok);
+    }
+
+    function sha256Yul(bytes memory input) public view returns (bytes memory out) {
+        assembly {
+            // mstore(0, input)
+            if iszero(staticcall(gas(), 2, 0, 32, 0, 32)) {
+                revert(0, 0)
+            }
+            // return(0, 32)
+        }
+    }
+
+    function sha256s(bytes memory input, uint256 n) public {
+        for (uint256 i = 0; i < n; i++) {
+            sha256(input);
+        }
+    }
+
+    function keccak256s(uint256 n) public {
+        bytes32[] memory output = new bytes32[](n);
+        for (uint256 i = 0; i < n; i++) {
+            bytes memory input = abi.encode(i);
+            output[i] = keccak256(input);
+        }
+    }
+}

rollup/dump-batch-info/main.go

@@ -0,0 +1,103 @@
+package main
+
+import (
+	"context"
+	"encoding/hex"
+	"os"
+	"strconv"
+
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/log"
+
+	"scroll-tech/common/database"
+	"scroll-tech/common/types/encoding"
+	"scroll-tech/common/types/encoding/codecv1"
+	"scroll-tech/rollup/internal/orm"
+)
+
+func main() {
+	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.LogfmtFormat()))
+	glogger.Verbosity(log.LvlInfo)
+	log.Root().SetHandler(glogger)
+
+	if len(os.Args) < 2 {
+		log.Crit("no batch index provided")
+		return
+	}
+
+	batchIndexStr := os.Args[1]
+	batchIndexInt, err := strconv.Atoi(batchIndexStr)
+	if err != nil || batchIndexInt <= 0 {
+		log.Crit("invalid batch index", "indexStr", batchIndexStr, "err", err)
+		return
+	}
+	batchIndex := uint64(batchIndexInt)
+
+	db, err := database.InitDB(&database.Config{
+		DriverName: "postgres",
+		DSN:        os.Getenv("DB_DSN"),
+		MaxOpenNum: 200,
+		MaxIdleNum: 20,
+	})
+	if err != nil {
+		log.Crit("failed to init db", "err", err)
+	}
+	defer func() {
+		if deferErr := database.CloseDB(db); deferErr != nil {
+			log.Error("failed to close db", "err", err)
+		}
+	}()
+
+	l2BlockOrm := orm.NewL2Block(db)
+	chunkOrm := orm.NewChunk(db)
+	batchOrm := orm.NewBatch(db)
+
+	dbBatch, err := batchOrm.GetBatchByIndex(context.Background(), batchIndex)
+	if err != nil {
+		log.Crit("failed to get batch", "index", batchIndex, "err", err)
+		return
+	}
+
+	dbParentBatch, err := batchOrm.GetBatchByIndex(context.Background(), batchIndex-1)
+	if err != nil {
+		log.Crit("failed to get batch", "index", batchIndex-1, "err", err)
+		return
+	}
+
+	dbChunks, err := chunkOrm.GetChunksInRange(context.Background(), dbBatch.StartChunkIndex, dbBatch.EndChunkIndex)
+	if err != nil {
+		log.Crit("failed to fetch chunks", "err", err)
+		return
+	}
+
+	chunks := make([]*encoding.Chunk, len(dbChunks))
+	for i, c := range dbChunks {
+		blocks, err := l2BlockOrm.GetL2BlocksInRange(context.Background(), c.StartBlockNumber, c.EndBlockNumber)
+		if err != nil {
+			log.Crit("failed to fetch blocks", "err", err)
+			return
+		}
+		chunks[i] = &encoding.Chunk{Blocks: blocks}
+	}
+
+	batch := &encoding.Batch{
+		Index:                      dbBatch.Index,
+		TotalL1MessagePoppedBefore: dbChunks[0].TotalL1MessagesPoppedBefore,
+		ParentBatchHash:            common.HexToHash(dbParentBatch.Hash),
+		Chunks:                     chunks,
+	}
+
+	daBatch, err := codecv1.NewDABatch(batch)
+	if err != nil {
+		log.Crit("failed to create DA batch", "err", err)
+		return
+	}
+
+	blobDataProof, err := daBatch.BlobDataProof()
+	if err != nil {
+		log.Crit("failed to get blob data proof", "err", err)
+		return
+	}
+
+	log.Info("batchMeta", "batchHash", daBatch.Hash().Hex(), "batchDataHash", daBatch.DataHash.Hex(), "blobDataProof", hex.EncodeToString(blobDataProof), "blobData", hex.EncodeToString(daBatch.Blob()[:]))
+}