BlockManager => BlockProcessor

cmd/utils/cmd.go

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

core/block_manager.go → core/block_processor.go

@@ -22,7 +22,7 @@ import (
 var statelogger = logger.NewLogger("BLOCK")
 
 type EthManager interface {
-	BlockManager() *BlockManager
+	BlockProcessor() *BlockProcessor
 	ChainManager() *ChainManager
 	TxPool() *TxPool
 	PeerCount() int
@@ -35,7 +35,7 @@ type EthManager interface {
 	EventMux() *event.TypeMux
 }
 
-type BlockManager struct {
+type BlockProcessor struct {
 	// Mutex for locking the block processor. Blocks can only be handled one at a time
 	mutex sync.Mutex
 	// Canonical block chain
@@ -57,8 +57,8 @@ type BlockManager struct {
 	eventMux *event.TypeMux
 }
 
-func NewBlockManager(txpool *TxPool, chainManager *ChainManager, eventMux *event.TypeMux) *BlockManager {
-	sm := &BlockManager{
+func NewBlockProcessor(txpool *TxPool, chainManager *ChainManager, eventMux *event.TypeMux) *BlockProcessor {
+	sm := &BlockProcessor{
 		mem:      make(map[string]*big.Int),
 		Pow:      ezp.New(),
 		bc:       chainManager,
@@ -69,7 +69,7 @@ func NewBlockManager(txpool *TxPool, chainManager *ChainManager, eventMux *event
 	return sm
 }
 
-func (sm *BlockManager) TransitionState(statedb *state.StateDB, parent, block *types.Block) (receipts types.Receipts, err error) {
+func (sm *BlockProcessor) TransitionState(statedb *state.StateDB, parent, block *types.Block) (receipts types.Receipts, err error) {
 	coinbase := statedb.GetOrNewStateObject(block.Header().Coinbase)
 	coinbase.SetGasPool(CalcGasLimit(parent, block))
 
@@ -82,7 +82,7 @@ func (sm *BlockManager) TransitionState(statedb *state.StateDB, parent, block *t
 	return receipts, nil
 }
 
-func (self *BlockManager) ApplyTransactions(coinbase *state.StateObject, state *state.StateDB, block *types.Block, txs types.Transactions, transientProcess bool) (types.Receipts, types.Transactions, types.Transactions, types.Transactions, error) {
+func (self *BlockProcessor) ApplyTransactions(coinbase *state.StateObject, state *state.StateDB, block *types.Block, txs types.Transactions, transientProcess bool) (types.Receipts, types.Transactions, types.Transactions, types.Transactions, error) {
 	var (
 		receipts           types.Receipts
 		handled, unhandled types.Transactions
@@ -149,7 +149,7 @@ done:
 	return receipts, handled, unhandled, erroneous, err
 }
 
-func (sm *BlockManager) Process(block *types.Block) (td *big.Int, msgs state.Messages, err error) {
+func (sm *BlockProcessor) Process(block *types.Block) (td *big.Int, msgs state.Messages, err error) {
 	// Processing a blocks may never happen simultaneously
 	sm.mutex.Lock()
 	defer sm.mutex.Unlock()
@@ -167,7 +167,7 @@ func (sm *BlockManager) Process(block *types.Block) (td *big.Int, msgs state.Mes
 	return sm.ProcessWithParent(block, parent)
 }
 
-func (sm *BlockManager) ProcessWithParent(block, parent *types.Block) (td *big.Int, messages state.Messages, err error) {
+func (sm *BlockProcessor) ProcessWithParent(block, parent *types.Block) (td *big.Int, messages state.Messages, err error) {
 	sm.lastAttemptedBlock = block
 
 	state := state.New(parent.Trie().Copy())
@@ -234,7 +234,7 @@ func (sm *BlockManager) ProcessWithParent(block, parent *types.Block) (td *big.I
 	}
 }
 
-func (sm *BlockManager) CalculateTD(block *types.Block) (*big.Int, bool) {
+func (sm *BlockProcessor) CalculateTD(block *types.Block) (*big.Int, bool) {
 	uncleDiff := new(big.Int)
 	for _, uncle := range block.Uncles() {
 		uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty)
@@ -257,7 +257,7 @@ func (sm *BlockManager) CalculateTD(block *types.Block) (*big.Int, 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 (sm *BlockManager) ValidateBlock(block, parent *types.Block) error {
+func (sm *BlockProcessor) ValidateBlock(block, parent *types.Block) error {
 	expd := CalcDifficulty(block, parent)
 	if expd.Cmp(block.Header().Difficulty) < 0 {
 		return fmt.Errorf("Difficulty check failed for block %v, %v", block.Header().Difficulty, expd)
@@ -283,7 +283,7 @@ func (sm *BlockManager) ValidateBlock(block, parent *types.Block) error {
 	return nil
 }
 
-func (sm *BlockManager) AccumelateRewards(statedb *state.StateDB, block, parent *types.Block) error {
+func (sm *BlockProcessor) AccumelateRewards(statedb *state.StateDB, block, parent *types.Block) error {
 	reward := new(big.Int).Set(BlockReward)
 
 	knownUncles := set.New()
@@ -338,7 +338,7 @@ func (sm *BlockManager) AccumelateRewards(statedb *state.StateDB, block, parent
 	return nil
 }
 
-func (sm *BlockManager) GetMessages(block *types.Block) (messages []*state.Message, err error) {
+func (sm *BlockProcessor) GetMessages(block *types.Block) (messages []*state.Message, err error) {
 	if !sm.bc.HasBlock(block.Header().ParentHash) {
 		return nil, ParentError(block.Header().ParentHash)
 	}

core/filter.go

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

eth/backend.go

@@ -52,11 +52,11 @@ type Ethereum struct {
 
 	//*** SERVICES ***
 	// State manager for processing new blocks and managing the over all states
-	blockManager *core.BlockManager
-	txPool       *core.TxPool
-	chainManager *core.ChainManager
-	blockPool    *BlockPool
-	whisper      *whisper.Whisper
+	blockProcessor *core.BlockProcessor
+	txPool         *core.TxPool
+	chainManager   *core.ChainManager
+	blockPool      *BlockPool
+	whisper        *whisper.Whisper
 
 	net      *p2p.Server
 	eventMux *event.TypeMux
@@ -122,8 +122,8 @@ func New(config *Config) (*Ethereum, error) {
 
 	eth.chainManager = core.NewChainManager(eth.EventMux())
 	eth.txPool = core.NewTxPool(eth.EventMux())
-	eth.blockManager = core.NewBlockManager(eth.txPool, eth.chainManager, eth.EventMux())
-	eth.chainManager.SetProcessor(eth.blockManager)
+	eth.blockProcessor = core.NewBlockProcessor(eth.txPool, eth.chainManager, eth.EventMux())
+	eth.chainManager.SetProcessor(eth.blockProcessor)
 	eth.whisper = whisper.New()
 
 	hasBlock := eth.chainManager.HasBlock
@@ -169,8 +169,8 @@ func (s *Ethereum) ChainManager() *core.ChainManager {
 	return s.chainManager
 }
 
-func (s *Ethereum) BlockManager() *core.BlockManager {
-	return s.blockManager
+func (s *Ethereum) BlockProcessor() *core.BlockProcessor {
+	return s.blockProcessor
 }
 
 func (s *Ethereum) TxPool() *core.TxPool {

eth/wallet.go

+package eth
+
+/*
+import (
+	"crypto/ecdsa"
+	"errors"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type Account struct {
+	w *Wallet
+}
+
+func (self *Account) Transact(to *Account, value, gas, price *big.Int, data []byte) error {
+	return self.w.transact(self, to, value, gas, price, data)
+}
+
+func (self *Account) Address() []byte {
+	return nil
+}
+
+func (self *Account) PrivateKey() *ecdsa.PrivateKey {
+	return nil
+}
+
+type Wallet struct{}
+
+func NewWallet() *Wallet {
+	return &Wallet{}
+}
+
+func (self *Wallet) GetAccount(i int) *Account {
+}
+
+func (self *Wallet) transact(from, to *Account, value, gas, price *big.Int, data []byte) error {
+	if from.PrivateKey() == nil {
+		return errors.New("accounts is not owned (no private key available)")
+	}
+
+	var createsContract bool
+	if to == nil {
+		createsContract = true
+	}
+
+	var msg *types.Transaction
+	if contractCreation {
+		msg = types.NewContractCreationTx(value, gas, price, data)
+	} else {
+		msg = types.NewTransactionMessage(to.Address(), value, gas, price, data)
+	}
+
+	state := self.chainManager.TransState()
+	nonce := state.GetNonce(key.Address())
+
+	msg.SetNonce(nonce)
+	msg.SignECDSA(from.PriateKey())
+
+	// Do some pre processing for our "pre" events  and hooks
+	block := self.chainManager.NewBlock(from.Address())
+	coinbase := state.GetOrNewStateObject(from.Address())
+	coinbase.SetGasPool(block.GasLimit())
+	self.blockManager.ApplyTransactions(coinbase, state, block, types.Transactions{tx}, true)
+
+	err := self.obj.TxPool().Add(tx)
+	if err != nil {
+		return nil, err
+	}
+	state.SetNonce(key.Address(), nonce+1)
+
+	if contractCreation {
+		addr := core.AddressFromMessage(tx)
+		pipelogger.Infof("Contract addr %x\n", addr)
+	}
+
+	return tx, nil
+}
+*/

miner/miner.go

@@ -174,9 +174,9 @@ func (self *Miner) reset() {
 
 func (self *Miner) mine() {
 	var (
-		blockManager = self.eth.BlockManager()
-		chainMan     = self.eth.ChainManager()
-		block        = chainMan.NewBlock(self.Coinbase)
+		blockProcessor = self.eth.BlockProcessor()
+		chainMan       = self.eth.ChainManager()
+		block          = chainMan.NewBlock(self.Coinbase)
 	)
 
 	// Apply uncles
@@ -194,7 +194,7 @@ func (self *Miner) mine() {
 
 	// Accumulate all valid transactions and apply them to the new state
 	// Error may be ignored. It's not important during mining
-	receipts, txs, _, erroneous, err := blockManager.ApplyTransactions(coinbase, state, block, transactions, true)
+	receipts, txs, _, erroneous, err := blockProcessor.ApplyTransactions(coinbase, state, block, transactions, true)
 	if err != nil {
 		minerlogger.Debugln(err)
 	}
@@ -204,7 +204,7 @@ func (self *Miner) mine() {
 	block.SetReceipts(receipts)
 
 	// Accumulate the rewards included for this block
-	blockManager.AccumelateRewards(state, block, parent)
+	blockProcessor.AccumelateRewards(state, block, parent)
 
 	state.Update(ethutil.Big0)
 	block.SetRoot(state.Root())

xeth/pipe.go → xeth/xeth.go

@@ -20,19 +20,19 @@ type VmVars struct {
 }
 
 type XEth struct {
-	obj          core.EthManager
-	blockManager *core.BlockManager
-	chainManager *core.ChainManager
-	world        *World
+	obj            core.EthManager
+	blockProcessor *core.BlockProcessor
+	chainManager   *core.ChainManager
+	world          *World
 
 	Vm VmVars
 }
 
 func New(obj core.EthManager) *XEth {
 	pipe := &XEth{
-		obj:          obj,
-		blockManager: obj.BlockManager(),
-		chainManager: obj.ChainManager(),
+		obj:            obj,
+		blockProcessor: obj.BlockProcessor(),
+		chainManager:   obj.ChainManager(),
 	}
 	pipe.world = NewWorld(pipe)
 
@@ -141,7 +141,7 @@ func (self *XEth) Transact(key *crypto.KeyPair, to []byte, value, gas, price *et
 	block := self.chainManager.NewBlock(key.Address())
 	coinbase := state.GetOrNewStateObject(key.Address())
 	coinbase.SetGasPool(block.GasLimit())
-	self.blockManager.ApplyTransactions(coinbase, state, block, types.Transactions{tx}, true)
+	self.blockProcessor.ApplyTransactions(coinbase, state, block, types.Transactions{tx}, true)
 
 	err := self.obj.TxPool().Add(tx)
 	if err != nil {