contracts-bedrock: ecotone gas config support (#10226)

* contracts-bedrock: ecotone gas config support

Updates the gas config on the `SystemConfig` to be ecotone first.
This resolves chain operator ux issues with setting the gas config,
rendering the additional tooling for calculating the encoded
scalar version obsolete. This version of the system config
is technically backwards compatible with pre-ecotone, but it
requires a follow up tx to call the old `setGasConfig` method.
The old gas config method was updated such that it cannot
be used to set ecotone style config to prevent footguns.
A new method `setGasConfigEcotone` should be used instead.

* tests: fix build

* config: fixup

* deploy-config: fixup

* chain-assertions: improve

* lint: fix

* scripts: remove overhead and scalar config

Reduces tech debt

* contracts-bedrock: fix build

* snapshots: update

* gas-snapshot: update

* contracts-bedrock: fix tests

* semver-lock: regenerate

* build: fix

* build: fix

* e2e: fix build

* config: fix test

* op-e2e: cleanup

Still support pre-ecotone tests

* test: fix

* kontrol: fixup

* op-e2e: turn on ecotone

* ecotone: fix test

* op-e2e: fix test

* op-e2e: fix failing test

* op-e2e: update tests

* deps: update

* kontrol: update

* semver-lock: update

* snapshots: update after version change

* typo: fix
Co-authored-by: Matt Solomon <matt@mattsolomon.dev>

---------
Co-authored-by: Matt Solomon <matt@mattsolomon.dev>

op-chain-ops/genesis/config.go

@@ -383,12 +383,6 @@ func (d *DeployConfig) Check() error {
 	if !d.SequencerFeeVaultWithdrawalNetwork.Valid() {
 		return fmt.Errorf("%w: SequencerFeeVaultWithdrawalNetwork can only be 0 (L1) or 1 (L2)", ErrInvalidDeployConfig)
 	}
-	if d.GasPriceOracleOverhead == 0 {
-		log.Warn("GasPriceOracleOverhead is 0")
-	}
-	if d.GasPriceOracleScalar == 0 {
-		log.Warn("GasPriceOracleScalar is 0")
-	}
 	if d.GasPriceOracleBaseFeeScalar == 0 {
 		log.Warn("GasPriceOracleBaseFeeScalar is 0")
 	}
@@ -606,7 +600,8 @@ func (d *DeployConfig) InteropTime(genesisTime uint64) *uint64 {
 	return &v
 }
 
-// RollupConfig converts a DeployConfig to a rollup.Config
+// RollupConfig converts a DeployConfig to a rollup.Config. If Ecotone is active at genesis, the
+// Overhead value is considered a noop.
 func (d *DeployConfig) RollupConfig(l1StartBlock *types.Block, l2GenesisBlockHash common.Hash, l2GenesisBlockNumber uint64) (*rollup.Config, error) {
 	if d.OptimismPortalProxy == (common.Address{}) {
 		return nil, errors.New("OptimismPortalProxy cannot be address(0)")

op-chain-ops/upgrades/l1.go

@@ -700,12 +700,6 @@ func SystemConfig(batch *safe.Batch, implementations superchain.ImplementationLi
 	}
 
 	if config != nil {
-		if gasPriceOracleOverhead.Uint64() != config.GasPriceOracleOverhead {
-			return fmt.Errorf("GasPriceOracleOverhead address doesn't match config")
-		}
-		if gasPriceOracleScalar.Uint64() != config.GasPriceOracleScalar {
-			return fmt.Errorf("GasPriceOracleScalar address doesn't match config")
-		}
 		if batcherHash != common.BytesToHash(config.BatchSenderAddress.Bytes()) {
 			return fmt.Errorf("BatchSenderAddress address doesn't match config")
 		}

op-e2e/actions/ecotone_fork_test.go

@@ -74,7 +74,8 @@ func TestEcotoneNetworkUpgradeTransactions(gt *testing.T) {
 	scalar, err := gasPriceOracle.Scalar(nil)
 	require.NoError(t, err)
 	require.True(t, scalar.Cmp(big.NewInt(0)) > 0, "scalar must start non-zero")
-	require.True(t, scalar.Cmp(new(big.Int).SetUint64(dp.DeployConfig.GasPriceOracleScalar)) == 0, "must match deploy config")
+	feeScalar := dp.DeployConfig.FeeScalar()
+	require.Equal(t, scalar, new(big.Int).SetBytes(feeScalar[:]), "must match deploy config")
 
 	// Get current implementations addresses (by slot) for L1Block + GasPriceOracle
 	initialGasPriceOracleAddress, err := ethCl.StorageAt(context.Background(), predeploys.GasPriceOracleAddr, genesis.ImplementationSlot, nil)
@@ -193,7 +194,7 @@ func TestEcotoneNetworkUpgradeTransactions(gt *testing.T) {
 	// test if the migrated scalar matches the deploy config
 	basefeeScalar, err := gasPriceOracle.BaseFeeScalar(nil)
 	require.NoError(t, err)
-	require.True(t, uint64(basefeeScalar) == dp.DeployConfig.GasPriceOracleScalar, "must match deploy config")
+	require.Equal(t, uint64(basefeeScalar), dp.DeployConfig.GasPriceOracleScalar, "must match deploy config")
 
 	cost, err = gasPriceOracle.GetL1Fee(nil, []byte{0, 1, 2, 3, 4})
 	require.NoError(t, err)

op-e2e/custom_gas_token_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/predeploys"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/stretchr/testify/require"
@@ -23,6 +24,12 @@ func TestCustomGasToken(t *testing.T) {
 	InitParallel(t, SkipOnFPAC) // Custom Gas Token feature is not yet compatible with FPAC
 
 	cfg := DefaultSystemConfig(t)
+	offset := hexutil.Uint64(0)
+	cfg.DeployConfig.L2GenesisRegolithTimeOffset = &offset
+	cfg.DeployConfig.L1CancunTimeOffset = &offset
+	cfg.DeployConfig.L2GenesisCanyonTimeOffset = &offset
+	cfg.DeployConfig.L2GenesisDeltaTimeOffset = &offset
+	cfg.DeployConfig.L2GenesisEcotoneTimeOffset = &offset
 
 	sys, err := cfg.Start(t)
 	require.NoError(t, err, "Error starting up system")
@@ -324,9 +331,9 @@ func setCustomGasToken(t *testing.T, cfg SystemConfig, sys *System, cgtAddress c
 	// Get existing parameters from SystemConfigProxy contract
 	owner, err := systemConfig.Owner(&bind.CallOpts{})
 	require.NoError(t, err)
-	overhead, err := systemConfig.Overhead(&bind.CallOpts{})
+	basefeeScalar, err := systemConfig.BasefeeScalar(&bind.CallOpts{})
 	require.NoError(t, err)
-	scalar, err := systemConfig.Scalar(&bind.CallOpts{})
+	blobbasefeeScalar, err := systemConfig.BlobbasefeeScalar(&bind.CallOpts{})
 	require.NoError(t, err)
 	batcherHash, err := systemConfig.BatcherHash(&bind.CallOpts{})
 	require.NoError(t, err)
@@ -406,8 +413,8 @@ func setCustomGasToken(t *testing.T, cfg SystemConfig, sys *System, cgtAddress c
 
 	// Reinitialise with existing initializer values but with custom gas token set
 	tx, err = systemConfig.Initialize(deployerOpts, owner,
-		overhead,
-		scalar,
+		basefeeScalar,
+		blobbasefeeScalar,
 		batcherHash,
 		gasLimit,
 		unsafeBlockSigner,

op-e2e/system_test.go

@@ -1266,7 +1266,8 @@ func testFees(t *testing.T, cfg SystemConfig) {
 
 		scalar, err := gpoContract.Scalar(&bind.CallOpts{})
 		require.Nil(t, err, "reading gpo scalar")
-		require.Equal(t, scalar.Uint64(), cfg.DeployConfig.GasPriceOracleScalar, "wrong gpo scalar")
+		feeScalar := cfg.DeployConfig.FeeScalar()
+		require.Equal(t, scalar, new(big.Int).SetBytes(feeScalar[:]), "wrong gpo scalar")
 	} else {
 		_, err := gpoContract.Overhead(&bind.CallOpts{})
 		require.ErrorContains(t, err, "deprecated")

op-e2e/system_tob_test.go

@@ -43,8 +43,9 @@ func TestGasPriceOracleFeeUpdates(t *testing.T) {
 	InitParallel(t)
 	// Define our values to set in the GasPriceOracle (we set them high to see if it can lock L2 or stop bindings
 	// from updating the prices once again.
-	overheadValue := abi.MaxUint256
-	scalarValue := abi.MaxUint256
+	overheadValue := new(big.Int).Set(abi.MaxUint256)
+	// Ensure the most significant byte is 0x00
+	scalarValue := new(big.Int).Rsh(new(big.Int).Set(abi.MaxUint256), 8)
 	var cancel context.CancelFunc
 
 	// Create our system configuration for L1/L2 and start it

op-node/rollup/types.go

@@ -25,7 +25,6 @@ var (
 	ErrGenesisHashesSame             = errors.New("achievement get! rollup inception: L1 and L2 genesis cannot be the same")
 	ErrMissingGenesisL2Time          = errors.New("missing L2 genesis time")
 	ErrMissingBatcherAddr            = errors.New("missing genesis system config batcher address")
-	ErrMissingOverhead               = errors.New("missing genesis system config overhead")
 	ErrMissingScalar                 = errors.New("missing genesis system config scalar")
 	ErrMissingGasLimit               = errors.New("missing genesis system config gas limit")
 	ErrMissingBatchInboxAddress      = errors.New("missing batch inbox address")
@@ -278,9 +277,6 @@ func (cfg *Config) Check() error {
 	if cfg.Genesis.SystemConfig.BatcherAddr == (common.Address{}) {
 		return ErrMissingBatcherAddr
 	}
-	if cfg.Genesis.SystemConfig.Overhead == (eth.Bytes32{}) {
-		return ErrMissingOverhead
-	}
 	if cfg.Genesis.SystemConfig.Scalar == (eth.Bytes32{}) {
 		return ErrMissingScalar
 	}

op-node/rollup/types_test.go

@@ -405,11 +405,6 @@ func TestConfig_Check(t *testing.T) {
 			modifier:    func(cfg *Config) { cfg.Genesis.SystemConfig.BatcherAddr = common.Address{} },
 			expectedErr: ErrMissingBatcherAddr,
 		},
-		{
-			name:        "NoOverhead",
-			modifier:    func(cfg *Config) { cfg.Genesis.SystemConfig.Overhead = eth.Bytes32{} },
-			expectedErr: ErrMissingOverhead,
-		},
 		{
 			name:        "NoScalar",
 			modifier:    func(cfg *Config) { cfg.Genesis.SystemConfig.Scalar = eth.Bytes32{} },

packages/contracts-bedrock/.gas-snapshot

-GasBenchMark_L1CrossDomainMessenger:test_sendMessage_benchmark_0() (gas: 369357)
-GasBenchMark_L1CrossDomainMessenger:test_sendMessage_benchmark_1() (gas: 2967497)
-GasBenchMark_L1StandardBridge_Deposit:test_depositERC20_benchmark_0() (gas: 561969)
-GasBenchMark_L1StandardBridge_Deposit:test_depositERC20_benchmark_1() (gas: 4074012)
-GasBenchMark_L1StandardBridge_Deposit:test_depositETH_benchmark_0() (gas: 466924)
-GasBenchMark_L1StandardBridge_Deposit:test_depositETH_benchmark_1() (gas: 3512606)
+GasBenchMark_L1CrossDomainMessenger:test_sendMessage_benchmark_0() (gas: 369380)
+GasBenchMark_L1CrossDomainMessenger:test_sendMessage_benchmark_1() (gas: 2967520)
+GasBenchMark_L1StandardBridge_Deposit:test_depositERC20_benchmark_0() (gas: 561992)
+GasBenchMark_L1StandardBridge_Deposit:test_depositERC20_benchmark_1() (gas: 4074035)
+GasBenchMark_L1StandardBridge_Deposit:test_depositETH_benchmark_0() (gas: 466947)
+GasBenchMark_L1StandardBridge_Deposit:test_depositETH_benchmark_1() (gas: 3512629)
 GasBenchMark_L1StandardBridge_Finalize:test_finalizeETHWithdrawal_benchmark() (gas: 72629)
 GasBenchMark_L2OutputOracle:test_proposeL2Output_benchmark() (gas: 92973)
-GasBenchMark_OptimismPortal:test_depositTransaction_benchmark() (gas: 68410)
-GasBenchMark_OptimismPortal:test_depositTransaction_benchmark_1() (gas: 68880)
+GasBenchMark_OptimismPortal:test_depositTransaction_benchmark() (gas: 68433)
+GasBenchMark_OptimismPortal:test_depositTransaction_benchmark_1() (gas: 68903)
 GasBenchMark_OptimismPortal:test_proveWithdrawalTransaction_benchmark() (gas: 155618)
\ No newline at end of file

packages/contracts-bedrock/deploy-config/devnetL1-template.json

@@ -35,6 +35,8 @@
   "l2GenesisBlockBaseFeePerGas": "0x1",
   "gasPriceOracleOverhead": 2100,
   "gasPriceOracleScalar": 1000000,
+  "gasPriceOracleBaseFeeScalar": 1368,
+  "gasPriceOracleBlobBaseFeeScalar": 810949,
   "enableGovernance": true,
   "governanceTokenSymbol": "OP",
   "governanceTokenName": "Optimism",

packages/contracts-bedrock/deploy-config/hardhat.json

@@ -16,8 +16,6 @@
   "l2OutputOracleSubmissionInterval": 6,
   "l2OutputOracleStartingTimestamp": 1,
   "l2OutputOracleStartingBlockNumber": 1,
-  "gasPriceOracleOverhead": 2100,
-  "gasPriceOracleScalar": 1000000,
   "gasPriceOracleBaseFeeScalar": 1368,
   "gasPriceOracleBlobBaseFeeScalar": 810949,
   "l2OutputOracleProposer": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",

packages/contracts-bedrock/deploy-config/internal-devnet.json

@@ -34,8 +34,6 @@
   "governanceTokenOwner": "0x858F0751ef8B4067f0d2668C076BDB50a8549fbF",
   "l2GenesisBlockGasLimit": "0x17D7840",
   "l2GenesisBlockBaseFeePerGas": "0x3b9aca00",
-  "gasPriceOracleOverhead": 2100,
-  "gasPriceOracleScalar": 1000000,
   "eip1559Denominator": 50,
   "eip1559Elasticity": 10,
   "systemConfigStartBlock": 8364212,

packages/contracts-bedrock/deploy-config/mainnet.json

@@ -34,8 +34,6 @@
   "governanceTokenOwner": "0x5C4e7Ba1E219E47948e6e3F55019A647bA501005",
   "l2GenesisBlockGasLimit": "0x1c9c380",
   "l2GenesisBlockBaseFeePerGas": "0x3b9aca00",
-  "gasPriceOracleOverhead": 0,
-  "gasPriceOracleScalar": 0,
   "gasPriceOracleBaseFeeScalar": 1368,
   "gasPriceOracleBlobBaseFeeScalar": 810949,
   "eip1559Denominator": 50,

packages/contracts-bedrock/deploy-config/sepolia-devnet-0.json

@@ -57,8 +57,6 @@
   "l1ERC721BridgeProxy": "0x0000000000000000000000000000000000000000",
   "systemConfigProxy": "0x0000000000000000000000000000000000000000",
   "optimismPortalProxy": "0x0000000000000000000000000000000000000000",
-  "gasPriceOracleOverhead": 188,
-  "gasPriceOracleScalar": 684000,
   "enableGovernance": true,
   "governanceTokenSymbol": "OP",
   "governanceTokenName": "Optimism",

packages/contracts-bedrock/deploy-config/sepolia.json

@@ -28,8 +28,6 @@
   "baseFeeVaultWithdrawalNetwork": 0,
   "l1FeeVaultWithdrawalNetwork": 0,
   "sequencerFeeVaultWithdrawalNetwork": 0,
-  "gasPriceOracleOverhead": 188,
-  "gasPriceOracleScalar": 684000,
   "enableGovernance": true,
   "governanceTokenSymbol": "OP",
   "governanceTokenName": "Optimism",

packages/contracts-bedrock/scripts/ChainAssertions.sol

@@ -71,11 +71,12 @@ library ChainAssertions {
 
         if (_isProxy) {
             require(config.owner() == _cfg.finalSystemOwner());
-            require(config.overhead() == _cfg.gasPriceOracleOverhead());
-            require(config.scalar() == _cfg.gasPriceOracleScalar());
+            require(config.basefeeScalar() == _cfg.basefeeScalar());
+            require(config.blobbasefeeScalar() == _cfg.blobbasefeeScalar());
             require(config.batcherHash() == bytes32(uint256(uint160(_cfg.batchSenderAddress()))));
             require(config.gasLimit() == uint64(_cfg.l2GenesisBlockGasLimit()));
             require(config.unsafeBlockSigner() == _cfg.p2pSequencerAddress());
+            require(config.scalar() >> 248 == 1);
             // Check _config
             ResourceMetering.ResourceConfig memory rconfig = Constants.DEFAULT_RESOURCE_CONFIG();
             require(resourceConfig.maxResourceLimit == rconfig.maxResourceLimit);
@@ -98,7 +99,9 @@ library ChainAssertions {
         } else {
             require(config.owner() == address(0xdead));
             require(config.overhead() == 0);
-            require(config.scalar() == 0);
+            require(config.scalar() == uint256(0x01) << 248); // version 1
+            require(config.basefeeScalar() == 0);
+            require(config.blobbasefeeScalar() == 0);
             require(config.batcherHash() == bytes32(0));
             require(config.gasLimit() == 1);
             require(config.unsafeBlockSigner() == address(0));

packages/contracts-bedrock/scripts/Deploy.s.sol

@@ -985,8 +985,8 @@ contract Deploy is Deployer {
                 SystemConfig.initialize,
                 (
                     cfg.finalSystemOwner(),
-                    cfg.gasPriceOracleOverhead(),
-                    cfg.gasPriceOracleScalar(),
+                    cfg.basefeeScalar(),
+                    cfg.blobbasefeeScalar(),
                     batcherHash,
                     uint64(cfg.l2GenesisBlockGasLimit()),
                     cfg.p2pSequencerAddress(),

packages/contracts-bedrock/scripts/DeployConfig.s.sol

@@ -46,8 +46,8 @@ contract DeployConfig is Script {
     string public governanceTokenSymbol;
     address public governanceTokenOwner;
     uint256 public l2GenesisBlockGasLimit;
-    uint256 public gasPriceOracleOverhead;
-    uint256 public gasPriceOracleScalar;
+    uint32 public basefeeScalar;
+    uint32 public blobbasefeeScalar;
     bool public enableGovernance;
     uint256 public eip1559Denominator;
     uint256 public eip1559Elasticity;
@@ -119,8 +119,9 @@ contract DeployConfig is Script {
         governanceTokenSymbol = stdJson.readString(_json, "$.governanceTokenSymbol");
         governanceTokenOwner = stdJson.readAddress(_json, "$.governanceTokenOwner");
         l2GenesisBlockGasLimit = stdJson.readUint(_json, "$.l2GenesisBlockGasLimit");
-        gasPriceOracleOverhead = stdJson.readUint(_json, "$.gasPriceOracleOverhead");
-        gasPriceOracleScalar = stdJson.readUint(_json, "$.gasPriceOracleScalar");
+        basefeeScalar = uint32(_readOr(_json, "$.gasPriceOracleBaseFeeScalar", 1368));
+        blobbasefeeScalar = uint32(_readOr(_json, "$.gasPriceOracleBlobBaseFeeScalar", 810949));
+
         enableGovernance = stdJson.readBool(_json, "$.enableGovernance");
         eip1559Denominator = stdJson.readUint(_json, "$.eip1559Denominator");
         eip1559Elasticity = stdJson.readUint(_json, "$.eip1559Elasticity");

packages/contracts-bedrock/scripts/go-ffi/differential-testing.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/crossdomain"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
 	"github.com/ethereum-optimism/optimism/op-service/predeploys"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
@@ -35,6 +36,8 @@ var (
 		{Type: fixedBytes},
 	}
 
+	uint32Type, _ = abi.NewType("uint32", "", nil)
+
 	// Decoded nonce tuple (nonce, version)
 	decodedNonce, _ = abi.NewType("tuple", "DecodedNonce", []abi.ArgumentMarshaling{
 		{Name: "nonce", Type: "uint256"},
@@ -44,6 +47,12 @@ var (
 		{Name: "encodedNonce", Type: decodedNonce},
 	}
 
+	// Decoded ecotone scalars (uint32, uint32)
+	decodedScalars = abi.Arguments{
+		{Name: "basefeeScalar", Type: uint32Type},
+		{Name: "blobbasefeeScalar", Type: uint32Type},
+	}
+
 	// WithdrawalHash slot tuple (bytes32, bytes32)
 	withdrawalSlot, _ = abi.NewType("tuple", "SlotHash", []abi.ArgumentMarshaling{
 		{Name: "withdrawalHash", Type: "bytes32"},
@@ -361,6 +370,25 @@ func DiffTestUtils() {
 		packed, err := cannonMemoryProofArgs.Pack(&output)
 		checkErr(err, "Error encoding output")
 		fmt.Print(hexutil.Encode(packed[32:]))
+	case "encodeScalarEcotone":
+		basefeeScalar, err := strconv.ParseUint(args[1], 10, 32)
+		checkErr(err, "Error decocding basefeeScalar")
+		blobbasefeeScalar, err := strconv.ParseUint(args[2], 10, 32)
+		checkErr(err, "Error decocding blobbasefeeScalar")
+
+		encoded := eth.EncodeScalar(eth.EcotoneScalars{
+			BaseFeeScalar:     uint32(basefeeScalar),
+			BlobBaseFeeScalar: uint32(blobbasefeeScalar),
+		})
+		fmt.Print(hexutil.Encode(encoded[:]))
+	case "decodeScalarEcotone":
+		scalar := common.HexToHash(args[1])
+		scalars, err := eth.DecodeScalar([32]byte(scalar[:]))
+		checkErr(err, "Error decoding scalar")
+
+		packed, err := decodedScalars.Pack(scalars.BaseFeeScalar, scalars.BlobBaseFeeScalar)
+		checkErr(err, "Error encoding output")
+		fmt.Print(hexutil.Encode(packed))
 	default:
 		panic(fmt.Errorf("Unknown command: %s", args[0]))
 	}

packages/contracts-bedrock/semver-lock.json

@@ -48,8 +48,8 @@
     "sourceCodeHash": "0xd6a894e371c2c7182b5960c507491f81c3775dda0efedd29475f7c30ca07b004"
   },
   "src/L1/SystemConfig.sol": {
-    "initCodeHash": "0xe937c5747e42d6701ff3fbb10471302288fa765fb40cbd9822e22547a42dfa25",
-    "sourceCodeHash": "0x9fb21393eb206f94bdf7e034c667535c415b7de93a1355058626d1c9e8abbff5"
+    "initCodeHash": "0x6160c9c96d0972e0761ab3b9d4f6d1b8543288c4c3aea9e132008a40e4c5d202",
+    "sourceCodeHash": "0xd27df6e227cc4728471641aec25a1fe6f79a12ce96d3ce6c1774d9411a54133e"
   },
   "src/L2/BaseFeeVault.sol": {
     "initCodeHash": "0x2744d34573be83206d1b75d049d18a7bb37f9058e68c0803e5008c46b0dc2474",

packages/contracts-bedrock/snapshots/abi/SystemConfig.json

@@ -134,6 +134,19 @@
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "basefeeScalar",
+    "outputs": [
+      {
+        "internalType": "uint32",
+        "name": "",
+        "type": "uint32"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [],
     "name": "batchInbox",
@@ -160,6 +173,19 @@
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "blobbasefeeScalar",
+    "outputs": [
+      {
+        "internalType": "uint32",
+        "name": "",
+        "type": "uint32"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [],
     "name": "disputeGameFactory",
@@ -238,14 +264,14 @@
         "type": "address"
       },
       {
-        "internalType": "uint256",
-        "name": "_overhead",
-        "type": "uint256"
+        "internalType": "uint32",
+        "name": "_basefeeScalar",
+        "type": "uint32"
       },
       {
-        "internalType": "uint256",
-        "name": "_scalar",
-        "type": "uint256"
+        "internalType": "uint32",
+        "name": "_blobbasefeeScalar",
+        "type": "uint32"
       },
       {
         "internalType": "bytes32",
@@ -578,6 +604,24 @@
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "uint32",
+        "name": "_basefeeScalar",
+        "type": "uint32"
+      },
+      {
+        "internalType": "uint32",
+        "name": "_blobbasefeeScalar",
+        "type": "uint32"
+      }
+    ],
+    "name": "setGasConfigEcotone",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {

packages/contracts-bedrock/snapshots/storageLayout/SystemConfig.json

@@ -62,6 +62,20 @@
     "slot": "104",
     "type": "uint64"
   },
+  {
+    "bytes": "4",
+    "label": "basefeeScalar",
+    "offset": 8,
+    "slot": "104",
+    "type": "uint32"
+  },
+  {
+    "bytes": "4",
+    "label": "blobbasefeeScalar",
+    "offset": 12,
+    "slot": "104",
+    "type": "uint32"
+  },
   {
     "bytes": "32",
     "label": "_resourceConfig",

packages/contracts-bedrock/src/L1/SystemConfig.sol

@@ -90,9 +90,12 @@ contract SystemConfig is OwnableUpgradeable, ISemver, IGasToken {
     uint64 internal constant MAX_GAS_LIMIT = 200_000_000;
 
     /// @notice Fixed L2 gas overhead. Used as part of the L2 fee calculation.
+    ///         Deprecated since the Ecotone network upgrade
     uint256 public overhead;
 
     /// @notice Dynamic L2 gas overhead. Used as part of the L2 fee calculation.
+    ///         The most significant byte is used to determine the version since the
+    ///         Ecotone network upgrade.
     uint256 public scalar;
 
     /// @notice Identifier for the batcher.
@@ -103,6 +106,12 @@ contract SystemConfig is OwnableUpgradeable, ISemver, IGasToken {
     /// @notice L2 block gas limit.
     uint64 public gasLimit;
 
+    /// @notice Basefee scalar value. Part of the L2 fee calculation since the Ecotone network upgrade.
+    uint32 public basefeeScalar;
+
+    /// @notice Blobbasefee scalar value. Part of the L2 fee calculation since the Ecotone network upgrade.
+    uint32 public blobbasefeeScalar;
+
     /// @notice The configuration for the deposit fee market.
     ///         Used by the OptimismPortal to meter the cost of buying L2 gas on L1.
     ///         Set as internal with a getter so that the struct is returned instead of a tuple.
@@ -115,8 +124,8 @@ contract SystemConfig is OwnableUpgradeable, ISemver, IGasToken {
     event ConfigUpdate(uint256 indexed version, UpdateType indexed updateType, bytes data);
 
     /// @notice Semantic version.
-    /// @custom:semver 2.2.0
-    string public constant version = "2.2.0";
+    /// @custom:semver 2.3.0-beta.1
+    string public constant version = "2.3.0-beta.1";
 
     /// @notice Constructs the SystemConfig contract. Cannot set
     ///         the owner to `address(0)` due to the Ownable contract's
@@ -127,8 +136,8 @@ contract SystemConfig is OwnableUpgradeable, ISemver, IGasToken {
         Storage.setUint(START_BLOCK_SLOT, type(uint256).max);
         initialize({
             _owner: address(0xdEaD),
-            _overhead: 0,
-            _scalar: 0,
+            _basefeeScalar: 0,
+            _blobbasefeeScalar: 0,
             _batcherHash: bytes32(0),
             _gasLimit: 1,
             _unsafeBlockSigner: address(0),
@@ -156,8 +165,8 @@ contract SystemConfig is OwnableUpgradeable, ISemver, IGasToken {
     /// @notice Initializer.
     ///         The resource config must be set before the require check.
     /// @param _owner             Initial owner of the contract.
-    /// @param _overhead          Initial overhead value.
-    /// @param _scalar            Initial scalar value.
+    /// @param _basefeeScalar     Initial basefee scalar value.
+    /// @param _blobbasefeeScalar Initial blobbasefee scalar value.
     /// @param _batcherHash       Initial batcher hash.
     /// @param _gasLimit          Initial gas limit.
     /// @param _unsafeBlockSigner Initial unsafe block signer address.
@@ -167,8 +176,8 @@ contract SystemConfig is OwnableUpgradeable, ISemver, IGasToken {
     /// @param _addresses         Set of L1 contract addresses. These should be the proxies.
     function initialize(
         address _owner,
-        uint256 _overhead,
-        uint256 _scalar,
+        uint32 _basefeeScalar,
+        uint32 _blobbasefeeScalar,
         bytes32 _batcherHash,
         uint64 _gasLimit,
         address _unsafeBlockSigner,
@@ -184,7 +193,7 @@ contract SystemConfig is OwnableUpgradeable, ISemver, IGasToken {
 
         // These are set in ascending order of their UpdateTypes.
         _setBatcherHash(_batcherHash);
-        _setGasConfig({ _overhead: _overhead, _scalar: _scalar });
+        _setGasConfigEcotone({ _basefeeScalar: _basefeeScalar, _blobbasefeeScalar: _blobbasefeeScalar });
         _setGasLimit(_gasLimit);
 
         Storage.setAddress(UNSAFE_BLOCK_SIGNER_SLOT, _unsafeBlockSigner);
@@ -346,6 +355,7 @@ contract SystemConfig is OwnableUpgradeable, ISemver, IGasToken {
     }
 
     /// @notice Updates gas config. Can only be called by the owner.
+    ///         Deprecated in favor of setGasConfigEcotone since the Ecotone upgrade.
     /// @param _overhead New overhead value.
     /// @param _scalar   New scalar value.
     function setGasConfig(uint256 _overhead, uint256 _scalar) external onlyOwner {
@@ -356,6 +366,8 @@ contract SystemConfig is OwnableUpgradeable, ISemver, IGasToken {
     /// @param _overhead New overhead value.
     /// @param _scalar   New scalar value.
     function _setGasConfig(uint256 _overhead, uint256 _scalar) internal {
+        require((uint256(0xff) << 248) & _scalar == 0, "SystemConfig: scalar exceeds max.");
+
         overhead = _overhead;
         scalar = _scalar;
 
@@ -363,6 +375,26 @@ contract SystemConfig is OwnableUpgradeable, ISemver, IGasToken {
         emit ConfigUpdate(VERSION, UpdateType.GAS_CONFIG, data);
     }
 
+    /// @notice Updates gas config as of the Ecotone upgrade. Can only be called by the owner.
+    /// @param _basefeeScalar     New basefeeScalar value.
+    /// @param _blobbasefeeScalar New blobbasefeeScalar value.
+    function setGasConfigEcotone(uint32 _basefeeScalar, uint32 _blobbasefeeScalar) external onlyOwner {
+        _setGasConfigEcotone(_basefeeScalar, _blobbasefeeScalar);
+    }
+
+    /// @notice Internal function for updating the fee scalars as of the Ecotone upgrade.
+    /// @param _basefeeScalar     New basefeeScalar value.
+    /// @param _blobbasefeeScalar New blobbasefeeScalar value.
+    function _setGasConfigEcotone(uint32 _basefeeScalar, uint32 _blobbasefeeScalar) internal {
+        basefeeScalar = _basefeeScalar;
+        blobbasefeeScalar = _blobbasefeeScalar;
+
+        scalar = (uint256(0x01) << 248) | (uint256(_blobbasefeeScalar) << 32) | _basefeeScalar;
+
+        bytes memory data = abi.encode(overhead, scalar);
+        emit ConfigUpdate(VERSION, UpdateType.GAS_CONFIG, data);
+    }
+
     /// @notice Updates the L2 gas limit. Can only be called by the owner.
     /// @param _gasLimit New gas limit.
     function setGasLimit(uint64 _gasLimit) external onlyOwner {

packages/contracts-bedrock/test/L1/SystemConfig.t.sol

@@ -26,20 +26,20 @@ contract SystemConfig_Init is CommonTest {
 contract SystemConfig_Initialize_Test is SystemConfig_Init {
     address batchInbox;
     address owner;
-    uint256 overhead;
-    uint256 scalar;
     bytes32 batcherHash;
     uint64 gasLimit;
     address unsafeBlockSigner;
     address systemConfigImpl;
     address optimismMintableERC20Factory;
+    uint32 basefeeScalar;
+    uint32 blobbasefeeScalar;
 
     function setUp() public virtual override {
         super.setUp();
         batchInbox = deploy.cfg().batchInboxAddress();
         owner = deploy.cfg().finalSystemOwner();
-        overhead = deploy.cfg().gasPriceOracleOverhead();
-        scalar = deploy.cfg().gasPriceOracleScalar();
+        basefeeScalar = deploy.cfg().basefeeScalar();
+        blobbasefeeScalar = deploy.cfg().blobbasefeeScalar();
         batcherHash = bytes32(uint256(uint160(deploy.cfg().batchSenderAddress())));
         gasLimit = uint64(deploy.cfg().l2GenesisBlockGasLimit());
         unsafeBlockSigner = deploy.cfg().p2pSequencerAddress();
@@ -52,10 +52,12 @@ contract SystemConfig_Initialize_Test is SystemConfig_Init {
         SystemConfig impl = SystemConfig(systemConfigImpl);
         assertEq(impl.owner(), address(0xdEaD));
         assertEq(impl.overhead(), 0);
-        assertEq(impl.scalar(), 0);
+        assertEq(impl.scalar(), uint256(0x01) << 248);
         assertEq(impl.batcherHash(), bytes32(0));
         assertEq(impl.gasLimit(), 1);
         assertEq(impl.unsafeBlockSigner(), address(0));
+        assertEq(impl.basefeeScalar(), 0);
+        assertEq(impl.blobbasefeeScalar(), 0);
         ResourceMetering.ResourceConfig memory actual = impl.resourceConfig();
         assertEq(actual.maxResourceLimit, 1);
         assertEq(actual.elasticityMultiplier, 1);
@@ -78,14 +80,16 @@ contract SystemConfig_Initialize_Test is SystemConfig_Init {
         assertEq(decimals, 18);
     }
 
-    /// @dev Tests that initailization sets the correct values.
+    /// @dev Tests that initialization sets the correct values.
     function test_initialize_succeeds() external view {
         assertEq(systemConfig.owner(), owner);
-        assertEq(systemConfig.overhead(), overhead);
-        assertEq(systemConfig.scalar(), scalar);
+        assertEq(systemConfig.overhead(), 0);
+        assertEq(systemConfig.scalar() >> 248, 1);
         assertEq(systemConfig.batcherHash(), batcherHash);
         assertEq(systemConfig.gasLimit(), gasLimit);
         assertEq(systemConfig.unsafeBlockSigner(), unsafeBlockSigner);
+        assertEq(systemConfig.basefeeScalar(), basefeeScalar);
+        assertEq(systemConfig.blobbasefeeScalar(), blobbasefeeScalar);
         // Depends on `initialize` being called with defaults
         ResourceMetering.ResourceConfig memory rcfg = Constants.DEFAULT_RESOURCE_CONFIG();
         ResourceMetering.ResourceConfig memory actual = systemConfig.resourceConfig();
@@ -127,8 +131,8 @@ contract SystemConfig_Initialize_TestFail is SystemConfig_Initialize_Test {
         vm.expectRevert("SystemConfig: gas limit too low");
         systemConfig.initialize({
             _owner: alice,
-            _overhead: 2100,
-            _scalar: 1000000,
+            _basefeeScalar: basefeeScalar,
+            _blobbasefeeScalar: blobbasefeeScalar,
             _batcherHash: bytes32(hex"abcd"),
             _gasLimit: minimumGasLimit - 1,
             _unsafeBlockSigner: address(1),
@@ -157,8 +161,8 @@ contract SystemConfig_Initialize_TestFail is SystemConfig_Initialize_Test {
         vm.prank(systemConfig.owner());
         systemConfig.initialize({
             _owner: alice,
-            _overhead: 2100,
-            _scalar: 1000000,
+            _basefeeScalar: basefeeScalar,
+            _blobbasefeeScalar: blobbasefeeScalar,
             _batcherHash: bytes32(hex"abcd"),
             _gasLimit: gasLimit,
             _unsafeBlockSigner: address(1),
@@ -188,8 +192,8 @@ contract SystemConfig_Initialize_TestFail is SystemConfig_Initialize_Test {
         vm.prank(systemConfig.owner());
         systemConfig.initialize({
             _owner: alice,
-            _overhead: 2100,
-            _scalar: 1000000,
+            _basefeeScalar: basefeeScalar,
+            _blobbasefeeScalar: blobbasefeeScalar,
             _batcherHash: bytes32(hex"abcd"),
             _gasLimit: gasLimit,
             _unsafeBlockSigner: address(1),
@@ -283,8 +287,8 @@ contract SystemConfig_Init_ResourceConfig is SystemConfig_Init {
         vm.expectRevert(bytes(revertMessage));
         systemConfig.initialize({
             _owner: address(0xdEaD),
-            _overhead: 0,
-            _scalar: 0,
+            _basefeeScalar: 0,
+            _blobbasefeeScalar: 0,
             _batcherHash: bytes32(0),
             _gasLimit: gasLimit,
             _unsafeBlockSigner: address(0),
@@ -321,8 +325,8 @@ contract SystemConfig_Init_CustomGasToken is SystemConfig_Init {
 
         systemConfig.initialize({
             _owner: alice,
-            _overhead: 2100,
-            _scalar: 1000000,
+            _basefeeScalar: 2100,
+            _blobbasefeeScalar: 1000000,
             _batcherHash: bytes32(hex"abcd"),
             _gasLimit: 30_000_000,
             _unsafeBlockSigner: address(1),
@@ -474,6 +478,18 @@ contract SystemConfig_Setters_TestFail is SystemConfig_Init {
         systemConfig.setGasConfig(0, 0);
     }
 
+    /// @notice Ensures that `setGasConfig` reverts if version byte is set.
+    function test_setGasConfig_badValues_reverts() external {
+        vm.prank(systemConfig.owner());
+        vm.expectRevert("SystemConfig: scalar exceeds max.");
+        systemConfig.setGasConfig({ _overhead: 0, _scalar: type(uint256).max });
+    }
+
+    function test_setGasConfigEcotone_notOwner_reverts() external {
+        vm.expectRevert("Ownable: caller is not the owner");
+        systemConfig.setGasConfigEcotone({ _basefeeScalar: 0, _blobbasefeeScalar: 0 });
+    }
+
     /// @dev Tests that `setGasLimit` reverts if the caller is not the owner.
     function test_setGasLimit_notOwner_reverts() external {
         vm.expectRevert("Ownable: caller is not the owner");
@@ -516,6 +532,8 @@ contract SystemConfig_Setters_Test is SystemConfig_Init {
 
     /// @dev Tests that `setGasConfig` updates the overhead and scalar successfully.
     function testFuzz_setGasConfig_succeeds(uint256 newOverhead, uint256 newScalar) external {
+        // always zero out most significant byte
+        newScalar = (newScalar << 16) >> 16;
         vm.expectEmit(address(systemConfig));
         emit ConfigUpdate(0, SystemConfig.UpdateType.GAS_CONFIG, abi.encode(newOverhead, newScalar));
 
@@ -525,6 +543,24 @@ contract SystemConfig_Setters_Test is SystemConfig_Init {
         assertEq(systemConfig.scalar(), newScalar);
     }
 
+    function testFuzz_setGasConfigEcotone_succeeds(uint32 _basefeeScalar, uint32 _blobbasefeeScalar) external {
+        bytes32 encoded =
+            ffi.encodeScalarEcotone({ _basefeeScalar: _basefeeScalar, _blobbasefeeScalar: _blobbasefeeScalar });
+
+        vm.expectEmit(address(systemConfig));
+        emit ConfigUpdate(0, SystemConfig.UpdateType.GAS_CONFIG, abi.encode(systemConfig.overhead(), encoded));
+
+        vm.prank(systemConfig.owner());
+        systemConfig.setGasConfigEcotone({ _basefeeScalar: _basefeeScalar, _blobbasefeeScalar: _blobbasefeeScalar });
+        assertEq(systemConfig.basefeeScalar(), _basefeeScalar);
+        assertEq(systemConfig.blobbasefeeScalar(), _blobbasefeeScalar);
+        assertEq(systemConfig.scalar(), uint256(encoded));
+
+        (uint32 basefeeScalar, uint32 blobbbasefeeScalar) = ffi.decodeScalarEcotone(encoded);
+        assertEq(uint256(basefeeScalar), uint256(_basefeeScalar));
+        assertEq(uint256(blobbbasefeeScalar), uint256(_blobbasefeeScalar));
+    }
+
     /// @dev Tests that `setGasLimit` updates the gas limit successfully.
     function testFuzz_setGasLimit_succeeds(uint64 newGasLimit) external {
         uint64 minimumGasLimit = systemConfig.minimumGasLimit();

packages/contracts-bedrock/test/kontrol/proofs/utils/DeploymentSummary.sol

@@ -30,7 +30,7 @@ contract DeploymentSummary is DeploymentSummaryCode {
     address internal constant safeSingletonAddress = 0x90193C961A926261B756D1E5bb255e67ff9498A1;
     address internal constant superchainConfigAddress = 0x068E44eB31e111028c41598E4535be7468674D0A;
     address internal constant superchainConfigProxyAddress = 0xDEb1E9a6Be7Baf84208BB6E10aC9F9bbE1D70809;
-    address internal constant systemConfigAddress = 0x19E90dC1Fb905f20BB3A7eC537B5B812d5FFA682;
+    address internal constant systemConfigAddress = 0x1182f45ae539e18534cbCC222c1C3D972B5Ba24D;
     address internal constant systemConfigProxyAddress = 0x1c23A6d89F95ef3148BCDA8E242cAb145bf9c0E4;
     address internal constant systemOwnerSafeAddress = 0x7d039be7F9b5190147621b02e82B250e1D748e02;
 
@@ -242,6 +242,9 @@ contract DeploymentSummary is DeploymentSummaryCode {
         slot = hex"0000000000000000000000000000000000000000000000000000000000000033";
         value = hex"000000000000000000000000000000000000000000000000000000000000dead";
         vm.store(systemConfigAddress, slot, value);
+        slot = hex"0000000000000000000000000000000000000000000000000000000000000066";
+        value = hex"0100000000000000000000000000000000000000000000000000000000000000";
+        vm.store(systemConfigAddress, slot, value);
         slot = hex"0000000000000000000000000000000000000000000000000000000000000068";
         value = hex"0000000000000000000000000000000000000000000000000000000000000001";
         vm.store(systemConfigAddress, slot, value);
@@ -281,7 +284,7 @@ contract DeploymentSummary is DeploymentSummaryCode {
         value = hex"0000000000000000000000000000000000000000000000000000000000000003";
         vm.store(systemOwnerSafeAddress, slot, value);
         slot = hex"360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
-        value = hex"00000000000000000000000019e90dc1fb905f20bb3a7ec537b5b812d5ffa682";
+        value = hex"0000000000000000000000001182f45ae539e18534cbcc222c1c3d972b5ba24d";
         vm.store(systemConfigProxyAddress, slot, value);
         slot = hex"0000000000000000000000000000000000000000000000000000000000000000";
         value = hex"0000000000000000000000000000000000000000000000000000000000000001";
@@ -298,14 +301,14 @@ contract DeploymentSummary is DeploymentSummaryCode {
         slot = hex"0000000000000000000000000000000000000000000000000000000000000067";
         value = hex"0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc";
         vm.store(systemConfigProxyAddress, slot, value);
-        slot = hex"0000000000000000000000000000000000000000000000000000000000000065";
-        value = hex"0000000000000000000000000000000000000000000000000000000000000834";
+        slot = hex"0000000000000000000000000000000000000000000000000000000000000068";
+        value = hex"00000000000000000000000000000000000c5fc5000005580000000000000000";
         vm.store(systemConfigProxyAddress, slot, value);
         slot = hex"0000000000000000000000000000000000000000000000000000000000000066";
-        value = hex"00000000000000000000000000000000000000000000000000000000000f4240";
+        value = hex"010000000000000000000000000000000000000000000000000c5fc500000558";
         vm.store(systemConfigProxyAddress, slot, value);
         slot = hex"0000000000000000000000000000000000000000000000000000000000000068";
-        value = hex"00000000000000000000000000000000000000000000000000000000017d7840";
+        value = hex"00000000000000000000000000000000000c5fc50000055800000000017d7840";
         vm.store(systemConfigProxyAddress, slot, value);
         slot = hex"65a7ed542fb37fe237fdfbdd70b31598523fe5b32879e307bae27a0bd9581c08";
         value = hex"0000000000000000000000009965507d1a55bcc2695c58ba16fb37d819b0a4dc";

packages/contracts-bedrock/test/kontrol/proofs/utils/DeploymentSummaryFaultProofs.sol

@@ -36,7 +36,7 @@ contract DeploymentSummaryFaultProofs is DeploymentSummaryFaultProofsCode {
     address internal constant safeSingletonAddress = 0x90193C961A926261B756D1E5bb255e67ff9498A1;
     address internal constant superchainConfigAddress = 0x068E44eB31e111028c41598E4535be7468674D0A;
     address internal constant superchainConfigProxyAddress = 0xDEb1E9a6Be7Baf84208BB6E10aC9F9bbE1D70809;
-    address internal constant systemConfigAddress = 0x19E90dC1Fb905f20BB3A7eC537B5B812d5FFA682;
+    address internal constant systemConfigAddress = 0x1182f45ae539e18534cbCC222c1C3D972B5Ba24D;
     address internal constant systemConfigProxyAddress = 0x20A42a5a785622c6Ba2576B2D6e924aA82BFA11D;
     address internal constant systemOwnerSafeAddress = 0x7d039be7F9b5190147621b02e82B250e1D748e02;
     address internal constant acc27Address = 0x12e721c390F5728200a26BBEf206A5F4F7E991f3;
@@ -245,6 +245,9 @@ contract DeploymentSummaryFaultProofs is DeploymentSummaryFaultProofsCode {
         slot = hex"0000000000000000000000000000000000000000000000000000000000000033";
         value = hex"000000000000000000000000000000000000000000000000000000000000dead";
         vm.store(systemConfigAddress, slot, value);
+        slot = hex"0000000000000000000000000000000000000000000000000000000000000066";
+        value = hex"0100000000000000000000000000000000000000000000000000000000000000";
+        vm.store(systemConfigAddress, slot, value);
         slot = hex"0000000000000000000000000000000000000000000000000000000000000068";
         value = hex"0000000000000000000000000000000000000000000000000000000000000001";
         vm.store(systemConfigAddress, slot, value);
@@ -373,7 +376,7 @@ contract DeploymentSummaryFaultProofs is DeploymentSummaryFaultProofsCode {
         value = hex"0000000000000000000000000000000000000000000000000000000000000003";
         vm.store(systemOwnerSafeAddress, slot, value);
         slot = hex"360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
-        value = hex"00000000000000000000000019e90dc1fb905f20bb3a7ec537b5b812d5ffa682";
+        value = hex"0000000000000000000000001182f45ae539e18534cbcc222c1c3d972b5ba24d";
         vm.store(systemConfigProxyAddress, slot, value);
         slot = hex"0000000000000000000000000000000000000000000000000000000000000000";
         value = hex"0000000000000000000000000000000000000000000000000000000000000001";
@@ -390,14 +393,14 @@ contract DeploymentSummaryFaultProofs is DeploymentSummaryFaultProofsCode {
         slot = hex"0000000000000000000000000000000000000000000000000000000000000067";
         value = hex"0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc";
         vm.store(systemConfigProxyAddress, slot, value);
-        slot = hex"0000000000000000000000000000000000000000000000000000000000000065";
-        value = hex"0000000000000000000000000000000000000000000000000000000000000834";
+        slot = hex"0000000000000000000000000000000000000000000000000000000000000068";
+        value = hex"00000000000000000000000000000000000c5fc5000005580000000000000000";
         vm.store(systemConfigProxyAddress, slot, value);
         slot = hex"0000000000000000000000000000000000000000000000000000000000000066";
-        value = hex"00000000000000000000000000000000000000000000000000000000000f4240";
+        value = hex"010000000000000000000000000000000000000000000000000c5fc500000558";
         vm.store(systemConfigProxyAddress, slot, value);
         slot = hex"0000000000000000000000000000000000000000000000000000000000000068";
-        value = hex"00000000000000000000000000000000000000000000000000000000017d7840";
+        value = hex"00000000000000000000000000000000000c5fc50000055800000000017d7840";
         vm.store(systemConfigProxyAddress, slot, value);
         slot = hex"65a7ed542fb37fe237fdfbdd70b31598523fe5b32879e307bae27a0bd9581c08";
         value = hex"0000000000000000000000009965507d1a55bcc2695c58ba16fb37d819b0a4dc";

packages/contracts-bedrock/test/setup/FFIInterface.sol

@@ -243,4 +243,25 @@ contract FFIInterface {
         (bytes32 memRoot, bytes memory proof) = abi.decode(result, (bytes32, bytes));
         return (memRoot, proof);
     }
+
+    function encodeScalarEcotone(uint32 _basefeeScalar, uint32 _blobbasefeeScalar) external returns (bytes32) {
+        string[] memory cmds = new string[](5);
+        cmds[0] = "scripts/go-ffi/go-ffi";
+        cmds[1] = "diff";
+        cmds[2] = "encodeScalarEcotone";
+        cmds[3] = vm.toString(_basefeeScalar);
+        cmds[4] = vm.toString(_blobbasefeeScalar);
+        bytes memory result = vm.ffi(cmds);
+        return abi.decode(result, (bytes32));
+    }
+
+    function decodeScalarEcotone(bytes32 _scalar) external returns (uint32, uint32) {
+        string[] memory cmds = new string[](4);
+        cmds[0] = "scripts/go-ffi/go-ffi";
+        cmds[1] = "diff";
+        cmds[2] = "decodeScalarEcotone";
+        cmds[3] = vm.toString(_scalar);
+        bytes memory result = vm.ffi(cmds);
+        return abi.decode(result, (uint32, uint32));
+    }
 }