Merge branch 'master' of https://github.com/harmony-one/harmony into explorer_updates

pull/1510/head
flicker-harmony 5 years ago
commit 2f73bcc09c
  1. 10
      api/proto/node/node.go
  2. 11
      api/proto/node/node_test.go
  3. 8
      api/service/explorer/service.go
  4. 3
      api/service/explorer/storage.go
  5. 20
      api/service/explorer/storage_test.go
  6. 4
      api/service/explorer/structs_test.go
  7. 2
      block/gen_header_json.go
  8. 90
      block/header.go
  9. 9
      consensus/consensus.go
  10. 3
      consensus/consensus_service.go
  11. 10
      consensus/consensus_v2.go
  12. 26
      consensus/engine/consensus_engine.go
  13. 4
      contracts/structs/structs.go
  14. 40
      core/blockchain.go
  15. 8
      core/chain_indexer.go
  16. 26
      core/chain_makers.go
  17. 15
      core/core_test.go
  18. 8
      core/evm.go
  19. 6
      core/genesis.go
  20. 27
      core/headerchain.go
  21. 14
      core/rawdb/accessors_chain.go
  22. 20
      core/rawdb/accessors_chain_test.go
  23. 4
      core/rawdb/accessors_indexes_test.go
  24. 44
      core/resharding.go
  25. 25
      core/resharding_test.go
  26. 8
      core/state_processor.go
  27. 5
      core/tx_pool.go
  28. 4
      core/tx_pool_test.go
  29. 125
      core/types/block.go
  30. 4
      core/types/block_test.go
  31. 8
      core/types/crosslink.go
  32. 4
      core/types/transaction.go
  33. 6
      core/types/transaction_signing.go
  34. 15
      crypto/hash/rlp.go
  35. 4
      drand/drand_test.go
  36. 10
      hmy/api_backend.go
  37. 4
      hmy/bloombits.go
  38. 8
      hmyclient/hmyclient.go
  39. 19
      internal/chain/engine.go
  40. 4
      internal/chain/reward.go
  41. 8
      internal/hmyapi/backend.go
  42. 8
      internal/hmyapi/filters/api.go
  43. 10
      internal/hmyapi/filters/filter.go
  44. 26
      internal/hmyapi/filters/filter_system.go
  45. 6
      node/node.go
  46. 10
      node/node_cross_shard.go
  47. 10
      node/node_genesis.go
  48. 22
      node/node_handler.go
  49. 4
      node/node_newblock.go
  50. 5
      node/staking.go
  51. 9
      node/worker/worker.go
  52. 22
      shard/shard_state.go
  53. 6
      shard/shard_state_test.go

@ -11,8 +11,10 @@ import (
peer "github.com/libp2p/go-libp2p-peer" peer "github.com/libp2p/go-libp2p-peer"
"github.com/harmony-one/harmony/api/proto" "github.com/harmony-one/harmony/api/proto"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/shard"
) )
// MessageType is to indicate the specific type of message under Node category // MessageType is to indicate the specific type of message under Node category
@ -147,7 +149,7 @@ func ConstructBlocksSyncMessage(blocks []*types.Block) []byte {
} }
// ConstructCrossLinkHeadersMessage constructs cross link header message to send to beacon chain // ConstructCrossLinkHeadersMessage constructs cross link header message to send to beacon chain
func ConstructCrossLinkHeadersMessage(headers []*types.Header) []byte { func ConstructCrossLinkHeadersMessage(headers []*block.Header) []byte {
byteBuffer := bytes.NewBuffer([]byte{byte(proto.Node)}) byteBuffer := bytes.NewBuffer([]byte{byte(proto.Node)})
byteBuffer.WriteByte(byte(Block)) byteBuffer.WriteByte(byte(Block))
byteBuffer.WriteByte(byte(Header)) byteBuffer.WriteByte(byte(Header))
@ -158,7 +160,7 @@ func ConstructCrossLinkHeadersMessage(headers []*types.Header) []byte {
} }
// ConstructEpochShardStateMessage contructs epoch shard state message // ConstructEpochShardStateMessage contructs epoch shard state message
func ConstructEpochShardStateMessage(epochShardState types.EpochShardState) []byte { func ConstructEpochShardStateMessage(epochShardState shard.EpochShardState) []byte {
byteBuffer := bytes.NewBuffer([]byte{byte(proto.Node)}) byteBuffer := bytes.NewBuffer([]byte{byte(proto.Node)})
byteBuffer.WriteByte(byte(ShardState)) byteBuffer.WriteByte(byte(ShardState))
@ -172,8 +174,8 @@ func ConstructEpochShardStateMessage(epochShardState types.EpochShardState) []by
} }
// DeserializeEpochShardStateFromMessage deserializes the shard state Message from bytes payload // DeserializeEpochShardStateFromMessage deserializes the shard state Message from bytes payload
func DeserializeEpochShardStateFromMessage(payload []byte) (*types.EpochShardState, error) { func DeserializeEpochShardStateFromMessage(payload []byte) (*shard.EpochShardState, error) {
epochShardState := new(types.EpochShardState) epochShardState := new(shard.EpochShardState)
r := bytes.NewBuffer(payload) r := bytes.NewBuffer(payload)
decoder := gob.NewDecoder(r) decoder := gob.NewDecoder(r)

@ -1,18 +1,19 @@
package node package node
import ( import (
"math/big"
"reflect"
"strings" "strings"
"testing"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/state" "github.com/harmony-one/harmony/core/state"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
"github.com/harmony-one/harmony/internal/params" "github.com/harmony-one/harmony/internal/params"
"math/big"
"reflect"
"testing"
) )
var ( var (
@ -59,7 +60,7 @@ func TestConstructBlocksSyncMessage(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
root := statedb.IntermediateRoot(false) root := statedb.IntermediateRoot(false)
head := &types.Header{ head := &block.Header{
Number: new(big.Int).SetUint64(uint64(10000)), Number: new(big.Int).SetUint64(uint64(10000)),
Epoch: big.NewInt(0), Epoch: big.NewInt(0),
ShardID: 0, ShardID: 0,

@ -17,6 +17,7 @@ import (
libp2p_peer "github.com/libp2p/go-libp2p-peer" libp2p_peer "github.com/libp2p/go-libp2p-peer"
"github.com/harmony-one/bls/ffi/go/bls" "github.com/harmony-one/bls/ffi/go/bls"
msg_pb "github.com/harmony-one/harmony/api/proto/message" msg_pb "github.com/harmony-one/harmony/api/proto/message"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
bls2 "github.com/harmony-one/harmony/crypto/bls" bls2 "github.com/harmony-one/harmony/crypto/bls"
@ -25,6 +26,7 @@ import (
"github.com/harmony-one/harmony/internal/ctxerror" "github.com/harmony-one/harmony/internal/ctxerror"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/p2p" "github.com/harmony-one/harmony/p2p"
"github.com/harmony-one/harmony/shard"
) )
// Constants for explorer service. // Constants for explorer service.
@ -207,7 +209,7 @@ func (s *Service) GetExplorerBlocks(w http.ResponseWriter, r *http.Request) {
accountBlocks := s.ReadBlocksFromDB(fromInt, toInt) accountBlocks := s.ReadBlocksFromDB(fromInt, toInt)
curEpoch := int64(-1) curEpoch := int64(-1)
committee := &types.Committee{} committee := &shard.Committee{}
for id, accountBlock := range accountBlocks { for id, accountBlock := range accountBlocks {
if id == 0 || id == len(accountBlocks)-1 || accountBlock == nil { if id == 0 || id == len(accountBlocks)-1 || accountBlock == nil {
continue continue
@ -215,7 +217,7 @@ func (s *Service) GetExplorerBlocks(w http.ResponseWriter, r *http.Request) {
block := NewBlock(accountBlock, id+fromInt-1) block := NewBlock(accountBlock, id+fromInt-1)
if int64(block.Epoch) > curEpoch { if int64(block.Epoch) > curEpoch {
if bytes, err := db.Get([]byte(GetCommitteeKey(uint32(s.ShardID), block.Epoch))); err == nil { if bytes, err := db.Get([]byte(GetCommitteeKey(uint32(s.ShardID), block.Epoch))); err == nil {
committee = &types.Committee{} committee = &shard.Committee{}
if err = rlp.DecodeBytes(bytes, committee); err != nil { if err = rlp.DecodeBytes(bytes, committee); err != nil {
utils.Logger().Warn().Err(err).Msg("cannot read committee for new epoch") utils.Logger().Warn().Err(err).Msg("cannot read committee for new epoch")
} }
@ -377,7 +379,7 @@ func (s *Service) GetExplorerCommittee(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(500) w.WriteHeader(500)
return return
} }
committee := &types.Committee{} committee := &shard.Committee{}
if err := rlp.DecodeBytes(bytes, committee); err != nil { if err := rlp.DecodeBytes(bytes, committee); err != nil {
utils.Logger().Warn().Err(err).Msg("cannot decode committee data from DB") utils.Logger().Warn().Err(err).Msg("cannot decode committee data from DB")
w.WriteHeader(500) w.WriteHeader(500)

@ -12,6 +12,7 @@ import (
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
"github.com/harmony-one/harmony/internal/ctxerror" "github.com/harmony-one/harmony/internal/ctxerror"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/shard"
) )
// Constants for storage. // Constants for storage.
@ -126,7 +127,7 @@ func (storage *Storage) Dump(block *types.Block, height uint64) {
} }
// DumpCommittee commits validators for shardNum and epoch. // DumpCommittee commits validators for shardNum and epoch.
func (storage *Storage) DumpCommittee(shardID uint32, epoch uint64, committee types.Committee) error { func (storage *Storage) DumpCommittee(shardID uint32, epoch uint64, committee shard.Committee) error {
batch := storage.db.NewBatch() batch := storage.db.NewBatch()
// Store committees. // Store committees.
committeeData, err := rlp.EncodeToBytes(committee) committeeData, err := rlp.EncodeToBytes(committee)

@ -9,7 +9,11 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rlp"
"github.com/harmony-one/bls/ffi/go/bls" "github.com/harmony-one/bls/ffi/go/bls"
block2 "github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
"github.com/harmony-one/harmony/shard"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
@ -54,7 +58,7 @@ func TestDump(t *testing.T) {
tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), 0, big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33}) tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), 0, big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33})
txs := []*types.Transaction{tx1, tx2, tx3} txs := []*types.Transaction{tx1, tx2, tx3}
block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, nil, nil) block := types.NewBlock(&block2.Header{Number: big.NewInt(314)}, txs, nil, nil, nil)
ins := GetStorageInstance("1.1.1.1", "3333", true) ins := GetStorageInstance("1.1.1.1", "3333", true)
ins.Dump(block, uint64(1)) ins.Dump(block, uint64(1))
db := ins.GetDB() db := ins.GetDB()
@ -82,14 +86,14 @@ func TestDumpCommittee(t *testing.T) {
assert.Nil(t, err, "should be nil") assert.Nil(t, err, "should be nil")
err = blsPubKey2.DeserializeHexStr("02c8ff0b88f313717bc3a627d2f8bb172ba3ad3bb9ba3ecb8eed4b7c878653d3d4faf769876c528b73f343967f74a917") err = blsPubKey2.DeserializeHexStr("02c8ff0b88f313717bc3a627d2f8bb172ba3ad3bb9ba3ecb8eed4b7c878653d3d4faf769876c528b73f343967f74a917")
assert.Nil(t, err, "should be nil") assert.Nil(t, err, "should be nil")
BlsPublicKey1 := new(types.BlsPublicKey) BlsPublicKey1 := new(shard.BlsPublicKey)
BlsPublicKey2 := new(types.BlsPublicKey) BlsPublicKey2 := new(shard.BlsPublicKey)
BlsPublicKey1.FromLibBLSPublicKey(blsPubKey1) BlsPublicKey1.FromLibBLSPublicKey(blsPubKey1)
BlsPublicKey2.FromLibBLSPublicKey(blsPubKey2) BlsPublicKey2.FromLibBLSPublicKey(blsPubKey2)
nodeID1 := types.NodeID{EcdsaAddress: common.HexToAddress("52789f18a342da8023cc401e5d2b14a6b710fba9"), BlsPublicKey: *BlsPublicKey1} nodeID1 := shard.NodeID{EcdsaAddress: common.HexToAddress("52789f18a342da8023cc401e5d2b14a6b710fba9"), BlsPublicKey: *BlsPublicKey1}
nodeID2 := types.NodeID{EcdsaAddress: common.HexToAddress("7c41e0668b551f4f902cfaec05b5bdca68b124ce"), BlsPublicKey: *BlsPublicKey2} nodeID2 := shard.NodeID{EcdsaAddress: common.HexToAddress("7c41e0668b551f4f902cfaec05b5bdca68b124ce"), BlsPublicKey: *BlsPublicKey2}
nodeIDList := []types.NodeID{nodeID1, nodeID2} nodeIDList := []shard.NodeID{nodeID1, nodeID2}
committee := types.Committee{ShardID: uint32(0), NodeList: nodeIDList} committee := shard.Committee{ShardID: uint32(0), NodeList: nodeIDList}
shardID := uint32(0) shardID := uint32(0)
epoch := uint64(0) epoch := uint64(0)
ins := GetStorageInstance("1.1.1.1", "3333", true) ins := GetStorageInstance("1.1.1.1", "3333", true)
@ -112,7 +116,7 @@ func TestUpdateAddressStorage(t *testing.T) {
tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), 0, big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33}) tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), 0, big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33})
txs := []*types.Transaction{tx1, tx2, tx3} txs := []*types.Transaction{tx1, tx2, tx3}
block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, nil, nil) block := types.NewBlock(&block2.Header{Number: big.NewInt(314)}, txs, nil, nil, nil)
ins := GetStorageInstance("1.1.1.1", "3333", true) ins := GetStorageInstance("1.1.1.1", "3333", true)
ins.Dump(block, uint64(1)) ins.Dump(block, uint64(1))
db := ins.GetDB() db := ins.GetDB()

@ -8,6 +8,8 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
block2 "github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
common2 "github.com/harmony-one/harmony/internal/common" common2 "github.com/harmony-one/harmony/internal/common"
) )
@ -19,7 +21,7 @@ func TestGetTransaction(t *testing.T) {
tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), 0, big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33}) tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), 0, big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33})
txs := []*types.Transaction{tx1, tx2, tx3} txs := []*types.Transaction{tx1, tx2, tx3}
block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, nil, nil) block := types.NewBlock(&block2.Header{Number: big.NewInt(314)}, txs, nil, nil, nil)
tx := GetTransaction(tx1, block) tx := GetTransaction(tx1, block)
assert.Equal(t, tx.ID, tx1.Hash().Hex(), "should be equal tx1.Hash()") assert.Equal(t, tx.ID, tx1.Hash().Hex(), "should be equal tx1.Hash()")

