aboutsummaryrefslogtreecommitdiffstats
path: root/core
diff options
context:
space:
mode:
Diffstat (limited to 'core')
-rw-r--r--core/block_processor.go153
-rw-r--r--core/chain_manager.go11
-rw-r--r--core/execution.go3
-rw-r--r--core/filter.go146
-rw-r--r--core/genesis.go1
-rw-r--r--core/manager.go22
-rw-r--r--core/state_transition.go29
-rw-r--r--core/transaction_pool.go20
-rw-r--r--core/transaction_pool_test.go10
-rw-r--r--core/types/block.go26
-rw-r--r--core/types/common.go8
-rw-r--r--core/vm_env.go4
12 files changed, 245 insertions, 188 deletions
diff --git a/core/block_processor.go b/core/block_processor.go
index 37acc4f72..0eb3f8920 100644
--- a/core/block_processor.go
+++ b/core/block_processor.go
@@ -8,33 +8,21 @@ import (
"time"
"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 PendingBlockEvent struct {
+ Block *types.Block
}
+var statelogger = logger.NewLogger("BLOCK")
+
type BlockProcessor struct {
db ethutil.Database
// Mutex for locking the block processor. Blocks can only be handled one at a time
@@ -84,6 +72,37 @@ func (sm *BlockProcessor) TransitionState(statedb *state.StateDB, parent, block
return receipts, nil
}
+func (self *BlockProcessor) ApplyTransaction(coinbase *state.StateObject, state *state.StateDB, block *types.Block, tx *types.Transaction, usedGas *big.Int, transientProcess bool) (*types.Receipt, *big.Int, error) {
+ // 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()
+
+ txGas.Sub(txGas, st.gas)
+
+ // Update the state with pending changes
+ state.Update(txGas)
+
+ cumulative := new(big.Int).Set(usedGas.Add(usedGas, 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})
+ }
+
+ go self.eventMux.Post(state.Logs())
+
+ return receipt, txGas, err
+}
+
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
@@ -94,82 +113,55 @@ func (self *BlockProcessor) ApplyTransactions(coinbase *state.StateObject, state
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()
+ for _, tx := range txs {
+ receipt, txGas, err := self.ApplyTransaction(coinbase, state, block, tx, totalUsedGas, transientProcess)
if err != nil {
switch {
case IsNonceErr(err):
- err = nil // ignore error
- continue
+ return nil, nil, nil, nil, err
case IsGasLimitErr(err):
- unhandled = txs[i:]
-
- break done
+ return nil, nil, nil, nil, err
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()
- }
+ cumulativeSum.Add(cumulativeSum, new(big.Int).Mul(txGas, tx.GasPrice()))
}
block.Reward = cumulativeSum
block.Header().GasUsed = totalUsedGas
+ if transientProcess {
+ go self.eventMux.Post(PendingBlockEvent{block})
+ }
+
return receipts, handled, unhandled, erroneous, err
}
-func (sm *BlockProcessor) Process(block *types.Block) (td *big.Int, msgs state.Messages, err error) {
+func (sm *BlockProcessor) Process(block *types.Block) (td *big.Int, 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()}
+ return nil, &KnownBlockError{header.Number, header.Hash()}
}
if !sm.bc.HasBlock(header.ParentHash) {
- return nil, nil, ParentError(header.ParentHash)
+ return 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) {
+func (sm *BlockProcessor) ProcessWithParent(block, parent *types.Block) (td *big.Int, err error) {
sm.lastAttemptedBlock = block
state := state.New(parent.Root(), sm.db)
@@ -206,7 +198,7 @@ func (sm *BlockProcessor) ProcessWithParent(block, parent *types.Block) (td *big
return
}
- if err = sm.AccumelateRewards(state, block, parent); err != nil {
+ if err = sm.AccumulateRewards(state, block, parent); err != nil {
return
}
@@ -219,11 +211,10 @@ func (sm *BlockProcessor) ProcessWithParent(block, parent *types.Block) (td *big
// Calculate the td for this block
td = CalculateTD(block, parent)
- // Sync the current block's state to the database and cancelling out the deferred Undo
+ // Sync the current block's state to the database
state.Sync()
// Set the block hashes for the current messages
state.Manifest().SetHash(block.Hash())
- messages = state.Manifest().Messages
// Reset the manifest XXX We need this?
state.Manifest().Reset()
// Remove transactions from the pool
@@ -231,7 +222,7 @@ func (sm *BlockProcessor) ProcessWithParent(block, parent *types.Block) (td *big
chainlogger.Infof("processed block #%d (%x...)\n", header.Number, block.Hash()[0:4])
- return td, messages, nil
+ return td, nil
}
// Validates the current block. Returns an error if the block was invalid,
@@ -247,9 +238,8 @@ func (sm *BlockProcessor) ValidateBlock(block, parent *types.Block) error {
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)
+ if block.Time() < parent.Time() {
+ return ValidationError("Block timestamp not after prev block (%v - %v)", block.Header().Time, parent.Header().Time)
}
if block.Time() > time.Now().Unix() {
@@ -264,7 +254,7 @@ func (sm *BlockProcessor) ValidateBlock(block, parent *types.Block) error {
return nil
}
-func (sm *BlockProcessor) AccumelateRewards(statedb *state.StateDB, block, parent *types.Block) error {
+func (sm *BlockProcessor) AccumulateRewards(statedb *state.StateDB, block, parent *types.Block) error {
reward := new(big.Int).Set(BlockReward)
ancestors := set.New()
@@ -285,6 +275,10 @@ func (sm *BlockProcessor) AccumelateRewards(statedb *state.StateDB, block, paren
return UncleError(fmt.Sprintf("Uncle's parent unknown (%x)", uncle.ParentHash[0:4]))
}
+ if !sm.Pow.Verify(types.NewBlockWithHeader(uncle)) {
+ return ValidationError("Uncle's nonce is invalid (= %v)", ethutil.Bytes2Hex(uncle.Nonce))
+ }
+
r := new(big.Int)
r.Mul(BlockReward, big.NewInt(15)).Div(r, big.NewInt(16))
@@ -299,14 +293,6 @@ func (sm *BlockProcessor) AccumelateRewards(statedb *state.StateDB, block, paren
// 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
}
@@ -326,7 +312,28 @@ func (sm *BlockProcessor) GetMessages(block *types.Block) (messages []*state.Mes
defer state.Reset()
sm.TransitionState(state, parent, block)
- sm.AccumelateRewards(state, block, parent)
+ sm.AccumulateRewards(state, block, parent)
return state.Manifest().Messages, nil
}
+
+func (sm *BlockProcessor) GetLogs(block *types.Block) (logs state.Logs, 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())
+ state = state.New(parent.Root(), sm.db)
+ )
+
+ defer state.Reset()
+
+ sm.TransitionState(state, parent, block)
+ sm.AccumulateRewards(state, block, parent)
+
+ return state.Logs(), nil
+}
diff --git a/core/chain_manager.go b/core/chain_manager.go
index c68b7cfc2..0847980ca 100644
--- a/core/chain_manager.go
+++ b/core/chain_manager.go
@@ -251,7 +251,13 @@ func (self *ChainManager) GetBlockHashesFromHash(hash []byte, max uint64) (chain
// XXX Could be optimised by using a different database which only holds hashes (i.e., linked list)
for i := uint64(0); i < max; i++ {
- block = self.GetBlock(block.Header().ParentHash)
+ parentHash := block.Header().ParentHash
+ block = self.GetBlock(parentHash)
+ if block == nil {
+ chainlogger.Infof("GetBlockHashesFromHash Parent UNKNOWN %x\n", parentHash)
+ break
+ }
+
chain = append(chain, block.Hash())
if block.Header().Number.Cmp(ethutil.Big0) <= 0 {
break
@@ -353,7 +359,7 @@ func (bc *ChainManager) Stop() {
func (self *ChainManager) InsertChain(chain types.Blocks) error {
for _, block := range chain {
- td, messages, err := self.processor.Process(block)
+ td, err := self.processor.Process(block)
if err != nil {
if IsKnownBlockErr(err) {
continue
@@ -385,7 +391,6 @@ func (self *ChainManager) InsertChain(chain types.Blocks) error {
self.mu.Unlock()
self.eventMux.Post(NewBlockEvent{block})
- self.eventMux.Post(messages)
}
return nil
diff --git a/core/execution.go b/core/execution.go
index cad4e84aa..5e0cbd37e 100644
--- a/core/execution.go
+++ b/core/execution.go
@@ -33,8 +33,7 @@ func (self *Execution) Call(codeAddr []byte, caller vm.ContextRef) ([]byte, erro
func (self *Execution) exec(code, contextAddr []byte, caller vm.ContextRef) (ret []byte, err error) {
env := self.env
- evm := vm.New(env)
-
+ evm := vm.NewVm(env)
if env.Depth() == vm.MaxCallDepth {
caller.ReturnGas(self.Gas, self.price)
diff --git a/core/filter.go b/core/filter.go
index 29be8841c..b93fcc8a5 100644
--- a/core/filter.go
+++ b/core/filter.go
@@ -3,10 +3,8 @@ package core
import (
"bytes"
"math"
- "math/big"
"github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
@@ -14,19 +12,30 @@ type AccountChange struct {
Address, StateAddress []byte
}
+type FilterOptions struct {
+ Earliest int64
+ Latest int64
+
+ Address []byte
+ Topics [][]byte
+
+ Skip int
+ Max int
+}
+
// Filtering interface
type Filter struct {
eth EthManager
earliest int64
latest int64
skip int
- from, to [][]byte
+ address []byte
max int
-
- Altered []AccountChange
+ topics [][]byte
BlockCallback func(*types.Block)
- MessageCallback func(state.Messages)
+ PendingCallback func(*types.Block)
+ LogsCallback func(state.Logs)
}
// Create a new filter which uses a bloom filter on blocks to figure out whether a particular block
@@ -35,8 +44,14 @@ func NewFilter(eth EthManager) *Filter {
return &Filter{eth: eth}
}
-func (self *Filter) AddAltered(address, stateAddress []byte) {
- self.Altered = append(self.Altered, AccountChange{address, stateAddress})
+func (self *Filter) SetOptions(options FilterOptions) {
+ self.earliest = options.Earliest
+ self.latest = options.Latest
+ self.skip = options.Skip
+ self.max = options.Max
+ self.address = options.Address
+ self.topics = options.Topics
+
}
// Set the earliest and latest block for filtering.
@@ -50,20 +65,12 @@ func (self *Filter) SetLatestBlock(latest int64) {
self.latest = latest
}
-func (self *Filter) SetFrom(addr [][]byte) {
- self.from = addr
-}
-
-func (self *Filter) AddFrom(addr []byte) {
- self.from = append(self.from, addr)
-}
-
-func (self *Filter) SetTo(addr [][]byte) {
- self.to = addr
+func (self *Filter) SetAddress(addr []byte) {
+ self.address = addr
}
-func (self *Filter) AddTo(addr []byte) {
- self.to = append(self.to, addr)
+func (self *Filter) SetTopics(topics [][]byte) {
+ self.topics = topics
}
func (self *Filter) SetMax(max int) {
@@ -74,8 +81,8 @@ func (self *Filter) SetSkip(skip int) {
self.skip = skip
}
-// Run filters messages with the current parameters set
-func (self *Filter) Find() []*state.Message {
+// Run filters logs with the current parameters set
+func (self *Filter) Find() state.Logs {
earliestBlock := self.eth.ChainManager().CurrentBlock()
var earliestBlockNo uint64 = uint64(self.earliest)
if self.earliest == -1 {
@@ -87,115 +94,84 @@ func (self *Filter) Find() []*state.Message {
}
var (
- messages []*state.Message
- block = self.eth.ChainManager().GetBlockByNumber(latestBlockNo)
- quit bool
+ logs state.Logs
+ block = self.eth.ChainManager().GetBlockByNumber(latestBlockNo)
+ quit bool
)
for i := 0; !quit && block != nil; i++ {
// Quit on latest
switch {
case block.NumberU64() == earliestBlockNo, block.NumberU64() == 0:
quit = true
- case self.max <= len(messages):
+ case self.max <= len(logs):
break
}
// Use bloom filtering to see if this block is interesting given the
// current parameters
if self.bloomFilter(block) {
- // Get the messages of the block
- msgs, err := self.eth.BlockProcessor().GetMessages(block)
+ // Get the logs of the block
+ logs, err := self.eth.BlockProcessor().GetLogs(block)
if err != nil {
- chainlogger.Warnln("err: filter get messages ", err)
+ chainlogger.Warnln("err: filter get logs ", err)
break
}
- messages = append(messages, self.FilterMessages(msgs)...)
+ logs = append(logs, self.FilterLogs(logs)...)
}
block = self.eth.ChainManager().GetBlock(block.ParentHash())
}
- skip := int(math.Min(float64(len(messages)), float64(self.skip)))
+ skip := int(math.Min(float64(len(logs)), float64(self.skip)))
- return messages[skip:]
+ return logs[skip:]
}
-func includes(addresses [][]byte, a []byte) (found bool) {
+func includes(addresses [][]byte, a []byte) bool {
for _, addr := range addresses {
- if bytes.Compare(addr, a) == 0 {
- return true
+ if !bytes.Equal(addr, a) {
+ return false
}
}
- return
+ return true
}
-func (self *Filter) FilterMessages(msgs []*state.Message) []*state.Message {
- var messages []*state.Message
+func (self *Filter) FilterLogs(logs state.Logs) state.Logs {
+ var ret state.Logs
- // Filter the messages for interesting stuff
- for _, message := range msgs {
- if len(self.to) > 0 && !includes(self.to, message.To) {
+ // Filter the logs for interesting stuff
+Logs:
+ for _, log := range logs {
+ if !bytes.Equal(self.address, log.Address()) {
continue
}
- if len(self.from) > 0 && !includes(self.from, message.From) {
- continue
- }
-
- var match bool
- if len(self.Altered) == 0 {
- match = true
- }
-
- for _, accountChange := range self.Altered {
- if len(accountChange.Address) > 0 && bytes.Compare(message.To, accountChange.Address) != 0 {
- continue
- }
-
- if len(accountChange.StateAddress) > 0 && !includes(message.ChangedAddresses, accountChange.StateAddress) {
- continue
+ max := int(math.Min(float64(len(self.topics)), float64(len(log.Topics()))))
+ for i := 0; i < max; i++ {
+ if !bytes.Equal(log.Topics()[i], self.topics[i]) {
+ continue Logs
}
-
- match = true
- break
}
- if !match {
- continue
- }
-
- messages = append(messages, message)
+ ret = append(ret, log)
}
- return messages
+ return ret
}
func (self *Filter) bloomFilter(block *types.Block) bool {
- var fromIncluded, toIncluded bool
- if len(self.from) > 0 {
- for _, from := range self.from {
- if types.BloomLookup(block.Bloom(), from) || bytes.Equal(block.Coinbase(), from) {
- fromIncluded = true
- break
- }
- }
- } else {
- fromIncluded = true
+ if len(self.address) > 0 && !types.BloomLookup(block.Bloom(), self.address) {
+ return false
}
- if len(self.to) > 0 {
- for _, to := range self.to {
- if types.BloomLookup(block.Bloom(), ethutil.U256(new(big.Int).Add(ethutil.Big1, ethutil.BigD(to))).Bytes()) || bytes.Equal(block.Coinbase(), to) {
- toIncluded = true
- break
- }
+ for _, topic := range self.topics {
+ if !types.BloomLookup(block.Bloom(), topic) {
+ return false
}
- } else {
- toIncluded = true
}
- return fromIncluded && toIncluded
+ return true
}
diff --git a/core/genesis.go b/core/genesis.go
index 6d4eeba72..c870ce61e 100644
--- a/core/genesis.go
+++ b/core/genesis.go
@@ -32,7 +32,6 @@ func GenesisBlock(db ethutil.Database) *types.Block {
genesis.SetReceipts(types.Receipts{})
statedb := state.New(genesis.Root(), db)
- //statedb := state.New(genesis.Trie())
for _, addr := range []string{
"dbdbdb2cbd23b783741e8d7fcf51e459b497e4a6",
"e4157b34ea9615cfbde6b4fda419828124b70c78",
diff --git a/core/manager.go b/core/manager.go
new file mode 100644
index 000000000..4671573b1
--- /dev/null
+++ b/core/manager.go
@@ -0,0 +1,22 @@
+package core
+
+import (
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/p2p"
+)
+
+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
+}
diff --git a/core/state_transition.go b/core/state_transition.go
index 8b0ca2ac4..33dd45f02 100644
--- a/core/state_transition.go
+++ b/core/state_transition.go
@@ -10,6 +10,8 @@ import (
"github.com/ethereum/go-ethereum/vm"
)
+const tryJit = false
+
/*
* The State transitioning model
*
@@ -184,6 +186,7 @@ func (self *StateTransition) TransitionState() (ret []byte, err error) {
return
}
+ //stateCopy := self.env.State().Copy()
vmenv := self.env
var ref vm.ContextRef
if MessageCreatesContract(msg) {
@@ -196,8 +199,34 @@ func (self *StateTransition) TransitionState() (ret []byte, err error) {
ref.SetCode(ret)
}
}
+
+ /*
+ if vmenv, ok := vmenv.(*VMEnv); ok && tryJit {
+ statelogger.Infof("CREATE: re-running using JIT (PH=%x)\n", stateCopy.Root()[:4])
+ // re-run using the JIT (validation for the JIT)
+ goodState := vmenv.State().Copy()
+ vmenv.state = stateCopy
+ vmenv.SetVmType(vm.JitVmTy)
+ vmenv.Create(sender, contract.Address(), self.msg.Data(), self.gas, self.gasPrice, self.value)
+ statelogger.Infof("DONE PH=%x STD_H=%x JIT_H=%x\n", stateCopy.Root()[:4], goodState.Root()[:4], vmenv.State().Root()[:4])
+ self.state.Set(goodState)
+ }
+ */
} else {
ret, err = vmenv.Call(self.From(), self.To().Address(), self.msg.Data(), self.gas, self.gasPrice, self.value)
+
+ /*
+ if vmenv, ok := vmenv.(*VMEnv); ok && tryJit {
+ statelogger.Infof("CALL: re-running using JIT (PH=%x)\n", stateCopy.Root()[:4])
+ // re-run using the JIT (validation for the JIT)
+ goodState := vmenv.State().Copy()
+ vmenv.state = stateCopy
+ vmenv.SetVmType(vm.JitVmTy)
+ vmenv.Call(self.From(), self.To().Address(), self.msg.Data(), self.gas, self.gasPrice, self.value)
+ statelogger.Infof("DONE PH=%x STD_H=%x JIT_H=%x\n", stateCopy.Root()[:4], goodState.Root()[:4], vmenv.State().Root()[:4])
+ self.state.Set(goodState)
+ }
+ */
}
if err != nil {
diff --git a/core/transaction_pool.go b/core/transaction_pool.go
index d3aec9050..7a901fcae 100644
--- a/core/transaction_pool.go
+++ b/core/transaction_pool.go
@@ -1,6 +1,7 @@
package core
import (
+ "errors"
"fmt"
"github.com/ethereum/go-ethereum/core/types"
@@ -9,7 +10,11 @@ import (
"github.com/ethereum/go-ethereum/logger"
)
-var txplogger = logger.NewLogger("TXP")
+var (
+ txplogger = logger.NewLogger("TXP")
+
+ ErrInvalidSender = errors.New("Invalid sender")
+)
const txPoolQueueSize = 50
@@ -60,22 +65,23 @@ func (pool *TxPool) ValidateTransaction(tx *types.Transaction) error {
return fmt.Errorf("Invalid recipient. len = %d", len(tx.To()))
}
+ // Validate curve param
v, _, _ := tx.Curve()
if v > 28 || v < 27 {
return fmt.Errorf("tx.v != (28 || 27) => %v", v)
}
+ // Validate sender address
+ senderAddr := tx.From()
+ if senderAddr == nil || len(senderAddr) != 20 {
+ return ErrInvalidSender
+ }
+
/* XXX this kind of validation needs to happen elsewhere in the gui when sending txs.
Other clients should do their own validation. Value transfer could throw error
but doesn't necessarily invalidate the tx. Gas can still be payed for and miner
can still be rewarded for their inclusion and processing.
- // Get the sender
- senderAddr := tx.From()
- if senderAddr == nil {
- return fmt.Errorf("invalid sender")
- }
sender := pool.stateQuery.GetAccount(senderAddr)
-
totAmount := new(big.Int).Set(tx.Value())
// Make sure there's enough in the sender's account. Having insufficient
// funds won't invalidate this transaction but simple ignores it.
diff --git a/core/transaction_pool_test.go b/core/transaction_pool_test.go
index 7f192fc4d..b2d981f01 100644
--- a/core/transaction_pool_test.go
+++ b/core/transaction_pool_test.go
@@ -85,3 +85,13 @@ func TestRemoveInvalid(t *testing.T) {
t.Error("expected pool size to be 1, is", pool.Size())
}
}
+
+func TestInvalidSender(t *testing.T) {
+ pool, _ := setup()
+ tx := new(types.Transaction)
+ tx.V = 28
+ err := pool.ValidateTransaction(tx)
+ if err != ErrInvalidSender {
+ t.Error("expected %v, got %v", ErrInvalidSender, err)
+ }
+}
diff --git a/core/types/block.go b/core/types/block.go
index be57e86a6..a334c512e 100644
--- a/core/types/block.go
+++ b/core/types/block.go
@@ -6,7 +6,6 @@ import (
"math/big"
"sort"
"time"
-
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/rlp"
@@ -146,6 +145,10 @@ func (self *Block) SetTransactions(transactions Transactions) {
self.transactions = transactions
self.header.TxHash = DeriveSha(transactions)
}
+func (self *Block) AddTransaction(transaction *Transaction) {
+ self.transactions = append(self.transactions, transaction)
+ self.SetTransactions(self.transactions)
+}
func (self *Block) Receipts() Receipts {
return self.receipts
@@ -156,6 +159,10 @@ func (self *Block) SetReceipts(receipts Receipts) {
self.header.ReceiptHash = DeriveSha(receipts)
self.header.Bloom = CreateBloom(receipts)
}
+func (self *Block) AddReceipt(receipt *Receipt) {
+ self.receipts = append(self.receipts, receipt)
+ self.SetReceipts(self.receipts)
+}
func (self *Block) RlpData() interface{} {
return []interface{}{self.header, self.transactions, self.uncles}
@@ -166,16 +173,13 @@ func (self *Block) RlpDataForStorage() interface{} {
}
// Header accessors (add as you need them)
-func (self *Block) Number() *big.Int { return self.header.Number }
-func (self *Block) NumberU64() uint64 { return self.header.Number.Uint64() }
-func (self *Block) Bloom() []byte { return self.header.Bloom }
-func (self *Block) Coinbase() []byte { return self.header.Coinbase }
-func (self *Block) Time() int64 { return int64(self.header.Time) }
-func (self *Block) GasLimit() *big.Int { return self.header.GasLimit }
-func (self *Block) GasUsed() *big.Int { return self.header.GasUsed }
-
-//func (self *Block) Trie() *ptrie.Trie { return ptrie.New(self.header.Root, ethutil.Config.Db) }
-//func (self *Block) State() *state.StateDB { return state.New(self.Trie()) }
+func (self *Block) Number() *big.Int { return self.header.Number }
+func (self *Block) NumberU64() uint64 { return self.header.Number.Uint64() }
+func (self *Block) Bloom() []byte { return self.header.Bloom }
+func (self *Block) Coinbase() []byte { return self.header.Coinbase }
+func (self *Block) Time() int64 { return int64(self.header.Time) }
+func (self *Block) GasLimit() *big.Int { return self.header.GasLimit }
+func (self *Block) GasUsed() *big.Int { return self.header.GasUsed }
func (self *Block) Root() []byte { return self.header.Root }
func (self *Block) SetRoot(root []byte) { self.header.Root = root }
func (self *Block) Size() ethutil.StorageSize { return ethutil.StorageSize(len(ethutil.Encode(self))) }
diff --git a/core/types/common.go b/core/types/common.go
index ba88b77e1..795374959 100644
--- a/core/types/common.go
+++ b/core/types/common.go
@@ -1,11 +1,7 @@
package types
-import (
- "math/big"
-
- "github.com/ethereum/go-ethereum/state"
-)
+import "math/big"
type BlockProcessor interface {
- Process(*Block) (*big.Int, state.Messages, error)
+ Process(*Block) (*big.Int, error)
}
diff --git a/core/vm_env.go b/core/vm_env.go
index 624a63333..c7491bcdc 100644
--- a/core/vm_env.go
+++ b/core/vm_env.go
@@ -14,6 +14,7 @@ type VMEnv struct {
msg Message
depth int
chain *ChainManager
+ typ vm.Type
}
func NewEnv(state *state.StateDB, chain *ChainManager, msg Message, block *types.Block) *VMEnv {
@@ -22,6 +23,7 @@ func NewEnv(state *state.StateDB, chain *ChainManager, msg Message, block *types
state: state,
block: block,
msg: msg,
+ typ: vm.StdVmTy,
}
}
@@ -35,6 +37,8 @@ func (self *VMEnv) Value() *big.Int { return self.msg.Value() }
func (self *VMEnv) State() *state.StateDB { return self.state }
func (self *VMEnv) Depth() int { return self.depth }
func (self *VMEnv) SetDepth(i int) { self.depth = i }
+func (self *VMEnv) VmType() vm.Type { return self.typ }
+func (self *VMEnv) SetVmType(t vm.Type) { self.typ = t }
func (self *VMEnv) GetHash(n uint64) []byte {
if block := self.chain.GetBlockByNumber(n); block != nil {
return block.Hash()
generated by cgit v1.2.3 (git 2.25.1) at 2025-01-05 10:47:28 +0800