Merge branch 'master' into dev_hdwallet_create

Makefile

@@ -99,6 +99,7 @@ build-staterecoverer:
 .PHONY: fmt
 fmt:
  $(GOCMD) fmt ./...
+ $(GOCMD) mod tidy
 
 .PHONY: lint
 lint:

api/grpcserver.go

@@ -79,7 +79,7 @@ var (
  Name: "iotex_apicallsource_nochainid_metrics",
  Help: "API call Source Without ChainID Statistics",
  },
- []string{"client_ip", "sender", "recipient"},
+ []string{"client_ip", "sender"},
  )
 )
 
@@ -336,19 +336,17 @@ func (svr *GRPCServer) SendAction(ctx context.Context, in *iotexapi.SendActionRe
  if in.GetAction().GetCore().GetChainID() > 0 {
  _apiCallSourceWithChainIDMtc.WithLabelValues(chainID).Inc()
  } else {
- var clientIP, sender, recipient string
- selp, err := (&action.Deserializer{}).ActionToSealedEnvelope(in.GetAction())
+ selp, err := (&action.Deserializer{}).SetEvmNetworkID(svr.coreService.EVMNetworkID()).ActionToSealedEnvelope(in.GetAction())
  if err != nil {
  return nil, err
  }
+ var clientIP string
  if p, ok := peer.FromContext(ctx); ok {
  clientIP, _, _ = net.SplitHostPort(p.Addr.String())
+ } else {
+ clientIP = "unknownIP"
  }
- if senderAddr, err := address.FromBytes(selp.SrcPubkey().Hash()); err == nil {
- sender = senderAddr.String()
- }
- recipient, _ = selp.Destination()
- _apiCallSourceWithOutChainIDMtc.WithLabelValues(clientIP, sender, recipient).Inc()
+ _apiCallSourceWithOutChainIDMtc.WithLabelValues(clientIP, selp.SenderAddress().String()).Inc()
  }
  actHash, err := svr.coreService.SendAction(ctx, in.GetAction())
  if err != nil {
@@ -690,7 +688,7 @@ func (svr *GRPCServer) TraceTransactionStructLogs(ctx context.Context, in *iotex
  if err != nil {
  return nil, err
  }
- act, err := (&action.Deserializer{}).ActionToSealedEnvelope(actInfo.Action)
+ act, err := (&action.Deserializer{}).SetEvmNetworkID(svr.coreService.EVMNetworkID()).ActionToSealedEnvelope(actInfo.Action)
  if err != nil {
  return nil, err
  }

api/grpcserver_test.go

@@ -67,6 +67,7 @@ func TestGrpcServer_SendAction(t *testing.T) {
  grpcSvr := NewGRPCServer(core, testutil.RandomPort())
 
  for _, test := range _sendActionTests {
+ core.EXPECT().EVMNetworkID().Return(uint32(1))
  core.EXPECT().SendAction(context.Background(), test.actionPb).Return(test.actionHash, nil)
  request := &iotexapi.SendActionRequest{Action: test.actionPb}
  res, err := grpcSvr.SendAction(context.Background(), request)

blockchain/block/block_deserializer.go

@@ -26,6 +26,13 @@ type Deserializer struct {
  evmNetworkID uint32
 }
 
+// NewDeserializer creates a new deserializer
+func NewDeserializer(evmNetworkID uint32) *Deserializer {
+ return &Deserializer{
+ evmNetworkID: evmNetworkID,
+ }
+}
+
 // SetEvmNetworkID sets the evm network ID for web3 actions
 func (bd *Deserializer) SetEvmNetworkID(id uint32) *Deserializer {
  bd.evmNetworkID = id
@@ -92,3 +99,33 @@ func (bd *Deserializer) DeserializeBody(buf []byte) (*Body, error) {
  }
  return &b, nil
 }
+
+// FromBlockStoreProto converts protobuf to block store
+func (bd *Deserializer) FromBlockStoreProto(pb *iotextypes.BlockStore) (*Store, error) {
+ in := &Store{}
+ blk, err := bd.FromBlockProto(pb.Block)
+ if err != nil {
+ return nil, err
+ }
+ // verify merkle root can match after deserialize
+ if err := blk.VerifyTxRoot(); err != nil {
+ return nil, err
+ }
+
+ in.Block = blk
+ for _, receiptPb := range pb.Receipts {
+ receipt := &action.Receipt{}
+ receipt.ConvertFromReceiptPb(receiptPb)
+ in.Receipts = append(in.Receipts, receipt)
+ }
+ return in, nil
+}
+
+// DeserializeBlockStore de-serializes a block store
+func (bd *Deserializer) DeserializeBlockStore(buf []byte) (*Store, error) {
+ pb := iotextypes.BlockStore{}
+ if err := proto.Unmarshal(buf, &pb); err != nil {
+ return nil, errors.Wrap(err, "failed to unmarshal block store")
+ }
+ return bd.FromBlockStoreProto(&pb)
+}

blockchain/block/block_deserializer_test.go

@@ -35,3 +35,21 @@ func TestBlockDeserializer(t *testing.T) {
  r.Equal(_pbBlock.Body.Actions[0].Core.ChainID, blk.Actions[0].ChainID())
  r.Equal(_pbBlock.Body.Actions[1].Core.ChainID, blk.Actions[1].ChainID())
 }
+
+func TestBlockStoreDeserializer(t *testing.T) {
+ require := require.New(t)
+ store, err := makeStore()
+ require.NoError(err)
+
+ storeProto := store.ToProto()
+
+ require.NotNil(storeProto)
+
+ bd := Deserializer{}
+ store1, err := bd.FromBlockStoreProto(storeProto)
+ require.NoError(err)
+
+ require.Equal(store1.Block.height, store.Block.height)
+ require.Equal(store1.Block.Header.prevBlockHash, store.Block.Header.prevBlockHash)
+ require.Equal(store1.Block.Header.blockSig, store.Block.Header.blockSig)
+}

blockchain/block/blockstore.go

@@ -12,7 +12,6 @@ import (
  "github.com/iotexproject/iotex-proto/golang/iotextypes"
 
  "github.com/iotexproject/iotex-core/action"
- "github.com/iotexproject/iotex-core/config"
 )
 
 type (
@@ -40,37 +39,6 @@ func (in *Store) ToProto() *iotextypes.BlockStore {
  }
 }
 
-// FromProto converts from proto message
-func (in *Store) FromProto(pb *iotextypes.BlockStore) error {
- // TODO: pass the correct EVM network ID at the time of newFileDAOv2()
- blk, err := (&Deserializer{}).SetEvmNetworkID(config.EVMNetworkID()).FromBlockProto(pb.Block)
- if err != nil {
- return err
- }
- // verify merkle root can match after deserialize
- if err := blk.VerifyTxRoot(); err != nil {
- return err
- }
-
- in.Block = blk
- in.Receipts = []*action.Receipt{}
- for _, receiptPb := range pb.Receipts {
- receipt := &action.Receipt{}
- receipt.ConvertFromReceiptPb(receiptPb)
- in.Receipts = append(in.Receipts, receipt)
- }
- return nil
-}
-
-// Deserialize parses the byte stream into Store
-func (in *Store) Deserialize(buf []byte) error {
- pbStore := &iotextypes.BlockStore{}
- if err := proto.Unmarshal(buf, pbStore); err != nil {
- return err
- }
- return in.FromProto(pbStore)
-}
-
 // DeserializeBlockStoresPb decode byte stream into BlockStores pb message
 func DeserializeBlockStoresPb(buf []byte) (*iotextypes.BlockStores, error) {
  pbStores := &iotextypes.BlockStores{}

blockchain/block/blockstore_test.go

@@ -28,22 +28,6 @@ func TestStoreProto(t *testing.T) {
  require.NotNil(storeProto)
  require.Equal(0, len(storeProto.Receipts))
 
- require.NoError(store.FromProto(storeProto))
-}
-
-func TestSerialize(t *testing.T) {
- require := require.New(t)
- store, err := makeStore()
- require.NoError(err)
-
- ser, err := store.Serialize()
- require.NoError(err)
-
- store1 := &Store{}
- require.NoError(store1.Deserialize(ser))
- require.Equal(store1.Block.height, store.Block.height)
- require.Equal(store1.Block.Header.prevBlockHash, store.Block.Header.prevBlockHash)
- require.Equal(store1.Block.Header.blockSig, store.Block.Header.blockSig)
 }
 
 func makeStore() (*Store, error) {

blockchain/blockdao/blockdao.go

@@ -60,8 +60,8 @@ type (
 )
 
 // NewBlockDAO instantiates a block DAO
-func NewBlockDAO(indexers []BlockIndexer, cfg db.Config) BlockDAO {
- blkStore, err := filedao.NewFileDAO(cfg)
+func NewBlockDAO(indexers []BlockIndexer, cfg db.Config, deser *block.Deserializer) BlockDAO {
+ blkStore, err := filedao.NewFileDAO(cfg, deser)
  if err != nil {
  log.L().Fatal(err.Error(), zap.Any("cfg", cfg))
  return nil

blockchain/blockdao/blockdao_test.go

@@ -441,17 +441,17 @@ func createTestBlockDAO(inMemory, legacy bool, compressBlock string, cfg db.Conf
  if inMemory {
  return NewBlockDAOInMemForTest(nil), nil
  }
-
+ deser := block.NewDeserializer(config.Default.Chain.EVMNetworkID)
  if legacy {
- fileDAO, err := filedao.CreateFileDAO(true, cfg)
+ fileDAO, err := filedao.CreateFileDAO(true, cfg, deser)
  if err != nil {
  return nil, err
  }
  return createBlockDAO(fileDAO, nil, cfg), nil
  }
 
  cfg.Compressor = compressBlock
- return NewBlockDAO(nil, cfg), nil
+ return NewBlockDAO(nil, cfg, deser), nil
 }
 
 func BenchmarkBlockCache(b *testing.B) {
@@ -472,7 +472,8 @@ func BenchmarkBlockCache(b *testing.B) {
  cfg.DbPath = indexPath
  cfg.DbPath = testPath
  cfg.MaxCacheSize = cacheSize
- blkDao := NewBlockDAO([]BlockIndexer{}, cfg)
+ deser := block.NewDeserializer(config.Default.Chain.EVMNetworkID)
+ blkDao := NewBlockDAO([]BlockIndexer{}, cfg, deser)
  require.NoError(b, blkDao.Start(context.Background()))
  defer func() {
  require.NoError(b, blkDao.Stop(context.Background()))

blockchain/filedao/filedao.go

@@ -72,25 +72,26 @@ type (
 
  // fileDAO implements FileDAO
  fileDAO struct {
- lock sync.Mutex
- topIndex uint64
- splitHeight uint64
- cfg db.Config
- currFd BaseFileDAO
- legacyFd FileDAO
- v2Fd *FileV2Manager // a collection of v2 db files
+ lock sync.Mutex
+ topIndex uint64
+ splitHeight uint64
+ cfg db.Config
+ currFd BaseFileDAO
+ legacyFd FileDAO
+ v2Fd *FileV2Manager // a collection of v2 db files
+ blockDeserializer *block.Deserializer
  }
 )
 
 // NewFileDAO creates an instance of FileDAO
-func NewFileDAO(cfg db.Config) (FileDAO, error) {
+func NewFileDAO(cfg db.Config, deser *block.Deserializer) (FileDAO, error) {
  header, err := readFileHeader(cfg.DbPath, FileAll)
  if err != nil {
  if err != ErrFileNotExist {
  return nil, err
  }
  // start new chain db using v2 format
- if err := createNewV2File(1, cfg); err != nil {
+ if err := createNewV2File(1, cfg, deser); err != nil {
  return nil, err
  }
  header = &FileHeader{Version: FileV2}
@@ -102,10 +103,10 @@ func NewFileDAO(cfg db.Config) (FileDAO, error) {
  return nil, ErrFileInvalid
  case FileLegacyMaster:
  // master file is legacy format
- return CreateFileDAO(true, cfg)
+ return CreateFileDAO(true, cfg, deser)
  case FileV2:
  // master file is v2 format
- return CreateFileDAO(false, cfg)
+ return CreateFileDAO(false, cfg, deser)
  default:
  panic(fmt.Errorf("corrupted file version: %s", header.Version))
  }
@@ -333,7 +334,7 @@ func (fd *fileDAO) addNewV2File(height uint64) error {
  // create a new v2 file
  cfg := fd.cfg
  cfg.DbPath = kthAuxFileName(cfg.DbPath, fd.topIndex+1)
- v2, err := newFileDAOv2(height, cfg)
+ v2, err := newFileDAOv2(height, cfg, fd.blockDeserializer)
  if err != nil {
  return err
  }
@@ -367,12 +368,12 @@ func (fd *fileDAO) DeleteTipBlock() error {
 }
 
 // CreateFileDAO creates FileDAO according to master file
-func CreateFileDAO(legacy bool, cfg db.Config) (FileDAO, error) {
- fd := fileDAO{splitHeight: 1, cfg: cfg}
+func CreateFileDAO(legacy bool, cfg db.Config, deser *block.Deserializer) (FileDAO, error) {
+ fd := fileDAO{splitHeight: 1, cfg: cfg, blockDeserializer: deser}
  fds := []*fileDAOv2{}
  v2Top, v2Files := checkAuxFiles(cfg.DbPath, FileV2)
  if legacy {
- legacyFd, err := newFileDAOLegacy(cfg)
+ legacyFd, err := newFileDAOLegacy(cfg, deser)
  if err != nil {
  return nil, err
  }
@@ -385,14 +386,14 @@ func CreateFileDAO(legacy bool, cfg db.Config) (FileDAO, error) {
  }
  } else {
  // v2 master file
- fds = append(fds, openFileDAOv2(cfg))
+ fds = append(fds, openFileDAOv2(cfg, deser))
  }
 
  // populate v2 files into v2 manager
  if len(v2Files) > 0 {
  for _, name := range v2Files {
  cfg.DbPath = name
- fds = append(fds, openFileDAOv2(cfg))
+ fds = append(fds, openFileDAOv2(cfg, deser))
  }
 
  // v2 file's top index overrides v1's top
@@ -407,8 +408,8 @@ func CreateFileDAO(legacy bool, cfg db.Config) (FileDAO, error) {
 }
 
 // createNewV2File creates a new v2 chain db file
-func createNewV2File(start uint64, cfg db.Config) error {
- v2, err := newFileDAOv2(start, cfg)
+func createNewV2File(start uint64, cfg db.Config, deser *block.Deserializer) error {
+ v2, err := newFileDAOv2(start, cfg, deser)
  if err != nil {
  return err
  }

blockchain/filedao/filedao_legacy.go

@@ -21,7 +21,6 @@ import (
 
  "github.com/iotexproject/iotex-core/action"
  "github.com/iotexproject/iotex-core/blockchain/block"
- "github.com/iotexproject/iotex-core/config"
  "github.com/iotexproject/iotex-core/db"
  "github.com/iotexproject/iotex-core/db/batch"
  "github.com/iotexproject/iotex-core/pkg/compress"
@@ -57,16 +56,18 @@ type (
  htf db.RangeIndex
  kvStore db.KVStore
  kvStores *cache.ThreadSafeLruCache //store like map[index]db.KVStore,index from 1...N
+ deser *block.Deserializer
  }
 )
 
 // newFileDAOLegacy creates a new legacy file
-func newFileDAOLegacy(cfg db.Config) (FileDAO, error) {
+func newFileDAOLegacy(cfg db.Config, deser *block.Deserializer) (FileDAO, error) {
  return &fileDAOLegacy{
  compressBlock: cfg.CompressLegacy,
  cfg: cfg,
  kvStore: db.NewBoltDB(cfg),
  kvStores: cache.NewThreadSafeLruCache(0),
+ deser: deser,
  }, nil
 }
 
@@ -263,8 +264,7 @@ func (fd *fileDAOLegacy) body(h hash.Hash256) (*block.Body, error) {
  // block body could be empty
  return &block.Body{}, nil
  }
- // TODO: pass the correct EVM network ID at the time of newFileDAOLegacy()
- return (&block.Deserializer{}).SetEvmNetworkID(config.EVMNetworkID()).DeserializeBody(value)
+ return fd.deser.DeserializeBody(value)
 }
 
 func (fd *fileDAOLegacy) footer(h hash.Hash256) (*block.Footer, error) {