// Copyright 2018 The dexon-consensus-core Authors
// This file is part of the dexon-consensus-core library.
//
// The dexon-consensus-core library is free software: you can redistribute it
// and/or modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// The dexon-consensus-core library is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
// General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the dexon-consensus-core library. If not, see
// <http://www.gnu.org/licenses/>.
package core
import (
"sync"
"time"
"github.com/dexon-foundation/dexon-consensus-core/common"
"github.com/dexon-foundation/dexon-consensus-core/core/blockdb"
"github.com/dexon-foundation/dexon-consensus-core/core/crypto"
"github.com/dexon-foundation/dexon-consensus-core/core/types"
)
// Shard represents a unit to produce a global ordering from multiple chains.
type Shard struct {
lock sync.RWMutex
ID uint32
nodeID types.NodeID
prvKey crypto.PrivateKey
chainNum uint32
app Application
debug Debug
db blockdb.BlockDatabase
pool blockPool
lattice *blockLattice
toModule *totalOrdering
ctModule *consensusTimestamp
}
// NewShard constructs an Shard instance.
func NewShard(
ID uint32,
cfg *types.Config,
prvKey crypto.PrivateKey,
app Application,
debug Debug,
db blockdb.BlockDatabase) (s *Shard) {
s = &Shard{
ID: ID,
nodeID: types.NewNodeID(prvKey.PublicKey()),
prvKey: prvKey,
chainNum: cfg.NumChains,
app: app,
debug: debug,
db: db,
pool: newBlockPool(cfg.NumChains),
lattice: newBlockLattice(ID, cfg.NumChains),
toModule: newTotalOrdering(
uint64(cfg.K),
uint64(float32(cfg.NumChains-1)*cfg.PhiRatio+1),
cfg.NumChains),
ctModule: newConsensusTimestamp(),
}
return
}
// PrepareBlock setup block's field based on current lattice status.
func (s *Shard) PrepareBlock(
b *types.Block, proposeTime time.Time) (err error) {
s.lock.RLock()
defer s.lock.RUnlock()
s.lattice.prepareBlock(b)
// TODO(mission): the proposeTime might be earlier than tip block of
// that chain. We should let blockLattice suggest the time.
b.ProposerID = s.nodeID
b.Timestamp = proposeTime
b.Payload = s.app.PreparePayload(b.Position)
if b.Hash, err = hashBlock(b); err != nil {
return
}
if b.Signature, err = s.prvKey.Sign(b.Hash); err != nil {
return
}
return
}
// SanityCheck check if a block is valid based on current lattice status.
//
// If some acking blocks don't exists, Shard would help to cache this block
// and retry when lattice updated in Shard.ProcessBlock.
func (s *Shard) SanityCheck(b *types.Block) (err error) {
// Check block.Position.
if b.Position.ShardID != s.ID {
err = ErrIncorrectBlockPosition
return
}
// Check the hash of block.
hash, err := hashBlock(b)
if err != nil || hash != b.Hash {
err = ErrIncorrectHash
return
}
// Check the signer.
pubKey, err := crypto.SigToPub(b.Hash, b.Signature)
if err != nil {
return
}
if !b.ProposerID.Equal(crypto.Keccak256Hash(pubKey.Bytes())) {
err = ErrIncorrectSignature
return
}
s.lock.RLock()
defer s.lock.RUnlock()
if err = s.lattice.sanityCheck(b); err != nil {
// Add to block pool, once the lattice updated,
// would be checked again.
if err == ErrAckingBlockNotExists {
s.pool.addBlock(b)
}
return
}
return
}
// ProcessBlock adds a block into lattice, and deliver ordered blocks.
// If any block pass sanity check after this block add into lattice, they
// would be returned, too.
//
// NOTE: assume the block passed sanity check.
func (s *Shard) ProcessBlock(
input *types.Block) (verified, delivered []*types.Block, err error) {
var (
tip, b *types.Block
toDelivered []*types.Block
inLattice []*types.Block
earlyDelivered bool
)
s.lock.Lock()
defer s.lock.Unlock()
if inLattice, err = s.lattice.addBlock(input); err != nil {
return
}
if err = s.db.Put(*input); err != nil {
return
}
// TODO(mission): remove this hack, BA related stuffs should not
// be done here.
if s.debug != nil {
s.debug.StronglyAcked(input.Hash)
s.debug.BlockConfirmed(input.Hash)
}
// Purge blocks in pool with the same chainID and lower height.
s.pool.purgeBlocks(input.Position.ChainID, input.Position.Height)
// Replay tips in pool to check their validity.
for i := uint32(0); i < s.chainNum; i++ {
if tip = s.pool.tip(i); tip == nil {
continue
}
err = s.lattice.sanityCheck(tip)
if err == nil {
verified = append(verified, tip)
}
if err == ErrAckingBlockNotExists {
continue
}
s.pool.removeTip(i)
}
// Perform total ordering for each block added to lattice.
for _, b = range inLattice {
toDelivered, earlyDelivered, err = s.toModule.processBlock(b)
if err != nil {
return
}
if len(toDelivered) == 0 {
continue
}
hashes := make(common.Hashes, len(toDelivered))
for idx := range toDelivered {
hashes[idx] = toDelivered[idx].Hash
}
if s.debug != nil {
s.debug.TotalOrderingDelivered(hashes, earlyDelivered)
}
// Perform timestamp generation.
if err = s.ctModule.processBlocks(toDelivered); err != nil {
return
}
delivered = append(delivered, toDelivered...)
}
return
}
