PoS_EVM
/
woop
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add shard state into genesis and fix shard state hashing bug

Browse Source
pull/1096/head
Rongjian Lan 5 years ago
parent fc91b1edd4
commit c7971dbb83
17 changed files with 156 additions and 116 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      cmd/harmony/main.go
  2. 46
      core/blockchain.go
  3. 9
      core/gen_genesis.go
  4. 44
      core/genesis.go
  5. 5
      core/headerchain.go
  6. 13
      core/rawdb/accessors_chain.go
  7. 14
      core/rawdb/accessors_chain_test.go
  8. 9
      core/resharding.go
  9. 37
      core/types/block.go
  10. 19
      core/types/shard_state.go
  11. 10
      core/types/shard_state_test.go
  12. 1
      go.mod
  13. 4
      node/node.go
  14. 20
      node/node_genesis.go
  15. 23
      node/node_handler.go
  16. 8
      node/node_newblock.go
  17. 8
      node/worker/worker.go

2
cmd/harmony/main.go
Unescape View File

@ -413,7 +413,7 @@ func setUpConsensusAndNode(nodeConfig *nodeconfig.ConfigType) *node.Node {
// This needs to be executed after consensus and drand are setup
if !*isNewNode || *shardID > -1 { // initial staking new node doesn't need to initialize shard state
// TODO: Have a better why to distinguish non-genesis node
// TODO: Have a better way to distinguish non-genesis node
if err := currentNode.InitShardState(*shardID == -1 && !*isNewNode); err != nil {
ctxerror.Crit(utils.GetLogger(), err, "InitShardState failed",
"shardID", *shardID, "isNewNode", *isNewNode)

46
core/blockchain.go
Unescape View File

@ -22,7 +22,6 @@ import (
"fmt"
"io"
"math/big"
mrand "math/rand"
"sync"
"sync/atomic"
"time"
@ -945,25 +944,12 @@ func (bc *BlockChain) WriteBlockWithState(block *types.Block, receipts []*types.
bc.wg.Add(1)
defer bc.wg.Done()
// Calculate the total difficulty of the block
ptd := bc.GetTd(block.ParentHash(), block.NumberU64()-1)
if ptd == nil {
return NonStatTy, consensus_engine.ErrUnknownAncestor
}
// Make sure no inconsistent state is leaked during insertion
bc.mu.Lock()
defer bc.mu.Unlock()
currentBlock := bc.CurrentBlock()
localTd := bc.GetTd(currentBlock.Hash(), currentBlock.NumberU64())
// Set the block's own difficulty to 1
// TODO: fix the difficulty issue
externTd := new(big.Int).Add(big.NewInt(1), ptd)
// Irrelevant of the canonical status, write the block itself to the database
if err := bc.hc.WriteTd(block.Hash(), block.NumberU64(), externTd); err != nil {
return NonStatTy, err
}
rawdb.WriteBlock(bc.db, block)
root, err := state.Commit(bc.chainConfig.IsEIP158(block.Number()))
@ -1026,21 +1012,8 @@ func (bc *BlockChain) WriteBlockWithState(block *types.Block, receipts []*types.
// If the total difficulty is higher than our known, add it to the canonical chain
// Second clause in the if statement reduces the vulnerability to selfish mining.
// Please refer to http://www.cs.cornell.edu/~ie53/publications/btcProcFC.pdf
reorg := externTd.Cmp(localTd) > 0
currentBlock = bc.CurrentBlock()
if !reorg && externTd.Cmp(localTd) == 0 {
// Split same-difficulty blocks by number, then preferentially select
// the block generated by the local miner as the canonical block.
if block.NumberU64() < currentBlock.NumberU64() {
reorg = true
} else if block.NumberU64() == currentBlock.NumberU64() {
var currentPreserve, blockPreserve bool
if bc.shouldPreserve != nil {
currentPreserve, blockPreserve = bc.shouldPreserve(currentBlock), bc.shouldPreserve(block)
}
reorg = !currentPreserve && (blockPreserve || mrand.Float64() < 0.5)
}
}
// TODO: figure out reorg issue
reorg := true
if reorg {
// Reorganise the chain if the parent is not the head block
if block.ParentHash() != currentBlock.Hash() {
@ -1086,7 +1059,7 @@ func (bc *BlockChain) InsertChain(chain types.Blocks) (int, error) {
"parentHash", header.ParentHash)
if header.ShardStateHash != (common.Hash{}) {
epoch := new(big.Int).Add(header.Epoch, common.Big1)
err = bc.WriteShardState(epoch, header.ShardState)
err = bc.WriteShardStateBytes(epoch, header.ShardState)
if err != nil {
ctxerror.Log15(header.Logger(utils.GetLogger()).Warn,
ctxerror.New("cannot store shard state").WithCause(err))
@ -1703,6 +1676,19 @@ func (bc *BlockChain) WriteShardState(
return nil
}
// WriteShardStateBytes saves the given sharding state under the given epoch number.
func (bc *BlockChain) WriteShardStateBytes(
epoch *big.Int, shardState []byte,
) error {
err := rawdb.WriteShardStateBytes(bc.db, epoch, shardState)
if err != nil {
return err
}
cacheKey := string(epoch.Bytes())
bc.shardStateCache.Add(cacheKey, shardState)
return nil
}
// GetVdfByNumber retrieves the rand seed given the block number, return 0 if not exist
func (bc *BlockChain) GetVdfByNumber(number uint64) [32]byte {
header := bc.GetHeaderByNumber(number)

9
core/gen_genesis.go
Unescape View File

@ -5,8 +5,6 @@ package core
import (
"encoding/json"
"errors"
"math/big"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/common/math"
@ -24,7 +22,6 @@ func (g Genesis) MarshalJSON() ([]byte, error) {
Timestamp math.HexOrDecimal64 `json:"timestamp"`
ExtraData hexutil.Bytes `json:"extraData"`
GasLimit math.HexOrDecimal64 `json:"gasLimit" gencodec:"required"`
Difficulty *math.HexOrDecimal256 `json:"difficulty" gencodec:"required"`
Mixhash common.Hash `json:"mixHash"`
Coinbase common.Address `json:"coinbase"`
Alloc map[common.UnprefixedAddress]GenesisAccount `json:"alloc" gencodec:"required"`
@ -40,7 +37,6 @@ func (g Genesis) MarshalJSON() ([]byte, error) {
enc.Timestamp = math.HexOrDecimal64(g.Timestamp)
enc.ExtraData = g.ExtraData
enc.GasLimit = math.HexOrDecimal64(g.GasLimit)
enc.Difficulty = (*math.HexOrDecimal256)(g.Difficulty)
enc.Mixhash = g.Mixhash
enc.Coinbase = g.Coinbase
if g.Alloc != nil {
@ -65,7 +61,6 @@ func (g *Genesis) UnmarshalJSON(input []byte) error {
Timestamp *math.HexOrDecimal64 `json:"timestamp"`
ExtraData *hexutil.Bytes `json:"extraData"`
GasLimit *math.HexOrDecimal64 `json:"gasLimit" gencodec:"required"`
Difficulty *math.HexOrDecimal256 `json:"difficulty" gencodec:"required"`
Mixhash *common.Hash `json:"mixHash"`
Coinbase *common.Address `json:"coinbase"`
Alloc map[common.UnprefixedAddress]GenesisAccount `json:"alloc" gencodec:"required"`
@ -97,10 +92,6 @@ func (g *Genesis) UnmarshalJSON(input []byte) error {
return errors.New("missing required field 'gasLimit' for Genesis")
}
g.GasLimit = uint64(*dec.GasLimit)
if dec.Difficulty == nil {
return errors.New("missing required field 'difficulty' for Genesis")
}
g.Difficulty = (*big.Int)(dec.Difficulty)
if dec.Mixhash != nil {
g.Mixhash = *dec.Mixhash
}

44
core/genesis.go
Unescape View File

@ -25,6 +25,8 @@ import (
"math/big"
"os"
"github.com/ethereum/go-ethereum/rlp"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/common/math"
@ -50,13 +52,12 @@ type Genesis struct {
ShardID uint32 `json:"shardID"`
Timestamp uint64 `json:"timestamp"`
ExtraData []byte `json:"extraData"`
GasLimit uint64 `json:"gasLimit" gencodec:"required"`
Difficulty *big.Int `json:"difficulty" gencodec:"required"`
GasLimit uint64 `json:"gasLimit" gencodec:"required"`
Mixhash common.Hash `json:"mixHash"`
Coinbase common.Address `json:"coinbase"`
Alloc GenesisAlloc `json:"alloc" gencodec:"required"`
ShardStateHash common.Hash `json:"shardStateHash"`
ShardState types.ShardState `json:"shardState"`
Alloc GenesisAlloc `json:"alloc" gencodec:"required"`
ShardStateHash common.Hash `json:"shardStateHash" gencodec:"required"`
ShardState types.ShardState `json:"shardState" gencodec:"required"`
// These fields are used for consensus tests. Please don't use them
// in actual genesis blocks.
@ -238,6 +239,11 @@ func (g *Genesis) ToBlock(db ethdb.Database) *types.Block {
}
}
root := statedb.IntermediateRoot(false)
shardStateBytes, err := rlp.EncodeToBytes(g.ShardState)
if err != nil {
utils.GetLogInstance().Error("failed to rlp-serialize genesis shard state")
os.Exit(1)
}
head := &types.Header{
Number: new(big.Int).SetUint64(g.Number),
Epoch: big.NewInt(0),
@ -251,7 +257,7 @@ func (g *Genesis) ToBlock(db ethdb.Database) *types.Block {
Coinbase: g.Coinbase,
Root: root,
ShardStateHash: g.ShardStateHash,
// ShardState is absent in epoch block; genesis shard state is implied
ShardState: shardStateBytes,
}
if g.GasLimit == 0 {
head.GasLimit = 10000000000 // TODO(RJ): figure out better solution. // params.GenesisGasLimit
@ -269,13 +275,19 @@ func (g *Genesis) Commit(db ethdb.Database) (*types.Block, error) {
if block.Number().Sign() != 0 {
return nil, fmt.Errorf("can't commit genesis block with number > 0")
}
rawdb.WriteTd(db, block.Hash(), block.NumberU64(), g.Difficulty)
rawdb.WriteBlock(db, block)
rawdb.WriteReceipts(db, block.Hash(), block.NumberU64(), nil)
rawdb.WriteCanonicalHash(db, block.Hash(), block.NumberU64())
rawdb.WriteHeadBlockHash(db, block.Hash())
rawdb.WriteHeadHeaderHash(db, block.Hash())
err := rawdb.WriteShardStateBytes(db, block.Header().Epoch, block.Header().ShardState)
if err != nil {
log.Crit("Failed to store genesis shard state", "err", err)
}
config := g.Config
if config == nil {
config = params.AllEthashProtocolChanges
@ -303,12 +315,11 @@ func GenesisBlockForTesting(db ethdb.Database, addr common.Address, balance *big
// DefaultGenesisBlock returns the Ethereum main net genesis block.
func DefaultGenesisBlock() *Genesis {
return &Genesis{
Config: params.MainnetChainConfig,
Nonce: 66,
ExtraData: hexutil.MustDecode("0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa"),
GasLimit: 5000,
Difficulty: big.NewInt(17179869184),
Alloc: decodePrealloc("empty"),
Config: params.MainnetChainConfig,
Nonce: 66,
ExtraData: hexutil.MustDecode("0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa"),
GasLimit: 5000,
Alloc: decodePrealloc("empty"),
}
}
@ -321,10 +332,9 @@ func DeveloperGenesisBlock(period uint64, faucet common.Address) *Genesis {
// Assemble and return the genesis with the precompiles and faucet pre-funded
return &Genesis{
Config: &config,
ExtraData: append(append(make([]byte, 32), faucet[:]...), make([]byte, 65)...),
GasLimit: 6283185,
Difficulty: big.NewInt(1),
Config: &config,
ExtraData: append(append(make([]byte, 32), faucet[:]...), make([]byte, 65)...),
GasLimit: 6283185,
Alloc: map[common.Address]GenesisAccount{
common.BytesToAddress([]byte{1}): {Balance: big.NewInt(1)}, // ECRecover
common.BytesToAddress([]byte{2}): {Balance: big.NewInt(1)}, // SHA256

5
core/headerchain.go
Unescape View File

@ -137,11 +137,6 @@ func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, er
hash = header.Hash()
number = header.Number.Uint64()
)
// Calculate the total difficulty of the header
ptd := hc.GetTd(header.ParentHash, number-1)
if ptd == nil {
return NonStatTy, consensus_engine.ErrUnknownAncestor
}
// TODO: implement fork choice mechanism
//localTd := hc.GetTd(hc.currentHeaderHash, hc.CurrentHeader().Number.Uint64())
//externTd := new(big.Int).Add(header.Difficulty, ptd)

13
core/rawdb/accessors_chain.go
Unescape View File

@ -358,7 +358,9 @@ func WriteBlock(db DatabaseWriter, block *types.Block) {
// Genesis block; record this block's epoch and block numbers.
writeOne()
}
if len(block.Header().ShardState) > 0 {
// TODO: don't change epoch based on shard state presence
if len(block.Header().ShardState) > 0 && block.NumberU64() != 0 {
// End-of-epoch block; record the next epoch after this block.
epoch = new(big.Int).Add(epoch, common.Big1)
epochBlockNum = new(big.Int).Add(epochBlockNum, common.Big1)
@ -430,13 +432,20 @@ func WriteShardState(
"epoch", epoch,
).WithCause(err)
}
return WriteShardStateBytes(db, epoch, data)
}
// WriteShardStateBytes stores sharding state into database.
func WriteShardStateBytes(
db DatabaseWriter, epoch *big.Int, data []byte,
) (err error) {
if err = db.Put(shardStateKey(epoch), data); err != nil {
return ctxerror.New("cannot write sharding state",
"epoch", epoch,
).WithCause(err)
}
utils.GetLogger().Info("wrote sharding state",
"epoch", epoch, "numShards", len(shardState))
"epoch", epoch, "numShards", len(data))
return nil
}

14
core/rawdb/accessors_chain_test.go
Unescape View File

@ -115,9 +115,7 @@ func TestBlockStorage(t *testing.T) {
ReceiptHash: types.EmptyRootHash,
Epoch: big.NewInt(0),
Number: big.NewInt(0),
ShardState: types.ShardState{
{},
},
ShardState: []byte("dummy data"),
})
if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry != nil {
t.Fatalf("Non existent block returned: %v", entry)
@ -150,11 +148,11 @@ func TestBlockStorage(t *testing.T) {
} else if expected := big.NewInt(0); actual.Cmp(expected) != 0 {
t.Fatalf("Genesis epoch block number mismatch: have %v, want %v", actual, expected)
}
if actual, err := ReadEpochBlockNumber(db, big.NewInt(1)); err != nil {
t.Fatalf("Next epoch block number not found, error=%#v", err)
} else if expected := big.NewInt(1); actual.Cmp(expected) != 0 {
t.Fatalf("Next epoch block number mismatch: have %v, want %v", actual, expected)
}
//if actual, err := ReadEpochBlockNumber(db, big.NewInt(1)); err != nil {
// t.Fatalf("Next epoch block number not found, error=%#v", err)
//} else if expected := big.NewInt(1); actual.Cmp(expected) != 0 {
// t.Fatalf("Next epoch block number mismatch: have %v, want %v", actual, expected)
//}
// Delete the block and verify the execution
DeleteBlock(db, block.Hash(), block.NumberU64())
if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry != nil {

9
core/resharding.go
Unescape View File

@ -2,6 +2,7 @@ package core
import (
"encoding/binary"
"errors"
"math/big"
"math/rand"
"sort"
@ -25,9 +26,9 @@ const (
// GenesisShardNum is the number of shard at genesis
GenesisShardNum = 4
// GenesisShardSize is the size of each shard at genesis
GenesisShardSize = 100
GenesisShardSize = 5
// GenesisShardHarmonyNodes is the number of harmony node at each shard
GenesisShardHarmonyNodes = 72
GenesisShardHarmonyNodes = 5
// CuckooRate is the percentage of nodes getting reshuffled in the second step of cuckoo resharding.
CuckooRate = 0.1
)
@ -159,6 +160,9 @@ func GetEpochFromBlockNumber(blockNumber uint64) uint64 {
// GetShardingStateFromBlockChain will retrieve random seed and shard map from beacon chain for given a epoch
func GetShardingStateFromBlockChain(bc *BlockChain, epoch *big.Int) (*ShardingState, error) {
if bc == nil {
return nil, errors.New("no blockchain is supplied to get shard state")
}
shardState, err := bc.ReadShardState(epoch)
if err != nil {
return nil, err
@ -221,6 +225,7 @@ func (ss *ShardingState) UpdateShardingState(stakeInfo *map[common.Address]*stru
// GetInitShardState returns the initial shard state at genesis.
func GetInitShardState() types.ShardState {
utils.GetLogInstance().Info("Generating Genesis Shard State.")
shardState := types.ShardState{}
for i := 0; i < GenesisShardNum; i++ {
com := types.Committee{ShardID: uint32(i)}

37
core/types/block.go
Unescape View File

@ -95,8 +95,8 @@ type Header struct {
Vdf [258]byte `json:"vdf"`
VdfProof [258]byte `json:"vdfProof"`
ShardStateHash common.Hash `json:"shardStateRoot"`
ShardState ShardState `json:"shardState"`
CrossLinks [][]byte `json:"crossLinks"`
ShardState []byte `json:"shardState"`
CrossLinks []byte `json:"crossLinks"`
}
// field type overrides for gencodec
@ -133,6 +133,16 @@ func (h *Header) Logger(logger log.Logger) log.Logger {
)
}
// 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)
@ -159,6 +169,7 @@ type Block struct {
// Td is used by package core to store the total difficulty
// of the chain up to and including the block.
// TODO: use it as chain weight (e.g. signatures/stakes)
td *big.Int
// These fields are used by package eth to track
@ -226,7 +237,7 @@ type storageblock struct {
// are ignored and set to values derived from the given txs,
// and receipts.
func NewBlock(header *Header, txs []*Transaction, receipts []*Receipt) *Block {
b := &Block{header: CopyHeader(header), td: new(big.Int)}
b := &Block{header: CopyHeader(header)}
// TODO: panic if len(txs) != len(receipts)
if len(txs) == 0 {
@ -265,10 +276,21 @@ func CopyHeader(h *Header) *Header {
if cpy.Number = new(big.Int); h.Number != nil {
cpy.Number.Set(h.Number)
}
if cpy.Epoch = new(big.Int); h.Epoch != nil {
cpy.Epoch.Set(h.Epoch)
}
if len(h.Extra) > 0 {
cpy.Extra = make([]byte, len(h.Extra))
copy(cpy.Extra, h.Extra)
}
if len(h.ShardState) > 0 {
cpy.ShardState = make([]byte, len(h.ShardState))
copy(cpy.ShardState, h.ShardState)
}
if len(h.CrossLinks) > 0 {
cpy.CrossLinks = make([]byte, len(h.CrossLinks))
copy(cpy.CrossLinks, h.CrossLinks)
}
return &cpy
}
@ -485,12 +507,17 @@ func (b *Block) AddVrf(vrf [32]byte) {
}
// AddShardState add shardState into block header
func (b *Block) AddShardState(shardState ShardState) {
func (b *Block) AddShardState(shardState ShardState) error {
// Make a copy because ShardState.Hash() internally sorts entries.
// Store the sorted copy.
shardState = append(shardState[:0:0], shardState...)
b.header.ShardStateHash = shardState.Hash()
b.header.ShardState = shardState
data, err := rlp.EncodeToBytes(shardState)
if err != nil {
return err
}
b.header.ShardState = data
return nil
}
// Logger returns a sub-logger with block contexts added.

19
core/types/shard_state.go
Unescape View File

@ -145,8 +145,9 @@ type Committee struct {
// DeepCopy returns a deep copy of the receiver.
func (c Committee) DeepCopy() Committee {
r := c
r.NodeList = r.NodeList.DeepCopy()
r := Committee{}
r.ShardID = c.ShardID
r.NodeList = c.NodeList.DeepCopy()
return r
}
@ -165,16 +166,13 @@ func CompareCommittee(c1, c2 *Committee) int {
}
// GetHashFromNodeList will sort the list, then use Keccak256 to hash the list
// notice that the input nodeList will be modified (sorted)
// NOTE: do not modify the underlining content for hash
func GetHashFromNodeList(nodeList []NodeID) []byte {
// in general, nodeList should not be empty
if nodeList == nil || len(nodeList) == 0 {
return []byte{}
}
sort.Slice(nodeList, func(i, j int) bool {
return CompareNodeIDByBLSKey(nodeList[i], nodeList[j]) == -1
})
d := sha3.NewLegacyKeccak256()
for i := range nodeList {
d.Write(nodeList[i].Serialize())
@ -186,12 +184,13 @@ func GetHashFromNodeList(nodeList []NodeID) []byte {
func (ss ShardState) Hash() (h common.Hash) {
// TODO ek – this sorting really doesn't belong here; it should instead
// be made an explicit invariant to be maintained and, if needed, checked.
sort.Slice(ss, func(i, j int) bool {
return ss[i].ShardID < ss[j].ShardID
copy := ss.DeepCopy()
sort.Slice(copy, func(i, j int) bool {
return copy[i].ShardID < copy[j].ShardID
})
d := sha3.NewLegacyKeccak256()
for i := range ss {
hash := GetHashFromNodeList(ss[i].NodeList)
for i := range copy {
hash := GetHashFromNodeList(copy[i].NodeList)
d.Write(hash)
}
d.Sum(h[:0])

10
core/types/shard_state_test.go
Unescape View File

@ -43,8 +43,8 @@ func TestGetHashFromNodeList(t *testing.T) {
h1 := GetHashFromNodeList(l1)
h2 := GetHashFromNodeList(l2)
if bytes.Compare(h1, h2) != 0 {
t.Error("node list l1 and l2 should have equal hash")
if bytes.Compare(h1, h2) == 0 {
t.Error("node list l1 and l2 should be different")
}
}
@ -71,17 +71,17 @@ func TestHash(t *testing.T) {
com3 := Committee{
ShardID: 2,
NodeList: []NodeID{
{common.Address{0x66}, blsPubKey6},
{common.Address{0x55}, blsPubKey5},
{common.Address{0x44}, blsPubKey4},
{common.Address{0x55}, blsPubKey5},
{common.Address{0x66}, blsPubKey6},
},
}
com4 := Committee{
ShardID: 22,
NodeList: []NodeID{
{common.Address{0x11}, blsPubKey1},
{common.Address{0x12}, blsPubKey11},
{common.Address{0x23}, blsPubKey22},
{common.Address{0x11}, blsPubKey1},
},
}

1
go.mod
Unescape View File

@ -16,6 +16,7 @@ require (
github.com/fjl/memsize v0.0.0-20180929194037-2a09253e352a
github.com/garslo/gogen v0.0.0-20170307003452-d6ebae628c7c // indirect
github.com/go-ole/go-ole v1.2.4 // indirect
github.com/go-openapi/errors v0.19.2
github.com/go-stack/stack v1.8.0 // indirect
github.com/golang/mock v1.2.0
github.com/golang/protobuf v1.3.0

4
node/node.go
Unescape View File

@ -322,8 +322,8 @@ func New(host p2p.Host, consensusObj *consensus.Consensus, chainDBFactory shardc
node.BlockChannel = make(chan *types.Block)
node.ConfirmedBlockChannel = make(chan *types.Block)
node.BeaconBlockChannel = make(chan *types.Block)
node.TxPool = core.NewTxPool(core.DefaultTxPoolConfig, params.TestChainConfig, chain)
node.Worker = worker.New(params.TestChainConfig, chain, node.Consensus, node.Consensus.SelfAddress, node.Consensus.ShardID)
node.TxPool = core.NewTxPool(core.DefaultTxPoolConfig, node.Blockchain().Config(), chain)
node.Worker = worker.New(node.Blockchain().Config(), chain, node.Consensus, node.Consensus.SelfAddress, node.Consensus.ShardID)
node.Consensus.VerifiedNewBlock = make(chan *types.Block)
// the sequence number is the next block number to be added in consensus protocol, which is always one more than current chain header block

20
node/node_genesis.go
Unescape View File

@ -8,7 +8,6 @@ import (
"github.com/harmony-one/harmony/common/config"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/params"
@ -16,7 +15,6 @@ import (
"github.com/harmony-one/harmony/common/denominations"
"github.com/harmony-one/harmony/core"
"github.com/harmony-one/harmony/core/rawdb"
"github.com/harmony-one/harmony/core/types"
common2 "github.com/harmony-one/harmony/internal/common"
"github.com/harmony-one/harmony/internal/ctxerror"
@ -42,24 +40,21 @@ type genesisInitializer struct {
func (gi *genesisInitializer) InitChainDB(db ethdb.Database, shardID uint32) error {
shardState := core.GetInitShardState()
if shardID != 0 {
// store only the local shard
// store only the local shard for shard chains
c := shardState.FindCommitteeByID(shardID)
if c == nil {
return errors.New("cannot find local shard in genesis")
}
shardState = types.ShardState{*c}
}
if err := rawdb.WriteShardState(db, common.Big0, shardState); err != nil {
return ctxerror.New("cannot store epoch shard state").WithCause(err)
}
if err := gi.node.SetupGenesisBlock(db, shardID); err != nil {
if err := gi.node.SetupGenesisBlock(db, shardID, shardState); err != nil {
return ctxerror.New("cannot setup genesis block").WithCause(err)
}
return nil
}
// SetupGenesisBlock sets up a genesis blockchain.
func (node *Node) SetupGenesisBlock(db ethdb.Database, shardID uint32) error {
func (node *Node) SetupGenesisBlock(db ethdb.Database, shardID uint32, myShardState types.ShardState) error {
utils.GetLogger().Info("setting up a brand new chain database",
"shardID", shardID)
if shardID == node.Consensus.ShardID {
@ -93,12 +88,15 @@ func (node *Node) SetupGenesisBlock(db ethdb.Database, shardID uint32) error {
// AddNodeAddressesToGenesisAlloc(genesisAlloc)
}
// Initialize shard state
// TODO: add ShardID into chainconfig and change ChainID to NetworkID
chainConfig.ChainID = big.NewInt(int64(shardID)) // Use ChainID as piggybacked ShardID
gspec := core.Genesis{
Config: &chainConfig,
Alloc: genesisAlloc,
ShardID: shardID,
Config: &chainConfig,
Alloc: genesisAlloc,
ShardID: shardID,
ShardStateHash: myShardState.Hash(),
ShardState: myShardState.DeepCopy(),
}
// Store genesis block into db.

23
node/node_handler.go
Unescape View File

@ -297,7 +297,12 @@ func (node *Node) validateNewShardState(block *types.Block, stakeInfo *map[commo
// We aren't expecting to reshard, so proceed to sign
return nil
}
proposed := header.ShardState
var shardState *types.ShardState
err := rlp.DecodeBytes(header.ShardState, shardState)
if err != nil {
return err
}
proposed := *shardState
if block.ShardID() == 0 {
// Beacon validators independently recalculate the master state and
// compare it against the proposed copy.
@ -428,15 +433,25 @@ func (node *Node) PostConsensusProcessing(newBlock *types.Block) {
ctxerror.Log15(utils.GetLogInstance().Error, e)
}
}
node.transitionIntoNextEpoch(newBlockHeader.ShardState)
shardState, err := newBlockHeader.GetShardState()
if err != nil {
e := ctxerror.New("cannot get shard state from header").WithCause(err)
ctxerror.Log15(utils.GetLogInstance().Error, e)
} else {
node.transitionIntoNextEpoch(shardState)
}
}
}
func (node *Node) broadcastEpochShardState(newBlock *types.Block) error {
shardState, err := newBlock.Header().GetShardState()
if err != nil {
return err
}
epochShardStateMessage := proto_node.ConstructEpochShardStateMessage(
types.EpochShardState{
Epoch: newBlock.Header().Epoch.Uint64() + 1,
ShardState: newBlock.Header().ShardState,
ShardState: shardState,
},
)
return node.host.SendMessageToGroups(
@ -448,7 +463,7 @@ func (node *Node) broadcastEpochShardState(newBlock *types.Block) error {
func (node *Node) AddNewBlock(newBlock *types.Block) {
blockNum, err := node.Blockchain().InsertChain([]*types.Block{newBlock})
if err != nil {
utils.GetLogInstance().Debug("Error Adding new block to blockchain", "blockNum", blockNum, "hash", newBlock.Header().Hash(), "Error", err)
utils.GetLogInstance().Debug("Error Adding new block to blockchain", "blockNum", blockNum, "parentHash", newBlock.Header().ParentHash, "hash", newBlock.Header().Hash(), "Error", err)
} else {
utils.GetLogInstance().Info("Added New Block to Blockchain!!!", "blockNum", blockNum, "hash", newBlock.Header().Hash(), "by node", node.SelfPeer)
}

8
node/node_newblock.go
Unescape View File

@ -124,8 +124,7 @@ func (node *Node) proposeBeaconShardState(block *types.Block) error {
if err != nil {
return err
}
block.AddShardState(shardState)
return nil
return block.AddShardState(shardState)
}
func (node *Node) proposeLocalShardState(block *types.Block) {
@ -153,5 +152,8 @@ func (node *Node) proposeLocalShardState(block *types.Block) {
getLogger().Info("beacon committee disowned us; proposing nothing")
// Leave local proposal empty to signal the end of shard (disbanding).
}
block.AddShardState(localShardState)
err := block.AddShardState(localShardState)
if err != nil {
getLogger().Error("Failed proposin local shard state", "error", err)
}
}

8
node/worker/worker.go
Unescape View File

@ -114,7 +114,9 @@ func (w *Worker) UpdateCurrent() error {
timestamp := time.Now().Unix()
// New block's epoch is the same as parent's...
epoch := new(big.Int).Set(parent.Header().Epoch)
if len(parent.Header().ShardState) > 0 {
// TODO: Don't depend on sharding state for epoch change.
if len(parent.Header().ShardState) > 0 && parent.NumberU64() != 0 {
// ... except if parent has a resharding assignment it increases by 1.
epoch = epoch.Add(epoch, common.Big1)
}
@ -181,7 +183,9 @@ func New(config *params.ChainConfig, chain *core.BlockChain, engine consensus_en
timestamp := time.Now().Unix()
// New block's epoch is the same as parent's...
epoch := new(big.Int).Set(parent.Header().Epoch)
if len(parent.Header().ShardState) > 0 {
// TODO: Don't depend on sharding state for epoch change.
if len(parent.Header().ShardState) > 0 && parent.NumberU64() != 0 {
// ... except if parent has a resharding assignment it increases by 1.
epoch = epoch.Add(epoch, common.Big1)
}

Write Preview
Loading…
Cancel
Save