[staking] enable new staking index

action/protocol/context.go

@@ -123,6 +123,7 @@ type (
 		PanicUnrecoverableError                 bool
 		CandidateIdentifiedByOwner              bool
 		UseTxContainer                          bool
+		LimitedStakingContract                  bool
 	}
 
 	// FeatureWithHeightCtx provides feature check functions.
@@ -271,6 +272,7 @@ func WithFeatureCtx(ctx context.Context) context.Context {
 			PanicUnrecoverableError:                 g.IsToBeEnabled(height),
 			CandidateIdentifiedByOwner:              !g.IsToBeEnabled(height),
 			UseTxContainer:                          g.IsToBeEnabled(height),
+			LimitedStakingContract:                  !g.IsToBeEnabled(height),
 		},
 	)
 }

action/protocol/staking/handler_candidate_selfstake_test.go

@@ -78,10 +78,13 @@ func initTestStateWithHeight(t *testing.T, ctrl *gomock.Controller, bucketCfgs [
 	require.NoError(err)
 
 	// create protocol
-	p, err := NewProtocol(depositGas, &BuilderConfig{
+	p, err := NewProtocol(HelperCtx{
+		DepositGas:    depositGas,
+		BlockInterval: getBlockInterval,
+	}, &BuilderConfig{
 		Staking:                  genesis.Default.Staking,
 		PersistStakingPatchBlock: math.MaxUint64,
-	}, nil, nil, genesis.Default.GreenlandBlockHeight)
+	}, nil, nil, nil, genesis.Default.GreenlandBlockHeight)
 	require.NoError(err)
 
 	// set up bucket

action/protocol/staking/handler_candidate_transfer_ownership_test.go

@@ -30,10 +30,13 @@ func TestProtocol_HandleCandidateTransferOwnership(t *testing.T) {
 	csm, err := NewCandidateStateManager(sm, false)
 	require.NoError(err)
 	// create protocol
-	p, err := NewProtocol(depositGas, &BuilderConfig{
+	p, err := NewProtocol(HelperCtx{
+		DepositGas:    depositGas,
+		BlockInterval: getBlockInterval,
+	}, &BuilderConfig{
 		Staking:                  genesis.Default.Staking,
 		PersistStakingPatchBlock: math.MaxUint64,
-	}, nil, nil, genesis.Default.GreenlandBlockHeight)
+	}, nil, nil, nil, genesis.Default.GreenlandBlockHeight)
 	require.NoError(err)
 	initCandidateCfgs := []struct {
 		Owner      address.Address

action/protocol/staking/handlers.go

@@ -794,7 +794,7 @@ func (p *Protocol) handleCandidateRegister(ctx context.Context, act *action.Cand
 	}
 
 	// put registrationFee to reward pool
-	if _, err := p.depositGas(ctx, csm.SM(), registrationFee); err != nil {
+	if _, err := p.helperCtx.DepositGas(ctx, csm.SM(), registrationFee); err != nil {
 		return log, nil, errors.Wrap(err, "failed to deposit gas")
 	}
 

action/protocol/staking/handlers_test.go

@@ -83,10 +83,13 @@ func TestProtocol_HandleCreateStake(t *testing.T) {
 	require.NoError(err)
 
 	// create protocol
-	p, err := NewProtocol(depositGas, &BuilderConfig{
+	p, err := NewProtocol(HelperCtx{
+		DepositGas:    depositGas,
+		BlockInterval: getBlockInterval,
+	}, &BuilderConfig{
 		Staking:                  genesis.Default.Staking,
 		PersistStakingPatchBlock: math.MaxUint64,
-	}, nil, nil, genesis.Default.GreenlandBlockHeight)
+	}, nil, nil, nil, genesis.Default.GreenlandBlockHeight)
 	require.NoError(err)
 
 	// set up candidate
@@ -3212,10 +3215,13 @@ func initAll(t *testing.T, ctrl *gomock.Controller) (protocol.StateManager, *Pro
 	require.NoError(err)
 
 	// create protocol
-	p, err := NewProtocol(depositGas, &BuilderConfig{
+	p, err := NewProtocol(HelperCtx{
+		DepositGas:    depositGas,
+		BlockInterval: getBlockInterval,
+	}, &BuilderConfig{
 		Staking:                  genesis.Default.Staking,
 		PersistStakingPatchBlock: math.MaxUint64,
-	}, nil, nil, genesis.Default.GreenlandBlockHeight)
+	}, nil, nil, nil, genesis.Default.GreenlandBlockHeight)
 	require.NoError(err)
 
 	// set up candidate
@@ -3264,6 +3270,10 @@ func depositGas(ctx context.Context, sm protocol.StateManager, gasFee *big.Int)
 	return nil, accountutil.StoreAccount(sm, actionCtx.Caller, acc)
 }
 
+func getBlockInterval(height uint64) time.Duration {
+	return 5 * time.Second
+}
+
 func newconsignment(r *require.Assertions, bucketIdx, nonce uint64, senderPrivate, recipient, consignTpye, reclaim string, wrongSig bool) []byte {
 	msg := action.ConsignMsgEther{
 		BucketIdx: bucketIdx,

action/protocol/staking/protocol.go

@@ -76,13 +76,14 @@ type (
 
 	// Protocol defines the protocol of handling staking
 	Protocol struct {
-		addr                   address.Address
-		depositGas             DepositGas
-		config                 Configuration
-		candBucketsIndexer     *CandidatesBucketsIndexer
-		contractStakingIndexer ContractStakingIndexerWithBucketType
-		voteReviser            *VoteReviser
-		patch                  *PatchStore
+		addr                     address.Address
+		config                   Configuration
+		candBucketsIndexer       *CandidatesBucketsIndexer
+		contractStakingIndexer   ContractStakingIndexerWithBucketType
+		contractStakingIndexerV2 ContractStakingIndexer
+		voteReviser              *VoteReviser
+		patch                    *PatchStore
+		helperCtx                HelperCtx
 	}
 
 	// Configuration is the staking protocol configuration.
@@ -95,6 +96,11 @@ type (
 		PersistStakingPatchBlock         uint64
 		EndorsementWithdrawWaitingBlocks uint64
 	}
+	// HelperCtx is the helper context for staking protocol
+	HelperCtx struct {
+		BlockInterval func(uint64) time.Duration
+		DepositGas    DepositGas
+	}
 
 	// DepositGas deposits gas to some pool
 	DepositGas func(ctx context.Context, sm protocol.StateManager, amount *big.Int) (*action.TransactionLog, error)
@@ -118,10 +124,11 @@ func FindProtocol(registry *protocol.Registry) *Protocol {
 
 // NewProtocol instantiates the protocol of staking
 func NewProtocol(
-	depositGas DepositGas,
+	helperCtx HelperCtx,
 	cfg *BuilderConfig,
 	candBucketsIndexer *CandidatesBucketsIndexer,
 	contractStakingIndexer ContractStakingIndexerWithBucketType,
+	contractStakingIndexerV2 ContractStakingIndexer,
 	correctCandsHeight uint64,
 	reviseHeights ...uint64,
 ) (*Protocol, error) {
@@ -163,11 +170,12 @@ func NewProtocol(
 			PersistStakingPatchBlock:         cfg.PersistStakingPatchBlock,
 			EndorsementWithdrawWaitingBlocks: cfg.Staking.EndorsementWithdrawWaitingBlocks,
 		},
-		depositGas:             depositGas,
-		candBucketsIndexer:     candBucketsIndexer,
-		voteReviser:            voteReviser,
-		patch:                  NewPatchStore(cfg.StakingPatchDir),
-		contractStakingIndexer: contractStakingIndexer,
+		candBucketsIndexer:       candBucketsIndexer,
+		voteReviser:              voteReviser,
+		patch:                    NewPatchStore(cfg.StakingPatchDir),
+		contractStakingIndexer:   contractStakingIndexer,
+		helperCtx:                helperCtx,
+		contractStakingIndexerV2: contractStakingIndexerV2,
 	}, nil
 }
 
@@ -558,7 +566,14 @@ func (p *Protocol) ReadState(ctx context.Context, sr protocol.StateReader, metho
 	}
 
 	// stakeSR is the stake state reader including native and contract staking
-	stakeSR, err := newCompositeStakingStateReader(p.candBucketsIndexer, sr, p.calculateVoteWeight, p.contractStakingIndexer)
+	indexers := []ContractStakingIndexer{}
+	if p.contractStakingIndexer != nil {
+		indexers = append(indexers, p.contractStakingIndexer)
+	}
+	if p.contractStakingIndexerV2 != nil {
+		indexers = append(indexers, p.contractStakingIndexerV2)
+	}
+	stakeSR, err := newCompositeStakingStateReader(p.candBucketsIndexer, sr, p.calculateVoteWeight, indexers...)
 	if err != nil {
 		return nil, 0, err
 	}
@@ -661,7 +676,7 @@ func (p *Protocol) settleAction(
 	actionCtx := protocol.MustGetActionCtx(ctx)
 	blkCtx := protocol.MustGetBlockCtx(ctx)
 	gasFee := big.NewInt(0).Mul(actionCtx.GasPrice, big.NewInt(0).SetUint64(actionCtx.IntrinsicGas))
-	depositLog, err := p.depositGas(ctx, sm, gasFee)
+	depositLog, err := p.helperCtx.DepositGas(ctx, sm, gasFee)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to deposit gas")
 	}
@@ -703,8 +718,15 @@ func (p *Protocol) needToWriteCandsMap(ctx context.Context, height uint64) bool
 func (p *Protocol) contractStakingVotes(ctx context.Context, candidate address.Address, height uint64) (*big.Int, error) {
 	featureCtx := protocol.MustGetFeatureCtx(ctx)
 	votes := big.NewInt(0)
+	indexers := []ContractStakingIndexer{}
 	if p.contractStakingIndexer != nil && featureCtx.AddContractStakingVotes {
-		btks, err := p.contractStakingIndexer.BucketsByCandidate(candidate, height)
+		indexers = append(indexers, p.contractStakingIndexer)
+	}
+	if p.contractStakingIndexerV2 != nil && !featureCtx.LimitedStakingContract {
+		indexers = append(indexers, p.contractStakingIndexerV2)
+	}
+	for _, indexer := range indexers {
+		btks, err := indexer.BucketsByCandidate(candidate, height)
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to get BucketsByCandidate from contractStakingIndexer")
 		}

action/protocol/staking/protocol_test.go

@@ -86,10 +86,13 @@ func TestProtocol(t *testing.T) {
 	}
 
 	// test loading with no candidate in stateDB
-	stk, err := NewProtocol(nil, &BuilderConfig{
+	stk, err := NewProtocol(HelperCtx{
+		DepositGas:    nil,
+		BlockInterval: getBlockInterval,
+	}, &BuilderConfig{
 		Staking:                  genesis.Default.Staking,
 		PersistStakingPatchBlock: math.MaxUint64,
-	}, nil, nil, genesis.Default.GreenlandBlockHeight)
+	}, nil, nil, nil, genesis.Default.GreenlandBlockHeight)
 	r.NotNil(stk)
 	r.NoError(err)
 	buckets, _, err := csr.getAllBuckets()
@@ -199,10 +202,13 @@ func TestCreatePreStates(t *testing.T) {
 	require := require.New(t)
 	ctrl := gomock.NewController(t)
 	sm := testdb.NewMockStateManager(ctrl)
-	p, err := NewProtocol(nil, &BuilderConfig{
+	p, err := NewProtocol(HelperCtx{
+		DepositGas:    nil,
+		BlockInterval: getBlockInterval,
+	}, &BuilderConfig{
 		Staking:                  genesis.Default.Staking,
 		PersistStakingPatchBlock: math.MaxUint64,
-	}, nil, nil, genesis.Default.GreenlandBlockHeight, genesis.Default.GreenlandBlockHeight)
+	}, nil, nil, nil, genesis.Default.GreenlandBlockHeight, genesis.Default.GreenlandBlockHeight)
 	require.NoError(err)
 	ctx := protocol.WithBlockCtx(
 		genesis.WithGenesisContext(context.Background(), genesis.Default),
@@ -262,10 +268,13 @@ func Test_CreatePreStatesWithRegisterProtocol(t *testing.T) {
 
 	ctx := context.Background()
 	require.NoError(cbi.Start(ctx))
-	p, err := NewProtocol(nil, &BuilderConfig{
+	p, err := NewProtocol(HelperCtx{
+		DepositGas:    nil,
+		BlockInterval: getBlockInterval,
+	}, &BuilderConfig{
 		Staking:                  genesis.Default.Staking,
 		PersistStakingPatchBlock: math.MaxUint64,
-	}, cbi, nil, genesis.Default.GreenlandBlockHeight, genesis.Default.GreenlandBlockHeight)
+	}, cbi, nil, nil, genesis.Default.GreenlandBlockHeight, genesis.Default.GreenlandBlockHeight)
 	require.NoError(err)
 
 	rol := rolldpos.NewProtocol(23, 4, 3)
@@ -378,10 +387,13 @@ func Test_CreateGenesisStates(t *testing.T) {
 	ctx = protocol.WithFeatureCtx(protocol.WithFeatureWithHeightCtx(ctx))
 	for _, test := range testBootstrapCandidates {
 		cfg.BootstrapCandidates = test.BootstrapCandidate
-		p, err := NewProtocol(nil, &BuilderConfig{
+		p, err := NewProtocol(HelperCtx{
+			DepositGas:    nil,
+			BlockInterval: getBlockInterval,
+		}, &BuilderConfig{
 			Staking:                  cfg,
 			PersistStakingPatchBlock: math.MaxUint64,
-		}, nil, nil, genesis.Default.GreenlandBlockHeight)
+		}, nil, nil, nil, genesis.Default.GreenlandBlockHeight)
 		require.NoError(err)
 
 		v, err := p.Start(ctx, sm)
@@ -412,10 +424,13 @@ func TestProtocol_ActiveCandidates(t *testing.T) {
 			SelfStakingTokens: selfStake.String(),
 		},
 	}
-	p, err := NewProtocol(nil, &BuilderConfig{
+	p, err := NewProtocol(HelperCtx{
+		DepositGas:    nil,
+		BlockInterval: getBlockInterval,
+	}, &BuilderConfig{
 		Staking:                  cfg,
 		PersistStakingPatchBlock: math.MaxUint64,
-	}, nil, csIndexer, genesis.Default.GreenlandBlockHeight)
+	}, nil, csIndexer, nil, genesis.Default.GreenlandBlockHeight)
 	require.NoError(err)
 
 	blkHeight := genesis.Default.QuebecBlockHeight + 1

action/protocol/staking/validations_test.go

@@ -18,10 +18,13 @@ import (
 
 func initTestProtocol(t *testing.T) (*Protocol, []*Candidate) {
 	require := require.New(t)
-	p, err := NewProtocol(nil, &BuilderConfig{
+	p, err := NewProtocol(HelperCtx{
+		DepositGas:    nil,
+		BlockInterval: getBlockInterval,
+	}, &BuilderConfig{
 		Staking:                  genesis.Default.Staking,
 		PersistStakingPatchBlock: math.MaxUint64,
-	}, nil, nil, genesis.Default.GreenlandBlockHeight)
+	}, nil, nil, nil, genesis.Default.GreenlandBlockHeight)
 	require.NoError(err)
 
 	var cans []*Candidate

action/protocol/staking/vote_reviser_test.go

@@ -115,13 +115,17 @@ func TestVoteReviser(t *testing.T) {
 
 	// test loading with no candidate in stateDB
 	stk, err := NewProtocol(
-		nil,
+		HelperCtx{
+			DepositGas:    nil,
+			BlockInterval: getBlockInterval,
+		},
 		&BuilderConfig{
 			Staking:                  genesis.Default.Staking,
 			PersistStakingPatchBlock: math.MaxUint64,
 		},
 		nil,
 		nil,
+		nil,
 		genesis.Default.OkhotskBlockHeight,
 		genesis.Default.HawaiiBlockHeight,
 		genesis.Default.GreenlandBlockHeight,