Deep VM queries: deep-history observer vs. regular observer

factory/api/apiResolverFactory.go

@@ -461,6 +461,7 @@ func createScQueryElement(
 		Marshaller:               args.coreComponents.InternalMarshalizer(),
 		Hasher:                   args.coreComponents.Hasher(),
 		Uint64ByteSliceConverter: args.coreComponents.Uint64ByteSliceConverter(),
+		IsInSnapshottingMode:     args.generalConfig.StateTriesConfig.SnapshotsEnabled,
 	}
 
 	return smartContract.NewSCQueryService(argsNewSCQueryService)

process/smartContract/scQueryService.go

@@ -33,7 +33,6 @@
 
 // MaxGasLimitPerQuery - each unit is the equivalent of 1 nanosecond processing time
 const MaxGasLimitPerQuery = 300_000_000_000
-const epochDifferenceToConsiderHistory = 2
 
 // SCQueryService can execute Get functions over SC to fetch stored values
 type SCQueryService struct {
@@ -53,6 +52,8 @@
 	marshaller               marshal.Marshalizer
 	hasher                   hashing.Hasher
 	uint64ByteSliceConverter typeConverters.Uint64ByteSliceConverter
+	latestQueriedEpoch       core.OptionalUint32
+	isInSnapshottingMode     bool
 }
 
 // ArgsNewSCQueryService defines the arguments needed for the sc query service
@@ -72,6 +73,7 @@
 	Marshaller               marshal.Marshalizer
 	Hasher                   hashing.Hasher
 	Uint64ByteSliceConverter typeConverters.Uint64ByteSliceConverter
+	IsInSnapshottingMode     bool
 }
 
 // NewSCQueryService returns a new instance of SCQueryService
@@ -103,6 +105,8 @@
 		marshaller:               args.Marshaller,
 		hasher:                   args.Hasher,
 		uint64ByteSliceConverter: args.Uint64ByteSliceConverter,
+		latestQueriedEpoch:       core.OptionalUint32{},
+		isInSnapshottingMode:     args.IsInSnapshottingMode,
 	}, nil
 }
 
@@ -255,14 +259,42 @@
 	}
 
 	accountsAdapter := service.blockChainHook.GetAccountsAdapter()
-	if blockHeader.GetEpoch()+epochDifferenceToConsiderHistory >= service.getCurrentEpoch() {
-		logQueryService.Trace("calling RecreateTrie, for recent history", "block", blockHeader.GetNonce(), "rootHash", blockRootHash)
-		return accountsAdapter.RecreateTrie(blockRootHash)
+
+	if service.shouldCallRecreateTrieWithoutEpoch(blockHeader.GetEpoch()) {
+		logQueryService.Trace("calling RecreateTrie", "block", blockHeader.GetNonce(), "rootHash", blockRootHash)
+
+		err := accountsAdapter.RecreateTrie(blockRootHash)
+		if err != nil {
+			return err
+		}
+
+		service.rememberQueriedEpoch(blockHeader.GetEpoch())
+		return nil
 	}
 
-	logQueryService.Trace("calling RecreateTrieFromEpoch, for older history", "block", blockHeader.GetNonce(), "rootHash", blockRootHash)
+	logQueryService.Trace("calling RecreateTrieFromEpoch", "block", blockHeader.GetNonce(), "rootHash", blockRootHash)
 	holder := holders.NewRootHashHolder(blockRootHash, core.OptionalUint32{Value: blockHeader.GetEpoch(), HasValue: true})
-	return accountsAdapter.RecreateTrieFromEpoch(holder)
+
+	err := accountsAdapter.RecreateTrieFromEpoch(holder)
+	if err != nil {
+		return err
+	}
+
+	service.rememberQueriedEpoch(blockHeader.GetEpoch())
+	return nil
+}
+
+func (service *SCQueryService) shouldCallRecreateTrieWithoutEpoch(epochInQuestion uint32) bool {
+	if !service.isInSnapshottingMode {
+		// for snapshotless operation, we need to force this method to return true so the RecreateTrie will be called instead of RecreateTrieFromEpoch
+		return true
+	}
+
+	return service.latestQueriedEpoch.HasValue && service.latestQueriedEpoch.Value == epochInQuestion
+}
+
+func (service *SCQueryService) rememberQueriedEpoch(epoch uint32) {
+	service.latestQueriedEpoch = core.OptionalUint32{Value: epoch, HasValue: true}
 }
 
 func (service *SCQueryService) getCurrentEpoch() uint32 {