store candidate votes in erigondb

Author: envestcc

blockindex/contractstaking/indexer.go

@@ -132,7 +132,8 @@ func (s *Indexer) LoadStakeView(ctx context.Context, sr protocol.StateReader) (s
 	})
 	processorBuilder := newEventProcessorBuilder(s.contractAddr)
 	cfg := &stakingindex.VoteViewConfig{ContractAddr: s.contractAddr}
-	return stakingindex.NewVoteView(s, cfg, s.height, cur, processorBuilder, calculateUnmutedVoteWeightAt), nil
+	mgr := stakingindex.NewCandidateVotesManager(s.ContractAddress())
+	return stakingindex.NewVoteView(s, cfg, s.height, cur, processorBuilder, mgr, calculateUnmutedVoteWeightAt), nil
 }
 
 // Stop stops the indexer

state/factory/erigonstore/registry.go

@@ -37,6 +37,7 @@ func init() {
 	assertions.MustNoError(storageRegistry.RegisterNamespace(state.CandidateNamespace, CandidatesContractIndex))
 	assertions.MustNoError(storageRegistry.RegisterNamespace(state.CandsMapNamespace, CandidateMapContractIndex))
 	assertions.MustNoError(storageRegistry.RegisterNamespace(state.StakingNamespace, BucketPoolContractIndex))
+	assertions.MustNoError(storageRegistry.RegisterNamespace(state.StakingViewNamespace, StakingViewContractIndex))
 
 	assertions.MustNoError(storageRegistry.RegisterObjectStorage(state.AccountKVNamespace, &state.Account{}, AccountIndex))
 	assertions.MustNoError(storageRegistry.RegisterObjectStorage(state.AccountKVNamespace, &state.CandidateList{}, PollLegacyCandidateListContractIndex))

state/factory/statedb.go

@@ -8,6 +8,7 @@ package factory
 import (
 	"context"
 	"fmt"
+	"slices"
 	"strconv"
 	"sync"
 	"time"
@@ -567,15 +568,22 @@ func (sdb *stateDB) flusherOptions(preEaster bool) []db.KVStoreFlusherOption {
 			return wi.Serialize()
 		}),
 	}
-	if !preEaster {
-		return opts
+	serializeFilterNs := []string{state.StakingViewNamespace}
+	if preEaster {
+		serializeFilterNs = append(serializeFilterNs, evm.CodeKVNameSpace, staking.CandsMapNS)
 	}
-	return append(
-		opts,
+	opts = append(opts,
+		db.FlushTranslateOption(func(wi *batch.WriteInfo) *batch.WriteInfo {
+			if wi.Namespace() == state.StakingViewNamespace {
+				return nil
+			}
+			return wi
+		}),
 		db.SerializeFilterOption(func(wi *batch.WriteInfo) bool {
-			return wi.Namespace() == evm.CodeKVNameSpace || wi.Namespace() == staking.CandsMapNS
+			return slices.Contains(serializeFilterNs, wi.Namespace())
 		}),
 	)
+	return opts
 }
 
 func (sdb *stateDB) state(h uint64, ns string, addr []byte, s interface{}) error {

state/tables.go

@@ -38,6 +38,10 @@ const (
 	//   - "4" + <bucketID> --> Endorsement
 	StakingNamespace = "Staking"
 
+	// StakingViewNamespace is the namespace to store staking view information
+	//   - "voteview" + <contractAddress> --> CandidateVotes
+	StakingViewNamespace = "StakingView"
+
 	// CandidateNamespace is the namespace to store candidate information
 	//   - <ID> --> Candidate
 	CandidateNamespace = "Candidate"

systemcontractindex/stakingindex/candidate_votes.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/iotexproject/iotex-core/v2/action/protocol"
 	"github.com/iotexproject/iotex-core/v2/systemcontractindex/stakingindex/stakingpb"
+	"github.com/iotexproject/iotex-core/v2/systemcontracts"
 )
 
 // CandidateVotes is the interface to manage candidate votes
@@ -125,6 +126,18 @@ func (cv *candidateVotes) Deserialize(data []byte) error {
 	return nil
 }
 
+func (cv *candidateVotes) Encode() (systemcontracts.GenericValue, error) {
+	data, err := cv.Serialize()
+	if err != nil {
+		return systemcontracts.GenericValue{}, err
+	}
+	return systemcontracts.GenericValue{PrimaryData: data}, nil
+}
+
+func (cv *candidateVotes) Decode(data systemcontracts.GenericValue) error {
+	return cv.Deserialize(data.PrimaryData)
+}
+
 func (cv *candidateVotes) Commit() CandidateVotes {
 	return cv
 }

systemcontractindex/stakingindex/candidate_votes_manager.go

@@ -0,0 +1,60 @@
+package stakingindex
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+
+	"github.com/iotexproject/iotex-address/address"
+
+	"github.com/iotexproject/iotex-core/v2/action/protocol"
+	"github.com/iotexproject/iotex-core/v2/state"
+)
+
+var (
+	voteViewKeyPrefix = []byte("voteview")
+	voteViewNS        = state.StakingViewNamespace
+)
+
+// CandidateVotesManager defines the interface to manage candidate votes
+type CandidateVotesManager interface {
+	Load(ctx context.Context, sr protocol.StateReader) (CandidateVotes, error)
+	Store(ctx context.Context, sm protocol.StateManager, candVotes CandidateVotes) error
+}
+
+type candidateVotesManager struct {
+	contractAddr address.Address
+}
+
+// NewCandidateVotesManager creates a new instance of CandidateVotesManager
+func NewCandidateVotesManager(contractAddr address.Address) CandidateVotesManager {
+	return &candidateVotesManager{
+		contractAddr: contractAddr,
+	}
+}
+
+func (s *candidateVotesManager) Store(ctx context.Context, sm protocol.StateManager, candVotes CandidateVotes) error {
+	if _, err := sm.PutState(candVotes,
+		protocol.KeyOption(s.key()),
+		protocol.NamespaceOption(voteViewNS),
+	); err != nil {
+		return errors.Wrap(err, "failed to put candidate votes state")
+	}
+	return nil
+}
+
+func (s *candidateVotesManager) Load(ctx context.Context, sr protocol.StateReader) (CandidateVotes, error) {
+	cur := newCandidateVotes()
+	_, err := sr.State(cur,
+		protocol.KeyOption(s.key()),
+		protocol.NamespaceOption(voteViewNS),
+	)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to get candidate votes state")
+	}
+	return cur, nil
+}
+
+func (s *candidateVotesManager) key() []byte {
+	return append(voteViewKeyPrefix, s.contractAddr.Bytes()...)
+}

