replace stakeview with voteview

Author: envestcc

action/protocol/staking/contractstake_indexer.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/iotexproject/iotex-address/address"
+
 	"github.com/iotexproject/iotex-core/v2/action"
 	"github.com/iotexproject/iotex-core/v2/action/protocol"
 	"github.com/iotexproject/iotex-core/v2/action/protocol/staking/contractstaking"
@@ -56,6 +57,10 @@ type (
 		LoadStakeView(context.Context, protocol.StateReader) (ContractStakeView, error)
 		// CreateEventProcessor creates a new event processor
 		CreateEventProcessor(context.Context, EventHandler) EventProcessor
+		// ContractStakingBuckets returns all the contract staking buckets
+		ContractStakingBuckets() (uint64, map[uint64]*contractstaking.Bucket, error)
+
+		BucketReader
 	}
 	// ContractStakingIndexerWithBucketType defines the interface of contract staking reader with bucket type
 	ContractStakingIndexerWithBucketType interface {

action/protocol/staking/contractstake_indexer_mock.go

@@ -441,6 +441,16 @@ func (p *Protocol) CreatePreStates(ctx context.Context, sm protocol.StateManager
 		return err
 	}
 	vd := v.(*viewData)
+	indexers := []ContractStakingIndexer{}
+	if p.contractStakingIndexer != nil {
+		indexers = append(indexers, p.contractStakingIndexer)
+	}
+	if p.contractStakingIndexerV2 != nil {
+		indexers = append(indexers, p.contractStakingIndexerV2)
+	}
+	if p.contractStakingIndexerV3 != nil {
+		indexers = append(indexers, p.contractStakingIndexerV3)
+	}
 	if blkCtx.BlockHeight == g.ToBeEnabledBlockHeight {
 		handler, err := newNFTBucketEventHandler(sm, func(bucket *contractstaking.Bucket, height uint64) *big.Int {
 			vb := p.convertToVoteBucket(bucket, height)
@@ -449,14 +459,43 @@ func (p *Protocol) CreatePreStates(ctx context.Context, sm protocol.StateManager
 		if err != nil {
 			return err
 		}
-		if err := vd.contractsStake.Migrate(handler); err != nil {
+		buckets := make([]map[uint64]*contractstaking.Bucket, 3)
+		for i, indexer := range indexers {
+			h, bs, err := indexer.ContractStakingBuckets()
+			if err != nil {
+				return err
+			}
+			if h != blkCtx.BlockHeight-1 {
+				return errors.Errorf("bucket cache height %d does not match current height %d", h, blkCtx.BlockHeight-1)
+			}
+			buckets[i] = bs
+		}
+		if err := vd.contractsStake.Migrate(handler, buckets); err != nil {
 			return errors.Wrap(err, "failed to flush buckets for contract staking")
 		}
 	}
 	if featureCtx.StoreVoteOfNFTBucketIntoView {
-		if err := vd.contractsStake.CreatePreStates(ctx); err != nil {
+		brs := make([]BucketReader, len(indexers))
+		for i, indexer := range indexers {
+			brs[i] = indexer
+		}
+		if err := vd.contractsStake.CreatePreStates(ctx, brs); err != nil {
 			return err
 		}
+		if blkCtx.BlockHeight == g.WakeBlockHeight {
+			buckets := make([]map[uint64]*contractstaking.Bucket, 3)
+			for i, indexer := range indexers {
+				h, bs, err := indexer.ContractStakingBuckets()
+				if err != nil {
+					return err
+				}
+				if h != blkCtx.BlockHeight-1 {
+					return errors.Errorf("bucket cache height %d does not match current height %d", h, blkCtx.BlockHeight-1)
+				}
+				buckets[i] = bs
+			}
+			vd.contractsStake.Revise(buckets)
+		}
 	}
 
 	if p.candBucketsIndexer == nil {
@@ -741,10 +780,6 @@ func (p *Protocol) isActiveCandidate(ctx context.Context, csr CandidiateStateCom
 
 // ActiveCandidates returns all active candidates in candidate center
 func (p *Protocol) ActiveCandidates(ctx context.Context, sr protocol.StateReader, height uint64) (state.CandidateList, error) {
-	srHeight, err := sr.Height()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get StateReader height")
-	}
 	c, err := ConstructBaseView(sr)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to get ActiveCandidates")
@@ -754,20 +789,10 @@ func (p *Protocol) ActiveCandidates(ctx context.Context, sr protocol.StateReader
 	for i := range list {
 		if protocol.MustGetFeatureCtx(ctx).StoreVoteOfNFTBucketIntoView {
 			var csVotes *big.Int
-			if protocol.MustGetFeatureCtx(ctx).CreatePostActionStates {
-				csVotes, err = p.contractStakingVotesFromView(ctx, list[i].GetIdentifier(), c.BaseView())
-				if err != nil {
-					return nil, err
-				}
-			} else {
-				// specifying the height param instead of query latest from indexer directly, aims to cause error when indexer falls behind.
-				// the reason of using srHeight-1 is contract indexer is not updated before the block is committed.
-				csVotes, err = p.contractStakingVotesFromIndexer(ctx, list[i].GetIdentifier(), srHeight-1)
-				if err != nil {
-					return nil, err
-				}
+			csVotes, err = p.contractStakingVotesFromView(ctx, list[i].GetIdentifier(), c.BaseView())
+			if err != nil {
+				return nil, err
 			}
-
 			list[i].Votes.Add(list[i].Votes, csVotes)
 		}
 		active, err := p.isActiveCandidate(ctx, c, list[i])
@@ -1049,13 +1074,11 @@ func (p *Protocol) contractStakingVotesFromView(ctx context.Context, candidate a
 		views = append(views, view.contractsStake.v3)
 	}
 	for _, cv := range views {
-		btks, err := cv.BucketsByCandidate(candidate)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to get BucketsByCandidate from contractStakingIndexer")
-		}
-		for _, b := range btks {
-			votes.Add(votes, p.contractBucketVotes(featureCtx, b))
+		v := cv.CandidateStakeVotes(ctx, candidate)
+		if v == nil {
+			continue
 		}
+		votes.Add(votes, v)
 	}
 	return votes, nil
 }

action/protocol/staking/protocol.go

@@ -10,12 +10,19 @@ import (
 	"math/big"
 
 	"github.com/iotexproject/iotex-address/address"
+	"github.com/pkg/errors"
+
 	"github.com/iotexproject/iotex-core/v2/action"
 	"github.com/iotexproject/iotex-core/v2/action/protocol"
-	"github.com/pkg/errors"
+	"github.com/iotexproject/iotex-core/v2/action/protocol/staking/contractstaking"
 )
 
 type (
+	// BucketReader defines the interface to read bucket info
+	BucketReader interface {
+		DeductBucket(address.Address, uint64) (*contractstaking.Bucket, error)
+	}
+
 	// ContractStakeView is the interface for contract stake view
 	ContractStakeView interface {
 		// Wrap wraps the contract stake view
@@ -27,13 +34,15 @@ type (
 		// Commit commits the contract stake view
 		Commit(context.Context, protocol.StateManager) error
 		// CreatePreStates creates pre states for the contract stake view
-		CreatePreStates(ctx context.Context) error
+		CreatePreStates(ctx context.Context, br BucketReader) error
 		// Handle handles the receipt for the contract stake view
 		Handle(ctx context.Context, receipt *action.Receipt) error
 		// Migrate writes the bucket types and buckets to the state manager
-		Migrate(EventHandler) error
+		Migrate(EventHandler, map[uint64]*contractstaking.Bucket) error
+		// Revise updates the contract stake view with the latest bucket data
+		Revise(map[uint64]*contractstaking.Bucket)
 		// BucketsByCandidate returns the buckets by candidate address
-		BucketsByCandidate(ownerAddr address.Address) ([]*VoteBucket, error)
+		CandidateStakeVotes(ctx context.Context, id address.Address) *big.Int
 		AddBlockReceipts(ctx context.Context, receipts []*action.Receipt) error
 	}
 	// viewData is the data that need to be stored in protocol's view
@@ -126,19 +135,37 @@ func (v *viewData) Revert(snapshot int) error {
 	return nil
 }
 
-func (csv *contractStakeView) Migrate(nftHandler EventHandler) error {
+func (csv *contractStakeView) Revise(buckets []map[uint64]*contractstaking.Bucket) {
+	idx := 0
+	if csv.v1 != nil {
+		csv.v1.Revise(buckets[idx])
+		idx++
+	}
+	if csv.v2 != nil {
+		csv.v2.Revise(buckets[idx])
+		idx++
+	}
+	if csv.v3 != nil {
+		csv.v3.Revise(buckets[idx])
+	}
+}
+
+func (csv *contractStakeView) Migrate(nftHandler EventHandler, buckets []map[uint64]*contractstaking.Bucket) error {
+	idx := 0
 	if csv.v1 != nil {
-		if err := csv.v1.Migrate(nftHandler); err != nil {
+		if err := csv.v1.Migrate(nftHandler, buckets[idx]); err != nil {
 			return err
 		}
+		idx++
 	}
 	if csv.v2 != nil {
-		if err := csv.v2.Migrate(nftHandler); err != nil {
+		if err := csv.v2.Migrate(nftHandler, buckets[idx]); err != nil {
 			return err
 		}
+		idx++
 	}
 	if csv.v3 != nil {
-		if err := csv.v3.Migrate(nftHandler); err != nil {
+		if err := csv.v3.Migrate(nftHandler, buckets[idx]); err != nil {
 			return err
 		}
 	}
@@ -179,19 +206,22 @@ func (csv *contractStakeView) Fork() *contractStakeView {
 	return clone
 }
 
-func (csv *contractStakeView) CreatePreStates(ctx context.Context) error {
+func (csv *contractStakeView) CreatePreStates(ctx context.Context, brs []BucketReader) error {
+	idx := 0
 	if csv.v1 != nil {
-		if err := csv.v1.CreatePreStates(ctx); err != nil {
+		if err := csv.v1.CreatePreStates(ctx, brs[idx]); err != nil {
 			return err
 		}
+		idx++
 	}
 	if csv.v2 != nil {
-		if err := csv.v2.CreatePreStates(ctx); err != nil {
+		if err := csv.v2.CreatePreStates(ctx, brs[idx]); err != nil {
 			return err
 		}
+		idx++
 	}
 	if csv.v3 != nil {
-		if err := csv.v3.CreatePreStates(ctx); err != nil {
+		if err := csv.v3.CreatePreStates(ctx, brs[idx]); err != nil {
 			return err
 		}
 	}

action/protocol/staking/viewdata.go

@@ -7,6 +7,7 @@ package contractstaking
 
 import (
 	"github.com/iotexproject/iotex-core/v2/action/protocol/staking"
+	"github.com/iotexproject/iotex-core/v2/action/protocol/staking/contractstaking"
 )
 
 // Bucket defines the bucket struct for contract staking
@@ -31,3 +32,28 @@ func assembleBucket(token uint64, bi *bucketInfo, bt *BucketType, contractAddr s
 	}
 	return &vb
 }
+
+func assembleContractBucket(bi *bucketInfo, bt *BucketType) *contractstaking.Bucket {
+	return &contractstaking.Bucket{
+		Candidate:      bi.Delegate,
+		Owner:          bi.Owner,
+		StakedAmount:   bt.Amount,
+		StakedDuration: bt.Duration,
+		CreatedAt:      bi.CreatedAt,
+		UnlockedAt:     bi.UnlockedAt,
+		UnstakedAt:     bi.UnstakedAt,
+	}
+}
+
+func contractBucketToVoteBucket(token uint64, b *contractstaking.Bucket, contractAddr string, blocksToDurationFn blocksDurationFn) *Bucket {
+	return assembleBucket(token, &bucketInfo{
+		Owner:      b.Owner,
+		Delegate:   b.Candidate,
+		CreatedAt:  b.CreatedAt,
+		UnlockedAt: b.UnlockedAt,
+		UnstakedAt: b.UnstakedAt,
+	}, &BucketType{
+		Amount:   b.StakedAmount,
+		Duration: b.StakedDuration,
+	}, contractAddr, blocksToDurationFn)
+}

blockindex/contractstaking/bucket.go

@@ -0,0 +1,23 @@
+package contractstaking
+
+import (
+	"context"
+
+	"github.com/iotexproject/iotex-address/address"
+
+	"github.com/iotexproject/iotex-core/v2/action/protocol/staking"
+)
+
+type eventProcessorBuilder struct {
+	contractAddr address.Address
+}
+
+func newEventProcessorBuilder(contractAddr address.Address) *eventProcessorBuilder {
+	return &eventProcessorBuilder{
+		contractAddr: contractAddr,
+	}
+}
+
+func (b *eventProcessorBuilder) Build(ctx context.Context, handler staking.EventHandler) staking.EventProcessor {
+	return newContractStakingEventProcessor(b.contractAddr, handler)
+}