From c1dee151445d1d9700e0c623916299370868490c Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 5 Jan 2015 00:18:44 +0100 Subject: BlockManager => BlockProcessor --- cmd/utils/cmd.go | 2 +- core/block_manager.go | 359 ------------------------------------------------ core/block_processor.go | 359 ++++++++++++++++++++++++++++++++++++++++++++++++ core/filter.go | 2 +- eth/backend.go | 18 +-- eth/wallet.go | 80 +++++++++++ miner/miner.go | 10 +- xeth/pipe.go | 181 ------------------------ xeth/xeth.go | 181 ++++++++++++++++++++++++ 9 files changed, 636 insertions(+), 556 deletions(-) delete mode 100644 core/block_manager.go create mode 100644 core/block_processor.go create mode 100644 eth/wallet.go delete mode 100644 xeth/pipe.go create mode 100644 xeth/xeth.go diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go index 6b1cf3726..7e6dd5f91 100644 --- a/cmd/utils/cmd.go +++ b/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 } diff --git a/core/block_manager.go b/core/block_manager.go deleted file mode 100644 index 76385ea1f..000000000 --- a/core/block_manager.go +++ /dev/null @@ -1,359 +0,0 @@ -package core - -import ( - "bytes" - "errors" - "fmt" - "math/big" - "sync" - - "github.com/ethereum/go-ethereum/core/types" - "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/p2p" - "github.com/ethereum/go-ethereum/pow" - "github.com/ethereum/go-ethereum/pow/ezp" - "github.com/ethereum/go-ethereum/state" - "gopkg.in/fatih/set.v0" -) - -var statelogger = logger.NewLogger("BLOCK") - -type EthManager interface { - BlockManager() *BlockManager - ChainManager() *ChainManager - TxPool() *TxPool - PeerCount() int - IsMining() bool - IsListening() bool - Peers() []*p2p.Peer - KeyManager() *crypto.KeyManager - ClientIdentity() p2p.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.PoW - - txpool *TxPool - - // 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 *types.Block - - events event.Subscription - - eventMux *event.TypeMux -} - -func NewBlockManager(txpool *TxPool, chainManager *ChainManager, eventMux *event.TypeMux) *BlockManager { - sm := &BlockManager{ - mem: make(map[string]*big.Int), - Pow: ezp.New(), - bc: chainManager, - eventMux: eventMux, - txpool: txpool, - } - - return sm -} - -func (sm *BlockManager) TransitionState(statedb *state.StateDB, parent, block *types.Block) (receipts types.Receipts, err error) { - coinbase := statedb.GetOrNewStateObject(block.Header().Coinbase) - coinbase.SetGasPool(CalcGasLimit(parent, block)) - - // Process the transactions on to current block - receipts, _, _, _, err = sm.ApplyTransactions(coinbase, statedb, block, block.Transactions(), false) - if err != nil { - return nil, err - } - - 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) { - var ( - receipts types.Receipts - handled, unhandled types.Transactions - erroneous types.Transactions - totalUsedGas = big.NewInt(0) - err error - cumulativeSum = new(big.Int) - ) - -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(NewEnv(state, self.bc, tx, block), tx, cb) - _, err = st.TransitionState() - if err != nil { - 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 - } - } - - txGas.Sub(txGas, st.gas) - cumulativeSum.Add(cumulativeSum, new(big.Int).Mul(txGas, tx.GasPrice())) - - // Update the state with pending changes - state.Update(txGas) - - cumulative := new(big.Int).Set(totalUsedGas.Add(totalUsedGas, txGas)) - receipt := types.NewReceipt(state.Root(), cumulative) - receipt.SetLogs(state.Logs()) - receipt.Bloom = types.CreateBloom(types.Receipts{receipt}) - chainlogger.Debugln(receipt) - - // Notify all subscribers - if !transientProcess { - go self.eventMux.Post(TxPostEvent{tx}) - } - - receipts = append(receipts, receipt) - handled = append(handled, tx) - - if ethutil.Config.Diff && ethutil.Config.DiffType == "all" { - state.CreateOutputForDiff() - } - } - - block.Reward = cumulativeSum - block.Header().GasUsed = totalUsedGas - - return receipts, handled, unhandled, erroneous, err -} - -func (sm *BlockManager) 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() - - header := block.Header() - if sm.bc.HasBlock(header.Hash()) { - return nil, nil, &KnownBlockError{header.Number, header.Hash()} - } - - if !sm.bc.HasBlock(header.ParentHash) { - return nil, nil, ParentError(header.ParentHash) - } - parent := sm.bc.GetBlock(header.ParentHash) - - return sm.ProcessWithParent(block, parent) -} - -func (sm *BlockManager) ProcessWithParent(block, parent *types.Block) (td *big.Int, messages state.Messages, err error) { - sm.lastAttemptedBlock = block - - state := state.New(parent.Trie().Copy()) - - // Block validation - if err = sm.ValidateBlock(block, parent); err != nil { - return - } - - receipts, err := sm.TransitionState(state, parent, block) - if err != nil { - return - } - - header := block.Header() - - rbloom := types.CreateBloom(receipts) - if bytes.Compare(rbloom, header.Bloom) != 0 { - err = fmt.Errorf("unable to replicate block's bloom=%x", rbloom) - return - } - - txSha := types.DeriveSha(block.Transactions()) - if bytes.Compare(txSha, header.TxHash) != 0 { - err = fmt.Errorf("validating transaction root. received=%x got=%x", header.TxHash, txSha) - return - } - - receiptSha := types.DeriveSha(receipts) - if bytes.Compare(receiptSha, header.ReceiptHash) != 0 { - fmt.Println("receipts", receipts) - err = fmt.Errorf("validating receipt root. received=%x got=%x", header.ReceiptHash, receiptSha) - return - } - - if err = sm.AccumelateRewards(state, block, parent); err != nil { - return - } - - state.Update(ethutil.Big0) - - if !bytes.Equal(header.Root, state.Root()) { - err = fmt.Errorf("invalid merkle root. received=%x got=%x", header.Root, state.Root()) - return - } - - // Calculate the new total difficulty and sync back to the db - if td, ok := sm.CalculateTD(block); ok { - // Sync the current block's state to the database and cancelling out the deferred Undo - state.Sync() - - state.Manifest().SetHash(block.Hash()) - - messages := state.Manifest().Messages - state.Manifest().Reset() - - chainlogger.Infof("Processed block #%d (%x...)\n", header.Number, block.Hash()[0:4]) - - sm.txpool.RemoveSet(block.Transactions()) - - return td, messages, nil - } else { - return nil, nil, errors.New("total diff failed") - } -} - -func (sm *BlockManager) CalculateTD(block *types.Block) (*big.Int, 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.Header().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 { - return td, true - } - - return nil, 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, 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) - } - - diff := block.Header().Time - parent.Header().Time - if diff < 0 { - return ValidationError("Block timestamp less then prev block %v (%v - %v)", diff, block.Header().Time, sm.bc.CurrentBlock().Header().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 /*block.HashNoNonce(), block.Difficulty, block.Nonce*/) { - return ValidationError("Block's nonce is invalid (= %v)", ethutil.Bytes2Hex(block.Header().Nonce)) - } - - return nil -} - -func (sm *BlockManager) AccumelateRewards(statedb *state.StateDB, block, parent *types.Block) error { - reward := new(big.Int).Set(BlockReward) - - knownUncles := set.New() - for _, uncle := range parent.Uncles() { - knownUncles.Add(string(uncle.Hash())) - } - - nonces := ethutil.NewSet(block.Header().Nonce) - for _, uncle := range block.Uncles() { - if nonces.Include(uncle.Nonce) { - // Error not unique - return UncleError("Uncle not unique") - } - - uncleParent := sm.bc.GetBlock(uncle.ParentHash) - if uncleParent == nil { - return UncleError(fmt.Sprintf("Uncle's parent unknown (%x)", uncle.ParentHash[0:4])) - } - - if uncleParent.Header().Number.Cmp(new(big.Int).Sub(parent.Header().Number, big.NewInt(6))) < 0 { - return UncleError("Uncle too old") - } - - if knownUncles.Has(string(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 := statedb.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 := statedb.GetAccount(block.Header().Coinbase) - // Reward amount of ether to the coinbase address - account.AddAmount(reward) - - statedb.Manifest().AddMessage(&state.Message{ - To: block.Header().Coinbase, - Input: nil, - Origin: nil, - Timestamp: int64(block.Header().Time), Coinbase: block.Header().Coinbase, Number: block.Header().Number, - Value: new(big.Int).Add(reward, block.Reward), - }) - - return nil -} - -func (sm *BlockManager) GetMessages(block *types.Block) (messages []*state.Message, err error) { - if !sm.bc.HasBlock(block.Header().ParentHash) { - return nil, ParentError(block.Header().ParentHash) - } - - sm.lastAttemptedBlock = block - - var ( - parent = sm.bc.GetBlock(block.Header().ParentHash) - state = state.New(parent.Trie().Copy()) - ) - - defer state.Reset() - - sm.TransitionState(state, parent, block) - sm.AccumelateRewards(state, block, parent) - - return state.Manifest().Messages, nil -} diff --git a/core/block_processor.go b/core/block_processor.go new file mode 100644 index 000000000..40ff7cb40 --- /dev/null +++ b/core/block_processor.go @@ -0,0 +1,359 @@ +package core + +import ( + "bytes" + "errors" + "fmt" + "math/big" + "sync" + + "github.com/ethereum/go-ethereum/core/types" + "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/p2p" + "github.com/ethereum/go-ethereum/pow" + "github.com/ethereum/go-ethereum/pow/ezp" + "github.com/ethereum/go-ethereum/state" + "gopkg.in/fatih/set.v0" +) + +var statelogger = logger.NewLogger("BLOCK") + +type EthManager interface { + BlockProcessor() *BlockProcessor + ChainManager() *ChainManager + TxPool() *TxPool + PeerCount() int + IsMining() bool + IsListening() bool + Peers() []*p2p.Peer + KeyManager() *crypto.KeyManager + ClientIdentity() p2p.ClientIdentity + Db() ethutil.Database + EventMux() *event.TypeMux +} + +type BlockProcessor 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.PoW + + txpool *TxPool + + // 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 *types.Block + + events event.Subscription + + eventMux *event.TypeMux +} + +func NewBlockProcessor(txpool *TxPool, chainManager *ChainManager, eventMux *event.TypeMux) *BlockProcessor { + sm := &BlockProcessor{ + mem: make(map[string]*big.Int), + Pow: ezp.New(), + bc: chainManager, + eventMux: eventMux, + txpool: txpool, + } + + return sm +} + +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)) + + // Process the transactions on to current block + receipts, _, _, _, err = sm.ApplyTransactions(coinbase, statedb, block, block.Transactions(), false) + if err != nil { + return nil, err + } + + return receipts, nil +} + +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 + erroneous types.Transactions + totalUsedGas = big.NewInt(0) + err error + cumulativeSum = new(big.Int) + ) + +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(NewEnv(state, self.bc, tx, block), tx, cb) + _, err = st.TransitionState() + if err != nil { + 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 + } + } + + txGas.Sub(txGas, st.gas) + cumulativeSum.Add(cumulativeSum, new(big.Int).Mul(txGas, tx.GasPrice())) + + // Update the state with pending changes + state.Update(txGas) + + cumulative := new(big.Int).Set(totalUsedGas.Add(totalUsedGas, txGas)) + receipt := types.NewReceipt(state.Root(), cumulative) + receipt.SetLogs(state.Logs()) + receipt.Bloom = types.CreateBloom(types.Receipts{receipt}) + chainlogger.Debugln(receipt) + + // Notify all subscribers + if !transientProcess { + go self.eventMux.Post(TxPostEvent{tx}) + } + + receipts = append(receipts, receipt) + handled = append(handled, tx) + + if ethutil.Config.Diff && ethutil.Config.DiffType == "all" { + state.CreateOutputForDiff() + } + } + + block.Reward = cumulativeSum + block.Header().GasUsed = totalUsedGas + + return receipts, handled, unhandled, erroneous, err +} + +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() + + header := block.Header() + if sm.bc.HasBlock(header.Hash()) { + return nil, nil, &KnownBlockError{header.Number, header.Hash()} + } + + if !sm.bc.HasBlock(header.ParentHash) { + return nil, nil, ParentError(header.ParentHash) + } + parent := sm.bc.GetBlock(header.ParentHash) + + return sm.ProcessWithParent(block, parent) +} + +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()) + + // Block validation + if err = sm.ValidateBlock(block, parent); err != nil { + return + } + + receipts, err := sm.TransitionState(state, parent, block) + if err != nil { + return + } + + header := block.Header() + + rbloom := types.CreateBloom(receipts) + if bytes.Compare(rbloom, header.Bloom) != 0 { + err = fmt.Errorf("unable to replicate block's bloom=%x", rbloom) + return + } + + txSha := types.DeriveSha(block.Transactions()) + if bytes.Compare(txSha, header.TxHash) != 0 { + err = fmt.Errorf("validating transaction root. received=%x got=%x", header.TxHash, txSha) + return + } + + receiptSha := types.DeriveSha(receipts) + if bytes.Compare(receiptSha, header.ReceiptHash) != 0 { + fmt.Println("receipts", receipts) + err = fmt.Errorf("validating receipt root. received=%x got=%x", header.ReceiptHash, receiptSha) + return + } + + if err = sm.AccumelateRewards(state, block, parent); err != nil { + return + } + + state.Update(ethutil.Big0) + + if !bytes.Equal(header.Root, state.Root()) { + err = fmt.Errorf("invalid merkle root. received=%x got=%x", header.Root, state.Root()) + return + } + + // Calculate the new total difficulty and sync back to the db + if td, ok := sm.CalculateTD(block); ok { + // Sync the current block's state to the database and cancelling out the deferred Undo + state.Sync() + + state.Manifest().SetHash(block.Hash()) + + messages := state.Manifest().Messages + state.Manifest().Reset() + + chainlogger.Infof("Processed block #%d (%x...)\n", header.Number, block.Hash()[0:4]) + + sm.txpool.RemoveSet(block.Transactions()) + + return td, messages, nil + } else { + return nil, nil, errors.New("total diff failed") + } +} + +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) + } + + // 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.Header().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 { + return td, true + } + + return nil, 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 *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) + } + + diff := block.Header().Time - parent.Header().Time + if diff < 0 { + return ValidationError("Block timestamp less then prev block %v (%v - %v)", diff, block.Header().Time, sm.bc.CurrentBlock().Header().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 /*block.HashNoNonce(), block.Difficulty, block.Nonce*/) { + return ValidationError("Block's nonce is invalid (= %v)", ethutil.Bytes2Hex(block.Header().Nonce)) + } + + return nil +} + +func (sm *BlockProcessor) AccumelateRewards(statedb *state.StateDB, block, parent *types.Block) error { + reward := new(big.Int).Set(BlockReward) + + knownUncles := set.New() + for _, uncle := range parent.Uncles() { + knownUncles.Add(string(uncle.Hash())) + } + + nonces := ethutil.NewSet(block.Header().Nonce) + for _, uncle := range block.Uncles() { + if nonces.Include(uncle.Nonce) { + // Error not unique + return UncleError("Uncle not unique") + } + + uncleParent := sm.bc.GetBlock(uncle.ParentHash) + if uncleParent == nil { + return UncleError(fmt.Sprintf("Uncle's parent unknown (%x)", uncle.ParentHash[0:4])) + } + + if uncleParent.Header().Number.Cmp(new(big.Int).Sub(parent.Header().Number, big.NewInt(6))) < 0 { + return UncleError("Uncle too old") + } + + if knownUncles.Has(string(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 := statedb.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 := statedb.GetAccount(block.Header().Coinbase) + // Reward amount of ether to the coinbase address + account.AddAmount(reward) + + statedb.Manifest().AddMessage(&state.Message{ + To: block.Header().Coinbase, + Input: nil, + Origin: nil, + Timestamp: int64(block.Header().Time), Coinbase: block.Header().Coinbase, Number: block.Header().Number, + Value: new(big.Int).Add(reward, block.Reward), + }) + + return nil +} + +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) + } + + sm.lastAttemptedBlock = block + + var ( + parent = sm.bc.GetBlock(block.Header().ParentHash) + state = state.New(parent.Trie().Copy()) + ) + + defer state.Reset() + + sm.TransitionState(state, parent, block) + sm.AccumelateRewards(state, block, parent) + + return state.Manifest().Messages, nil +} diff --git a/core/filter.go b/core/filter.go index 7c34748df..29be8841c 100644 --- a/core/filter.go +++ b/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) diff --git a/eth/backend.go b/eth/backend.go index bf6c91282..db8e8e029 100644 --- a/eth/backend.go +++ b/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 { diff --git a/eth/wallet.go b/eth/wallet.go new file mode 100644 index 000000000..9ec834309 --- /dev/null +++ b/eth/wallet.go @@ -0,0 +1,80 @@ +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 +} +*/ diff --git a/miner/miner.go b/miner/miner.go index aefcadab8..949227d98 100644 --- a/miner/miner.go +++ b/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()) diff --git a/xeth/pipe.go b/xeth/pipe.go deleted file mode 100644 index 05cefd8ad..000000000 --- a/xeth/pipe.go +++ /dev/null @@ -1,181 +0,0 @@ -package xeth - -/* - * eXtended ETHereum - */ - -import ( - "github.com/ethereum/go-ethereum/core" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" - "github.com/ethereum/go-ethereum/logger" - "github.com/ethereum/go-ethereum/state" -) - -var pipelogger = logger.NewLogger("XETH") - -type VmVars struct { - State *state.StateDB -} - -type XEth struct { - obj core.EthManager - blockManager *core.BlockManager - chainManager *core.ChainManager - world *World - - Vm VmVars -} - -func New(obj core.EthManager) *XEth { - pipe := &XEth{ - obj: obj, - blockManager: obj.BlockManager(), - chainManager: obj.ChainManager(), - } - pipe.world = NewWorld(pipe) - - return pipe -} - -/* - * State / Account accessors - */ -func (self *XEth) Balance(addr []byte) *ethutil.Value { - return ethutil.NewValue(self.World().safeGet(addr).Balance) -} - -func (self *XEth) Nonce(addr []byte) uint64 { - return self.World().safeGet(addr).Nonce -} - -func (self *XEth) Block(hash []byte) *types.Block { - return self.chainManager.GetBlock(hash) -} - -func (self *XEth) Storage(addr, storageAddr []byte) *ethutil.Value { - return self.World().safeGet(addr).GetStorage(ethutil.BigD(storageAddr)) -} - -func (self *XEth) Exists(addr []byte) bool { - return self.World().Get(addr) != nil -} - -// Converts the given private key to an address -func (self *XEth) ToAddress(priv []byte) []byte { - pair, err := crypto.NewKeyPairFromSec(priv) - if err != nil { - return nil - } - - return pair.Address() -} - -/* - * Execution helpers - */ -func (self *XEth) Execute(addr []byte, data []byte, value, gas, price *ethutil.Value) ([]byte, error) { - return self.ExecuteObject(&Object{self.World().safeGet(addr)}, data, value, gas, price) -} - -func (self *XEth) ExecuteObject(object *Object, data []byte, value, gas, price *ethutil.Value) ([]byte, error) { - var ( - initiator = state.NewStateObject(self.obj.KeyManager().KeyPair().Address()) - block = self.chainManager.CurrentBlock() - ) - - self.Vm.State = self.World().State().Copy() - - vmenv := NewEnv(self.chainManager, self.Vm.State, block, value.BigInt(), initiator.Address()) - return vmenv.Call(initiator, object.Address(), data, gas.BigInt(), price.BigInt(), value.BigInt()) -} - -/* - * Transactional methods - */ -func (self *XEth) TransactString(key *crypto.KeyPair, rec string, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) { - // Check if an address is stored by this address - var hash []byte - addr := self.World().Config().Get("NameReg").StorageString(rec).Bytes() - if len(addr) > 0 { - hash = addr - } else if ethutil.IsHex(rec) { - hash = ethutil.Hex2Bytes(rec[2:]) - } else { - hash = ethutil.Hex2Bytes(rec) - } - - return self.Transact(key, hash, value, gas, price, data) -} - -func (self *XEth) Transact(key *crypto.KeyPair, to []byte, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) { - var hash []byte - var contractCreation bool - if types.IsContractAddr(to) { - contractCreation = true - } else { - // Check if an address is stored by this address - addr := self.World().Config().Get("NameReg").Storage(to).Bytes() - if len(addr) > 0 { - hash = addr - } else { - hash = to - } - } - - var tx *types.Transaction - if contractCreation { - tx = types.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), data) - } else { - tx = types.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data) - } - - state := self.chainManager.TransState() - nonce := state.GetNonce(key.Address()) - - tx.SetNonce(nonce) - tx.Sign(key.PrivateKey) - - // Do some pre processing for our "pre" events and hooks - 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) - - 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 -} - -func (self *XEth) PushTx(tx *types.Transaction) ([]byte, error) { - err := self.obj.TxPool().Add(tx) - if err != nil { - return nil, err - } - - if tx.To() == nil { - addr := core.AddressFromMessage(tx) - pipelogger.Infof("Contract addr %x\n", addr) - return addr, nil - } - return tx.Hash(), nil -} - -func (self *XEth) CompileMutan(code string) ([]byte, error) { - data, err := ethutil.Compile(code, false) - if err != nil { - return nil, err - } - - return data, nil -} diff --git a/xeth/xeth.go b/xeth/xeth.go new file mode 100644 index 000000000..a10ccfc8b --- /dev/null +++ b/xeth/xeth.go @@ -0,0 +1,181 @@ +package xeth + +/* + * eXtended ETHereum + */ + +import ( + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/state" +) + +var pipelogger = logger.NewLogger("XETH") + +type VmVars struct { + State *state.StateDB +} + +type XEth struct { + obj core.EthManager + blockProcessor *core.BlockProcessor + chainManager *core.ChainManager + world *World + + Vm VmVars +} + +func New(obj core.EthManager) *XEth { + pipe := &XEth{ + obj: obj, + blockProcessor: obj.BlockProcessor(), + chainManager: obj.ChainManager(), + } + pipe.world = NewWorld(pipe) + + return pipe +} + +/* + * State / Account accessors + */ +func (self *XEth) Balance(addr []byte) *ethutil.Value { + return ethutil.NewValue(self.World().safeGet(addr).Balance) +} + +func (self *XEth) Nonce(addr []byte) uint64 { + return self.World().safeGet(addr).Nonce +} + +func (self *XEth) Block(hash []byte) *types.Block { + return self.chainManager.GetBlock(hash) +} + +func (self *XEth) Storage(addr, storageAddr []byte) *ethutil.Value { + return self.World().safeGet(addr).GetStorage(ethutil.BigD(storageAddr)) +} + +func (self *XEth) Exists(addr []byte) bool { + return self.World().Get(addr) != nil +} + +// Converts the given private key to an address +func (self *XEth) ToAddress(priv []byte) []byte { + pair, err := crypto.NewKeyPairFromSec(priv) + if err != nil { + return nil + } + + return pair.Address() +} + +/* + * Execution helpers + */ +func (self *XEth) Execute(addr []byte, data []byte, value, gas, price *ethutil.Value) ([]byte, error) { + return self.ExecuteObject(&Object{self.World().safeGet(addr)}, data, value, gas, price) +} + +func (self *XEth) ExecuteObject(object *Object, data []byte, value, gas, price *ethutil.Value) ([]byte, error) { + var ( + initiator = state.NewStateObject(self.obj.KeyManager().KeyPair().Address()) + block = self.chainManager.CurrentBlock() + ) + + self.Vm.State = self.World().State().Copy() + + vmenv := NewEnv(self.chainManager, self.Vm.State, block, value.BigInt(), initiator.Address()) + return vmenv.Call(initiator, object.Address(), data, gas.BigInt(), price.BigInt(), value.BigInt()) +} + +/* + * Transactional methods + */ +func (self *XEth) TransactString(key *crypto.KeyPair, rec string, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) { + // Check if an address is stored by this address + var hash []byte + addr := self.World().Config().Get("NameReg").StorageString(rec).Bytes() + if len(addr) > 0 { + hash = addr + } else if ethutil.IsHex(rec) { + hash = ethutil.Hex2Bytes(rec[2:]) + } else { + hash = ethutil.Hex2Bytes(rec) + } + + return self.Transact(key, hash, value, gas, price, data) +} + +func (self *XEth) Transact(key *crypto.KeyPair, to []byte, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) { + var hash []byte + var contractCreation bool + if types.IsContractAddr(to) { + contractCreation = true + } else { + // Check if an address is stored by this address + addr := self.World().Config().Get("NameReg").Storage(to).Bytes() + if len(addr) > 0 { + hash = addr + } else { + hash = to + } + } + + var tx *types.Transaction + if contractCreation { + tx = types.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), data) + } else { + tx = types.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data) + } + + state := self.chainManager.TransState() + nonce := state.GetNonce(key.Address()) + + tx.SetNonce(nonce) + tx.Sign(key.PrivateKey) + + // Do some pre processing for our "pre" events and hooks + block := self.chainManager.NewBlock(key.Address()) + coinbase := state.GetOrNewStateObject(key.Address()) + coinbase.SetGasPool(block.GasLimit()) + self.blockProcessor.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 +} + +func (self *XEth) PushTx(tx *types.Transaction) ([]byte, error) { + err := self.obj.TxPool().Add(tx) + if err != nil { + return nil, err + } + + if tx.To() == nil { + addr := core.AddressFromMessage(tx) + pipelogger.Infof("Contract addr %x\n", addr) + return addr, nil + } + return tx.Hash(), nil +} + +func (self *XEth) CompileMutan(code string) ([]byte, error) { + data, err := ethutil.Compile(code, false) + if err != nil { + return nil, err + } + + return data, nil +} -- cgit v1.2.3