Renamed block manager to state manager
This commit is contained in:
obscuren
parent
79320e2868
commit
6c6e8b0fd7
@ -15,14 +15,14 @@ type BlockProcessor interface {
|
||||
}
|
||||
|
||||
type EthManager interface {
|
||||
StateManager() *BlockManager
|
||||
StateManager() *StateManager
|
||||
BlockChain() *BlockChain
|
||||
TxPool() *TxPool
|
||||
Broadcast(msgType ethwire.MsgType, data []interface{})
|
||||
}
|
||||
|
||||
// TODO rename to state manager
|
||||
type BlockManager struct {
|
||||
type StateManager struct {
|
||||
// Mutex for locking the block processor. Blocks can only be handled one at a time
|
||||
mutex sync.Mutex
|
||||
|
||||
@ -52,8 +52,8 @@ type BlockManager struct {
|
||||
compState *State
|
||||
}
|
||||
|
||||
func NewBlockManager(ethereum EthManager) *BlockManager {
|
||||
bm := &BlockManager{
|
||||
func NewStateManager(ethereum EthManager) *StateManager {
|
||||
sm := &StateManager{
|
||||
stack: NewStack(),
|
||||
mem: make(map[string]*big.Int),
|
||||
Pow: &EasyPow{},
|
||||
@ -62,57 +62,57 @@ func NewBlockManager(ethereum EthManager) *BlockManager {
|
||||
bc: ethereum.BlockChain(),
|
||||
}
|
||||
|
||||
return bm
|
||||
return sm
|
||||
}
|
||||
|
||||
func (bm *BlockManager) ProcState() *State {
|
||||
return bm.procState
|
||||
func (sm *StateManager) ProcState() *State {
|
||||
return sm.procState
|
||||
}
|
||||
|
||||
// Watches any given address and puts it in the address state store
|
||||
func (bm *BlockManager) WatchAddr(addr []byte) *AccountState {
|
||||
//FIXME account := bm.procState.GetAccount(addr)
|
||||
account := bm.bc.CurrentBlock.state.GetAccount(addr)
|
||||
func (sm *StateManager) WatchAddr(addr []byte) *AccountState {
|
||||
//FIXME account := sm.procState.GetAccount(addr)
|
||||
account := sm.bc.CurrentBlock.state.GetAccount(addr)
|
||||
|
||||
return bm.addrStateStore.Add(addr, account)
|
||||
return sm.addrStateStore.Add(addr, account)
|
||||
}
|
||||
|
||||
func (bm *BlockManager) GetAddrState(addr []byte) *AccountState {
|
||||
account := bm.addrStateStore.Get(addr)
|
||||
func (sm *StateManager) GetAddrState(addr []byte) *AccountState {
|
||||
account := sm.addrStateStore.Get(addr)
|
||||
if account == nil {
|
||||
a := bm.bc.CurrentBlock.state.GetAccount(addr)
|
||||
a := sm.bc.CurrentBlock.state.GetAccount(addr)
|
||||
account = &AccountState{Nonce: a.Nonce, Account: a}
|
||||
}
|
||||
|
||||
return account
|
||||
}
|
||||
|
||||
func (bm *BlockManager) BlockChain() *BlockChain {
|
||||
return bm.bc
|
||||
func (sm *StateManager) BlockChain() *BlockChain {
|
||||
return sm.bc
|
||||
}
|
||||
|
||||
func (bm *BlockManager) MakeContract(tx *Transaction) {
|
||||
contract := MakeContract(tx, bm.procState)
|
||||
func (sm *StateManager) MakeContract(tx *Transaction) {
|
||||
contract := MakeContract(tx, sm.procState)
|
||||
if contract != nil {
|
||||
bm.procState.states[string(tx.Hash()[12:])] = contract.state
|
||||
sm.procState.states[string(tx.Hash()[12:])] = contract.state
|
||||
}
|
||||
}
|
||||
|
||||
func (bm *BlockManager) ApplyTransactions(block *Block, txs []*Transaction) {
|
||||
func (sm *StateManager) ApplyTransactions(block *Block, txs []*Transaction) {
|
||||
// Process each transaction/contract
|
||||
for _, tx := range txs {
|
||||
// If there's no recipient, it's a contract
|
||||
if tx.IsContract() {
|
||||
//FIXME bm.MakeContract(tx)
|
||||
//FIXME sm.MakeContract(tx)
|
||||
block.MakeContract(tx)
|
||||
} else {
|
||||
//FIXME if contract := procState.GetContract(tx.Recipient); contract != nil {
|
||||
if contract := block.state.GetContract(tx.Recipient); contract != nil {
|
||||
bm.ProcessContract(contract, tx, block)
|
||||
sm.ProcessContract(contract, tx, block)
|
||||
} else {
|
||||
err := bm.Ethereum.TxPool().ProcessTransaction(tx, block)
|
||||
err := sm.Ethereum.TxPool().ProcessTransaction(tx, block)
|
||||
if err != nil {
|
||||
ethutil.Config.Log.Infoln("[BMGR]", err)
|
||||
ethutil.Config.Log.Infoln("[smGR]", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -121,78 +121,78 @@ func (bm *BlockManager) ApplyTransactions(block *Block, txs []*Transaction) {
|
||||
|
||||
// The prepare function, prepares the state manager for the next
|
||||
// "ProcessBlock" action.
|
||||
func (bm *BlockManager) Prepare(processer *State, comparative *State) {
|
||||
bm.compState = comparative
|
||||
bm.procState = processer
|
||||
func (sm *StateManager) Prepare(processer *State, comparative *State) {
|
||||
sm.compState = comparative
|
||||
sm.procState = processer
|
||||
}
|
||||
|
||||
// Default prepare function
|
||||
func (bm *BlockManager) PrepareDefault(block *Block) {
|
||||
bm.Prepare(bm.BlockChain().CurrentBlock.State(), block.State())
|
||||
func (sm *StateManager) PrepareDefault(block *Block) {
|
||||
sm.Prepare(sm.BlockChain().CurrentBlock.State(), block.State())
|
||||
}
|
||||
|
||||
// Block processing and validating with a given (temporarily) state
|
||||
func (bm *BlockManager) ProcessBlock(block *Block) error {
|
||||
func (sm *StateManager) ProcessBlock(block *Block) error {
|
||||
// Processing a blocks may never happen simultaneously
|
||||
bm.mutex.Lock()
|
||||
defer bm.mutex.Unlock()
|
||||
sm.mutex.Lock()
|
||||
defer sm.mutex.Unlock()
|
||||
// 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 bm.bc.CurrentBlock.Undo()
|
||||
defer sm.bc.CurrentBlock.Undo()
|
||||
|
||||
hash := block.Hash()
|
||||
|
||||
if bm.bc.HasBlock(hash) {
|
||||
if sm.bc.HasBlock(hash) {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Check if we have the parent hash, if it isn't known we discard it
|
||||
// Reasons might be catching up or simply an invalid block
|
||||
if !bm.bc.HasBlock(block.PrevHash) && bm.bc.CurrentBlock != nil {
|
||||
if !sm.bc.HasBlock(block.PrevHash) && sm.bc.CurrentBlock != nil {
|
||||
return ParentError(block.PrevHash)
|
||||
}
|
||||
|
||||
// Process the transactions on to current block
|
||||
bm.ApplyTransactions(bm.bc.CurrentBlock, block.Transactions())
|
||||
sm.ApplyTransactions(sm.bc.CurrentBlock, block.Transactions())
|
||||
|
||||
// Block validation
|
||||
if err := bm.ValidateBlock(block); err != nil {
|
||||
if err := sm.ValidateBlock(block); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// I'm not sure, but I don't know if there should be thrown
|
||||
// any errors at this time.
|
||||
if err := bm.AccumelateRewards(bm.bc.CurrentBlock, block); err != nil {
|
||||
if err := sm.AccumelateRewards(sm.bc.CurrentBlock, block); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// if !bm.compState.Cmp(bm.procState)
|
||||
if !block.state.Cmp(bm.bc.CurrentBlock.state) {
|
||||
return fmt.Errorf("Invalid merkle root. Expected %x, got %x", block.State().trie.Root, bm.bc.CurrentBlock.State().trie.Root)
|
||||
//FIXME return fmt.Errorf("Invalid merkle root. Expected %x, got %x", bm.compState.trie.Root, bm.procState.trie.Root)
|
||||
// if !sm.compState.Cmp(sm.procState)
|
||||
if !block.state.Cmp(sm.bc.CurrentBlock.state) {
|
||||
return fmt.Errorf("Invalid merkle root. Expected %x, got %x", block.State().trie.Root, sm.bc.CurrentBlock.State().trie.Root)
|
||||
//FIXME return fmt.Errorf("Invalid merkle root. Expected %x, got %x", sm.compState.trie.Root, sm.procState.trie.Root)
|
||||
}
|
||||
|
||||
// Calculate the new total difficulty and sync back to the db
|
||||
if bm.CalculateTD(block) {
|
||||
if sm.CalculateTD(block) {
|
||||
// Sync the current block's state to the database and cancelling out the deferred Undo
|
||||
bm.bc.CurrentBlock.Sync()
|
||||
//FIXME bm.procState.Sync()
|
||||
sm.bc.CurrentBlock.Sync()
|
||||
//FIXME sm.procState.Sync()
|
||||
|
||||
// Broadcast the valid block back to the wire
|
||||
//bm.Ethereum.Broadcast(ethwire.MsgBlockTy, []interface{}{block.Value().Val})
|
||||
//sm.Ethereum.Broadcast(ethwire.MsgBlockTy, []interface{}{block.Value().Val})
|
||||
|
||||
// Add the block to the chain
|
||||
bm.bc.Add(block)
|
||||
sm.bc.Add(block)
|
||||
|
||||
// If there's a block processor present, pass in the block for further
|
||||
// processing
|
||||
if bm.SecondaryBlockProcessor != nil {
|
||||
bm.SecondaryBlockProcessor.ProcessBlock(block)
|
||||
if sm.SecondaryBlockProcessor != nil {
|
||||
sm.SecondaryBlockProcessor.ProcessBlock(block)
|
||||
}
|
||||
|
||||
ethutil.Config.Log.Infof("[BMGR] Added block #%d (%x)\n", block.BlockInfo().Number, block.Hash())
|
||||
ethutil.Config.Log.Infof("[smGR] Added block #%d (%x)\n", block.BlockInfo().Number, block.Hash())
|
||||
} else {
|
||||
fmt.Println("total diff failed")
|
||||
}
|
||||
@ -200,7 +200,7 @@ func (bm *BlockManager) ProcessBlock(block *Block) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (bm *BlockManager) CalculateTD(block *Block) bool {
|
||||
func (sm *StateManager) CalculateTD(block *Block) bool {
|
||||
uncleDiff := new(big.Int)
|
||||
for _, uncle := range block.Uncles {
|
||||
uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty)
|
||||
@ -208,14 +208,14 @@ func (bm *BlockManager) CalculateTD(block *Block) bool {
|
||||
|
||||
// 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(bm.bc.TD, uncleDiff)
|
||||
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(bm.bc.TD) > 0 {
|
||||
if td.Cmp(sm.bc.TD) > 0 {
|
||||
// Set the new total difficulty back to the block chain
|
||||
bm.bc.SetTotalDifficulty(td)
|
||||
sm.bc.SetTotalDifficulty(td)
|
||||
|
||||
return true
|
||||
}
|
||||
@ -226,20 +226,20 @@ func (bm *BlockManager) CalculateTD(block *Block) bool {
|
||||
// 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 (bm *BlockManager) ValidateBlock(block *Block) error {
|
||||
func (sm *StateManager) ValidateBlock(block *Block) error {
|
||||
// TODO
|
||||
// 2. Check if the difficulty is correct
|
||||
|
||||
// Check each uncle's previous hash. In order for it to be valid
|
||||
// is if it has the same block hash as the current
|
||||
previousBlock := bm.bc.GetBlock(block.PrevHash)
|
||||
previousBlock := sm.bc.GetBlock(block.PrevHash)
|
||||
for _, uncle := range block.Uncles {
|
||||
if bytes.Compare(uncle.PrevHash, previousBlock.PrevHash) != 0 {
|
||||
return ValidationError("Mismatch uncle's previous hash. Expected %x, got %x", previousBlock.PrevHash, uncle.PrevHash)
|
||||
}
|
||||
}
|
||||
|
||||
diff := block.Time - bm.bc.CurrentBlock.Time
|
||||
diff := block.Time - sm.bc.CurrentBlock.Time
|
||||
if diff < 0 {
|
||||
return ValidationError("Block timestamp less then prev block %v", diff)
|
||||
}
|
||||
@ -250,7 +250,7 @@ func (bm *BlockManager) ValidateBlock(block *Block) error {
|
||||
}
|
||||
|
||||
// Verify the nonce of the block. Return an error if it's not valid
|
||||
if !bm.Pow.Verify(block.HashNoNonce(), block.Difficulty, block.Nonce) {
|
||||
if !sm.Pow.Verify(block.HashNoNonce(), block.Difficulty, block.Nonce) {
|
||||
return ValidationError("Block's nonce is invalid (= %v)", block.Nonce)
|
||||
}
|
||||
|
||||
@ -269,7 +269,7 @@ func CalculateUncleReward(block *Block) *big.Int {
|
||||
return UncleReward
|
||||
}
|
||||
|
||||
func (bm *BlockManager) AccumelateRewards(processor *Block, block *Block) error {
|
||||
func (sm *StateManager) AccumelateRewards(processor *Block, block *Block) error {
|
||||
// Get the coinbase rlp data
|
||||
addr := processor.state.GetAccount(block.Coinbase)
|
||||
//FIXME addr := proc.GetAccount(block.Coinbase)
|
||||
@ -290,11 +290,11 @@ func (bm *BlockManager) AccumelateRewards(processor *Block, block *Block) error
|
||||
return nil
|
||||
}
|
||||
|
||||
func (bm *BlockManager) Stop() {
|
||||
bm.bc.Stop()
|
||||
func (sm *StateManager) Stop() {
|
||||
sm.bc.Stop()
|
||||
}
|
||||
|
||||
func (bm *BlockManager) ProcessContract(contract *Contract, tx *Transaction, block *Block) {
|
||||
func (sm *StateManager) ProcessContract(contract *Contract, tx *Transaction, block *Block) {
|
||||
// Recovering function in case the VM had any errors
|
||||
/*
|
||||
defer func() {
|
||||
@ -305,7 +305,7 @@ func (bm *BlockManager) ProcessContract(contract *Contract, tx *Transaction, blo
|
||||
*/
|
||||
|
||||
vm := &Vm{}
|
||||
//vm.Process(contract, bm.procState, RuntimeVars{
|
||||
//vm.Process(contract, sm.procState, RuntimeVars{
|
||||
vm.Process(contract, block.state, RuntimeVars{
|
||||
address: tx.Hash()[12:],
|
||||
blockNumber: block.BlockInfo().Number,
|
||||
12
ethereum.go
12
ethereum.go
@ -36,8 +36,8 @@ type Ethereum struct {
|
||||
// DB interface
|
||||
//db *ethdb.LDBDatabase
|
||||
db ethutil.Database
|
||||
// Block manager for processing new blocks and managing the block chain
|
||||
blockManager *ethchain.BlockManager
|
||||
// State manager for processing new blocks and managing the over all states
|
||||
stateManager *ethchain.StateManager
|
||||
// The transaction pool. Transaction can be pushed on this pool
|
||||
// for later including in the blocks
|
||||
txPool *ethchain.TxPool
|
||||
@ -91,7 +91,7 @@ func New(caps Caps, usePnp bool) (*Ethereum, error) {
|
||||
}
|
||||
ethereum.txPool = ethchain.NewTxPool(ethereum)
|
||||
ethereum.blockChain = ethchain.NewBlockChain(ethereum)
|
||||
ethereum.blockManager = ethchain.NewBlockManager(ethereum)
|
||||
ethereum.stateManager = ethchain.NewStateManager(ethereum)
|
||||
|
||||
// Start the tx pool
|
||||
ethereum.txPool.Start()
|
||||
@ -103,8 +103,8 @@ func (s *Ethereum) BlockChain() *ethchain.BlockChain {
|
||||
return s.blockChain
|
||||
}
|
||||
|
||||
func (s *Ethereum) StateManager() *ethchain.BlockManager {
|
||||
return s.blockManager
|
||||
func (s *Ethereum) StateManager() *ethchain.StateManager {
|
||||
return s.stateManager
|
||||
}
|
||||
|
||||
func (s *Ethereum) TxPool() *ethchain.TxPool {
|
||||
@ -304,7 +304,7 @@ func (s *Ethereum) Stop() {
|
||||
close(s.quit)
|
||||
|
||||
s.txPool.Stop()
|
||||
s.blockManager.Stop()
|
||||
s.stateManager.Stop()
|
||||
|
||||
close(s.shutdownChan)
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user