Event handler unit test

action/protocol/context.go

@@ -162,6 +162,7 @@ type (
 		NotSlashUnproductiveDelegates           bool
 		CandidateBLSPublicKey                   bool
 		NotUseMinSelfStakeToBeActive            bool
+		StoreVoteOfNFTBucketIntoView            bool
 	}
 
 	// FeatureWithHeightCtx provides feature check functions.
@@ -327,6 +328,7 @@ func WithFeatureCtx(ctx context.Context) context.Context {
 			NotSlashUnproductiveDelegates:           !g.IsToBeEnabled(height),
 			CandidateBLSPublicKey:                   g.IsToBeEnabled(height),
 			NotUseMinSelfStakeToBeActive:            !g.IsToBeEnabled(height),
+			StoreVoteOfNFTBucketIntoView:            !g.IsToBeEnabled(height),
 		},
 	)
 }

action/protocol/execution/evm/contract.go

@@ -20,11 +20,11 @@ import (
 
 const (
 	// CodeKVNameSpace is the bucket name for code
-	CodeKVNameSpace = "Code"
+	CodeKVNameSpace = state.CodeKVNameSpace
 	// ContractKVNameSpace is the bucket name for contract data storage
-	ContractKVNameSpace = "Contract"
+	ContractKVNameSpace = state.ContractKVNameSpace
 	// PreimageKVNameSpace is the bucket name for preimage data storage
-	PreimageKVNameSpace = "Preimage"
+	PreimageKVNameSpace = state.PreimageKVNameSpace
 )
 
 type (

action/protocol/execution/evm/evm.go

@@ -8,6 +8,7 @@ package evm
 import (
 	"bytes"
 	"context"
+	"encoding/hex"
 	"math"
 	"math/big"
 	"time"
@@ -326,10 +327,7 @@ func ExecuteContract(
 
 	if ps.featureCtx.SetRevertMessageToReceipt && receipt.Status == uint64(iotextypes.ReceiptStatus_ErrExecutionReverted) && retval != nil && bytes.Equal(retval[:4], _revertSelector) {
 		// in case of the execution revert error, parse the retVal and add to receipt
-		data := retval[4:]
-		msgLength := byteutil.BytesToUint64BigEndian(data[56:64])
-		revertMsg := string(data[64 : 64+msgLength])
-		receipt.SetExecutionRevertMsg(revertMsg)
+		receipt.SetExecutionRevertMsg(ExtractRevertMessage(retval))
 	}
 	log.S().Debugf("Retval: %x, Receipt: %+v, %v", retval, receipt, err)
 	if tCtx, ok := GetTracerCtx(ctx); ok && tCtx.CaptureTx != nil {
@@ -765,3 +763,17 @@ func SimulateExecution(
 	))
 	return ExecuteContract(ctx, sm, ex)
 }
+
+// ExtractRevertMessage extracts the revert message from the return value
+func ExtractRevertMessage(ret []byte) string {
+	if len(ret) < 4 {
+		return hex.EncodeToString(ret)
+	}
+	if !bytes.Equal(ret[:4], _revertSelector) {
+		return hex.EncodeToString(ret)
+	}
+	data := ret[4:]
+	msgLength := byteutil.BytesToUint64BigEndian(data[56:64])
+	revertMsg := string(data[64 : 64+msgLength])
+	return revertMsg
+}

action/protocol/managers.go

@@ -54,12 +54,30 @@ func CreateStateConfig(opts ...StateOption) (*StateConfig, error) {
 	return &cfg, nil
 }
 
+// ObjectOption sets the object for call
+func ObjectOption(obj any) StateOption {
+	return func(cfg *StateConfig) error {
+		cfg.Object = obj
+		return nil
+	}
+}
+
+// SecondaryOnlyOption sets the option to only access secondary workingset store
+func SecondaryOnlyOption() StateOption {
+	return func(cfg *StateConfig) error {
+		cfg.SecondaryOnly = true
+		return nil
+	}
+}
+
 type (
 	// StateConfig is the config for accessing stateDB
 	StateConfig struct {
-		Namespace string // namespace used by state's storage
-		Key       []byte
-		Keys      [][]byte
+		Namespace     string // namespace used by state's storage
+		Key           []byte
+		Keys          [][]byte
+		Object        any  // object used by state's storage
+		SecondaryOnly bool // only access secondary workingset store
 	}
 
 	// StateOption sets parameter for access state

action/protocol/poll/blockmeta.go

@@ -12,7 +12,12 @@ import (
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
+	"github.com/iotexproject/iotex-address/address"
+
+	"github.com/iotexproject/iotex-core/v2/action/protocol"
 	"github.com/iotexproject/iotex-core/v2/action/protocol/poll/blockmetapb"
+	"github.com/iotexproject/iotex-core/v2/state"
+	"github.com/iotexproject/iotex-core/v2/systemcontracts"
 )
 
 // BlockMeta is a struct to store block metadata
@@ -22,6 +27,8 @@ type BlockMeta struct {
 	MintTime time.Time
 }
 
+var _ state.ContractStorageStandard = (*BlockMeta)(nil)
+
 // NewBlockMeta constructs new blockmeta struct with given fieldss
 func NewBlockMeta(height uint64, producer string, mintTime time.Time) *BlockMeta {
 	return &BlockMeta{
@@ -70,3 +77,14 @@ func (bm *BlockMeta) LoadProto(pb *blockmetapb.BlockMeta) error {
 	bm.MintTime = mintTime.UTC()
 	return nil
 }
+
+func (bm *BlockMeta) ContractStorageAddress(ns string, key []byte) (address.Address, error) {
+	if ns != protocol.SystemNamespace {
+		return nil, errors.Errorf("invalid namespace %s, expected %s", ns, protocol.SystemNamespace)
+	}
+	return systemcontracts.SystemContracts[systemcontracts.PollBlockMetaContractIndex].Address, nil
+}
+
+func (bm *BlockMeta) New() state.ContractStorageStandard {
+	return &BlockMeta{}
+}

action/protocol/poll/util.go

@@ -271,7 +271,7 @@ func shiftCandidates(sm protocol.StateManager) (uint64, error) {
 	if stateHeight != putStateHeight {
 		return 0, errors.Wrap(ErrInconsistentHeight, "failed to shift candidates")
 	}
-	if delStateHeight, err = sm.DelState(protocol.KeyOption(nextKey[:]), protocol.NamespaceOption(protocol.SystemNamespace)); err != nil {
+	if delStateHeight, err = sm.DelState(protocol.KeyOption(nextKey[:]), protocol.NamespaceOption(protocol.SystemNamespace), protocol.ObjectOption(&state.CandidateList{})); err != nil {
 		return 0, errors.Wrap(
 			err,
 			"failed to delete next candidatelist after shifting",
@@ -306,7 +306,7 @@ func shiftProbationList(sm protocol.StateManager) (uint64, error) {
 	if stateHeight != putStateHeight {
 		return 0, errors.Wrap(ErrInconsistentHeight, "failed to shift candidates")
 	}
-	if delStateHeight, err = sm.DelState(protocol.KeyOption(nextKey[:]), protocol.NamespaceOption(protocol.SystemNamespace)); err != nil {
+	if delStateHeight, err = sm.DelState(protocol.KeyOption(nextKey[:]), protocol.NamespaceOption(protocol.SystemNamespace), protocol.ObjectOption(&vote.ProbationList{})); err != nil {
 		return 0, errors.Wrap(
 			err,
 			"failed to delete next probationlist after shifting",
@@ -341,6 +341,7 @@ func allBlockMetasFromDB(sr protocol.StateReader, blocksInEpoch uint64) ([]*Bloc
 		protocol.KeysOption(func() ([][]byte, error) {
 			return keys, nil
 		}),
+		protocol.ObjectOption(&BlockMeta{}),
 	)
 	if err != nil {
 		return nil, err

action/protocol/protocol.go

@@ -16,6 +16,7 @@ import (
 
 	"github.com/iotexproject/iotex-core/v2/action"
 	"github.com/iotexproject/iotex-core/v2/pkg/log"
+	"github.com/iotexproject/iotex-core/v2/state"
 )
 
 var (
@@ -27,7 +28,7 @@ var (
 
 const (
 	// SystemNamespace is the namespace to store system information such as candidates/probationList/unproductiveDelegates
-	SystemNamespace = "System"
+	SystemNamespace = state.SystemNamespace
 )
 
 // Protocol defines the protocol interfaces atop IoTeX blockchain
@@ -44,6 +45,11 @@ type Starter interface {
 	Start(context.Context, StateReader) (View, error)
 }
 
+// Viewer defines the viewer interface for the protocol
+type Viewer interface {
+	ViewAt(context.Context, StateReader) (View, error)
+}
+
 // GenesisStateCreator creates some genesis states
 type GenesisStateCreator interface {
 	CreateGenesisStates(context.Context, StateManager) error
@@ -115,19 +121,53 @@ type (
 		Fork() View
 		Snapshot() int
 		Revert(int) error
-		Commit(context.Context, StateReader) error
+		Commit(context.Context, StateManager) error
 	}
 
 	// Views stores the view for all protocols
 	Views struct {
-		vm map[string]View
+		snapshotID int
+		snapshots  map[int]map[string]int
+		vm         map[string]View
 	}
 )
 
 func NewViews() *Views {
 	return &Views{
-		vm: make(map[string]View),
+		snapshotID: 0,
+		snapshots:  make(map[int]map[string]int),
+		vm:         make(map[string]View),
+	}
+}
+
+func (views *Views) Snapshot() int {
+	views.snapshotID++
+	views.snapshots[views.snapshotID] = make(map[string]int)
+	keys := make([]string, 0, len(views.vm))
+	for key := range views.vm {
+		keys = append(keys, key)
+	}
+	for _, key := range keys {
+		views.snapshots[views.snapshotID][key] = views.vm[key].Snapshot()
+	}
+	return views.snapshotID
+}
+
+func (views *Views) Revert(id int) error {
+	if id > views.snapshotID || id < 0 {
+		return errors.Errorf("invalid snapshot id %d, max id is %d", id, views.snapshotID)
 	}
+	for k, v := range views.snapshots[id] {
+		if err := views.vm[k].Revert(v); err != nil {
+			return err
+		}
+	}
+	views.snapshotID = id
+	// clean up snapshots that are not needed anymore
+	for i := id + 1; i <= views.snapshotID; i++ {
+		delete(views.snapshots, i)
+	}
+	return nil
 }
 
 func (views *Views) Fork() *Views {
@@ -138,9 +178,9 @@ func (views *Views) Fork() *Views {
 	return fork
 }
 
-func (views *Views) Commit(ctx context.Context, sr StateReader) error {
+func (views *Views) Commit(ctx context.Context, sm StateManager) error {
 	for _, view := range views.vm {
-		if err := view.Commit(ctx, sr); err != nil {
+		if err := view.Commit(ctx, sm); err != nil {
 			return err
 		}
 	}

action/protocol/registry.go

@@ -113,3 +113,28 @@ func (r *Registry) StartAll(ctx context.Context, sr StateReader) (*Views, error)
 	}
 	return allViews, nil
 }
+
+// ViewsAt returns the views of all protocols at a specific state
+func (r *Registry) ViewsAt(ctx context.Context, sr StateReader) (*Views, error) {
+	if r == nil {
+		return nil, nil
+	}
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	allViews := NewViews()
+	for _, p := range r.all() {
+		s, ok := p.(Viewer)
+		if !ok {
+			continue
+		}
+		view, err := s.ViewAt(ctx, sr)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to start protocol %s", reflect.TypeOf(p))
+		}
+		if view == nil {
+			continue
+		}
+		allViews.Write(p.Name(), view)
+	}
+	return allViews, nil
+}