Genesis accounts with esdt balances

cmd/sovereignnode/config/sovereignConfig.toml

@@ -65,3 +65,7 @@
         AcknowledgeTimeout = 60
         # Payload version to process
         Version = 1
+
+[GenesisConfig]
+    # NativeESDT specifies the sovereign shard's native esdt currency
+    NativeESDT = "WEGLD-bd4d79"

config/sovereignConfig.go

@@ -8,6 +8,7 @@ type SovereignConfig struct {
 	OutgoingSubscribedEvents         OutgoingSubscribedEvents `toml:"OutgoingSubscribedEvents"`
 	OutGoingBridge                   OutGoingBridge           `toml:"OutGoingBridge"`
 	NotifierConfig                   NotifierConfig           `toml:"NotifierConfig"`
+	GenesisConfig                    GenesisConfig            `toml:"GenesisConfig"`
 	OutGoingBridgeCertificate        OutGoingBridgeCertificate
 }
 
@@ -58,3 +59,8 @@ type WebSocketConfig struct {
 	AcknowledgeTimeout int    `toml:"AcknowledgeTimeout"`
 	Version            uint32 `toml:"Version"`
 }
+
+// GenesisConfig should hold all sovereign genesis related configs
+type GenesisConfig struct {
+	NativeESDT string `toml:"NativeESDT"`
+}

factory/processing/blockProcessorCreator.go

@@ -35,7 +35,7 @@ import (
 	"github.com/multiversx/mx-chain-go/process/smartContract/hooks"
 	"github.com/multiversx/mx-chain-go/process/smartContract/hooks/counters"
 	"github.com/multiversx/mx-chain-go/process/smartContract/processProxy"
-	"github.com/multiversx/mx-chain-go/process/smartContract/processorV2"
+	"github.com/multiversx/mx-chain-go/process/smartContract/processorV2/scrProcFactory"
 	"github.com/multiversx/mx-chain-go/process/smartContract/scrCommon"
 	"github.com/multiversx/mx-chain-go/process/throttle"
 	"github.com/multiversx/mx-chain-go/process/transaction"
@@ -266,7 +266,7 @@ func (pcf *processComponentsFactory) newShardBlockProcessor(
 		WasmVMChangeLocker:  wasmVMChangeLocker,
 	}
 
-	scProcessorProxy, err := processorV2.CreateSCRProcessor(pcf.chainRunType, argsNewScProcessor)
+	scProcessorProxy, err := scrProcFactory.CreateSCRProcessor(pcf.chainRunType, argsNewScProcessor, pcf.epochNotifier)
 	if err != nil {
 		return nil, err
 	}

factory/processing/processComponents.go

@@ -970,6 +970,8 @@ func (pcf *processComponentsFactory) generateGenesisHeadersAndApplyInitialBalanc
 		ShardCoordinatorFactory: pcf.shardCoordinatorFactory,
 		TxPreprocessorCreator:   pcf.txPreprocessorCreator,
 		DNSV2Addresses:          pcf.config.BuiltInFunctions.DNSV2Addresses,
+		// TODO: We should only pass the whole config instead of passing sub-configs as above
+		Config: pcf.config,
 	}
 
 	gbc, err := pcf.genesisBlockCreatorFactory.CreateGenesisBlockCreator(arg)

factory/processing/txSimulatorProcessComponents.go

