[sovereign] Trie sync

dataRetriever/factory/containers/requestersContainer.go

@@ -25,6 +25,8 @@ func NewRequestersContainer() *requestersContainer {
 	}
 }
 
+// TODO: THIS STILL CONTAINS META STUFF FOR SOVEREIGN
+
 // Get returns the object stored at a certain key.
 // Returns an error if the element does not exist
 func (rc *requestersContainer) Get(key string) (dataRetriever.Requester, error) {

dataRetriever/factory/requestersContainer/baseRequestersContainerFactory.go

@@ -324,7 +324,7 @@ func (brcf *baseRequestersContainerFactory) createTrieNodesRequester(
 }
 
 func (brcf *baseRequestersContainerFactory) generateValidatorInfoRequester() error {
-	identifierValidatorInfo := common.ValidatorInfoTopic
+	identifierValidatorInfo := common.ValidatorInfoTopic + brcf.shardCoordinator.CommunicationIdentifier(core.SovereignChainShardId)
 	shardC := brcf.shardCoordinator
 	requestSender, err := brcf.createOneRequestSenderWithSpecifiedNumRequests(identifierValidatorInfo, EmptyExcludePeersOnTopic, shardC.SelfId(), brcf.numCrossShardPeers, brcf.numIntraShardPeers)
 	if err != nil {

dataRetriever/factory/resolverscontainer/baseResolversContainerFactory.go

@@ -378,7 +378,7 @@ func (brcf *baseResolversContainerFactory) createTrieNodesResolver(
 }
 
 func (brcf *baseResolversContainerFactory) generateValidatorInfoResolver() error {
-	identifierValidatorInfo := common.ValidatorInfoTopic
+	identifierValidatorInfo := common.ValidatorInfoTopic + brcf.shardCoordinator.CommunicationIdentifier(core.SovereignChainShardId)
 	shardC := brcf.shardCoordinator
 	resolverSender, err := brcf.createOneResolverSenderWithSpecifiedNumRequests(identifierValidatorInfo, EmptyExcludePeersOnTopic, shardC.SelfId())
 	if err != nil {

dataRetriever/factory/storageRequestersContainer/shardRequestersContainerFactory.go

@@ -6,6 +6,7 @@ import (
 	"github.com/multiversx/mx-chain-go/dataRetriever/factory/containers"
 	storagerequesters "github.com/multiversx/mx-chain-go/dataRetriever/storageRequesters"
 	"github.com/multiversx/mx-chain-go/process/factory"
+	logger "github.com/multiversx/mx-chain-logger-go"
 )
 
 var _ dataRetriever.RequestersContainerFactory = (*shardRequestersContainerFactory)(nil)
@@ -14,10 +15,14 @@ type shardRequestersContainerFactory struct {
 	*baseRequestersContainerFactory
 }
 
+// THIS SHOULD BE CHANGED FOR SOVEREIGN
+var log = logger.GetOrCreate("dsada")
+
 // NewShardRequestersContainerFactory creates a new container filled with topic requesters for shards
 func NewShardRequestersContainerFactory(
 	args FactoryArgs,
 ) (*shardRequestersContainerFactory, error) {
+	log.Error("#########################################NewShardRequestersContainerFactory")
 	container := containers.NewRequestersContainer()
 	base := &baseRequestersContainerFactory{
 		container:                container,

dataRetriever/requestHandlers/requestHandler.go

@@ -266,7 +266,7 @@ func (rrh *resolverRequestHandler) RequestMiniBlocks(destShardID uint32, miniblo
 		"num mbs", len(unrequestedHashes),
 	)
 
-	requester, err := rrh.requestersFinder.CrossShardRequester(factory.MiniBlocksTopic, destShardID)
+	requester, err := rrh.requestersFinder.IntraShardRequester(factory.MiniBlocksTopic)
 	if err != nil {
 		log.Error("RequestMiniBlocks.CrossShardRequester",
 			"error", err.Error(),
@@ -574,7 +574,7 @@ func (rrh *resolverRequestHandler) RequestValidatorInfo(hash []byte) {
 		"epoch", rrh.epoch,
 	)
 
-	requester, err := rrh.requestersFinder.MetaChainRequester(common.ValidatorInfoTopic)
+	requester, err := rrh.requestersFinder.IntraShardRequester(common.ValidatorInfoTopic)
 	if err != nil {
 		log.Error("RequestValidatorInfo.MetaChainRequester",
 			"error", err.Error(),
@@ -614,7 +614,7 @@ func (rrh *resolverRequestHandler) RequestValidatorsInfo(hashes [][]byte) {
 		"epoch", rrh.epoch,
 	)
 
-	requester, err := rrh.requestersFinder.MetaChainRequester(common.ValidatorInfoTopic)
+	requester, err := rrh.requestersFinder.IntraShardRequester(common.ValidatorInfoTopic)
 	if err != nil {
 		log.Error("RequestValidatorInfo.MetaChainRequester",
 			"error", err.Error(),

dataRetriever/resolvers/headerResolver.go

@@ -125,13 +125,16 @@ func (hdrRes *HeaderResolver) ProcessReceivedMessage(message p2p.MessageP2P, fro
 
 	var buff []byte
 
+	log.Error("HeaderResolver", "TYPE", rd.Type)
+
 	switch rd.Type {
 	case dataRetriever.HashType:
 		buff, err = hdrRes.resolveHeaderFromHash(rd)
 	case dataRetriever.NonceType:
 		buff, err = hdrRes.resolveHeaderFromNonce(rd)
 	case dataRetriever.EpochType:
 		buff, err = hdrRes.resolveHeaderFromEpoch(rd.Value)
+		log.Error("REST", "buff", string(buff), "err", err)
 	default:
 		return dataRetriever.ErrResolveTypeUnknown
 	}
@@ -228,10 +231,11 @@ func (hdrRes *HeaderResolver) resolveHeaderFromEpoch(key []byte) ([]byte, error)
 		return nil, err
 	}
 	if isUnknownEpoch {
+
 		hdrRes.mutEpochHandler.RLock()
-		metaEpoch := hdrRes.epochHandler.MetaEpoch()
+		metaEpoch := hdrRes.epochHandler.MetaEpoch() // DISABLED?????
 		hdrRes.mutEpochHandler.RUnlock()
-
+		log.Error("UNKNOWN EPOCH", "epoch", hdrRes.epochHandler.MetaEpoch())
 		actualKey = []byte(core.EpochStartIdentifier(metaEpoch))
 	}
 

epochStart/bootstrap/factory/epochStartInterceptorsContainerFactory.go

@@ -17,6 +17,7 @@ import (
 	"github.com/multiversx/mx-chain-go/process/factory/interceptorscontainer"
 	"github.com/multiversx/mx-chain-go/sharding"
 	"github.com/multiversx/mx-chain-go/storage/cache"
+	"github.com/multiversx/mx-chain-go/testscommon/sovereign"
 	"github.com/multiversx/mx-chain-go/update"
 )
 
@@ -110,27 +111,37 @@ func NewEpochStartInterceptorsContainer(args ArgsEpochStartInterceptorContainer)
 		NodeOperationMode:            args.NodeOperationMode,
 	}
 
-	interceptorsContainerFactory, err := interceptorscontainer.NewMetaInterceptorsContainerFactory(containerFactoryArgs)
+	// WHY META  ??????????????????????????????????
+
+	sp, err := interceptorscontainer.NewShardInterceptorsContainerFactory(containerFactoryArgs)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	mainContainer, fullArchiveContainer, err := interceptorsContainerFactory.Create()
+	interceptorsContainerFactory, err := interceptorscontainer.NewSovereignShardInterceptorsContainerFactory(interceptorscontainer.ArgsSovereignShardInterceptorsContainerFactory{
+		ShardContainer:           sp,
+		IncomingHeaderSubscriber: &sovereign.IncomingHeaderSubscriberStub{}, // definetely this needs help
+	})
 	if err != nil {
 		return nil, nil, err
 	}
 
-	err = interceptorsContainerFactory.AddShardTrieNodeInterceptors(mainContainer)
+	mainContainer, fullArchiveContainer, err := interceptorsContainerFactory.Create()
 	if err != nil {
 		return nil, nil, err
 	}
 
-	if args.NodeOperationMode == common.FullArchiveMode {
-		err = interceptorsContainerFactory.AddShardTrieNodeInterceptors(fullArchiveContainer)
-		if err != nil {
-			return nil, nil, err
-		}
-	}
+	//err = interceptorsContainerFactory.AddShardTrieNodeInterceptors(mainContainer)
+	//if err != nil {
+	//	return nil, nil, err
+	//}
+	//
+	//if args.NodeOperationMode == common.FullArchiveMode {
+	//	err = interceptorsContainerFactory.AddShardTrieNodeInterceptors(fullArchiveContainer)
+	//	if err != nil {
+	//		return nil, nil, err
+	//	}
+	//}
 
 	return mainContainer, fullArchiveContainer, nil
 }

epochStart/metachain/sovereignTrigger.go

@@ -9,22 +9,31 @@ import (
 	"github.com/multiversx/mx-chain-core-go/data/block"
 	"github.com/multiversx/mx-chain-go/dataRetriever"
 	"github.com/multiversx/mx-chain-go/epochStart"
+	"github.com/multiversx/mx-chain-go/process"
 )
 
 type sovereignTrigger struct {
 	*trigger
+	currentEpochValidatorInfoPool epochStart.ValidatorInfoCacher
+	PeerMiniBlocksSyncer          process.ValidatorInfoSyncer
 }
 
 // NewSovereignTrigger creates a new sovereign epoch start trigger
-func NewSovereignTrigger(args *ArgsNewMetaEpochStartTrigger) (*sovereignTrigger, error) {
+func NewSovereignTrigger(args *ArgsNewMetaEpochStartTrigger, PeerMiniBlocksSyncer process.ValidatorInfoSyncer) (*sovereignTrigger, error) {
 	metaTrigger, err := newTrigger(args, &block.SovereignChainHeader{}, &sovereignTriggerRegistryCreator{}, dataRetriever.BlockHeaderUnit)
 	if err != nil {
 		return nil, err
 	}
 
-	return &sovereignTrigger{
-		trigger: metaTrigger,
-	}, nil
+	st := &sovereignTrigger{
+		trigger:                       metaTrigger,
+		currentEpochValidatorInfoPool: args.DataPool.CurrentEpochValidatorInfo(),
+		PeerMiniBlocksSyncer:          PeerMiniBlocksSyncer,
+	}
+
+	args.DataPool.Headers().RegisterHandler(st.receivedMetaBlock)
+
+	return st, nil
 }
 
 // SetProcessed sets start of epoch to false and cleans underlying structure
@@ -112,6 +121,57 @@ func (st *sovereignTrigger) revert(header data.HeaderHandler) error {
 	return nil
 }
 
+// receivedMetaBlock is a callback function when a new metablock was received
+// upon receiving checks if trigger can be updated
+func (t *sovereignTrigger) receivedMetaBlock(headerHandler data.HeaderHandler, metaBlockHash []byte) {
+	t.mutTrigger.Lock()
+	defer t.mutTrigger.Unlock()
+
+	metaHdr, ok := headerHandler.(*block.SovereignChainHeader)
+	if !ok {
+		return
+	}
+
+	if !metaHdr.IsStartOfEpochBlock() {
+		return
+	}
+
+	log.Error("##############################receivedMetaBlock", "epoch", headerHandler.GetEpoch())
+
+	isMetaStartOfEpochForCurrentEpoch := metaHdr.GetEpoch() == t.epoch && metaHdr.IsStartOfEpochBlock()
+	if isMetaStartOfEpochForCurrentEpoch {
+		log.Error("##############################isMetaStartOfEpochForCurrentEpoch")
+		return
+	}
+
+	var err error
+	defer func() {
+		log.LogIfError(err)
+	}()
+
+	missingMiniBlocksHashes, blockBody, err := t.PeerMiniBlocksSyncer.SyncMiniBlocks(metaHdr)
+	if err != nil {
+		//	t.addMissingMiniBlocks(metaHdr.GetEpoch(), missingMiniBlocksHashes)
+		log.Debug("checkIfTriggerCanBeActivated.SyncMiniBlocks", "num missing mini blocks", len(missingMiniBlocksHashes), "error", err)
+		return
+	}
+
+	missingValidatorsInfoHashes, validatorsInfo, err := t.PeerMiniBlocksSyncer.SyncValidatorsInfo(blockBody)
+	if err != nil {
+		//t.addMissingValidatorsInfo(metaHdr.GetEpoch(), missingValidatorsInfoHashes)
+		log.Debug("checkIfTriggerCanBeActivated.SyncValidatorsInfo", "num missing validators info", len(missingValidatorsInfoHashes), "error", err)
+		return
+	}
+
+	for validatorInfoHash, validatorInfo := range validatorsInfo {
+		t.currentEpochValidatorInfoPool.AddValidatorInfo([]byte(validatorInfoHash), validatorInfo)
+	}
+
+	log.Error("##############################receivedMetaBlock", "NotifyAllPrepare", "true")
+
+	t.epochStartNotifier.NotifyAllPrepare(metaHdr, blockBody)
+}
+
 // IsInterfaceNil checks if the underlying pointer is nil
 func (st *sovereignTrigger) IsInterfaceNil() bool {
 	return st == nil

epochStart/metachain/stakingDataProvider.go

@@ -273,7 +273,7 @@ func (sdp *stakingDataProvider) GetBlsKeyOwner(blsKey []byte) (string, error) {
 		return "", err
 	}
 	if vmOutput.ReturnCode != vmcommon.Ok {
-		return "", fmt.Errorf("%w, error: %v", epochStart.ErrExecutingSystemScCode, vmOutput.ReturnCode)
+		return "", fmt.Errorf("%w, error: %v, message: %s", epochStart.ErrExecutingSystemScCode, vmOutput.ReturnCode, vmOutput.ReturnMessage)
 	}
 	data := vmOutput.ReturnData
 	if len(data) != 1 {

factory/consensus/consensusComponents.go

@@ -470,6 +470,11 @@ func (ccf *consensusComponentsFactory) createShardStorageAndSyncBootstrapper() (
 		return nil, err
 	}
 
+	validatorDBSyncer, err := ccf.createValidatorAccountsSyncer()
+	if err != nil {
+		return nil, err
+	}
+
 	stateNodesNotifierSubscriber, ok := accountsDBSyncer.(common.StateSyncNotifierSubscriber)
 	if !ok {
 		return nil, fmt.Errorf("wrong type conversion for accountsDBSyncer, type: %T", accountsDBSyncer)
@@ -508,6 +513,7 @@ func (ccf *consensusComponentsFactory) createShardStorageAndSyncBootstrapper() (
 		ScheduledTxsExecutionHandler: ccf.processComponents.ScheduledTxsExecutionHandler(),
 		ProcessWaitTime:              time.Duration(ccf.config.GeneralSettings.SyncProcessTimeInMillis) * time.Millisecond,
 		RepopulateTokensSupplies:     ccf.flagsConfig.RepopulateTokensSupplies,
+		ValidatorDBSyncer:            validatorDBSyncer,
 	}
 
 	argsShardBootstrapper := sync.ArgShardBootstrapper{

factory/epochStartTrigger/sovereignEpochStartTriggerFactory.go

@@ -3,6 +3,7 @@ package epochStartTrigger
 import (
 	"github.com/multiversx/mx-chain-go/epochStart"
 	"github.com/multiversx/mx-chain-go/epochStart/metachain"
+	"github.com/multiversx/mx-chain-go/epochStart/shardchain"
 	"github.com/multiversx/mx-chain-go/factory"
 )
 
@@ -24,7 +25,17 @@ func (f *sovereignEpochStartTriggerFactory) CreateEpochStartTrigger(args factory
 		return nil, err
 	}
 
-	return metachain.NewSovereignTrigger(metaTriggerArgs)
+	argsPeerMiniBlockSyncer := shardchain.ArgPeerMiniBlockSyncer{
+		MiniBlocksPool:     args.DataComps.Datapool().MiniBlocks(),
+		ValidatorsInfoPool: args.DataComps.Datapool().ValidatorsInfo(),
+		RequestHandler:     args.RequestHandler,
+	}
+	peerMiniBlockSyncer, err := shardchain.NewPeerMiniBlockSyncer(argsPeerMiniBlockSyncer)
+	if err != nil {
+		return nil, err
+	}
+
+	return metachain.NewSovereignTrigger(metaTriggerArgs, peerMiniBlockSyncer)
 }
 
 // IsInterfaceNil checks if the underlying pointer is nil

process/block/interceptedBlocks/interceptedMetaBlockHeader.go

@@ -56,9 +56,10 @@ func NewInterceptedMetaHeader(arg *ArgInterceptedBlockHeader) (*InterceptedMetaH
 	return inHdr, nil
 }
 
-func createMetaHdr(marshalizer marshal.Marshalizer, hdrBuff []byte) (*block.MetaBlock, error) {
-	hdr := &block.MetaBlock{
-		ShardInfo: make([]block.ShardData, 0),
+func createMetaHdr(marshalizer marshal.Marshalizer, hdrBuff []byte) (data.MetaHeaderHandler, error) {
+	hdr := &block.SovereignChainHeader{
+		//ShardInfo: make([]block.ShardData, 0),
+		Header: &block.Header{},
 	}
 	err := marshalizer.Unmarshal(hdr, hdrBuff)
 	if err != nil {
@@ -128,9 +129,9 @@ func (imh *InterceptedMetaHeader) isMetaHeaderEpochOutOfRange() bool {
 		return false
 	}
 
-	if imh.hdr.GetEpoch() > imh.epochStartTrigger.Epoch()+1 {
-		return true
-	}
+	//if imh.hdr.GetEpoch() > imh.epochStartTrigger.Epoch()+1 {
+	//	return true
+	//}
 
 	return false
 }