L1-chain

.gitmodules

@@ -2,6 +2,6 @@
 	path = tests/tests
 	url = https://github.com/ethereum/tests.git
 	shallow = true
-[submodule "core-contracts"]
-	path = core-contracts
-	url = https://github.com/0xPolygon/core-contracts
+[submodule "blade-contracts"]
+	path = blade-contracts
+	url = https://github.com/Ethernal-Tech/blade-contracts

Makefile

@@ -81,9 +81,9 @@ test-property-polybft: check-go
 	env EDGE_BINARY=${PWD}/artifacts/blade E2E_TESTS=true E2E_LOGS=true go test -v -timeout=30m ./e2e-polybft/property/... \
 	-rapid.checks=10
 
-.PHONY: compile-core-contracts
-compile-core-contracts: check-npm
-	cd core-contracts && npm install && npm run compile
+.PHONY: compile-blade-contracts
+compile-blade-contracts: check-npm
+	cd blade-contracts && npm install && npm run compile
 	$(MAKE) generate-smart-contract-bindings
 
 .PHONY: generate-smart-contract-bindings
@@ -117,7 +117,7 @@ help:
 	@printf "  %-35s - %s\n" "test-e2e" "Run end-to-end tests"
 	@printf "  %-35s - %s\n" "test-e2e-polybft" "Run end-to-end tests for PolyBFT"
 	@printf "  %-35s - %s\n" "test-property-polybft" "Run property tests for PolyBFT"
-	@printf "  %-35s - %s\n" "compile-core-contracts" "Compile core contracts"
+	@printf "  %-35s - %s\n" "compile-blade-contracts" "Compile blade contracts"
 	@printf "  %-35s - %s\n" "generate-smart-contract-bindings" "Generate smart contract bindings"
 	@printf "  %-35s - %s\n" "run-docker" "Run Docker cluster for PolyBFT"
 	@printf "  %-35s - %s\n" "stop-docker" "Stop Docker cluster for PolyBFT"

command/genesis/genesis.go

@@ -60,20 +60,23 @@ func setFlags(cmd *cobra.Command) {
 		),
 	)
 
+	cmd.Flags().StringArrayVar(
+		&params.stake,
+		stakeFlag,
+		[]string{},
+		fmt.Sprintf(
+			"the staked accounts and balances (format: <address>[:<stake>]). Default staked balance: %d",
+			command.DefaultStake,
+		),
+	)
+
 	cmd.Flags().Uint64Var(
 		&params.blockGasLimit,
 		blockGasLimitFlag,
 		command.DefaultGenesisGasLimit,
 		"the maximum amount of gas used by all transactions in a block",
 	)
 
