add new blockchain hooks

process/interface.go

@@ -530,6 +530,7 @@ type BlockChainHookHandler interface {
 	IsLimitedTransfer(tokenID []byte) bool
 	NumberOfShards() uint32
 	SetCurrentHeader(hdr data.HeaderHandler) error
+	SetEpochStartHeader(hdr data.HeaderHandler)
 	SaveCompiledCode(codeHash []byte, code []byte)
 	GetCompiledCode(codeHash []byte) (bool, []byte)
 	IsPayable(sndAddress []byte, recvAddress []byte) (bool, error)

process/smartContract/hooks/blockChainHook.go

@@ -804,10 +804,10 @@ func (bh *BlockChainHookImpl) SetCurrentHeader(hdr data.HeaderHandler) error {
 	defer bh.mutCurrentHdr.Unlock()
 
 	bh.currentHdr = hdr
-	return bh.updateEpochStartHeader(hdr)
+	return bh.updateEpochStartHeaderFromCurrentHeader(hdr)
 }
 
-func (bh *BlockChainHookImpl) updateEpochStartHeader(hdr data.HeaderHandler) error {
+func (bh *BlockChainHookImpl) updateEpochStartHeaderFromCurrentHeader(hdr data.HeaderHandler) error {
 	bh.mutEpochStartHdr.Lock()
 	defer bh.mutEpochStartHdr.Unlock()
 
@@ -838,6 +838,13 @@ func (bh *BlockChainHookImpl) updateEpochStartHeader(hdr data.HeaderHandler) err
 	return nil
 }
 
+func (bh *BlockChainHookImpl) SetEpochStartHeader(header data.HeaderHandler) {
+	bh.mutEpochStartHdr.Lock()
+	defer bh.mutEpochStartHdr.Unlock()
+
+	bh.epochStartHdr = header
+}
+
 // SaveCompiledCode saves the compiled code to cache and storage
 func (bh *BlockChainHookImpl) SaveCompiledCode(codeHash []byte, code []byte) {
 	bh.compiledScPool.Put(codeHash, code, len(code))

process/smartContract/scQueryService.go

@@ -34,6 +34,9 @@ var logQueryService = logger.GetOrCreate("process/smartcontract.queryService")
 // MaxGasLimitPerQuery - each unit is the equivalent of 1 nanosecond processing time
 const MaxGasLimitPerQuery = 300_000_000_000
 
+// EpochStartHdrCacheSize - the size of the cache for the EpochStartHdr
+const EpochStartHdrCacheSize = 5
+
 // SCQueryService can execute Get functions over SC to fetch stored values
 type SCQueryService struct {
 	vmContainer                process.VirtualMachinesContainer
@@ -53,6 +56,7 @@ type SCQueryService struct {
 	hasher                     hashing.Hasher
 	uint64ByteSliceConverter   typeConverters.Uint64ByteSliceConverter
 	isInHistoricalBalancesMode bool
+	epochStartHdrCache         map[uint32]data.HeaderHandler
 }
 
 // ArgsNewSCQueryService defines the arguments needed for the sc query service
@@ -105,6 +109,7 @@ func NewSCQueryService(
 		hasher:                     args.Hasher,
 		uint64ByteSliceConverter:   args.Uint64ByteSliceConverter,
 		isInHistoricalBalancesMode: args.IsInHistoricalBalancesMode,
+		epochStartHdrCache:         make(map[uint32]data.HeaderHandler, EpochStartHdrCacheSize),
 	}, nil
 }
 
@@ -207,6 +212,12 @@ func (service *SCQueryService) executeScCall(query *process.SCQuery, gasPrice ui
 			return nil, nil, err
 		}
 
+		epochStartHdr, err := service.getEpochStartBlockHdr(blockHeader.GetEpoch())
+		if err != nil {
+			return nil, nil, err
+		}
+		service.blockChainHook.SetEpochStartHeader(epochStartHdr)
+
 		err = service.blockChainHook.SetCurrentHeader(blockHeader)
 		if err != nil {
 			return nil, nil, err
@@ -322,6 +333,44 @@ func (service *SCQueryService) getBlockHeaderByHash(headerHash []byte) (data.Hea
 	return header, nil
 }
 
+func (service *SCQueryService) getEpochStartBlockHdr(epoch uint32) (data.HeaderHandler, error) {
+	if header, ok := service.epochStartHdrCache[epoch]; ok {
+		return header, nil
+	}
+
+	storer, err := service.storageService.GetStorer(dataRetriever.BlockHeaderUnit)
+	if err != nil {
+		return nil, err
+	}
+
+	identifier := core.EpochStartIdentifier(epoch)
+	headerBytes, err := storer.GetFromEpoch([]byte(identifier), epoch)
+	if err != nil {
+		return nil, err
+	}
+
+	shardId := service.shardCoordinator.SelfId()
+
+	header, err := process.UnmarshalHeader(shardId, service.marshaller, headerBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(service.epochStartHdrCache) >= EpochStartHdrCacheSize {
+		oldestEpoch := uint32(1<<32 - 1)
+		for e := range service.epochStartHdrCache {
+			if e < oldestEpoch {
+				oldestEpoch = e
+			}
+		}
+
+		delete(service.epochStartHdrCache, oldestEpoch)
+	}
+
+	service.epochStartHdrCache[epoch] = header
+	return header, nil
+}
+
 func (service *SCQueryService) getOptionalEpochByHash(hash []byte) (core.OptionalUint32, error) {
 	if !service.historyRepository.IsEnabled() {
 		return core.OptionalUint32{}, nil

process/smartContract/scQueryService_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 	"time"
 
+	"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/transaction"
@@ -412,6 +413,15 @@ func TestExecuteQuery_ShouldReceiveQueryCorrectly(t *testing.T) {
 			GetStorerCalled: func(unitType dataRetriever.UnitType) (storage.Storer, error) {
 				return &storageStubs.StorerStub{
 					GetFromEpochCalled: func(key []byte, epoch uint32) ([]byte, error) {
+						if string(key) == core.EpochStartIdentifier(epoch) {
+							hdr := &block.Header{
+								RootHash:           []byte("epoch start"),
+								EpochStartMetaHash: []byte("meta"),
+							}
+							buff, _ := argsNewSCQuery.Marshaller.Marshal(hdr)
+							return buff, nil
+						}
+
 						counter++
 						if counter > 2 {
 							return nil, fmt.Errorf("no scheduled")
@@ -469,6 +479,7 @@ func TestExecuteQuery_ShouldReceiveQueryCorrectly(t *testing.T) {
 		}
 
 		_, _, err := target.ExecuteQuery(&query)
+		assert.Nil(t, err)
 		assert.True(t, runWasCalled)
 		assert.True(t, recreateTrieFromEpochWasCalled)
 		assert.False(t, recreateTrieWasCalled)

testscommon/blockChainHookStub.go

@@ -45,6 +45,7 @@ type BlockChainHookStub struct {
 	GetSnapshotCalled                       func() int
 	RevertToSnapshotCalled                  func(snapshot int) error
 	SetCurrentHeaderCalled                  func(hdr data.HeaderHandler) error
+	SetEpochStartHeaderCalled               func(hdr data.HeaderHandler)
 	DeleteCompiledCodeCalled                func(codeHash []byte)
 	SaveNFTMetaDataToSystemAccountCalled    func(tx data.TransactionHandler) error
 	CloseCalled                             func() error
@@ -330,6 +331,13 @@ func (stub *BlockChainHookStub) SetCurrentHeader(hdr data.HeaderHandler) error {
 	return nil
 }
 
+// SetEpochStartHeader -
+func (stub *BlockChainHookStub) SetEpochStartHeader(hdr data.HeaderHandler) {
+	if stub.SetEpochStartHeaderCalled != nil {
+		stub.SetEpochStartHeaderCalled(hdr)
+	}
+}
+
 // SaveCompiledCode -
 func (stub *BlockChainHookStub) SaveCompiledCode(codeHash []byte, code []byte) {
 	if stub.SaveCompiledCodeCalled != nil {