mirror
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum
2
0
Fork 1
Code Issues Releases Wiki Activity

StateManager => BlockManager

Browse Source
pull/182/head
obscuren 10 years ago
parent 1025d097fd
commit f59a3b67f6
16 changed files with 51 additions and 67 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      block_pool.go
  2. 52
      chain/block_manager.go
  3. 6
      chain/bloom9_test.go
  4. 2
      chain/filter.go
  5. 4
      chain/transaction_pool.go
  6. 2
      cmd/mist/bindings.go
  7. 4
      cmd/mist/debugger.go
  8. 4
      cmd/mist/gui.go
  9. 2
      cmd/mist/ui_lib.go
  10. 2
      cmd/utils/cmd.go
  11. 12
      ethereum.go
  12. 2
      javascript/javascript_runtime.go
  13. 10
      miner/miner.go
  14. 4
      xeth/hexface.go
  15. 8
      xeth/pipe.go
  16. 2
      xeth/world.go

2
block_pool.go
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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 {

Write Preview
Loading…
Cancel
Save