systemcontractindex/stakingindex/index.go

@@ -176,8 +176,9 @@ func (s *Indexer) LoadStakeView(ctx context.Context, sr protocol.StateReader) (s
 	cfg := &VoteViewConfig{
 		ContractAddr: s.common.ContractAddress(),
 	}
+	mgr := NewCandidateVotesManager(s.ContractAddress())
 	processorBuilder := newEventProcessorBuilder(s.common.ContractAddress(), s.timestamped, s.muteHeight)
-	return NewVoteView(s, cfg, s.common.Height(), s.createCandidateVotes(s.cache.buckets), processorBuilder, s.calculateContractVoteWeight), nil
+	return NewVoteView(s, cfg, s.common.Height(), s.createCandidateVotes(s.cache.buckets), processorBuilder, mgr, s.calculateContractVoteWeight), nil
 }
 
 // ContractStakingBuckets returns all the contract staking buckets

systemcontractindex/stakingindex/voteview.go

@@ -30,6 +30,7 @@ type (
 		height                uint64
 		cur                   CandidateVotes
 		store                 BucketStore
+		cvm                   CandidateVotesManager
 		processorBuilder      EventProcessorBuilder
 		calculateVoteWeightFn CalculateUnmutedVoteWeightAtFn
 	}
@@ -42,6 +43,7 @@ func NewVoteView(
 	height uint64,
 	cur CandidateVotes,
 	processorBuilder EventProcessorBuilder,
+	cvm CandidateVotesManager,
 	fn CalculateUnmutedVoteWeightAtFn,
 ) staking.ContractStakeView {
 	return &voteView{
@@ -50,6 +52,7 @@ func NewVoteView(
 		height:                height,
 		cur:                   cur,
 		processorBuilder:      processorBuilder,
+		cvm:                   cvm,
 		calculateVoteWeightFn: fn,
 	}
 }
@@ -71,6 +74,7 @@ func (s *voteView) Wrap() staking.ContractStakeView {
 		cur:                   cur,
 		store:                 store,
 		processorBuilder:      s.processorBuilder,
+		cvm:                   s.cvm,
 		calculateVoteWeightFn: s.calculateVoteWeightFn,
 	}
 }
@@ -88,6 +92,7 @@ func (s *voteView) Fork() staking.ContractStakeView {
 		cur:                   cur,
 		store:                 store,
 		processorBuilder:      s.processorBuilder,
+		cvm:                   s.cvm,
 		calculateVoteWeightFn: s.calculateVoteWeightFn,
 	}
 }
@@ -167,5 +172,5 @@ func (s *voteView) AddBlockReceipts(ctx context.Context, receipts []*action.Rece
 
 func (s *voteView) Commit(ctx context.Context, sm protocol.StateManager) error {
 	s.cur = s.cur.Commit()
-	return nil
+	return s.cvm.Store(ctx, sm, s.cur)
 }