@ -1,6 +1,6 @@
// Code generated by github.com/fjl/gencodec. DO NOT EDIT. // Code generated by github.com/fjl/gencodec. DO NOT EDIT.
package types package block
import ( import (
"encoding/json" "encoding/json"

@ -0,0 +1,90 @@
package block
import (
"math/big"
"unsafe"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/rlp"
"github.com/rs/zerolog"
"github.com/harmony-one/harmony/crypto/hash"
"github.com/harmony-one/harmony/shard"
)
// Header represents a block header in the Harmony blockchain.
type Header struct {
ParentHash common.Hash `json:"parentHash" gencodec:"required"`
Coinbase common.Address `json:"miner" gencodec:"required"`
Root common.Hash `json:"stateRoot" gencodec:"required"`
TxHash common.Hash `json:"transactionsRoot" gencodec:"required"`
ReceiptHash common.Hash `json:"receiptsRoot" gencodec:"required"`
OutgoingReceiptHash common.Hash `json:"outgoingReceiptsRoot" gencodec:"required"`
IncomingReceiptHash common.Hash `json:"incomingReceiptsRoot" gencodec:"required"`
Bloom types.Bloom `json:"logsBloom" gencodec:"required"`
Number *big.Int `json:"number" gencodec:"required"`
GasLimit uint64 `json:"gasLimit" gencodec:"required"`
GasUsed uint64 `json:"gasUsed" gencodec:"required"`
Time *big.Int `json:"timestamp" gencodec:"required"`
Extra []byte `json:"extraData" gencodec:"required"`
MixDigest common.Hash `json:"mixHash" gencodec:"required"`
// Additional Fields
ViewID *big.Int `json:"viewID" gencodec:"required"`
Epoch *big.Int `json:"epoch" gencodec:"required"`
ShardID uint32 `json:"shardID" gencodec:"required"`
LastCommitSignature [96]byte `json:"lastCommitSignature" gencodec:"required"`
LastCommitBitmap []byte `json:"lastCommitBitmap" gencodec:"required"` // Contains which validator signed
ShardStateHash common.Hash `json:"shardStateRoot"`
Vrf []byte `json:"vrf"`
Vdf []byte `json:"vdf"`
ShardState []byte `json:"shardState"`
CrossLinks []byte `json:"crossLink"`
}
// field type overrides for gencodec
type headerMarshaling struct {
Difficulty *hexutil.Big
Number *hexutil.Big
GasLimit hexutil.Uint64
GasUsed hexutil.Uint64
Time *hexutil.Big
Extra hexutil.Bytes
Hash common.Hash `json:"hash"` // adds call to Hash() in MarshalJSON
}
// Hash returns the block hash of the header, which is simply the keccak256 hash of its
// RLP encoding.
func (h *Header) Hash() common.Hash {
return hash.FromRLP(h)
}
// Size returns the approximate memory used by all internal contents. It is used
// to approximate and limit the memory consumption of various caches.
func (h *Header) Size() common.StorageSize {
// TODO: update with new fields
return common.StorageSize(unsafe.Sizeof(*h)) + common.StorageSize(len(h.Extra)+(h.Number.BitLen()+h.Time.BitLen())/8)
}
// Logger returns a sub-logger with block contexts added.
func (h *Header) Logger(logger *zerolog.Logger) *zerolog.Logger {
nlogger := logger.
With().
Str("blockHash", h.Hash().Hex()).
Uint32("blockShard", h.ShardID).
Uint64("blockEpoch", h.Epoch.Uint64()).
Uint64("blockNumber", h.Number.Uint64()).
Logger()
return &nlogger
}
// GetShardState returns the deserialized shard state object.
func (h *Header) GetShardState() (shard.State, error) {
shardState := shard.State{}
err := rlp.DecodeBytes(h.ShardState, &shardState)
if err != nil {
return nil, err
}
return shardState, nil
}

@ -20,6 +20,7 @@ import (
"github.com/harmony-one/harmony/internal/memprofiling" "github.com/harmony-one/harmony/internal/memprofiling"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/p2p" "github.com/harmony-one/harmony/p2p"
"github.com/harmony-one/harmony/shard"
) )
const ( const (
@ -304,7 +305,7 @@ func New(host p2p.Host, ShardID uint32, leader p2p.Peer, blsPriKey *bls.SecretKe
// genesis accounts. // genesis accounts.
// When used for block reward, it rewards only foundational nodes. // When used for block reward, it rewards only foundational nodes.
type GenesisStakeInfoFinder struct { type GenesisStakeInfoFinder struct {
byNodeKey map[types.BlsPublicKey][]*structs.StakeInfo byNodeKey map[shard.BlsPublicKey][]*structs.StakeInfo
byAccount map[common.Address][]*structs.StakeInfo byAccount map[common.Address][]*structs.StakeInfo
} }
@ -314,7 +315,7 @@ type GenesisStakeInfoFinder struct {
func (f *GenesisStakeInfoFinder) FindStakeInfoByNodeKey( func (f *GenesisStakeInfoFinder) FindStakeInfoByNodeKey(
key *bls.PublicKey, key *bls.PublicKey,
) []*structs.StakeInfo { ) []*structs.StakeInfo {
var pk types.BlsPublicKey var pk shard.BlsPublicKey
if err := pk.FromLibBLSPublicKey(key); err != nil { if err := pk.FromLibBLSPublicKey(key); err != nil {
utils.Logger().Warn().Err(err).Msg("cannot convert BLS public key") utils.Logger().Warn().Err(err).Msg("cannot convert BLS public key")
return nil return nil
@ -337,13 +338,13 @@ func (f *GenesisStakeInfoFinder) FindStakeInfoByAccount(
// genesis nodes. // genesis nodes.
func NewGenesisStakeInfoFinder() (*GenesisStakeInfoFinder, error) { func NewGenesisStakeInfoFinder() (*GenesisStakeInfoFinder, error) {
f := &GenesisStakeInfoFinder{ f := &GenesisStakeInfoFinder{
byNodeKey: make(map[types.BlsPublicKey][]*structs.StakeInfo), byNodeKey: make(map[shard.BlsPublicKey][]*structs.StakeInfo),
byAccount: make(map[common.Address][]*structs.StakeInfo), byAccount: make(map[common.Address][]*structs.StakeInfo),
} }
for idx, account := range genesis.HarmonyAccounts { for idx, account := range genesis.HarmonyAccounts {
pub := &bls.PublicKey{} pub := &bls.PublicKey{}
pub.DeserializeHexStr(account.BlsPublicKey) pub.DeserializeHexStr(account.BlsPublicKey)
var blsPublicKey types.BlsPublicKey var blsPublicKey shard.BlsPublicKey
if err := blsPublicKey.FromLibBLSPublicKey(pub); err != nil { if err := blsPublicKey.FromLibBLSPublicKey(pub); err != nil {
return nil, ctxerror.New("cannot convert BLS public key", return nil, ctxerror.New("cannot convert BLS public key",
"accountIndex", idx, "accountIndex", idx,

@ -9,6 +9,7 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/crypto/hash" "github.com/harmony-one/harmony/crypto/hash"
@ -456,7 +457,7 @@ func (consensus *Consensus) getLogger() *zerolog.Logger {
} }
// retrieve corresponding blsPublicKey from Coinbase Address // retrieve corresponding blsPublicKey from Coinbase Address
func (consensus *Consensus) getLeaderPubKeyFromCoinbase(header *types.Header) (*bls.PublicKey, error) { func (consensus *Consensus) getLeaderPubKeyFromCoinbase(header *block.Header) (*bls.PublicKey, error) {
shardState, err := consensus.ChainReader.ReadShardState(header.Epoch) shardState, err := consensus.ChainReader.ReadShardState(header.Epoch)
if err != nil { if err != nil {
return nil, ctxerror.New("cannot read shard state", return nil, ctxerror.New("cannot read shard state",

@ -10,8 +10,11 @@ import (
"github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rlp"
protobuf "github.com/golang/protobuf/proto" protobuf "github.com/golang/protobuf/proto"
"github.com/harmony-one/bls/ffi/go/bls" "github.com/harmony-one/bls/ffi/go/bls"
"github.com/harmony-one/vdf/src/vdf_go"
"github.com/harmony-one/harmony/api/proto" "github.com/harmony-one/harmony/api/proto"
msg_pb "github.com/harmony-one/harmony/api/proto/message" msg_pb "github.com/harmony-one/harmony/api/proto/message"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
vrf_bls "github.com/harmony-one/harmony/crypto/vrf/bls" vrf_bls "github.com/harmony-one/harmony/crypto/vrf/bls"
@ -20,7 +23,6 @@ import (
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/p2p" "github.com/harmony-one/harmony/p2p"
"github.com/harmony-one/harmony/p2p/host" "github.com/harmony-one/harmony/p2p/host"
"github.com/harmony-one/vdf/src/vdf_go"
) )
// handleMessageUpdate will update the consensus state according to received message // handleMessageUpdate will update the consensus state according to received message
@ -182,7 +184,7 @@ func (consensus *Consensus) onAnnounce(msg *msg_pb.Message) {
// verify validity of block header object // verify validity of block header object
blockHeader := recvMsg.Payload blockHeader := recvMsg.Payload
var headerObj types.Header var headerObj block.Header
err = rlp.DecodeBytes(blockHeader, &headerObj) err = rlp.DecodeBytes(blockHeader, &headerObj)
if err != nil { if err != nil {
consensus.getLogger().Warn(). consensus.getLogger().Warn().
@ -1203,7 +1205,7 @@ func (consensus *Consensus) GenerateVrfAndProof(newBlock *types.Block, vrfBlockN
} }
// ValidateVrfAndProof validates a VRF/Proof from hash of previous block // ValidateVrfAndProof validates a VRF/Proof from hash of previous block
func (consensus *Consensus) ValidateVrfAndProof(headerObj types.Header) bool { func (consensus *Consensus) ValidateVrfAndProof(headerObj block.Header) bool {
vrfPk := vrf_bls.NewVRFVerifier(consensus.LeaderPubKey) vrfPk := vrf_bls.NewVRFVerifier(consensus.LeaderPubKey)
var blockHash [32]byte var blockHash [32]byte
@ -1275,7 +1277,7 @@ func (consensus *Consensus) GenerateVdfAndProof(newBlock *types.Block, vrfBlockN
} }
// ValidateVdfAndProof validates the VDF/proof in the current epoch // ValidateVdfAndProof validates the VDF/proof in the current epoch
func (consensus *Consensus) ValidateVdfAndProof(headerObj types.Header) bool { func (consensus *Consensus) ValidateVdfAndProof(headerObj block.Header) bool {
vrfBlockNumbers, err := consensus.ChainReader.ReadEpochVrfBlockNums(headerObj.Epoch) vrfBlockNumbers, err := consensus.ChainReader.ReadEpochVrfBlockNums(headerObj.Epoch)
if err != nil { if err != nil {
consensus.getLogger().Error().Err(err). consensus.getLogger().Error().Err(err).

@ -6,8 +6,10 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/harmony-one/harmony/internal/params" "github.com/harmony-one/harmony/internal/params"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/state" "github.com/harmony-one/harmony/core/state"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
"github.com/harmony-one/harmony/shard"
) )
// ChainReader defines a small collection of methods needed to access the local // ChainReader defines a small collection of methods needed to access the local
@ -18,22 +20,22 @@ type ChainReader interface {
Config() *params.ChainConfig Config() *params.ChainConfig
// CurrentHeader retrieves the current header from the local chain. // CurrentHeader retrieves the current header from the local chain.
CurrentHeader() *types.Header CurrentHeader() *block.Header
// GetHeader retrieves a block header from the database by hash and number. // GetHeader retrieves a block header from the database by hash and number.
GetHeader(hash common.Hash, number uint64) *types.Header GetHeader(hash common.Hash, number uint64) *block.Header
// GetHeaderByNumber retrieves a block header from the database by number. // GetHeaderByNumber retrieves a block header from the database by number.
GetHeaderByNumber(number uint64) *types.Header GetHeaderByNumber(number uint64) *block.Header
// GetHeaderByHash retrieves a block header from the database by its hash. // GetHeaderByHash retrieves a block header from the database by its hash.
GetHeaderByHash(hash common.Hash) *types.Header GetHeaderByHash(hash common.Hash) *block.Header
// GetBlock retrieves a block from the database by hash and number. // GetBlock retrieves a block from the database by hash and number.
GetBlock(hash common.Hash, number uint64) *types.Block GetBlock(hash common.Hash, number uint64) *types.Block
// ReadShardState retrieves sharding state given the epoch number. // ReadShardState retrieves sharding state given the epoch number.
ReadShardState(epoch *big.Int) (types.ShardState, error) ReadShardState(epoch *big.Int) (shard.State, error)
} }
// Engine is an algorithm agnostic consensus engine. // Engine is an algorithm agnostic consensus engine.
@ -41,32 +43,32 @@ type ChainReader interface {
type Engine interface { type Engine interface {
// Author retrieves the Harmony address of the account that validated the given // Author retrieves the Harmony address of the account that validated the given
// block. // block.
Author(header *types.Header) (common.Address, error) Author(header *block.Header) (common.Address, error)
// VerifyHeader checks whether a header conforms to the consensus rules of a // VerifyHeader checks whether a header conforms to the consensus rules of a
// given engine. Verifying the seal may be done optionally here, or explicitly // given engine. Verifying the seal may be done optionally here, or explicitly
// via the VerifySeal method. // via the VerifySeal method.
VerifyHeader(chain ChainReader, header *types.Header, seal bool) error VerifyHeader(chain ChainReader, header *block.Header, seal bool) error
// VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers // VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers
// concurrently. The method returns a quit channel to abort the operations and // concurrently. The method returns a quit channel to abort the operations and
// a results channel to retrieve the async verifications (the order is that of // a results channel to retrieve the async verifications (the order is that of
// the input slice). // the input slice).
VerifyHeaders(chain ChainReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) VerifyHeaders(chain ChainReader, headers []*block.Header, seals []bool) (chan<- struct{}, <-chan error)
// VerifySeal checks whether the crypto seal on a header is valid according to // VerifySeal checks whether the crypto seal on a header is valid according to
// the consensus rules of the given engine. // the consensus rules of the given engine.
VerifySeal(chain ChainReader, header *types.Header) error VerifySeal(chain ChainReader, header *block.Header) error
// Prepare initializes the consensus fields of a block header according to the // Prepare initializes the consensus fields of a block header according to the
// rules of a particular engine. The changes are executed inline. // rules of a particular engine. The changes are executed inline.
Prepare(chain ChainReader, header *types.Header) error Prepare(chain ChainReader, header *block.Header) error
// Finalize runs any post-transaction state modifications (e.g. block rewards) // Finalize runs any post-transaction state modifications (e.g. block rewards)
// and assembles the final block. // and assembles the final block.
// Note: The block header and state database might be updated to reflect any // Note: The block header and state database might be updated to reflect any
// consensus rules that happen at finalization (e.g. block rewards). // consensus rules that happen at finalization (e.g. block rewards).
Finalize(chain ChainReader, header *types.Header, state *state.DB, txs []*types.Transaction, Finalize(chain ChainReader, header *block.Header, state *state.DB, txs []*types.Transaction,
receipts []*types.Receipt, outcxs []*types.CXReceipt, incxs []*types.CXReceiptsProof) (*types.Block, error) receipts []*types.Receipt, outcxs []*types.CXReceipt, incxs []*types.CXReceiptsProof) (*types.Block, error)
// Seal generates a new sealing request for the given input block and pushes // Seal generates a new sealing request for the given input block and pushes
@ -77,5 +79,5 @@ type Engine interface {
Seal(chain ChainReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error Seal(chain ChainReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error
// SealHash returns the hash of a block prior to it being sealed. // SealHash returns the hash of a block prior to it being sealed.
SealHash(header *types.Header) common.Hash SealHash(header *block.Header) common.Hash
} }

@ -3,7 +3,7 @@ package structs
import ( import (
"math/big" "math/big"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/shard"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
) )
@ -22,7 +22,7 @@ type StakeInfoReturnValue struct {
// StakeInfo stores the staking information for a staker. // StakeInfo stores the staking information for a staker.
type StakeInfo struct { type StakeInfo struct {
Account common.Address Account common.Address
BlsPublicKey types.BlsPublicKey BlsPublicKey shard.BlsPublicKey
BlockNum *big.Int BlockNum *big.Int
LockPeriodCount *big.Int // The number of locking period the token will be locked. LockPeriodCount *big.Int // The number of locking period the token will be locked.
Amount *big.Int Amount *big.Int

@ -38,6 +38,7 @@ import (
"github.com/harmony-one/harmony/internal/params" "github.com/harmony-one/harmony/internal/params"
lru "github.com/hashicorp/golang-lru" lru "github.com/hashicorp/golang-lru"
"github.com/harmony-one/harmony/block"
consensus_engine "github.com/harmony-one/harmony/consensus/engine" consensus_engine "github.com/harmony-one/harmony/consensus/engine"
"github.com/harmony-one/harmony/contracts/structs" "github.com/harmony-one/harmony/contracts/structs"
"github.com/harmony-one/harmony/core/rawdb" "github.com/harmony-one/harmony/core/rawdb"
@ -46,6 +47,7 @@ import (
"github.com/harmony-one/harmony/core/vm" "github.com/harmony-one/harmony/core/vm"
"github.com/harmony-one/harmony/internal/ctxerror" "github.com/harmony-one/harmony/internal/ctxerror"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/shard"
) )
var ( var (
@ -248,7 +250,7 @@ func IsEpochLastBlock(block *types.Block) bool {
// IsEpochLastBlockByHeader returns whether this block is the last block of an epoch // IsEpochLastBlockByHeader returns whether this block is the last block of an epoch
// given block header // given block header
func IsEpochLastBlockByHeader(header *types.Header) bool { func IsEpochLastBlockByHeader(header *block.Header) bool {
return ShardingSchedule.IsLastBlock(header.Number.Uint64()) return ShardingSchedule.IsLastBlock(header.Number.Uint64())
} }
@ -725,11 +727,11 @@ func (bc *BlockChain) GetBlocksFromHash(hash common.Hash, n int) (blocks []*type
// GetUnclesInChain retrieves all the uncles from a given block backwards until // GetUnclesInChain retrieves all the uncles from a given block backwards until
// a specific distance is reached. // a specific distance is reached.
func (bc *BlockChain) GetUnclesInChain(block *types.Block, length int) []*types.Header { func (bc *BlockChain) GetUnclesInChain(b *types.Block, length int) []*block.Header {
uncles := []*types.Header{} uncles := []*block.Header{}
for i := 0; block != nil && i < length; i++ { for i := 0; b != nil && i < length; i++ {
uncles = append(uncles, block.Uncles()...) uncles = append(uncles, b.Uncles()...)
block = bc.GetBlock(block.ParentHash(), block.NumberU64()-1) b = bc.GetBlock(b.ParentHash(), b.NumberU64()-1)
} }
return uncles return uncles
} }
@ -1207,7 +1209,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks) (int, []interface{}, []*ty
coalescedLogs []*types.Log coalescedLogs []*types.Log
) )
// Start the parallel header verifier // Start the parallel header verifier
headers := make([]*types.Header, len(chain)) headers := make([]*block.Header, len(chain))
seals := make([]bool, len(chain)) seals := make([]bool, len(chain))
for i, block := range chain { for i, block := range chain {
@ -1669,7 +1671,7 @@ Error: %v
// should be done or not. The reason behind the optional check is because some // should be done or not. The reason behind the optional check is because some
// of the header retrieval mechanisms already need to verify nonces, as well as // of the header retrieval mechanisms already need to verify nonces, as well as
// because nonces can be verified sparsely, not needing to check each. // because nonces can be verified sparsely, not needing to check each.
func (bc *BlockChain) InsertHeaderChain(chain []*types.Header, checkFreq int) (int, error) { func (bc *BlockChain) InsertHeaderChain(chain []*block.Header, checkFreq int) (int, error) {
start := time.Now() start := time.Now()
if i, err := bc.hc.ValidateHeaderChain(chain, checkFreq); err != nil { if i, err := bc.hc.ValidateHeaderChain(chain, checkFreq); err != nil {
return i, err return i, err
@ -1682,7 +1684,7 @@ func (bc *BlockChain) InsertHeaderChain(chain []*types.Header, checkFreq int) (i
bc.wg.Add(1) bc.wg.Add(1)
defer bc.wg.Done() defer bc.wg.Done()
whFunc := func(header *types.Header) error { whFunc := func(header *block.Header) error {
bc.mu.Lock() bc.mu.Lock()
defer bc.mu.Unlock() defer bc.mu.Unlock()
@ -1702,7 +1704,7 @@ func (bc *BlockChain) InsertHeaderChain(chain []*types.Header, checkFreq int) (i
// without the real blocks. Hence, writing headers directly should only be done // without the real blocks. Hence, writing headers directly should only be done
// in two scenarios: pure-header mode of operation (light clients), or properly // in two scenarios: pure-header mode of operation (light clients), or properly
// separated header/block phases (non-archive clients). // separated header/block phases (non-archive clients).
func (bc *BlockChain) writeHeader(header *types.Header) error { func (bc *BlockChain) writeHeader(header *block.Header) error {
bc.wg.Add(1) bc.wg.Add(1)
defer bc.wg.Done() defer bc.wg.Done()
@ -1715,7 +1717,7 @@ func (bc *BlockChain) writeHeader(header *types.Header) error {
// CurrentHeader retrieves the current head header of the canonical chain. The // CurrentHeader retrieves the current head header of the canonical chain. The
// header is retrieved from the HeaderChain's internal cache. // header is retrieved from the HeaderChain's internal cache.
func (bc *BlockChain) CurrentHeader() *types.Header { func (bc *BlockChain) CurrentHeader() *block.Header {
return bc.hc.CurrentHeader() return bc.hc.CurrentHeader()
} }
@ -1733,13 +1735,13 @@ func (bc *BlockChain) GetTdByHash(hash common.Hash) *big.Int {
// GetHeader retrieves a block header from the database by hash and number, // GetHeader retrieves a block header from the database by hash and number,
// caching it if found. // caching it if found.
func (bc *BlockChain) GetHeader(hash common.Hash, number uint64) *types.Header { func (bc *BlockChain) GetHeader(hash common.Hash, number uint64) *block.Header {
return bc.hc.GetHeader(hash, number) return bc.hc.GetHeader(hash, number)
} }
// GetHeaderByHash retrieves a block header from the database by hash, caching it if // GetHeaderByHash retrieves a block header from the database by hash, caching it if
// found. // found.
func (bc *BlockChain) GetHeaderByHash(hash common.Hash) *types.Header { func (bc *BlockChain) GetHeaderByHash(hash common.Hash) *block.Header {
return bc.hc.GetHeaderByHash(hash) return bc.hc.GetHeaderByHash(hash)
} }
@ -1769,7 +1771,7 @@ func (bc *BlockChain) GetAncestor(hash common.Hash, number, ancestor uint64, max
// GetHeaderByNumber retrieves a block header from the database by number, // GetHeaderByNumber retrieves a block header from the database by number,
// caching it (associated with its hash) if found. // caching it (associated with its hash) if found.
func (bc *BlockChain) GetHeaderByNumber(number uint64) *types.Header { func (bc *BlockChain) GetHeaderByNumber(number uint64) *block.Header {
return bc.hc.GetHeaderByNumber(number) return bc.hc.GetHeaderByNumber(number)
} }
@ -1805,10 +1807,10 @@ func (bc *BlockChain) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscript
} }
// ReadShardState retrieves sharding state given the epoch number. // ReadShardState retrieves sharding state given the epoch number.
func (bc *BlockChain) ReadShardState(epoch *big.Int) (types.ShardState, error) { func (bc *BlockChain) ReadShardState(epoch *big.Int) (shard.State, error) {
cacheKey := string(epoch.Bytes()) cacheKey := string(epoch.Bytes())
if cached, ok := bc.shardStateCache.Get(cacheKey); ok { if cached, ok := bc.shardStateCache.Get(cacheKey); ok {
shardState := cached.(types.ShardState) shardState := cached.(shard.State)
return shardState, nil return shardState, nil
} }
shardState, err := rawdb.ReadShardState(bc.db, epoch) shardState, err := rawdb.ReadShardState(bc.db, epoch)
@ -1821,7 +1823,7 @@ func (bc *BlockChain) ReadShardState(epoch *big.Int) (types.ShardState, error) {
// WriteShardState saves the given sharding state under the given epoch number. // WriteShardState saves the given sharding state under the given epoch number.
func (bc *BlockChain) WriteShardState( func (bc *BlockChain) WriteShardState(
epoch *big.Int, shardState types.ShardState, epoch *big.Int, shardState shard.State,
) error { ) error {
shardState = shardState.DeepCopy() shardState = shardState.DeepCopy()
err := rawdb.WriteShardState(bc.db, epoch, shardState) err := rawdb.WriteShardState(bc.db, epoch, shardState)
@ -1837,7 +1839,7 @@ func (bc *BlockChain) WriteShardState(
func (bc *BlockChain) WriteShardStateBytes( func (bc *BlockChain) WriteShardStateBytes(
epoch *big.Int, shardState []byte, epoch *big.Int, shardState []byte,
) error { ) error {
decodeShardState := types.ShardState{} decodeShardState := shard.State{}
if err := rlp.DecodeBytes(shardState, &decodeShardState); err != nil { if err := rlp.DecodeBytes(shardState, &decodeShardState); err != nil {
return err return err
} }
@ -1897,7 +1899,7 @@ func (bc *BlockChain) GetVrfByNumber(number uint64) []byte {
func (bc *BlockChain) GetShardState( func (bc *BlockChain) GetShardState(
epoch *big.Int, epoch *big.Int,
stakeInfo *map[common.Address]*structs.StakeInfo, stakeInfo *map[common.Address]*structs.StakeInfo,
) (types.ShardState, error) { ) (shard.State, error) {
shardState, err := bc.ReadShardState(epoch) shardState, err := bc.ReadShardState(epoch)
if err == nil { // TODO ek – distinguish ErrNotFound if err == nil { // TODO ek – distinguish ErrNotFound
return shardState, err return shardState, err

@ -29,8 +29,8 @@ import (
"github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/event"
"github.com/rs/zerolog" "github.com/rs/zerolog"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/rawdb" "github.com/harmony-one/harmony/core/rawdb"
"github.com/harmony-one/harmony/core/types"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
) )
@ -44,7 +44,7 @@ type ChainIndexerBackend interface {
// Process crunches through the next header in the chain segment. The caller // Process crunches through the next header in the chain segment. The caller
// will ensure a sequential order of headers. // will ensure a sequential order of headers.
Process(ctx context.Context, header *types.Header) error Process(ctx context.Context, header *block.Header) error
// Commit finalizes the section metadata and stores it into the database. // Commit finalizes the section metadata and stores it into the database.
Commit() error Commit() error
@ -53,7 +53,7 @@ type ChainIndexerBackend interface {
// ChainIndexerChain interface is used for connecting the indexer to a blockchain // ChainIndexerChain interface is used for connecting the indexer to a blockchain
type ChainIndexerChain interface { type ChainIndexerChain interface {
// CurrentHeader retrieves the latest locally known header. // CurrentHeader retrieves the latest locally known header.
CurrentHeader() *types.Header CurrentHeader() *block.Header
// SubscribeChainHeadEvent subscribes to new head header notifications. // SubscribeChainHeadEvent subscribes to new head header notifications.
SubscribeChainHeadEvent(ch chan<- ChainHeadEvent) event.Subscription SubscribeChainHeadEvent(ch chan<- ChainHeadEvent) event.Subscription
@ -193,7 +193,7 @@ func (c *ChainIndexer) Close() error {
// eventLoop is a secondary - optional - event loop of the indexer which is only // eventLoop is a secondary - optional - event loop of the indexer which is only
// started for the outermost indexer to push chain head events into a processing // started for the outermost indexer to push chain head events into a processing
// queue. // queue.
func (c *ChainIndexer) eventLoop(currentHeader *types.Header, events chan ChainHeadEvent, sub event.Subscription) { func (c *ChainIndexer) eventLoop(currentHeader *block.Header, events chan ChainHeadEvent, sub event.Subscription) {
// Mark the chain indexer as active, requiring an additional teardown // Mark the chain indexer as active, requiring an additional teardown
atomic.StoreUint32(&c.active, 1) atomic.StoreUint32(&c.active, 1)

@ -24,10 +24,12 @@ import (
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/harmony-one/harmony/internal/params" "github.com/harmony-one/harmony/internal/params"
"github.com/harmony-one/harmony/block"
consensus_engine "github.com/harmony-one/harmony/consensus/engine" consensus_engine "github.com/harmony-one/harmony/consensus/engine"
"github.com/harmony-one/harmony/core/state" "github.com/harmony-one/harmony/core/state"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
"github.com/harmony-one/harmony/core/vm" "github.com/harmony-one/harmony/core/vm"
"github.com/harmony-one/harmony/shard"
) )
// BlockGen creates blocks for testing. // BlockGen creates blocks for testing.
@ -36,13 +38,13 @@ type BlockGen struct {
i int i int
parent *types.Block parent *types.Block
chain []*types.Block chain []*types.Block
header *types.Header header *block.Header
statedb *state.DB statedb *state.DB
gasPool *GasPool gasPool *GasPool
txs []*types.Transaction txs []*types.Transaction
receipts []*types.Receipt receipts []*types.Receipt
uncles []*types.Header uncles []*block.Header
config *params.ChainConfig config *params.ChainConfig
engine consensus_engine.Engine engine consensus_engine.Engine
@ -128,7 +130,7 @@ func (b *BlockGen) TxNonce(addr common.Address) uint64 {
} }
// AddUncle adds an uncle header to the generated block. // AddUncle adds an uncle header to the generated block.
func (b *BlockGen) AddUncle(h *types.Header) { func (b *BlockGen) AddUncle(h *block.Header) {
b.uncles = append(b.uncles, h) b.uncles = append(b.uncles, h)
} }
@ -206,7 +208,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
return blocks, receipts return blocks, receipts
} }
func makeHeader(chain consensus_engine.ChainReader, parent *types.Block, state *state.DB, engine consensus_engine.Engine) *types.Header { func makeHeader(chain consensus_engine.ChainReader, parent *types.Block, state *state.DB, engine consensus_engine.Engine) *block.Header {
var time *big.Int var time *big.Int
if parent.Time() == nil { if parent.Time() == nil {
time = big.NewInt(10) time = big.NewInt(10)
@ -214,7 +216,7 @@ func makeHeader(chain consensus_engine.ChainReader, parent *types.Block, state *
time = new(big.Int).Add(parent.Time(), big.NewInt(10)) // block time is fixed at 10 seconds time = new(big.Int).Add(parent.Time(), big.NewInt(10)) // block time is fixed at 10 seconds
} }
return &types.Header{ return &block.Header{
Root: state.IntermediateRoot(chain.Config().IsEIP158(parent.Number())), Root: state.IntermediateRoot(chain.Config().IsEIP158(parent.Number())),
ParentHash: parent.Hash(), ParentHash: parent.Hash(),
Coinbase: parent.Coinbase(), Coinbase: parent.Coinbase(),
@ -231,9 +233,9 @@ func makeHeader(chain consensus_engine.ChainReader, parent *types.Block, state *
} }
// makeHeaderChain creates a deterministic chain of headers rooted at parent. // makeHeaderChain creates a deterministic chain of headers rooted at parent.
func makeHeaderChain(parent *types.Header, n int, engine consensus_engine.Engine, db ethdb.Database, seed int) []*types.Header { func makeHeaderChain(parent *block.Header, n int, engine consensus_engine.Engine, db ethdb.Database, seed int) []*block.Header {
blocks := makeBlockChain(types.NewBlockWithHeader(parent), n, engine, db, seed) blocks := makeBlockChain(types.NewBlockWithHeader(parent), n, engine, db, seed)
headers := make([]*types.Header, len(blocks)) headers := make([]*block.Header, len(blocks))
for i, block := range blocks { for i, block := range blocks {
headers[i] = block.Header() headers[i] = block.Header()
} }
@ -258,9 +260,9 @@ func (cr *fakeChainReader) Config() *params.ChainConfig {
return cr.config return cr.config
} }
func (cr *fakeChainReader) CurrentHeader() *types.Header { return nil } func (cr *fakeChainReader) CurrentHeader() *block.Header { return nil }
func (cr *fakeChainReader) GetHeaderByNumber(number uint64) *types.Header { return nil } func (cr *fakeChainReader) GetHeaderByNumber(number uint64) *block.Header { return nil }
func (cr *fakeChainReader) GetHeaderByHash(hash common.Hash) *types.Header { return nil } func (cr *fakeChainReader) GetHeaderByHash(hash common.Hash) *block.Header { return nil }
func (cr *fakeChainReader) GetHeader(hash common.Hash, number uint64) *types.Header { return nil } func (cr *fakeChainReader) GetHeader(hash common.Hash, number uint64) *block.Header { return nil }
func (cr *fakeChainReader) GetBlock(hash common.Hash, number uint64) *types.Block { return nil } func (cr *fakeChainReader) GetBlock(hash common.Hash, number uint64) *types.Block { return nil }
func (cr *fakeChainReader) ReadShardState(epoch *big.Int) (types.ShardState, error) { return nil, nil } func (cr *fakeChainReader) ReadShardState(epoch *big.Int) (shard.State, error) { return nil, nil }

@ -4,18 +4,19 @@ import (
"math/big" "math/big"
"testing" "testing"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
shardingconfig "github.com/harmony-one/harmony/internal/configs/sharding" shardingconfig "github.com/harmony-one/harmony/internal/configs/sharding"
) )
func TestIsEpochBlock(t *testing.T) { func TestIsEpochBlock(t *testing.T) {
block1 := types.NewBlock(&types.Header{Number: big.NewInt(10)}, nil, nil, nil, nil) block1 := types.NewBlock(&block.Header{Number: big.NewInt(10)}, nil, nil, nil, nil)
block2 := types.NewBlock(&types.Header{Number: big.NewInt(0)}, nil, nil, nil, nil) block2 := types.NewBlock(&block.Header{Number: big.NewInt(0)}, nil, nil, nil, nil)
block3 := types.NewBlock(&types.Header{Number: big.NewInt(344064)}, nil, nil, nil, nil) block3 := types.NewBlock(&block.Header{Number: big.NewInt(344064)}, nil, nil, nil, nil)
block4 := types.NewBlock(&types.Header{Number: big.NewInt(77)}, nil, nil, nil, nil) block4 := types.NewBlock(&block.Header{Number: big.NewInt(77)}, nil, nil, nil, nil)
block5 := types.NewBlock(&types.Header{Number: big.NewInt(78)}, nil, nil, nil, nil) block5 := types.NewBlock(&block.Header{Number: big.NewInt(78)}, nil, nil, nil, nil)
block6 := types.NewBlock(&types.Header{Number: big.NewInt(188)}, nil, nil, nil, nil) block6 := types.NewBlock(&block.Header{Number: big.NewInt(188)}, nil, nil, nil, nil)
block7 := types.NewBlock(&types.Header{Number: big.NewInt(189)}, nil, nil, nil, nil) block7 := types.NewBlock(&block.Header{Number: big.NewInt(189)}, nil, nil, nil, nil)
tests := []struct { tests := []struct {
schedule shardingconfig.Schedule schedule shardingconfig.Schedule
block *types.Block block *types.Block

@ -20,6 +20,8 @@ import (
"math/big" "math/big"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/harmony-one/harmony/block"
consensus_engine "github.com/harmony-one/harmony/consensus/engine" consensus_engine "github.com/harmony-one/harmony/consensus/engine"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
"github.com/harmony-one/harmony/core/vm" "github.com/harmony-one/harmony/core/vm"
@ -32,11 +34,11 @@ type ChainContext interface {
Engine() consensus_engine.Engine Engine() consensus_engine.Engine
// GetHeader returns the hash corresponding to their hash. // GetHeader returns the hash corresponding to their hash.
GetHeader(common.Hash, uint64) *types.Header GetHeader(common.Hash, uint64) *block.Header
} }
// NewEVMContext creates a new context for use in the EVM. // NewEVMContext creates a new context for use in the EVM.
func NewEVMContext(msg Message, header *types.Header, chain ChainContext, author *common.Address) vm.Context { func NewEVMContext(msg Message, header *block.Header, chain ChainContext, author *common.Address) vm.Context {
// If we don't have an explicit author (i.e. not mining), extract from the header // If we don't have an explicit author (i.e. not mining), extract from the header
var beneficiary common.Address var beneficiary common.Address
if author == nil { if author == nil {
@ -59,7 +61,7 @@ func NewEVMContext(msg Message, header *types.Header, chain ChainContext, author
} }
// GetHashFn returns a GetHashFunc which retrieves header hashes by number // GetHashFn returns a GetHashFunc which retrieves header hashes by number
func GetHashFn(ref *types.Header, chain ChainContext) func(n uint64) common.Hash { func GetHashFn(ref *block.Header, chain ChainContext) func(n uint64) common.Hash {
var cache map[uint64]common.Hash var cache map[uint64]common.Hash
return func(n uint64) common.Hash { return func(n uint64) common.Hash {

@ -32,10 +32,12 @@ import (
"github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rlp"
"github.com/harmony-one/harmony/internal/params" "github.com/harmony-one/harmony/internal/params"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/rawdb" "github.com/harmony-one/harmony/core/rawdb"
"github.com/harmony-one/harmony/core/state" "github.com/harmony-one/harmony/core/state"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/shard"
) )
// no go:generate gencodec -type Genesis -field-override genesisSpecMarshaling -out gen_genesis.go // no go:generate gencodec -type Genesis -field-override genesisSpecMarshaling -out gen_genesis.go
@ -56,7 +58,7 @@ type Genesis struct {
Coinbase common.Address `json:"coinbase"` Coinbase common.Address `json:"coinbase"`
Alloc GenesisAlloc `json:"alloc" gencodec:"required"` Alloc GenesisAlloc `json:"alloc" gencodec:"required"`
ShardStateHash common.Hash `json:"shardStateHash" gencodec:"required"` ShardStateHash common.Hash `json:"shardStateHash" gencodec:"required"`
ShardState types.ShardState `json:"shardState" gencodec:"required"` ShardState shard.State `json:"shardState" gencodec:"required"`
// These fields are used for consensus tests. Please don't use them // These fields are used for consensus tests. Please don't use them
// in actual genesis blocks. // in actual genesis blocks.
@ -243,7 +245,7 @@ func (g *Genesis) ToBlock(db ethdb.Database) *types.Block {
utils.Logger().Error().Msg("failed to rlp-serialize genesis shard state") utils.Logger().Error().Msg("failed to rlp-serialize genesis shard state")
os.Exit(1) os.Exit(1)
} }
head := &types.Header{ head := &block.Header{
Number: new(big.Int).SetUint64(g.Number), Number: new(big.Int).SetUint64(g.Number),
Epoch: big.NewInt(0), Epoch: big.NewInt(0),
ShardID: g.ShardID, ShardID: g.ShardID,

@ -31,6 +31,7 @@ import (
"github.com/harmony-one/harmony/internal/params" "github.com/harmony-one/harmony/internal/params"
lru "github.com/hashicorp/golang-lru" lru "github.com/hashicorp/golang-lru"
"github.com/harmony-one/harmony/block"
consensus_engine "github.com/harmony-one/harmony/consensus/engine" consensus_engine "github.com/harmony-one/harmony/consensus/engine"
"github.com/harmony-one/harmony/core/rawdb" "github.com/harmony-one/harmony/core/rawdb"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
@ -52,7 +53,7 @@ type HeaderChain struct {
config *params.ChainConfig config *params.ChainConfig
chainDb ethdb.Database chainDb ethdb.Database
genesisHeader *types.Header genesisHeader *block.Header
currentHeader atomic.Value // Current head of the header chain (may be above the block chain!) currentHeader atomic.Value // Current head of the header chain (may be above the block chain!)
currentHeaderHash common.Hash // Hash of the current head of the header chain (prevent recomputing all the time) currentHeaderHash common.Hash // Hash of the current head of the header chain (prevent recomputing all the time)
@ -132,7 +133,7 @@ func (hc *HeaderChain) GetBlockNumber(hash common.Hash) *uint64 {
// without the real blocks. Hence, writing headers directly should only be done // without the real blocks. Hence, writing headers directly should only be done
// in two scenarios: pure-header mode of operation (light clients), or properly // in two scenarios: pure-header mode of operation (light clients), or properly
// separated header/block phases (non-archive clients). // separated header/block phases (non-archive clients).
func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, err error) { func (hc *HeaderChain) WriteHeader(header *block.Header) (status WriteStatus, err error) {
// Cache some values to prevent constant recalculation // Cache some values to prevent constant recalculation
var ( var (
hash = header.Hash() hash = header.Hash()
@ -199,10 +200,10 @@ func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, er
// processed and light chain events sent, while in a BlockChain this is not // processed and light chain events sent, while in a BlockChain this is not
// necessary since chain events are sent after inserting blocks. Second, the // necessary since chain events are sent after inserting blocks. Second, the
// header writes should be protected by the parent chain mutex individually. // header writes should be protected by the parent chain mutex individually.
type WhCallback func(*types.Header) error type WhCallback func(*block.Header) error
// ValidateHeaderChain validates header chain. // ValidateHeaderChain validates header chain.
func (hc *HeaderChain) ValidateHeaderChain(chain []*types.Header, checkFreq int) (int, error) { func (hc *HeaderChain) ValidateHeaderChain(chain []*block.Header, checkFreq int) (int, error) {
// Do a sanity check that the provided chain is actually ordered and linked // Do a sanity check that the provided chain is actually ordered and linked
for i := 1; i < len(chain); i++ { for i := 1; i < len(chain); i++ {
if chain[i].Number.Uint64() != chain[i-1].Number.Uint64()+1 || chain[i].ParentHash != chain[i-1].Hash() { if chain[i].Number.Uint64() != chain[i-1].Number.Uint64()+1 || chain[i].ParentHash != chain[i-1].Hash() {
@ -259,7 +260,7 @@ func (hc *HeaderChain) ValidateHeaderChain(chain []*types.Header, checkFreq int)
// should be done or not. The reason behind the optional check is because some // should be done or not. The reason behind the optional check is because some
// of the header retrieval mechanisms already need to verfy nonces, as well as // of the header retrieval mechanisms already need to verfy nonces, as well as
// because nonces can be verified sparsely, not needing to check each. // because nonces can be verified sparsely, not needing to check each.
func (hc *HeaderChain) InsertHeaderChain(chain []*types.Header, writeHeader WhCallback, start time.Time) (int, error) { func (hc *HeaderChain) InsertHeaderChain(chain []*block.Header, writeHeader WhCallback, start time.Time) (int, error) {
// Collect some import statistics to report on // Collect some import statistics to report on
stats := struct{ processed, ignored int }{} stats := struct{ processed, ignored int }{}
// All headers passed verification, import them into the database // All headers passed verification, import them into the database
@ -395,10 +396,10 @@ func (hc *HeaderChain) WriteTd(hash common.Hash, number uint64, td *big.Int) err
// GetHeader retrieves a block header from the database by hash and number, // GetHeader retrieves a block header from the database by hash and number,
// caching it if found. // caching it if found.
func (hc *HeaderChain) GetHeader(hash common.Hash, number uint64) *types.Header { func (hc *HeaderChain) GetHeader(hash common.Hash, number uint64) *block.Header {
// Short circuit if the header's already in the cache, retrieve otherwise // Short circuit if the header's already in the cache, retrieve otherwise
if header, ok := hc.headerCache.Get(hash); ok { if header, ok := hc.headerCache.Get(hash); ok {
return header.(*types.Header) return header.(*block.Header)
} }
header := rawdb.ReadHeader(hc.chainDb, hash, number) header := rawdb.ReadHeader(hc.chainDb, hash, number)
if header == nil { if header == nil {
@ -411,7 +412,7 @@ func (hc *HeaderChain) GetHeader(hash common.Hash, number uint64) *types.Header
// GetHeaderByHash retrieves a block header from the database by hash, caching it if // GetHeaderByHash retrieves a block header from the database by hash, caching it if
// found. // found.
func (hc *HeaderChain) GetHeaderByHash(hash common.Hash) *types.Header { func (hc *HeaderChain) GetHeaderByHash(hash common.Hash) *block.Header {
number := hc.GetBlockNumber(hash) number := hc.GetBlockNumber(hash)
if number == nil { if number == nil {
return nil return nil
@ -429,7 +430,7 @@ func (hc *HeaderChain) HasHeader(hash common.Hash, number uint64) bool {
// GetHeaderByNumber retrieves a block header from the database by number, // GetHeaderByNumber retrieves a block header from the database by number,
// caching it (associated with its hash) if found. // caching it (associated with its hash) if found.
func (hc *HeaderChain) GetHeaderByNumber(number uint64) *types.Header { func (hc *HeaderChain) GetHeaderByNumber(number uint64) *block.Header {
hash := rawdb.ReadCanonicalHash(hc.chainDb, number) hash := rawdb.ReadCanonicalHash(hc.chainDb, number)
if hash == (common.Hash{}) { if hash == (common.Hash{}) {
return nil return nil
@ -439,12 +440,12 @@ func (hc *HeaderChain) GetHeaderByNumber(number uint64) *types.Header {
// CurrentHeader retrieves the current head header of the canonical chain. The // CurrentHeader retrieves the current head header of the canonical chain. The
// header is retrieved from the HeaderChain's internal cache. // header is retrieved from the HeaderChain's internal cache.
func (hc *HeaderChain) CurrentHeader() *types.Header { func (hc *HeaderChain) CurrentHeader() *block.Header {
return hc.currentHeader.Load().(*types.Header) return hc.currentHeader.Load().(*block.Header)
} }
// SetCurrentHeader sets the current head header of the canonical chain. // SetCurrentHeader sets the current head header of the canonical chain.
func (hc *HeaderChain) SetCurrentHeader(head *types.Header) { func (hc *HeaderChain) SetCurrentHeader(head *block.Header) {
rawdb.WriteHeadHeaderHash(hc.chainDb, head.Hash()) rawdb.WriteHeadHeaderHash(hc.chainDb, head.Hash())
hc.currentHeader.Store(head) hc.currentHeader.Store(head)
@ -495,7 +496,7 @@ func (hc *HeaderChain) SetHead(head uint64, delFn DeleteCallback) {
} }
// SetGenesis sets a new genesis block header for the chain // SetGenesis sets a new genesis block header for the chain
func (hc *HeaderChain) SetGenesis(head *types.Header) { func (hc *HeaderChain) SetGenesis(head *block.Header) {
hc.genesisHeader = head hc.genesisHeader = head
} }

@ -24,9 +24,11 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rlp"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
"github.com/harmony-one/harmony/internal/ctxerror" "github.com/harmony-one/harmony/internal/ctxerror"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/shard"
) )
// Indicate whether the receipts corresponding to a blockHash is spent or not // Indicate whether the receipts corresponding to a blockHash is spent or not
@ -150,12 +152,12 @@ func HasHeader(db DatabaseReader, hash common.Hash, number uint64) bool {
} }
// ReadHeader retrieves the block header corresponding to the hash. // ReadHeader retrieves the block header corresponding to the hash.
func ReadHeader(db DatabaseReader, hash common.Hash, number uint64) *types.Header { func ReadHeader(db DatabaseReader, hash common.Hash, number uint64) *block.Header {
data := ReadHeaderRLP(db, hash, number) data := ReadHeaderRLP(db, hash, number)
if len(data) == 0 { if len(data) == 0 {
return nil return nil
} }
header := new(types.Header) header := new(block.Header)
if err := rlp.Decode(bytes.NewReader(data), header); err != nil { if err := rlp.Decode(bytes.NewReader(data), header); err != nil {
utils.Logger().Error().Err(err).Str("hash", hash.Hex()).Msg("Invalid block header RLP") utils.Logger().Error().Err(err).Str("hash", hash.Hex()).Msg("Invalid block header RLP")
return nil return nil
@ -165,7 +167,7 @@ func ReadHeader(db DatabaseReader, hash common.Hash, number uint64) *types.Heade
// WriteHeader stores a block header into the database and also stores the hash- // WriteHeader stores a block header into the database and also stores the hash-
// to-number mapping. // to-number mapping.
func WriteHeader(db DatabaseWriter, header *types.Header) { func WriteHeader(db DatabaseWriter, header *block.Header) {
// Write the hash -> number mapping // Write the hash -> number mapping
var ( var (
hash = header.Hash() hash = header.Hash()
@ -383,7 +385,7 @@ func DeleteBlock(db DatabaseDeleter, hash common.Hash, number uint64) {
} }
// FindCommonAncestor returns the last common ancestor of two block headers // FindCommonAncestor returns the last common ancestor of two block headers
func FindCommonAncestor(db DatabaseReader, a, b *types.Header) *types.Header { func FindCommonAncestor(db DatabaseReader, a, b *block.Header) *block.Header {
for bn := b.Number.Uint64(); a.Number.Uint64() > bn; { for bn := b.Number.Uint64(); a.Number.Uint64() > bn; {
a = ReadHeader(db, a.ParentHash, a.Number.Uint64()-1) a = ReadHeader(db, a.ParentHash, a.Number.Uint64()-1)
if a == nil { if a == nil {
@ -412,7 +414,7 @@ func FindCommonAncestor(db DatabaseReader, a, b *types.Header) *types.Header {
// ReadShardState retrieves sharding state. // ReadShardState retrieves sharding state.
func ReadShardState( func ReadShardState(
db DatabaseReader, epoch *big.Int, db DatabaseReader, epoch *big.Int,
) (shardState types.ShardState, err error) { ) (shardState shard.State, err error) {
var data []byte var data []byte
data, err = db.Get(shardStateKey(epoch)) data, err = db.Get(shardStateKey(epoch))
if err != nil { if err != nil {
@ -430,7 +432,7 @@ func ReadShardState(
// WriteShardState stores sharding state into database. // WriteShardState stores sharding state into database.
func WriteShardState( func WriteShardState(
db DatabaseWriter, epoch *big.Int, shardState types.ShardState, db DatabaseWriter, epoch *big.Int, shardState shard.State,
) (err error) { ) (err error) {
data, err := rlp.EncodeToBytes(shardState) data, err := rlp.EncodeToBytes(shardState)
if err != nil { if err != nil {

@ -27,10 +27,12 @@ import (
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rlp"
"github.com/golang/mock/gomock" "github.com/golang/mock/gomock"
mock "github.com/harmony-one/harmony/core/rawdb/mock"
"github.com/harmony-one/harmony/core/types"
"github.com/syndtr/goleveldb/leveldb" "github.com/syndtr/goleveldb/leveldb"
"golang.org/x/crypto/sha3" "golang.org/x/crypto/sha3"
"github.com/harmony-one/harmony/block"
mock "github.com/harmony-one/harmony/core/rawdb/mock"
"github.com/harmony-one/harmony/core/types"
) )
// Tests block header storage and retrieval operations. // Tests block header storage and retrieval operations.
@ -38,7 +40,7 @@ func TestHeaderStorage(t *testing.T) {
db := ethdb.NewMemDatabase() db := ethdb.NewMemDatabase()
// Create a test header to move around the database and make sure it's really new // Create a test header to move around the database and make sure it's really new
header := &types.Header{Number: big.NewInt(42), Extra: []byte("test header")} header := &block.Header{Number: big.NewInt(42), Extra: []byte("test header")}
if entry := ReadHeader(db, header.Hash(), header.Number.Uint64()); entry != nil { if entry := ReadHeader(db, header.Hash(), header.Number.Uint64()); entry != nil {
t.Fatalf("Non existent header returned: %v", entry) t.Fatalf("Non existent header returned: %v", entry)
} }
@ -71,7 +73,7 @@ func TestBodyStorage(t *testing.T) {
db := ethdb.NewMemDatabase() db := ethdb.NewMemDatabase()
// Create a test body to move around the database and make sure it's really new // Create a test body to move around the database and make sure it's really new
body := &types.Body{Uncles: []*types.Header{{Extra: []byte("test header")}}} body := &types.Body{Uncles: []*block.Header{{Extra: []byte("test header")}}}
hasher := sha3.NewLegacyKeccak256() hasher := sha3.NewLegacyKeccak256()
rlp.Encode(hasher, body) rlp.Encode(hasher, body)
@ -109,7 +111,7 @@ func TestBlockStorage(t *testing.T) {
db := ethdb.NewMemDatabase() db := ethdb.NewMemDatabase()
// Create a test block to move around the database and make sure it's really new // Create a test block to move around the database and make sure it's really new
block := types.NewBlockWithHeader(&types.Header{ block := types.NewBlockWithHeader(&block.Header{
Extra: []byte("test block"), Extra: []byte("test block"),
TxHash: types.EmptyRootHash, TxHash: types.EmptyRootHash,
ReceiptHash: types.EmptyRootHash, ReceiptHash: types.EmptyRootHash,
@ -169,7 +171,7 @@ func TestBlockStorage(t *testing.T) {
// Tests that partial block contents don't get reassembled into full blocks. // Tests that partial block contents don't get reassembled into full blocks.
func TestPartialBlockStorage(t *testing.T) { func TestPartialBlockStorage(t *testing.T) {
db := ethdb.NewMemDatabase() db := ethdb.NewMemDatabase()
block := types.NewBlockWithHeader(&types.Header{ block := types.NewBlockWithHeader(&block.Header{
Extra: []byte("test block"), Extra: []byte("test block"),
TxHash: types.EmptyRootHash, TxHash: types.EmptyRootHash,
ReceiptHash: types.EmptyRootHash, ReceiptHash: types.EmptyRootHash,
@ -249,9 +251,9 @@ func TestCanonicalMappingStorage(t *testing.T) {
func TestHeadStorage(t *testing.T) { func TestHeadStorage(t *testing.T) {
db := ethdb.NewMemDatabase() db := ethdb.NewMemDatabase()
blockHead := types.NewBlockWithHeader(&types.Header{Extra: []byte("test block header")}) blockHead := types.NewBlockWithHeader(&block.Header{Extra: []byte("test block header")})
blockFull := types.NewBlockWithHeader(&types.Header{Extra: []byte("test block full")}) blockFull := types.NewBlockWithHeader(&block.Header{Extra: []byte("test block full")})
blockFast := types.NewBlockWithHeader(&types.Header{Extra: []byte("test block fast")}) blockFast := types.NewBlockWithHeader(&block.Header{Extra: []byte("test block fast")})
// Check that no head entries are in a pristine database // Check that no head entries are in a pristine database
if entry := ReadHeadHeaderHash(db); entry != (common.Hash{}) { if entry := ReadHeadHeaderHash(db); entry != (common.Hash{}) {

@ -22,6 +22,8 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
block2 "github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
) )
@ -34,7 +36,7 @@ func TestLookupStorage(t *testing.T) {
tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), 0, big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33}) tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), 0, big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33})
txs := []*types.Transaction{tx1, tx2, tx3} txs := []*types.Transaction{tx1, tx2, tx3}
block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, nil, nil) block := types.NewBlock(&block2.Header{Number: big.NewInt(314)}, txs, nil, nil, nil)
// Check that no transactions entries are in a pristine database // Check that no transactions entries are in a pristine database
for i, tx := range txs { for i, tx := range txs {

@ -12,11 +12,11 @@ import (
"github.com/harmony-one/bls/ffi/go/bls" "github.com/harmony-one/bls/ffi/go/bls"
"github.com/harmony-one/harmony/contracts/structs" "github.com/harmony-one/harmony/contracts/structs"
"github.com/harmony-one/harmony/core/types"
common2 "github.com/harmony-one/harmony/internal/common" common2 "github.com/harmony-one/harmony/internal/common"
shardingconfig "github.com/harmony-one/harmony/internal/configs/sharding" shardingconfig "github.com/harmony-one/harmony/internal/configs/sharding"
"github.com/harmony-one/harmony/internal/ctxerror" "github.com/harmony-one/harmony/internal/ctxerror"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/shard"
) )
const ( const (
@ -31,7 +31,7 @@ type ShardingState struct {
epoch uint64 // current epoch epoch uint64 // current epoch
rnd uint64 // random seed for resharding rnd uint64 // random seed for resharding
numShards int // TODO ek – equal to len(shardState); remove this numShards int // TODO ek – equal to len(shardState); remove this
shardState types.ShardState shardState shard.State
} }
// sortedCommitteeBySize will sort shards by size // sortedCommitteeBySize will sort shards by size
@ -46,7 +46,7 @@ func (ss *ShardingState) sortCommitteeBySize() {
} }
// assignNewNodes add new nodes into the N/2 active committees evenly // assignNewNodes add new nodes into the N/2 active committees evenly
func (ss *ShardingState) assignNewNodes(newNodeList []types.NodeID) { func (ss *ShardingState) assignNewNodes(newNodeList []shard.NodeID) {
ss.sortCommitteeBySize() ss.sortCommitteeBySize()
numActiveShards := ss.numShards / 2 numActiveShards := ss.numShards / 2
Shuffle(newNodeList) Shuffle(newNodeList)
@ -66,7 +66,7 @@ func (ss *ShardingState) assignNewNodes(newNodeList []types.NodeID) {
// cuckooResharding uses cuckoo rule to reshard X% of active committee(shards) into inactive committee(shards) // cuckooResharding uses cuckoo rule to reshard X% of active committee(shards) into inactive committee(shards)
func (ss *ShardingState) cuckooResharding(percent float64) { func (ss *ShardingState) cuckooResharding(percent float64) {
numActiveShards := ss.numShards / 2 numActiveShards := ss.numShards / 2
kickedNodes := []types.NodeID{} kickedNodes := []shard.NodeID{}
for i := range ss.shardState { for i := range ss.shardState {
if i >= numActiveShards { if i >= numActiveShards {
break break
@ -96,12 +96,12 @@ func (ss *ShardingState) cuckooResharding(percent float64) {
} }
// Reshard will first add new nodes into shards, then use cuckoo rule to reshard to get new shard state // Reshard will first add new nodes into shards, then use cuckoo rule to reshard to get new shard state
func (ss *ShardingState) Reshard(newNodeList []types.NodeID, percent float64) { func (ss *ShardingState) Reshard(newNodeList []shard.NodeID, percent float64) {
rand.Seed(int64(ss.rnd)) rand.Seed(int64(ss.rnd))
ss.sortCommitteeBySize() ss.sortCommitteeBySize()
// Take out and preserve leaders // Take out and preserve leaders
leaders := []types.NodeID{} leaders := []shard.NodeID{}
for i := 0; i < ss.numShards; i++ { for i := 0; i < ss.numShards; i++ {
if len(ss.shardState[i].NodeList) > 0 { if len(ss.shardState[i].NodeList) > 0 {
leaders = append(leaders, ss.shardState[i].NodeList[0]) leaders = append(leaders, ss.shardState[i].NodeList[0])
@ -119,15 +119,15 @@ func (ss *ShardingState) Reshard(newNodeList []types.NodeID, percent float64) {
utils.Logger().Error().Msg("Not enough leaders to assign to shards") utils.Logger().Error().Msg("Not enough leaders to assign to shards")
} }
for i := 0; i < ss.numShards; i++ { for i := 0; i < ss.numShards; i++ {
ss.shardState[i].NodeList = append([]types.NodeID{leaders[i]}, ss.shardState[i].NodeList...) ss.shardState[i].NodeList = append([]shard.NodeID{leaders[i]}, ss.shardState[i].NodeList...)
} }
} }
// Shuffle will shuffle the list with result uniquely determined by seed, assuming there is no repeat items in the list // Shuffle will shuffle the list with result uniquely determined by seed, assuming there is no repeat items in the list
func Shuffle(list []types.NodeID) { func Shuffle(list []shard.NodeID) {
// Sort to make sure everyone will generate the same with the same rand seed. // Sort to make sure everyone will generate the same with the same rand seed.
sort.Slice(list, func(i, j int) bool { sort.Slice(list, func(i, j int) bool {
return types.CompareNodeIDByBLSKey(list[i], list[j]) == -1 return shard.CompareNodeIDByBLSKey(list[i], list[j]) == -1
}) })
rand.Shuffle(len(list), func(i, j int) { rand.Shuffle(len(list), func(i, j int) {
list[i], list[j] = list[j], list[i] list[i], list[j] = list[j], list[i]
@ -175,7 +175,7 @@ func GetShardingStateFromBlockChain(bc *BlockChain, epoch *big.Int) (*ShardingSt
func CalculateNewShardState( func CalculateNewShardState(
bc *BlockChain, epoch *big.Int, bc *BlockChain, epoch *big.Int,
stakeInfo *map[common.Address]*structs.StakeInfo, stakeInfo *map[common.Address]*structs.StakeInfo,
) (types.ShardState, error) { ) (shard.State, error) {
if epoch.Cmp(big.NewInt(GenesisEpoch)) == 0 { if epoch.Cmp(big.NewInt(GenesisEpoch)) == 0 {
return GetInitShardState(), nil return GetInitShardState(), nil
} }
@ -192,8 +192,8 @@ func CalculateNewShardState(
} }
// UpdateShardingState remove the unstaked nodes and returns the newly staked node Ids. // UpdateShardingState remove the unstaked nodes and returns the newly staked node Ids.
func (ss *ShardingState) UpdateShardingState(stakeInfo *map[common.Address]*structs.StakeInfo) []types.NodeID { func (ss *ShardingState) UpdateShardingState(stakeInfo *map[common.Address]*structs.StakeInfo) []shard.NodeID {
oldBlsPublicKeys := make(map[types.BlsPublicKey]bool) // map of bls public keys oldBlsPublicKeys := make(map[shard.BlsPublicKey]bool) // map of bls public keys
for _, shard := range ss.shardState { for _, shard := range ss.shardState {
newNodeList := shard.NodeList newNodeList := shard.NodeList
for _, nodeID := range shard.NodeList { for _, nodeID := range shard.NodeList {
@ -208,11 +208,11 @@ func (ss *ShardingState) UpdateShardingState(stakeInfo *map[common.Address]*stru
shard.NodeList = newNodeList shard.NodeList = newNodeList
} }
newAddresses := []types.NodeID{} newAddresses := []shard.NodeID{}
for addr, info := range *stakeInfo { for addr, info := range *stakeInfo {
_, ok := oldBlsPublicKeys[info.BlsPublicKey] _, ok := oldBlsPublicKeys[info.BlsPublicKey]
if !ok { if !ok {
newAddresses = append(newAddresses, types.NodeID{ newAddresses = append(newAddresses, shard.NodeID{
EcdsaAddress: addr, EcdsaAddress: addr,
BlsPublicKey: info.BlsPublicKey, BlsPublicKey: info.BlsPublicKey,
}) })
@ -230,12 +230,12 @@ func (ss *ShardingState) UpdateShardingState(stakeInfo *map[common.Address]*stru
var ShardingSchedule shardingconfig.Schedule = shardingconfig.MainnetSchedule var ShardingSchedule shardingconfig.Schedule = shardingconfig.MainnetSchedule
// GetInitShardState returns the initial shard state at genesis. // GetInitShardState returns the initial shard state at genesis.
func GetInitShardState() types.ShardState { func GetInitShardState() shard.State {
return GetShardState(big.NewInt(GenesisEpoch)) return GetShardState(big.NewInt(GenesisEpoch))
} }
// GetShardState returns the shard state based on epoch number // GetShardState returns the shard state based on epoch number
func GetShardState(epoch *big.Int) types.ShardState { func GetShardState(epoch *big.Int) shard.State {
utils.Logger().Info().Int64("epoch", epoch.Int64()).Msg("Get Shard State of Epoch.") utils.Logger().Info().Int64("epoch", epoch.Int64()).Msg("Get Shard State of Epoch.")
shardingConfig := ShardingSchedule.InstanceForEpoch(epoch) shardingConfig := ShardingSchedule.InstanceForEpoch(epoch)
shardNum := int(shardingConfig.NumShards()) shardNum := int(shardingConfig.NumShards())
@ -244,18 +244,18 @@ func GetShardState(epoch *big.Int) types.ShardState {
hmyAccounts := shardingConfig.HmyAccounts() hmyAccounts := shardingConfig.HmyAccounts()
fnAccounts := shardingConfig.FnAccounts() fnAccounts := shardingConfig.FnAccounts()
shardState := types.ShardState{} shardState := shard.State{}
for i := 0; i < shardNum; i++ { for i := 0; i < shardNum; i++ {
com := types.Committee{ShardID: uint32(i)} com := shard.Committee{ShardID: uint32(i)}
for j := 0; j < shardHarmonyNodes; j++ { for j := 0; j < shardHarmonyNodes; j++ {
index := i + j*shardNum // The initial account to use for genesis nodes index := i + j*shardNum // The initial account to use for genesis nodes
pub := &bls.PublicKey{} pub := &bls.PublicKey{}
pub.DeserializeHexStr(hmyAccounts[index].BlsPublicKey) pub.DeserializeHexStr(hmyAccounts[index].BlsPublicKey)
pubKey := types.BlsPublicKey{} pubKey := shard.BlsPublicKey{}
pubKey.FromLibBLSPublicKey(pub) pubKey.FromLibBLSPublicKey(pub)
// TODO: directly read address for bls too // TODO: directly read address for bls too
curNodeID := types.NodeID{ curNodeID := shard.NodeID{
EcdsaAddress: common2.ParseAddr(hmyAccounts[index].Address), EcdsaAddress: common2.ParseAddr(hmyAccounts[index].Address),
BlsPublicKey: pubKey, BlsPublicKey: pubKey,
} }
@ -269,10 +269,10 @@ func GetShardState(epoch *big.Int) types.ShardState {
pub := &bls.PublicKey{} pub := &bls.PublicKey{}
pub.DeserializeHexStr(fnAccounts[index].BlsPublicKey) pub.DeserializeHexStr(fnAccounts[index].BlsPublicKey)
pubKey := types.BlsPublicKey{} pubKey := shard.BlsPublicKey{}
pubKey.FromLibBLSPublicKey(pub) pubKey.FromLibBLSPublicKey(pub)
// TODO: directly read address for bls too // TODO: directly read address for bls too
curNodeID := types.NodeID{ curNodeID := shard.NodeID{
EcdsaAddress: common2.ParseAddr(fnAccounts[index].Address), EcdsaAddress: common2.ParseAddr(fnAccounts[index].Address),
BlsPublicKey: pubKey, BlsPublicKey: pubKey,
} }

@ -8,7 +8,8 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/shard"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
@ -38,17 +39,17 @@ func init() {
copy(blsPubKey10[:], []byte("random key 10")) copy(blsPubKey10[:], []byte("random key 10"))
} }
func fakeGetInitShardState(numberOfShards, numOfNodes int) types.ShardState { func fakeGetInitShardState(numberOfShards, numOfNodes int) shard.State {
rand.Seed(int64(42)) rand.Seed(int64(42))
shardState := types.ShardState{} shardState := shard.State{}
for i := 0; i < numberOfShards; i++ { for i := 0; i < numberOfShards; i++ {
sid := uint32(i) sid := uint32(i)
com := types.Committee{ShardID: sid} com := shard.Committee{ShardID: sid}
for j := 0; j < numOfNodes; j++ { for j := 0; j < numOfNodes; j++ {
nid := strconv.Itoa(int(rand.Int63())) nid := strconv.Itoa(int(rand.Int63()))
blsPubKey := [48]byte{} blsPubKey := [48]byte{}
copy(blsPubKey1[:], []byte(nid)) copy(blsPubKey1[:], []byte(nid))
com.NodeList = append(com.NodeList, types.NodeID{ com.NodeList = append(com.NodeList, shard.NodeID{
EcdsaAddress: common.BytesToAddress([]byte(nid)), EcdsaAddress: common.BytesToAddress([]byte(nid)),
BlsPublicKey: blsPubKey, BlsPublicKey: blsPubKey,
}) })
@ -58,15 +59,15 @@ func fakeGetInitShardState(numberOfShards, numOfNodes int) types.ShardState {
return shardState return shardState
} }
func fakeNewNodeList(seed int64) []types.NodeID { func fakeNewNodeList(seed int64) []shard.NodeID {
rand.Seed(seed) rand.Seed(seed)
numNewNodes := rand.Intn(10) numNewNodes := rand.Intn(10)
nodeList := []types.NodeID{} nodeList := []shard.NodeID{}
for i := 0; i < numNewNodes; i++ { for i := 0; i < numNewNodes; i++ {
nid := strconv.Itoa(int(rand.Int63())) nid := strconv.Itoa(int(rand.Int63()))
blsPubKey := [48]byte{} blsPubKey := [48]byte{}
copy(blsPubKey1[:], []byte(nid)) copy(blsPubKey1[:], []byte(nid))
nodeList = append(nodeList, types.NodeID{ nodeList = append(nodeList, shard.NodeID{
EcdsaAddress: common.BytesToAddress([]byte(nid)), EcdsaAddress: common.BytesToAddress([]byte(nid)),
BlsPublicKey: blsPubKey, BlsPublicKey: blsPubKey,
}) })
@ -80,7 +81,7 @@ func TestFakeNewNodeList(t *testing.T) {
} }
func TestShuffle(t *testing.T) { func TestShuffle(t *testing.T) {
nodeList := []types.NodeID{ nodeList := []shard.NodeID{
{EcdsaAddress: common.Address{0x12}, BlsPublicKey: blsPubKey1}, {EcdsaAddress: common.Address{0x12}, BlsPublicKey: blsPubKey1},
{EcdsaAddress: common.Address{0x22}, BlsPublicKey: blsPubKey2}, {EcdsaAddress: common.Address{0x22}, BlsPublicKey: blsPubKey2},
{EcdsaAddress: common.Address{0x32}, BlsPublicKey: blsPubKey3}, {EcdsaAddress: common.Address{0x32}, BlsPublicKey: blsPubKey3},
@ -93,7 +94,7 @@ func TestShuffle(t *testing.T) {
{EcdsaAddress: common.Address{0x02}, BlsPublicKey: blsPubKey10}, {EcdsaAddress: common.Address{0x02}, BlsPublicKey: blsPubKey10},
} }
cpList := []types.NodeID{} cpList := []shard.NodeID{}
cpList = append(cpList, nodeList...) cpList = append(cpList, nodeList...)
Shuffle(nodeList) Shuffle(nodeList)
cnt := 0 cnt := 0
@ -120,7 +121,7 @@ func TestSortCommitteeBySize(t *testing.T) {
func TestUpdateShardState(t *testing.T) { func TestUpdateShardState(t *testing.T) {
shardState := fakeGetInitShardState(6, 10) shardState := fakeGetInitShardState(6, 10)
ss := &ShardingState{epoch: 1, rnd: 42, shardState: shardState, numShards: len(shardState)} ss := &ShardingState{epoch: 1, rnd: 42, shardState: shardState, numShards: len(shardState)}
newNodeList := []types.NodeID{ newNodeList := []shard.NodeID{
{EcdsaAddress: common.Address{0x12}, BlsPublicKey: blsPubKey1}, {EcdsaAddress: common.Address{0x12}, BlsPublicKey: blsPubKey1},
{EcdsaAddress: common.Address{0x22}, BlsPublicKey: blsPubKey2}, {EcdsaAddress: common.Address{0x22}, BlsPublicKey: blsPubKey2},
{EcdsaAddress: common.Address{0x32}, BlsPublicKey: blsPubKey3}, {EcdsaAddress: common.Address{0x32}, BlsPublicKey: blsPubKey3},
@ -136,7 +137,7 @@ func TestUpdateShardState(t *testing.T) {
func TestAssignNewNodes(t *testing.T) { func TestAssignNewNodes(t *testing.T) {
shardState := fakeGetInitShardState(2, 2) shardState := fakeGetInitShardState(2, 2)
ss := &ShardingState{epoch: 1, rnd: 42, shardState: shardState, numShards: len(shardState)} ss := &ShardingState{epoch: 1, rnd: 42, shardState: shardState, numShards: len(shardState)}
newNodes := []types.NodeID{ newNodes := []shard.NodeID{
{EcdsaAddress: common.Address{0x12}, BlsPublicKey: blsPubKey1}, {EcdsaAddress: common.Address{0x12}, BlsPublicKey: blsPubKey1},
{EcdsaAddress: common.Address{0x22}, BlsPublicKey: blsPubKey2}, {EcdsaAddress: common.Address{0x22}, BlsPublicKey: blsPubKey2},
{EcdsaAddress: common.Address{0x32}, BlsPublicKey: blsPubKey3}, {EcdsaAddress: common.Address{0x32}, BlsPublicKey: blsPubKey3},

@ -21,6 +21,8 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/harmony-one/harmony/block"
consensus_engine "github.com/harmony-one/harmony/consensus/engine" consensus_engine "github.com/harmony-one/harmony/consensus/engine"
"github.com/harmony-one/harmony/core/state" "github.com/harmony-one/harmony/core/state"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
@ -101,7 +103,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.DB, cfg vm.C
} }
// return true if it is valid // return true if it is valid
func getTransactionType(header *types.Header, tx *types.Transaction) types.TransactionType { func getTransactionType(header *block.Header, tx *types.Transaction) types.TransactionType {
if tx.ShardID() == tx.ToShardID() && header.ShardID == tx.ShardID() { if tx.ShardID() == tx.ToShardID() && header.ShardID == tx.ShardID() {
return types.SameShardTx return types.SameShardTx
} }
@ -117,7 +119,7 @@ func getTransactionType(header *types.Header, tx *types.Transaction) types.Trans
// and uses the input parameters for its environment. It returns the receipt // and uses the input parameters for its environment. It returns the receipt
// for the transaction, gas used and an error if the transaction failed, // for the transaction, gas used and an error if the transaction failed,
// indicating the block was invalid. // indicating the block was invalid.
func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.DB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, *types.CXReceipt, uint64, error) { func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.DB, header *block.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, *types.CXReceipt, uint64, error) {
txType := getTransactionType(header, tx) txType := getTransactionType(header, tx)
if txType == types.InvalidTx { if txType == types.InvalidTx {
return nil, nil, 0, fmt.Errorf("Invalid Transaction Type") return nil, nil, 0, fmt.Errorf("Invalid Transaction Type")
@ -172,7 +174,7 @@ func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *commo
} }
// ApplyIncomingReceipt will add amount into ToAddress in the receipt // ApplyIncomingReceipt will add amount into ToAddress in the receipt
func ApplyIncomingReceipt(config *params.ChainConfig, db *state.DB, header *types.Header, cxp *types.CXReceiptsProof) error { func ApplyIncomingReceipt(config *params.ChainConfig, db *state.DB, header *block.Header, cxp *types.CXReceiptsProof) error {
if cxp == nil { if cxp == nil {
return nil return nil
} }

@ -32,6 +32,7 @@ import (
"github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/metrics"
"github.com/harmony-one/harmony/internal/params" "github.com/harmony-one/harmony/internal/params"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/state" "github.com/harmony-one/harmony/core/state"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
@ -360,7 +361,7 @@ func (pool *TxPool) loop() {
// lockedReset is a wrapper around reset to allow calling it in a thread safe // lockedReset is a wrapper around reset to allow calling it in a thread safe
// manner. This method is only ever used in the tester! // manner. This method is only ever used in the tester!
func (pool *TxPool) lockedReset(oldHead, newHead *types.Header) { func (pool *TxPool) lockedReset(oldHead, newHead *block.Header) {
pool.mu.Lock() pool.mu.Lock()
defer pool.mu.Unlock() defer pool.mu.Unlock()
@ -369,7 +370,7 @@ func (pool *TxPool) lockedReset(oldHead, newHead *types.Header) {
// reset retrieves the current state of the blockchain and ensures the content // reset retrieves the current state of the blockchain and ensures the content
// of the transaction pool is valid with regard to the chain state. // of the transaction pool is valid with regard to the chain state.
func (pool *TxPool) reset(oldHead, newHead *types.Header) { func (pool *TxPool) reset(oldHead, newHead *block.Header) {
// If we're reorging an old state, reinject all dropped transactions // If we're reorging an old state, reinject all dropped transactions
var reinject types.Transactions var reinject types.Transactions

@ -30,6 +30,8 @@ import (
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/event"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/common/denominations" "github.com/harmony-one/harmony/common/denominations"
"github.com/harmony-one/harmony/core/state" "github.com/harmony-one/harmony/core/state"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
@ -52,7 +54,7 @@ type testBlockChain struct {
} }
func (bc *testBlockChain) CurrentBlock() *types.Block { func (bc *testBlockChain) CurrentBlock() *types.Block {
return types.NewBlock(&types.Header{ return types.NewBlock(&block.Header{
GasLimit: bc.gasLimit, GasLimit: bc.gasLimit,
}, nil, nil, nil, nil) }, nil, nil, nil, nil)
} }

@ -24,16 +24,17 @@ import (
"sort" "sort"
"sync/atomic" "sync/atomic"
"time" "time"
"unsafe"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/hexutil"
ethtypes "github.com/ethereum/go-ethereum/core/types" ethtypes "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rlp"
"github.com/rs/zerolog" "github.com/rs/zerolog"
"golang.org/x/crypto/sha3"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/crypto/hash"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/shard"
) )
// Constants for block. // Constants for block.
@ -69,100 +70,18 @@ func (n *BlockNonce) UnmarshalText(input []byte) error {
return hexutil.UnmarshalFixedText("BlockNonce", input, n[:]) return hexutil.UnmarshalFixedText("BlockNonce", input, n[:])
} }
// Header represents a block header in the Harmony blockchain.
type Header struct {
ParentHash common.Hash `json:"parentHash" gencodec:"required"`
Coinbase common.Address `json:"miner" gencodec:"required"`
Root common.Hash `json:"stateRoot" gencodec:"required"`
TxHash common.Hash `json:"transactionsRoot" gencodec:"required"`
ReceiptHash common.Hash `json:"receiptsRoot" gencodec:"required"`
OutgoingReceiptHash common.Hash `json:"outgoingReceiptsRoot" gencodec:"required"`
IncomingReceiptHash common.Hash `json:"incomingReceiptsRoot" gencodec:"required"`
Bloom ethtypes.Bloom `json:"logsBloom" gencodec:"required"`
Number *big.Int `json:"number" gencodec:"required"`
GasLimit uint64 `json:"gasLimit" gencodec:"required"`
GasUsed uint64 `json:"gasUsed" gencodec:"required"`
Time *big.Int `json:"timestamp" gencodec:"required"`
Extra []byte `json:"extraData" gencodec:"required"`
MixDigest common.Hash `json:"mixHash" gencodec:"required"`
// Additional Fields
ViewID *big.Int `json:"viewID" gencodec:"required"`
Epoch *big.Int `json:"epoch" gencodec:"required"`
ShardID uint32 `json:"shardID" gencodec:"required"`
LastCommitSignature [96]byte `json:"lastCommitSignature" gencodec:"required"`
LastCommitBitmap []byte `json:"lastCommitBitmap" gencodec:"required"` // Contains which validator signed
ShardStateHash common.Hash `json:"shardStateRoot"`
Vrf []byte `json:"vrf"`
Vdf []byte `json:"vdf"`
ShardState []byte `json:"shardState"`
CrossLinks []byte `json:"crossLink"`
}
// field type overrides for gencodec
type headerMarshaling struct {
Difficulty *hexutil.Big
Number *hexutil.Big
GasLimit hexutil.Uint64
GasUsed hexutil.Uint64
Time *hexutil.Big
Extra hexutil.Bytes
Hash common.Hash `json:"hash"` // adds call to Hash() in MarshalJSON
}
// Hash returns the block hash of the header, which is simply the keccak256 hash of its
// RLP encoding.
func (h *Header) Hash() common.Hash {
return rlpHash(h)
}
// Size returns the approximate memory used by all internal contents. It is used
// to approximate and limit the memory consumption of various caches.
func (h *Header) Size() common.StorageSize {
// TODO: update with new fields
return common.StorageSize(unsafe.Sizeof(*h)) + common.StorageSize(len(h.Extra)+(h.Number.BitLen()+h.Time.BitLen())/8)
}
// Logger returns a sub-logger with block contexts added.
func (h *Header) Logger(logger *zerolog.Logger) *zerolog.Logger {
nlogger := logger.
With().
Str("blockHash", h.Hash().Hex()).
Uint32("blockShard", h.ShardID).
Uint64("blockEpoch", h.Epoch.Uint64()).
Uint64("blockNumber", h.Number.Uint64()).
Logger()
return &nlogger
}
// GetShardState returns the deserialized shard state object.
func (h *Header) GetShardState() (ShardState, error) {
shardState := ShardState{}
err := rlp.DecodeBytes(h.ShardState, &shardState)
if err != nil {
return nil, err
}
return shardState, nil
}
func rlpHash(x interface{}) (h common.Hash) {
hw := sha3.NewLegacyKeccak256()
rlp.Encode(hw, x)
hw.Sum(h[:0])
return h
}
// Body is a simple (mutable, non-safe) data container for storing and moving // Body is a simple (mutable, non-safe) data container for storing and moving
// a block's data contents (transactions and uncles) together. // a block's data contents (transactions and uncles) together.
type Body struct { type Body struct {
Transactions []*Transaction Transactions []*Transaction
Uncles []*Header Uncles []*block.Header
IncomingReceipts CXReceiptsProofs IncomingReceipts CXReceiptsProofs
} }
// Block represents an entire block in the Ethereum blockchain. // Block represents an entire block in the Ethereum blockchain.
type Block struct { type Block struct {
header *Header header *block.Header
uncles []*Header uncles []*block.Header
transactions Transactions transactions Transactions
incomingReceipts CXReceiptsProofs incomingReceipts CXReceiptsProofs
@ -208,18 +127,18 @@ type StorageBlock Block
// "external" block encoding. used for eth protocol, etc. // "external" block encoding. used for eth protocol, etc.
type extblock struct { type extblock struct {
Header *Header Header *block.Header
Txs []*Transaction Txs []*Transaction
Uncles []*Header Uncles []*block.Header
IncomingReceipts CXReceiptsProofs IncomingReceipts CXReceiptsProofs
} }
// [deprecated by eth/63] // [deprecated by eth/63]
// "storage" block encoding. used for database. // "storage" block encoding. used for database.
type storageblock struct { type storageblock struct {
Header *Header Header *block.Header
Txs []*Transaction Txs []*Transaction
Uncles []*Header Uncles []*block.Header
TD *big.Int TD *big.Int
} }
@ -230,7 +149,7 @@ type storageblock struct {
// The values of TxHash, UncleHash, ReceiptHash and Bloom in header // The values of TxHash, UncleHash, ReceiptHash and Bloom in header
// are ignored and set to values derived from the given txs, // are ignored and set to values derived from the given txs,
// and receipts. // and receipts.
func NewBlock(header *Header, txs []*Transaction, receipts []*Receipt, outcxs []*CXReceipt, incxs []*CXReceiptsProof) *Block { func NewBlock(header *block.Header, txs []*Transaction, receipts []*Receipt, outcxs []*CXReceipt, incxs []*CXReceiptsProof) *Block {
b := &Block{header: CopyHeader(header)} b := &Block{header: CopyHeader(header)}
// TODO: panic if len(txs) != len(receipts) // TODO: panic if len(txs) != len(receipts)
@ -265,13 +184,13 @@ func NewBlock(header *Header, txs []*Transaction, receipts []*Receipt, outcxs []
// NewBlockWithHeader creates a block with the given header data. The // NewBlockWithHeader creates a block with the given header data. The
// header data is copied, changes to header and to the field values // header data is copied, changes to header and to the field values
// will not affect the block. // will not affect the block.
func NewBlockWithHeader(header *Header) *Block { func NewBlockWithHeader(header *block.Header) *Block {
return &Block{header: CopyHeader(header)} return &Block{header: CopyHeader(header)}
} }
// CopyHeader creates a deep copy of a block header to prevent side effects from // CopyHeader creates a deep copy of a block header to prevent side effects from
// modifying a header variable. // modifying a header variable.
func CopyHeader(h *Header) *Header { func CopyHeader(h *block.Header) *block.Header {
// TODO: update with new fields // TODO: update with new fields
cpy := *h cpy := *h
if cpy.Time = new(big.Int); h.Time != nil { if cpy.Time = new(big.Int); h.Time != nil {
@ -347,7 +266,7 @@ func (b *StorageBlock) DecodeRLP(s *rlp.Stream) error {
} }
// Uncles return uncles. // Uncles return uncles.
func (b *Block) Uncles() []*Header { func (b *Block) Uncles() []*block.Header {
return b.uncles return b.uncles
} }
@ -420,7 +339,7 @@ func (b *Block) OutgoingReceiptHash() common.Hash { return b.header.OutgoingRece
func (b *Block) Extra() []byte { return common.CopyBytes(b.header.Extra) } func (b *Block) Extra() []byte { return common.CopyBytes(b.header.Extra) }
// Header returns a copy of Header. // Header returns a copy of Header.
func (b *Block) Header() *Header { return CopyHeader(b.header) } func (b *Block) Header() *block.Header { return CopyHeader(b.header) }
// Body returns the non-header content of the block. // Body returns the non-header content of the block.
func (b *Block) Body() *Body { return &Body{b.transactions, b.uncles, b.incomingReceipts} } func (b *Block) Body() *Body { return &Body{b.transactions, b.uncles, b.incomingReceipts} }
@ -451,13 +370,13 @@ func (c *writeCounter) Write(b []byte) (int, error) {
} }
// CalcUncleHash returns rlp hash of uncles. // CalcUncleHash returns rlp hash of uncles.
func CalcUncleHash(uncles []*Header) common.Hash { func CalcUncleHash(uncles []*block.Header) common.Hash {
return rlpHash(uncles) return hash.FromRLP(uncles)
} }
// WithSeal returns a new block with the data from b but the header replaced with // WithSeal returns a new block with the data from b but the header replaced with
// the sealed one. // the sealed one.
func (b *Block) WithSeal(header *Header) *Block { func (b *Block) WithSeal(header *block.Header) *Block {
cpy := *header cpy := *header
return &Block{ return &Block{
@ -468,11 +387,11 @@ func (b *Block) WithSeal(header *Header) *Block {
} }
// WithBody returns a new block with the given transaction and uncle contents. // WithBody returns a new block with the given transaction and uncle contents.
func (b *Block) WithBody(transactions []*Transaction, uncles []*Header, incomingReceipts CXReceiptsProofs) *Block { func (b *Block) WithBody(transactions []*Transaction, uncles []*block.Header, incomingReceipts CXReceiptsProofs) *Block {
block := &Block{ block := &Block{
header: CopyHeader(b.header), header: CopyHeader(b.header),
transactions: make([]*Transaction, len(transactions)), transactions: make([]*Transaction, len(transactions)),
uncles: make([]*Header, len(uncles)), uncles: make([]*block.Header, len(uncles)),
incomingReceipts: make([]*CXReceiptsProof, len(incomingReceipts)), incomingReceipts: make([]*CXReceiptsProof, len(incomingReceipts)),
} }
copy(block.transactions, transactions) copy(block.transactions, transactions)
@ -546,8 +465,8 @@ func (b *Block) AddVdf(vdf []byte) {
} }
// AddShardState add shardState into block header // AddShardState add shardState into block header
func (b *Block) AddShardState(shardState ShardState) error { func (b *Block) AddShardState(shardState shard.State) error {
// Make a copy because ShardState.Hash() internally sorts entries. // Make a copy because State.Hash() internally sorts entries.
// Store the sorted copy. // Store the sorted copy.
shardState = append(shardState[:0:0], shardState...) shardState = append(shardState[:0:0], shardState...)
b.header.ShardStateHash = shardState.Hash() b.header.ShardStateHash = shardState.Hash()

@ -20,6 +20,8 @@ package types
import ( import (
"bytes" "bytes"
"testing" "testing"
"github.com/harmony-one/harmony/block"
) )
var ( var (
@ -94,7 +96,7 @@ func TestBlock_SetLastCommitSig(t *testing.T) {
} }
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
b := &Block{header: &Header{}} b := &Block{header: &block.Header{}}
b.SetLastCommitSig(tt.sig, tt.signers) b.SetLastCommitSig(tt.sig, tt.signers)
if !bytes.Equal(tt.sig, b.header.LastCommitSignature[:]) { if !bytes.Equal(tt.sig, b.header.LastCommitSignature[:]) {
t.Errorf("signature mismatch: expected %+v, actual %+v", t.Errorf("signature mismatch: expected %+v, actual %+v",

@ -7,20 +7,22 @@ import (
"github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rlp"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/harmony-one/harmony/block"
) )
// CrossLink is only used on beacon chain to store the hash links from other shards // CrossLink is only used on beacon chain to store the hash links from other shards
type CrossLink struct { type CrossLink struct {
ChainHeader *Header ChainHeader *block.Header
} }
// NewCrossLink returns a new cross link object // NewCrossLink returns a new cross link object
func NewCrossLink(header *Header) CrossLink { func NewCrossLink(header *block.Header) CrossLink {
return CrossLink{header} return CrossLink{header}
} }
// Header returns header // Header returns header
func (cl CrossLink) Header() *Header { func (cl CrossLink) Header() *block.Header {
return cl.ChainHeader return cl.ChainHeader
} }

@ -28,6 +28,8 @@ import (
"github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rlp"
"github.com/harmony-one/harmony/crypto/hash"
common2 "github.com/harmony-one/harmony/internal/common" common2 "github.com/harmony-one/harmony/internal/common"
) )
@ -292,7 +294,7 @@ func (tx *Transaction) Hash() common.Hash {
if hash := tx.hash.Load(); hash != nil { if hash := tx.hash.Load(); hash != nil {
return hash.(common.Hash) return hash.(common.Hash)
} }
v := rlpHash(tx) v := hash.FromRLP(tx)
tx.hash.Store(v) tx.hash.Store(v)
return v return v
} }

@ -24,6 +24,8 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/harmony-one/harmony/crypto/hash"
"github.com/harmony-one/harmony/internal/params" "github.com/harmony-one/harmony/internal/params"
) )
@ -157,7 +159,7 @@ func (s EIP155Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big
// Hash returns the hash to be signed by the sender. // Hash returns the hash to be signed by the sender.
// It does not uniquely identify the transaction. // It does not uniquely identify the transaction.
func (s EIP155Signer) Hash(tx *Transaction) common.Hash { func (s EIP155Signer) Hash(tx *Transaction) common.Hash {
return rlpHash([]interface{}{ return hash.FromRLP([]interface{}{
tx.data.AccountNonce, tx.data.AccountNonce,
tx.data.Price, tx.data.Price,
tx.data.GasLimit, tx.data.GasLimit,
@ -215,7 +217,7 @@ func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *
// Hash returns the hash to be signed by the sender. // Hash returns the hash to be signed by the sender.
// It does not uniquely identify the transaction. // It does not uniquely identify the transaction.
func (fs FrontierSigner) Hash(tx *Transaction) common.Hash { func (fs FrontierSigner) Hash(tx *Transaction) common.Hash {
return rlpHash([]interface{}{ return hash.FromRLP([]interface{}{
tx.data.AccountNonce, tx.data.AccountNonce,
tx.data.Price, tx.data.Price,
tx.data.GasLimit, tx.data.GasLimit,

@ -0,0 +1,15 @@
package hash
import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/rlp"
"golang.org/x/crypto/sha3"
)
// FromRLP hashes the RLP representation of the given object.
func FromRLP(x interface{}) (h common.Hash) {
hw := sha3.NewLegacyKeccak256()
rlp.Encode(hw, x)
hw.Sum(h[:0])
return h
}

@ -7,6 +7,8 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/harmony-one/bls/ffi/go/bls" "github.com/harmony-one/bls/ffi/go/bls"
block2 "github.com/harmony-one/harmony/block"
bls2 "github.com/harmony-one/harmony/crypto/bls" bls2 "github.com/harmony-one/harmony/crypto/bls"
msg_pb "github.com/harmony-one/harmony/api/proto/message" msg_pb "github.com/harmony-one/harmony/api/proto/message"
@ -126,7 +128,7 @@ func TestVrf(test *testing.T) {
tx1 := types.NewTransaction(1, common.BytesToAddress([]byte{0x11}), 0, big.NewInt(111), 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11}) tx1 := types.NewTransaction(1, common.BytesToAddress([]byte{0x11}), 0, big.NewInt(111), 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11})
txs := []*types.Transaction{tx1} txs := []*types.Transaction{tx1}
block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, nil, nil) block := types.NewBlock(&block2.Header{Number: big.NewInt(314)}, txs, nil, nil, nil)
blockHash := block.Hash() blockHash := block.Hash()
dRand.vrf(blockHash) dRand.vrf(blockHash)

@ -12,8 +12,10 @@ import (
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
"github.com/harmony-one/harmony/accounts" "github.com/harmony-one/harmony/accounts"
"github.com/harmony-one/harmony/api/proto" "github.com/harmony-one/harmony/api/proto"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/core/state" "github.com/harmony-one/harmony/core/state"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
@ -55,7 +57,7 @@ func (b *APIBackend) BlockByNumber(ctx context.Context, blockNr rpc.BlockNumber)
} }
// StateAndHeaderByNumber ... // StateAndHeaderByNumber ...
func (b *APIBackend) StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*state.DB, *types.Header, error) { func (b *APIBackend) StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*state.DB, *block.Header, error) {
// Pending state is only known by the miner // Pending state is only known by the miner
if blockNr == rpc.PendingBlockNumber { if blockNr == rpc.PendingBlockNumber {
return nil, nil, errors.New("not implemented") return nil, nil, errors.New("not implemented")
@ -70,7 +72,7 @@ func (b *APIBackend) StateAndHeaderByNumber(ctx context.Context, blockNr rpc.Blo
} }
// HeaderByNumber ... // HeaderByNumber ...
func (b *APIBackend) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error) { func (b *APIBackend) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*block.Header, error) {
// Pending block is only known by the miner // Pending block is only known by the miner
if blockNr == rpc.PendingBlockNumber { if blockNr == rpc.PendingBlockNumber {
return nil, errors.New("not implemented") return nil, errors.New("not implemented")
@ -139,7 +141,7 @@ func (b *APIBackend) GetLogs(ctx context.Context, blockHash common.Hash) ([][]*t
} }
// HeaderByHash ... // HeaderByHash ...
func (b *APIBackend) HeaderByHash(ctx context.Context, blockHash common.Hash) (*types.Header, error) { func (b *APIBackend) HeaderByHash(ctx context.Context, blockHash common.Hash) (*block.Header, error) {
// TODO(ricl): implement // TODO(ricl): implement
return nil, nil return nil, nil
} }
@ -211,7 +213,7 @@ func (b *APIBackend) NetVersion() uint64 {
} }
// GetEVM returns a new EVM entity // GetEVM returns a new EVM entity
func (b *APIBackend) GetEVM(ctx context.Context, msg core.Message, state *state.DB, header *types.Header) (*vm.EVM, func() error, error) { func (b *APIBackend) GetEVM(ctx context.Context, msg core.Message, state *state.DB, header *block.Header) (*vm.EVM, func() error, error) {
// TODO(ricl): The code is borrowed from [go-ethereum](https://github.com/ethereum/go-ethereum/blob/40cdcf8c47ff094775aca08fd5d94051f9cf1dbb/les/api_backend.go#L114) // TODO(ricl): The code is borrowed from [go-ethereum](https://github.com/ethereum/go-ethereum/blob/40cdcf8c47ff094775aca08fd5d94051f9cf1dbb/les/api_backend.go#L114)
// [question](https://ethereum.stackexchange.com/q/72977/54923) // [question](https://ethereum.stackexchange.com/q/72977/54923)
// Might need to reconsider the SetBalance behavior // Might need to reconsider the SetBalance behavior

@ -25,6 +25,8 @@ import (
"github.com/ethereum/go-ethereum/core/bloombits" "github.com/ethereum/go-ethereum/core/bloombits"
"github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
) )
@ -117,7 +119,7 @@ func (b *BloomIndexer) Reset(ctx context.Context, section uint64, lastSectionHea
// Process implements core.ChainIndexerBackend, adding a new header's bloom into // Process implements core.ChainIndexerBackend, adding a new header's bloom into
// the index. // the index.
func (b *BloomIndexer) Process(ctx context.Context, header *types.Header) error { func (b *BloomIndexer) Process(ctx context.Context, header *block.Header) error {
b.gen.AddBloom(uint(header.Number.Uint64()-b.section*b.size), header.Bloom) b.gen.AddBloom(uint(header.Number.Uint64()-b.section*b.size), header.Bloom)
b.head = header.Hash() b.head = header.Hash()
return nil return nil

@ -6,10 +6,12 @@ import (
"fmt" "fmt"
"math/big" "math/big"
ethereum "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
) )
@ -96,7 +98,7 @@ func (c *Client) getBlock(ctx context.Context, method string, args ...interface{
return nil, ethereum.NotFound return nil, ethereum.NotFound
} }
// Decode header and transactions. // Decode header and transactions.
var head *types.Header var head *block.Header
var body rpcBlock var body rpcBlock
if err := json.Unmarshal(raw, &head); err != nil { if err := json.Unmarshal(raw, &head); err != nil {
return nil, err return nil, err
@ -119,7 +121,7 @@ func (c *Client) getBlock(ctx context.Context, method string, args ...interface{
} }
txs[i] = tx.tx txs[i] = tx.tx
} }
return types.NewBlockWithHeader(head).WithBody(txs, []*types.Header{}, nil), nil return types.NewBlockWithHeader(head).WithBody(txs, []*block.Header{}, nil), nil
} }
func toBlockNumArg(number *big.Int) string { func toBlockNumArg(number *big.Int) string {

@ -9,6 +9,7 @@ import (
"github.com/pkg/errors" "github.com/pkg/errors"
"golang.org/x/crypto/sha3" "golang.org/x/crypto/sha3"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/consensus/engine" "github.com/harmony-one/harmony/consensus/engine"
"github.com/harmony-one/harmony/core/state" "github.com/harmony-one/harmony/core/state"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
@ -22,7 +23,7 @@ type engineImpl struct{}
var Engine = &engineImpl{} var Engine = &engineImpl{}
// SealHash returns the hash of a block prior to it being sealed. // SealHash returns the hash of a block prior to it being sealed.
func (e *engineImpl) SealHash(header *types.Header) (hash common.Hash) { func (e *engineImpl) SealHash(header *block.Header) (hash common.Hash) {
hasher := sha3.NewLegacyKeccak256() hasher := sha3.NewLegacyKeccak256()
// TODO: update with new fields // TODO: update with new fields
if err := rlp.Encode(hasher, []interface{}{ if err := rlp.Encode(hasher, []interface{}{
@ -51,20 +52,20 @@ func (e *engineImpl) Seal(chain engine.ChainReader, block *types.Block, results
} }
// Author returns the author of the block header. // Author returns the author of the block header.
func (e *engineImpl) Author(header *types.Header) (common.Address, error) { func (e *engineImpl) Author(header *block.Header) (common.Address, error) {
// TODO: implement this // TODO: implement this
return common.Address{}, nil return common.Address{}, nil
} }
// Prepare is to prepare ... // Prepare is to prepare ...
// TODO(RJ): fix it. // TODO(RJ): fix it.
func (e *engineImpl) Prepare(chain engine.ChainReader, header *types.Header) error { func (e *engineImpl) Prepare(chain engine.ChainReader, header *block.Header) error {
// TODO: implement prepare method // TODO: implement prepare method
return nil return nil
} }
// VerifyHeader checks whether a header conforms to the consensus rules of the bft engine. // VerifyHeader checks whether a header conforms to the consensus rules of the bft engine.
func (e *engineImpl) VerifyHeader(chain engine.ChainReader, header *types.Header, seal bool) error { func (e *engineImpl) VerifyHeader(chain engine.ChainReader, header *block.Header, seal bool) error {
parentHeader := chain.GetHeader(header.ParentHash, header.Number.Uint64()-1) parentHeader := chain.GetHeader(header.ParentHash, header.Number.Uint64()-1)
if parentHeader == nil { if parentHeader == nil {
return engine.ErrUnknownAncestor return engine.ErrUnknownAncestor
@ -80,7 +81,7 @@ func (e *engineImpl) VerifyHeader(chain engine.ChainReader, header *types.Header
// VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers // VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers
// concurrently. The method returns a quit channel to abort the operations and // concurrently. The method returns a quit channel to abort the operations and
// a results channel to retrieve the async verifications. // a results channel to retrieve the async verifications.
func (e *engineImpl) VerifyHeaders(chain engine.ChainReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) { func (e *engineImpl) VerifyHeaders(chain engine.ChainReader, headers []*block.Header, seals []bool) (chan<- struct{}, <-chan error) {
abort, results := make(chan struct{}), make(chan error, len(headers)) abort, results := make(chan struct{}), make(chan error, len(headers))
for i := 0; i < len(headers); i++ { for i := 0; i < len(headers); i++ {
results <- nil results <- nil
@ -89,7 +90,7 @@ func (e *engineImpl) VerifyHeaders(chain engine.ChainReader, headers []*types.He
} }
// retrievePublicKeysFromLastBlock finds the public keys of last block's committee // retrievePublicKeysFromLastBlock finds the public keys of last block's committee
func retrievePublicKeysFromLastBlock(bc engine.ChainReader, header *types.Header) ([]*bls.PublicKey, error) { func retrievePublicKeysFromLastBlock(bc engine.ChainReader, header *block.Header) ([]*bls.PublicKey, error) {
parentHeader := bc.GetHeaderByHash(header.ParentHash) parentHeader := bc.GetHeaderByHash(header.ParentHash)
if parentHeader == nil { if parentHeader == nil {
return nil, ctxerror.New("cannot find parent block header in DB", return nil, ctxerror.New("cannot find parent block header in DB",
@ -123,7 +124,7 @@ func retrievePublicKeysFromLastBlock(bc engine.ChainReader, header *types.Header
// VerifySeal implements Engine, checking whether the given block satisfies // VerifySeal implements Engine, checking whether the given block satisfies
// the PoS difficulty requirements, i.e. >= 2f+1 valid signatures from the committee // the PoS difficulty requirements, i.e. >= 2f+1 valid signatures from the committee
func (e *engineImpl) VerifySeal(chain engine.ChainReader, header *types.Header) error { func (e *engineImpl) VerifySeal(chain engine.ChainReader, header *block.Header) error {
if chain.CurrentHeader().Number.Uint64() <= uint64(1) { if chain.CurrentHeader().Number.Uint64() <= uint64(1) {
return nil return nil
} }
@ -159,7 +160,7 @@ func (e *engineImpl) VerifySeal(chain engine.ChainReader, header *types.Header)
// Finalize implements Engine, accumulating the block rewards, // Finalize implements Engine, accumulating the block rewards,
// setting the final state and assembling the block. // setting the final state and assembling the block.
func (e *engineImpl) Finalize(chain engine.ChainReader, header *types.Header, state *state.DB, txs []*types.Transaction, receipts []*types.Receipt, outcxs []*types.CXReceipt, incxs []*types.CXReceiptsProof) (*types.Block, error) { func (e *engineImpl) Finalize(chain engine.ChainReader, header *block.Header, state *state.DB, txs []*types.Transaction, receipts []*types.Receipt, outcxs []*types.CXReceipt, incxs []*types.CXReceiptsProof) (*types.Block, error) {
// Accumulate any block and uncle rewards and commit the final state root // Accumulate any block and uncle rewards and commit the final state root
// Header seems complete, assemble into a block and return // Header seems complete, assemble into a block and return
if err := AccumulateRewards(chain, state, header); err != nil { if err := AccumulateRewards(chain, state, header); err != nil {
@ -171,7 +172,7 @@ func (e *engineImpl) Finalize(chain engine.ChainReader, header *types.Header, st
// QuorumForBlock returns the quorum for the given block header. // QuorumForBlock returns the quorum for the given block header.
func QuorumForBlock( func QuorumForBlock(
chain engine.ChainReader, h *types.Header, chain engine.ChainReader, h *block.Header,
) (quorum int, err error) { ) (quorum int, err error) {
ss, err := chain.ReadShardState(h.Epoch) ss, err := chain.ReadShardState(h.Epoch)
if err != nil { if err != nil {

@ -6,10 +6,10 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/harmony-one/bls/ffi/go/bls" "github.com/harmony-one/bls/ffi/go/bls"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/common/denominations" "github.com/harmony-one/harmony/common/denominations"
"github.com/harmony-one/harmony/consensus/engine" "github.com/harmony-one/harmony/consensus/engine"
"github.com/harmony-one/harmony/core/state" "github.com/harmony-one/harmony/core/state"
"github.com/harmony-one/harmony/core/types"
bls2 "github.com/harmony-one/harmony/crypto/bls" bls2 "github.com/harmony-one/harmony/crypto/bls"
common2 "github.com/harmony-one/harmony/internal/common" common2 "github.com/harmony-one/harmony/internal/common"
"github.com/harmony-one/harmony/internal/ctxerror" "github.com/harmony-one/harmony/internal/ctxerror"
@ -23,7 +23,7 @@ var BlockReward = new(big.Int).Mul(big.NewInt(24), big.NewInt(denominations.One)
// reward. The total reward consists of the static block reward and rewards for // reward. The total reward consists of the static block reward and rewards for
// included uncles. The coinbase of each uncle block is also rewarded. // included uncles. The coinbase of each uncle block is also rewarded.
func AccumulateRewards( func AccumulateRewards(
bc engine.ChainReader, state *state.DB, header *types.Header, bc engine.ChainReader, state *state.DB, header *block.Header,
) error { ) error {
blockNum := header.Number.Uint64() blockNum := header.Number.Uint64()
if blockNum == 0 { if blockNum == 0 {

@ -9,7 +9,9 @@ import (
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
"github.com/harmony-one/harmony/accounts" "github.com/harmony-one/harmony/accounts"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/core/state" "github.com/harmony-one/harmony/core/state"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
@ -36,13 +38,13 @@ type Backend interface {
// BlockChain API // BlockChain API
// SetHead(number uint64) // SetHead(number uint64)
HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*block.Header, error)
BlockByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Block, error) BlockByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Block, error)
StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*state.DB, *types.Header, error) StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*state.DB, *block.Header, error)
GetBlock(ctx context.Context, blockHash common.Hash) (*types.Block, error) GetBlock(ctx context.Context, blockHash common.Hash) (*types.Block, error)
GetReceipts(ctx context.Context, blockHash common.Hash) (types.Receipts, error) GetReceipts(ctx context.Context, blockHash common.Hash) (types.Receipts, error)
// GetTd(blockHash common.Hash) *big.Int // GetTd(blockHash common.Hash) *big.Int
GetEVM(ctx context.Context, msg core.Message, state *state.DB, header *types.Header) (*vm.EVM, func() error, error) GetEVM(ctx context.Context, msg core.Message, state *state.DB, header *block.Header) (*vm.EVM, func() error, error)
SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription
SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription
SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription

@ -6,11 +6,13 @@ import (
"sync" "sync"
"time" "time"
ethereum "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
) )
@ -154,7 +156,7 @@ func (api *PublicFilterAPI) NewPendingTransactions(ctx context.Context) (*rpc.Su
// https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_newblockfilter // https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_newblockfilter
func (api *PublicFilterAPI) NewBlockFilter() rpc.ID { func (api *PublicFilterAPI) NewBlockFilter() rpc.ID {
var ( var (
headers = make(chan *types.Header) headers = make(chan *block.Header)
headerSub = api.events.SubscribeNewHeads(headers) headerSub = api.events.SubscribeNewHeads(headers)
) )
@ -193,7 +195,7 @@ func (api *PublicFilterAPI) NewHeads(ctx context.Context) (*rpc.Subscription, er
rpcSub := notifier.CreateSubscription() rpcSub := notifier.CreateSubscription()
go func() { go func() {
headers := make(chan *types.Header) headers := make(chan *block.Header)
headersSub := api.events.SubscribeNewHeads(headers) headersSub := api.events.SubscribeNewHeads(headers)
for { for {

@ -27,6 +27,8 @@ import (
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
) )
@ -35,8 +37,8 @@ import (
type Backend interface { type Backend interface {
ChainDb() ethdb.Database ChainDb() ethdb.Database
EventMux() *event.TypeMux EventMux() *event.TypeMux
HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*block.Header, error)
HeaderByHash(ctx context.Context, blockHash common.Hash) (*types.Header, error) HeaderByHash(ctx context.Context, blockHash common.Hash) (*block.Header, error)
GetReceipts(ctx context.Context, blockHash common.Hash) (types.Receipts, error) GetReceipts(ctx context.Context, blockHash common.Hash) (types.Receipts, error)
GetLogs(ctx context.Context, blockHash common.Hash) ([][]*types.Log, error) GetLogs(ctx context.Context, blockHash common.Hash) ([][]*types.Log, error)
@ -232,7 +234,7 @@ func (f *Filter) unindexedLogs(ctx context.Context, end uint64) ([]*types.Log, e
} }
// blockLogs returns the logs matching the filter criteria within a single block. // blockLogs returns the logs matching the filter criteria within a single block.
func (f *Filter) blockLogs(ctx context.Context, header *types.Header) (logs []*types.Log, err error) { func (f *Filter) blockLogs(ctx context.Context, header *block.Header) (logs []*types.Log, err error) {
if bloomFilter(header.Bloom, f.addresses, f.topics) { if bloomFilter(header.Bloom, f.addresses, f.topics) {
found, err := f.checkMatches(ctx, header) found, err := f.checkMatches(ctx, header)
if err != nil { if err != nil {
@ -245,7 +247,7 @@ func (f *Filter) blockLogs(ctx context.Context, header *types.Header) (logs []*t
// checkMatches checks if the receipts belonging to the given header contain any log events that // checkMatches checks if the receipts belonging to the given header contain any log events that
// match the filter criteria. This function is called when the bloom filter signals a potential match. // match the filter criteria. This function is called when the bloom filter signals a potential match.
func (f *Filter) checkMatches(ctx context.Context, header *types.Header) (logs []*types.Log, err error) { func (f *Filter) checkMatches(ctx context.Context, header *block.Header) (logs []*types.Log, err error) {
// Get the logs of the block // Get the logs of the block
logsList, err := f.backend.GetLogs(ctx, header.Hash()) logsList, err := f.backend.GetLogs(ctx, header.Hash())
if err != nil { if err != nil {

@ -24,11 +24,13 @@ import (
"sync" "sync"
"time" "time"
ethereum "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/core/rawdb" "github.com/harmony-one/harmony/core/rawdb"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
@ -76,7 +78,7 @@ type subscription struct {
logsCrit ethereum.FilterQuery logsCrit ethereum.FilterQuery
logs chan []*types.Log logs chan []*types.Log
hashes chan []common.Hash hashes chan []common.Hash
headers chan *types.Header headers chan *block.Header
installed chan struct{} // closed when the filter is installed installed chan struct{} // closed when the filter is installed
err chan error // closed when the filter is uninstalled err chan error // closed when the filter is uninstalled
} }
@ -87,7 +89,7 @@ type EventSystem struct {
mux *event.TypeMux mux *event.TypeMux
backend Backend backend Backend
lightMode bool lightMode bool
lastHead *types.Header lastHead *block.Header
// Subscriptions // Subscriptions
txsSub event.Subscription // Subscription for new transaction event txsSub event.Subscription // Subscription for new transaction event
@ -236,7 +238,7 @@ func (es *EventSystem) subscribeMinedPendingLogs(crit ethereum.FilterQuery, logs
created: time.Now(), created: time.Now(),
logs: logs, logs: logs,
hashes: make(chan []common.Hash), hashes: make(chan []common.Hash),
headers: make(chan *types.Header), headers: make(chan *block.Header),
installed: make(chan struct{}), installed: make(chan struct{}),
err: make(chan error), err: make(chan error),
} }
@ -253,7 +255,7 @@ func (es *EventSystem) subscribeLogs(crit ethereum.FilterQuery, logs chan []*typ
created: time.Now(), created: time.Now(),
logs: logs, logs: logs,
hashes: make(chan []common.Hash), hashes: make(chan []common.Hash),
headers: make(chan *types.Header), headers: make(chan *block.Header),
installed: make(chan struct{}), installed: make(chan struct{}),
err: make(chan error), err: make(chan error),
} }
@ -270,7 +272,7 @@ func (es *EventSystem) subscribePendingLogs(crit ethereum.FilterQuery, logs chan
created: time.Now(), created: time.Now(),
logs: logs, logs: logs,
hashes: make(chan []common.Hash), hashes: make(chan []common.Hash),
headers: make(chan *types.Header), headers: make(chan *block.Header),
installed: make(chan struct{}), installed: make(chan struct{}),
err: make(chan error), err: make(chan error),
} }
@ -279,7 +281,7 @@ func (es *EventSystem) subscribePendingLogs(crit ethereum.FilterQuery, logs chan
// SubscribeNewHeads creates a subscription that writes the header of a block that is // SubscribeNewHeads creates a subscription that writes the header of a block that is
// imported in the chain. // imported in the chain.
func (es *EventSystem) SubscribeNewHeads(headers chan *types.Header) *Subscription { func (es *EventSystem) SubscribeNewHeads(headers chan *block.Header) *Subscription {
sub := &subscription{ sub := &subscription{
id: rpc.NewID(), id: rpc.NewID(),
typ: BlocksSubscription, typ: BlocksSubscription,
@ -302,7 +304,7 @@ func (es *EventSystem) SubscribePendingTxs(hashes chan []common.Hash) *Subscript
created: time.Now(), created: time.Now(),
logs: make(chan []*types.Log), logs: make(chan []*types.Log),
hashes: hashes, hashes: hashes,
headers: make(chan *types.Header), headers: make(chan *block.Header),
installed: make(chan struct{}), installed: make(chan struct{}),
err: make(chan error), err: make(chan error),
} }
@ -355,7 +357,7 @@ func (es *EventSystem) broadcast(filters filterIndex, ev interface{}) {
f.headers <- e.Block.Header() f.headers <- e.Block.Header()
} }
if es.lightMode && len(filters[LogsSubscription]) > 0 { if es.lightMode && len(filters[LogsSubscription]) > 0 {
es.lightFilterNewHead(e.Block.Header(), func(header *types.Header, remove bool) { es.lightFilterNewHead(e.Block.Header(), func(header *block.Header, remove bool) {
for _, f := range filters[LogsSubscription] { for _, f := range filters[LogsSubscription] {
if matchedLogs := es.lightFilterLogs(header, f.logsCrit.Addresses, f.logsCrit.Topics, remove); len(matchedLogs) > 0 { if matchedLogs := es.lightFilterLogs(header, f.logsCrit.Addresses, f.logsCrit.Topics, remove); len(matchedLogs) > 0 {
f.logs <- matchedLogs f.logs <- matchedLogs
@ -366,7 +368,7 @@ func (es *EventSystem) broadcast(filters filterIndex, ev interface{}) {
} }
} }
func (es *EventSystem) lightFilterNewHead(newHeader *types.Header, callBack func(*types.Header, bool)) { func (es *EventSystem) lightFilterNewHead(newHeader *block.Header, callBack func(*block.Header, bool)) {
oldh := es.lastHead oldh := es.lastHead
es.lastHead = newHeader es.lastHead = newHeader
if oldh == nil { if oldh == nil {
@ -374,7 +376,7 @@ func (es *EventSystem) lightFilterNewHead(newHeader *types.Header, callBack func
} }
newh := newHeader newh := newHeader
// find common ancestor, create list of rolled back and new block hashes // find common ancestor, create list of rolled back and new block hashes
var oldHeaders, newHeaders []*types.Header var oldHeaders, newHeaders []*block.Header
for oldh.Hash() != newh.Hash() { for oldh.Hash() != newh.Hash() {
if oldh.Number.Uint64() >= newh.Number.Uint64() { if oldh.Number.Uint64() >= newh.Number.Uint64() {
oldHeaders = append(oldHeaders, oldh) oldHeaders = append(oldHeaders, oldh)
@ -400,7 +402,7 @@ func (es *EventSystem) lightFilterNewHead(newHeader *types.Header, callBack func
} }
// filter logs of a single header in light client mode // filter logs of a single header in light client mode
func (es *EventSystem) lightFilterLogs(header *types.Header, addresses []common.Address, topics [][]common.Hash, remove bool) []*types.Log { func (es *EventSystem) lightFilterLogs(header *block.Header, addresses []common.Address, topics [][]common.Hash, remove bool) []*types.Log {
if bloomFilter(header.Bloom, addresses, topics) { if bloomFilter(header.Bloom, addresses, topics) {
// Get the logs of the block // Get the logs of the block
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5) ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)

@ -18,6 +18,7 @@ import (
"github.com/harmony-one/harmony/api/service" "github.com/harmony-one/harmony/api/service"
"github.com/harmony-one/harmony/api/service/syncing" "github.com/harmony-one/harmony/api/service/syncing"
"github.com/harmony-one/harmony/api/service/syncing/downloader" "github.com/harmony-one/harmony/api/service/syncing/downloader"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/consensus" "github.com/harmony-one/harmony/consensus"
"github.com/harmony-one/harmony/contracts" "github.com/harmony-one/harmony/contracts"
"github.com/harmony-one/harmony/contracts/structs" "github.com/harmony-one/harmony/contracts/structs"
@ -32,6 +33,7 @@ import (
"github.com/harmony-one/harmony/node/worker" "github.com/harmony-one/harmony/node/worker"
"github.com/harmony-one/harmony/p2p" "github.com/harmony-one/harmony/p2p"
p2p_host "github.com/harmony-one/harmony/p2p/host" p2p_host "github.com/harmony-one/harmony/p2p/host"
"github.com/harmony-one/harmony/shard"
) )
// State is a state of a node. // State is a state of a node.
@ -95,7 +97,7 @@ type Node struct {
ConfirmedBlockChannel chan *types.Block // The channel to send confirmed blocks ConfirmedBlockChannel chan *types.Block // The channel to send confirmed blocks
BeaconBlockChannel chan *types.Block // The channel to send beacon blocks for non-beaconchain nodes BeaconBlockChannel chan *types.Block // The channel to send beacon blocks for non-beaconchain nodes
DRand *drand.DRand // The instance for distributed randomness protocol DRand *drand.DRand // The instance for distributed randomness protocol
pendingCrossLinks []*types.Header pendingCrossLinks []*block.Header
pendingClMutex sync.Mutex pendingClMutex sync.Mutex
pendingCXReceipts []*types.CXReceiptsProof // All the receipts received but not yet processed for Consensus pendingCXReceipts []*types.CXReceiptsProof // All the receipts received but not yet processed for Consensus
@ -201,7 +203,7 @@ type Node struct {
// Next shard state // Next shard state
nextShardState struct { nextShardState struct {
// The received master shard state // The received master shard state
master *types.EpochShardState master *shard.EpochShardState
// When for a leader to propose the next shard state, // When for a leader to propose the next shard state,
// or for a validator to wait for a proposal before view change. // or for a validator to wait for a proposal before view change.

@ -9,6 +9,8 @@ import (
"github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rlp"
"github.com/harmony-one/bls/ffi/go/bls" "github.com/harmony-one/bls/ffi/go/bls"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
bls_cosi "github.com/harmony-one/harmony/crypto/bls" bls_cosi "github.com/harmony-one/harmony/crypto/bls"
@ -20,7 +22,7 @@ import (
func (node *Node) ProcessHeaderMessage(msgPayload []byte) { func (node *Node) ProcessHeaderMessage(msgPayload []byte) {
if node.NodeConfig.ShardID == 0 { if node.NodeConfig.ShardID == 0 {
var headers []*types.Header var headers []*block.Header
err := rlp.DecodeBytes(msgPayload, &headers) err := rlp.DecodeBytes(msgPayload, &headers)
if err != nil { if err != nil {
utils.Logger().Error(). utils.Logger().Error().
@ -32,7 +34,7 @@ func (node *Node) ProcessHeaderMessage(msgPayload []byte) {
// Try to reprocess all the pending cross links // Try to reprocess all the pending cross links
node.pendingClMutex.Lock() node.pendingClMutex.Lock()
crossLinkHeadersToProcess := node.pendingCrossLinks crossLinkHeadersToProcess := node.pendingCrossLinks
node.pendingCrossLinks = []*types.Header{} node.pendingCrossLinks = []*block.Header{}
node.pendingClMutex.Unlock() node.pendingClMutex.Unlock()
firstCrossLinkBlock := core.ShardingSchedule.FirstCrossLinkBlock() firstCrossLinkBlock := core.ShardingSchedule.FirstCrossLinkBlock()
@ -46,7 +48,7 @@ func (node *Node) ProcessHeaderMessage(msgPayload []byte) {
utils.Logger().Debug(). utils.Logger().Debug().
Msgf("[ProcessingHeader] number of crosslink headers to propose %d, firstCrossLinkBlock %d", len(crossLinkHeadersToProcess), firstCrossLinkBlock) Msgf("[ProcessingHeader] number of crosslink headers to propose %d, firstCrossLinkBlock %d", len(crossLinkHeadersToProcess), firstCrossLinkBlock)
headersToQuque := []*types.Header{} headersToQuque := []*block.Header{}
for _, header := range crossLinkHeadersToProcess { for _, header := range crossLinkHeadersToProcess {
if len(headersToQuque) > crossLinkBatchSize { if len(headersToQuque) > crossLinkBatchSize {
@ -156,7 +158,7 @@ func (node *Node) compareCrosslinkWithReceipts(cxp *types.CXReceiptsProof) error
} }
// VerifyCrosslinkHeader verifies the header is valid against the prevHeader. // VerifyCrosslinkHeader verifies the header is valid against the prevHeader.
func (node *Node) VerifyCrosslinkHeader(prevHeader, header *types.Header) error { func (node *Node) VerifyCrosslinkHeader(prevHeader, header *block.Header) error {
// TODO: add fork choice rule // TODO: add fork choice rule
if prevHeader.Hash() != header.ParentHash { if prevHeader.Hash() != header.ParentHash {

@ -9,17 +9,17 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
nodeconfig "github.com/harmony-one/harmony/internal/configs/node"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/harmony-one/harmony/common/denominations" "github.com/harmony-one/harmony/common/denominations"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/core/types"
common2 "github.com/harmony-one/harmony/internal/common" common2 "github.com/harmony-one/harmony/internal/common"
nodeconfig "github.com/harmony-one/harmony/internal/configs/node"
"github.com/harmony-one/harmony/internal/genesis" "github.com/harmony-one/harmony/internal/genesis"
"github.com/harmony-one/harmony/internal/params" "github.com/harmony-one/harmony/internal/params"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/shard"
) )
const ( const (
@ -47,14 +47,14 @@ func (gi *genesisInitializer) InitChainDB(db ethdb.Database, shardID uint32) err
if c == nil { if c == nil {
return errors.New("cannot find local shard in genesis") return errors.New("cannot find local shard in genesis")
} }
shardState = types.ShardState{*c} shardState = shard.State{*c}
} }
gi.node.SetupGenesisBlock(db, shardID, shardState) gi.node.SetupGenesisBlock(db, shardID, shardState)
return nil return nil
} }
// SetupGenesisBlock sets up a genesis blockchain. // SetupGenesisBlock sets up a genesis blockchain.
func (node *Node) SetupGenesisBlock(db ethdb.Database, shardID uint32, myShardState types.ShardState) { func (node *Node) SetupGenesisBlock(db ethdb.Database, shardID uint32, myShardState shard.State) {
utils.Logger().Info().Interface("shardID", shardID).Msg("setting up a brand new chain database") utils.Logger().Info().Interface("shardID", shardID).Msg("setting up a brand new chain database")
if shardID == node.NodeConfig.ShardID { if shardID == node.NodeConfig.ShardID {
node.isFirstTime = true node.isFirstTime = true

@ -25,6 +25,7 @@ import (
proto_discovery "github.com/harmony-one/harmony/api/proto/discovery" proto_discovery "github.com/harmony-one/harmony/api/proto/discovery"
"github.com/harmony-one/harmony/api/proto/message" "github.com/harmony-one/harmony/api/proto/message"
proto_node "github.com/harmony-one/harmony/api/proto/node" proto_node "github.com/harmony-one/harmony/api/proto/node"
"github.com/harmony-one/harmony/block"
"github.com/harmony-one/harmony/contracts/structs" "github.com/harmony-one/harmony/contracts/structs"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
@ -33,6 +34,7 @@ import (
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/p2p" "github.com/harmony-one/harmony/p2p"
"github.com/harmony-one/harmony/p2p/host" "github.com/harmony-one/harmony/p2p/host"
"github.com/harmony-one/harmony/shard"
) )
const ( const (
@ -264,7 +266,7 @@ func (node *Node) BroadcastNewBlock(newBlock *types.Block) {
// BroadcastCrossLinkHeader is called by consensus leader to send the new header as cross link to beacon chain. // BroadcastCrossLinkHeader is called by consensus leader to send the new header as cross link to beacon chain.
func (node *Node) BroadcastCrossLinkHeader(newBlock *types.Block) { func (node *Node) BroadcastCrossLinkHeader(newBlock *types.Block) {
utils.Logger().Info().Msgf("Broadcasting new header to beacon chain groupID %s", node.NodeConfig.GetBeaconGroupID()) utils.Logger().Info().Msgf("Broadcasting new header to beacon chain groupID %s", node.NodeConfig.GetBeaconGroupID())
headers := []*types.Header{} headers := []*block.Header{}
lastLink, err := node.Beaconchain().ReadShardLastCrossLink(newBlock.ShardID()) lastLink, err := node.Beaconchain().ReadShardLastCrossLink(newBlock.ShardID())
var latestBlockNum uint64 var latestBlockNum uint64
@ -472,7 +474,7 @@ func (node *Node) validateNewShardState(block *types.Block, stakeInfo *map[commo
// We aren't expecting to reshard, so proceed to sign // We aren't expecting to reshard, so proceed to sign
return nil return nil
} }
shardState := &types.ShardState{} shardState := &shard.State{}
err := rlp.DecodeBytes(header.ShardState, shardState) err := rlp.DecodeBytes(header.ShardState, shardState)
if err != nil { if err != nil {
return err return err
@ -491,7 +493,7 @@ func (node *Node) validateNewShardState(block *types.Block, stakeInfo *map[commo
return ctxerror.New("cannot calculate expected shard state"). return ctxerror.New("cannot calculate expected shard state").
WithCause(err) WithCause(err)
} }
if types.CompareShardState(expected, proposed) != 0 { if shard.CompareShardState(expected, proposed) != 0 {
// TODO ek – log state proposal differences // TODO ek – log state proposal differences
// TODO ek – this error should trigger view change // TODO ek – this error should trigger view change
err := errors.New("shard state proposal is different from expected") err := errors.New("shard state proposal is different from expected")
@ -538,7 +540,7 @@ func (node *Node) validateNewShardState(block *types.Block, stakeInfo *map[commo
"leader proposed to continue against beacon decision") "leader proposed to continue against beacon decision")
} }
// Did beaconchain say the same proposal? // Did beaconchain say the same proposal?
if types.CompareCommittee(expected, &proposed) != 0 { if shard.CompareCommittee(expected, &proposed) != 0 {
// TODO ek – log differences // TODO ek – log differences
// TODO ek – invoke view change // TODO ek – invoke view change
return errors.New("proposal differs from one in beacon chain") return errors.New("proposal differs from one in beacon chain")
@ -647,7 +649,7 @@ func (node *Node) broadcastEpochShardState(newBlock *types.Block) error {
return err return err
} }
epochShardStateMessage := proto_node.ConstructEpochShardStateMessage( epochShardStateMessage := proto_node.ConstructEpochShardStateMessage(
types.EpochShardState{ shard.EpochShardState{
Epoch: newBlock.Header().Epoch.Uint64() + 1, Epoch: newBlock.Header().Epoch.Uint64() + 1,
ShardState: shardState, ShardState: shardState,
}, },
@ -679,13 +681,13 @@ func (node *Node) AddNewBlock(newBlock *types.Block) error {
type genesisNode struct { type genesisNode struct {
ShardID uint32 ShardID uint32
MemberIndex int MemberIndex int
NodeID types.NodeID NodeID shard.NodeID
} }
var ( var (
genesisCatalogOnce sync.Once genesisCatalogOnce sync.Once
genesisNodeByStakingAddress = make(map[common.Address]*genesisNode) genesisNodeByStakingAddress = make(map[common.Address]*genesisNode)
genesisNodeByConsensusKey = make(map[types.BlsPublicKey]*genesisNode) genesisNodeByConsensusKey = make(map[shard.BlsPublicKey]*genesisNode)
) )
func initGenesisCatalog() { func initGenesisCatalog() {
@ -708,7 +710,7 @@ func getGenesisNodeByStakingAddress(address common.Address) *genesisNode {
return genesisNodeByStakingAddress[address] return genesisNodeByStakingAddress[address]
} }
func getGenesisNodeByConsensusKey(key types.BlsPublicKey) *genesisNode { func getGenesisNodeByConsensusKey(key shard.BlsPublicKey) *genesisNode {
genesisCatalogOnce.Do(initGenesisCatalog) genesisCatalogOnce.Do(initGenesisCatalog)
return genesisNodeByConsensusKey[key] return genesisNodeByConsensusKey[key]
} }
@ -832,7 +834,7 @@ func (node *Node) epochShardStateMessageHandler(msgPayload []byte) error {
} }
/* /*
func (node *Node) transitionIntoNextEpoch(shardState types.ShardState) { func (node *Node) transitionIntoNextEpoch(shardState types.State) {
logger = logger.New( logger = logger.New(
"blsPubKey", hex.EncodeToString(node.Consensus.PubKey.Serialize()), "blsPubKey", hex.EncodeToString(node.Consensus.PubKey.Serialize()),
"curShard", node.Blockchain().ShardID(), "curShard", node.Blockchain().ShardID(),
@ -884,7 +886,7 @@ func (node *Node) transitionIntoNextEpoch(shardState types.ShardState) {
*/ */
func findRoleInShardState( func findRoleInShardState(
key *bls.PublicKey, state types.ShardState, key *bls.PublicKey, state shard.State,
) (shardID uint32, isLeader bool) { ) (shardID uint32, isLeader bool) {
keyBytes := key.Serialize() keyBytes := key.Serialize()
for idx, shard := range state { for idx, shard := range state {

@ -8,10 +8,12 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rlp"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
"github.com/harmony-one/harmony/internal/ctxerror" "github.com/harmony-one/harmony/internal/ctxerror"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/shard"
) )
// Constants of lower bound limit of a new block. // Constants of lower bound limit of a new block.
@ -193,7 +195,7 @@ func (node *Node) proposeLocalShardState(block *types.Block) {
return return
} }
masterShardState := node.nextShardState.master.ShardState masterShardState := node.nextShardState.master.ShardState
var localShardState types.ShardState var localShardState shard.State
committee := masterShardState.FindCommitteeByID(block.ShardID()) committee := masterShardState.FindCommitteeByID(block.ShardID())
if committee != nil { if committee != nil {
logger.Info().Msg("found local shard info; proposing it") logger.Info().Msg("found local shard info; proposing it")

@ -4,13 +4,14 @@ import (
"encoding/hex" "encoding/hex"
"math/big" "math/big"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/shard"
"github.com/harmony-one/harmony/contracts/structs" "github.com/harmony-one/harmony/contracts/structs"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/hexutil"
@ -45,7 +46,7 @@ func (node *Node) UpdateStakingList(stakeInfoReturnValue *structs.StakeInfoRetur
} }
// True if the token is still staked within the locking period. // True if the token is still staked within the locking period.
if curEpoch-startEpoch <= lockPeriodCount.Uint64()*lockPeriodInEpochs { if curEpoch-startEpoch <= lockPeriodCount.Uint64()*lockPeriodInEpochs {
blsPubKey := types.BlsPublicKey{} blsPubKey := shard.BlsPublicKey{}
copy(blsPubKey[:32], stakeInfoReturnValue.BlsPubicKeys1[i][:]) copy(blsPubKey[:32], stakeInfoReturnValue.BlsPubicKeys1[i][:])
copy(blsPubKey[32:48], stakeInfoReturnValue.BlsPubicKeys2[i][:16]) copy(blsPubKey[32:48], stakeInfoReturnValue.BlsPubicKeys2[i][:16])
node.CurrentStakes[addr] = &structs.StakeInfo{ node.CurrentStakes[addr] = &structs.StakeInfo{

@ -8,6 +8,7 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/harmony-one/harmony/internal/params" "github.com/harmony-one/harmony/internal/params"
"github.com/harmony-one/harmony/block"
consensus_engine "github.com/harmony-one/harmony/consensus/engine" consensus_engine "github.com/harmony-one/harmony/consensus/engine"
"github.com/harmony-one/harmony/core" "github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/core/state" "github.com/harmony-one/harmony/core/state"
@ -24,7 +25,7 @@ type environment struct {
state *state.DB // apply state changes here state *state.DB // apply state changes here
gasPool *core.GasPool // available gas used to pack transactions gasPool *core.GasPool // available gas used to pack transactions
header *types.Header header *block.Header
txs []*types.Transaction txs []*types.Transaction
receipts []*types.Receipt receipts []*types.Receipt
outcxs []*types.CXReceipt // cross shard transaction receipts (source shard) outcxs []*types.CXReceipt // cross shard transaction receipts (source shard)
@ -211,7 +212,7 @@ func (w *Worker) UpdateCurrent(coinbase common.Address) error {
// ... except if parent has a resharding assignment it increases by 1. // ... except if parent has a resharding assignment it increases by 1.
epoch = epoch.Add(epoch, common.Big1) epoch = epoch.Add(epoch, common.Big1)
} }
header := &types.Header{ header := &block.Header{
ParentHash: parent.Hash(), ParentHash: parent.Hash(),
Number: num.Add(num, common.Big1), Number: num.Add(num, common.Big1),
GasLimit: core.CalcGasLimit(parent, w.gasFloor, w.gasCeil), GasLimit: core.CalcGasLimit(parent, w.gasFloor, w.gasCeil),
@ -224,7 +225,7 @@ func (w *Worker) UpdateCurrent(coinbase common.Address) error {
} }
// makeCurrent creates a new environment for the current cycle. // makeCurrent creates a new environment for the current cycle.
func (w *Worker) makeCurrent(parent *types.Block, header *types.Header) error { func (w *Worker) makeCurrent(parent *types.Block, header *block.Header) error {
state, err := w.chain.StateAt(parent.Root()) state, err := w.chain.StateAt(parent.Root())
if err != nil { if err != nil {
return err return err
@ -306,7 +307,7 @@ func New(config *params.ChainConfig, chain *core.BlockChain, engine consensus_en
// ... except if parent has a resharding assignment it increases by 1. // ... except if parent has a resharding assignment it increases by 1.
epoch = epoch.Add(epoch, common.Big1) epoch = epoch.Add(epoch, common.Big1)
} }
header := &types.Header{ header := &block.Header{
ParentHash: parent.Hash(), ParentHash: parent.Hash(),
Number: num.Add(num, common.Big1), Number: num.Add(num, common.Big1),
GasLimit: core.CalcGasLimit(parent, worker.gasFloor, worker.gasCeil), GasLimit: core.CalcGasLimit(parent, worker.gasFloor, worker.gasCeil),

@ -1,4 +1,4 @@
package types package shard
import ( import (
"bytes" "bytes"
@ -16,15 +16,15 @@ import (
// EpochShardState is the shard state of an epoch // EpochShardState is the shard state of an epoch
type EpochShardState struct { type EpochShardState struct {
Epoch uint64 Epoch uint64
ShardState ShardState ShardState State
} }
// ShardState is the collection of all committees // State is the collection of all committees
type ShardState []Committee type State []Committee
// FindCommitteeByID returns the committee configuration for the given shard, // FindCommitteeByID returns the committee configuration for the given shard,
// or nil if the given shard is not found. // or nil if the given shard is not found.
func (ss ShardState) FindCommitteeByID(shardID uint32) *Committee { func (ss State) FindCommitteeByID(shardID uint32) *Committee {
for _, committee := range ss { for _, committee := range ss {
if committee.ShardID == shardID { if committee.ShardID == shardID {
return &committee return &committee
@ -34,16 +34,16 @@ func (ss ShardState) FindCommitteeByID(shardID uint32) *Committee {
} }
// DeepCopy returns a deep copy of the receiver. // DeepCopy returns a deep copy of the receiver.
func (ss ShardState) DeepCopy() ShardState { func (ss State) DeepCopy() State {
var r ShardState var r State
for _, c := range ss { for _, c := range ss {
r = append(r, c.DeepCopy()) r = append(r, c.DeepCopy())
} }
return r return r
} }
// CompareShardState compares two ShardState instances. // CompareShardState compares two State instances.
func CompareShardState(s1, s2 ShardState) int { func CompareShardState(s1, s2 State) int {
commonLen := len(s1) commonLen := len(s1)
if commonLen > len(s2) { if commonLen > len(s2) {
commonLen = len(s2) commonLen = len(s2)
@ -180,8 +180,8 @@ func GetHashFromNodeList(nodeList []NodeID) []byte {
return d.Sum(nil) return d.Sum(nil)
} }
// Hash is the root hash of ShardState // Hash is the root hash of State
func (ss ShardState) Hash() (h common.Hash) { func (ss State) Hash() (h common.Hash) {
// TODO ek – this sorting really doesn't belong here; it should instead // TODO ek – this sorting really doesn't belong here; it should instead
// be made an explicit invariant to be maintained and, if needed, checked. // be made an explicit invariant to be maintained and, if needed, checked.
copy := ss.DeepCopy() copy := ss.DeepCopy()

@ -1,4 +1,4 @@
package types package shard
import ( import (
"bytes" "bytes"
@ -65,7 +65,7 @@ func TestHash(t *testing.T) {
{common.Address{0x66}, blsPubKey6}, {common.Address{0x66}, blsPubKey6},
}, },
} }
shardState1 := ShardState{com1, com2} shardState1 := State{com1, com2}
h1 := shardState1.Hash() h1 := shardState1.Hash()
com3 := Committee{ com3 := Committee{
@ -85,7 +85,7 @@ func TestHash(t *testing.T) {
}, },
} }
shardState2 := ShardState{com3, com4} shardState2 := State{com3, com4}
h2 := shardState2.Hash() h2 := shardState2.Hash()
if bytes.Compare(h1[:], h2[:]) != 0 { if bytes.Compare(h1[:], h2[:]) != 0 {
Loading…
Cancel
Save