@@ -13,7 +13,7 @@ import (
 	"github.com/multiversx/mx-chain-go/process/coordinator"
 	"github.com/multiversx/mx-chain-go/process/factory/shard"
 	"github.com/multiversx/mx-chain-go/process/smartContract"
-	"github.com/multiversx/mx-chain-go/process/smartContract/processorV2"
+	"github.com/multiversx/mx-chain-go/process/smartContract/processorV2/scrProcFactory"
 	"github.com/multiversx/mx-chain-go/process/smartContract/scrCommon"
 	"github.com/multiversx/mx-chain-go/process/transaction"
 	"github.com/multiversx/mx-chain-go/process/transactionEvaluator"
@@ -367,7 +367,7 @@ func (pcf *processComponentsFactory) createArgsTxSimulatorProcessorShard(
 		IsGenesisProcessing: false,
 	}
 
-	scProcessor, err := processorV2.CreateSCRProcessor(pcf.chainRunType, scProcArgs)
+	scProcessor, err := scrProcFactory.CreateSCRProcessor(pcf.chainRunType, scProcArgs, pcf.epochNotifier)
 	if err != nil {
 		return args, nil, nil, err
 	}

genesis/process/argGenesisBlockCreator.go

@@ -69,6 +69,7 @@ type ArgsGenesisBlockCreator struct {
 	TxExecutionOrderHandler common.TxExecutionOrderHandler
 	TxPreprocessorCreator   preprocess.TxPreProcessorCreator
 	ChainRunType            common.ChainRunType
+	Config                  config.Config
 
 	GenesisNodePrice *big.Int
 	GenesisString    string

genesis/process/errors.go

@@ -3,3 +3,5 @@ package process
 import "errors"
 
 var errNilGenesisBlockCreator = errors.New("nil genesis block creator provided")
+
+var errCouldNotGenerateInitialESDTTransfers = errors.New("could not generate initial esdt transfers")

genesis/process/shardGenesisBlockCreator.go

@@ -33,7 +33,7 @@
 	"github.com/multiversx/mx-chain-go/process/smartContract/builtInFunctions"
 	"github.com/multiversx/mx-chain-go/process/smartContract/hooks"
 	"github.com/multiversx/mx-chain-go/process/smartContract/hooks/counters"
-	"github.com/multiversx/mx-chain-go/process/smartContract/processProxy"
+	"github.com/multiversx/mx-chain-go/process/smartContract/processorV2/scrProcFactory"
 	"github.com/multiversx/mx-chain-go/process/smartContract/scrCommon"
 	syncDisabled "github.com/multiversx/mx-chain-go/process/sync/disabled"
 	"github.com/multiversx/mx-chain-go/process/transaction"
@@ -174,6 +174,20 @@
 		return createShardGenesisBlockAfterHardFork(arg, body, hardForkBlockProcessor)
 	}
 
+	processors, err := createProcessorsForShardGenesisBlock(arg, createGenesisConfig(), createGenesisRoundConfig())
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	return baseCreateShardGenesisBlock(arg, nodesListSplitter, processors)
+}
+
+func baseCreateShardGenesisBlock(
+	arg ArgsGenesisBlockCreator,
+	nodesListSplitter genesis.NodesListSplitter,
+	processors *genesisProcessors,
+) (data.HeaderHandler, [][]byte, *genesis.IndexingData, error) {
+
 	indexingData := &genesis.IndexingData{
 		DelegationTxs:      make([]data.TransactionHandler, 0),
 		ScrsTxs:            make(map[string]data.TransactionHandler),
@@ -182,11 +196,6 @@
 		DeployInitialScTxs: make([]data.TransactionHandler, 0),
 	}
 
-	processors, err := createProcessorsForShardGenesisBlock(arg, createGenesisConfig(), createGenesisRoundConfig())
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
 	deployMetrics := &deployedScMetrics{}
 
 	scAddresses, scTxs, err := deployInitialSmartContracts(processors, arg, deployMetrics)
@@ -582,7 +591,7 @@
 		WasmVMChangeLocker:  genesisWasmVMLocker,
 	}
 
-	scProcessorProxy, err := processProxy.NewSmartContractProcessorProxy(argsNewScProcessor, epochNotifier)
+	scProcessorProxy, err := scrProcFactory.CreateSCRProcessor(arg.ChainRunType, argsNewScProcessor, epochNotifier)
 	if err != nil {
 		return nil, err
 	}

genesis/process/sovereignGenesisBlockCreator.go

@@ -9,12 +9,12 @@
 	"github.com/multiversx/mx-chain-core-go/core"
 	"github.com/multiversx/mx-chain-core-go/data"
 	"github.com/multiversx/mx-chain-core-go/data/block"
+	"github.com/multiversx/mx-chain-core-go/data/smartContractResult"
 	"github.com/multiversx/mx-chain-core-go/data/transaction"
 	"github.com/multiversx/mx-chain-go/config"
 	"github.com/multiversx/mx-chain-go/factory"
 	"github.com/multiversx/mx-chain-go/genesis"
 	"github.com/multiversx/mx-chain-go/process"
