aboutsummaryrefslogtreecommitdiffstats
path: root/core
diff options
context:
space:
mode:
Diffstat (limited to 'core')
-rw-r--r--core/block_processor.go22
-rw-r--r--core/chain_manager.go28
-rw-r--r--core/execution.go4
-rw-r--r--core/helper_test.go5
-rw-r--r--core/state/state_object.go16
-rw-r--r--core/state_transition.go4
-rw-r--r--core/transaction_pool.go95
-rw-r--r--core/vm/context.go8
-rw-r--r--core/vm/environment.go17
-rw-r--r--core/vm/errors.go12
-rw-r--r--core/vm/logger.go51
-rw-r--r--core/vm/stack.go6
-rw-r--r--core/vm/virtual_machine.go2
-rw-r--r--core/vm/vm.go235
-rw-r--r--core/vm_env.go11
15 files changed, 281 insertions, 235 deletions
diff --git a/core/block_processor.go b/core/block_processor.go
index 190e72694..c01b110be 100644
--- a/core/block_processor.go
+++ b/core/block_processor.go
@@ -71,14 +71,10 @@ func (sm *BlockProcessor) TransitionState(statedb *state.StateDB, parent, block
func (self *BlockProcessor) ApplyTransaction(coinbase *state.StateObject, statedb *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
- //statedb.EmptyLogs()
cb := statedb.GetStateObject(coinbase.Address())
_, gas, err := ApplyMessage(NewEnv(statedb, self.bc, tx, block), tx, cb)
if err != nil && (IsNonceErr(err) || state.IsGasLimitErr(err) || IsInvalidTxErr(err)) {
- // If the account is managed, remove the invalid nonce.
- //from, _ := tx.From()
- //self.bc.TxState().RemoveNonce(from, tx.Nonce())
return nil, nil, err
}
@@ -151,11 +147,17 @@ func (sm *BlockProcessor) RetryProcess(block *types.Block) (logs state.Logs, err
return nil, ParentError(header.ParentHash)
}
parent := sm.bc.GetBlock(header.ParentHash)
- if !sm.Pow.Verify(block) {
+
+ // FIXME Change to full header validation. See #1225
+ errch := make(chan bool)
+ go func() { errch <- sm.Pow.Verify(block) }()
+
+ logs, err = sm.processWithParent(block, parent)
+ if !<-errch {
return nil, ValidationError("Block's nonce is invalid (= %x)", block.Nonce)
}
- return sm.processWithParent(block, parent)
+ return logs, err
}
// Process block will attempt to process the given block's transactions and applies them
@@ -258,6 +260,12 @@ func (sm *BlockProcessor) processWithParent(block, parent *types.Block) (logs st
putTx(sm.extraDb, tx, block, uint64(i))
}
+ receiptsRlp := receipts.RlpEncode()
+ /*if len(receipts) > 0 {
+ glog.V(logger.Info).Infof("Saving %v receipts, rlp len is %v\n", len(receipts), len(receiptsRlp))
+ }*/
+ sm.extraDb.Put(append(receiptsPre, block.Hash().Bytes()...), receiptsRlp)
+
return state.Logs(), nil
}
@@ -402,6 +410,8 @@ func getBlockReceipts(db common.Database, bhash common.Hash) (receipts types.Rec
if err == nil {
err = rlp.DecodeBytes(rdata, &receipts)
+ } else {
+ glog.V(logger.Detail).Infof("getBlockReceipts error %v\n", err)
}
return
}
diff --git a/core/chain_manager.go b/core/chain_manager.go
index 6897c453c..c3b7273c2 100644
--- a/core/chain_manager.go
+++ b/core/chain_manager.go
@@ -5,9 +5,9 @@ import (
"fmt"
"io"
"math/big"
- "os"
"runtime"
"sync"
+ "sync/atomic"
"time"
"github.com/ethereum/go-ethereum/common"
@@ -101,7 +101,9 @@ type ChainManager struct {
futureBlocks *BlockCache
quit chan struct{}
- wg sync.WaitGroup
+ // procInterrupt must be atomically called
+ procInterrupt int32 // interrupt signaler for block processing
+ wg sync.WaitGroup
pow pow.PoW
}
@@ -232,15 +234,8 @@ func (bc *ChainManager) setLastState() {
if block != nil {
bc.currentBlock = block
bc.lastBlockHash = block.Hash()
- } else { // TODO CLEAN THIS UP TMP CODE
- block = bc.GetBlockByNumber(400000)
- if block == nil {
- fmt.Println("Fatal. LastBlock not found. Report this issue")
- os.Exit(1)
- }
- bc.currentBlock = block
- bc.lastBlockHash = block.Hash()
- bc.insert(block)
+ } else {
+ glog.Fatalf("Fatal. LastBlock not found. Please run removedb and resync")
}
} else {
bc.Reset()
@@ -516,6 +511,7 @@ func (self *ChainManager) CalcTotalDiff(block *types.Block) (*big.Int, error) {
func (bc *ChainManager) Stop() {
close(bc.quit)
+ atomic.StoreInt32(&bc.procInterrupt, 1)
bc.wg.Wait()
@@ -567,7 +563,13 @@ func (self *ChainManager) InsertChain(chain types.Blocks) (int, error) {
go verifyNonces(self.pow, chain, nonceQuit, nonceDone)
defer close(nonceQuit)
+ txcount := 0
for i, block := range chain {
+ if atomic.LoadInt32(&self.procInterrupt) == 1 {
+ glog.V(logger.Debug).Infoln("Premature abort during chain processing")
+ break
+ }
+
bstart := time.Now()
// Wait for block i's nonce to be verified before processing
// its state transition.
@@ -625,6 +627,8 @@ func (self *ChainManager) InsertChain(chain types.Blocks) (int, error) {
return i, err
}
+ txcount += len(block.Transactions())
+
cblock := self.currentBlock
// Compare the TD of the last known block in the canonical chain to make sure it's greater.
// At this point it's possible that a different chain (fork) becomes the new canonical chain.
@@ -683,7 +687,7 @@ func (self *ChainManager) InsertChain(chain types.Blocks) (int, error) {
if (stats.queued > 0 || stats.processed > 0 || stats.ignored > 0) && bool(glog.V(logger.Info)) {
tend := time.Since(tstart)
start, end := chain[0], chain[len(chain)-1]
- glog.Infof("imported %d block(s) (%d queued %d ignored) in %v. #%v [%x / %x]\n", stats.processed, stats.queued, stats.ignored, tend, end.Number(), start.Hash().Bytes()[:4], end.Hash().Bytes()[:4])
+ glog.Infof("imported %d block(s) (%d queued %d ignored) including %d txs in %v. #%v [%x / %x]\n", stats.processed, stats.queued, stats.ignored, txcount, tend, end.Number(), start.Hash().Bytes()[:4], end.Hash().Bytes()[:4])
}
go self.eventMux.Post(queueEvent)
diff --git a/core/execution.go b/core/execution.go
index 522c90449..9fb0210de 100644
--- a/core/execution.go
+++ b/core/execution.go
@@ -2,7 +2,6 @@ package core
import (
"math/big"
- "time"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/state"
@@ -49,8 +48,6 @@ func (self *Execution) Create(caller vm.ContextRef) (ret []byte, err error, acco
}
func (self *Execution) exec(contextAddr *common.Address, code []byte, caller vm.ContextRef) (ret []byte, err error) {
- start := time.Now()
-
env := self.env
evm := self.evm
if env.Depth() > int(params.CallCreateDepth.Int64()) {
@@ -96,7 +93,6 @@ func (self *Execution) exec(contextAddr *common.Address, code []byte, caller vm.
context.SetCallCode(contextAddr, code)
ret, err = evm.Run(context, self.input)
- evm.Printf("message call took %v", time.Since(start)).Endl()
if err != nil {
env.State().Set(snapshot)
}
diff --git a/core/helper_test.go b/core/helper_test.go
index 1e0ed178b..a308153aa 100644
--- a/core/helper_test.go
+++ b/core/helper_test.go
@@ -6,8 +6,8 @@ import (
"github.com/ethereum/go-ethereum/core/types"
// "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/event"
)
@@ -76,8 +76,5 @@ func NewTestManager() *TestManager {
// testManager.blockChain = NewChainManager(testManager)
// testManager.stateManager = NewStateManager(testManager)
- // Start the tx pool
- testManager.txPool.Start()
-
return testManager
}
diff --git a/core/state/state_object.go b/core/state/state_object.go
index bfc4ebc6c..6d2455d79 100644
--- a/core/state/state_object.go
+++ b/core/state/state_object.go
@@ -336,6 +336,22 @@ func (self *StateObject) Nonce() uint64 {
return self.nonce
}
+func (self *StateObject) EachStorage(cb func(key, value []byte)) {
+ // When iterating over the storage check the cache first
+ for h, v := range self.storage {
+ cb([]byte(h), v.Bytes())
+ }
+
+ it := self.State.trie.Iterator()
+ for it.Next() {
+ // ignore cached values
+ key := self.State.trie.GetKey(it.Key)
+ if _, ok := self.storage[string(key)]; !ok {
+ cb(key, it.Value)
+ }
+ }
+}
+
//
// Encoding
//
diff --git a/core/state_transition.go b/core/state_transition.go
index 7672fa3ff..fedea8021 100644
--- a/core/state_transition.go
+++ b/core/state_transition.go
@@ -223,6 +223,10 @@ func (self *StateTransition) transitionState() (ret []byte, usedGas *big.Int, er
return nil, nil, InvalidTxError(err)
}
+ if vm.Debug {
+ vm.StdErrFormat(vmenv.StructLogs())
+ }
+
self.refundGas()
self.state.AddBalance(self.coinbase, new(big.Int).Mul(self.gasUsed(), self.gasPrice))
diff --git a/core/transaction_pool.go b/core/transaction_pool.go
index a2f970195..e31f5c6b3 100644
--- a/core/transaction_pool.go
+++ b/core/transaction_pool.go
@@ -19,6 +19,7 @@ var (
// Transaction Pool Errors
ErrInvalidSender = errors.New("Invalid sender")
ErrNonce = errors.New("Nonce too low")
+ ErrCheap = errors.New("Gas price too low for acceptance")
ErrBalance = errors.New("Insufficient balance")
ErrNonExistentAccount = errors.New("Account does not exist or account balance too low")
ErrInsufficientFunds = errors.New("Insufficient funds for gas * price + value")
@@ -27,6 +28,10 @@ var (
ErrNegativeValue = errors.New("Negative value")
)
+const (
+ maxQueued = 200 // max limit of queued txs per address
+)
+
type stateFn func() *state.StateDB
// TxPool contains all currently known transactions. Transactions
@@ -41,6 +46,7 @@ type TxPool struct {
currentState stateFn // The state function which will allow us to do some pre checkes
pendingState *state.ManagedState
gasLimit func() *big.Int // The current gas limit function callback
+ minGasPrice *big.Int
eventMux *event.TypeMux
events event.Subscription
@@ -50,26 +56,35 @@ type TxPool struct {
}
func NewTxPool(eventMux *event.TypeMux, currentStateFn stateFn, gasLimitFn func() *big.Int) *TxPool {
- return &TxPool{
+ pool := &TxPool{
pending: make(map[common.Hash]*types.Transaction),
queue: make(map[common.Address]map[common.Hash]*types.Transaction),
quit: make(chan bool),
eventMux: eventMux,
currentState: currentStateFn,
gasLimit: gasLimitFn,
+ minGasPrice: new(big.Int),
pendingState: state.ManageState(currentStateFn()),
+ events: eventMux.Subscribe(ChainEvent{}, GasPriceChanged{}),
}
+ go pool.eventLoop()
+
+ return pool
}
-func (pool *TxPool) Start() {
+func (pool *TxPool) eventLoop() {
// Track chain events. When a chain events occurs (new chain canon block)
// we need to know the new state. The new state will help us determine
// the nonces in the managed state
- pool.events = pool.eventMux.Subscribe(ChainEvent{})
- for _ = range pool.events.Chan() {
+ for ev := range pool.events.Chan() {
pool.mu.Lock()
- pool.resetState()
+ switch ev := ev.(type) {
+ case ChainEvent:
+ pool.resetState()
+ case GasPriceChanged:
+ pool.minGasPrice = ev.Price
+ }
pool.mu.Unlock()
}
@@ -100,7 +115,6 @@ func (pool *TxPool) resetState() {
}
func (pool *TxPool) Stop() {
- pool.pending = make(map[common.Hash]*types.Transaction)
close(pool.quit)
pool.events.Unsubscribe()
glog.V(logger.Info).Infoln("TX Pool stopped")
@@ -122,6 +136,11 @@ func (pool *TxPool) validateTx(tx *types.Transaction) error {
err error
)
+ // Drop transactions under our own minimal accepted gas price
+ if pool.minGasPrice.Cmp(tx.GasPrice()) > 0 {
+ return ErrCheap
+ }
+
// Validate the transaction sender and it's sig. Throw
// if the from fields is invalid.
if from, err = tx.From(); err != nil {
@@ -169,15 +188,10 @@ func (pool *TxPool) validateTx(tx *types.Transaction) error {
return nil
}
+// validate and queue transactions.
func (self *TxPool) add(tx *types.Transaction) error {
hash := tx.Hash()
- /* XXX I'm unsure about this. This is extremely dangerous and may result
- in total black listing of certain transactions
- if self.invalidHashes.Has(hash) {
- return fmt.Errorf("Invalid transaction (%x)", hash[:4])
- }
- */
if self.pending[hash] != nil {
return fmt.Errorf("Known transaction (%x)", hash[:4])
}
@@ -207,6 +221,30 @@ func (self *TxPool) add(tx *types.Transaction) error {
return nil
}
+// queueTx will queue an unknown transaction
+func (self *TxPool) queueTx(hash common.Hash, tx *types.Transaction) {
+ from, _ := tx.From() // already validated
+ if self.queue[from] == nil {
+ self.queue[from] = make(map[common.Hash]*types.Transaction)
+ }
+ self.queue[from][hash] = tx
+}
+
+// addTx will add a transaction to the pending (processable queue) list of transactions
+func (pool *TxPool) addTx(hash common.Hash, addr common.Address, tx *types.Transaction) {
+ if _, ok := pool.pending[hash]; !ok {
+ pool.pending[hash] = tx
+
+ // Increment the nonce on the pending state. This can only happen if
+ // the nonce is +1 to the previous one.
+ pool.pendingState.SetNonce(addr, tx.AccountNonce+1)
+ // Notify the subscribers. This event is posted in a goroutine
+ // because it's possible that somewhere during the post "Remove transaction"
+ // gets called which will then wait for the global tx pool lock and deadlock.
+ go pool.eventMux.Post(TxPreEvent{tx})
+ }
+}
+
// Add queues a single transaction in the pool if it is valid.
func (self *TxPool) Add(tx *types.Transaction) error {
self.mu.Lock()
@@ -290,28 +328,6 @@ func (self *TxPool) RemoveTransactions(txs types.Transactions) {
}
}
-func (self *TxPool) queueTx(hash common.Hash, tx *types.Transaction) {
- from, _ := tx.From() // already validated
- if self.queue[from] == nil {
- self.queue[from] = make(map[common.Hash]*types.Transaction)
- }
- self.queue[from][hash] = tx
-}
-
-func (pool *TxPool) addTx(hash common.Hash, addr common.Address, tx *types.Transaction) {
- if _, ok := pool.pending[hash]; !ok {
- pool.pending[hash] = tx
-
- // Increment the nonce on the pending state. This can only happen if
- // the nonce is +1 to the previous one.
- pool.pendingState.SetNonce(addr, tx.AccountNonce+1)
- // Notify the subscribers. This event is posted in a goroutine
- // because it's possible that somewhere during the post "Remove transaction"
- // gets called which will then wait for the global tx pool lock and deadlock.
- go pool.eventMux.Post(TxPreEvent{tx})
- }
-}
-
// checkQueue moves transactions that have become processable to main pool.
func (pool *TxPool) checkQueue() {
state := pool.pendingState
@@ -336,7 +352,16 @@ func (pool *TxPool) checkQueue() {
// Find the next consecutive nonce range starting at the
// current account nonce.
sort.Sort(addq)
- for _, e := range addq {
+ for i, e := range addq {
+ // start deleting the transactions from the queue if they exceed the limit
+ if i > maxQueued {
+ if glog.V(logger.Debug) {
+ glog.Infof("Queued tx limit exceeded for %s. Tx %s removed\n", common.PP(address[:]), common.PP(e.hash[:]))
+ }
+ delete(pool.queue[address], e.hash)
+ continue
+ }
+
if e.AccountNonce > guessedNonce {
break
}
diff --git a/core/vm/context.go b/core/vm/context.go
index de03f84f0..e33324b53 100644
--- a/core/vm/context.go
+++ b/core/vm/context.go
@@ -49,13 +49,13 @@ func NewContext(caller ContextRef, object ContextRef, value, gas, price *big.Int
return c
}
-func (c *Context) GetOp(n *big.Int) OpCode {
+func (c *Context) GetOp(n uint64) OpCode {
return OpCode(c.GetByte(n))
}
-func (c *Context) GetByte(n *big.Int) byte {
- if n.Cmp(big.NewInt(int64(len(c.Code)))) < 0 {
- return c.Code[n.Int64()]
+func (c *Context) GetByte(n uint64) byte {
+ if n < uint64(len(c.Code)) {
+ return c.Code[n]
}
return 0
diff --git a/core/vm/environment.go b/core/vm/environment.go
index 282d19578..c103049a2 100644
--- a/core/vm/environment.go
+++ b/core/vm/environment.go
@@ -8,6 +8,8 @@ import (
"github.com/ethereum/go-ethereum/core/state"
)
+// Environment is is required by the virtual machine to get information from
+// it's own isolated environment. For an example see `core.VMEnv`
type Environment interface {
State() *state.StateDB
@@ -20,6 +22,8 @@ type Environment interface {
GasLimit() *big.Int
Transfer(from, to Account, amount *big.Int) error
AddLog(*state.Log)
+ AddStructLog(StructLog)
+ StructLogs() []StructLog
VmType() Type
@@ -31,6 +35,19 @@ type Environment interface {
Create(me ContextRef, data []byte, gas, price, value *big.Int) ([]byte, error, ContextRef)
}
+// StructLog is emited to the Environment each cycle and lists information about the curent internal state
+// prior to the execution of the statement.
+type StructLog struct {
+ Pc uint64
+ Op OpCode
+ Gas *big.Int
+ GasCost *big.Int
+ Memory []byte
+ Stack []*big.Int
+ Storage map[common.Hash][]byte
+ Err error
+}
+
type Account interface {
SubBalance(amount *big.Int)
AddBalance(amount *big.Int)
diff --git a/core/vm/errors.go b/core/vm/errors.go
index fc3459de0..799eb6797 100644
--- a/core/vm/errors.go
+++ b/core/vm/errors.go
@@ -2,20 +2,14 @@ package vm
import (
"fmt"
+
"github.com/ethereum/go-ethereum/params"
- "math/big"
)
-type OutOfGasError struct {
- req, has *big.Int
-}
-
-func OOG(req, has *big.Int) OutOfGasError {
- return OutOfGasError{req, has}
-}
+type OutOfGasError struct{}
func (self OutOfGasError) Error() string {
- return fmt.Sprintf("out of gas! require %v, have %v", self.req, self.has)
+ return "Out Of Gas"
}
func IsOOGErr(err error) bool {
diff --git a/core/vm/logger.go b/core/vm/logger.go
new file mode 100644
index 000000000..0e2a417ae
--- /dev/null
+++ b/core/vm/logger.go
@@ -0,0 +1,51 @@
+package vm
+
+import (
+ "fmt"
+ "os"
+ "unicode"
+
+ "github.com/ethereum/go-ethereum/common"
+)
+
+func StdErrFormat(logs []StructLog) {
+ fmt.Fprintf(os.Stderr, "VM STAT %d OPs\n", len(logs))
+ for _, log := range logs {
+ fmt.Fprintf(os.Stderr, "PC %08d: %s GAS: %v COST: %v", log.Pc, log.Op, log.Gas, log.GasCost)
+ if log.Err != nil {
+ fmt.Fprintf(os.Stderr, " ERROR: %v", log.Err)
+ }
+ fmt.Fprintf(os.Stderr, "\n")
+
+ fmt.Fprintln(os.Stderr, "STACK =", len(log.Stack))
+
+ for i := len(log.Stack) - 1; i >= 0; i-- {
+ fmt.Fprintf(os.Stderr, "%04d: %x\n", len(log.Stack)-i-1, common.LeftPadBytes(log.Stack[i].Bytes(), 32))
+ }
+
+ const maxMem = 10
+ addr := 0
+ fmt.Fprintln(os.Stderr, "MEM =", len(log.Memory))
+ for i := 0; i+16 <= len(log.Memory) && addr < maxMem; i += 16 {
+ data := log.Memory[i : i+16]
+ str := fmt.Sprintf("%04d: % x ", addr*16, data)
+ for _, r := range data {
+ if r == 0 {
+ str += "."
+ } else if unicode.IsPrint(rune(r)) {
+ str += fmt.Sprintf("%s", string(r))
+ } else {
+ str += "?"
+ }
+ }
+ addr++
+ fmt.Fprintln(os.Stderr, str)
+ }
+
+ fmt.Fprintln(os.Stderr, "STORAGE =", len(log.Storage))
+ for h, item := range log.Storage {
+ fmt.Fprintf(os.Stderr, "%x: %x\n", h, common.LeftPadBytes(item, 32))
+ }
+ fmt.Fprintln(os.Stderr)
+ }
+}
diff --git a/core/vm/stack.go b/core/vm/stack.go
index bb232d0b9..2be5c3dbe 100644
--- a/core/vm/stack.go
+++ b/core/vm/stack.go
@@ -5,7 +5,7 @@ import (
"math/big"
)
-func newStack() *stack {
+func newstack() *stack {
return &stack{}
}
@@ -14,6 +14,10 @@ type stack struct {
ptr int
}
+func (st *stack) Data() []*big.Int {
+ return st.data[:st.ptr]
+}
+
func (st *stack) push(d *big.Int) {
// NOTE push limit (1024) is checked in baseCheck
stackItem := new(big.Int).Set(d)
diff --git a/core/vm/virtual_machine.go b/core/vm/virtual_machine.go
index 6db284f42..1fd1dcd88 100644
--- a/core/vm/virtual_machine.go
+++ b/core/vm/virtual_machine.go
@@ -3,6 +3,4 @@ package vm
type VirtualMachine interface {
Env() Environment
Run(context *Context, data []byte) ([]byte, error)
- Printf(string, ...interface{}) VirtualMachine
- Endl() VirtualMachine
}
diff --git a/core/vm/vm.go b/core/vm/vm.go
index 2bd950385..c5ad761f6 100644
--- a/core/vm/vm.go
+++ b/core/vm/vm.go
@@ -7,16 +7,13 @@ import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/params"
)
+// Vm implements VirtualMachine
type Vm struct {
env Environment
- logTy byte
- logStr string
-
err error
// For logging
debug bool
@@ -31,13 +28,13 @@ type Vm struct {
After func(*Context, error)
}
+// New returns a new Virtual Machine
func New(env Environment) *Vm {
- lt := LogTyPretty
-
- return &Vm{debug: Debug, env: env, logTy: lt, Recoverable: true}
+ return &Vm{env: env, debug: Debug, Recoverable: true}
}
-func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
+// Run loops and evaluates the contract's code with the given input data
+func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) {
self.env.SetDepth(self.env.Depth() + 1)
defer self.env.SetDepth(self.env.Depth() - 1)
@@ -46,9 +43,32 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
code = context.Code
value = context.value
price = context.Price
- )
- self.Printf("(%d) (%x) %x (code=%d) gas: %v (d) %x", self.env.Depth(), caller.Address().Bytes()[:4], context.Address(), len(code), context.Gas, callData).Endl()
+ op OpCode // current opcode
+ codehash = crypto.Sha3Hash(code) // codehash is used when doing jump dest caching
+ mem = NewMemory() // bound memory
+ stack = newstack() // local stack
+ statedb = self.env.State() // current state
+ // For optimisation reason we're using uint64 as the program counter.
+ // It's theoretically possible to go above 2^64. The YP defines the PC to be uint256. Pratically much less so feasible.
+ pc = uint64(0) // program counter
+
+ // jump evaluates and checks whether the given jump destination is a valid one
+ // if valid move the `pc` otherwise return an error.
+ jump = func(from uint64, to *big.Int) error {
+ if !context.jumpdests.has(codehash, code, to) {
+ nop := context.GetOp(to.Uint64())
+ return fmt.Errorf("invalid jump destination (%v) %v", nop, to)
+ }
+
+ pc = to.Uint64()
+
+ return nil
+ }
+
+ newMemSize *big.Int
+ cost *big.Int
+ )
// User defer pattern to check for an error and, based on the error being nil or not, use all gas and return.
defer func() {
@@ -57,7 +77,8 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
}
if err != nil {
- self.Printf(" %v", err).Endl()
+ self.log(pc, op, context.Gas, cost, mem, stack, context, err)
+
// In case of a VM exception (known exceptions) all gas consumed (panics NOT included).
context.UseGas(context.Gas)
@@ -67,7 +88,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
if context.CodeAddr != nil {
if p := Precompiled[context.CodeAddr.Str()]; p != nil {
- return self.RunPrecompiled(p, callData, context)
+ return self.RunPrecompiled(p, input, context)
}
}
@@ -76,29 +97,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
return context.Return(nil), nil
}
- var (
- op OpCode
- codehash = crypto.Sha3Hash(code)
- mem = NewMemory()
- stack = newStack()
- pc = new(big.Int)
- statedb = self.env.State()
-
- jump = func(from *big.Int, to *big.Int) error {
- if !context.jumpdests.has(codehash, code, to) {
- nop := context.GetOp(to)
- return fmt.Errorf("invalid jump destination (%v) %v", nop, to)
- }
-
- self.Printf(" ~> %v", to)
- pc = to
-
- self.Endl()
-
- return nil
- }
- )
-
for {
// The base for all big integer arithmetic
base := new(big.Int)
@@ -106,63 +104,55 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
// Get the memory location of pc
op = context.GetOp(pc)
- self.Printf("(pc) %-3d -o- %-14s (m) %-4d (s) %-4d ", pc, op.String(), mem.Len(), stack.len())
- newMemSize, gas, err := self.calculateGasAndSize(context, caller, op, statedb, mem, stack)
+ // calculate the new memory size and gas price for the current executing opcode
+ newMemSize, cost, err = self.calculateGasAndSize(context, caller, op, statedb, mem, stack)
if err != nil {
return nil, err
}
- self.Printf("(g) %-3v (%v)", gas, context.Gas)
-
- if !context.UseGas(gas) {
- self.Endl()
-
- tmp := new(big.Int).Set(context.Gas)
+ // Use the calculated gas. When insufficient gas is present, use all gas and return an
+ // Out Of Gas error
+ if !context.UseGas(cost) {
context.UseGas(context.Gas)
- return context.Return(nil), OOG(gas, tmp)
+ return context.Return(nil), OutOfGasError{}
}
-
+ // Resize the memory calculated previously
mem.Resize(newMemSize.Uint64())
+ // Add a log message
+ self.log(pc, op, context.Gas, cost, mem, stack, context, nil)
switch op {
case ADD:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v + %v", y, x)
base.Add(x, y)
U256(base)
- self.Printf(" = %v", base)
// pop result back on the stack
stack.push(base)
case SUB:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v - %v", x, y)
base.Sub(x, y)
U256(base)
- self.Printf(" = %v", base)
// pop result back on the stack
stack.push(base)
case MUL:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v * %v", y, x)
base.Mul(x, y)
U256(base)
- self.Printf(" = %v", base)
// pop result back on the stack
stack.push(base)
case DIV:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v / %v", x, y)
if y.Cmp(common.Big0) != 0 {
base.Div(x, y)
@@ -170,14 +160,11 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
U256(base)
- self.Printf(" = %v", base)
// pop result back on the stack
stack.push(base)
case SDIV:
x, y := S256(stack.pop()), S256(stack.pop())
- self.Printf(" %v / %v", x, y)
-
if y.Cmp(common.Big0) == 0 {
base.Set(common.Big0)
} else {
@@ -193,13 +180,10 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
U256(base)
}
- self.Printf(" = %v", base)
stack.push(base)
case MOD:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v %% %v", x, y)
-
if y.Cmp(common.Big0) == 0 {
base.Set(common.Big0)
} else {
@@ -208,13 +192,10 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
U256(base)
- self.Printf(" = %v", base)
stack.push(base)
case SMOD:
x, y := S256(stack.pop()), S256(stack.pop())
- self.Printf(" %v %% %v", x, y)
-
if y.Cmp(common.Big0) == 0 {
base.Set(common.Big0)
} else {
@@ -230,20 +211,15 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
U256(base)
}
- self.Printf(" = %v", base)
stack.push(base)
case EXP:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v ** %v", x, y)
-
base.Exp(x, y, Pow256)
U256(base)
- self.Printf(" = %v", base)
-
stack.push(base)
case SIGNEXTEND:
back := stack.pop()
@@ -260,15 +236,13 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
num = U256(num)
- self.Printf(" = %v", num)
-
stack.push(num)
}
case NOT:
stack.push(U256(new(big.Int).Not(stack.pop())))
case LT:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v < %v", x, y)
+
// x < y
if x.Cmp(y) < 0 {
stack.push(common.BigTrue)
@@ -277,7 +251,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
}
case GT:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v > %v", x, y)
// x > y
if x.Cmp(y) > 0 {
@@ -288,7 +261,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
case SLT:
x, y := S256(stack.pop()), S256(stack.pop())
- self.Printf(" %v < %v", x, y)
+
// x < y
if x.Cmp(S256(y)) < 0 {
stack.push(common.BigTrue)
@@ -297,7 +270,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
}
case SGT:
x, y := S256(stack.pop()), S256(stack.pop())
- self.Printf(" %v > %v", x, y)
// x > y
if x.Cmp(y) > 0 {
@@ -308,7 +280,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
case EQ:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v == %v", y, x)
// x == y
if x.Cmp(y) == 0 {
@@ -326,17 +297,14 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
case AND:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v & %v", y, x)
stack.push(base.And(x, y))
case OR:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v | %v", x, y)
stack.push(base.Or(x, y))
case XOR:
x, y := stack.pop(), stack.pop()
- self.Printf(" %v ^ %v", x, y)
stack.push(base.Xor(x, y))
case BYTE:
@@ -350,8 +318,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
base.Set(common.BigFalse)
}
- self.Printf(" => 0x%x", base.Bytes())
-
stack.push(base)
case ADDMOD:
x := stack.pop()
@@ -365,8 +331,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
base = U256(base)
}
- self.Printf(" %v + %v %% %v = %v", x, y, z, base)
-
stack.push(base)
case MULMOD:
x := stack.pop()
@@ -380,8 +344,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
U256(base)
}
- self.Printf(" %v + %v %% %v = %v", x, y, z, base)
-
stack.push(base)
case SHA3:
@@ -390,55 +352,45 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
stack.push(common.BigD(data))
- self.Printf(" => (%v) %x", size, data)
case ADDRESS:
stack.push(common.Bytes2Big(context.Address().Bytes()))
- self.Printf(" => %x", context.Address())
case BALANCE:
addr := common.BigToAddress(stack.pop())
balance := statedb.GetBalance(addr)
stack.push(balance)
- self.Printf(" => %v (%x)", balance, addr)
case ORIGIN:
origin := self.env.Origin()
stack.push(origin.Big())
- self.Printf(" => %x", origin)
case CALLER:
caller := context.caller.Address()
stack.push(common.Bytes2Big(caller.Bytes()))
- self.Printf(" => %x", caller)
case CALLVALUE:
stack.push(value)
- self.Printf(" => %v", value)
case CALLDATALOAD:
- data := getData(callData, stack.pop(), common.Big32)
-
- self.Printf(" => 0x%x", data)
+ data := getData(input, stack.pop(), common.Big32)
stack.push(common.Bytes2Big(data))
case CALLDATASIZE:
- l := int64(len(callData))
+ l := int64(len(input))
stack.push(big.NewInt(l))
- self.Printf(" => %d", l)
case CALLDATACOPY:
var (
mOff = stack.pop()
cOff = stack.pop()
l = stack.pop()
)
- data := getData(callData, cOff, l)
+ data := getData(input, cOff, l)
mem.Set(mOff.Uint64(), l.Uint64(), data)
- self.Printf(" => [%v, %v, %v]", mOff, cOff, l)
case CODESIZE, EXTCODESIZE:
var code []byte
if op == EXTCODESIZE {
@@ -452,7 +404,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
l := big.NewInt(int64(len(code)))
stack.push(l)
- self.Printf(" => %d", l)
case CODECOPY, EXTCODECOPY:
var code []byte
if op == EXTCODECOPY {
@@ -472,12 +423,9 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
mem.Set(mOff.Uint64(), l.Uint64(), codeCopy)
- self.Printf(" => [%v, %v, %v] %x", mOff, cOff, l, codeCopy)
case GASPRICE:
stack.push(context.Price)
- self.Printf(" => %x", context.Price)
-
case BLOCKHASH:
num := stack.pop()
@@ -488,56 +436,47 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
stack.push(common.Big0)
}
- self.Printf(" => 0x%x", stack.peek().Bytes())
case COINBASE:
coinbase := self.env.Coinbase()
stack.push(coinbase.Big())
- self.Printf(" => 0x%x", coinbase)
case TIMESTAMP:
time := self.env.Time()
stack.push(big.NewInt(time))
- self.Printf(" => 0x%x", time)
case NUMBER:
number := self.env.BlockNumber()
stack.push(U256(number))
- self.Printf(" => 0x%x", number.Bytes())
case DIFFICULTY:
difficulty := self.env.Difficulty()
stack.push(difficulty)
- self.Printf(" => 0x%x", difficulty.Bytes())
case GASLIMIT:
- self.Printf(" => %v", self.env.GasLimit())
stack.push(self.env.GasLimit())
case PUSH1, PUSH2, PUSH3, PUSH4, PUSH5, PUSH6, PUSH7, PUSH8, PUSH9, PUSH10, PUSH11, PUSH12, PUSH13, PUSH14, PUSH15, PUSH16, PUSH17, PUSH18, PUSH19, PUSH20, PUSH21, PUSH22, PUSH23, PUSH24, PUSH25, PUSH26, PUSH27, PUSH28, PUSH29, PUSH30, PUSH31, PUSH32:
- a := big.NewInt(int64(op - PUSH1 + 1))
- byts := getData(code, new(big.Int).Add(pc, big.NewInt(1)), a)
+ size := uint64(op - PUSH1 + 1)
+ byts := getData(code, new(big.Int).SetUint64(pc+1), new(big.Int).SetUint64(size))
// push value to stack
stack.push(common.Bytes2Big(byts))
- pc.Add(pc, a)
+ pc += size
- self.Printf(" => 0x%x", byts)
case POP:
stack.pop()
case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16:
n := int(op - DUP1 + 1)
stack.dup(n)
- self.Printf(" => [%d] 0x%x", n, stack.peek().Bytes())
case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16:
n := int(op - SWAP1 + 2)
stack.swap(n)
- self.Printf(" => [%d]", n)
case LOG0, LOG1, LOG2, LOG3, LOG4:
n := int(op - LOG0)
topics := make([]common.Hash, n)
@@ -550,38 +489,32 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
log := state.NewLog(context.Address(), topics, data, self.env.BlockNumber().Uint64())
self.env.AddLog(log)
- self.Printf(" => %v", log)
case MLOAD:
offset := stack.pop()
val := common.BigD(mem.Get(offset.Int64(), 32))
stack.push(val)
- self.Printf(" => 0x%x", val.Bytes())
case MSTORE:
// pop value of the stack
mStart, val := stack.pop(), stack.pop()
mem.Set(mStart.Uint64(), 32, common.BigToBytes(val, 256))
- self.Printf(" => 0x%x", val)
case MSTORE8:
off, val := stack.pop().Int64(), stack.pop().Int64()
mem.store[off] = byte(val & 0xff)
- self.Printf(" => [%v] 0x%x", off, mem.store[off])
case SLOAD:
loc := common.BigToHash(stack.pop())
val := common.Bytes2Big(statedb.GetState(context.Address(), loc))
stack.push(val)
- self.Printf(" {0x%x : 0x%x}", loc, val.Bytes())
case SSTORE:
loc := common.BigToHash(stack.pop())
val := stack.pop()
statedb.SetState(context.Address(), loc, val)
- self.Printf(" {0x%x : 0x%x}", loc, val.Bytes())
case JUMP:
if err := jump(pc, stack.pop()); err != nil {
return nil, err
@@ -599,17 +532,14 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
continue
}
- self.Printf(" ~> false")
-
case JUMPDEST:
case PC:
- stack.push(pc)
+ stack.push(new(big.Int).SetUint64(pc))
case MSIZE:
stack.push(big.NewInt(int64(mem.Len())))
case GAS:
stack.push(context.Gas)
- self.Printf(" => %x", context.Gas)
case CREATE:
var (
@@ -619,14 +549,12 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
gas = new(big.Int).Set(context.Gas)
addr common.Address
)
- self.Endl()
context.UseGas(context.Gas)
ret, suberr, ref := self.env.Create(context, input, gas, price, value)
if suberr != nil {
stack.push(common.BigFalse)
- self.Printf(" (*) 0x0 %v", suberr)
} else {
// gas < len(ret) * CreateDataGas == NO_CODE
dataGas := big.NewInt(int64(len(ret)))
@@ -651,7 +579,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
retOffset, retSize := stack.pop(), stack.pop()
address := common.BigToAddress(addr)
- self.Printf(" => %x", address).Endl()
// Get the arguments from the memory
args := mem.Get(inOffset.Int64(), inSize.Int64())
@@ -673,47 +600,41 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) {
if err != nil {
stack.push(common.BigFalse)
- self.Printf("%v").Endl()
} else {
stack.push(common.BigTrue)
mem.Set(retOffset.Uint64(), retSize.Uint64(), ret)
}
- self.Printf("resume %x (%v)", context.Address(), context.Gas)
+
case RETURN:
offset, size := stack.pop(), stack.pop()
ret := mem.GetPtr(offset.Int64(), size.Int64())
- self.Printf(" => [%v, %v] (%d) 0x%x", offset, size, len(ret), ret).Endl()
-
return context.Return(ret), nil
case SUICIDE:
receiver := statedb.GetOrNewStateObject(common.BigToAddress(stack.pop()))
balance := statedb.GetBalance(context.Address())
- self.Printf(" => (%x) %v", receiver.Address().Bytes()[:4], balance)
-
receiver.AddBalance(balance)
statedb.Delete(context.Address())
fallthrough
case STOP: // Stop the context
- self.Endl()
return context.Return(nil), nil
default:
- self.Printf("(pc) %-3v Invalid opcode %x\n", pc, op).Endl()
return nil, fmt.Errorf("Invalid opcode %x", op)
}
- pc.Add(pc, One)
+ pc++
- self.Endl()
}
}
+// calculateGasAndSize calculates the required given the opcode and stack items calculates the new memorysize for
+// the operation. This does not reduce gas or resizes the memory.
func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCode, statedb *state.StateDB, mem *Memory, stack *stack) (*big.Int, *big.Int, error) {
var (
gas = new(big.Int)
@@ -855,40 +776,38 @@ func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCo
return newMemSize, gas, nil
}
-func (self *Vm) RunPrecompiled(p *PrecompiledAccount, callData []byte, context *Context) (ret []byte, err error) {
- gas := p.Gas(len(callData))
+// RunPrecompile runs and evaluate the output of a precompiled contract defined in contracts.go
+func (self *Vm) RunPrecompiled(p *PrecompiledAccount, input []byte, context *Context) (ret []byte, err error) {
+ gas := p.Gas(len(input))
if context.UseGas(gas) {
- ret = p.Call(callData)
- self.Printf("NATIVE_FUNC => %x", ret)
- self.Endl()
+ ret = p.Call(input)
return context.Return(ret), nil
} else {
- self.Printf("NATIVE_FUNC => failed").Endl()
-
- tmp := new(big.Int).Set(context.Gas)
-
- return nil, OOG(gas, tmp)
- }
-}
-
-func (self *Vm) Printf(format string, v ...interface{}) VirtualMachine {
- if self.debug {
- self.logStr += fmt.Sprintf(format, v...)
+ return nil, OutOfGasError{}
}
-
- return self
}
-func (self *Vm) Endl() VirtualMachine {
- if self.debug {
- glog.V(0).Infoln(self.logStr)
- self.logStr = ""
+// log emits a log event to the environment for each opcode encountered. This is not to be confused with the
+// LOG* opcode.
+func (self *Vm) log(pc uint64, op OpCode, gas, cost *big.Int, memory *Memory, stack *stack, context *Context, err error) {
+ if Debug {
+ mem := make([]byte, len(memory.Data()))
+ copy(mem, memory.Data())
+ stck := make([]*big.Int, len(stack.Data()))
+ copy(stck, stack.Data())
+
+ object := context.self.(*state.StateObject)
+ storage := make(map[common.Hash][]byte)
+ object.EachStorage(func(k, v []byte) {
+ storage[common.BytesToHash(k)] = v
+ })
+
+ self.env.AddStructLog(StructLog{pc, op, new(big.Int).Set(gas), cost, mem, stck, storage, err})
}
-
- return self
}
+// Environment returns the current workable state of the VM
func (self *Vm) Env() Environment {
return self.env
}
diff --git a/core/vm_env.go b/core/vm_env.go
index c439d2946..da862d5c8 100644
--- a/core/vm_env.go
+++ b/core/vm_env.go
@@ -16,6 +16,8 @@ type VMEnv struct {
depth int
chain *ChainManager
typ vm.Type
+ // structured logging
+ logs []vm.StructLog
}
func NewEnv(state *state.StateDB, chain *ChainManager, msg Message, block *types.Block) *VMEnv {
@@ -47,6 +49,7 @@ func (self *VMEnv) GetHash(n uint64) common.Hash {
return common.Hash{}
}
+
func (self *VMEnv) AddLog(log *state.Log) {
self.state.AddLog(log)
}
@@ -68,3 +71,11 @@ func (self *VMEnv) Create(me vm.ContextRef, data []byte, gas, price, value *big.
exe := NewExecution(self, nil, data, gas, price, value)
return exe.Create(me)
}
+
+func (self *VMEnv) StructLogs() []vm.StructLog {
+ return self.logs
+}
+
+func (self *VMEnv) AddStructLog(log vm.StructLog) {
+ self.logs = append(self.logs, log)
+}
generated by cgit (git 2.34.1) at 2024-11-15 04:28:34 +0800