feat: implement governance token minting and distribution (#333)

* feat(contracts): implement governance token minting and distribution

* test(e2e): mint in e2e setup and add enable governance token bridge test

* ci(e2e): enable parallel

* chore(contracts): add GovernanceTokenProxy deployments of Kroma and KromaSepolia

* fix(hardhat-deploy-config): correct env variable and companion networks

* feat: deploy `GovernanceTokenProxy` using `CREATE2` to use deterministic address

* feat: apply PR reviews

* feat(contracts): disable initialize in `GovernanceToken` constructor

.github/workflows/test.yml

@@ -60,6 +60,5 @@ jobs:
 
       - name: Run tests
         env:
-          OP_E2E_DISABLE_PARALLEL: true
-          OP_E2E_USE_CANYON: true
+          OP_E2E_DISABLE_PARALLEL: false
         run: make test

Makefile

@@ -30,7 +30,7 @@ test:
 	go test ./kroma-bindings/...
 	go test ./kroma-chain-ops/...
 	go test ./kroma-validator/...
-	go test ./op-e2e/... -timeout 30m # requires a minimum of 30min in a CI
+	go test ./op-e2e/... -timeout 30m # a maximum of 30min in a CI
 	pnpm test
 .PHONY: test
 

kroma-bindings/artifacts.json

@@ -20,6 +20,7 @@
   "L2OutputOracle",
   "L2StandardBridge",
   "L2ToL1MessagePasser",
+  "MintManager",
   "ProtocolVault",
   "Proxy",
   "ProxyAdmin",

kroma-bindings/predeploys/addresses.go

@@ -20,7 +20,6 @@ const (
 	L2ERC721Bridge               = "0x420000000000000000000000000000000000000A"
 	KromaMintableERC20Factory    = "0x420000000000000000000000000000000000000B"
 	KromaMintableERC721Factory   = "0x420000000000000000000000000000000000000C"
-	GovernanceToken              = "0x42000000000000000000000000000000000000FF"
 	Create2Deployer              = "0x13b0D85CcB8bf860b6b79AF3029fCA081AE9beF2"
 	MultiCall3                   = "0xcA11bde05977b3631167028862bE2a173976CA11"
 	Safe_v130                    = "0x69f4D1788e39c87893C980c06EdF4b7f686e2938"
@@ -45,7 +44,6 @@ var (
 	L1FeeVaultAddr                   = common.HexToAddress(L1FeeVault)
 	ValidatorRewardVaultAddr         = common.HexToAddress(ValidatorRewardVault)
 	L2StandardBridgeAddr             = common.HexToAddress(L2StandardBridge)
-	GovernanceTokenAddr              = common.HexToAddress(GovernanceToken)
 	L2ERC721BridgeAddr               = common.HexToAddress(L2ERC721Bridge)
 	KromaMintableERC20FactoryAddr    = common.HexToAddress(KromaMintableERC20Factory)
 	KromaMintableERC721FactoryAddr   = common.HexToAddress(KromaMintableERC721Factory)
@@ -89,15 +87,15 @@ func init() {
 	Predeploys["L1FeeVault"] = &oppredeploys.Predeploy{Address: L1FeeVaultAddr}
 	Predeploys["ValidatorRewardVault"] = &oppredeploys.Predeploy{Address: ValidatorRewardVaultAddr}
 	Predeploys["L2StandardBridge"] = &oppredeploys.Predeploy{Address: L2StandardBridgeAddr}
+	/* [Kroma: START]
 	Predeploys["GovernanceToken"] = &oppredeploys.Predeploy{
 		Address: GovernanceTokenAddr,
-		/* [Kroma: START]
 		ProxyDisabled: true,
-		*/
 		Enabled: func(config oppredeploys.DeployConfig) bool {
 			return config.GovernanceEnabled()
 		},
 	}
+	*/
 	Predeploys["L2ERC721Bridge"] = &oppredeploys.Predeploy{Address: L2ERC721BridgeAddr}
 	Predeploys["KromaMintableERC20Factory"] = &oppredeploys.Predeploy{Address: KromaMintableERC20FactoryAddr}
 	Predeploys["KromaMintableERC721Factory"] = &oppredeploys.Predeploy{Address: KromaMintableERC721FactoryAddr}

kroma-chain-ops/genesis/config.go

@@ -11,16 +11,16 @@ import (
 	"reflect"
 	"strings"
 
+	"github.com/ethereum-optimism/optimism/op-chain-ops/state"
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	gstate "github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
 
-	"github.com/ethereum-optimism/optimism/op-chain-ops/state"
-	"github.com/ethereum-optimism/optimism/op-node/rollup"
-	"github.com/ethereum-optimism/optimism/op-service/eth"
 	"github.com/kroma-network/kroma/kroma-bindings/predeploys"
 	"github.com/kroma-network/kroma/kroma-chain-ops/immutables"
 )
@@ -155,13 +155,31 @@ type DeployConfig struct {
 	GasPriceOracleScalar uint64 `json:"gasPriceOracleScalar"`
 	// EnableGovernance configures whether or not include governance token predeploy.
 	EnableGovernance bool `json:"enableGovernance"`
+	/* [Kroma: START]
 	// GovernanceTokenSymbol represents the  ERC20 symbol of the GovernanceToken.
 	GovernanceTokenSymbol string `json:"governanceTokenSymbol"`
 	// GovernanceTokenName represents the ERC20 name of the GovernanceToken
 	GovernanceTokenName string `json:"governanceTokenName"`
 	// GovernanceTokenOwner represents the owner of the GovernanceToken. Has the ability
 	// to mint and burn tokens.
 	GovernanceTokenOwner common.Address `json:"governanceTokenOwner"`
+	[Kroma: END] */
+	// [Kroma: START]
+	// GovernanceTokenAddress represents GovernanceToken address on L2.
+	GovernanceTokenAddress common.Address `json:"governanceTokenAddress,omitempty"`
+	// GovernanceTokenProxySalt is used to determine GovernanceTokenProxy address on L1 and L2.
+	GovernanceTokenProxySalt common.Hash `json:"governanceTokenProxySalt"`
+	// MintManagerOwner represents the owner of the MintManager on L1 and L2. Has the ability to mint initially.
+	MintManagerOwner common.Address `json:"mintManagerOwner"`
+	// L1MintManagerRecipients is an array of recipient addresses to receive the minted governance tokens on L1.
+	L1MintManagerRecipients []common.Address `json:"l1MintManagerRecipients"`
+	// L1MintManagerShares is an array of each recipient's share of total minted tokens on L1.
+	L1MintManagerShares []uint64 `json:"l1MintManagerShares"`
+	// L2MintManagerRecipients is an array of recipient addresses to receive the minted governance tokens on L2.
+	L2MintManagerRecipients []common.Address `json:"l2MintManagerRecipients"`
+	// L2MintManagerShares is an array of each recipient's share of total minted tokens on L2.
+	L2MintManagerShares []uint64 `json:"l2MintManagerShares"`
+	// [Kroma: END]
 	// DeploymentWaitConfirmations is the number of confirmations to wait during
 	// deployment. This is DEPRECATED and should be removed in a future PR.
 	DeploymentWaitConfirmations int `json:"deploymentWaitConfirmations"`
@@ -283,9 +301,6 @@ type DeployConfig struct {
 	ZKVerifierHashScalar *hexutil.Big `json:"zkVerifierHashScalar"`
 	ZKVerifierM56Px      *hexutil.Big `json:"zkVerifierM56Px"`
 	ZKVerifierM56Py      *hexutil.Big `json:"zkVerifierM56Py"`
-
-	// L1GovernanceTokenProxy represents the address of the L1GovernanceTokenProxy on L1.
-	L1GovernanceTokenProxy common.Address `json:"l1GovernanceTokenProxy"`
 	// [Kroma: END]
 }
 
@@ -381,16 +396,33 @@ func (d *DeployConfig) Check() error {
 		return fmt.Errorf("%w: L2 genesis block base fee per gas cannot be nil", ErrInvalidDeployConfig)
 	}
 	if d.EnableGovernance {
+		/* [Kroma: START]
 		if d.GovernanceTokenName == "" {
 			return fmt.Errorf("%w: GovernanceToken.name cannot be empty", ErrInvalidDeployConfig)
 		}
 		if d.GovernanceTokenSymbol == "" {
 			return fmt.Errorf("%w: GovernanceToken.symbol cannot be empty", ErrInvalidDeployConfig)
 		}
+		if d.GovernanceTokenOwner == (common.Address{}) {
+			return fmt.Errorf("%w: GovernanceToken owner cannot be address(0)", ErrInvalidDeployConfig)
+		}
+		[Kroma: END] */
 		// [Kroma: START]
-		// if d.GovernanceTokenOwner == (common.Address{}) {
-		// 	return fmt.Errorf("%w: GovernanceToken owner cannot be address(0)", ErrInvalidDeployConfig)
-		// }
+		if d.MintManagerOwner == (common.Address{}) {
+			return fmt.Errorf("%w: MintManagerOwner cannot be address(0)", ErrInvalidDeployConfig)
+		}
+		if len(d.L1MintManagerRecipients) == 0 {
+			return fmt.Errorf("%w: L1MintManagerRecipients array cannot be empty", ErrInvalidDeployConfig)
+		}
+		if len(d.L1MintManagerRecipients) != len(d.L1MintManagerShares) {
+			return fmt.Errorf("%w: L1MintManagerRecipients and L1MintManagerShares must be the same length", ErrInvalidDeployConfig)
+		}
+		if len(d.L2MintManagerRecipients) == 0 {
+			return fmt.Errorf("%w: L2MintManagerRecipients array cannot be empty", ErrInvalidDeployConfig)
+		}
+		if len(d.L2MintManagerRecipients) != len(d.L2MintManagerShares) {
+			return fmt.Errorf("%w: L2MintManagerRecipients and L2MintManagerShares must be the same length", ErrInvalidDeployConfig)
+		}
 		// [Kroma: END]
 	}
 	// L2 block time must always be smaller than L1 block time
@@ -532,12 +564,6 @@ func (d *DeployConfig) CheckAddresses() error {
 	if d.KromaPortalProxy == (common.Address{}) {
 		return fmt.Errorf("%w: KromaPortalProxy cannot be address(0)", ErrInvalidDeployConfig)
 	}
-
-	// [Kroma: START]
-	if d.L1GovernanceTokenProxy == (common.Address{}) {
-		return fmt.Errorf("%w: L1GovernanceTokenProxy cannot be address(0)", ErrInvalidDeployConfig)
-	}
-	// [Kroma: END]
 	return nil
 }
 
@@ -551,7 +577,6 @@ func (d *DeployConfig) SetDeployments(deployments *L1Deployments) {
 
 	// [Kroma: START]
 	d.ValidatorPoolProxy = deployments.ValidatorPoolProxy
-	d.L1GovernanceTokenProxy = deployments.L1GovernanceTokenProxy
 	// [Kroma: END]
 }
 
@@ -734,7 +759,6 @@ type L1Deployments struct {
 	// [Kroma: START]
 	Colosseum                 common.Address `json:"Colosseum"`
 	ColosseumProxy            common.Address `json:"ColosseumProxy"`
-	L1GovernanceToken         common.Address `json:"L1GovernanceToken"`
 	L1GovernanceTokenProxy    common.Address `json:"L1GovernanceTokenProxy"`
 	Poseidon2                 common.Address `json:"Poseidon2"`
 	SecurityCouncil           common.Address `json:"SecurityCouncil"`
@@ -786,6 +810,12 @@ func (d *L1Deployments) Check(deployConfig *DeployConfig) error {
 				name == "DataAvailabilityChallengeProxy") {
 			continue
 		}
+		// [Kroma: START]
+		// Skip contract that will be deployed later in setup
+		if name == "L1GovernanceTokenProxy" {
+			continue
+		}
+		// [Kroma: END]
 		if val.Field(i).Interface().(common.Address) == (common.Address{}) {
 			return fmt.Errorf("%s is not set", name)
 		}
@@ -942,17 +972,9 @@ func NewL2ImmutableConfig(config *DeployConfig, block *types.Block) (*immutables
 		GasPriceOracle: struct{}{},
 		L1Block:        struct{}{},
 		/* [Kroma: START]
+		GovernanceToken: struct{}{},
 		LegacyMessagePasser: struct{}{},
-		[Kroma: END] */
-		// [Kroma: START]
-		GovernanceToken: struct {
-			Bridge      common.Address
-			RemoteToken common.Address
-		}{
-			Bridge:      predeploys.L2StandardBridgeAddr,
-			RemoteToken: config.L1GovernanceTokenProxy,
-		},
-		// [Kroma: END]
+		[Kroma: END]*/
 		L2ERC721Bridge: struct {
 			OtherBridge common.Address
 			Messenger   common.Address
@@ -973,6 +995,7 @@ func NewL2ImmutableConfig(config *DeployConfig, block *types.Block) (*immutables
 			Bridge: predeploys.L2StandardBridgeAddr,
 		},
 		ProxyAdmin: struct{}{},
+		// [Kroma: START]
 		ProtocolVault: struct {
 			Recipient common.Address
 		}{
@@ -1062,13 +1085,15 @@ func NewL2StorageConfig(config *DeployConfig, block *types.Block) (state.Storage
 		"symbol":   "WETH",
 		"decimals": 18,
 	}
+	/* [Kroma: START]
 	if config.EnableGovernance {
 		storage["GovernanceToken"] = state.StorageValues{
 			"_name":   config.GovernanceTokenName,
 			"_symbol": config.GovernanceTokenSymbol,
-			// "_owner":  config.GovernanceTokenOwner,
+			"_owner":  config.GovernanceTokenOwner,
 		}
 	}
+	[Kroma: END] */
 	storage["ProxyAdmin"] = state.StorageValues{
 		"_owner": config.ProxyAdminOwner,
 	}