status-im
/
op-geth
mirror of https://github.com/status-im/op-geth.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

StateManager => BlockManager

This commit is contained in:
obscuren 2014-11-04 10:57:02 +01:00
parent 1025d097fd
commit f59a3b67f6
16 changed files with 51 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
block_pool.go
View File

@ -315,7 +315,7 @@ out:
// otherwise process and don't emit anything // otherwise process and don't emit anything
var err error var err error
for i, block := range blocks { for i, block := range blocks {
err = self.eth.StateManager().Process(block) err = self.eth.BlockManager().Process(block)
if err != nil { if err != nil {
poollogger.Infoln(err) poollogger.Infoln(err)
poollogger.Debugf("Block #%v failed (%x...)\n", block.Number, block.Hash()[0:4]) poollogger.Debugf("Block #%v failed (%x...)\n", block.Number, block.Hash()[0:4])

52
chain/state_manager.go → chain/block_manager.go
View File

@ -32,7 +32,7 @@ type Peer interface {
} }
type EthManager interface { type EthManager interface {
StateManager() *StateManager BlockManager() *BlockManager
ChainManager() *ChainManager ChainManager() *ChainManager
TxPool() *TxPool TxPool() *TxPool
Broadcast(msgType wire.MsgType, data []interface{}) Broadcast(msgType wire.MsgType, data []interface{})
@ -46,7 +46,7 @@ type EthManager interface {
EventMux() *event.TypeMux EventMux() *event.TypeMux
} }
type StateManager struct { type BlockManager struct {
// Mutex for locking the block processor. Blocks can only be handled one at a time // Mutex for locking the block processor. Blocks can only be handled one at a time
mutex sync.Mutex mutex sync.Mutex
// Canonical block chain // Canonical block chain
@ -74,8 +74,8 @@ type StateManager struct {
events event.Subscription events event.Subscription
} }
func NewStateManager(ethereum EthManager) *StateManager { func NewBlockManager(ethereum EthManager) *BlockManager {
sm := &StateManager{ sm := &BlockManager{
mem: make(map[string]*big.Int), mem: make(map[string]*big.Int),
Pow: &EasyPow{}, Pow: &EasyPow{},
eth: ethereum, eth: ethereum,
@ -87,18 +87,18 @@ func NewStateManager(ethereum EthManager) *StateManager {
return sm return sm
} }
func (self *StateManager) Start() { func (self *BlockManager) Start() {
statelogger.Debugln("Starting state manager") statelogger.Debugln("Starting state manager")
self.events = self.eth.EventMux().Subscribe(Blocks(nil)) self.events = self.eth.EventMux().Subscribe(Blocks(nil))
go self.updateThread() go self.updateThread()
} }
func (self *StateManager) Stop() { func (self *BlockManager) Stop() {
statelogger.Debugln("Stopping state manager") statelogger.Debugln("Stopping state manager")
self.events.Unsubscribe() self.events.Unsubscribe()
} }
func (self *StateManager) updateThread() { func (self *BlockManager) updateThread() {
for ev := range self.events.Chan() { for ev := range self.events.Chan() {
for _, block := range ev.(Blocks) { for _, block := range ev.(Blocks) {
err := self.Process(block) err := self.Process(block)
@ -112,29 +112,29 @@ func (self *StateManager) updateThread() {
} }
} }
func (sm *StateManager) CurrentState() *state.State { func (sm *BlockManager) CurrentState() *state.State {
return sm.eth.ChainManager().CurrentBlock.State() return sm.eth.ChainManager().CurrentBlock.State()
} }
func (sm *StateManager) TransState() *state.State { func (sm *BlockManager) TransState() *state.State {
return sm.transState return sm.transState
} }
func (sm *StateManager) MiningState() *state.State { func (sm *BlockManager) MiningState() *state.State {
return sm.miningState return sm.miningState
} }
func (sm *StateManager) NewMiningState() *state.State { func (sm *BlockManager) NewMiningState() *state.State {
sm.miningState = sm.eth.ChainManager().CurrentBlock.State().Copy() sm.miningState = sm.eth.ChainManager().CurrentBlock.State().Copy()
return sm.miningState return sm.miningState
} }
func (sm *StateManager) ChainManager() *ChainManager { func (sm *BlockManager) ChainManager() *ChainManager {
return sm.bc return sm.bc
} }
func (self *StateManager) ProcessTransactions(coinbase *state.StateObject, state *state.State, block, parent *Block, txs Transactions) (Receipts, Transactions, Transactions, Transactions, error) { func (self *BlockManager) ProcessTransactions(coinbase *state.StateObject, state *state.State, block, parent *Block, txs Transactions) (Receipts, Transactions, Transactions, Transactions, error) {
var ( var (
receipts Receipts receipts Receipts
handled, unhandled Transactions handled, unhandled Transactions
@ -209,7 +209,7 @@ done:
return receipts, handled, unhandled, erroneous, err return receipts, handled, unhandled, erroneous, err
} }
func (sm *StateManager) Process(block *Block) (err error) { func (sm *BlockManager) Process(block *Block) (err error) {
// Processing a blocks may never happen simultaneously // Processing a blocks may never happen simultaneously
sm.mutex.Lock() sm.mutex.Lock()
defer sm.mutex.Unlock() defer sm.mutex.Unlock()
@ -298,7 +298,7 @@ func (sm *StateManager) Process(block *Block) (err error) {
return nil return nil
} }
func (sm *StateManager) ApplyDiff(state *state.State, parent, block *Block) (receipts Receipts, err error) { func (sm *BlockManager) ApplyDiff(state *state.State, parent, block *Block) (receipts Receipts, err error) {
coinbase := state.GetOrNewStateObject(block.Coinbase) coinbase := state.GetOrNewStateObject(block.Coinbase)
coinbase.SetGasPool(block.CalcGasLimit(parent)) coinbase.SetGasPool(block.CalcGasLimit(parent))
@ -311,7 +311,7 @@ func (sm *StateManager) ApplyDiff(state *state.State, parent, block *Block) (rec
return receipts, nil return receipts, nil
} }
func (sm *StateManager) CalculateTD(block *Block) bool { func (sm *BlockManager) CalculateTD(block *Block) bool {
uncleDiff := new(big.Int) uncleDiff := new(big.Int)
for _, uncle := range block.Uncles { for _, uncle := range block.Uncles {
uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty) uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty)
@ -337,7 +337,7 @@ func (sm *StateManager) CalculateTD(block *Block) bool {
// Validates the current block. Returns an error if the block was invalid, // Validates the current block. Returns an error if the block was invalid,
// an uncle or anything that isn't on the current block chain. // an uncle or anything that isn't on the current block chain.
// Validation validates easy over difficult (dagger takes longer time = difficult) // Validation validates easy over difficult (dagger takes longer time = difficult)
func (sm *StateManager) ValidateBlock(block *Block) error { func (sm *BlockManager) ValidateBlock(block *Block) error {
// Check each uncle's previous hash. In order for it to be valid // Check each uncle's previous hash. In order for it to be valid
// is if it has the same block hash as the current // is if it has the same block hash as the current
parent := sm.bc.GetBlock(block.PrevHash) parent := sm.bc.GetBlock(block.PrevHash)
@ -374,7 +374,7 @@ func (sm *StateManager) ValidateBlock(block *Block) error {
return nil return nil
} }
func (sm *StateManager) AccumelateRewards(state *state.State, block, parent *Block) error { func (sm *BlockManager) AccumelateRewards(state *state.State, block, parent *Block) error {
reward := new(big.Int).Set(BlockReward) reward := new(big.Int).Set(BlockReward)
knownUncles := ethutil.Set(parent.Uncles) knownUncles := ethutil.Set(parent.Uncles)
@ -417,21 +417,7 @@ func (sm *StateManager) AccumelateRewards(state *state.State, block, parent *Blo
return nil return nil
} }
// Manifest will handle both creating notifications and generating bloom bin data func (sm *BlockManager) GetMessages(block *Block) (messages []*state.Message, err error) {
func (sm *StateManager) createBloomFilter(state *state.State) *BloomFilter {
bloomf := NewBloomFilter(nil)
for _, msg := range state.Manifest().Messages {
bloomf.Set(msg.To)
bloomf.Set(msg.From)
}
sm.eth.EventMux().Post(state.Manifest().Messages)
return bloomf
}
func (sm *StateManager) GetMessages(block *Block) (messages []*state.Message, err error) {
if !sm.bc.HasBlock(block.PrevHash) { if !sm.bc.HasBlock(block.PrevHash) {
return nil, ParentError(block.PrevHash) return nil, ParentError(block.PrevHash)
} }

6
chain/bloom9_test.go
View File

@ -1,12 +1,8 @@
package chain package chain
import ( import (
"fmt"
"testing" "testing"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/state"
"github.com/ethgo.old/ethutil"
) )
func TestBloom9(t *testing.T) { func TestBloom9(t *testing.T) {
@ -21,6 +17,7 @@ func TestBloom9(t *testing.T) {
} }
} }
/*
func TestAddress(t *testing.T) { func TestAddress(t *testing.T) {
block := &Block{} block := &Block{}
block.Coinbase = ethutil.Hex2Bytes("22341ae42d6dd7384bc8584e50419ea3ac75b83f") block.Coinbase = ethutil.Hex2Bytes("22341ae42d6dd7384bc8584e50419ea3ac75b83f")
@ -29,3 +26,4 @@ func TestAddress(t *testing.T) {
bin := CreateBloom(block) bin := CreateBloom(block)
fmt.Printf("bin = %x\n", ethutil.LeftPadBytes(bin, 64)) fmt.Printf("bin = %x\n", ethutil.LeftPadBytes(bin, 64))
} }
*/

2
chain/filter.go
View File

@ -100,7 +100,7 @@ func (self *Filter) Find() []*state.Message {
// current parameters // current parameters
if self.bloomFilter(block) { if self.bloomFilter(block) {
// Get the messages of the block // Get the messages of the block
msgs, err := self.eth.StateManager().GetMessages(block) msgs, err := self.eth.BlockManager().GetMessages(block)
if err != nil { if err != nil {
chainlogger.Warnln("err: filter get messages ", err) chainlogger.Warnln("err: filter get messages ", err)

4
chain/transaction_pool.go
View File

@ -114,8 +114,8 @@ func (pool *TxPool) ValidateTransaction(tx *Transaction) error {
} }
// Get the sender // Get the sender
//sender := pool.Ethereum.StateManager().procState.GetAccount(tx.Sender()) //sender := pool.Ethereum.BlockManager().procState.GetAccount(tx.Sender())
sender := pool.Ethereum.StateManager().CurrentState().GetAccount(tx.Sender()) sender := pool.Ethereum.BlockManager().CurrentState().GetAccount(tx.Sender())
totAmount := new(big.Int).Set(tx.Value) totAmount := new(big.Int).Set(tx.Value)
// Make sure there's enough in the sender's account. Having insufficient // Make sure there's enough in the sender's account. Having insufficient

2
cmd/mist/bindings.go
View File

@ -108,7 +108,7 @@ func (self *Gui) DumpState(hash, path string) {
var stateDump []byte var stateDump []byte
if len(hash) == 0 { if len(hash) == 0 {
stateDump = self.eth.StateManager().CurrentState().Dump() stateDump = self.eth.BlockManager().CurrentState().Dump()
} else { } else {
var block *chain.Block var block *chain.Block
if hash[0] == '#' { if hash[0] == '#' {

4
cmd/mist/debugger.go
View File

@ -141,8 +141,8 @@ func (self *DebuggerWindow) Debug(valueStr, gasStr, gasPriceStr, scriptStr, data
keyPair = self.lib.eth.KeyManager().KeyPair() keyPair = self.lib.eth.KeyManager().KeyPair()
) )
statedb := self.lib.eth.StateManager().TransState() statedb := self.lib.eth.BlockManager().TransState()
account := self.lib.eth.StateManager().TransState().GetAccount(keyPair.Address()) account := self.lib.eth.BlockManager().TransState().GetAccount(keyPair.Address())
contract := statedb.NewStateObject([]byte{0}) contract := statedb.NewStateObject([]byte{0})
contract.SetBalance(value) contract.SetBalance(value)

4
cmd/mist/gui.go
View File

@ -396,7 +396,7 @@ func (gui *Gui) update() {
generalUpdateTicker := time.NewTicker(500 * time.Millisecond) generalUpdateTicker := time.NewTicker(500 * time.Millisecond)
statsUpdateTicker := time.NewTicker(5 * time.Second) statsUpdateTicker := time.NewTicker(5 * time.Second)
state := gui.eth.StateManager().TransState() state := gui.eth.BlockManager().TransState()
unconfirmedFunds := new(big.Int) unconfirmedFunds := new(big.Int)
gui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(state.GetAccount(gui.address()).Balance()))) gui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(state.GetAccount(gui.address()).Balance())))
@ -428,7 +428,7 @@ func (gui *Gui) update() {
case chain.NewBlockEvent: case chain.NewBlockEvent:
gui.processBlock(ev.Block, false) gui.processBlock(ev.Block, false)
if bytes.Compare(ev.Block.Coinbase, gui.address()) == 0 { if bytes.Compare(ev.Block.Coinbase, gui.address()) == 0 {
gui.setWalletValue(gui.eth.StateManager().CurrentState().GetAccount(gui.address()).Balance(), nil) gui.setWalletValue(gui.eth.BlockManager().CurrentState().GetAccount(gui.address()).Balance(), nil)
} }
case chain.TxPreEvent: case chain.TxPreEvent:

2
cmd/mist/ui_lib.go
View File

@ -190,7 +190,7 @@ func (ui *UiLib) AssetPath(p string) string {
func (self *UiLib) StartDbWithContractAndData(contractHash, data string) { func (self *UiLib) StartDbWithContractAndData(contractHash, data string) {
dbWindow := NewDebuggerWindow(self) dbWindow := NewDebuggerWindow(self)
object := self.eth.StateManager().CurrentState().GetStateObject(ethutil.Hex2Bytes(contractHash)) object := self.eth.BlockManager().CurrentState().GetStateObject(ethutil.Hex2Bytes(contractHash))
if len(object.Code) > 0 { if len(object.Code) > 0 {
dbWindow.SetCode("0x" + ethutil.Bytes2Hex(object.Code)) dbWindow.SetCode("0x" + ethutil.Bytes2Hex(object.Code))
} }

2
cmd/utils/cmd.go
View File

@ -317,7 +317,7 @@ func BlockDo(ethereum *eth.Ethereum, hash []byte) error {
parent := ethereum.ChainManager().GetBlock(block.PrevHash) parent := ethereum.ChainManager().GetBlock(block.PrevHash)
_, err := ethereum.StateManager().ApplyDiff(parent.State(), parent, block) _, err := ethereum.BlockManager().ApplyDiff(parent.State(), parent, block)
if err != nil { if err != nil {
return err return err
} }

12
ethereum.go
View File

@ -50,7 +50,7 @@ type Ethereum struct {
// DB interface // DB interface
db ethutil.Database db ethutil.Database
// State manager for processing new blocks and managing the over all states // State manager for processing new blocks and managing the over all states
stateManager *chain.StateManager blockManager *chain.BlockManager
// The transaction pool. Transaction can be pushed on this pool // The transaction pool. Transaction can be pushed on this pool
// for later including in the blocks // for later including in the blocks
txPool *chain.TxPool txPool *chain.TxPool
@ -130,7 +130,7 @@ func New(db ethutil.Database, clientIdentity wire.ClientIdentity, keyManager *cr
ethereum.blockPool = NewBlockPool(ethereum) ethereum.blockPool = NewBlockPool(ethereum)
ethereum.txPool = chain.NewTxPool(ethereum) ethereum.txPool = chain.NewTxPool(ethereum)
ethereum.blockChain = chain.NewChainManager(ethereum) ethereum.blockChain = chain.NewChainManager(ethereum)
ethereum.stateManager = chain.NewStateManager(ethereum) ethereum.blockManager = chain.NewBlockManager(ethereum)
// Start the tx pool // Start the tx pool
ethereum.txPool.Start() ethereum.txPool.Start()
@ -150,8 +150,8 @@ func (s *Ethereum) ChainManager() *chain.ChainManager {
return s.blockChain return s.blockChain
} }
func (s *Ethereum) StateManager() *chain.StateManager { func (s *Ethereum) BlockManager() *chain.BlockManager {
return s.stateManager return s.blockManager
} }
func (s *Ethereum) TxPool() *chain.TxPool { func (s *Ethereum) TxPool() *chain.TxPool {
@ -392,7 +392,7 @@ func (s *Ethereum) reapDeadPeerHandler() {
// Start the ethereum // Start the ethereum
func (s *Ethereum) Start(seed bool) { func (s *Ethereum) Start(seed bool) {
s.blockPool.Start() s.blockPool.Start()
s.stateManager.Start() s.blockManager.Start()
// Bind to addr and port // Bind to addr and port
ln, err := net.Listen("tcp", ":"+s.Port) ln, err := net.Listen("tcp", ":"+s.Port)
@ -516,7 +516,7 @@ func (s *Ethereum) Stop() {
s.RpcServer.Stop() s.RpcServer.Stop()
} }
s.txPool.Stop() s.txPool.Stop()
s.stateManager.Stop() s.blockManager.Stop()
s.blockPool.Stop() s.blockPool.Stop()
loggerger.Infoln("Server stopped") loggerger.Infoln("Server stopped")

2
javascript/javascript_runtime.go
View File

@ -149,7 +149,7 @@ func (self *JSRE) dump(call otto.FunctionCall) otto.Value {
state = block.State() state = block.State()
} else { } else {
state = self.ethereum.StateManager().CurrentState() state = self.ethereum.BlockManager().CurrentState()
} }
v, _ := self.Vm.ToValue(state.Dump()) v, _ := self.Vm.ToValue(state.Dump())

10
miner/miner.go
View File

@ -67,7 +67,7 @@ func (miner *Miner) Start() {
miner.events = mux.Subscribe(chain.NewBlockEvent{}, chain.TxPreEvent{}) miner.events = mux.Subscribe(chain.NewBlockEvent{}, chain.TxPreEvent{})
// Prepare inital block // Prepare inital block
//miner.ethereum.StateManager().Prepare(miner.block.State(), miner.block.State()) //miner.ethereum.BlockManager().Prepare(miner.block.State(), miner.block.State())
go miner.listener() go miner.listener()
minerlogger.Infoln("Started") minerlogger.Infoln("Started")
@ -161,7 +161,7 @@ func (miner *Miner) stopMining() {
} }
func (self *Miner) mineNewBlock() { func (self *Miner) mineNewBlock() {
stateManager := self.ethereum.StateManager() blockManager := self.ethereum.BlockManager()
self.block = self.ethereum.ChainManager().NewBlock(self.coinbase) self.block = self.ethereum.ChainManager().NewBlock(self.coinbase)
@ -178,7 +178,7 @@ func (self *Miner) mineNewBlock() {
parent := self.ethereum.ChainManager().GetBlock(self.block.PrevHash) parent := self.ethereum.ChainManager().GetBlock(self.block.PrevHash)
coinbase := self.block.State().GetOrNewStateObject(self.block.Coinbase) coinbase := self.block.State().GetOrNewStateObject(self.block.Coinbase)
coinbase.SetGasPool(self.block.CalcGasLimit(parent)) coinbase.SetGasPool(self.block.CalcGasLimit(parent))
receipts, txs, unhandledTxs, erroneous, err := stateManager.ProcessTransactions(coinbase, self.block.State(), self.block, self.block, self.txs) receipts, txs, unhandledTxs, erroneous, err := blockManager.ProcessTransactions(coinbase, self.block.State(), self.block, self.block, self.txs)
if err != nil { if err != nil {
minerlogger.Debugln(err) minerlogger.Debugln(err)
} }
@ -189,7 +189,7 @@ func (self *Miner) mineNewBlock() {
self.block.SetReceipts(receipts) self.block.SetReceipts(receipts)
// Accumulate the rewards included for this block // Accumulate the rewards included for this block
stateManager.AccumelateRewards(self.block.State(), self.block, parent) blockManager.AccumelateRewards(self.block.State(), self.block, parent)
self.block.State().Update() self.block.State().Update()
@ -199,7 +199,7 @@ func (self *Miner) mineNewBlock() {
nonce := self.pow.Search(self.block, self.powQuitChan) nonce := self.pow.Search(self.block, self.powQuitChan)
if nonce != nil { if nonce != nil {
self.block.Nonce = nonce self.block.Nonce = nonce
err := self.ethereum.StateManager().Process(self.block) err := self.ethereum.BlockManager().Process(self.block)
if err != nil { if err != nil {
minerlogger.Infoln(err) minerlogger.Infoln(err)
} else { } else {

4
xeth/hexface.go
View File

@ -224,10 +224,10 @@ func (self *JSXEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr
tx = chain.NewTransactionMessage(hash, value, gas, gasPrice, data) tx = chain.NewTransactionMessage(hash, value, gas, gasPrice, data)
} }
acc := self.obj.StateManager().TransState().GetOrNewStateObject(keyPair.Address()) acc := self.obj.BlockManager().TransState().GetOrNewStateObject(keyPair.Address())
tx.Nonce = acc.Nonce tx.Nonce = acc.Nonce
acc.Nonce += 1 acc.Nonce += 1
self.obj.StateManager().TransState().UpdateStateObject(acc) self.obj.BlockManager().TransState().UpdateStateObject(acc)
tx.Sign(keyPair.PrivateKey) tx.Sign(keyPair.PrivateKey)
self.obj.TxPool().QueueTransaction(tx) self.obj.TxPool().QueueTransaction(tx)

8
xeth/pipe.go
View File

@ -24,7 +24,7 @@ type VmVars struct {
type XEth struct { type XEth struct {
obj chain.EthManager obj chain.EthManager
stateManager *chain.StateManager blockManager *chain.BlockManager
blockChain *chain.ChainManager blockChain *chain.ChainManager
world *World world *World
@ -34,7 +34,7 @@ type XEth struct {
func New(obj chain.EthManager) *XEth { func New(obj chain.EthManager) *XEth {
pipe := &XEth{ pipe := &XEth{
obj: obj, obj: obj,
stateManager: obj.StateManager(), blockManager: obj.BlockManager(),
blockChain: obj.ChainManager(), blockChain: obj.ChainManager(),
} }
pipe.world = NewWorld(pipe) pipe.world = NewWorld(pipe)
@ -137,10 +137,10 @@ func (self *XEth) Transact(key *crypto.KeyPair, rec []byte, value, gas, price *e
tx = chain.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data) tx = chain.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data)
} }
acc := self.stateManager.TransState().GetOrNewStateObject(key.Address()) acc := self.blockManager.TransState().GetOrNewStateObject(key.Address())
tx.Nonce = acc.Nonce tx.Nonce = acc.Nonce
acc.Nonce += 1 acc.Nonce += 1
self.stateManager.TransState().UpdateStateObject(acc) self.blockManager.TransState().UpdateStateObject(acc)
tx.Sign(key.PrivateKey) tx.Sign(key.PrivateKey)
self.obj.TxPool().QueueTransaction(tx) self.obj.TxPool().QueueTransaction(tx)

2
xeth/world.go
View File

@ -23,7 +23,7 @@ func (self *XEth) World() *World {
} }
func (self *World) State() *state.State { func (self *World) State() *state.State {
return self.pipe.stateManager.CurrentState() return self.pipe.blockManager.CurrentState()
} }
func (self *World) Get(addr []byte) *Object { func (self *World) Get(addr []byte) *Object {