contracts-bedrock: modularize deposit resource config

op-chain-ops/genesis/layer_one.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
@@ -22,19 +23,45 @@ import (
 	"github.com/ethereum-optimism/optimism/op-chain-ops/state"
 )
 
-var proxies = []string{
-	"SystemConfigProxy",
-	"L2OutputOracleProxy",
-	"L1CrossDomainMessengerProxy",
-	"L1StandardBridgeProxy",
-	"OptimismPortalProxy",
-	"OptimismMintableERC20FactoryProxy",
-}
-
-var portalMeteringSlot = common.Hash{31: 0x01}
+var (
+	// proxies represents the set of proxies in front of contracts.
+	proxies = []string{
+		"SystemConfigProxy",
+		"L2OutputOracleProxy",
+		"L1CrossDomainMessengerProxy",
+		"L1StandardBridgeProxy",
+		"OptimismPortalProxy",
+		"OptimismMintableERC20FactoryProxy",
+	}
+	// portalMeteringSlot is the storage slot containing the metering params.
+	portalMeteringSlot = common.Hash{31: 0x01}
+	// zeroHash represents the zero value for a hash.
+	zeroHash = common.Hash{}
+	// uint128Max is type(uint128).max and is set in the init function.
+	uint128Max = new(big.Int)
+	// The default values for the ResourceConfig, used as part of
+	// an EIP-1559 curve for deposit gas.
+	defaultResourceConfig = bindings.ResourceMeteringResourceConfig{
+		MaxResourceLimit:            20_000_000,
+		ElasticityMultiplier:        10,
+		BaseFeeMaxChangeDenominator: 8,
+		MinimumBaseFee:              params.GWei,
+		SystemTxMaxGas:              1_000_000,
+	}
+)
 
-var zeroHash common.Hash
+func init() {
+	var ok bool
+	uint128Max, ok = new(big.Int).SetString("ffffffffffffffffffffffffffffffff", 16)
+	if !ok {
+		panic("bad uint128Max")
+	}
+	// Set the maximum base fee on the default config.
+	defaultResourceConfig.MaximumBaseFee = uint128Max
+}
 
