[EVM-706]: Provide native token initial total supply (0xPolygon#1623)

* Add initial total supply to native erc20 tokens

* Comments fix

* UT fix

consensus/polybft/polybft.go

@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"math/big"
 	"path/filepath"
 	"time"
 
@@ -125,6 +126,19 @@ func GenesisPostHookFactory(config *chain.Chain, engineName string) func(txn *st
 			return err
 		}
 
+		// calculate initial total supply of native erc20 token
+		// we skip zero address, since its a special case address
+		// that is used for minting and burning native token
+		initialTotalSupply := big.NewInt(0)
+
+		for addr, alloc := range config.Genesis.Alloc {
+			if addr == types.ZeroAddress {
+				continue
+			}
+
+			initialTotalSupply.Add(initialTotalSupply, alloc.Balance)
+		}
+
 		bridgeCfg := polyBFTConfig.Bridge
 		if bridgeCfg == nil {
 			return errMissingBridgeConfig
@@ -308,12 +322,13 @@ func GenesisPostHookFactory(config *chain.Chain, engineName string) func(txn *st
 		if polyBFTConfig.NativeTokenConfig.IsMintable {
 			// initialize NativeERC20Mintable SC
 			params := &contractsapi.InitializeNativeERC20MintableFn{
-				Predicate_: contracts.ChildERC20PredicateContract,
-				Owner_:     polyBFTConfig.NativeTokenConfig.Owner,
-				RootToken_: polyBFTConfig.Bridge.RootNativeERC20Addr,
-				Name_:      polyBFTConfig.NativeTokenConfig.Name,
-				Symbol_:    polyBFTConfig.NativeTokenConfig.Symbol,
-				Decimals_:  polyBFTConfig.NativeTokenConfig.Decimals,
+				Predicate_:   contracts.ChildERC20PredicateContract,
+				Owner_:       polyBFTConfig.NativeTokenConfig.Owner,
+				RootToken_:   polyBFTConfig.Bridge.RootNativeERC20Addr,
+				Name_:        polyBFTConfig.NativeTokenConfig.Name,
+				Symbol_:      polyBFTConfig.NativeTokenConfig.Symbol,
+				Decimals_:    polyBFTConfig.NativeTokenConfig.Decimals,
+				TokenSupply_: initialTotalSupply,
 			}
 
 			input, err := params.EncodeAbi()
@@ -328,11 +343,12 @@ func GenesisPostHookFactory(config *chain.Chain, engineName string) func(txn *st
 		} else {
 			// initialize NativeERC20 SC
 			params := &contractsapi.InitializeNativeERC20Fn{
-				Name_:      polyBFTConfig.NativeTokenConfig.Name,
-				Symbol_:    polyBFTConfig.NativeTokenConfig.Symbol,
-				Decimals_:  polyBFTConfig.NativeTokenConfig.Decimals,
-				RootToken_: polyBFTConfig.Bridge.RootNativeERC20Addr,
-				Predicate_: contracts.ChildERC20PredicateContract,
+				Name_:        polyBFTConfig.NativeTokenConfig.Name,
+				Symbol_:      polyBFTConfig.NativeTokenConfig.Symbol,
+				Decimals_:    polyBFTConfig.NativeTokenConfig.Decimals,
+				RootToken_:   polyBFTConfig.Bridge.RootNativeERC20Addr,
+				Predicate_:   contracts.ChildERC20PredicateContract,
+				TokenSupply_: initialTotalSupply,
 			}
 
 			input, err := params.EncodeAbi()

consensus/polybft/polybft_test.go

@@ -332,7 +332,7 @@ func Test_GenesisPostHookFactory(t *testing.T) {
 				Engine:          map[string]interface{}{ConsensusName: tc.config},
 				BridgeAllowList: tc.bridgeAllowList,
 			}
-			chainConfig := &chain.Chain{Params: params}
+			chainConfig := &chain.Chain{Params: params, Genesis: &chain.Genesis{Alloc: make(map[types.Address]*chain.GenesisAccount)}}
 			initHandler := GenesisPostHookFactory(chainConfig, ConsensusName)
 			require.NotNil(t, initHandler)
 

e2e-polybft/e2e/consensus_test.go

@@ -13,24 +13,39 @@ import (
 	"github.com/umbracle/ethgo/abi"
 	"github.com/umbracle/ethgo/wallet"
 
+	"github.com/0xPolygon/polygon-edge/command"
 	"github.com/0xPolygon/polygon-edge/command/genesis"
 	"github.com/0xPolygon/polygon-edge/command/sidechain"
 	"github.com/0xPolygon/polygon-edge/consensus/polybft"
 	"github.com/0xPolygon/polygon-edge/consensus/polybft/contractsapi"
 	"github.com/0xPolygon/polygon-edge/contracts"
 	"github.com/0xPolygon/polygon-edge/e2e-polybft/framework"
-	"github.com/0xPolygon/polygon-edge/helper/hex"
 	"github.com/0xPolygon/polygon-edge/txrelayer"
 	"github.com/0xPolygon/polygon-edge/types"
 )
 
+var uint256ABIType = abi.MustNewType("tuple(uint256)")
+
 func TestE2E_Consensus_Basic_WithNonValidators(t *testing.T) {
 	const epochSize = 4
 
 	cluster := framework.NewTestCluster(t, 5,
 		framework.WithEpochSize(epochSize), framework.WithNonValidators(2))
 	defer cluster.Stop()
 
+	cluster.WaitForReady(t)
+
+	// initialize tx relayer
+	relayer, err := txrelayer.NewTxRelayer(txrelayer.WithClient(cluster.Servers[0].JSONRPC()))
+	require.NoError(t, err)
+
+	// because we are using native token as reward wallet, and it has default premine balance
+	initialTotalSupply := new(big.Int).Set(command.DefaultPremineBalance)
+
+	// check if initial total supply of native ERC20 token is the same as expected
+	totalSupply := queryNativeERC20Metadata(t, "totalSupply", uint256ABIType, relayer)
+	require.True(t, initialTotalSupply.Cmp(totalSupply.(*big.Int)) == 0) //nolint:forcetypeassert
+
 	t.Run("consensus protocol", func(t *testing.T) {
 		require.NoError(t, cluster.WaitForBlock(2*epochSize+1, 1*time.Minute))
 	})
@@ -449,41 +464,30 @@ func TestE2E_Consensus_MintableERC20NativeToken(t *testing.T) {
 		decimals    = uint8(5)
 	)
 
-	nativeTokenAddr := ethgo.Address(contracts.NativeERC20TokenContract)
-
-	queryNativeERC20Metadata := func(funcName string, abiType *abi.Type, relayer txrelayer.TxRelayer) interface{} {
-		valueHex, err := ABICall(relayer, contractsapi.NativeERC20Mintable, nativeTokenAddr, ethgo.ZeroAddress, funcName)
-		require.NoError(t, err)
-
-		valueRaw, err := hex.DecodeHex(valueHex)
-		require.NoError(t, err)
-
-		var decodedResult map[string]interface{}
-
-		err = abiType.DecodeStruct(valueRaw, &decodedResult)
-		require.NoError(t, err)
-
-		return decodedResult["0"]
-	}
-
 	validatorsAddrs := make([]types.Address, validatorCount)
 	initValidatorsBalance := ethgo.Ether(1)
 	initMinterBalance := ethgo.Ether(100000)
 
 	minter, err := wallet.GenerateKey()
 	require.NoError(t, err)
 
+	// because we are using native token as reward wallet, and it has default premine balance
+	initialTotalSupply := new(big.Int).Set(command.DefaultPremineBalance)
+
 	cluster := framework.NewTestCluster(t,
 		validatorCount,
 		framework.WithNativeTokenConfig(
 			fmt.Sprintf("%s:%s:%d:true:%s", tokenName, tokenSymbol, decimals, minter.Address())),
 		framework.WithEpochSize(epochSize),
 		framework.WithSecretsCallback(func(addrs []types.Address, config *framework.TestClusterConfig) {
 			config.Premine = append(config.Premine, fmt.Sprintf("%s:%d", minter.Address(), initMinterBalance))
+			initialTotalSupply.Add(initialTotalSupply, initMinterBalance)
+
 			for i, addr := range addrs {
 				config.Premine = append(config.Premine, fmt.Sprintf("%s:%d", addr, initValidatorsBalance))
 				config.StakeAmounts = append(config.StakeAmounts, new(big.Int).Set(initValidatorsBalance))
 				validatorsAddrs[i] = addr
+				initialTotalSupply.Add(initialTotalSupply, initValidatorsBalance)
 			}
 		}))
 	defer cluster.Stop()
@@ -500,20 +504,25 @@ func TestE2E_Consensus_MintableERC20NativeToken(t *testing.T) {
 	stringABIType := abi.MustNewType("tuple(string)")
 	uint8ABIType := abi.MustNewType("tuple(uint8)")
 
-	name := queryNativeERC20Metadata("name", stringABIType, relayer)
+	totalSupply := queryNativeERC20Metadata(t, "totalSupply", uint256ABIType, relayer)
+	require.True(t, initialTotalSupply.Cmp(totalSupply.(*big.Int)) == 0) //nolint:forcetypeassert
+
+	// check if initial total supply of native ERC20 token is the same as expected
+	name := queryNativeERC20Metadata(t, "name", stringABIType, relayer)
 	require.Equal(t, tokenName, name)
 
-	symbol := queryNativeERC20Metadata("symbol", stringABIType, relayer)
+	symbol := queryNativeERC20Metadata(t, "symbol", stringABIType, relayer)
 	require.Equal(t, tokenSymbol, symbol)
 
-	decimalsCount := queryNativeERC20Metadata("decimals", uint8ABIType, relayer)
+	decimalsCount := queryNativeERC20Metadata(t, "decimals", uint8ABIType, relayer)
 	require.Equal(t, decimals, decimalsCount)
 
 	// send mint transactions
 	mintFn, exists := contractsapi.NativeERC20Mintable.Abi.Methods["mint"]
 	require.True(t, exists)
 
 	mintAmount := ethgo.Ether(10)
+	nativeTokenAddr := ethgo.Address(contracts.NativeERC20TokenContract)
 
 	// make sure minter account can mint tokens
 	for _, addr := range validatorsAddrs {
@@ -570,6 +579,20 @@ func TestE2E_Consensus_CustomRewardToken(t *testing.T) {
 	)
 	defer cluster.Stop()
 
+	cluster.WaitForReady(t)
+
+	// initialize tx relayer
+	relayer, err := txrelayer.NewTxRelayer(txrelayer.WithClient(cluster.Servers[0].JSONRPC()))
+	require.NoError(t, err)
+
+	// because we are not using native token as reward wallet, and have no premine
+	// initial token supply should be 0
+	initialTotalSupply := big.NewInt(0)
+
+	// check if initial total supply of native ERC20 token is the same as expected
+	totalSupply := queryNativeERC20Metadata(t, "totalSupply", uint256ABIType, relayer)
+	require.True(t, initialTotalSupply.Cmp(totalSupply.(*big.Int)) == 0) //nolint:forcetypeassert
+
 	// wait for couple of epochs to accumulate some rewards
 	require.NoError(t, cluster.WaitForBlock(epochSize*3, 3*time.Minute))
 

e2e-polybft/e2e/helpers_test.go

@@ -20,6 +20,7 @@ import (
 	"github.com/0xPolygon/polygon-edge/consensus/polybft"
 	"github.com/0xPolygon/polygon-edge/consensus/polybft/contractsapi"
 	"github.com/0xPolygon/polygon-edge/consensus/polybft/contractsapi/artifact"
+	"github.com/0xPolygon/polygon-edge/contracts"
 	"github.com/0xPolygon/polygon-edge/e2e-polybft/framework"
 	"github.com/0xPolygon/polygon-edge/helper/common"
 	"github.com/0xPolygon/polygon-edge/helper/hex"
@@ -310,3 +311,23 @@ func erc721OwnerOf(t *testing.T, tokenID *big.Int, tokenAddr types.Address, rela
 
 	return types.StringToAddress(ownerRaw)
 }
+
+// queryNativeERC20Metadata returns some meta data user requires from native erc20 token
+func queryNativeERC20Metadata(t *testing.T, funcName string, abiType *abi.Type, relayer txrelayer.TxRelayer) interface{} {
+	t.Helper()
+
+	valueHex, err := ABICall(relayer, contractsapi.NativeERC20Mintable,
+		ethgo.Address(contracts.NativeERC20TokenContract),
+		ethgo.ZeroAddress, funcName)
+	require.NoError(t, err)
+
+	valueRaw, err := hex.DecodeHex(valueHex)
+	require.NoError(t, err)
+
+	var decodedResult map[string]interface{}
+
+	err = abiType.DecodeStruct(valueRaw, &decodedResult)
+	require.NoError(t, err)
+
+	return decodedResult["0"]
+}