aboutsummaryrefslogtreecommitdiffstats
path: root/ethchain
diff options
context:
space:
mode:
Diffstat (limited to 'ethchain')
-rw-r--r--ethchain/asm.go2
-rw-r--r--ethchain/deprecated.go236
-rw-r--r--ethchain/stack.go10
-rw-r--r--ethchain/state.go49
-rw-r--r--ethchain/state_manager.go31
-rw-r--r--ethchain/state_object.go49
-rw-r--r--ethchain/state_transition.go143
-rw-r--r--ethchain/transaction.go8
-rw-r--r--ethchain/types.go3
-rw-r--r--ethchain/vm.go260
10 files changed, 355 insertions, 436 deletions
diff --git a/ethchain/asm.go b/ethchain/asm.go
index c267f9b55..277326ff9 100644
--- a/ethchain/asm.go
+++ b/ethchain/asm.go
@@ -28,7 +28,7 @@ func Disassemble(script []byte) (asm []string) {
if len(data) == 0 {
data = []byte{0}
}
- asm = append(asm, fmt.Sprintf("%#x", data))
+ asm = append(asm, fmt.Sprintf("0x%x", data))
pc.Add(pc, big.NewInt(a-1))
}
diff --git a/ethchain/deprecated.go b/ethchain/deprecated.go
deleted file mode 100644
index 0985fa25d..000000000
--- a/ethchain/deprecated.go
+++ /dev/null
@@ -1,236 +0,0 @@
-package ethchain
-
-import (
- "bytes"
- "fmt"
- "github.com/ethereum/eth-go/ethutil"
- "math/big"
-)
-
-func (sm *StateManager) MakeStateObject(state *State, tx *Transaction) *StateObject {
- contract := MakeContract(tx, state)
- if contract != nil {
- state.states[string(tx.CreationAddress())] = contract.state
-
- return contract
- }
-
- return nil
-}
-
-func (sm *StateManager) EvalScript(state *State, script []byte, object *StateObject, tx *Transaction, block *Block) (ret []byte, gas *big.Int, err error) {
- account := state.GetAccount(tx.Sender())
-
- err = account.ConvertGas(tx.Gas, tx.GasPrice)
- if err != nil {
- ethutil.Config.Log.Debugln(err)
- return
- }
-
- closure := NewClosure(account, object, script, state, tx.Gas, tx.GasPrice)
- vm := NewVm(state, sm, RuntimeVars{
- Origin: account.Address(),
- BlockNumber: block.BlockInfo().Number,
- PrevHash: block.PrevHash,
- Coinbase: block.Coinbase,
- Time: block.Time,
- Diff: block.Difficulty,
- Value: tx.Value,
- //Price: tx.GasPrice,
- })
- ret, gas, err = closure.Call(vm, tx.Data, nil)
-
- // Update the account (refunds)
- state.UpdateStateObject(account)
- state.UpdateStateObject(object)
-
- return
-}
-
-func (self *StateManager) ProcessTransaction(tx *Transaction, coinbase *StateObject, state *State, toContract bool) (gas *big.Int, err error) {
- fmt.Printf("state root before update %x\n", state.Root())
- defer func() {
- if r := recover(); r != nil {
- ethutil.Config.Log.Infoln(r)
- err = fmt.Errorf("%v", r)
- }
- }()
-
- gas = new(big.Int)
- addGas := func(g *big.Int) { gas.Add(gas, g) }
- addGas(GasTx)
-
- // Get the sender
- sender := state.GetAccount(tx.Sender())
-
- if sender.Nonce != tx.Nonce {
- err = NonceError(tx.Nonce, sender.Nonce)
- return
- }
-
- sender.Nonce += 1
- defer func() {
- //state.UpdateStateObject(sender)
- // Notify all subscribers
- self.Ethereum.Reactor().Post("newTx:post", tx)
- }()
-
- txTotalBytes := big.NewInt(int64(len(tx.Data)))
- //fmt.Println("txTotalBytes", txTotalBytes)
- //txTotalBytes.Div(txTotalBytes, ethutil.Big32)
- addGas(new(big.Int).Mul(txTotalBytes, GasData))
-
- rGas := new(big.Int).Set(gas)
- rGas.Mul(gas, tx.GasPrice)
-
- // Make sure there's enough in the sender's account. Having insufficient
- // funds won't invalidate this transaction but simple ignores it.
- totAmount := new(big.Int).Add(tx.Value, rGas)
- if sender.Amount.Cmp(totAmount) < 0 {
- state.UpdateStateObject(sender)
- err = fmt.Errorf("[TXPL] Insufficient amount in sender's (%x) account", tx.Sender())
- return
- }
-
- coinbase.BuyGas(gas, tx.GasPrice)
- state.UpdateStateObject(coinbase)
- fmt.Printf("1. root %x\n", state.Root())
-
- // Get the receiver
- receiver := state.GetAccount(tx.Recipient)
-
- // Send Tx to self
- if bytes.Compare(tx.Recipient, tx.Sender()) == 0 {
- // Subtract the fee
- sender.SubAmount(rGas)
- } else {
- // Subtract the amount from the senders account
- sender.SubAmount(totAmount)
- state.UpdateStateObject(sender)
- fmt.Printf("3. root %x\n", state.Root())
-
- // Add the amount to receivers account which should conclude this transaction
- receiver.AddAmount(tx.Value)
- state.UpdateStateObject(receiver)
- fmt.Printf("2. root %x\n", state.Root())
- }
-
- ethutil.Config.Log.Infof("[TXPL] Processed Tx %x\n", tx.Hash())
-
- return
-}
-
-func (sm *StateManager) ApplyTransaction(coinbase []byte, state *State, block *Block, tx *Transaction) (totalGasUsed *big.Int, err error) {
- /*
- Applies transactions to the given state and creates new
- state objects where needed.
-
- If said objects needs to be created
- run the initialization script provided by the transaction and
- assume there's a return value. The return value will be set to
- the script section of the state object.
- */
- var (
- addTotalGas = func(gas *big.Int) { totalGasUsed.Add(totalGasUsed, gas) }
- gas = new(big.Int)
- script []byte
- )
- totalGasUsed = big.NewInt(0)
- snapshot := state.Snapshot()
-
- ca := state.GetAccount(coinbase)
- // Apply the transaction to the current state
- gas, err = sm.ProcessTransaction(tx, ca, state, false)
- addTotalGas(gas)
- fmt.Println("gas used by tx", gas)
-
- if tx.CreatesContract() {
- if err == nil {
- // Create a new state object and the transaction
- // as it's data provider.
- contract := sm.MakeStateObject(state, tx)
- if contract != nil {
- fmt.Println(Disassemble(contract.Init()))
- // Evaluate the initialization script
- // and use the return value as the
- // script section for the state object.
- script, gas, err = sm.EvalScript(state, contract.Init(), contract, tx, block)
- fmt.Println("gas used by eval", gas)
- addTotalGas(gas)
- fmt.Println("total =", totalGasUsed)
-
- fmt.Println("script len =", len(script))
-
- if err != nil {
- err = fmt.Errorf("[STATE] Error during init script run %v", err)
- return
- }
- contract.script = script
- state.UpdateStateObject(contract)
- } else {
- err = fmt.Errorf("[STATE] Unable to create contract")
- }
- } else {
- err = fmt.Errorf("[STATE] contract creation tx: %v for sender %x", err, tx.Sender())
- }
- } else {
- // Find the state object at the "recipient" address. If
- // there's an object attempt to run the script.
- stateObject := state.GetStateObject(tx.Recipient)
- if err == nil && stateObject != nil && len(stateObject.Script()) > 0 {
- _, gas, err = sm.EvalScript(state, stateObject.Script(), stateObject, tx, block)
- addTotalGas(gas)
- }
- }
-
- parent := sm.bc.GetBlock(block.PrevHash)
- total := new(big.Int).Add(block.GasUsed, totalGasUsed)
- limit := block.CalcGasLimit(parent)
- if total.Cmp(limit) > 0 {
- state.Revert(snapshot)
- err = GasLimitError(total, limit)
- }
-
- return
-}
-
-// Apply transactions uses the transaction passed to it and applies them onto
-// the current processing state.
-func (sm *StateManager) ApplyTransactions(coinbase []byte, state *State, block *Block, txs []*Transaction) ([]*Receipt, []*Transaction) {
- // Process each transaction/contract
- var receipts []*Receipt
- var validTxs []*Transaction
- var ignoredTxs []*Transaction // Transactions which go over the gasLimit
-
- totalUsedGas := big.NewInt(0)
-
- for _, tx := range txs {
- usedGas, err := sm.ApplyTransaction(coinbase, state, block, tx)
- if err != nil {
- if IsNonceErr(err) {
- continue
- }
- if IsGasLimitErr(err) {
- ignoredTxs = append(ignoredTxs, tx)
- // We need to figure out if we want to do something with thse txes
- ethutil.Config.Log.Debugln("Gastlimit:", err)
- continue
- }
-
- ethutil.Config.Log.Infoln(err)
- }
-
- accumelative := new(big.Int).Set(totalUsedGas.Add(totalUsedGas, usedGas))
- receipt := &Receipt{tx, ethutil.CopyBytes(state.Root().([]byte)), accumelative}
-
- receipts = append(receipts, receipt)
- validTxs = append(validTxs, tx)
- }
-
- fmt.Println("################# MADE\n", receipts, "\n############################")
-
- // Update the total gas used for the block (to be mined)
- block.GasUsed = totalUsedGas
-
- return receipts, validTxs
-}
diff --git a/ethchain/stack.go b/ethchain/stack.go
index 37d1f84b9..a9fa2e522 100644
--- a/ethchain/stack.go
+++ b/ethchain/stack.go
@@ -2,7 +2,7 @@ package ethchain
import (
"fmt"
- _ "github.com/ethereum/eth-go/ethutil"
+ "math"
"math/big"
)
@@ -118,7 +118,13 @@ func (m *Memory) Resize(size uint64) {
}
func (m *Memory) Get(offset, size int64) []byte {
- return m.store[offset : offset+size]
+ if len(m.store) > int(offset) {
+ end := int(math.Min(float64(len(m.store)), float64(offset+size)))
+
+ return m.store[offset:end]
+ }
+
+ return nil
}
func (m *Memory) Len() int {
diff --git a/ethchain/state.go b/ethchain/state.go
index 9a9d0a278..a08dfac83 100644
--- a/ethchain/state.go
+++ b/ethchain/state.go
@@ -13,8 +13,6 @@ import (
type State struct {
// The trie for this structure
trie *ethutil.Trie
- // Nested states
- states map[string]*State
stateObjects map[string]*StateObject
@@ -23,7 +21,7 @@ type State struct {
// Create a new state from a given trie
func NewState(trie *ethutil.Trie) *State {
- return &State{trie: trie, states: make(map[string]*State), stateObjects: make(map[string]*StateObject), manifest: NewManifest()}
+ return &State{trie: trie, stateObjects: make(map[string]*StateObject), manifest: NewManifest()}
}
// Resets the trie and all siblings
@@ -38,12 +36,16 @@ func (s *State) Reset() {
stateObject.state.Reset()
}
+
+ s.Empty()
}
// Syncs the trie and all siblings
func (s *State) Sync() {
// Sync all nested states
for _, stateObject := range s.stateObjects {
+ s.UpdateStateObject(stateObject)
+
if stateObject.state == nil {
continue
}
@@ -52,6 +54,18 @@ func (s *State) Sync() {
}
s.trie.Sync()
+
+ s.Empty()
+}
+
+func (self *State) Empty() {
+ self.stateObjects = make(map[string]*StateObject)
+}
+
+func (self *State) Update() {
+ for _, stateObject := range self.stateObjects {
+ self.UpdateStateObject(stateObject)
+ }
}
// Purges the current trie.
@@ -64,6 +78,12 @@ func (s *State) EachStorage(cb ethutil.EachCallback) {
it.Each(cb)
}
+func (self *State) ResetStateObject(stateObject *StateObject) {
+ delete(self.stateObjects, string(stateObject.Address()))
+
+ stateObject.state.Reset()
+}
+
func (self *State) UpdateStateObject(stateObject *StateObject) {
addr := stateObject.Address()
@@ -98,13 +118,21 @@ func (self *State) GetStateObject(addr []byte) *StateObject {
func (self *State) GetOrNewStateObject(addr []byte) *StateObject {
stateObject := self.GetStateObject(addr)
if stateObject == nil {
- stateObject = NewStateObject(addr)
- self.stateObjects[string(addr)] = stateObject
+ stateObject = self.NewStateObject(addr)
}
return stateObject
}
+func (self *State) NewStateObject(addr []byte) *StateObject {
+ ethutil.Config.Log.Printf(ethutil.LogLevelInfo, "(+) %x\n", addr)
+
+ stateObject := NewStateObject(addr)
+ self.stateObjects[string(addr)] = stateObject
+
+ return stateObject
+}
+
func (self *State) GetAccount(addr []byte) *StateObject {
return self.GetOrNewStateObject(addr)
}
@@ -126,13 +154,10 @@ func (self *State) Copy() *State {
return nil
}
-func (s *State) Snapshot() *State {
- return s.Copy()
-}
-
-func (s *State) Revert(snapshot *State) {
- s.trie = snapshot.trie
- s.states = snapshot.states
+func (self *State) Set(state *State) {
+ //s.trie = snapshot.trie
+ //s.stateObjects = snapshot.stateObjects
+ self = state
}
func (s *State) Put(key, object []byte) {
diff --git a/ethchain/state_manager.go b/ethchain/state_manager.go
index 36bb14846..36ba1731c 100644
--- a/ethchain/state_manager.go
+++ b/ethchain/state_manager.go
@@ -127,6 +127,9 @@ done:
// Notify all subscribers
self.Ethereum.Reactor().Post("newTx:post", tx)
+ // Update the state with pending changes
+ state.Update()
+
txGas.Sub(txGas, st.gas)
accumelative := new(big.Int).Set(totalUsedGas.Add(totalUsedGas, txGas))
receipt := &Receipt{tx, ethutil.CopyBytes(state.Root().([]byte)), accumelative}
@@ -135,8 +138,6 @@ done:
handled = append(handled, tx)
}
- fmt.Println("################# MADE\n", receipts, "\n############################")
-
parent.GasUsed = totalUsedGas
return receipts, handled, unhandled, err
@@ -154,7 +155,7 @@ func (sm *StateManager) Process(block *Block, dontReact bool) error {
}
// Block processing and validating with a given (temporarily) state
-func (sm *StateManager) ProcessBlock(state *State, parent, block *Block, dontReact bool) error {
+func (sm *StateManager) ProcessBlock(state *State, parent, block *Block, dontReact bool) (err error) {
// Processing a blocks may never happen simultaneously
sm.mutex.Lock()
defer sm.mutex.Unlock()
@@ -175,30 +176,40 @@ func (sm *StateManager) ProcessBlock(state *State, parent, block *Block, dontRea
if !sm.bc.HasBlock(block.PrevHash) && sm.bc.CurrentBlock != nil {
return ParentError(block.PrevHash)
}
- fmt.Println(block.Receipts())
coinbase := state.GetOrNewStateObject(block.Coinbase)
coinbase.SetGasPool(block.CalcGasLimit(parent))
// Process the transactions on to current block
- //sm.ApplyTransactions(block.Coinbase, state, parent, block.Transactions())
- sm.ProcessTransactions(coinbase, state, block, parent, block.Transactions())
+ receipts, _, _, _ := sm.ProcessTransactions(coinbase, state, block, parent, block.Transactions())
+ defer func() {
+ if err != nil {
+ if len(receipts) == len(block.Receipts()) {
+ for i, receipt := range block.Receipts() {
+ ethutil.Config.Log.Debugf("diff (r) %v ~ %x <=> (c) %v ~ %x (%x)\n", receipt.CumulativeGasUsed, receipt.PostState[0:4], receipts[i].CumulativeGasUsed, receipts[i].PostState[0:4], receipt.Tx.Hash())
+ }
+ } else {
+ ethutil.Config.Log.Debugln("Unable to print receipt diff. Length didn't match", len(receipts), "for", len(block.Receipts()))
+ }
+ }
+ }()
// Block validation
- if err := sm.ValidateBlock(block); err != nil {
+ if err = sm.ValidateBlock(block); err != nil {
fmt.Println("[SM] Error validating block:", err)
return err
}
// I'm not sure, but I don't know if there should be thrown
// any errors at this time.
- if err := sm.AccumelateRewards(state, block); err != nil {
+ if err = sm.AccumelateRewards(state, block); err != nil {
fmt.Println("[SM] Error accumulating reward", err)
return err
}
if !block.State().Cmp(state) {
- return fmt.Errorf("Invalid merkle root.\nrec: %x\nis: %x", block.State().trie.Root, state.trie.Root)
+ err = fmt.Errorf("Invalid merkle root.\nrec: %x\nis: %x", block.State().trie.Root, state.trie.Root)
+ return
}
// Calculate the new total difficulty and sync back to the db
@@ -270,10 +281,12 @@ func (sm *StateManager) ValidateBlock(block *Block) error {
return ValidationError("Block timestamp less then prev block %v", diff)
}
+ /* 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.HashNoNonce(), block.Difficulty, block.Nonce) {
diff --git a/ethchain/state_object.go b/ethchain/state_object.go
index 1445bcd82..5b64c3b37 100644
--- a/ethchain/state_object.go
+++ b/ethchain/state_object.go
@@ -4,8 +4,15 @@ import (
"fmt"
"github.com/ethereum/eth-go/ethutil"
"math/big"
+ "strings"
)
+type Code []byte
+
+func (self Code) String() string {
+ return strings.Join(Disassemble(self), " ")
+}
+
type StateObject struct {
// Address of the object
address []byte
@@ -15,8 +22,8 @@ type StateObject struct {
Nonce uint64
// Contract related attributes
state *State
- script []byte
- initScript []byte
+ script Code
+ initScript Code
// Total gas pool is the total amount of gas currently
// left if this object is the coinbase. Gas is directly
@@ -30,12 +37,9 @@ func MakeContract(tx *Transaction, state *State) *StateObject {
if tx.IsContract() {
addr := tx.CreationAddress()
- value := tx.Value
- contract := NewContract(addr, value, ZeroHash256)
-
+ contract := state.NewStateObject(addr)
contract.initScript = tx.Data
-
- state.UpdateStateObject(contract)
+ contract.state = NewState(ethutil.NewTrie(ethutil.Config.Db, ""))
return contract
}
@@ -44,7 +48,7 @@ func MakeContract(tx *Transaction, state *State) *StateObject {
}
func NewStateObject(addr []byte) *StateObject {
- return &StateObject{address: addr, Amount: new(big.Int)}
+ return &StateObject{address: addr, Amount: new(big.Int), gasPool: new(big.Int)}
}
func NewContract(address []byte, Amount *big.Int, root []byte) *StateObject {
@@ -120,13 +124,13 @@ func (c *StateObject) ReturnGas(gas, price *big.Int, state *State) {
func (c *StateObject) AddAmount(amount *big.Int) {
c.SetAmount(new(big.Int).Add(c.Amount, amount))
- ethutil.Config.Log.Printf(ethutil.LogLevelSystem, "%x: #%d %v (+ %v)\n", c.Address(), c.Nonce, c.Amount, amount)
+ ethutil.Config.Log.Printf(ethutil.LogLevelInfo, "%x: #%d %v (+ %v)\n", c.Address(), c.Nonce, c.Amount, amount)
}
func (c *StateObject) SubAmount(amount *big.Int) {
c.SetAmount(new(big.Int).Sub(c.Amount, amount))
- ethutil.Config.Log.Printf(ethutil.LogLevelSystem, "%x: #%d %v (- %v)\n", c.Address(), c.Nonce, c.Amount, amount)
+ ethutil.Config.Log.Printf(ethutil.LogLevelInfo, "%x: #%d %v (- %v)\n", c.Address(), c.Nonce, c.Amount, amount)
}
func (c *StateObject) SetAmount(amount *big.Int) {
@@ -173,6 +177,26 @@ func (self *StateObject) RefundGas(gas, price *big.Int) {
}
func (self *StateObject) Copy() *StateObject {
+ stateObject := NewStateObject(self.Address())
+ stateObject.Amount.Set(self.Amount)
+ stateObject.ScriptHash = ethutil.CopyBytes(self.ScriptHash)
+ stateObject.Nonce = self.Nonce
+ if self.state != nil {
+ stateObject.state = self.state.Copy()
+ }
+ stateObject.script = ethutil.CopyBytes(self.script)
+ stateObject.initScript = ethutil.CopyBytes(self.initScript)
+ //stateObject.gasPool.Set(self.gasPool)
+
+ return self
+}
+
+func (self *StateObject) Set(stateObject *StateObject) {
+ self = stateObject
+}
+
+/*
+func (self *StateObject) Copy() *StateObject {
stCopy := &StateObject{}
stCopy.address = make([]byte, len(self.address))
copy(stCopy.address, self.address)
@@ -190,6 +214,7 @@ func (self *StateObject) Copy() *StateObject {
return stCopy
}
+*/
// Returns the address of the contract/account
func (c *StateObject) Address() []byte {
@@ -197,12 +222,12 @@ func (c *StateObject) Address() []byte {
}
// Returns the main script body
-func (c *StateObject) Script() []byte {
+func (c *StateObject) Script() Code {
return c.script
}
// Returns the initialization script
-func (c *StateObject) Init() []byte {
+func (c *StateObject) Init() Code {
return c.initScript
}
diff --git a/ethchain/state_transition.go b/ethchain/state_transition.go
index 25efd64cc..1f5b4f959 100644
--- a/ethchain/state_transition.go
+++ b/ethchain/state_transition.go
@@ -23,17 +23,19 @@ import (
* 6) Derive new state root
*/
type StateTransition struct {
- coinbase []byte
- tx *Transaction
- gas *big.Int
- state *State
- block *Block
+ coinbase, receiver []byte
+ tx *Transaction
+ gas, gasPrice *big.Int
+ value *big.Int
+ data []byte
+ state *State
+ block *Block
cb, rec, sen *StateObject
}
func NewStateTransition(coinbase *StateObject, tx *Transaction, state *State, block *Block) *StateTransition {
- return &StateTransition{coinbase.Address(), tx, new(big.Int), state, block, coinbase, nil, nil}
+ return &StateTransition{coinbase.Address(), tx.Recipient, tx, new(big.Int), new(big.Int).Set(tx.GasPrice), tx.Value, tx.Data, state, block, coinbase, nil, nil}
}
func (self *StateTransition) Coinbase() *StateObject {
@@ -53,7 +55,7 @@ func (self *StateTransition) Sender() *StateObject {
return self.sen
}
func (self *StateTransition) Receiver() *StateObject {
- if self.tx.CreatesContract() {
+ if self.tx != nil && self.tx.CreatesContract() {
return nil
}
@@ -67,13 +69,8 @@ func (self *StateTransition) Receiver() *StateObject {
func (self *StateTransition) MakeStateObject(state *State, tx *Transaction) *StateObject {
contract := MakeContract(tx, state)
- if contract != nil {
- state.states[string(tx.CreationAddress())] = contract.state
- return contract
- }
-
- return nil
+ return contract
}
func (self *StateTransition) UseGas(amount *big.Int) error {
@@ -94,7 +91,7 @@ func (self *StateTransition) BuyGas() error {
sender := self.Sender()
if sender.Amount.Cmp(self.tx.GasValue()) < 0 {
- return fmt.Errorf("Insufficient funds to pre-pay gas. Req %v, has %v", self.tx.GasValue(), self.tx.Value)
+ return fmt.Errorf("Insufficient funds to pre-pay gas. Req %v, has %v", self.tx.GasValue(), sender.Amount)
}
coinbase := self.Coinbase()
@@ -102,7 +99,6 @@ func (self *StateTransition) BuyGas() error {
if err != nil {
return err
}
- //self.state.UpdateStateObject(coinbase)
self.AddGas(self.tx.Gas)
sender.SubAmount(self.tx.GasValue())
@@ -119,22 +115,10 @@ func (self *StateTransition) RefundGas() {
sender.AddAmount(remaining)
}
-func (self *StateTransition) TransitionState() (err error) {
- //snapshot := st.state.Snapshot()
-
- /*
- defer func() {
- if r := recover(); r != nil {
- ethutil.Config.Log.Infoln(r)
- err = fmt.Errorf("state transition err %v", r)
- }
- }()
- */
-
+func (self *StateTransition) preCheck() (err error) {
var (
- tx = self.tx
- sender = self.Sender()
- receiver *StateObject
+ tx = self.tx
+ sender = self.Sender()
)
// Make sure this transaction's nonce is correct
@@ -147,38 +131,49 @@ func (self *StateTransition) TransitionState() (err error) {
return err
}
- // XXX Transactions after this point are considered valid.
+ return nil
+}
- defer func() {
- self.RefundGas()
+func (self *StateTransition) TransitionState() (err error) {
+ ethutil.Config.Log.Printf(ethutil.LogLevelInfo, "(~) %x\n", self.tx.Hash())
- if sender != nil {
- self.state.UpdateStateObject(sender)
- }
+ /*
+ defer func() {
+ if r := recover(); r != nil {
+ ethutil.Config.Log.Infoln(r)
+ err = fmt.Errorf("state transition err %v", r)
+ }
+ }()
+ */
- if receiver != nil {
- self.state.UpdateStateObject(receiver)
- }
+ // XXX Transactions after this point are considered valid.
+ if err = self.preCheck(); err != nil {
+ return
+ }
+
+ var (
+ tx = self.tx
+ sender = self.Sender()
+ receiver *StateObject
+ )
- self.state.UpdateStateObject(self.Coinbase())
- }()
+ defer self.RefundGas()
// Increment the nonce for the next transaction
sender.Nonce += 1
- // Get the receiver (TODO fix this, if coinbase is the receiver we need to save/retrieve)
receiver = self.Receiver()
// Transaction gas
if err = self.UseGas(GasTx); err != nil {
- return err
+ return
}
// Pay data gas
- dataPrice := big.NewInt(int64(len(tx.Data)))
+ dataPrice := big.NewInt(int64(len(self.data)))
dataPrice.Mul(dataPrice, GasData)
if err = self.UseGas(dataPrice); err != nil {
- return err
+ return
}
// If the receiver is nil it's a contract (\0*32).
@@ -186,75 +181,83 @@ func (self *StateTransition) TransitionState() (err error) {
// Create a new state object for the contract
receiver = self.MakeStateObject(self.state, tx)
if receiver == nil {
- return fmt.Errorf("ERR. Unable to create contract with transaction %v", tx)
+ return fmt.Errorf("Unable to create contract")
}
}
// Transfer value from sender to receiver
if err = self.transferValue(sender, receiver); err != nil {
- return err
+ return
}
// Process the init code and create 'valid' contract
- if tx.CreatesContract() {
+ if IsContractAddr(self.receiver) {
// Evaluate the initialization script
// and use the return value as the
// script section for the state object.
- //script, gas, err = sm.Eval(state, contract.Init(), contract, tx, block)
- code, err := self.Eval(receiver.Init(), receiver)
- if err != nil {
- return fmt.Errorf("Error during init script run %v", err)
+ self.data = nil
+
+ code, err, deepErr := self.Eval(receiver.Init(), receiver)
+ if err != nil || deepErr {
+ self.state.ResetStateObject(receiver)
+
+ return fmt.Errorf("Error during init script run %v (deepErr = %v)", err, deepErr)
}
receiver.script = code
} else {
if len(receiver.Script()) > 0 {
- _, err := self.Eval(receiver.Script(), receiver)
+ var deepErr bool
+ _, err, deepErr = self.Eval(receiver.Script(), receiver)
if err != nil {
- return fmt.Errorf("Error during code execution %v", err)
+ self.state.ResetStateObject(receiver)
+
+ return fmt.Errorf("Error during code execution %v (deepErr = %v)", err, deepErr)
}
}
}
- return nil
+ return
}
func (self *StateTransition) transferValue(sender, receiver *StateObject) error {
- if sender.Amount.Cmp(self.tx.Value) < 0 {
- return fmt.Errorf("Insufficient funds to transfer value. Req %v, has %v", self.tx.Value, sender.Amount)
+ if sender.Amount.Cmp(self.value) < 0 {
+ return fmt.Errorf("Insufficient funds to transfer value. Req %v, has %v", self.value, sender.Amount)
}
- if self.tx.Value.Cmp(ethutil.Big0) > 0 {
- // Subtract the amount from the senders account
- sender.SubAmount(self.tx.Value)
- // Add the amount to receivers account which should conclude this transaction
- receiver.AddAmount(self.tx.Value)
+ //if self.value.Cmp(ethutil.Big0) > 0 {
+ // Subtract the amount from the senders account
+ sender.SubAmount(self.value)
+ // Add the amount to receivers account which should conclude this transaction
+ receiver.AddAmount(self.value)
- ethutil.Config.Log.Debugf("%x => %x (%v) %x\n", sender.Address()[:4], receiver.Address()[:4], self.tx.Value, self.tx.Hash())
- }
+ //ethutil.Config.Log.Debugf("%x => %x (%v)\n", sender.Address()[:4], receiver.Address()[:4], self.value)
+ //}
return nil
}
-func (self *StateTransition) Eval(script []byte, context *StateObject) (ret []byte, err error) {
+func (self *StateTransition) Eval(script []byte, context *StateObject) (ret []byte, err error, deepErr bool) {
var (
- tx = self.tx
block = self.block
initiator = self.Sender()
state = self.state
)
- closure := NewClosure(initiator, context, script, state, self.gas, tx.GasPrice)
+ closure := NewClosure(initiator, context, script, state, self.gas, self.gasPrice)
vm := NewVm(state, nil, RuntimeVars{
Origin: initiator.Address(),
- BlockNumber: block.BlockInfo().Number,
+ Block: block,
+ BlockNumber: block.Number,
PrevHash: block.PrevHash,
Coinbase: block.Coinbase,
Time: block.Time,
Diff: block.Difficulty,
- Value: tx.Value,
+ Value: self.value,
})
- ret, _, err = closure.Call(vm, tx.Data, nil)
+ vm.Verbose = true
+ ret, _, err = closure.Call(vm, self.data, nil)
+ deepErr = vm.err != nil
return
}
diff --git a/ethchain/transaction.go b/ethchain/transaction.go
index 3d52e4f73..34ab357a1 100644
--- a/ethchain/transaction.go
+++ b/ethchain/transaction.go
@@ -10,6 +10,10 @@ import (
var ContractAddr = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+func IsContractAddr(addr []byte) bool {
+ return bytes.Compare(addr, ContractAddr) == 0
+}
+
type Transaction struct {
Nonce uint64
Recipient []byte
@@ -65,7 +69,7 @@ func (tx *Transaction) CreatesContract() bool {
return tx.contractCreation
}
-/* Depricated */
+/* Deprecated */
func (tx *Transaction) IsContract() bool {
return tx.CreatesContract()
}
@@ -149,7 +153,7 @@ func (tx *Transaction) RlpValueDecode(decoder *ethutil.Value) {
tx.r = decoder.Get(7).Bytes()
tx.s = decoder.Get(8).Bytes()
- if bytes.Compare(tx.Recipient, ContractAddr) == 0 {
+ if IsContractAddr(tx.Recipient) {
tx.contractCreation = true
}
}
diff --git a/ethchain/types.go b/ethchain/types.go
index d89fad147..9e7269f74 100644
--- a/ethchain/types.go
+++ b/ethchain/types.go
@@ -166,6 +166,7 @@ var opCodeToString = map[OpCode]string{
GASLIMIT: "GASLIMIT",
// 0x50 range - 'storage' and execution
+ POP: "POP",
DUP: "DUP",
SWAP: "SWAP",
MLOAD: "MLOAD",
@@ -226,7 +227,7 @@ var opCodeToString = map[OpCode]string{
func (o OpCode) String() string {
str := opCodeToString[o]
if len(str) == 0 {
- return fmt.Sprintf("Missing opcode %#x", int(o))
+ return fmt.Sprintf("Missing opcode 0x%x", int(o))
}
return str
diff --git a/ethchain/vm.go b/ethchain/vm.go
index 2ba0e2ef3..fc3c37dc1 100644
--- a/ethchain/vm.go
+++ b/ethchain/vm.go
@@ -1,12 +1,9 @@
package ethchain
import (
- _ "bytes"
"fmt"
"github.com/ethereum/eth-go/ethutil"
- _ "github.com/obscuren/secp256k1-go"
"math"
- _ "math"
"math/big"
)
@@ -45,11 +42,18 @@ type Vm struct {
state *State
stateManager *StateManager
+
+ Verbose bool
+
+ logStr string
+
+ err error
}
type RuntimeVars struct {
Origin []byte
- BlockNumber uint64
+ Block *Block
+ BlockNumber *big.Int
PrevHash []byte
Coinbase []byte
Time int64
@@ -58,6 +62,23 @@ type RuntimeVars struct {
Value *big.Int
}
+func (self *Vm) Printf(format string, v ...interface{}) *Vm {
+ if self.Verbose {
+ self.logStr += fmt.Sprintf(format, v...)
+ }
+
+ return self
+}
+
+func (self *Vm) Endl() *Vm {
+ if self.Verbose {
+ ethutil.Config.Log.Infoln(self.logStr)
+ self.logStr = ""
+ }
+
+ return self
+}
+
func NewVm(state *State, stateManager *StateManager, vars RuntimeVars) *Vm {
return &Vm{vars: vars, state: state, stateManager: stateManager}
}
@@ -69,14 +90,14 @@ var isRequireError = false
func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err error) {
// Recover from any require exception
defer func() {
- if r := recover(); r != nil /*&& isRequireError*/ {
+ if r := recover(); r != nil {
ret = closure.Return(nil)
err = fmt.Errorf("%v", r)
fmt.Println("vm err", err)
}
}()
- ethutil.Config.Log.Debugf("[VM] Running closure %x\n", closure.object.Address())
+ ethutil.Config.Log.Debugf("[VM] (~) %x gas: %v (d) %x\n", closure.object.Address(), closure.Gas, closure.Args)
// Memory for the current closure
mem := &Memory{}
@@ -95,10 +116,6 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
step := 0
prevStep := 0
- if ethutil.Config.Debug {
- ethutil.Config.Log.Debugf("# op\n")
- }
-
for {
prevStep = step
// The base for all big integer arithmetic
@@ -109,13 +126,12 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
val := closure.Get(pc)
// Get the opcode (it must be an opcode!)
op := OpCode(val.Uint())
- if ethutil.Config.Debug {
- ethutil.Config.Log.Debugf("%-3d %-4s", pc, op.String())
- }
gas := new(big.Int)
addStepGasUsage := func(amount *big.Int) {
- gas.Add(gas, amount)
+ if amount.Cmp(ethutil.Big0) >= 0 {
+ gas.Add(gas, amount)
+ }
}
addStepGasUsage(GasStep)
@@ -123,7 +139,9 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
var newMemSize uint64 = 0
switch op {
case STOP:
+ gas.Set(ethutil.Big0)
case SUICIDE:
+ gas.Set(ethutil.Big0)
case SLOAD:
gas.Set(GasSLoad)
case SSTORE:
@@ -169,7 +187,7 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
case CALL:
require(7)
gas.Set(GasCall)
- addStepGasUsage(stack.data[stack.Len()-2])
+ addStepGasUsage(stack.data[stack.Len()-1])
x := stack.data[stack.Len()-6].Uint64() + stack.data[stack.Len()-7].Uint64()
y := stack.data[stack.Len()-4].Uint64() + stack.data[stack.Len()-5].Uint64()
@@ -189,11 +207,16 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
}
if !closure.UseGas(gas) {
- ethutil.Config.Log.Debugln("Insufficient gas", closure.Gas, gas)
+ err := fmt.Errorf("Insufficient gas for %v. req %v has %v", op, gas, closure.Gas)
- return closure.Return(nil), fmt.Errorf("insufficient gas %v %v", closure.Gas, gas)
+ closure.UseGas(closure.Gas)
+
+ return closure.Return(nil), err
}
+ vm.Printf("(pc) %-3d -o- %-14s", pc, op.String())
+ vm.Printf(" (g) %-3v (%v)", gas, closure.Gas)
+
mem.Resize(newMemSize)
switch op {
@@ -204,29 +227,41 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
case ADD:
require(2)
x, y := stack.Popn()
- // (x + y) % 2 ** 256
- base.Add(x, y)
+ vm.Printf(" %v + %v", y, x)
+
+ base.Add(y, x)
+
+ vm.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case SUB:
require(2)
x, y := stack.Popn()
- // (x - y) % 2 ** 256
- base.Sub(x, y)
+ vm.Printf(" %v - %v", y, x)
+
+ base.Sub(y, x)
+
+ vm.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case MUL:
require(2)
x, y := stack.Popn()
- // (x * y) % 2 ** 256
- base.Mul(x, y)
+ vm.Printf(" %v * %v", y, x)
+
+ base.Mul(y, x)
+
+ vm.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case DIV:
require(2)
x, y := stack.Popn()
- // floor(x / y)
- base.Div(x, y)
+ vm.Printf(" %v / %v", y, x)
+
+ base.Div(y, x)
+
+ vm.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case SDIV:
@@ -249,7 +284,12 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
case MOD:
require(2)
x, y := stack.Popn()
- base.Mod(x, y)
+
+ vm.Printf(" %v %% %v", y, x)
+
+ base.Mod(y, x)
+
+ vm.Printf(" = %v", base)
stack.Push(base)
case SMOD:
require(2)
@@ -271,7 +311,12 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
case EXP:
require(2)
x, y := stack.Popn()
- base.Exp(x, y, Pow256)
+
+ vm.Printf(" %v ** %v", y, x)
+
+ base.Exp(y, x, Pow256)
+
+ vm.Printf(" = %v", base)
stack.Push(base)
case NEG:
@@ -280,7 +325,8 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
stack.Push(base)
case LT:
require(2)
- x, y := stack.Popn()
+ y, x := stack.Popn()
+ vm.Printf(" %v < %v", x, y)
// x < y
if x.Cmp(y) < 0 {
stack.Push(ethutil.BigTrue)
@@ -289,7 +335,9 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
}
case GT:
require(2)
- x, y := stack.Popn()
+ y, x := stack.Popn()
+ vm.Printf(" %v > %v", x, y)
+
// x > y
if x.Cmp(y) > 0 {
stack.Push(ethutil.BigTrue)
@@ -299,6 +347,8 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
case EQ:
require(2)
x, y := stack.Popn()
+ vm.Printf(" %v == %v", y, x)
+
// x == y
if x.Cmp(y) == 0 {
stack.Push(ethutil.BigTrue)
@@ -318,24 +368,21 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
case AND:
require(2)
x, y := stack.Popn()
- if (x.Cmp(ethutil.BigTrue) >= 0) && (y.Cmp(ethutil.BigTrue) >= 0) {
- stack.Push(ethutil.BigTrue)
- } else {
- stack.Push(ethutil.BigFalse)
- }
+ vm.Printf(" %v & %v", y, x)
+ stack.Push(base.And(y, x))
case OR:
require(2)
x, y := stack.Popn()
- if (x.Cmp(ethutil.BigInt0) >= 0) || (y.Cmp(ethutil.BigInt0) >= 0) {
- stack.Push(ethutil.BigTrue)
- } else {
- stack.Push(ethutil.BigFalse)
- }
+ vm.Printf(" %v | %v", y, x)
+
+ stack.Push(base.Or(y, x))
case XOR:
require(2)
x, y := stack.Popn()
- stack.Push(base.Xor(x, y))
+ vm.Printf(" %v ^ %v", y, x)
+
+ stack.Push(base.Xor(y, x))
case BYTE:
require(2)
val, th := stack.Popn()
@@ -360,25 +407,35 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
case ORIGIN:
stack.Push(ethutil.BigD(vm.vars.Origin))
case CALLER:
- stack.Push(ethutil.BigD(closure.caller.Address()))
+ caller := closure.caller.Address()
+ stack.Push(ethutil.BigD(caller))
+
+ vm.Printf(" => %x", caller)
case CALLVALUE:
stack.Push(vm.vars.Value)
case CALLDATALOAD:
require(1)
offset := stack.Pop().Int64()
- var data []byte
- if len(closure.Args) >= int(offset+32) {
- data = closure.Args[offset : offset+32]
- } else {
- data = []byte{0}
+ data := make([]byte, 32)
+ if len(closure.Args) >= int(offset) {
+ l := int64(math.Min(float64(offset+32), float64(len(closure.Args))))
+
+ copy(data, closure.Args[offset:l])
}
+ vm.Printf(" => 0x%x", data)
+
stack.Push(ethutil.BigD(data))
case CALLDATASIZE:
- stack.Push(big.NewInt(int64(len(closure.Args))))
+ l := int64(len(closure.Args))
+ stack.Push(big.NewInt(l))
+
+ vm.Printf(" => %d", l)
case CALLDATACOPY:
+ panic("not implemented")
case CODESIZE:
+ stack.Push(big.NewInt(int64(len(closure.Script))))
case CODECOPY:
var (
size = int64(len(closure.Script))
@@ -408,7 +465,7 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
case TIMESTAMP:
stack.Push(big.NewInt(vm.vars.Time))
case NUMBER:
- stack.Push(big.NewInt(int64(vm.vars.BlockNumber)))
+ stack.Push(vm.vars.BlockNumber)
case DIFFICULTY:
stack.Push(vm.vars.Diff)
case GASLIMIT:
@@ -426,12 +483,16 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
pc.Add(pc, a.Sub(a, big.NewInt(1)))
step += int(op) - int(PUSH1) + 1
+
+ vm.Printf(" => 0x%x", data.Bytes())
case POP:
require(1)
stack.Pop()
case DUP:
require(1)
stack.Push(stack.Peek())
+
+ vm.Printf(" => 0x%x", stack.Peek().Bytes())
case SWAP:
require(2)
x, y := stack.Popn()
@@ -446,38 +507,53 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
// Pop value of the stack
val, mStart := stack.Popn()
mem.Set(mStart.Int64(), 32, ethutil.BigToBytes(val, 256))
+
+ vm.Printf(" => 0x%x", val)
case MSTORE8:
require(2)
val, mStart := stack.Popn()
base.And(val, new(big.Int).SetInt64(0xff))
mem.Set(mStart.Int64(), 32, ethutil.BigToBytes(base, 256))
+
+ vm.Printf(" => 0x%x", val)
case SLOAD:
require(1)
loc := stack.Pop()
val := closure.GetMem(loc)
- //fmt.Println("get", val.BigInt(), "@", loc)
stack.Push(val.BigInt())
+
+ vm.Printf(" {} 0x%x", val)
case SSTORE:
require(2)
val, loc := stack.Popn()
- //fmt.Println("storing", val, "@", loc)
- closure.SetStorage(loc, ethutil.NewValue(val))
+
+ // FIXME This should be handled in the Trie it self
+ if val.Cmp(big.NewInt(0)) != 0 {
+ closure.SetStorage(loc, ethutil.NewValue(val))
+ }
// Add the change to manifest
vm.state.manifest.AddStorageChange(closure.Object(), loc.Bytes(), val)
+
+ vm.Printf(" {0x%x} 0x%x", loc, val)
case JUMP:
require(1)
pc = stack.Pop()
// Reduce pc by one because of the increment that's at the end of this for loop
- //pc.Sub(pc, ethutil.Big1)
+ vm.Printf(" ~> %v", pc).Endl()
+
continue
case JUMPI:
require(2)
cond, pos := stack.Popn()
- if cond.Cmp(ethutil.BigTrue) == 0 {
+ if cond.Cmp(ethutil.BigTrue) >= 0 {
pc = pos
- //pc.Sub(pc, ethutil.Big1)
+
+ vm.Printf(" ~> %v (t)", pc).Endl()
+
continue
+ } else {
+ vm.Printf(" (f)")
}
case PC:
stack.Push(pc)
@@ -494,7 +570,7 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
// Snapshot the current stack so we are able to
// revert back to it later.
- snapshot := vm.state.Snapshot()
+ snapshot := vm.state.Copy()
// Generate a new address
addr := ethutil.CreateAddress(closure.caller.Address(), closure.caller.N())
@@ -522,19 +598,18 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
stack.Push(ethutil.BigFalse)
// Revert the state as it was before.
- vm.state.Revert(snapshot)
+ vm.state.Set(snapshot)
} else {
stack.Push(ethutil.BigD(addr))
-
- vm.state.UpdateStateObject(contract)
}
case CALL:
- // TODO RE-WRITE
require(7)
- // Closure addr
- addr := stack.Pop()
+
+ vm.Endl()
+
+ gas := stack.Pop()
// Pop gas and value of the stack.
- gas, value := stack.Popn()
+ value, addr := stack.Popn()
// Pop input size and offset
inSize, inOffset := stack.Popn()
// Pop return size and offset
@@ -543,39 +618,34 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
// Get the arguments from the memory
args := mem.Get(inOffset.Int64(), inSize.Int64())
- snapshot := vm.state.Snapshot()
-
- closure.object.Nonce += 1
if closure.object.Amount.Cmp(value) < 0 {
ethutil.Config.Log.Debugf("Insufficient funds to transfer value. Req %v, has %v", value, closure.object.Amount)
stack.Push(ethutil.BigFalse)
} else {
- // Fetch the contract which will serve as the closure body
- contract := vm.state.GetStateObject(addr.Bytes())
-
- if contract != nil {
- // Add the value to the state object
- contract.AddAmount(value)
-
- // Create a new callable closure
- closure := NewClosure(closure, contract, contract.script, vm.state, gas, closure.Price)
- // Executer the closure and get the return value (if any)
- ret, _, err := closure.Call(vm, args, hook)
- if err != nil {
- stack.Push(ethutil.BigFalse)
- // Reset the changes applied this object
- vm.state.Revert(snapshot)
- } else {
- stack.Push(ethutil.BigTrue)
-
- vm.state.UpdateStateObject(contract)
-
- mem.Set(retOffset.Int64(), retSize.Int64(), ret)
- }
- } else {
- ethutil.Config.Log.Debugf("Contract %x not found\n", addr.Bytes())
+ snapshot := vm.state.Copy()
+
+ stateObject := vm.state.GetOrNewStateObject(addr.Bytes())
+
+ closure.object.SubAmount(value)
+ // Add the value to the state object
+ stateObject.AddAmount(value)
+
+ // Create a new callable closure
+ closure := NewClosure(closure, stateObject, stateObject.script, vm.state, gas, closure.Price)
+ // Executer the closure and get the return value (if any)
+ ret, _, err := closure.Call(vm, args, hook)
+ if err != nil {
stack.Push(ethutil.BigFalse)
+
+ ethutil.Config.Log.Debugf("Closure execution failed. %v\n", err)
+
+ vm.err = err
+ vm.state.Set(snapshot)
+ } else {
+ stack.Push(ethutil.BigTrue)
+
+ mem.Set(retOffset.Int64(), retSize.Int64(), ret)
}
}
case RETURN:
@@ -583,18 +653,24 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
size, offset := stack.Popn()
ret := mem.Get(offset.Int64(), size.Int64())
+ vm.Printf(" => (%d) 0x%x", len(ret), ret).Endl()
+
return closure.Return(ret), nil
case SUICIDE:
require(1)
receiver := vm.state.GetAccount(stack.Pop().Bytes())
receiver.AddAmount(closure.object.Amount)
- vm.state.UpdateStateObject(receiver)
- closure.object.state.Purge()
+ trie := closure.object.state.trie
+ trie.NewIterator().Each(func(key string, v *ethutil.Value) {
+ trie.Delete(key)
+ })
fallthrough
case STOP: // Stop the closure
+ vm.Printf(" (g) %v", closure.Gas).Endl()
+
return closure.Return(nil), nil
default:
ethutil.Config.Log.Debugf("Invalid opcode %x\n", op)
@@ -604,6 +680,8 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
pc.Add(pc, ethutil.Big1)
+ vm.Endl()
+
if hook != nil {
if !hook(prevStep, op, mem, stack, closure.Object()) {
return nil, nil
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-16 04:52:40 +0800