X-Git-Url: http://git.osdn.net/view?p=bytom%2Fvapor.git;a=blobdiff_plain;f=protocol%2Fprotocol.go;h=39ef664ff99d342f23fa3cd181d8101e825ecdbd;hp=98b285b032ccdf59d9a49ef1a53db1e218600891;hb=42c5ab23c13e7f43d0055221ec38752555bd987e;hpb=a6f99bcae0c1f80ff65708b65ab03244c0a2fecc

diff --git a/protocol/protocol.go b/protocol/protocol.go
index 98b285b0..39ef664f 100644
--- a/protocol/protocol.go
+++ b/protocol/protocol.go
@@ -5,31 +5,29 @@ import (
 
 	log "github.com/sirupsen/logrus"
 
+	"github.com/vapor/common"
 	"github.com/vapor/config"
 	"github.com/vapor/event"
 	"github.com/vapor/protocol/bc"
 	"github.com/vapor/protocol/bc/types"
 	"github.com/vapor/protocol/state"
-	"github.com/vapor/common"
 )
 
 const maxProcessBlockChSize = 1024
 
 // Chain provides functions for working with the Bytom block chain.
 type Chain struct {
-	index          *state.BlockIndex
 	orphanManage   *OrphanManage
 	txPool         *TxPool
 	store          Store
 	processBlockCh chan *processBlockMsg
 
-	consensusNodeManager *consensusNodeManager
-	signatureCache       *common.Cache
-	eventDispatcher      *event.Dispatcher
+	signatureCache  *common.Cache
+	eventDispatcher *event.Dispatcher
 
-	cond                 sync.Cond
-	bestNode             *state.BlockNode
-	bestIrreversibleNode *state.BlockNode
+	cond               sync.Cond
+	bestBlockHeader    *types.BlockHeader
+	bestIrrBlockHeader *types.BlockHeader
 }
 
 // NewChain returns a new Chain using store as the underlying storage.
@@ -53,14 +51,15 @@ func NewChain(store Store, txPool *TxPool, eventDispatcher *event.Dispatcher) (*
 	}
 
 	var err error
-	if c.index, err = store.LoadBlockIndex(storeStatus.Height); err != nil {
+	c.bestBlockHeader, err = c.store.GetBlockHeader(storeStatus.Hash)
+	if err != nil {
 		return nil, err
 	}
 
-	c.bestNode = c.index.GetNode(storeStatus.Hash)
-	c.bestIrreversibleNode = c.index.GetNode(storeStatus.IrreversibleHash)
-	c.consensusNodeManager = newConsensusNodeManager(store, c.index)
-	c.index.SetMainChain(c.bestNode)
+	c.bestIrrBlockHeader, err = c.store.GetBlockHeader(storeStatus.IrreversibleHash)
+	if err != nil {
+		return nil, err
+	}
 	go c.blockProcesser()
 	return c, nil
 }
@@ -90,50 +89,66 @@ func (c *Chain) initChainStatus() error {
 		BlockHash:   genesisBlock.Hash(),
 		BlockHeight: 0,
 	}}
-	node, err := state.NewBlockNode(&genesisBlock.BlockHeader, nil)
-	if err != nil {
-		return err
-	}
 
-	return c.store.SaveChainStatus(node, node, utxoView, voteResults)
+	genesisBlockHeader := &genesisBlock.BlockHeader
+	return c.store.SaveChainStatus(genesisBlockHeader, genesisBlockHeader, []*types.BlockHeader{genesisBlockHeader}, utxoView, voteResults)
 }
 
 // BestBlockHeight returns the current height of the blockchain.
 func (c *Chain) BestBlockHeight() uint64 {
 	c.cond.L.Lock()
 	defer c.cond.L.Unlock()
-	return c.bestNode.Height
+	return c.bestBlockHeader.Height
 }
 
 // BestBlockHash return the hash of the chain tail block
 func (c *Chain) BestBlockHash() *bc.Hash {
 	c.cond.L.Lock()
 	defer c.cond.L.Unlock()
-	return &c.bestNode.Hash
+	bestHash := c.bestBlockHeader.Hash()
+	return &bestHash
+}
+
+// BestIrreversibleHeader returns the chain best irreversible block header
+func (c *Chain) BestIrreversibleHeader() *types.BlockHeader {
+	c.cond.L.Lock()
+	defer c.cond.L.Unlock()
+	return c.bestIrrBlockHeader
 }
 
-// BestBlockHeader returns the chain tail block
+// BestBlockHeader returns the chain best block header
 func (c *Chain) BestBlockHeader() *types.BlockHeader {
-	node := c.index.BestNode()
-	return node.BlockHeader()
+	c.cond.L.Lock()
+	defer c.cond.L.Unlock()
+	return c.bestBlockHeader
 }
 
 // InMainChain checks wheather a block is in the main chain
 func (c *Chain) InMainChain(hash bc.Hash) bool {
-	return c.index.InMainchain(hash)
+	blockHeader, err := c.store.GetBlockHeader(&hash)
+	if err != nil {
+		return false
+	}
+
+	blockHash, err := c.store.GetMainChainHash(blockHeader.Height)
+	if err != nil {
+		log.WithFields(log.Fields{"module": logModule, "height": blockHeader.Height}).Debug("not contain block hash in main chain for specified height")
+		return false
+	}
+	return *blockHash == hash
 }
 
 // This function must be called with mu lock in above level
-func (c *Chain) setState(node, irreversibleNode *state.BlockNode, view *state.UtxoViewpoint, voteResults []*state.VoteResult) error {
-	if err := c.store.SaveChainStatus(node, irreversibleNode, view, voteResults); err != nil {
+func (c *Chain) setState(blockHeader, irrBlockHeader *types.BlockHeader, mainBlockHeaders []*types.BlockHeader, view *state.UtxoViewpoint, voteResults []*state.VoteResult) error {
+	if err := c.store.SaveChainStatus(blockHeader, irrBlockHeader, mainBlockHeaders, view, voteResults); err != nil {
 		return err
 	}
 
-	c.index.SetMainChain(node)
-	c.bestNode = node
-	c.bestIrreversibleNode = irreversibleNode
+	c.bestBlockHeader = blockHeader
+	c.bestIrrBlockHeader = irrBlockHeader
 
-	log.WithFields(log.Fields{"module": logModule, "height": c.bestNode.Height, "hash": c.bestNode.Hash.String()}).Debug("chain best status has been update")
+	blockHash := blockHeader.Hash()
+	log.WithFields(log.Fields{"module": logModule, "height": blockHeader.Height, "hash": blockHash.String()}).Debug("chain best status has been update")
 	c.cond.Broadcast()
 	return nil
 }
@@ -144,7 +159,7 @@ func (c *Chain) BlockWaiter(height uint64) <-chan struct{} {
 	go func() {
 		c.cond.L.Lock()
 		defer c.cond.L.Unlock()
-		for c.bestNode.Height < height {
+		for c.bestBlockHeader.Height < height {
 			c.cond.Wait()
 		}
 		ch <- struct{}{}