store poll states to erigon db

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 {
@@ -762,3 +760,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,21 @@ 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
+	}
+}
+
 type (
 	// StateConfig is the config for accessing stateDB
 	StateConfig struct {
 		Namespace string // namespace used by state's storage
 		Key       []byte
 		Keys      [][]byte
+		Object    any // object used by state's storage
 	}
 
 	// StateOption sets parameter for access state

action/protocol/poll/blockmeta.go

@@ -12,7 +12,11 @@ import (
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
+	"github.com/iotexproject/iotex-core/v2/action/protocol"
 	"github.com/iotexproject/iotex-core/v2/action/protocol/poll/blockmetapb"
+	"github.com/iotexproject/iotex-core/v2/pkg/util/assertions"
+	"github.com/iotexproject/iotex-core/v2/state/factory/erigonstore"
+	"github.com/iotexproject/iotex-core/v2/systemcontracts"
 )
 
 // BlockMeta is a struct to store block metadata
@@ -22,6 +26,10 @@ type BlockMeta struct {
 	MintTime time.Time
 }
 
+func init() {
+	assertions.MustNoError(erigonstore.GetObjectStorageRegistry().RegisterPollBlockMeta(protocol.SystemNamespace, &BlockMeta{}))
+}
+
 // NewBlockMeta constructs new blockmeta struct with given fieldss
 func NewBlockMeta(height uint64, producer string, mintTime time.Time) *BlockMeta {
 	return &BlockMeta{
@@ -70,3 +78,17 @@ func (bm *BlockMeta) LoadProto(pb *blockmetapb.BlockMeta) error {
 	bm.MintTime = mintTime.UTC()
 	return nil
 }
+
+// Encode encodes BlockMeta into a GenericValue
+func (bm *BlockMeta) Encode() (systemcontracts.GenericValue, error) {
+	data, err := bm.Serialize()
+	if err != nil {
+		return systemcontracts.GenericValue{}, errors.Wrap(err, "failed to serialize block meta")
+	}
+	return systemcontracts.GenericValue{PrimaryData: data}, nil
+}
+
+// Decode decodes a GenericValue into BlockMeta
+func (bm *BlockMeta) Decode(data systemcontracts.GenericValue) error {
+	return bm.Deserialize(data.PrimaryData)
+}

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

action/protocol/rewarding/admin.go

@@ -13,9 +13,14 @@ import (
 	"google.golang.org/protobuf/proto"
 
 	"github.com/iotexproject/iotex-address/address"
+
 	"github.com/iotexproject/iotex-core/v2/action/protocol"
 	"github.com/iotexproject/iotex-core/v2/action/protocol/rewarding/rewardingpb"
 	"github.com/iotexproject/iotex-core/v2/blockchain/genesis"
+	"github.com/iotexproject/iotex-core/v2/pkg/util/assertions"
+	"github.com/iotexproject/iotex-core/v2/state"
+	"github.com/iotexproject/iotex-core/v2/state/factory/erigonstore"
+	"github.com/iotexproject/iotex-core/v2/systemcontracts"
 )
 
 // admin stores the admin data of the rewarding protocol
@@ -29,6 +34,14 @@ type admin struct {
 	productivityThreshold          uint64
 }
 
+func init() {
+	registry := erigonstore.GetObjectStorageRegistry()
+	assertions.MustNoError(registry.RegisterRewardingV1(state.AccountKVNamespace, &admin{}))
+	assertions.MustNoError(registry.RegisterRewardingV1(state.AccountKVNamespace, &exempt{}))
+	assertions.MustNoError(registry.RegisterRewardingV2(_v2RewardingNamespace, &admin{}))
+	assertions.MustNoError(registry.RegisterRewardingV2(_v2RewardingNamespace, &exempt{}))
+}
+
 // Serialize serializes admin state into bytes
 func (a admin) Serialize() ([]byte, error) {
 	gen := rewardingpb.Admin{
@@ -71,6 +84,20 @@ func (a *admin) Deserialize(data []byte) error {
 	return nil
 }
 
+func (a *admin) Encode() (systemcontracts.GenericValue, error) {
+	data, err := a.Serialize()
+	if err != nil {
+		return systemcontracts.GenericValue{}, err
+	}
+	return systemcontracts.GenericValue{
+		AuxiliaryData: data,
+	}, nil
+}
+
+func (a *admin) Decode(v systemcontracts.GenericValue) error {
+	return a.Deserialize(v.AuxiliaryData)
+}
+
 func (a *admin) grantFoundationBonus(epoch uint64) bool {
 	return epoch <= a.foundationBonusLastEpoch
 }
@@ -106,6 +133,20 @@ func (e *exempt) Deserialize(data []byte) error {
 	return nil
 }
 
+func (e *exempt) Encode() (systemcontracts.GenericValue, error) {
+	data, err := e.Serialize()
+	if err != nil {
+		return systemcontracts.GenericValue{}, err
+	}
+	return systemcontracts.GenericValue{
+		AuxiliaryData: data,
+	}, nil
+}
+
+func (e *exempt) Decode(v systemcontracts.GenericValue) error {
+	return e.Deserialize(v.AuxiliaryData)
+}
+
 // CreateGenesisStates initializes the rewarding protocol by setting the original admin, block and epoch reward
 func (p *Protocol) CreateGenesisStates(
 	ctx context.Context,

action/protocol/rewarding/fund.go

@@ -19,7 +19,10 @@ import (
 	"github.com/iotexproject/iotex-core/v2/action/protocol"
 	accountutil "github.com/iotexproject/iotex-core/v2/action/protocol/account/util"
 	"github.com/iotexproject/iotex-core/v2/action/protocol/rewarding/rewardingpb"
+	"github.com/iotexproject/iotex-core/v2/pkg/util/assertions"
 	"github.com/iotexproject/iotex-core/v2/state"
+	"github.com/iotexproject/iotex-core/v2/state/factory/erigonstore"
+	"github.com/iotexproject/iotex-core/v2/systemcontracts"
 )
 
 // fund stores the balance of the rewarding fund. The difference between total and available balance should be
@@ -29,6 +32,12 @@ type fund struct {
 	unclaimedBalance *big.Int
 }
 
+func init() {
+	registry := erigonstore.GetObjectStorageRegistry()
+	assertions.MustNoError(registry.RegisterRewardingV1(state.AccountKVNamespace, &fund{}))
+	assertions.MustNoError(registry.RegisterRewardingV2(_v2RewardingNamespace, &fund{}))
+}
+
 // Serialize serializes fund state into bytes
 func (f fund) Serialize() ([]byte, error) {
 	gen := rewardingpb.Fund{
@@ -57,6 +66,20 @@ func (f *fund) Deserialize(data []byte) error {
 	return nil
 }
 
+func (f *fund) Encode() (systemcontracts.GenericValue, error) {
+	data, err := f.Serialize()
+	if err != nil {
+		return systemcontracts.GenericValue{}, err
+	}
+	return systemcontracts.GenericValue{
+		AuxiliaryData: data,
+	}, nil
+}
+
+func (f *fund) Decode(v systemcontracts.GenericValue) error {
+	return f.Deserialize(v.AuxiliaryData)
+}
+
 // Deposit deposits token into the rewarding fund
 func (p *Protocol) Deposit(
 	ctx context.Context,

action/protocol/rewarding/protocol.go

@@ -28,7 +28,7 @@ import (
 const (
 	// TODO: it works only for one instance per protocol definition now
 	_protocolID           = "rewarding"
-	_v2RewardingNamespace = "Rewarding"
+	_v2RewardingNamespace = state.RewardingNamespace
 )
 
 var (
@@ -138,7 +138,7 @@ func (p *Protocol) migrateValue(sm protocol.StateManager, key []byte, value inte
 	if err := p.putStateV2(sm, key, value); err != nil {
 		return err
 	}
-	return p.deleteStateV1(sm, key)
+	return p.deleteStateV1(sm, key, value)
 }
 
 func (p *Protocol) setFoundationBonusExtension(ctx context.Context, sm protocol.StateManager) error {
@@ -359,26 +359,9 @@ func (p *Protocol) putStateV2(sm protocol.StateManager, key []byte, value interf
 	return err
 }
 
-func (p *Protocol) deleteState(ctx context.Context, sm protocol.StateManager, key []byte) error {
-	if useV2Storage(ctx) {
-		return p.deleteStateV2(sm, key)
-	}
-	return p.deleteStateV1(sm, key)
-}
-
-func (p *Protocol) deleteStateV1(sm protocol.StateManager, key []byte) error {
+func (p *Protocol) deleteStateV1(sm protocol.StateManager, key []byte, obj any) error {
 	keyHash := hash.Hash160b(append(p.keyPrefix, key...))
-	_, err := sm.DelState(protocol.LegacyKeyOption(keyHash))
-	if errors.Cause(err) == state.ErrStateNotExist {
-		// don't care if not exist
-		return nil
-	}
-	return err
-}
-
-func (p *Protocol) deleteStateV2(sm protocol.StateManager, key []byte) error {
-	k := append(p.keyPrefix, key...)
-	_, err := sm.DelState(protocol.KeyOption(k), protocol.NamespaceOption(_v2RewardingNamespace))
+	_, err := sm.DelState(protocol.LegacyKeyOption(keyHash), protocol.ObjectOption(obj))
 	if errors.Cause(err) == state.ErrStateNotExist {
 		// don't care if not exist
 		return nil