Add GetTotalItems in CacheStorageInterface & GetBlockByHeightCacheFormat in Blocks Service

common/storage/blockState.go

@@ -75,6 +75,11 @@ func (bs *BlockStateStorage) GetAllItems(item interface{}) error {
 	return nil
 }
 
+func (bs *BlockStateStorage) GetTotalItems() int {
+	// this storage only have 1 item
+	return 1
+}
+
 func (bs *BlockStateStorage) RemoveItem(key interface{}) error {
 	return nil
 }

common/storage/mempoolBackupStorage.go

@@ -106,6 +106,13 @@ func (m *MempoolBackupStorage) GetAllItems(item interface{}) error {
 	return nil
 }
 
+func (m *MempoolBackupStorage) GetTotalItems() int {
+	m.RLock()
+	var totalItems = len(m.mempools)
+	m.RUnlock()
+	return totalItems
+}
+
 // RemoveItem remove specific item by key
 func (m *MempoolBackupStorage) RemoveItem(key interface{}) error {
 	m.Lock()

common/storage/mempoolStorage.go

@@ -84,6 +84,13 @@ func (m *MempoolCacheStorage) GetAllItems(item interface{}) error {
 	return nil
 }
 
+func (m *MempoolCacheStorage) GetTotalItems() int {
+	m.RLock()
+	var totalItems = len(m.mempoolMap)
+	m.RUnlock()
+	return totalItems
+}
+
 func (m *MempoolCacheStorage) RemoveItem(keys interface{}) error {
 	m.Lock()
 	defer m.Unlock()

common/storage/nodeAddressInfoStorage.go

@@ -144,6 +144,16 @@ func (nas *NodeAddressInfoStorage) GetAllItems(item interface{}) error {
 	return nil
 }
 
+func (nas *NodeAddressInfoStorage) GetTotalItems() int {
+	nas.RLock()
+	defer nas.RUnlock()
+	var totalItems int
+	for _, nodeIDs := range nas.nodeAddressInfoMapByAddressPort {
+		totalItems += len(nodeIDs)
+	}
+	return totalItems
+}
+
 func (nas *NodeAddressInfoStorage) RemoveItem(key interface{}) error {
 	nas.Lock()
 	defer nas.Unlock()

common/storage/nodeAdmissionTimestampStorage.go

@@ -67,6 +67,11 @@ func (ns *NodeAdmissionTimestampStorage) GetAllItems(item interface{}) error {
 	return nil
 }
 
+func (ns *NodeAdmissionTimestampStorage) GetTotalItems() int {
+	// this storage only have 1 item
+	return 1
+}
+
 func (ns *NodeAdmissionTimestampStorage) RemoveItem(key interface{}) error {
 	return nil
 }

common/storage/nodeRegistration.go

@@ -165,6 +165,13 @@ func (n *NodeRegistryCacheStorage) GetAllItems(item interface{}) error {
 	return nil
 }
 
+func (n *NodeRegistryCacheStorage) GetTotalItems() int {
+	n.RLock()
+	var totalItems = len(n.transactionalNodeRegistries)
+	n.RUnlock()
+	return totalItems
+}
+
 func (n *NodeRegistryCacheStorage) RemoveItem(idx interface{}) error {
 	n.Lock()
 	defer n.Unlock()

common/storage/nodeShardCacheStorage.go

@@ -87,6 +87,16 @@ func (n *NodeShardCacheStorage) GetAllItems(item interface{}) error {
 	return nil
 }
 
+func (n *NodeShardCacheStorage) GetTotalItems() int {
+	n.RLock()
+	defer n.RUnlock()
+	var totalItems int
+	for _, IDs := range n.shardMap.NodeShards {
+		totalItems += len(IDs)
+	}
+	return totalItems
+}
+
 func (n *NodeShardCacheStorage) RemoveItem(key interface{}) error {
 	return nil
 }

common/storage/receiptPoolCacheStorage.go

@@ -89,6 +89,13 @@ func (brs *ReceiptPoolCacheStorage) GetAllItems(items interface{}) error {
 	return nil
 }
 
+func (brs *ReceiptPoolCacheStorage) GetTotalItems() int {
+	brs.Lock()
+	var totalItems = len(brs.receipts)
+	brs.Unlock()
+	return totalItems
+}
+
 func (brs *ReceiptPoolCacheStorage) RemoveItem(_ interface{}) error {
 	return nil
 }

common/storage/receiptReminder.go

@@ -81,6 +81,14 @@ func (rs *ReceiptReminderStorage) GetAllItems(key interface{}) error {
 	}
 	return blocker.NewBlocker(blocker.ValidationErr, "WrongType key")
 }
+
+func (rs *ReceiptReminderStorage) GetTotalItems() int {
+	rs.Lock()
+	var totalItems = len(rs.reminders)
+	rs.Unlock()
+	return totalItems
+}
+
 func (rs *ReceiptReminderStorage) RemoveItem(key interface{}) error {
 	rs.Lock()
 	defer rs.Unlock()

common/storage/storage.go

@@ -10,6 +10,8 @@ type (
 		GetItem(key, item interface{}) error
 		// GetAllItems fetch all cached items
 		GetAllItems(item interface{}) error
+		// GetTotalItems fetch the number of total cached items
+		GetTotalItems() int
 		// RemoveItem remove item by providing the key(s)
 		RemoveItem(key interface{}) error
 		// GetSize return the size of storage in number of `byte`

core/service/blockCoreService.go

@@ -29,6 +29,7 @@ type (
 		PushBlock(previousBlock, block *model.Block, broadcast, persist bool) error
 		GetBlockByID(id int64, withAttachedData bool) (*model.Block, error)
 		GetBlockByHeight(uint32) (*model.Block, error)
+		GetBlockByHeightCacheFormat(uint32) (*storage.BlockCacheObject, error)
 		GetBlocksFromHeight(startHeight, limit uint32, withAttachedData bool) ([]*model.Block, error)
 		GetLastBlock() (*model.Block, error)
 		GetLastBlockCacheFormat() (*storage.BlockCacheObject, error)

core/service/blockMainService.go

@@ -1076,6 +1076,15 @@ func (bs *BlockService) GetBlockByHeight(height uint32) (*model.Block, error) {
 	return block, nil
 }
 
+func (bs *BlockService) GetBlockByHeightCacheFormat(height uint32) (*storage.BlockCacheObject, error) {
+	return commonUtils.GetBlockByHeightUseBlocksCache(
+		height,
+		bs.QueryExecutor,
+		bs.BlockQuery,
+		bs.BlocksStorage,
+	)
+}
+
 // GetGenesisBlock return the last pushed block
 func (bs *BlockService) GetGenesisBlock() (*model.Block, error) {
 	var (
@@ -1459,11 +1468,15 @@ func (bs *BlockService) ReceiveBlock(
 	if err != nil {
 		return nil, err
 	}
-
+	lastBlockCacheFormat := &storage.BlockCacheObject{
+		ID:        lastBlock.ID,
+		Height:    lastBlock.Height,
+		BlockHash: lastBlock.BlockHash,
+	}
 	// generate receipt and return as response
 	receipt, err := bs.ReceiptService.GenerateReceiptWithReminder(
 		bs.Chaintype, block.GetBlockHash(),
-		lastBlock,
+		lastBlockCacheFormat,
 		senderPublicKey,
 		nodeSecretPhrase,
 		constant.ReceiptDatumTypeBlock,

core/service/blockMainService_test.go

@@ -2967,7 +2967,7 @@ type (
 )
 
 func (*mockReceiptServiceSuccess) GenerateReceiptWithReminder(
-	chaintype.ChainType, []byte, *model.Block, []byte, string, uint32,
+	chaintype.ChainType, []byte, *storage.BlockCacheObject, []byte, string, uint32,
 ) (*model.Receipt, error) {
 	return nil, nil
 }

core/service/blockSpineService.go

@@ -4,21 +4,20 @@ import (
 	"bytes"
 	"database/sql"
 	"fmt"
-	"github.com/zoobc/zoobc-core/common/crypto"
-	"github.com/zoobc/zoobc-core/common/signaturetype"
 	"math/big"
 	"sort"
 	"sync"
 
-	"github.com/zoobc/zoobc-core/common/accounttype"
-
 	log "github.com/sirupsen/logrus"
+	"github.com/zoobc/zoobc-core/common/accounttype"
 	"github.com/zoobc/zoobc-core/common/blocker"
 	"github.com/zoobc/zoobc-core/common/chaintype"
 	"github.com/zoobc/zoobc-core/common/constant"
+	"github.com/zoobc/zoobc-core/common/crypto"
 	"github.com/zoobc/zoobc-core/common/model"
 	"github.com/zoobc/zoobc-core/common/monitoring"
 	"github.com/zoobc/zoobc-core/common/query"
+	"github.com/zoobc/zoobc-core/common/signaturetype"
 	"github.com/zoobc/zoobc-core/common/storage"
 	commonUtils "github.com/zoobc/zoobc-core/common/util"
 	"github.com/zoobc/zoobc-core/core/smith/strategy"
@@ -487,6 +486,10 @@ func (bs *BlockSpineService) GetBlockByHeight(height uint32) (*model.Block, erro
 	return block, nil
 }
 
+func (bs *BlockSpineService) GetBlockByHeightCacheFormat(height uint32) (*storage.BlockCacheObject, error) {
+	return nil, blocker.NewBlocker(blocker.AppErr, "GetBlockByHeightCacheFormat-NotImplementedYet")
+}
+
 // GetGenesisBlock return the genesis block
 func (bs *BlockSpineService) GetGenesisBlock() (*model.Block, error) {
 	var (
@@ -615,7 +618,7 @@ func (bs *BlockSpineService) GenerateBlock(
 		newReferenceBlockHeight     uint32
 	)
 	// select main block to be include in spine block
-	lastMainBlock, err := bs.MainBlockService.GetLastBlock()
+	lastMainBlock, err := bs.MainBlockService.GetLastBlockCacheFormat()
 	if err != nil {
 		return nil, err
 	}
@@ -918,7 +921,7 @@ func (bs *BlockSpineService) validateIncludedMainBlock(lastBlock, incomingBlock
 	if incomingBlock.ReferenceBlockHeight <= lastBlock.ReferenceBlockHeight {
 		return blocker.NewBlocker(blocker.ValidationErr, "InvalidReferenceBlockHeight")
 	}
-	var mainLastBlock, err = bs.MainBlockService.GetLastBlock()
+	var mainLastBlock, err = bs.MainBlockService.GetLastBlockCacheFormat()
 	if err != nil {
 		return err
 	}
@@ -928,7 +931,7 @@ func (bs *BlockSpineService) validateIncludedMainBlock(lastBlock, incomingBlock
 	}
 	var referenceBlock = mainLastBlock
 	if mainLastBlock.Height != incomingBlock.ReferenceBlockHeight {
-		referenceBlock, err = bs.MainBlockService.GetBlockByHeight(incomingBlock.ReferenceBlockHeight)
+		referenceBlock, err = bs.MainBlockService.GetBlockByHeightCacheFormat(incomingBlock.ReferenceBlockHeight)
 		if err != nil {
 			return err
 		}

core/service/blockSpineService_test.go

@@ -4,7 +4,6 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
-	"github.com/zoobc/zoobc-core/common/crypto"
 	"math/big"
 	"reflect"
 	"regexp"
@@ -15,6 +14,7 @@ import (
 	log "github.com/sirupsen/logrus"
 	"github.com/zoobc/zoobc-core/common/chaintype"
 	"github.com/zoobc/zoobc-core/common/constant"
+	"github.com/zoobc/zoobc-core/common/crypto"
 	"github.com/zoobc/zoobc-core/common/model"
 	"github.com/zoobc/zoobc-core/common/query"
 	"github.com/zoobc/zoobc-core/common/storage"
@@ -1433,8 +1433,12 @@ var (
 	}
 )
 
-func (*mockSpineGenerateblockMainBlockServiceSuccess) GetLastBlock() (*model.Block, error) {
-	return &mockGenerateBlockMainBlock, nil
+func (*mockSpineGenerateblockMainBlockServiceSuccess) GetLastBlockCacheFormat() (*storage.BlockCacheObject, error) {
+	return &storage.BlockCacheObject{
+		ID:        mockGenerateBlockMainBlock.ID,
+		Height:    mockGenerateBlockMainBlock.Height,
+		BlockHash: mockGenerateBlockMainBlock.BlockHash,
+	}, nil
 }
 
 func (*mockSpineGenerateblockMainBlockServiceSuccess) GetBlocksFromHeight(startHeight, limit uint32, withAttachedData bool) ([]*model.Block, error) {
@@ -2345,12 +2349,12 @@ type (
 	}
 )
 
-func (*mockReceiveBlockMainBlockServiceSuccess) GetBlockByHeight(uint32) (*model.Block, error) {
-	return &model.Block{}, nil
+func (*mockReceiveBlockMainBlockServiceSuccess) GetBlockByHeightCacheFormat(uint32) (*storage.BlockCacheObject, error) {
+	return &storage.BlockCacheObject{}, nil
 }
 
-func (*mockReceiveBlockMainBlockServiceSuccess) GetLastBlock() (*model.Block, error) {
-	return &model.Block{}, nil
+func (*mockReceiveBlockMainBlockServiceSuccess) GetLastBlockCacheFormat() (*storage.BlockCacheObject, error) {
+	return &storage.BlockCacheObject{}, nil
 }
 
 func TestBlockSpineService_ReceiveBlock(t *testing.T) {
@@ -2886,12 +2890,12 @@ type (
 	}
 )
 
-func (*mockValidateBlockMainBlockServiceSuccess) GetBlockByHeight(uint32) (*model.Block, error) {
-	return &model.Block{}, nil
+func (*mockValidateBlockMainBlockServiceSuccess) GetBlockByHeightCacheFormat(uint32) (*storage.BlockCacheObject, error) {
+	return &storage.BlockCacheObject{}, nil
 }
 
-func (*mockValidateBlockMainBlockServiceSuccess) GetLastBlock() (*model.Block, error) {
-	return &model.Block{}, nil
+func (*mockValidateBlockMainBlockServiceSuccess) GetLastBlockCacheFormat() (*storage.BlockCacheObject, error) {
+	return &storage.BlockCacheObject{}, nil
 }
 
 func (*mockSpineBlocksmithServiceValidateBlockSuccess) GetSortedBlocksmithsMap(*model.Block) map[string]*int64 {