From 6d99c03d915789c445c2d40579419a16fde2b7c8 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 3 Dec 2014 17:22:26 +0100 Subject: [PATCH] Updated environments according to the new interface set --- cmd/mist/debugger.go | 20 ++++++++++++-------- cmd/utils/vm_env.go | 34 +++++++++++++++++++++++++++++++++- xeth/pipe.go | 17 +++++++++-------- xeth/vm_env.go | 30 +++++++++++++++++++++++++++++- 4 files changed, 83 insertions(+), 18 deletions(-) diff --git a/cmd/mist/debugger.go b/cmd/mist/debugger.go index a2aae6f0b2..8331b55660 100644 --- a/cmd/mist/debugger.go +++ b/cmd/mist/debugger.go @@ -144,24 +144,28 @@ func (self *DebuggerWindow) Debug(valueStr, gasStr, gasPriceStr, scriptStr, data statedb := self.lib.eth.BlockManager().TransState() account := self.lib.eth.BlockManager().TransState().GetAccount(keyPair.Address()) contract := statedb.NewStateObject([]byte{0}) + contract.SetCode(script) contract.SetBalance(value) self.SetAsm(script) block := self.lib.eth.ChainManager().CurrentBlock - callerClosure := vm.NewClosure(&state.Message{}, account, contract, script, gas, gasPrice) env := utils.NewEnv(statedb, block, account.Address(), value) - evm := vm.NewDebugVm(env) - evm.Dbg = self.Db + /* + callerClosure := vm.NewClosure(&state.Message{}, account, contract, script, gas, gasPrice) + evm := vm.NewDebugVm(env) + evm.Dbg = self.Db + self.vm = evm + self.Db.done = false + */ - self.vm = evm - self.Db.done = false self.Logf("callsize %d", len(script)) go func() { - ret, g, err := callerClosure.Call(evm, data) - tot := new(big.Int).Mul(g, gasPrice) - self.Logf("gas usage %v total price = %v (%v)", g, tot, ethutil.CurrencyToString(tot)) + ret, err := env.Call(account, contract.Address(), data, gas, gasPrice, ethutil.Big0) + //ret, g, err := callerClosure.Call(evm, data) + tot := new(big.Int).Mul(env.Gas, gasPrice) + self.Logf("gas usage %v total price = %v (%v)", env.Gas, tot, ethutil.CurrencyToString(tot)) if err != nil { self.Logln("exited with errors:", err) } else { diff --git a/cmd/utils/vm_env.go b/cmd/utils/vm_env.go index b2788efa1c..c8744076e3 100644 --- a/cmd/utils/vm_env.go +++ b/cmd/utils/vm_env.go @@ -2,6 +2,8 @@ package utils import ( "math/big" + + "github.com/ethereum/go-ethereum/chain" "github.com/ethereum/go-ethereum/chain/types" "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/vm" @@ -13,6 +15,9 @@ type VMEnv struct { transactor []byte value *big.Int + + depth int + Gas *big.Int } func NewEnv(state *state.State, block *types.Block, transactor []byte, value *big.Int) *VMEnv { @@ -34,7 +39,34 @@ func (self *VMEnv) BlockHash() []byte { return self.block.Hash() } func (self *VMEnv) Value() *big.Int { return self.value } func (self *VMEnv) State() *state.State { return self.state } func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit } -func (self *VMEnv) AddLog(*state.Log) {} +func (self *VMEnv) Depth() int { return self.depth } +func (self *VMEnv) SetDepth(i int) { self.depth = i } +func (self *VMEnv) AddLog(log *state.Log) { + self.state.AddLog(log) +} func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error { return vm.Transfer(from, to, amount) } + +func (self *VMEnv) vm(addr, data []byte, gas, price, value *big.Int) *chain.Execution { + evm := vm.New(self, vm.DebugVmTy) + + return chain.NewExecution(evm, addr, data, gas, price, value) +} + +func (self *VMEnv) Call(caller vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) { + exe := self.vm(addr, data, gas, price, value) + ret, err := exe.Call(addr, caller) + self.Gas = exe.Gas + + return ret, err +} +func (self *VMEnv) CallCode(caller vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) { + exe := self.vm(caller.Address(), data, gas, price, value) + return exe.Call(addr, caller) +} + +func (self *VMEnv) Create(caller vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ClosureRef) { + exe := self.vm(addr, data, gas, price, value) + return exe.Create(caller) +} diff --git a/xeth/pipe.go b/xeth/pipe.go index c96c6efc0a..2dfb91b7f7 100644 --- a/xeth/pipe.go +++ b/xeth/pipe.go @@ -5,15 +5,12 @@ package xeth */ import ( - "fmt" - "github.com/ethereum/go-ethereum/chain" "github.com/ethereum/go-ethereum/chain/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/state" - "github.com/ethereum/go-ethereum/vm" ) var pipelogger = logger.NewLogger("XETH") @@ -62,14 +59,18 @@ func (self *XEth) ExecuteObject(object *Object, data []byte, value, gas, price * self.Vm.State = self.World().State().Copy() - evm := vm.New(NewEnv(self.Vm.State, block, value.BigInt(), initiator.Address()), vm.Type(ethutil.Config.VmType)) + vmenv := NewEnv(self.Vm.State, block, value.BigInt(), initiator.Address()) + return vmenv.Call(initiator, object.Address(), data, gas.BigInt(), price.BigInt(), value.BigInt()) + /* + evm := vm.New(, vm.Type(ethutil.Config.VmType)) - msg := vm.NewExecution(evm, object.Address(), data, gas.BigInt(), price.BigInt(), value.BigInt()) - ret, err := msg.Exec(object.Address(), initiator) + msg := vm.NewExecution(evm, object.Address(), data, gas.BigInt(), price.BigInt(), value.BigInt()) + ret, err := msg.Exec(object.Address(), initiator) - fmt.Println("returned from call", ret, err) + fmt.Println("returned from call", ret, err) - return ret, err + return ret, err + */ } func (self *XEth) Block(hash []byte) *types.Block { diff --git a/xeth/vm_env.go b/xeth/vm_env.go index 10575ad798..d114596266 100644 --- a/xeth/vm_env.go +++ b/xeth/vm_env.go @@ -2,6 +2,8 @@ package xeth import ( "math/big" + + "github.com/ethereum/go-ethereum/chain" "github.com/ethereum/go-ethereum/chain/types" "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/vm" @@ -12,6 +14,8 @@ type VMEnv struct { block *types.Block value *big.Int sender []byte + + depth int } func NewEnv(state *state.State, block *types.Block, value *big.Int, sender []byte) *VMEnv { @@ -33,7 +37,31 @@ func (self *VMEnv) BlockHash() []byte { return self.block.Hash() } func (self *VMEnv) Value() *big.Int { return self.value } func (self *VMEnv) State() *state.State { return self.state } func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit } -func (self *VMEnv) AddLog(*state.Log) {} +func (self *VMEnv) Depth() int { return self.depth } +func (self *VMEnv) SetDepth(i int) { self.depth = i } +func (self *VMEnv) AddLog(log *state.Log) { + self.state.AddLog(log) +} func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error { return vm.Transfer(from, to, amount) } + +func (self *VMEnv) vm(addr, data []byte, gas, price, value *big.Int) *chain.Execution { + evm := vm.New(self, vm.DebugVmTy) + + return chain.NewExecution(evm, addr, data, gas, price, value) +} + +func (self *VMEnv) Call(me vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) { + exe := self.vm(addr, data, gas, price, value) + return exe.Call(addr, me) +} +func (self *VMEnv) CallCode(me vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) { + exe := self.vm(me.Address(), data, gas, price, value) + return exe.Call(addr, me) +} + +func (self *VMEnv) Create(me vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ClosureRef) { + exe := self.vm(addr, data, gas, price, value) + return exe.Create(me) +}