aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--cmd/utils/cmd.go2
-rw-r--r--core/block_processor.go (renamed from core/block_manager.go)24
-rw-r--r--core/filter.go2
-rw-r--r--eth/backend.go18
-rw-r--r--eth/wallet.go80
-rw-r--r--miner/miner.go10
-rw-r--r--xeth/xeth.go (renamed from xeth/pipe.go)16
7 files changed, 116 insertions, 36 deletions
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_processor.go
index 76385ea1f..40ff7cb40 100644
--- a/core/block_manager.go
+++ b/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)
}
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/xeth.go
index 05cefd8ad..a10ccfc8b 100644
--- a/xeth/pipe.go
+++ b/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 {
generated by cgit (git 2.34.1) at 2024-11-14 09:04:09 +0800