aboutsummaryrefslogtreecommitdiffstats
path: root/chain/block_manager.go
diff options
context:
space:
mode:
authorobscuren <geffobscura@gmail.com>2014-11-04 17:57:02 +0800
committerobscuren <geffobscura@gmail.com>2014-11-04 17:57:02 +0800
commitf59a3b67f69b26f969084e0de165435e80bd8e12 (patch)
treef92098fa0252484fcdccdaf6075c2842713a2fc9 /chain/block_manager.go
parent1025d097fd4e5171dadb2c1a8eeb43b7730b13b6 (diff)
downloadgo-tangerine-f59a3b67f69b26f969084e0de165435e80bd8e12.tar.gz
go-tangerine-f59a3b67f69b26f969084e0de165435e80bd8e12.tar.zst
go-tangerine-f59a3b67f69b26f969084e0de165435e80bd8e12.zip
StateManager => BlockManager
Diffstat (limited to 'chain/block_manager.go')
-rw-r--r--chain/block_manager.go439
1 files changed, 439 insertions, 0 deletions
diff --git a/chain/block_manager.go b/chain/block_manager.go
new file mode 100644
index 000000000..998b1705d
--- /dev/null
+++ b/chain/block_manager.go
@@ -0,0 +1,439 @@
+package chain
+
+import (
+ "bytes"
+ "container/list"
+ "fmt"
+ "math/big"
+ "os"
+ "sync"
+ "time"
+
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/logger"
+ "github.com/ethereum/go-ethereum/state"
+ "github.com/ethereum/go-ethereum/wire"
+)
+
+var statelogger = logger.NewLogger("BLOCK")
+
+type Peer interface {
+ Inbound() bool
+ LastSend() time.Time
+ LastPong() int64
+ Host() []byte
+ Port() uint16
+ Version() string
+ PingTime() string
+ Connected() *int32
+ Caps() *ethutil.Value
+}
+
+type EthManager interface {
+ BlockManager() *BlockManager
+ ChainManager() *ChainManager
+ TxPool() *TxPool
+ Broadcast(msgType wire.MsgType, data []interface{})
+ PeerCount() int
+ IsMining() bool
+ IsListening() bool
+ Peers() *list.List
+ KeyManager() *crypto.KeyManager
+ ClientIdentity() wire.ClientIdentity
+ Db() ethutil.Database
+ EventMux() *event.TypeMux
+}
+
+type BlockManager struct {
+ // Mutex for locking the block processor. Blocks can only be handled one at a time
+ mutex sync.Mutex
+ // Canonical block chain
+ bc *ChainManager
+ // non-persistent key/value memory storage
+ mem map[string]*big.Int
+ // Proof of work used for validating
+ Pow PoW
+ // The ethereum manager interface
+ eth EthManager
+ // The managed states
+ // Transiently state. The trans state isn't ever saved, validated and
+ // it could be used for setting account nonces without effecting
+ // the main states.
+ transState *state.State
+ // Mining state. The mining state is used purely and solely by the mining
+ // operation.
+ miningState *state.State
+
+ // The last attempted block is mainly used for debugging purposes
+ // This does not have to be a valid block and will be set during
+ // 'Process' & canonical validation.
+ lastAttemptedBlock *Block
+
+ events event.Subscription
+}
+
+func NewBlockManager(ethereum EthManager) *BlockManager {
+ sm := &BlockManager{
+ mem: make(map[string]*big.Int),
+ Pow: &EasyPow{},
+ eth: ethereum,
+ bc: ethereum.ChainManager(),
+ }
+ sm.transState = ethereum.ChainManager().CurrentBlock.State().Copy()
+ sm.miningState = ethereum.ChainManager().CurrentBlock.State().Copy()
+
+ return sm
+}
+
+func (self *BlockManager) Start() {
+ statelogger.Debugln("Starting state manager")
+ self.events = self.eth.EventMux().Subscribe(Blocks(nil))
+ go self.updateThread()
+}
+
+func (self *BlockManager) Stop() {
+ statelogger.Debugln("Stopping state manager")
+ self.events.Unsubscribe()
+}
+
+func (self *BlockManager) updateThread() {
+ for ev := range self.events.Chan() {
+ for _, block := range ev.(Blocks) {
+ err := self.Process(block)
+ if err != nil {
+ statelogger.Infoln(err)
+ statelogger.Debugf("Block #%v failed (%x...)\n", block.Number, block.Hash()[0:4])
+ statelogger.Debugln(block)
+ break
+ }
+ }
+ }
+}
+
+func (sm *BlockManager) CurrentState() *state.State {
+ return sm.eth.ChainManager().CurrentBlock.State()
+}
+
+func (sm *BlockManager) TransState() *state.State {
+ return sm.transState
+}
+
+func (sm *BlockManager) MiningState() *state.State {
+ return sm.miningState
+}
+
+func (sm *BlockManager) NewMiningState() *state.State {
+ sm.miningState = sm.eth.ChainManager().CurrentBlock.State().Copy()
+
+ return sm.miningState
+}
+
+func (sm *BlockManager) ChainManager() *ChainManager {
+ return sm.bc
+}
+
+func (self *BlockManager) ProcessTransactions(coinbase *state.StateObject, state *state.State, block, parent *Block, txs Transactions) (Receipts, Transactions, Transactions, Transactions, error) {
+ var (
+ receipts Receipts
+ handled, unhandled Transactions
+ erroneous Transactions
+ totalUsedGas = big.NewInt(0)
+ err error
+ )
+
+done:
+ for i, tx := range txs {
+ // If we are mining this block and validating we want to set the logs back to 0
+ state.EmptyLogs()
+
+ txGas := new(big.Int).Set(tx.Gas)
+
+ cb := state.GetStateObject(coinbase.Address())
+ st := NewStateTransition(cb, tx, state, block)
+ err = st.TransitionState()
+ if err != nil {
+ statelogger.Infoln(err)
+ switch {
+ case IsNonceErr(err):
+ err = nil // ignore error
+ continue
+ case IsGasLimitErr(err):
+ unhandled = txs[i:]
+
+ break done
+ default:
+ statelogger.Infoln(err)
+ erroneous = append(erroneous, tx)
+ err = nil
+ continue
+ //return nil, nil, nil, err
+ }
+ }
+
+ // Update the state with pending changes
+ state.Update()
+
+ txGas.Sub(txGas, st.gas)
+ cumulative := new(big.Int).Set(totalUsedGas.Add(totalUsedGas, txGas))
+ //receipt := &Receipt{tx, ethutil.CopyBytes(state.Root().([]byte)), accumelative}
+ receipt := &Receipt{ethutil.CopyBytes(state.Root().([]byte)), cumulative, LogsBloom(state.Logs()).Bytes(), state.Logs()}
+
+ if i < len(block.Receipts()) {
+ original := block.Receipts()[i]
+ if !original.Cmp(receipt) {
+ if ethutil.Config.Diff {
+ os.Exit(1)
+ }
+
+ err := fmt.Errorf("#%d receipt failed (r) %v ~ %x <=> (c) %v ~ %x (%x...)", i+1, original.CumulativeGasUsed, original.PostState[0:4], receipt.CumulativeGasUsed, receipt.PostState[0:4], tx.Hash()[0:4])
+
+ return nil, nil, nil, nil, err
+ }
+ }
+
+ // Notify all subscribers
+ go self.eth.EventMux().Post(TxPostEvent{tx})
+
+ receipts = append(receipts, receipt)
+ handled = append(handled, tx)
+
+ if ethutil.Config.Diff && ethutil.Config.DiffType == "all" {
+ state.CreateOutputForDiff()
+ }
+ }
+
+ parent.GasUsed = totalUsedGas
+
+ return receipts, handled, unhandled, erroneous, err
+}
+
+func (sm *BlockManager) Process(block *Block) (err error) {
+ // Processing a blocks may never happen simultaneously
+ sm.mutex.Lock()
+ defer sm.mutex.Unlock()
+
+ if sm.bc.HasBlock(block.Hash()) {
+ return nil
+ }
+
+ if !sm.bc.HasBlock(block.PrevHash) {
+ return ParentError(block.PrevHash)
+ }
+
+ sm.lastAttemptedBlock = block
+
+ var (
+ parent = sm.bc.GetBlock(block.PrevHash)
+ state = parent.State()
+ )
+
+ // Defer the Undo on the Trie. If the block processing happened
+ // we don't want to undo but since undo only happens on dirty
+ // nodes this won't happen because Commit would have been called
+ // before that.
+ defer state.Reset()
+
+ if ethutil.Config.Diff && ethutil.Config.DiffType == "all" {
+ fmt.Printf("## %x %x ##\n", block.Hash(), block.Number)
+ }
+
+ txSha := DeriveSha(block.transactions)
+ if bytes.Compare(txSha, block.TxSha) != 0 {
+ return fmt.Errorf("Error validating transaction sha. Received %x, got %x", block.TxSha, txSha)
+ }
+
+ receipts, err := sm.ApplyDiff(state, parent, block)
+ if err != nil {
+ return err
+ }
+
+ receiptSha := DeriveSha(receipts)
+ if bytes.Compare(receiptSha, block.ReceiptSha) != 0 {
+ return fmt.Errorf("Error validating receipt sha. Received %x, got %x", block.ReceiptSha, receiptSha)
+ }
+
+ // TODO validate bloom
+
+ // Block validation
+ if err = sm.ValidateBlock(block); err != nil {
+ statelogger.Errorln("Error validating block:", err)
+ return err
+ }
+
+ if err = sm.AccumelateRewards(state, block, parent); err != nil {
+ statelogger.Errorln("Error accumulating reward", err)
+ return err
+ }
+
+ state.Update()
+
+ if !block.State().Cmp(state) {
+ err = fmt.Errorf("Invalid merkle root.\nrec: %x\nis: %x", block.State().Trie.Root, state.Trie.Root)
+ return
+ }
+
+ // Calculate the new total difficulty and sync back to the db
+ if sm.CalculateTD(block) {
+ // Sync the current block's state to the database and cancelling out the deferred Undo
+ state.Sync()
+
+ // Add the block to the chain
+ sm.bc.Add(block)
+
+ // TODO at this point we should also insert LOGS in to a database
+
+ sm.transState = state.Copy()
+
+ statelogger.Infof("Imported block #%d (%x...)\n", block.Number, block.Hash()[0:4])
+
+ state.Manifest().Reset()
+
+ sm.eth.TxPool().RemoveSet(block.Transactions())
+ } else {
+ statelogger.Errorln("total diff failed")
+ }
+
+ return nil
+}
+
+func (sm *BlockManager) ApplyDiff(state *state.State, parent, block *Block) (receipts Receipts, err error) {
+ coinbase := state.GetOrNewStateObject(block.Coinbase)
+ coinbase.SetGasPool(block.CalcGasLimit(parent))
+
+ // Process the transactions on to current block
+ receipts, _, _, _, err = sm.ProcessTransactions(coinbase, state, block, parent, block.Transactions())
+ if err != nil {
+ return nil, err
+ }
+
+ return receipts, nil
+}
+
+func (sm *BlockManager) CalculateTD(block *Block) bool {
+ uncleDiff := new(big.Int)
+ for _, uncle := range block.Uncles {
+ uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty)
+ }
+
+ // TD(genesis_block) = 0 and TD(B) = TD(B.parent) + sum(u.difficulty for u in B.uncles) + B.difficulty
+ td := new(big.Int)
+ td = td.Add(sm.bc.TD, uncleDiff)
+ td = td.Add(td, block.Difficulty)
+
+ // The new TD will only be accepted if the new difficulty is
+ // is greater than the previous.
+ if td.Cmp(sm.bc.TD) > 0 {
+ // Set the new total difficulty back to the block chain
+ sm.bc.SetTotalDifficulty(td)
+
+ return true
+ }
+
+ return false
+}
+
+// Validates the current block. Returns an error if the block was invalid,
+// an uncle or anything that isn't on the current block chain.
+// Validation validates easy over difficult (dagger takes longer time = difficult)
+func (sm *BlockManager) ValidateBlock(block *Block) error {
+ // Check each uncle's previous hash. In order for it to be valid
+ // is if it has the same block hash as the current
+ parent := sm.bc.GetBlock(block.PrevHash)
+ /*
+ for _, uncle := range block.Uncles {
+ if bytes.Compare(uncle.PrevHash,parent.PrevHash) != 0 {
+ return ValidationError("Mismatch uncle's previous hash. Expected %x, got %x",parent.PrevHash, uncle.PrevHash)
+ }
+ }
+ */
+
+ expd := CalcDifficulty(block, parent)
+ if expd.Cmp(block.Difficulty) < 0 {
+ return fmt.Errorf("Difficulty check failed for block %v, %v", block.Difficulty, expd)
+ }
+
+ diff := block.Time - parent.Time
+ if diff < 0 {
+ return ValidationError("Block timestamp less then prev block %v (%v - %v)", diff, block.Time, sm.bc.CurrentBlock.Time)
+ }
+
+ /* XXX
+ // New blocks must be within the 15 minute range of the last block.
+ if diff > int64(15*time.Minute) {
+ return ValidationError("Block is too far in the future of last block (> 15 minutes)")
+ }
+ */
+
+ // Verify the nonce of the block. Return an error if it's not valid
+ if !sm.Pow.Verify(block.HashNoNonce(), block.Difficulty, block.Nonce) {
+ return ValidationError("Block's nonce is invalid (= %v)", ethutil.Bytes2Hex(block.Nonce))
+ }
+
+ return nil
+}
+
+func (sm *BlockManager) AccumelateRewards(state *state.State, block, parent *Block) error {
+ reward := new(big.Int).Set(BlockReward)
+
+ knownUncles := ethutil.Set(parent.Uncles)
+ nonces := ethutil.NewSet(block.Nonce)
+ for _, uncle := range block.Uncles {
+ if nonces.Include(uncle.Nonce) {
+ // Error not unique
+ return UncleError("Uncle not unique")
+ }
+
+ uncleParent := sm.bc.GetBlock(uncle.PrevHash)
+ if uncleParent == nil {
+ return UncleError("Uncle's parent unknown")
+ }
+
+ if uncleParent.Number.Cmp(new(big.Int).Sub(parent.Number, big.NewInt(6))) < 0 {
+ return UncleError("Uncle too old")
+ }
+
+ if knownUncles.Include(uncle.Hash()) {
+ return UncleError("Uncle in chain")
+ }
+
+ nonces.Insert(uncle.Nonce)
+
+ r := new(big.Int)
+ r.Mul(BlockReward, big.NewInt(15)).Div(r, big.NewInt(16))
+
+ uncleAccount := state.GetAccount(uncle.Coinbase)
+ uncleAccount.AddAmount(r)
+
+ reward.Add(reward, new(big.Int).Div(BlockReward, big.NewInt(32)))
+ }
+
+ // Get the account associated with the coinbase
+ account := state.GetAccount(block.Coinbase)
+ // Reward amount of ether to the coinbase address
+ account.AddAmount(reward)
+
+ return nil
+}
+
+func (sm *BlockManager) GetMessages(block *Block) (messages []*state.Message, err error) {
+ if !sm.bc.HasBlock(block.PrevHash) {
+ return nil, ParentError(block.PrevHash)
+ }
+
+ sm.lastAttemptedBlock = block
+
+ var (
+ parent = sm.bc.GetBlock(block.PrevHash)
+ state = parent.State().Copy()
+ )
+
+ defer state.Reset()
+
+ sm.ApplyDiff(state, parent, block)
+
+ sm.AccumelateRewards(state, block, parent)
+
+ return state.Manifest().Messages, nil
+}