-	cmd.Flags().StringVar(
-		&params.burnContract,
-		burnContractFlag,
-		"",
-		"the burn contract block and address (format: <block>:<address>[:<burn destination>])",
-	)
-
 	cmd.Flags().StringVar(
 		&params.baseFeeConfig,
 		genesisBaseFeeConfigFlag,
@@ -187,7 +190,7 @@ func setFlags(cmd *cobra.Command) {
 			nativeTokenConfigFlag,
 			"",
 			"native token configuration, provided in the following format: "+
-				"<name:symbol:decimals count:mintable flag:[mintable token owner address]>",
+				"<name:symbol:decimals count:mintable token owner address>",
 		)
 
 		cmd.Flags().StringVar(

command/genesis/params.go

@@ -3,6 +3,7 @@ package genesis
 import (
 	"errors"
 	"fmt"
+	"math/big"
 	"os"
 	"time"
 
@@ -18,11 +19,11 @@ const (
 	dirFlag                      = "dir"
 	nameFlag                     = "name"
 	premineFlag                  = "premine"
+	stakeFlag                    = "stake"
 	chainIDFlag                  = "chain-id"
 	epochSizeFlag                = "epoch-size"
 	epochRewardFlag              = "epoch-reward"
 	blockGasLimitFlag            = "block-gas-limit"
-	burnContractFlag             = "burn-contract"
 	genesisBaseFeeConfigFlag     = "base-fee-config"
 	nativeTokenConfigFlag        = "native-token-config"
 	rewardTokenCodeFlag          = "reward-token-code"
@@ -56,14 +57,14 @@ type genesisParams struct {
 	name         string
 	consensusRaw string
 	premine      []string
+	stake        []string
 	bootnodes    []string
 
 	chainID   uint64
 	epochSize uint64
 
 	blockGasLimit uint64
 
-	burnContract        string
 	baseFeeConfig       string
 	parsedBaseFeeConfig *baseFeeInfo
 
@@ -103,6 +104,7 @@ type genesisParams struct {
 	nativeTokenConfig    *polybft.TokenConfig
 
 	premineInfos []*helper.PremineInfo
+	stakeInfos   map[types.Address]*big.Int
 
 	// rewards
 	rewardTokenCode string
@@ -138,7 +140,23 @@ func (p *genesisParams) validateFlags() error {
 	}
 
 	if p.isPolyBFTConsensus() {
-		if err := p.validatePolyBFTParams(); err != nil {
+		if err := p.extractNativeTokenMetadata(); err != nil {
+			return err
+		}
+
+		if err := p.validateRewardWalletAndToken(); err != nil {
+			return err
+		}
+
+		if err := p.validatePremineInfo(); err != nil {
+			return err
+		}
+
+		if err := p.validateProxyContractsAdmin(); err != nil {
+			return err
+		}
+
+		if err := p.parseStakeInfo(); err != nil {
 			return err
 		}
 	}
@@ -182,11 +200,7 @@ func (p *genesisParams) generateGenesis() error {
 }
 
 func (p *genesisParams) initGenesisConfig() error {
-	// Disable london hardfork if burn contract address is not provided
 	enabledForks := chain.AllForksEnabled
-	if !p.isBurnContractEnabled() {
-		enabledForks.RemoveFork(chain.London)
-	}
 
 	chainConfig := &chain.Chain{
 		Name: p.name,
@@ -207,21 +221,8 @@ func (p *genesisParams) initGenesisConfig() error {
 		Bootnodes: p.bootnodes,
 	}
 
-	// burn contract can be set only for non mintable native token
-	if p.isBurnContractEnabled() {
-		chainConfig.Genesis.BaseFee = p.parsedBaseFeeConfig.baseFee
-		chainConfig.Genesis.BaseFeeEM = p.parsedBaseFeeConfig.baseFeeEM
-		chainConfig.Genesis.BaseFeeChangeDenom = p.parsedBaseFeeConfig.baseFeeChangeDenom
-		chainConfig.Params.BurnContract = make(map[uint64]types.Address, 1)
-
-		burnContractInfo, err := parseBurnContractInfo(p.burnContract)
-		if err != nil {
-			return err
-		}
-
-		chainConfig.Params.BurnContract[burnContractInfo.BlockNumber] = burnContractInfo.Address
-		chainConfig.Params.BurnContractDestinationAddress = burnContractInfo.DestinationAddress
-	}
+	chainConfig.Params.BurnContract = make(map[uint64]types.Address, 1)
+	chainConfig.Params.BurnContract[0] = types.ZeroAddress
 
 	for _, premineInfo := range p.premineInfos {
 		chainConfig.Genesis.Alloc[premineInfo.Address] = &chain.GenesisAccount{
@@ -250,6 +251,43 @@ func (p *genesisParams) parsePremineInfo() error {
 	return nil
 }
 
+func (p *genesisParams) parseStakeInfo() error {
+	p.stakeInfos = make(map[types.Address]*big.Int, len(p.stake))
+
+	for _, stake := range p.stake {
+		stakeInfo, err := helper.ParsePremineInfo(stake)
+		if err != nil {
+			return fmt.Errorf("invalid stake amount provided: %w", err)
+		}
+
+		p.stakeInfos[stakeInfo.Address] = stakeInfo.Amount
+	}
+
+	return nil
+}
+
+// validatePremineInfo validates whether reserve account (0x0 address) is premined
+func (p *genesisParams) validatePremineInfo() error {
+	for _, premineInfo := range p.premineInfos {
+		if premineInfo.Address == types.ZeroAddress {
+			// we have premine of zero address, just return
+			return nil
+		}
+	}
+
+	return errReserveAccMustBePremined
+}
+
+// validateBlockTrackerPollInterval validates block tracker block interval
+// which can not be 0
+func (p *genesisParams) validateBlockTrackerPollInterval() error {
+	if p.blockTrackerPollInterval == 0 {
+		return helper.ErrBlockTrackerPollInterval
+	}
+
+	return nil
+}
+
 func (p *genesisParams) validateGenesisBaseFeeConfig() error {
 	if p.baseFeeConfig == "" {
 		return errors.New("invalid input(empty string) for genesis base fee config flag")
@@ -277,11 +315,6 @@ func (p *genesisParams) validateGenesisBaseFeeConfig() error {
 	return nil
 }
 
-// isBurnContractEnabled returns true in case burn contract info is provided
-func (p *genesisParams) isBurnContractEnabled() bool {
-	return p.burnContract != ""
-}
-
 func (p *genesisParams) getResult() command.CommandResult {
 	return &GenesisResult{
 		Message: fmt.Sprintf("\nGenesis written to %s\n", p.genesisPath),

command/genesis/params_test.go

@@ -35,60 +35,26 @@ func Test_extractNativeTokenMetadata(t *testing.T) {
 		},
 		{
 			name:      "empty name provided",
-			rawConfig: ":TST:18:false",
+			rawConfig: ":TST:18:0x123456789",
 			expectErr: true,
 		},
 		{
 			name:      "empty symbol provided",
-			rawConfig: "Test::18:false",
+			rawConfig: "Test::18:0x123456789",
 			expectErr: true,
 		},
 		{
 			name:      "invalid decimals number provided",
-			rawConfig: "Test:TST:9999999999999999999999999999999999999999999999999999999999:false",
+			rawConfig: "Test:TST:9999999999999999999999999999999999999999999999999999999999:false:0x123456789",
 			expectErr: true,
 		},
 		{
-			name:      "invalid mintable flag provided",
-			rawConfig: "Test:TST:18:bar",
-			expectErr: true,
-		},
-		{
-			name:      "mintable token not enough params provided",
-			rawConfig: "Test:TST:18:true",
-			expectErr: true,
-		},
-		{
-			name:      "non-mintable valid config",
-			rawConfig: "MyToken:MTK:9:false",
-			expectedCfg: &polybft.TokenConfig{
-				Name:       "MyToken",
-				Symbol:     "MTK",
-				Decimals:   9,
-				IsMintable: false,
-				Owner:      types.ZeroAddress,
-			},
-			expectErr: false,
-		},
-		{
-			name:      "non-mintable token config, owner provided but ignored",
-			rawConfig: "MyToken:MTK:9:false:0x123456789",
+			name:      "valid config",
+			rawConfig: "MyToken:MTK:9:0x123456789",
 			expectedCfg: &polybft.TokenConfig{
 				Name:       "MyToken",
 				Symbol:     "MTK",
 				Decimals:   9,
-				IsMintable: false,
-				Owner:      types.ZeroAddress,
-			},
-			expectErr: false,
-		},
-		{
-			name:      "mintable token valid config",
-			rawConfig: "MyMintToken:MMTK:9:true:0x123456789",
-			expectedCfg: &polybft.TokenConfig{
-				Name:       "MyMintToken",
-				Symbol:     "MMTK",
-				Decimals:   9,
 				IsMintable: true,
 				Owner:      types.StringToAddress("0x123456789"),
 			},