feat: introduce fee splitter for revenue share

.circleci/config.yml

@@ -562,7 +562,7 @@ jobs:
   contracts-bedrock-build:
     docker:
       - image: <<pipeline.parameters.default_docker_image>>
-    resource_class: xlarge
+    resource_class: 2xlarge
     parameters:
       build_args:
         description: Forge build arguments
@@ -862,7 +862,7 @@ jobs:
     circleci_ip_ranges: true
     docker:
       - image: <<pipeline.parameters.default_docker_image>>
-    resource_class: xlarge
+    resource_class: 2xlarge
     parameters:
       test_list:
         description: List of test files to run

.gitignore

@@ -50,4 +50,4 @@ __pycache__
 crytic-export
 
 # ignore local asdf config
-.tool-versions
+.tool-versions

.semgrep/rules/sol-rules.yaml

@@ -194,6 +194,7 @@ rules:
     paths:
       exclude:
         - packages/contracts-bedrock/src/legacy/L1ChugSplashProxy.sol
+        - packages/contracts-bedrock/test/invariants/FeeSplit.t.sol
 
   - id: sol-style-enforce-require-msg
     languages: [solidity]

devnet-sdk/contracts/constants/constants.go

@@ -22,13 +22,15 @@ var (
 	ProxyAdmin                    types.Address = common.HexToAddress("0x4200000000000000000000000000000000000018")
 	BaseFeeVault                  types.Address = common.HexToAddress("0x4200000000000000000000000000000000000019")
 	L1FeeVault                    types.Address = common.HexToAddress("0x420000000000000000000000000000000000001a")
+	OperatorFeeVault              types.Address = common.HexToAddress("0x420000000000000000000000000000000000001B")
 	SchemaRegistry                types.Address = common.HexToAddress("0x4200000000000000000000000000000000000020")
 	EAS                           types.Address = common.HexToAddress("0x4200000000000000000000000000000000000021")
 	CrossL2Inbox                  types.Address = common.HexToAddress("0x4200000000000000000000000000000000000022")
 	L2ToL2CrossDomainMessenger    types.Address = common.HexToAddress("0x4200000000000000000000000000000000000023")
 	SuperchainETHBridge           types.Address = common.HexToAddress("0x4200000000000000000000000000000000000024")
 	ETHLiquidity                  types.Address = common.HexToAddress("0x4200000000000000000000000000000000000025")
 	SuperchainTokenBridge         types.Address = common.HexToAddress("0x4200000000000000000000000000000000000028")
+	FeeSplitter                   types.Address = common.HexToAddress("0x420000000000000000000000000000000000002B")
 	GovernanceToken               types.Address = common.HexToAddress("0x4200000000000000000000000000000000000042")
 	Create2Deployer               types.Address = common.HexToAddress("0x13b0D85CcB8bf860b6b79AF3029fCA081AE9beF2")
 	MultiCall3                    types.Address = common.HexToAddress("0xcA11bde05977b3631167028862bE2a173976CA11")

op-chain-ops/devkeys/devkeys.go

@@ -158,6 +158,10 @@ const (
 	SequencerFeeVaultRecipientRole ChainOperatorRole = 9
 	// SystemConfigOwner is the key that can make SystemConfig changes.
 	SystemConfigOwner ChainOperatorRole = 10
+	// OperatorFeeVaultRecipientRole is the key that receives from the OperatorFeeVault predeploy
+	OperatorFeeVaultRecipientRole ChainOperatorRole = 11
+	// ChainFeesRecipientRole is the key that receives the chain's share from the FeeSplitter
+	ChainFeesRecipientRole ChainOperatorRole = 12
 )
 
 func (role ChainOperatorRole) String() string {
@@ -182,8 +186,12 @@ func (role ChainOperatorRole) String() string {
 		return "l1-fee-vault-recipient"
 	case SequencerFeeVaultRecipientRole:
 		return "sequencer-fee-vault-recipient"
+	case OperatorFeeVaultRecipientRole:
+		return "operator-fee-vault-recipient"
 	case SystemConfigOwner:
 		return "system-config-owner"
+	case ChainFeesRecipientRole:
+		return "chain-fees-recipient"
 	default:
 		return fmt.Sprintf("unknown-operator-%d", uint64(role))
 	}

op-chain-ops/genesis/config.go

@@ -86,6 +86,22 @@ type DevDeployConfig struct {
 	FundDevAccounts bool `json:"fundDevAccounts"`
 }
 
+type RevenueShareDeployConfig struct {
+	UseRevenueShare    bool           `json:"useRevenueShare"`
+	ChainFeesRecipient common.Address `json:"chainFeesRecipient"`
+}
+
+var _ ConfigChecker = (*RevenueShareDeployConfig)(nil)
+
+func (d *RevenueShareDeployConfig) Check(log log.Logger) error {
+	if d.UseRevenueShare {
+		if d.ChainFeesRecipient == (common.Address{}) {
+			return fmt.Errorf("%w: ChainFeesRecipient cannot be address(0)", ErrInvalidDeployConfig)
+		}
+	}
+	return nil
+}
+
 type L2GenesisBlockDeployConfig struct {
 	L2GenesisBlockNonce         hexutil.Uint64 `json:"l2GenesisBlockNonce"`
 	L2GenesisBlockGasLimit      hexutil.Uint64 `json:"l2GenesisBlockGasLimit"`
@@ -150,18 +166,24 @@ type L2VaultsDeployConfig struct {
 	// SequencerFeeVaultRecipient represents the recipient of fees accumulated in the SequencerFeeVault.
 	// Can be an account on L1 or L2, depending on the SequencerFeeVaultWithdrawalNetwork value.
 	SequencerFeeVaultRecipient common.Address `json:"sequencerFeeVaultRecipient"`
+	// OperatorFeeVaultRecipient represents the recipient of fees accumulated in the OperatorFeeVault.
+	OperatorFeeVaultRecipient common.Address `json:"operatorFeeVaultRecipient"`
 	// BaseFeeVaultMinimumWithdrawalAmount represents the minimum withdrawal amount for the BaseFeeVault.
 	BaseFeeVaultMinimumWithdrawalAmount *hexutil.Big `json:"baseFeeVaultMinimumWithdrawalAmount"`
 	// L1FeeVaultMinimumWithdrawalAmount represents the minimum withdrawal amount for the L1FeeVault.
 	L1FeeVaultMinimumWithdrawalAmount *hexutil.Big `json:"l1FeeVaultMinimumWithdrawalAmount"`
 	// SequencerFeeVaultMinimumWithdrawalAmount represents the minimum withdrawal amount for the SequencerFeeVault.
 	SequencerFeeVaultMinimumWithdrawalAmount *hexutil.Big `json:"sequencerFeeVaultMinimumWithdrawalAmount"`
+	// OperatorFeeVaultMinimumWithdrawalAmount represents the minimum withdrawal amount for the OperatorFeeVault.
+	OperatorFeeVaultMinimumWithdrawalAmount *hexutil.Big `json:"operatorFeeVaultMinimumWithdrawalAmount"`
 	// BaseFeeVaultWithdrawalNetwork represents the withdrawal network for the BaseFeeVault.
 	BaseFeeVaultWithdrawalNetwork WithdrawalNetwork `json:"baseFeeVaultWithdrawalNetwork"`
 	// L1FeeVaultWithdrawalNetwork represents the withdrawal network for the L1FeeVault.
 	L1FeeVaultWithdrawalNetwork WithdrawalNetwork `json:"l1FeeVaultWithdrawalNetwork"`
 	// SequencerFeeVaultWithdrawalNetwork represents the withdrawal network for the SequencerFeeVault.
 	SequencerFeeVaultWithdrawalNetwork WithdrawalNetwork `json:"sequencerFeeVaultWithdrawalNetwork"`
+	// OperatorFeeVaultWithdrawalNetwork represents the withdrawal network for the OperatorFeeVault.
+	OperatorFeeVaultWithdrawalNetwork WithdrawalNetwork `json:"operatorFeeVaultWithdrawalNetwork"`
 }
 
 var _ ConfigChecker = (*L2VaultsDeployConfig)(nil)
@@ -176,6 +198,9 @@ func (d *L2VaultsDeployConfig) Check(log log.Logger) error {
 	if d.SequencerFeeVaultRecipient == (common.Address{}) {
 		return fmt.Errorf("%w: SequencerFeeVaultRecipient cannot be address(0)", ErrInvalidDeployConfig)
 	}
+	if d.OperatorFeeVaultRecipient == (common.Address{}) {
+		return fmt.Errorf("%w: OperatorFeeVaultRecipient cannot be address(0)", ErrInvalidDeployConfig)
+	}
 	if !d.BaseFeeVaultWithdrawalNetwork.Valid() {
 		return fmt.Errorf("%w: BaseFeeVaultWithdrawalNetwork can only be 0 (L1) or 1 (L2)", ErrInvalidDeployConfig)
 	}
@@ -185,6 +210,9 @@ func (d *L2VaultsDeployConfig) Check(log log.Logger) error {
 	if !d.SequencerFeeVaultWithdrawalNetwork.Valid() {
 		return fmt.Errorf("%w: SequencerFeeVaultWithdrawalNetwork can only be 0 (L1) or 1 (L2)", ErrInvalidDeployConfig)
 	}
+	if !d.OperatorFeeVaultWithdrawalNetwork.Valid() {
+		return fmt.Errorf("%w: OperatorFeeVaultWithdrawalNetwork can only be 0 (L1) or 1 (L2)", ErrInvalidDeployConfig)
+	}
 	return nil
 }
 
@@ -743,6 +771,7 @@ type L2InitializationConfig struct {
 	L2CoreDeployConfig
 	FeeMarketConfig
 	AltDADeployConfig
+	RevenueShareDeployConfig
 }
 
 func (d *L2InitializationConfig) Check(log log.Logger) error {

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

@@ -40,12 +40,15 @@
   "baseFeeVaultRecipient": "0x42000000000000000000000000000000000000f5",
   "l1FeeVaultRecipient": "0x42000000000000000000000000000000000000f6",
   "sequencerFeeVaultRecipient": "0x42000000000000000000000000000000000000f7",
+  "operatorFeeVaultRecipient": "0x4200000000000000000000000000000000000063",
   "baseFeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000",
   "l1FeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000",
   "sequencerFeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000",
+  "operatorFeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000",
   "baseFeeVaultWithdrawalNetwork": 0,
   "l1FeeVaultWithdrawalNetwork": 1,
   "sequencerFeeVaultWithdrawalNetwork": 1,
+  "operatorFeeVaultWithdrawalNetwork": 1,
   "l1StandardBridgeProxy": "0x42000000000000000000000000000000000000f8",
   "l1CrossDomainMessengerProxy": "0x42000000000000000000000000000000000000f9",
   "l1ERC721BridgeProxy": "0x4200000000000000000000000000000000000060",
@@ -94,5 +97,7 @@
   "daChallengeProxy": "0x0000000000000000000000000000000000000000",
   "daChallengeWindow": 0,
   "daResolveWindow": 0,
-  "daResolverRefundPercentage": 0
+  "daResolverRefundPercentage": 0,
+  "useRevenueShare": true,
+  "chainFeesRecipient": "0x0000000000000000000000000000000000000444"
 }

op-chain-ops/genesis/withdrawal_network_test.go

@@ -83,18 +83,21 @@ func TestWithdrawalNetworkInlineJSON(t *testing.T) {
 		BaseFeeVaultWithdrawalNetwork      WithdrawalNetwork `json:"baseFeeVaultWithdrawalNetwork"`
 		L1FeeVaultWithdrawalNetwork        WithdrawalNetwork `json:"l1FeeVaultWithdrawalNetwork"`
 		SequencerFeeVaultWithdrawalNetwork WithdrawalNetwork `json:"sequencerFeeVaultWithdrawalNetwork"`
+		OperatorFeeVaultWithdrawalNetwork  WithdrawalNetwork `json:"operatorFeeVaultWithdrawalNetwork"`
 	}
 
 	jsonString := `{
 		"baseFeeVaultWithdrawalNetwork": "remote",
 		"l1FeeVaultWithdrawalNetwork": "local",
-		"sequencerFeeVaultWithdrawalNetwork": "local"
+		"sequencerFeeVaultWithdrawalNetwork": "local",
+		"operatorFeeVaultWithdrawalNetwork": "local"
 	}`
 
 	intJsonString := `{
 		"baseFeeVaultWithdrawalNetwork": 0,
 		"l1FeeVaultWithdrawalNetwork": 1,
-		"sequencerFeeVaultWithdrawalNetwork": 1
+		"sequencerFeeVaultWithdrawalNetwork": 1,
+		"operatorFeeVaultWithdrawalNetwork": 1
 	}`
 
 	t.Run("StringMarshaling", func(t *testing.T) {
@@ -104,6 +107,7 @@ func TestWithdrawalNetworkInlineJSON(t *testing.T) {
 		require.Equal(t, WithdrawalNetwork("remote"), decoded.BaseFeeVaultWithdrawalNetwork)
 		require.Equal(t, WithdrawalNetwork("local"), decoded.L1FeeVaultWithdrawalNetwork)
 		require.Equal(t, WithdrawalNetwork("local"), decoded.SequencerFeeVaultWithdrawalNetwork)
+		require.Equal(t, WithdrawalNetwork("local"), decoded.OperatorFeeVaultWithdrawalNetwork)
 
 		encoded, err := json.Marshal(decoded)
 		require.NoError(t, err)
@@ -118,6 +122,7 @@ func TestWithdrawalNetworkInlineJSON(t *testing.T) {
 		require.Equal(t, WithdrawalNetwork("remote"), decoded.BaseFeeVaultWithdrawalNetwork)
 		require.Equal(t, WithdrawalNetwork("local"), decoded.L1FeeVaultWithdrawalNetwork)
 		require.Equal(t, WithdrawalNetwork("local"), decoded.SequencerFeeVaultWithdrawalNetwork)
+		require.Equal(t, WithdrawalNetwork("local"), decoded.OperatorFeeVaultWithdrawalNetwork)
 
 		encoded, err := json.Marshal(decoded)
 		require.NoError(t, err)

op-chain-ops/interopgen/deploy.go

@@ -21,6 +21,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer"
 	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/manage"
 	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/opcm"
+	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/standard"
 	"github.com/ethereum-optimism/optimism/op-service/eth"
 )
 
@@ -329,11 +330,17 @@ func GenesisL2(l2Host *script.Host, cfg *L2Config, deployment *L2Deployment, mul
 		L1FeeVaultRecipient:                      cfg.L1FeeVaultRecipient,
 		L1FeeVaultMinimumWithdrawalAmount:        cfg.L1FeeVaultMinimumWithdrawalAmount.ToInt(),
 		L1FeeVaultWithdrawalNetwork:              big.NewInt(int64(cfg.L1FeeVaultWithdrawalNetwork.ToUint8())),
+		OperatorFeeVaultRecipient:                cfg.OperatorFeeVaultRecipient,
+		OperatorFeeVaultMinimumWithdrawalAmount:  cfg.OperatorFeeVaultMinimumWithdrawalAmount.ToInt(),
+		OperatorFeeVaultWithdrawalNetwork:        big.NewInt(int64(cfg.OperatorFeeVaultWithdrawalNetwork.ToUint8())),
 		GovernanceTokenOwner:                     cfg.GovernanceTokenOwner,
 		Fork:                                     big.NewInt(cfg.SolidityForkNumber(1)),
 		DeployCrossL2Inbox:                       multichainDepSet,
 		EnableGovernance:                         cfg.EnableGovernance,
 		FundDevAccounts:                          cfg.FundDevAccounts,
+		UseRevenueShare:                          cfg.UseRevenueShare,
+		ChainFeesRecipient:                       cfg.ChainFeesRecipient,
+		L1FeesDepositor:                          standard.L1FeesDepositor,
 	}); err != nil {
 		return fmt.Errorf("failed L2 genesis: %w", err)
 	}

op-chain-ops/interopgen/recipe.go

@@ -186,6 +186,10 @@ func (r *InteropDevL2Recipe) build(l1ChainID uint64, addrs devkeys.Addresses) (*
 	if err != nil {
 		return nil, err
 	}
+	operatorFeeVaultRecipient, err := addrs.Address(chainOps(devkeys.OperatorFeeVaultRecipientRole))
+	if err != nil {
+		return nil, err
+	}
 	sequencerP2P, err := addrs.Address(chainOps(devkeys.SequencerP2PRole))
 	if err != nil {
 		return nil, err
@@ -228,12 +232,15 @@ func (r *InteropDevL2Recipe) build(l1ChainID uint64, addrs devkeys.Addresses) (*
 				BaseFeeVaultRecipient:                    baseFeeVaultRecipient,
 				L1FeeVaultRecipient:                      l1FeeVaultRecipient,
 				SequencerFeeVaultRecipient:               sequencerFeeVaultRecipient,
+				OperatorFeeVaultRecipient:                operatorFeeVaultRecipient,
 				BaseFeeVaultMinimumWithdrawalAmount:      (*hexutil.Big)(Ether(10)),
 				L1FeeVaultMinimumWithdrawalAmount:        (*hexutil.Big)(Ether(10)),
 				SequencerFeeVaultMinimumWithdrawalAmount: (*hexutil.Big)(Ether(10)),
+				OperatorFeeVaultMinimumWithdrawalAmount:  (*hexutil.Big)(Ether(10)),
 				BaseFeeVaultWithdrawalNetwork:            "remote",
 				L1FeeVaultWithdrawalNetwork:              "remote",
 				SequencerFeeVaultWithdrawalNetwork:       "remote",
+				OperatorFeeVaultWithdrawalNetwork:        "remote",
 			},
 			GovernanceDeployConfig: genesis.GovernanceDeployConfig{
 				EnableGovernance: false,
@@ -282,6 +289,10 @@ func (r *InteropDevL2Recipe) build(l1ChainID uint64, addrs devkeys.Addresses) (*
 			AltDADeployConfig: genesis.AltDADeployConfig{
 				UseAltDA: false,
 			},
+			RevenueShareDeployConfig: genesis.RevenueShareDeployConfig{
+				UseRevenueShare:    false,
+				ChainFeesRecipient: common.Address{},
+			},
 		},
 		Prefund:                 make(map[common.Address]*big.Int),
 		SaltMixer:               "",

op-core/predeploys/addresses.go

@@ -31,6 +31,7 @@ const (
 	SuperchainETHBridge           = "0x4200000000000000000000000000000000000024"
 	ETHLiquidity                  = "0x4200000000000000000000000000000000000025"
 	SuperchainTokenBridge         = "0x4200000000000000000000000000000000000028"
+	FeeSplitter                   = "0x420000000000000000000000000000000000002b"
 	Create2Deployer               = "0x13b0D85CcB8bf860b6b79AF3029fCA081AE9beF2"
 	MultiCall3                    = "0xcA11bde05977b3631167028862bE2a173976CA11"
 	Safe_v130                     = "0x69f4D1788e39c87893C980c06EdF4b7f686e2938"
@@ -72,6 +73,7 @@ var (
 	SuperchainETHBridgeAddr           = common.HexToAddress(SuperchainETHBridge)
 	ETHLiquidityAddr                  = common.HexToAddress(ETHLiquidity)
 	SuperchainTokenBridgeAddr         = common.HexToAddress(SuperchainTokenBridge)
+	FeeSplitterAddr                   = common.HexToAddress(FeeSplitter)
 	Create2DeployerAddr               = common.HexToAddress(Create2Deployer)
 	MultiCall3Addr                    = common.HexToAddress(MultiCall3)
 	Safe_v130Addr                     = common.HexToAddress(Safe_v130)
@@ -106,6 +108,7 @@ func init() {
 	Predeploys["SuperchainETHBridge"] = &Predeploy{Address: SuperchainETHBridgeAddr}
 	Predeploys["ETHLiquidity"] = &Predeploy{Address: ETHLiquidityAddr}
 	Predeploys["SuperchainTokenBridge"] = &Predeploy{Address: SuperchainTokenBridgeAddr}
+	Predeploys["FeeSplitter"] = &Predeploy{Address: FeeSplitterAddr}
 	Predeploys["GovernanceToken"] = &Predeploy{
 		Address:       GovernanceTokenAddr,
 		ProxyDisabled: true,

op-deployer/book/src/user-guide/init.md

@@ -44,9 +44,15 @@ l2ContractsLocator = "tag://op-contracts/v1.7.0-beta.1+l2-contracts"
   baseFeeVaultRecipient = "0x0000000000000000000000000000000000000000"
   l1FeeVaultRecipient = "0x0000000000000000000000000000000000000000"
   sequencerFeeVaultRecipient = "0x0000000000000000000000000000000000000000"
+  operatorFeeVaultRecipient = "0x0000000000000000000000000000000000000000"
   eip1559DenominatorCanyon = 250
   eip1559Denominator = 50
   eip1559Elasticity = 6
+
+  # Revenue Sharing Configuration
+  useRevenueShare = true
+  chainFeesRecipient = "0x0000000000000000000000000000000000000000"
+
   [chains.roles]
     l1ProxyAdminOwner = "0x0000000000000000000000000000000000000000"
     l2ProxyAdminOwner = "0x0000000000000000000000000000000000000000"
@@ -60,20 +66,38 @@ l2ContractsLocator = "tag://op-contracts/v1.7.0-beta.1+l2-contracts"
 Before you can use your intent file for a deployment, you will need to update all zero values to whatever is
 appropriate for your chain. For dev environments, it is ok to use all EOAs/hot-wallets.
 
+## Revenue Sharing Configuration
+
+The `useRevenueShare` field controls whether your chain enables the revenue sharing system feature:
+
+- **`useRevenueShare = true`** (default for standard configurations): `FeeVault`s are upgraded and configured to use the `FeeSplitter` contract as the recipient, L2 as withdrawal network and `0` as the minimum withdrawal amount. The split logic is calculated using the `SuperchainRevSharesCalculator` contract. The `L1Withdrawer` contract is set to withdraw the OP portion of fees automatically.
+
+- **`useRevenueShare = false`**: `FeeSplitter` is deployed but initialized with zero address for the `sharesCalculator` field. No deployment is made for the `SuperchainRevSharesCalculator` and `L1Withdrawer` contracts. `FeeVault`s are upgraded but initialized using the custom configuration you provide.
+
+### Configuration Fields
+
+- `useRevenueShare` (optional): Enables or disables the revenue sharing system. Defaults to `true` for standard configurations, `false` for custom.
+- `chainFeesRecipient` (required when `useRevenueShare = true`): Address that receives the chain operator's portion of fee revenue on L2. Must be able to receive ETH.
+
+> **Note**: Since `useRevenueShare` defaults to `true` for standard configurations, you must either provide a `chainFeesRecipient` address OR explicitly set `useRevenueShare = false` to opt out. The deployment will fail validation if revenue sharing is enabled without a recipient.
+
 ## Production Setup
+
 In production environments, you should use a more secure setup with cold-wallet multisigs (e.g. Gnosis Safes) for the following:
-* `baseFeeVaultRecipient`
-* `l1FeeVaultRecipient`
-* `sequencerFeeVaultRecipient`
-* `l1ProxyAdminOwner`
-* `l2ProxyAdminOwner`
-* `systemConfigOwner`
+
+- `baseFeeVaultRecipient`
+- `l1FeeVaultRecipient`
+- `sequencerFeeVaultRecipient`
+- `operatorFeeVaultRecipient`
+- `l1ProxyAdminOwner`
+- `l2ProxyAdminOwner`
+- `systemConfigOwner`
 
 HSMs (hardware security modules) are recommended for the following hot-wallets:
-* `unsafeBlockSigner`
-* `batcher`
-* `proposer`
-* `challenger`
 
+- `unsafeBlockSigner`
+- `batcher`
+- `proposer`
+- `challenger`
 
 [stages]: ../architecture/pipeline.md