-	"github.com/multiversx/mx-chain-go/update"
 	"github.com/multiversx/mx-chain-go/vm"
 	vmcommon "github.com/multiversx/mx-chain-vm-common-go"
 )
@@ -29,18 +29,25 @@
 		return nil, errNilGenesisBlockCreator
 	}
 
+	log.Debug("NewSovereignGenesisBlockCreator", "native esdt token", gbc.arg.Config.SovereignConfig.GenesisConfig.NativeESDT)
+
 	return &sovereignGenesisBlockCreator{
 		genesisBlockCreator: gbc,
 	}, nil
 }
 
 // CreateGenesisBlocks will create sovereign genesis blocks
 func (gbc *sovereignGenesisBlockCreator) CreateGenesisBlocks() (map[uint32]data.HeaderHandler, error) {
+	err := gbc.initGenesisAccounts()
+	if err != nil {
+		return nil, err
+	}
+
 	if !mustDoGenesisProcess(gbc.arg) {
 		return gbc.createSovereignEmptyGenesisBlocks()
 	}
 
-	err := gbc.computeSovereignDNSAddresses(gbc.arg.EpochConfig.EnableEpochs)
+	err = gbc.computeSovereignDNSAddresses(gbc.arg.EpochConfig.EnableEpochs)
 	if err != nil {
 		return nil, err
 	}
@@ -55,8 +62,27 @@
 	return gbc.createSovereignHeaders(argsCreateBlock)
 }
 
+func (gbc *sovereignGenesisBlockCreator) initGenesisAccounts() error {
+	acc, err := gbc.arg.Accounts.LoadAccount(core.SystemAccountAddress)
+	if err != nil {
+		return err
+	}
+
+	err = gbc.arg.Accounts.SaveAccount(acc)
+	if err != nil {
+		return err
+	}
+
+	acc, err = gbc.arg.Accounts.LoadAccount(core.ESDTSCAddress)
+	if err != nil {
+		return err
+	}
+
+	return gbc.arg.Accounts.SaveAccount(acc)
+}
+
 func (gbc *sovereignGenesisBlockCreator) createSovereignEmptyGenesisBlocks() (map[uint32]data.HeaderHandler, error) {
-	err := gbc.computeSovereignDNSAddresses(createGenesisConfig())
+	err := gbc.computeSovereignDNSAddresses(createSovereignGenesisConfig())
 	if err != nil {
 		return nil, err
 	}
@@ -77,6 +103,12 @@
 	return mapEmptyGenesisBlocks, nil
 }
 
