feat(gas-oracle): add gas price update after curie

common/version/version.go

@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.4.7"
+var tag = "v4.4.8"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

contracts/src/L2/predeploys/IL1GasPriceOracle.sol

@@ -15,10 +15,22 @@ interface IL1GasPriceOracle {
     /// @param scalar The current fee scalar updated.
     event ScalarUpdated(uint256 scalar);
 
+    /// @notice Emitted when current commit fee scalar is updated.
+    /// @param scalar The current commit fee scalar updated.
+    event CommitScalarUpdated(uint256 scalar);
+
+    /// @notice Emitted when current blob fee scalar is updated.
+    /// @param scalar The current blob fee scalar updated.
+    event BlobScalarUpdated(uint256 scalar);
+
     /// @notice Emitted when current l1 base fee is updated.
     /// @param l1BaseFee The current l1 base fee updated.
     event L1BaseFeeUpdated(uint256 l1BaseFee);
 
+    /// @notice Emitted when current l1 blob base fee is updated.
+    /// @param l1BlobBaseFee The current l1 blob base fee updated.
+    event L1BlobBaseFeeUpdated(uint256 l1BlobBaseFee);
+
     /*************************
      * Public View Functions *
      *************************/
@@ -26,15 +38,24 @@ interface IL1GasPriceOracle {
     /// @notice Return the current l1 fee overhead.
     function overhead() external view returns (uint256);
 
-    /// @notice Return the current l1 fee scalar.
+    /// @notice Return the current l1 fee scalar before Curie fork.
     function scalar() external view returns (uint256);
 
+    /// @notice Return the current l1 commit fee scalar.
+    function commitScalar() external view returns (uint256);
+
+    /// @notice Return the current l1 blob fee scalar.
+    function blobScalar() external view returns (uint256);
+
     /// @notice Return the latest known l1 base fee.
     function l1BaseFee() external view returns (uint256);
 
+    /// @notice Return the latest known l1 blob base fee.
+    function l1BlobBaseFee() external view returns (uint256);
+
     /// @notice Computes the L1 portion of the fee based on the size of the rlp encoded input
     ///         transaction, the current L1 base fee, and the various dynamic parameters.
-    /// @param data Unsigned fully RLP-encoded transaction to get the L1 fee for.
+    /// @param data Signed fully RLP-encoded transaction to get the L1 fee for.
     /// @return L1 fee that should be paid for the tx
     function getL1Fee(bytes memory data) external view returns (uint256);
 
@@ -42,7 +63,7 @@ interface IL1GasPriceOracle {
     ///         represents the per-transaction gas overhead of posting the transaction and state
     ///         roots to L1. Adds 74 bytes of padding to account for the fact that the input does
     ///         not have a signature.
-    /// @param data Unsigned fully RLP-encoded transaction to get the L1 gas for.
+    /// @param data Signed fully RLP-encoded transaction to get the L1 gas for.
     /// @return Amount of L1 gas used to publish the transaction.
     function getL1GasUsed(bytes memory data) external view returns (uint256);
 
@@ -53,4 +74,9 @@ interface IL1GasPriceOracle {
     /// @notice Allows whitelisted caller to modify the l1 base fee.
     /// @param _l1BaseFee New l1 base fee.
     function setL1BaseFee(uint256 _l1BaseFee) external;
+
+    /// @notice Allows whitelisted caller to modify the l1 base fee.
+    /// @param _l1BaseFee New l1 base fee.
+    /// @param _l1BlobBaseFee New l1 blob base fee.
+    function setL1BaseFeeAndBlobBaseFee(uint256 _l1BaseFee, uint256 _l1BlobBaseFee) external;
 }

contracts/src/L2/predeploys/L1GasPriceOracle.sol

@@ -17,6 +17,28 @@ contract L1GasPriceOracle is OwnableBase, IL1GasPriceOracle {
     /// @param _newWhitelist The address of new whitelist contract.
     event UpdateWhitelist(address _oldWhitelist, address _newWhitelist);
 
+    /**********
+     * Errors *
+     **********/
+
+    /// @dev Thrown when the blob fee scalar exceed `MAX_BLOB_SCALAR`.
+    error ErrExceedMaxBlobScalar();
+
+    /// @dev Thrown when the commit fee scalar exceed `MAX_COMMIT_SCALAR`.
+    error ErrExceedMaxCommitScalar();
+
+    /// @dev Thrown when the l1 fee overhead exceed `MAX_OVERHEAD`.
+    error ErrExceedMaxOverhead();
+
+    /// @dev Thrown when the l1 fee scalar exceed `MAX_SCALAR`.
+    error ErrExceedMaxScalar();
+
+    /// @dev Thrown when the caller is not whitelisted.
+    error ErrCallerNotWhitelisted();
+
+    /// @dev Thrown when we enable Curie fork in Curie fork.
+    error ErrAlreadyInCurieFork();
+
     /*************
      * Constants *
      *************/
@@ -28,9 +50,25 @@ contract L1GasPriceOracle is OwnableBase, IL1GasPriceOracle {
     ///      Computed based on current l1 block gas limit.
     uint256 private constant MAX_OVERHEAD = 30000000 / 16;
 
-    /// @dev The maximum possible l1 fee scale.
+    /// @dev The maximum possible l1 fee scale before Curie.
     ///      x1000 should be enough.
-    uint256 private constant MAX_SCALE = 1000 * PRECISION;
+    uint256 private constant MAX_SCALAR = 1000 * PRECISION;
+
+    /// @dev The maximum possible l1 commit fee scalar after Curie.
+    /// We derive the commit scalar by
+    /// ```
+    /// commit_scalar = commit_gas_per_tx * fluctuation_multiplier * 1e9
+    /// ```
+    /// So, the value should not exceed 10^18 * 1e9 normally.
+    uint256 private constant MAX_COMMIT_SCALAR = 10 ** 18 * PRECISION;
+
+    /// @dev The maximum possible l1 blob fee scalar after Curie.
+    /// We derive the blob scalar by
+    /// ```
+    /// blob_scalar = fluctuation_multiplier / compression_ratio / blob_util_ratio * 1e9
+    /// ```
+    /// So, the value should not exceed 10^18 * 1e9 normally.
+    uint256 private constant MAX_BLOB_SCALAR = 10 ** 18 * PRECISION;
 
     /*************
      * Variables *
@@ -48,6 +86,27 @@ contract L1GasPriceOracle is OwnableBase, IL1GasPriceOracle {
     /// @notice The address of whitelist contract.
     IWhitelist public whitelist;
 
+    /// @inheritdoc IL1GasPriceOracle
+    uint256 public override l1BlobBaseFee;
+
+    /// @inheritdoc IL1GasPriceOracle
+    uint256 public override commitScalar;
+
+    /// @inheritdoc IL1GasPriceOracle
+    uint256 public override blobScalar;
+
+    /// @notice Indicates whether the network has gone through the Curie upgrade.
+    bool public isCurie;
+
+    /*************
+     * Modifiers *
+     *************/
+
+    modifier onlyWhitelistedSender() {
+        if (!whitelist.isSenderAllowed(msg.sender)) revert ErrCallerNotWhitelisted();
+        _;
+    }
+
     /***************
      * Constructor *
      ***************/
@@ -62,15 +121,116 @@ contract L1GasPriceOracle is OwnableBase, IL1GasPriceOracle {
 
     /// @inheritdoc IL1GasPriceOracle
     function getL1Fee(bytes memory _data) external view override returns (uint256) {
-        uint256 _l1GasUsed = getL1GasUsed(_data);
-        uint256 _l1Fee = _l1GasUsed * l1BaseFee;
-        return (_l1Fee * scalar) / PRECISION;
+        if (isCurie) {
+            return _getL1FeeCurie(_data);
+        } else {
+            return _getL1FeeBeforeCurie(_data);
+        }
     }
 
     /// @inheritdoc IL1GasPriceOracle
-    /// @dev The `_data` is the RLP-encoded transaction with signature. And we also reserve additional
-    ///      4 bytes in the non-zero bytes to store the number of bytes in the RLP-encoded transaction.
     function getL1GasUsed(bytes memory _data) public view override returns (uint256) {
+        if (isCurie) {
+            // It is near zero since we put all transactions to blob.
+            return 0;
+        } else {
+            return _getL1GasUsedBeforeCurie(_data);
+        }
+    }
+
+    /*****************************
+     * Public Mutating Functions *
+     *****************************/
+
+    /// @inheritdoc IL1GasPriceOracle
+    function setL1BaseFee(uint256 _l1BaseFee) external override onlyWhitelistedSender {
+        l1BaseFee = _l1BaseFee;
+
+        emit L1BaseFeeUpdated(_l1BaseFee);
+    }
+
+    /// @inheritdoc IL1GasPriceOracle
+    function setL1BaseFeeAndBlobBaseFee(
+        uint256 _l1BaseFee,
+        uint256 _l1BlobBaseFee
+    ) external override onlyWhitelistedSender {
+        l1BaseFee = _l1BaseFee;
+        l1BlobBaseFee = _l1BlobBaseFee;
+
+        emit L1BaseFeeUpdated(_l1BaseFee);
+        emit L1BlobBaseFeeUpdated(_l1BlobBaseFee);
+    }
+
+    /************************
+     * Restricted Functions *
+     ************************/
+
+    /// @notice Allows the owner to modify the overhead.
+    /// @param _overhead New overhead
+    function setOverhead(uint256 _overhead) external onlyOwner {
+        if (_overhead > MAX_OVERHEAD) revert ErrExceedMaxOverhead();
+
+        overhead = _overhead;
+        emit OverheadUpdated(_overhead);
+    }
+
+    /// Allows the owner to modify the scalar.
+    /// @param _scalar New scalar
+    function setScalar(uint256 _scalar) external onlyOwner {
+        if (_scalar > MAX_SCALAR) revert ErrExceedMaxScalar();
+
+        scalar = _scalar;
+        emit ScalarUpdated(_scalar);
+    }
+
+    /// Allows the owner to modify the commit scalar.
+    /// @param _scalar New scalar
+    function setCommitScalar(uint256 _scalar) external onlyOwner {
+        if (_scalar > MAX_COMMIT_SCALAR) revert ErrExceedMaxCommitScalar();
+
+        commitScalar = _scalar;
+        emit CommitScalarUpdated(_scalar);
+    }
+
+    /// Allows the owner to modify the blob scalar.
+    /// @param _scalar New scalar
+    function setBlobScalar(uint256 _scalar) external onlyOwner {
+        if (_scalar > MAX_BLOB_SCALAR) revert ErrExceedMaxBlobScalar();
+
+        blobScalar = _scalar;
+        emit BlobScalarUpdated(_scalar);
+    }
+
+    /// @notice Update whitelist contract.
+    /// @dev This function can only called by contract owner.
+    /// @param _newWhitelist The address of new whitelist contract.
+    function updateWhitelist(address _newWhitelist) external onlyOwner {
+        address _oldWhitelist = address(whitelist);
+
+        whitelist = IWhitelist(_newWhitelist);
+        emit UpdateWhitelist(_oldWhitelist, _newWhitelist);
+    }
+
+    /// @notice Enable the Curie fork (callable by contract owner).
+    ///
+    /// @dev Since this is a predeploy contract, we will directly set the slot while hard fork
+    /// to avoid external owner operations.
+    /// The reason that we keep this function is for easy unit testing.
+    function enableCurie() external onlyOwner {
+        if (isCurie) revert ErrAlreadyInCurieFork();
+        isCurie = true;
+    }
+
+    /**********************
+     * Internal Functions *
+     **********************/
+
+    /// @dev Internal function to computes the amount of L1 gas used for a transaction before Curie fork.
+    ///   The `_data` is the RLP-encoded transaction with signature. And we also reserve additional
+    ///   4 bytes in the non-zero bytes to store the number of bytes in the RLP-encoded transaction.
+    /// @param _data Signed fully RLP-encoded transaction to get the L1 gas for.
+    /// @return Amount of L1 gas used to publish the transaction.
+    function _getL1GasUsedBeforeCurie(bytes memory _data) private view returns (uint256) {
         uint256 _total = 0;
         uint256 _length = _data.length;
         unchecked {
@@ -85,48 +245,22 @@ contract L1GasPriceOracle is OwnableBase, IL1GasPriceOracle {
         }
     }
 
-    /*****************************
-     * Public Mutating Functions *
-     *****************************/
-
-    /// @inheritdoc IL1GasPriceOracle
-    function setL1BaseFee(uint256 _l1BaseFee) external override {
-        require(whitelist.isSenderAllowed(msg.sender), "Not whitelisted sender");
-
-        l1BaseFee = _l1BaseFee;
-
-        emit L1BaseFeeUpdated(_l1BaseFee);
+    /// @dev Internal function to compute the L1 portion of the fee based on the size of the rlp encoded input
+    ///   transaction, the current L1 base fee, and the various dynamic parameters, before Curie fork.
+    /// @param _data Signed fully RLP-encoded transaction to get the L1 fee for.
+    /// @return L1 fee that should be paid for the tx
+    function _getL1FeeBeforeCurie(bytes memory _data) private view returns (uint256) {
+        uint256 _l1GasUsed = _getL1GasUsedBeforeCurie(_data);
+        uint256 _l1Fee = _l1GasUsed * l1BaseFee;
+        return (_l1Fee * scalar) / PRECISION;
     }
 
-    /************************
-     * Restricted Functions *
-     ************************/
-
-    /// @notice Allows the owner to modify the overhead.
-    /// @param _overhead New overhead
-    function setOverhead(uint256 _overhead) external onlyOwner {
-        require(_overhead <= MAX_OVERHEAD, "exceed maximum overhead");
-
-        overhead = _overhead;
-        emit OverheadUpdated(_overhead);
-    }
-
-    /// Allows the owner to modify the scalar.
-    /// @param _scalar New scalar
-    function setScalar(uint256 _scalar) external onlyOwner {
-        require(_scalar <= MAX_SCALE, "exceed maximum scale");
-
-        scalar = _scalar;
-        emit ScalarUpdated(_scalar);
-    }
-
-    /// @notice Update whitelist contract.
-    /// @dev This function can only called by contract owner.
-    /// @param _newWhitelist The address of new whitelist contract.
-    function updateWhitelist(address _newWhitelist) external onlyOwner {
-        address _oldWhitelist = address(whitelist);
-
-        whitelist = IWhitelist(_newWhitelist);
-        emit UpdateWhitelist(_oldWhitelist, _newWhitelist);
+    /// @dev Internal function to compute the L1 portion of the fee based on the size of the rlp encoded input
+    ///   transaction, the current L1 base fee, and the various dynamic parameters, after Curie fork.
+    /// @param _data Signed fully RLP-encoded transaction to get the L1 fee for.
+    /// @return L1 fee that should be paid for the tx
+    function _getL1FeeCurie(bytes memory _data) private view returns (uint256) {
+        // We have bounded the value of `commitScalar` and `blobScalar`, the whole expression won't overflow.
+        return (commitScalar * l1BaseFee + blobScalar * _data.length * l1BlobBaseFee) / PRECISION;
     }
 }

contracts/src/test/L1GasPriceOracle.t.sol

@@ -4,14 +4,15 @@ pragma solidity =0.8.24;
 
 import {DSTestPlus} from "solmate/test/utils/DSTestPlus.sol";
 
-import {L1BlockContainer} from "../L2/predeploys/L1BlockContainer.sol";
 import {L1GasPriceOracle} from "../L2/predeploys/L1GasPriceOracle.sol";
 import {Whitelist} from "../L2/predeploys/Whitelist.sol";
 
 contract L1GasPriceOracleTest is DSTestPlus {
     uint256 private constant PRECISION = 1e9;
     uint256 private constant MAX_OVERHEAD = 30000000 / 16;
-    uint256 private constant MAX_SCALE = 1000 * PRECISION;
+    uint256 private constant MAX_SCALAR = 1000 * PRECISION;
+    uint256 private constant MAX_COMMIT_SCALAR = 10 ** 18 * PRECISION;
+    uint256 private constant MAX_BLOB_SCALAR = 10 ** 18 * PRECISION;
 
     L1GasPriceOracle private oracle;
     Whitelist private whitelist;
@@ -36,7 +37,7 @@ contract L1GasPriceOracleTest is DSTestPlus {
         hevm.stopPrank();
 
         // overhead is too large
-        hevm.expectRevert("exceed maximum overhead");
+        hevm.expectRevert(L1GasPriceOracle.ErrExceedMaxOverhead.selector);
         oracle.setOverhead(MAX_OVERHEAD + 1);
 
         // call by owner, should succeed
@@ -46,7 +47,7 @@ contract L1GasPriceOracleTest is DSTestPlus {
     }
 
     function testSetScalar(uint256 _scalar) external {
-        _scalar = bound(_scalar, 0, MAX_SCALE);
+        _scalar = bound(_scalar, 0, MAX_SCALAR);
 
         // call by non-owner, should revert
         hevm.startPrank(address(1));
@@ -55,8 +56,8 @@ contract L1GasPriceOracleTest is DSTestPlus {
         hevm.stopPrank();
 
         // scale is too large
-        hevm.expectRevert("exceed maximum scale");
-        oracle.setScalar(MAX_SCALE + 1);
+        hevm.expectRevert(L1GasPriceOracle.ErrExceedMaxScalar.selector);
+        oracle.setScalar(MAX_SCALAR + 1);
 
         // call by owner, should succeed
         assertEq(oracle.scalar(), 0);
@@ -64,6 +65,44 @@ contract L1GasPriceOracleTest is DSTestPlus {
         assertEq(oracle.scalar(), _scalar);
     }
 
+    function testSetCommitScalar(uint256 _scalar) external {
+        _scalar = bound(_scalar, 0, MAX_COMMIT_SCALAR);
+
+        // call by non-owner, should revert
+        hevm.startPrank(address(1));
+        hevm.expectRevert("caller is not the owner");
+        oracle.setCommitScalar(_scalar);
+        hevm.stopPrank();
+
+        // scale is too large
+        hevm.expectRevert(L1GasPriceOracle.ErrExceedMaxCommitScalar.selector);
+        oracle.setCommitScalar(MAX_COMMIT_SCALAR + 1);
+
+        // call by owner, should succeed
+        assertEq(oracle.commitScalar(), 0);
+        oracle.setCommitScalar(_scalar);
+        assertEq(oracle.commitScalar(), _scalar);
+    }
+
+    function testSetBlobScalar(uint256 _scalar) external {
+        _scalar = bound(_scalar, 0, MAX_BLOB_SCALAR);
+
+        // call by non-owner, should revert
+        hevm.startPrank(address(1));
+        hevm.expectRevert("caller is not the owner");
+        oracle.setBlobScalar(_scalar);
+        hevm.stopPrank();
+
+        // scale is too large
+        hevm.expectRevert(L1GasPriceOracle.ErrExceedMaxBlobScalar.selector);
+        oracle.setBlobScalar(MAX_COMMIT_SCALAR + 1);
+
+        // call by owner, should succeed
+        assertEq(oracle.blobScalar(), 0);
+        oracle.setBlobScalar(_scalar);
+        assertEq(oracle.blobScalar(), _scalar);
+    }
+
     function testUpdateWhitelist(address _newWhitelist) external {
         hevm.assume(_newWhitelist != address(whitelist));
 
@@ -79,12 +118,29 @@ contract L1GasPriceOracleTest is DSTestPlus {
         assertEq(address(oracle.whitelist()), _newWhitelist);
     }
 
+    function testEnableCurie() external {
+        // call by non-owner, should revert
+        hevm.startPrank(address(1));
+        hevm.expectRevert("caller is not the owner");
+        oracle.enableCurie();
+        hevm.stopPrank();
+
+        // call by owner, should succeed
+        assertBoolEq(oracle.isCurie(), false);
+        oracle.enableCurie();
+        assertBoolEq(oracle.isCurie(), true);
+
+        // enable twice, should revert
+        hevm.expectRevert(L1GasPriceOracle.ErrAlreadyInCurieFork.selector);
+        oracle.enableCurie();
+    }
+
     function testSetL1BaseFee(uint256 _baseFee) external {
         _baseFee = bound(_baseFee, 0, 1e9 * 20000); // max 20k gwei
 
         // call by non-owner, should revert
         hevm.startPrank(address(1));
-        hevm.expectRevert("Not whitelisted sender");
+        hevm.expectRevert(L1GasPriceOracle.ErrCallerNotWhitelisted.selector);
         oracle.setL1BaseFee(_baseFee);
         hevm.stopPrank();
 
@@ -94,7 +150,25 @@ contract L1GasPriceOracleTest is DSTestPlus {
         assertEq(oracle.l1BaseFee(), _baseFee);
     }
 
-    function testGetL1GasUsed(uint256 _overhead, bytes memory _data) external {
+    function testSetL1BaseFeeAndBlobBaseFee(uint256 _baseFee, uint256 _blobBaseFee) external {
+        _baseFee = bound(_baseFee, 0, 1e9 * 20000); // max 20k gwei
+        _blobBaseFee = bound(_blobBaseFee, 0, 1e9 * 20000); // max 20k gwei
+
+        // call by non-owner, should revert
+        hevm.startPrank(address(1));
+        hevm.expectRevert(L1GasPriceOracle.ErrCallerNotWhitelisted.selector);
+        oracle.setL1BaseFeeAndBlobBaseFee(_baseFee, _blobBaseFee);
+        hevm.stopPrank();
+
+        // call by owner, should succeed
+        assertEq(oracle.l1BaseFee(), 0);
+        assertEq(oracle.l1BlobBaseFee(), 0);
+        oracle.setL1BaseFeeAndBlobBaseFee(_baseFee, _blobBaseFee);
+        assertEq(oracle.l1BaseFee(), _baseFee);
+        assertEq(oracle.l1BlobBaseFee(), _blobBaseFee);
+    }
+
+    function testGetL1GasUsedBeforeCurie(uint256 _overhead, bytes memory _data) external {
         _overhead = bound(_overhead, 0, MAX_OVERHEAD);
 
         oracle.setOverhead(_overhead);
@@ -108,14 +182,14 @@ contract L1GasPriceOracleTest is DSTestPlus {
         assertEq(oracle.getL1GasUsed(_data), _gasUsed);
     }
 
-    function testGetL1Fee(
+    function testGetL1FeeBeforeCurie(
         uint256 _baseFee,
         uint256 _overhead,
         uint256 _scalar,
         bytes memory _data
     ) external {
         _overhead = bound(_overhead, 0, MAX_OVERHEAD);
-        _scalar = bound(_scalar, 0, MAX_SCALE);
+        _scalar = bound(_scalar, 0, MAX_SCALAR);
         _baseFee = bound(_baseFee, 0, 1e9 * 20000); // max 20k gwei
 
         oracle.setOverhead(_overhead);
@@ -130,4 +204,32 @@ contract L1GasPriceOracleTest is DSTestPlus {
 
         assertEq(oracle.getL1Fee(_data), (_gasUsed * _baseFee * _scalar) / PRECISION);
     }
+
+    function testGetL1GasUsedCurie(bytes memory _data) external {
+        oracle.enableCurie();
+        assertEq(oracle.getL1GasUsed(_data), 0);
+    }
+
+    function testGetL1FeeCurie(
+        uint256 _baseFee,
+        uint256 _blobBaseFee,
+        uint256 _commitScalar,
+        uint256 _blobScalar,
+        bytes memory _data
+    ) external {
+        _baseFee = bound(_baseFee, 0, 1e9 * 20000); // max 20k gwei
+        _blobBaseFee = bound(_blobBaseFee, 0, 1e9 * 20000); // max 20k gwei
+        _commitScalar = bound(_commitScalar, 0, MAX_COMMIT_SCALAR);
+        _blobScalar = bound(_blobScalar, 0, MAX_BLOB_SCALAR);
+
+        oracle.enableCurie();
+        oracle.setCommitScalar(_commitScalar);
+        oracle.setBlobScalar(_blobScalar);
+        oracle.setL1BaseFeeAndBlobBaseFee(_baseFee, _blobBaseFee);
+
+        assertEq(
+            oracle.getL1Fee(_data),
+            (_commitScalar * _baseFee + _blobScalar * _blobBaseFee * _data.length) / PRECISION
+        );
+    }
 }

rollup/abi/bridge_abi.go

@@ -101,7 +101,7 @@ var L2MessageQueueMetaData = &bind.MetaData{
 
 // L1GasPriceOracleMetaData contains all meta data concerning the L1GasPriceOracle contract.
 var L1GasPriceOracleMetaData = &bind.MetaData{
-	ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"l1BaseFee\",\"type\":\"uint256\"}],\"name\":\"L1BaseFeeUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"overhead\",\"type\":\"uint256\"}],\"name\":\"OverheadUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_oldOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"scalar\",\"type\":\"uint256\"}],\"name\":\"ScalarUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_oldWhitelist\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_newWhitelist\",\"type\":\"address\"}],\"name\":\"UpdateWhitelist\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"getL1Fee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"getL1GasUsed\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1BaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"overhead\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"scalar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l1BaseFee\",\"type\":\"uint256\"}],\"name\":\"setL1BaseFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_overhead\",\"type\":\"uint256\"}],\"name\":\"setOverhead\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_scalar\",\"type\":\"uint256\"}],\"name\":\"setScalar\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newWhitelist\",\"type\":\"address\"}],\"name\":\"updateWhitelist\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"whitelist\",\"outputs\":[{\"internalType\":\"contract IWhitelist\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]\n",
+	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"scalar\",\"type\":\"uint256\"}],\"name\":\"BlobScalarUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"scalar\",\"type\":\"uint256\"}],\"name\":\"CommitScalarUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"l1BaseFee\",\"type\":\"uint256\"}],\"name\":\"L1BaseFeeUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"l1BlobBaseFee\",\"type\":\"uint256\"}],\"name\":\"L1BlobBaseFeeUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"overhead\",\"type\":\"uint256\"}],\"name\":\"OverheadUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"scalar\",\"type\":\"uint256\"}],\"name\":\"ScalarUpdated\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"blobScalar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"commitScalar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"getL1Fee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"getL1GasUsed\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1BaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1BlobBaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"overhead\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"scalar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l1BaseFee\",\"type\":\"uint256\"}],\"name\":\"setL1BaseFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l1BaseFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_l1BlobBaseFee\",\"type\":\"uint256\"}],\"name\":\"setL1BaseFeeAndBlobBaseFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
 }
 
 // IL1ScrollMessengerL2MessageProof is an auto generated low-level Go binding around an user-defined struct.

rollup/internal/controller/relayer/l1_relayer.go

@@ -36,7 +36,8 @@ type Layer1Relayer struct {
 	gasOracleSender *sender.Sender
 	l1GasOracleABI  *abi.ABI
 
-	lastGasPrice        uint64
+	lastBaseFee         uint64
+	lastBlobBaseFee     uint64
 	minGasPrice         uint64
 	gasPriceDiff        uint64
 	l1BaseFeeWeight     float64
@@ -130,37 +131,45 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 	block := blocks[0]
 
 	if types.GasOracleStatus(block.GasOracleStatus) == types.GasOraclePending {
-		expectedDelta := r.lastGasPrice * r.gasPriceDiff / gasPriceDiffPrecision
-		if r.lastGasPrice > 0 && expectedDelta == 0 {
-			expectedDelta = 1
-		}
-
 		latestL2Height, err := r.l2BlockOrm.GetL2BlocksLatestHeight(r.ctx)
 		if err != nil {
 			log.Warn("Failed to fetch latest L2 block height from db", "err", err)
 			return
 		}
 
-		var isBernoulli = r.chainCfg.IsBernoulli(new(big.Int).SetUint64(latestL2Height))
+		var isBernoulli = block.BlobBaseFee > 0 && r.chainCfg.IsBernoulli(new(big.Int).SetUint64(latestL2Height))
+		var isCurie = block.BlobBaseFee > 0 && r.chainCfg.IsCurie(new(big.Int).SetUint64(latestL2Height))
 
 		var baseFee uint64
-		if isBernoulli && block.BlobBaseFee != 0 {
+		var blobBaseFee uint64
+		if isCurie {
+			baseFee = block.BaseFee
+			blobBaseFee = block.BlobBaseFee
+		} else if isBernoulli {
 			baseFee = uint64(math.Ceil(r.l1BaseFeeWeight*float64(block.BaseFee) + r.l1BlobBaseFeeWeight*float64(block.BlobBaseFee)))
 		} else {
 			baseFee = block.BaseFee
 		}
 
-		// last is undefined or (baseFee >= minGasPrice && exceed diff)
-		if r.lastGasPrice == 0 || (baseFee >= r.minGasPrice && (baseFee >= r.lastGasPrice+expectedDelta || baseFee <= r.lastGasPrice-expectedDelta)) {
-			data, err := r.l1GasOracleABI.Pack("setL1BaseFee", new(big.Int).SetUint64(baseFee))
-			if err != nil {
-				log.Error("Failed to pack setL1BaseFee", "block.Hash", block.Hash, "block.Height", block.Number, "block.BaseFee", baseFee, "isBernoulli", isBernoulli, "err", err)
-				return
+		if r.shouldUpdateGasOracle(baseFee, blobBaseFee, isCurie) {
+			var data []byte
+			if isCurie {
+				data, err = r.l1GasOracleABI.Pack("setL1BaseFeeAndBlobBaseFee", new(big.Int).SetUint64(baseFee), new(big.Int).SetUint64(blobBaseFee))
+				if err != nil {
+					log.Error("Failed to pack setL1BaseFeeAndBlobBaseFee", "block.Hash", block.Hash, "block.Height", block.Number, "block.BaseFee", baseFee, "block.BlobBaseFee", blobBaseFee, "isBernoulli", isBernoulli, "isCurie", isCurie, "err", err)
+					return
+				}
+			} else {
+				data, err = r.l1GasOracleABI.Pack("setL1BaseFee", new(big.Int).SetUint64(baseFee))
+				if err != nil {
+					log.Error("Failed to pack setL1BaseFee", "block.Hash", block.Hash, "block.Height", block.Number, "block.BaseFee", baseFee, "block.BlobBaseFee", blobBaseFee, "isBernoulli", isBernoulli, "isCurie", isCurie, "err", err)
+					return
+				}
 			}
 
 			hash, err := r.gasOracleSender.SendTransaction(block.Hash, &r.cfg.GasPriceOracleContractAddress, data, nil, 0)
 			if err != nil {
-				log.Error("Failed to send setL1BaseFee tx to layer2 ", "block.Hash", block.Hash, "block.Height", block.Number, "err", err)
+				log.Error("Failed to send gas oracle update tx to layer2", "block.Hash", block.Hash, "block.Height", block.Number, "block.BaseFee", baseFee, "block.BlobBaseFee", blobBaseFee, "isBernoulli", isBernoulli, "isCurie", isCurie, "err", err)
 				return
 			}
 
@@ -169,9 +178,12 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 				log.Error("UpdateGasOracleStatusAndOracleTxHash failed", "block.Hash", block.Hash, "block.Height", block.Number, "err", err)
 				return
 			}
-			r.lastGasPrice = baseFee
-			r.metrics.rollupL1RelayerLastGasPrice.Set(float64(r.lastGasPrice))
-			log.Info("Update l1 base fee", "txHash", hash.String(), "baseFee", baseFee, "isBernoulli", isBernoulli)
+
+			r.lastBaseFee = baseFee
+			r.lastBlobBaseFee = blobBaseFee
+			r.metrics.rollupL1RelayerLastestBaseFee.Set(float64(r.lastBaseFee))
+			r.metrics.rollupL1RelayerLastestBlobBaseFee.Set(float64(r.lastBlobBaseFee))
+			log.Info("Update l1 base fee", "txHash", hash.String(), "baseFee", baseFee, "blobBaseFee", blobBaseFee, "isBernoulli", isBernoulli, "isCurie", isCurie)
 		}
 	}
 }
@@ -219,3 +231,29 @@ func (r *Layer1Relayer) StopSenders() {
 		r.gasOracleSender.Stop()
 	}
 }
+
+func (r *Layer1Relayer) shouldUpdateGasOracle(baseFee uint64, blobBaseFee uint64, isCurie bool) bool {
+	// Right after restarting.
+	if r.lastBaseFee == 0 {
+		return true
+	}
+
+	expectedBaseFeeDelta := r.lastBaseFee*r.gasPriceDiff/gasPriceDiffPrecision + 1
+	if baseFee >= r.minGasPrice && (baseFee >= r.lastBaseFee+expectedBaseFeeDelta || baseFee+expectedBaseFeeDelta <= r.lastBaseFee) {
+		return true
+	}
+
+	// Omitting blob base fee checks before Curie.
+	if !isCurie {
+		return false
+	}
+
+	expectedBlobBaseFeeDelta := r.lastBlobBaseFee * r.gasPriceDiff / gasPriceDiffPrecision
+	// Plus a minimum of 0.01 gwei, since the blob base fee is usually low, preventing short-time flunctuation.
+	expectedBlobBaseFeeDelta += 10000000
+	if blobBaseFee >= r.minGasPrice && (blobBaseFee >= r.lastBlobBaseFee+expectedBlobBaseFeeDelta || blobBaseFee+expectedBlobBaseFeeDelta <= r.lastBlobBaseFee) {
+		return true
+	}
+
+	return false
+}

rollup/internal/controller/relayer/l1_relayer_metrics.go

@@ -9,7 +9,8 @@ import (
 
 type l1RelayerMetrics struct {
 	rollupL1RelayerGasPriceOraclerRunTotal      prometheus.Counter
-	rollupL1RelayerLastGasPrice                 prometheus.Gauge
+	rollupL1RelayerLastestBaseFee               prometheus.Gauge
+	rollupL1RelayerLastestBlobBaseFee           prometheus.Gauge
 	rollupL1UpdateGasOracleConfirmedTotal       prometheus.Counter
 	rollupL1UpdateGasOracleConfirmedFailedTotal prometheus.Counter
 }
@@ -26,9 +27,13 @@ func initL1RelayerMetrics(reg prometheus.Registerer) *l1RelayerMetrics {
 				Name: "rollup_layer1_gas_price_oracler_total",
 				Help: "The total number of layer1 gas price oracler run total",
 			}),
-			rollupL1RelayerLastGasPrice: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
-				Name: "rollup_layer1_gas_price_latest_gas_price",
-				Help: "The latest gas price of rollup relayer l1",
+			rollupL1RelayerLastestBaseFee: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+				Name: "rollup_layer1_latest_base_fee",
+				Help: "The latest base fee of l1 rollup relayer",
+			}),
+			rollupL1RelayerLastestBlobBaseFee: promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+				Name: "rollup_layer1_latest_blob_base_fee",
+				Help: "The latest blob base fee of l1 rollup relayer",
 			}),
 			rollupL1UpdateGasOracleConfirmedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 				Name: "rollup_layer1_update_gas_oracle_confirmed_total",

rollup/internal/controller/relayer/l2_relayer.go

@@ -309,7 +309,7 @@ func (r *Layer2Relayer) ProcessGasPriceOracle() {
 		}
 
 		// last is undefine or (suggestGasPriceUint64 >= minGasPrice && exceed diff)
-		if r.lastGasPrice == 0 || (suggestGasPriceUint64 >= r.minGasPrice && (suggestGasPriceUint64 >= r.lastGasPrice+expectedDelta || suggestGasPriceUint64 <= r.lastGasPrice-expectedDelta)) {
+		if r.lastGasPrice == 0 || (suggestGasPriceUint64 >= r.minGasPrice && (suggestGasPriceUint64 >= r.lastGasPrice+expectedDelta || suggestGasPriceUint64+expectedDelta <= r.lastGasPrice)) {
 			data, err := r.l2GasOracleABI.Pack("setL2BaseFee", suggestGasPrice)
 			if err != nil {
 				log.Error("Failed to pack setL2BaseFee", "batch.Hash", batch.Hash, "GasPrice", suggestGasPrice.Uint64(), "err", err)

rollup/mock_bridge/MockBridge.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity =0.8.24;
+pragma solidity ^0.8.24;
 
 import {BatchHeaderV0Codec} from "../../../contracts/src/libraries/codec/BatchHeaderV0Codec.sol";
 import {BatchHeaderV1Codec} from "../../../contracts/src/libraries/codec/BatchHeaderV1Codec.sol";
@@ -82,14 +82,25 @@ contract MockBridge {
     /// point evaluation precompile
     uint256 constant BLS_MODULUS = 52435875175126190479447740508185965837690552500527637822603658699938581184513;
 
+    uint256 public l1BaseFee;
+    uint256 public l1BlobBaseFee;
     uint256 public l2BaseFee;
     uint256 public lastFinalizedBatchIndex;
     mapping(uint256 => bytes32) public committedBatches;
     mapping(uint256 => bytes32) public finalizedStateRoots;
     mapping(uint256 => bytes32) public withdrawRoots;
 
-    function setL2BaseFee(uint256 _newL2BaseFee) external {
-      l2BaseFee = _newL2BaseFee;
+    function setL1BaseFee(uint256 _l1BaseFee) external {
+        l1BaseFee = _l1BaseFee;
+    }
+
+    function setL1BaseFeeAndBlobBaseFee(uint256 _l1BaseFee, uint256 _l1BlobBaseFee) external {
+        l1BaseFee = _l1BaseFee;
+        l1BlobBaseFee = _l1BlobBaseFee;
+    }
+
+    function setL2BaseFee(uint256 _l2BaseFee) external {
+        l2BaseFee = _l2BaseFee;
     }
 
     /*****************************

rollup/tests/bridge_test.go

@@ -40,8 +40,8 @@ var (
 	l1Client *ethclient.Client
 	l2Client *ethclient.Client
 
-	// l1Auth
 	l1Auth *bind.TransactOpts
+	l2Auth *bind.TransactOpts
 )
 
 func setupDB(t *testing.T) *gorm.DB {
@@ -82,6 +82,7 @@ func setupEnv(t *testing.T) {
 	var (
 		err           error
 		l1GethChainID *big.Int
+		l2GethChainID *big.Int
 	)
 
 	testApps = tc.NewTestcontainerApps()
@@ -96,6 +97,8 @@ func setupEnv(t *testing.T) {
 	assert.NoError(t, err)
 	l1GethChainID, err = l1Client.ChainID(context.Background())
 	assert.NoError(t, err)
+	l2GethChainID, err = l2Client.ChainID(context.Background())
+	assert.NoError(t, err)
 
 	l1Cfg, l2Cfg := rollupApp.Config.L1Config, rollupApp.Config.L2Config
 	l1Cfg.Confirmations = 0
@@ -103,17 +106,16 @@ func setupEnv(t *testing.T) {
 	l2Cfg.Confirmations = 0
 	l2Cfg.RelayerConfig.SenderConfig.Confirmations = 0
 
-	l1Auth, err = bind.NewKeyedTransactorWithChainID(rollupApp.Config.L2Config.RelayerConfig.CommitSenderPrivateKey, l1GethChainID)
+	l1Auth, err = bind.NewKeyedTransactorWithChainID(l2Cfg.RelayerConfig.CommitSenderPrivateKey, l1GethChainID)
 	assert.NoError(t, err)
-	rollupApp.Config.L1Config.Endpoint, err = testApps.GetPoSL1EndPoint()
-	assert.NoError(t, err)
-	rollupApp.Config.L2Config.RelayerConfig.SenderConfig.Endpoint, err = testApps.GetPoSL1EndPoint()
+
+	l2Auth, err = bind.NewKeyedTransactorWithChainID(l1Cfg.RelayerConfig.GasOracleSenderPrivateKey, l2GethChainID)
 	assert.NoError(t, err)
 
 	port, err := rand.Int(rand.Reader, big.NewInt(10000))
 	assert.NoError(t, err)
 	svrPort := strconv.FormatInt(port.Int64()+40000, 10)
-	rollupApp.Config.L2Config.RelayerConfig.ChainMonitor.BaseURL = "http://localhost:" + svrPort
+	l2Cfg.RelayerConfig.ChainMonitor.BaseURL = "http://localhost:" + svrPort
 }
 
 func mockChainMonitorServer(baseURL string) (*http.Server, error) {
@@ -137,7 +139,7 @@ func prepareContracts(t *testing.T) {
 	// L1 ScrolChain contract
 	nonce, err := l1Client.PendingNonceAt(context.Background(), l1Auth.From)
 	assert.NoError(t, err)
-	scrollChainAddress := crypto.CreateAddress(l1Auth.From, nonce)
+	mockL1ContractAddress := crypto.CreateAddress(l1Auth.From, nonce)
 	tx := types.NewContractCreation(nonce, big.NewInt(0), 10000000, big.NewInt(1000000000), common.FromHex(mock_bridge.MockBridgeMetaData.Bin))
 	signedTx, err := l1Auth.Signer(l1Auth.From, tx)
 	assert.NoError(t, err)
@@ -155,13 +157,41 @@ func prepareContracts(t *testing.T) {
 	}, 30*time.Second, time.Second)
 
 	assert.Eventually(t, func() bool {
-		code, err := l1Client.CodeAt(context.Background(), scrollChainAddress, nil)
+		code, err := l1Client.CodeAt(context.Background(), mockL1ContractAddress, nil)
+		return err == nil && len(code) > 0
+	}, 30*time.Second, time.Second)
+
+	// L2 ScrolChain contract
+	nonce, err = l2Client.PendingNonceAt(context.Background(), l2Auth.From)
+	assert.NoError(t, err)
+	mockL2ContractAddress := crypto.CreateAddress(l2Auth.From, nonce)
+	tx = types.NewContractCreation(nonce, big.NewInt(0), 2000000, big.NewInt(1000000000), common.FromHex(mock_bridge.MockBridgeMetaData.Bin))
+	signedTx, err = l2Auth.Signer(l2Auth.From, tx)
+	assert.NoError(t, err)
+	err = l2Client.SendTransaction(context.Background(), signedTx)
+	assert.NoError(t, err)
+
+	assert.Eventually(t, func() bool {
+		_, isPending, err := l2Client.TransactionByHash(context.Background(), signedTx.Hash())
+		return err == nil && !isPending
+	}, 30*time.Second, time.Second)
+
+	assert.Eventually(t, func() bool {
+		receipt, err := l2Client.TransactionReceipt(context.Background(), signedTx.Hash())
+		return err == nil && receipt.Status == gethTypes.ReceiptStatusSuccessful
+	}, 30*time.Second, time.Second)
+
+	assert.Eventually(t, func() bool {
+		code, err := l2Client.CodeAt(context.Background(), mockL2ContractAddress, nil)
 		return err == nil && len(code) > 0
 	}, 30*time.Second, time.Second)
 
 	l1Config, l2Config := rollupApp.Config.L1Config, rollupApp.Config.L2Config
-	l1Config.ScrollChainContractAddress = scrollChainAddress
-	l2Config.RelayerConfig.RollupContractAddress = scrollChainAddress
+	l1Config.ScrollChainContractAddress = mockL1ContractAddress
+	l2Config.RelayerConfig.RollupContractAddress = mockL1ContractAddress
+
+	l2Config.RelayerConfig.GasPriceOracleContractAddress = mockL1ContractAddress
+	l1Config.RelayerConfig.GasPriceOracleContractAddress = mockL2ContractAddress
 }
 
 func TestFunction(t *testing.T) {
@@ -182,5 +212,6 @@ func TestFunction(t *testing.T) {
 
 	// l1/l2 gas oracle
 	t.Run("TestImportL1GasPrice", testImportL1GasPrice)
+	t.Run("TestImportL1GasPriceAfterCurie", testImportL1GasPriceAfterCurie)
 	t.Run("TestImportL2GasPrice", testImportL2GasPrice)
 }

rollup/tests/gas_oracle_test.go

@@ -64,6 +64,51 @@ func testImportL1GasPrice(t *testing.T) {
 	assert.Equal(t, types.GasOracleStatus(blocks[0].GasOracleStatus), types.GasOracleImporting)
 }
 
+func testImportL1GasPriceAfterCurie(t *testing.T) {
+	db := setupDB(t)
+	defer database.CloseDB(db)
+
+	prepareContracts(t)
+
+	l1Cfg := rollupApp.Config.L1Config
+
+	// Create L1Relayer
+	l1Relayer, err := relayer.NewLayer1Relayer(context.Background(), db, l1Cfg.RelayerConfig, &params.ChainConfig{BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0)}, relayer.ServiceTypeL1GasOracle, nil)
+	assert.NoError(t, err)
+	defer l1Relayer.StopSenders()
+
+	// Create L1Watcher
+	startHeight, err := l1Client.BlockNumber(context.Background())
+	assert.NoError(t, err)
+	l1Watcher := watcher.NewL1WatcherClient(context.Background(), l1Client, startHeight-1, 0, l1Cfg.L1MessageQueueAddress, l1Cfg.ScrollChainContractAddress, db, nil)
+
+	// fetch new blocks
+	number, err := l1Client.BlockNumber(context.Background())
+	assert.Greater(t, number, startHeight-1)
+	assert.NoError(t, err)
+	err = l1Watcher.FetchBlockHeader(number)
+	assert.NoError(t, err)
+
+	l1BlockOrm := orm.NewL1Block(db)
+	// check db status
+	latestBlockHeight, err := l1BlockOrm.GetLatestL1BlockHeight(context.Background())
+	assert.NoError(t, err)
+	assert.Equal(t, number, latestBlockHeight)
+	blocks, err := l1BlockOrm.GetL1Blocks(context.Background(), map[string]interface{}{"number": latestBlockHeight})
+	assert.NoError(t, err)
+	assert.Equal(t, len(blocks), 1)
+	assert.Empty(t, blocks[0].OracleTxHash)
+	assert.Equal(t, types.GasOracleStatus(blocks[0].GasOracleStatus), types.GasOraclePending)
+
+	// relay gas price
+	l1Relayer.ProcessGasPriceOracle()
+	blocks, err = l1BlockOrm.GetL1Blocks(context.Background(), map[string]interface{}{"number": latestBlockHeight})
+	assert.NoError(t, err)
+	assert.Equal(t, len(blocks), 1)
+	assert.NotEmpty(t, blocks[0].OracleTxHash)
+	assert.Equal(t, types.GasOracleStatus(blocks[0].GasOracleStatus), types.GasOracleImporting)
+}
+
 func testImportL2GasPrice(t *testing.T) {
 	db := setupDB(t)
 	defer database.CloseDB(db)