+// BuildL1DeveloperGenesis will create a L1 genesis block after creating
+// all of the state required for an Optimism network to function.
 func BuildL1DeveloperGenesis(config *DeployConfig) (*core.Genesis, error) {
 	if config.L2OutputOracleStartingTimestamp != -1 {
 		return nil, errors.New("l2oo starting timestamp must be -1")
@@ -67,6 +94,26 @@ func BuildL1DeveloperGenesis(config *DeployConfig) (*core.Genesis, error) {
 	if err != nil {
 		return nil, err
 	}
+
+	portalABI, err := bindings.OptimismPortalMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+	// Initialize the OptimismPortal without being paused
+	data, err := portalABI.Pack("initialize", false)
+	if err != nil {
+		return nil, fmt.Errorf("cannot abi encode initialize for OptimismPortal: %w", err)
+	}
+	if _, err := upgradeProxy(
+		backend,
+		opts,
+		depsByName["OptimismPortalProxy"].Address,
+		depsByName["OptimismPortal"].Address,
+		data,
+	); err != nil {
+		return nil, fmt.Errorf("cannot upgrade OptimismPortalProxy: %w", err)
+	}
+
 	sysCfgABI, err := bindings.SystemConfigMetaData.GetAbi()
 	if err != nil {
 		return nil, err
@@ -75,14 +122,16 @@ func BuildL1DeveloperGenesis(config *DeployConfig) (*core.Genesis, error) {
 	if gasLimit == 0 {
 		gasLimit = defaultL2GasLimit
 	}
-	data, err := sysCfgABI.Pack(
+
+	data, err = sysCfgABI.Pack(
 		"initialize",
 		config.FinalSystemOwner,
 		uint642Big(config.GasPriceOracleOverhead),
 		uint642Big(config.GasPriceOracleScalar),
 		config.BatchSenderAddress.Hash(),
 		gasLimit,
 		config.P2PSequencerAddress,
+		defaultResourceConfig,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("cannot abi encode initialize for SystemConfig: %w", err)
@@ -94,7 +143,7 @@ func BuildL1DeveloperGenesis(config *DeployConfig) (*core.Genesis, error) {
 		depsByName["SystemConfig"].Address,
 		data,
 	); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("cannot upgrade SystemConfigProxy: %w", err)
 	}
 
 	l2ooABI, err := bindings.L2OutputOracleMetaData.GetAbi()
@@ -119,24 +168,6 @@ func BuildL1DeveloperGenesis(config *DeployConfig) (*core.Genesis, error) {
 		return nil, err
 	}
 
-	portalABI, err := bindings.OptimismPortalMetaData.GetAbi()
-	if err != nil {
-		return nil, err
-	}
-	// Initialize the OptimismPortal without being paused
-	data, err = portalABI.Pack("initialize", false)
-	if err != nil {
-		return nil, fmt.Errorf("cannot abi encode initialize for OptimismPortal: %w", err)
-	}
-	if _, err := upgradeProxy(
-		backend,
-		opts,
-		depsByName["OptimismPortalProxy"].Address,
-		depsByName["OptimismPortal"].Address,
-		data,
-	); err != nil {
-		return nil, err
-	}
 	l1XDMABI, err := bindings.L1CrossDomainMessengerMetaData.GetAbi()
 	if err != nil {
 		return nil, err
@@ -264,6 +295,7 @@ func deployL1Contracts(config *DeployConfig, backend *backends.SimulatedBackend)
 	if gasLimit == 0 {
 		gasLimit = defaultL2GasLimit
 	}
+
 	constructors = append(constructors, []deployer.Constructor{
 		{
 			Name: "SystemConfig",
@@ -274,6 +306,7 @@ func deployL1Contracts(config *DeployConfig, backend *backends.SimulatedBackend)
 				config.BatchSenderAddress.Hash(), // left-padded 32 bytes value, version is zero anyway
 				gasLimit,
 				config.P2PSequencerAddress,
+				defaultResourceConfig,
 			},
 		},
 		{
@@ -297,6 +330,7 @@ func deployL1Contracts(config *DeployConfig, backend *backends.SimulatedBackend)
 				predeploys.DevL2OutputOracleAddr,
 				config.PortalGuardian,
 				true, // _paused
+				predeploys.DevSystemConfigAddr,
 			},
 		},
 		{
@@ -342,6 +376,7 @@ func l1Deployer(backend *backends.SimulatedBackend, opts *bind.TransactOpts, dep
 			deployment.Args[3].(common.Hash),
 			deployment.Args[4].(uint64),
 			deployment.Args[5].(common.Address),
+			deployment.Args[6].(bindings.ResourceMeteringResourceConfig),
 		)
 	case "L2OutputOracle":
 		_, tx, _, err = bindings.DeployL2OutputOracle(
@@ -362,6 +397,7 @@ func l1Deployer(backend *backends.SimulatedBackend, opts *bind.TransactOpts, dep
 			deployment.Args[0].(common.Address),
 			deployment.Args[1].(common.Address),
 			deployment.Args[2].(bool),
+			deployment.Args[3].(common.Address),
 		)
 	case "L1CrossDomainMessenger":
 		_, tx, _, err = bindings.DeployL1CrossDomainMessenger(
@@ -421,6 +457,15 @@ func l1Deployer(backend *backends.SimulatedBackend, opts *bind.TransactOpts, dep
 
 func upgradeProxy(backend *backends.SimulatedBackend, opts *bind.TransactOpts, proxyAddr common.Address, implAddr common.Address, callData []byte) (*types.Transaction, error) {
 	var tx *types.Transaction
+
+	code, err := backend.CodeAt(context.Background(), implAddr, nil)
+	if err != nil {
+		return nil, err
+	}
+	if len(code) == 0 {
+		return nil, fmt.Errorf("no code at %s", implAddr)
+	}
+
 	proxy, err := bindings.NewProxy(proxyAddr, backend)
 	if err != nil {
 		return nil, err

op-chain-ops/genesis/layer_one_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
@@ -100,6 +101,30 @@ func TestBuildL1DeveloperGenesis(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, "Wrapped Ether", name)
 
+	sysCfg, err := bindings.NewSystemConfig(predeploys.DevSystemConfigAddr, sim)
+	require.NoError(t, err)
+	cfg, err := sysCfg.ResourceConfig(&bind.CallOpts{})
+	require.NoError(t, err)
+	require.Equal(t, cfg, defaultResourceConfig)
+	owner, err = sysCfg.Owner(&bind.CallOpts{})
+	require.NoError(t, err)
+	require.Equal(t, owner, config.FinalSystemOwner)
+	overhead, err := sysCfg.Overhead(&bind.CallOpts{})
+	require.NoError(t, err)
+	require.Equal(t, overhead.Uint64(), config.GasPriceOracleOverhead)
+	scalar, err := sysCfg.Scalar(&bind.CallOpts{})
+	require.NoError(t, err)
+	require.Equal(t, scalar.Uint64(), config.GasPriceOracleScalar)
+	batcherHash, err := sysCfg.BatcherHash(&bind.CallOpts{})
+	require.NoError(t, err)
+	require.Equal(t, common.Hash(batcherHash), config.BatchSenderAddress.Hash())
+	gasLimit, err := sysCfg.GasLimit(&bind.CallOpts{})
+	require.NoError(t, err)
+	require.Equal(t, gasLimit, uint64(config.L2GenesisBlockGasLimit))
+	unsafeBlockSigner, err := sysCfg.UnsafeBlockSigner(&bind.CallOpts{})
+	require.NoError(t, err)
+	require.Equal(t, unsafeBlockSigner, config.P2PSequencerAddress)
+
 	// test that we can do deposits, etc.
 	priv, err := crypto.HexToECDSA("ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80")
 	require.NoError(t, err)

op-chain-ops/genesis/testdata/test-deploy-config-full.json

@@ -16,7 +16,7 @@
   "l1BlockTime": 15,
   "l1GenesisBlockNonce": "0x0",
   "cliqueSignerAddress": "0x0000000000000000000000000000000000000000",
-  "l1GenesisBlockGasLimit": "0xe4e1c0",
+  "l1GenesisBlockGasLimit": "0x1c9c380",
   "l1GenesisBlockDifficulty": "0x1",
   "finalSystemOwner": "0x0000000000000000000000000000000000000111",
   "portalGuardian": "0x0000000000000000000000000000000000000112",
@@ -29,7 +29,7 @@
   "l1GenesisBlockTimestamp": "0x0",
   "l1GenesisBlockBaseFeePerGas": "0x3b9aca00",
   "l2GenesisBlockNonce": "0x0",
-  "l2GenesisBlockGasLimit": "0xe4e1c0",
+  "l2GenesisBlockGasLimit": "0x1c9c380",
   "l2GenesisBlockDifficulty": "0x1",
   "l2GenesisBlockMixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
   "l2GenesisBlockNumber": "0x0",

op-e2e/e2eutils/setup.go

@@ -79,7 +79,7 @@ func MakeDeployParams(t require.TestingT, tp *TestParams) *DeployParams {
 		L1GenesisBlockNonce:         0,
 		CliqueSignerAddress:         common.Address{}, // proof of stake, no clique
 		L1GenesisBlockTimestamp:     hexutil.Uint64(time.Now().Unix()),
-		L1GenesisBlockGasLimit:      15_000_000,
+		L1GenesisBlockGasLimit:      30_000_000,
 		L1GenesisBlockDifficulty:    uint64ToBig(1),
 		L1GenesisBlockMixHash:       common.Hash{},
 		L1GenesisBlockCoinbase:      common.Address{},
@@ -90,7 +90,7 @@ func MakeDeployParams(t require.TestingT, tp *TestParams) *DeployParams {
 		FinalizationPeriodSeconds:   12,
 
 		L2GenesisBlockNonce:         0,
-		L2GenesisBlockGasLimit:      15_000_000,
+		L2GenesisBlockGasLimit:      30_000_000,
 		L2GenesisBlockDifficulty:    uint64ToBig(0),
 		L2GenesisBlockMixHash:       common.Hash{},
 		L2GenesisBlockNumber:        0,

op-e2e/setup.go

@@ -75,7 +75,7 @@ func DefaultSystemConfig(t *testing.T) SystemConfig {
 		L1GenesisBlockNonce:         4660,
 		CliqueSignerAddress:         addresses.CliqueSigner,
 		L1GenesisBlockTimestamp:     hexutil.Uint64(time.Now().Unix()),
-		L1GenesisBlockGasLimit:      8_000_000,
+		L1GenesisBlockGasLimit:      30_000_000,
 		L1GenesisBlockDifficulty:    uint642big(1),
 		L1GenesisBlockMixHash:       common.Hash{},
 		L1GenesisBlockCoinbase:      common.Address{},
@@ -85,7 +85,7 @@ func DefaultSystemConfig(t *testing.T) SystemConfig {
 		L1GenesisBlockBaseFeePerGas: uint642big(7),
 
 		L2GenesisBlockNonce:         0,
-		L2GenesisBlockGasLimit:      8_000_000,
+		L2GenesisBlockGasLimit:      30_000_000,
 		L2GenesisBlockDifficulty:    uint642big(1),
 		L2GenesisBlockMixHash:       common.Hash{},
 		L2GenesisBlockNumber:        0,