+func createSovereignGenesisConfig() config.EnableEpochs {
+	cfg := createGenesisConfig()
+	cfg.ESDTMultiTransferEnableEpoch = 0
+	return cfg
+}
+
 func (gbc *sovereignGenesisBlockCreator) computeSovereignDNSAddresses(enableEpochsConfig config.EnableEpochs) error {
 	initialAddresses, err := factory.DecodeAddresses(gbc.arg.Core.AddressPubKeyConverter(), gbc.arg.DNSV2Addresses)
 	if err != nil {
@@ -96,9 +128,7 @@
 
 	genesisBlock, scResults, gbc.initialIndexingData[shardID], err = createSovereignShardGenesisBlock(
 		args.mapArgsGenesisBlockCreator[shardID],
-		args.mapBodies[shardID],
 		args.nodesListSplitter,
-		args.mapHardForkBlockProcessor[shardID],
 	)
 
 	if err != nil {
@@ -132,16 +162,20 @@
 
 func createSovereignShardGenesisBlock(
 	arg ArgsGenesisBlockCreator,
-	body *block.Body,
 	nodesListSplitter genesis.NodesListSplitter,
-	hardForkBlockProcessor update.HardForkBlockProcessor,
 ) (data.HeaderHandler, [][]byte, *genesis.IndexingData, error) {
-	genesisBlock, scAddresses, indexingData, err := CreateShardGenesisBlock(arg, body, nodesListSplitter, hardForkBlockProcessor)
+	sovereignGenesisConfig := createSovereignGenesisConfig()
+	shardProcessors, err := createProcessorsForShardGenesisBlock(arg, sovereignGenesisConfig, createGenesisRoundConfig())
 	if err != nil {
 		return nil, nil, nil, err
 	}
 
-	metaProcessor, err := createProcessorsForMetaGenesisBlock(arg, createGenesisConfig(), createGenesisRoundConfig())
+	genesisBlock, scAddresses, indexingData, err := baseCreateShardGenesisBlock(arg, nodesListSplitter, shardProcessors)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	metaProcessor, err := createProcessorsForMetaGenesisBlock(arg, sovereignGenesisConfig, createGenesisRoundConfig())
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -158,14 +192,20 @@
 	}
 	indexingData.StakingTxs = stakingTxs
 
-	rootHash, err := arg.Accounts.Commit()
+	metaScrsTxs := metaProcessor.txCoordinator.GetAllCurrentUsedTxs(block.SmartContractResultBlock)
+	genesisESDTTransfers, err := createSovereignGenesisESDTTransfers(arg, shardProcessors.scrProcessor)
 	if err != nil {
-		return nil, nil, nil, fmt.Errorf("%w encountered when creating sovereign genesis block while commiting", err)
+		return nil, nil, nil, err
 	}
 
-	metaScrsTxs := metaProcessor.txCoordinator.GetAllCurrentUsedTxs(block.SmartContractResultBlock)
+	indexingData.ScrsTxs = mergeScrs(indexingData.ScrsTxs, genesisESDTTransfers)
 	indexingData.ScrsTxs = mergeScrs(indexingData.ScrsTxs, metaScrsTxs)
 
+	rootHash, err := arg.Accounts.Commit()
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("%w encountered when creating sovereign genesis block while commiting", err)
+	}
+
 	err = setRootHash(genesisBlock, rootHash)
 	if err != nil {
 		return nil, nil, nil, err
@@ -277,3 +317,53 @@
 
 	return stakingTxs, nil
 }
+
+func createSovereignGenesisESDTTransfers(args ArgsGenesisBlockCreator, scrProcessor process.SmartContractResultProcessor) (map[string]data.TransactionHandler, error) {
+	initialESDTTxs := make(map[string]data.TransactionHandler, 0)
+	initialAccounts := args.AccountsParser.InitialAccounts()
+
+	tokenID := args.Config.SovereignConfig.GenesisConfig.NativeESDT
+	for nonce, initialAcc := range initialAccounts {
+		accInitialBalance := initialAcc.GetBalanceValue()
+
+		log.Debug("creating genesis initial esdt balance",
+			"address", initialAcc.GetAddress(), "balance", accInitialBalance.String(), "tokenID", tokenID)
+
+		scr := &smartContractResult.SmartContractResult{
+			Nonce:   uint64(nonce),
+			RcvAddr: initialAcc.AddressBytes(),
+			SndAddr: core.ESDTSCAddress,
+			Data:    createGenesisSCRData(tokenID, accInitialBalance),
+			Value:   big.NewInt(0),
+		}
+
+		retCode, err := scrProcessor.ProcessSmartContractResult(scr)
+		if err != nil {
+			return nil, err
+		}
+
+		if retCode != vmcommon.Ok {
+			log.Error("could not generate initial esdt balances",
+				"func", "createSovereignGenesisESDTTransfers", "ret code", retCode, "address", initialAcc.GetAddress())
+			return nil, errCouldNotGenerateInitialESDTTransfers
+		}
+
+		hash, err := core.CalculateHash(args.Core.InternalMarshalizer(), args.Core.Hasher(), scr)
+		if err != nil {
+			return nil, err
+		}
+
+		initialESDTTxs[string(hash)] = scr
+	}
+
+	return initialESDTTxs, nil
+}
+
+func createGenesisSCRData(tokenID string, value *big.Int) []byte {
+	numTokensToTransferBytes := big.NewInt(1).Bytes()
+	return []byte(core.BuiltInFunctionMultiESDTNFTTransfer +
+		"@" + hex.EncodeToString(numTokensToTransferBytes) +
+		"@" + hex.EncodeToString([]byte(tokenID)) + // tokenID
+		"@" + hex.EncodeToString(big.NewInt(0).Bytes()) + //nonce
+		"@" + hex.EncodeToString(value.Bytes())) // value
+}