diff --git a/ethchain/state_transition.go b/ethchain/state_transition.go
index 10159929b6af0cca1542ae343ee512870cdf6163..719e5fd66625bf05b9795f63797338557ac36d64 100644
--- a/ethchain/state_transition.go
+++ b/ethchain/state_transition.go
@@ -270,7 +270,8 @@ func (self *StateTransition) Eval(msg *ethstate.Message, script []byte, context
callerClosure = ethvm.NewClosure(msg, transactor, context, script, self.gas, self.gasPrice)
)
- vm := ethvm.New(env, ethvm.Type(ethutil.Config.VmType))
+ //vm := ethvm.New(env, ethvm.Type(ethutil.Config.VmType))
+ vm := ethutil.New(env, ethvm.DebugVmTy)
ret, _, err = callerClosure.Call(vm, self.tx.Data)
diff --git a/ethstate/state.go b/ethstate/state.go
index c2486849bc3d4f1a8bfb0c1584d6caed18141a95..b897b7ce37cf51873a9aaf959abefcefd326da39 100644
--- a/ethstate/state.go
+++ b/ethstate/state.go
@@ -57,6 +57,15 @@ func (self *State) GetCode(addr []byte) []byte {
return nil
}
+func (self *State) GetState(a, b []byte) []byte {
+ stateObject := self.GetStateObject(a)
+ if stateObject != nil {
+ return stateObject.GetState(b).Bytes()
+ }
+
+ return nil
+}
+
//
// Setting, updating & deleting state object methods
//
diff --git a/ethstate/state_object.go b/ethstate/state_object.go
index fe4c5f73bbe6351fd7b6a49fc13aa0b5660e9c80..4d2aae1a7a61b6fb26d003944473529b3d30cbb6 100644
--- a/ethstate/state_object.go
+++ b/ethstate/state_object.go
@@ -98,13 +98,13 @@ func (c *StateObject) SetAddr(addr []byte, value interface{}) {
}
func (self *StateObject) GetStorage(key *big.Int) *ethutil.Value {
- return self.getStorage(key.Bytes())
+ return self.GetState(key.Bytes())
}
func (self *StateObject) SetStorage(key *big.Int, value *ethutil.Value) {
- self.setStorage(key.Bytes(), value)
+ self.SetState(key.Bytes(), value)
}
-func (self *StateObject) getStorage(k []byte) *ethutil.Value {
+func (self *StateObject) GetState(k []byte) *ethutil.Value {
key := ethutil.LeftPadBytes(k, 32)
value := self.storage[string(key)]
@@ -117,11 +117,9 @@ func (self *StateObject) getStorage(k []byte) *ethutil.Value {
}
return value
-
- //return self.GetAddr(key)
}
-func (self *StateObject) setStorage(k []byte, value *ethutil.Value) {
+func (self *StateObject) SetState(k []byte, value *ethutil.Value) {
key := ethutil.LeftPadBytes(k, 32)
self.storage[string(key)] = value.Copy()
}
diff --git a/ethutil/big.go b/ethutil/big.go
index e23d8f6596bb03babcc2c5e9dcd5b511e89b735d..bdcf86421fc9fb1c7987a4f4417d732880ce7b6e 100644
--- a/ethutil/big.go
+++ b/ethutil/big.go
@@ -1,8 +1,8 @@
package ethutil
-import (
- "math/big"
-)
+import "math/big"
+
+var MaxInt256 *big.Int = BigD(Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"))
// Big pow
//
@@ -37,18 +37,29 @@ func BigD(data []byte) *big.Int {
// To256
//
// "cast" the big int to a 256 big int (i.e., limit to)
-var tt256 = new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(1))
+var tt256 = new(big.Int).Lsh(big.NewInt(1), 256)
+var tt256m1 = new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(1))
+var tt255 = new(big.Int).Lsh(big.NewInt(1), 255)
-func To256(x *big.Int) *big.Int {
- x.And(x, tt256)
+func U256(x *big.Int) *big.Int {
+ //if x.Cmp(Big0) < 0 {
+ // return new(big.Int).Add(tt256, x)
+ // }
- if x.Cmp(new(big.Int)) < 0 {
- x.SetInt64(0)
- }
+ x.And(x, tt256m1)
return x
}
+func S256(x *big.Int) *big.Int {
+ if x.Cmp(tt255) < 0 {
+ return x
+ } else {
+ // We don't want to modify x, ever
+ return new(big.Int).Sub(x, tt256)
+ }
+}
+
// Big to bytes
//
// Returns the bytes of a big integer with the size specified by **base**
diff --git a/ethvm/common.go b/ethvm/common.go
index 6854a52197400520f7664441360cb4ed525ebdaf..617a8279fd1453bba79ff750d009571c7efbdd55 100644
--- a/ethvm/common.go
+++ b/ethvm/common.go
@@ -35,7 +35,8 @@ var (
LogTyPretty byte = 0x1
LogTyDiff byte = 0x2
- To256 = ethutil.To256
+ U256 = ethutil.U256
+ S256 = ethutil.S256
)
const MaxCallDepth = 1024
diff --git a/ethvm/vm.go b/ethvm/vm.go
index dad031e0170551e62052ab6321d32f9c6b22a73a..4df98328e42cda9af6af55b898a81eecf378a723 100644
--- a/ethvm/vm.go
+++ b/ethvm/vm.go
@@ -8,6 +8,9 @@ import (
"github.com/ethereum/eth-go/ethutil"
)
+// BIG FAT WARNING. THIS VM IS NOT YET IS USE!
+// I want to get all VM tests pass first before updating this VM
+
type Vm struct {
env Environment
err error
@@ -170,7 +173,7 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Add(y, x)
- To256(base)
+ U256(base)
// Pop result back on the stack
stack.Push(base)
@@ -180,7 +183,7 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Sub(y, x)
- To256(base)
+ U256(base)
// Pop result back on the stack
stack.Push(base)
@@ -190,7 +193,7 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Mul(y, x)
- To256(base)
+ U256(base)
// Pop result back on the stack
stack.Push(base)
@@ -202,21 +205,29 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Div(y, x)
}
- To256(base)
+ U256(base)
// Pop result back on the stack
stack.Push(base)
case SDIV:
require(2)
- x, y := stack.Popn()
+ y, x := S256(stack.Pop()), S256(stack.Pop())
- if x.Cmp(ethutil.Big0) != 0 {
- base.Div(y, x)
- }
+ if x.Cmp(ethutil.Big0) == 0 {
+ base.Set(ethutil.Big0)
+ } else {
+ n := new(big.Int)
+ if new(big.Int).Mul(y, x).Cmp(ethutil.Big0) < 0 {
+ n.SetInt64(-1)
+ } else {
+ n.SetInt64(1)
+ }
- To256(base)
+ base.Div(y.Abs(y), x.Mul(x.Abs(x), n))
+
+ U256(base)
+ }
- // Pop result back on the stack
stack.Push(base)
case MOD:
require(2)
@@ -224,16 +235,27 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Mod(y, x)
- To256(base)
+ U256(base)
stack.Push(base)
case SMOD:
require(2)
- x, y := stack.Popn()
+ y, x := S256(stack.Pop()), S256(stack.Pop())
- base.Mod(y, x)
+ if x.Cmp(ethutil.Big0) == 0 {
+ base.Set(ethutil.Big0)
+ } else {
+ n := new(big.Int)
+ if y.Cmp(ethutil.Big0) < 0 {
+ n.SetInt64(-1)
+ } else {
+ n.SetInt64(1)
+ }
- To256(base)
+ base.Mod(y.Abs(y), x.Mul(x.Abs(x), n))
+
+ U256(base)
+ }
stack.Push(base)
@@ -243,12 +265,15 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Exp(y, x, Pow256)
- To256(base)
+ U256(base)
stack.Push(base)
case NEG:
require(1)
base.Sub(Pow256, stack.Pop())
+
+ base = U256(base)
+
stack.Push(base)
case LT:
require(2)
@@ -272,16 +297,16 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
case SLT:
require(2)
- x, y := stack.Popn()
+ y, x := S256(stack.Pop()), S256(stack.Pop())
// x < y
- if y.Cmp(x) < 0 {
+ if y.Cmp(S256(x)) < 0 {
stack.Push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
}
case SGT:
require(2)
- x, y := stack.Popn()
+ y, x := S256(stack.Pop()), S256(stack.Pop())
// x > y
if y.Cmp(x) > 0 {
@@ -345,7 +370,7 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Add(x, y)
base.Mod(base, z)
- To256(base)
+ U256(base)
stack.Push(base)
case MULMOD:
@@ -358,7 +383,7 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Mul(x, y)
base.Mod(base, z)
- To256(base)
+ U256(base)
stack.Push(base)
diff --git a/ethvm/vm_debug.go b/ethvm/vm_debug.go
index df8cbb10c326bd1fea42a0ca0933e09b23b9f711..d3d3d7696391e7e31f97ae94c8519d30b0e6651b 100644
--- a/ethvm/vm_debug.go
+++ b/ethvm/vm_debug.go
@@ -40,10 +40,27 @@ func NewDebugVm(env Environment) *DebugVm {
func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
self.depth++
+ var (
+ op OpCode
+
+ mem = &Memory{}
+ stack = NewStack()
+ pc = big.NewInt(0)
+ step = 0
+ prevStep = 0
+ require = func(m int) {
+ if stack.Len() < m {
+ panic(fmt.Sprintf("%04v (%v) stack err size = %d, required = %d", pc, op, stack.Len(), m))
+ }
+ }
+ )
+
if self.Recoverable {
// Recover from any require exception
defer func() {
if r := recover(); r != nil {
+ self.Endl()
+
ret = closure.Return(nil)
err = fmt.Errorf("%v", r)
}
@@ -62,21 +79,6 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
vmlogger.Debugf("(%s) %x gas: %v (d) %x\n", self.Fn, closure.Address(), closure.Gas, closure.Args)
- var (
- op OpCode
-
- mem = &Memory{}
- stack = NewStack()
- pc = big.NewInt(0)
- step = 0
- prevStep = 0
- require = func(m int) {
- if stack.Len() < m {
- panic(fmt.Sprintf("%04v (%v) stack err size = %d, required = %d", pc, op, stack.Len(), m))
- }
- }
- )
-
for {
prevStep = step
// The base for all big integer arithmetic
@@ -223,7 +225,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Add(y, x)
- To256(base)
+ U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
@@ -235,7 +237,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Sub(y, x)
- To256(base)
+ U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
@@ -247,60 +249,84 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Mul(y, x)
- To256(base)
+ U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case DIV:
require(2)
- x, y := stack.Popn()
- self.Printf(" %v / %v", y, x)
+ x, y := stack.Pop(), stack.Pop()
+ self.Printf(" %v / %v", x, y)
- if x.Cmp(ethutil.Big0) != 0 {
- base.Div(y, x)
+ if y.Cmp(ethutil.Big0) != 0 {
+ base.Div(x, y)
}
- To256(base)
+ U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case SDIV:
require(2)
- x, y := stack.Popn()
- self.Printf(" %v / %v", y, x)
+ x, y := S256(stack.Pop()), S256(stack.Pop())
- if x.Cmp(ethutil.Big0) != 0 {
- base.Div(y, x)
- }
+ self.Printf(" %v / %v", x, y)
- To256(base)
+ if y.Cmp(ethutil.Big0) == 0 {
+ base.Set(ethutil.Big0)
+ } else {
+ n := new(big.Int)
+ if new(big.Int).Mul(x, y).Cmp(ethutil.Big0) < 0 {
+ n.SetInt64(-1)
+ } else {
+ n.SetInt64(1)
+ }
+
+ base.Div(x.Abs(x), y.Abs(y)).Mul(base, n)
+
+ U256(base)
+ }
self.Printf(" = %v", base)
- // Pop result back on the stack
stack.Push(base)
case MOD:
require(2)
- x, y := stack.Popn()
+ x, y := stack.Pop(), stack.Pop()
- self.Printf(" %v %% %v", y, x)
+ self.Printf(" %v %% %v", x, y)
- base.Mod(y, x)
+ if y.Cmp(ethutil.Big0) == 0 {
+ base.Set(ethutil.Big0)
+ } else {
+ base.Mod(x, y)
+ }
- To256(base)
+ U256(base)
self.Printf(" = %v", base)
stack.Push(base)
case SMOD:
require(2)
- x, y := stack.Popn()
+ x, y := S256(stack.Pop()), S256(stack.Pop())
- self.Printf(" %v %% %v", y, x)
+ self.Printf(" %v %% %v", x, y)
- base.Mod(y, x)
+ if y.Cmp(ethutil.Big0) == 0 {
+ base.Set(ethutil.Big0)
+ } else {
+ n := new(big.Int)
+ if x.Cmp(ethutil.Big0) < 0 {
+ n.SetInt64(-1)
+ } else {
+ n.SetInt64(1)
+ }
- To256(base)
+ base.Mod(x.Abs(x), y.Abs(y)).Mul(base, n)
+
+ U256(base)
+ }
self.Printf(" = %v", base)
stack.Push(base)
@@ -313,7 +339,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Exp(y, x, Pow256)
- To256(base)
+ U256(base)
self.Printf(" = %v", base)
@@ -321,6 +347,9 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
case NEG:
require(1)
base.Sub(Pow256, stack.Pop())
+
+ base = U256(base)
+
stack.Push(base)
case LT:
require(2)
@@ -346,17 +375,17 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
case SLT:
require(2)
- x, y := stack.Popn()
+ y, x := S256(stack.Pop()), S256(stack.Pop())
self.Printf(" %v < %v", y, x)
// x < y
- if y.Cmp(x) < 0 {
+ if y.Cmp(S256(x)) < 0 {
stack.Push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
}
case SGT:
require(2)
- x, y := stack.Popn()
+ y, x := S256(stack.Pop()), S256(stack.Pop())
self.Printf(" %v > %v", y, x)
// x > y
@@ -426,7 +455,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Add(x, y)
base.Mod(base, z)
- To256(base)
+ U256(base)
self.Printf(" = %v", base)
@@ -441,7 +470,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
base.Mul(x, y)
base.Mod(base, z)
- To256(base)
+ U256(base)
self.Printf(" = %v", base)
diff --git a/tests/helper/http.go b/tests/helper/http.go
index b379695d03e168418ac2c30f8c28265ed9d2a749..3c570d10686b6dd5128fb5d9413ba96f22511b24 100644
--- a/tests/helper/http.go
+++ b/tests/helper/http.go
@@ -4,12 +4,15 @@ import (
"encoding/json"
"io/ioutil"
"net/http"
+ "testing"
)
-func CreateTests(uri string, value interface{}) error {
+func CreateTests(t *testing.T, uri string, value interface{}) {
resp, err := http.Get(uri)
if err != nil {
- panic(err)
+ t.Error(err)
+
+ return
}
defer resp.Body.Close()
@@ -17,8 +20,6 @@ func CreateTests(uri string, value interface{}) error {
err = json.Unmarshal(data, &value)
if err != nil {
- return err
+ t.Error(err)
}
-
- return nil
}
diff --git a/tests/helper/init.go b/tests/helper/init.go
index 1f2ee208abc5f252b5308d88e4fff1ad5406e38a..5f95dfc2fd1643fca712975fa77006e946bd77be 100644
--- a/tests/helper/init.go
+++ b/tests/helper/init.go
@@ -8,8 +8,11 @@ import (
"github.com/ethereum/eth-go/ethutil"
)
+var Logger ethlog.LogSystem
+
func init() {
- ethlog.AddLogSystem(ethlog.NewStdLogSystem(os.Stdout, log.LstdFlags, ethlog.LogLevel(4)))
+ Logger = ethlog.NewStdLogSystem(os.Stdout, log.LstdFlags, ethlog.LogLevel(4))
+ ethlog.AddLogSystem(Logger)
ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
}
diff --git a/tests/helper/vm.go b/tests/helper/vm.go
index 49a0bfeae9f497a1dedd9ef10d93dd1085432513..44eb8fda1ea4824adf0f7319298d515bc7c2a2c1 100644
--- a/tests/helper/vm.go
+++ b/tests/helper/vm.go
@@ -1,7 +1,6 @@
package helper
import (
- "fmt"
"math/big"
"github.com/ethereum/eth-go/ethstate"
@@ -51,16 +50,13 @@ func (self *Env) BlockHash() []byte { return nil }
// This is likely to fail if anything ever gets looked up in the state trie :-)
func (self *Env) State() *ethstate.State { return ethstate.New(ethtrie.New(nil, "")) }
-func RunVm(state *ethstate.State, env, exec map[string]string) ([]byte, *big.Int) {
+func RunVm(state *ethstate.State, env, exec map[string]string) ([]byte, *big.Int, error) {
caller := state.NewStateObject(ethutil.Hex2Bytes(exec["caller"]))
callee := state.GetStateObject(ethutil.Hex2Bytes(exec["address"]))
closure := ethvm.NewClosure(nil, caller, callee, callee.Code, ethutil.Big(exec["gas"]), ethutil.Big(exec["gasPrice"]))
vm := ethvm.New(NewEnvFromMap(state, env, exec), ethvm.DebugVmTy)
ret, _, e := closure.Call(vm, nil)
- if e != nil {
- fmt.Println(e)
- }
- return ret, closure.Gas
+ return ret, closure.Gas, e
}
diff --git a/tests/vm/gh_test.go b/tests/vm/gh_test.go
index ac8d47fe62891f3711baed92b572c2de266bb2ad..067b1fe8ee6ff2f5eef2f1abedc290fb505ad7e9 100644
--- a/tests/vm/gh_test.go
+++ b/tests/vm/gh_test.go
@@ -2,7 +2,6 @@ package ethvm
import (
"bytes"
- "log"
"testing"
"github.com/ethereum/eth-go/ethstate"
@@ -40,12 +39,9 @@ type VmTest struct {
Pre map[string]Account
}
-func TestRemote(t *testing.T) {
+func RunVmTest(url string, t *testing.T) {
tests := make(map[string]VmTest)
- err := helper.CreateTests("https://raw.githubusercontent.com/ethereum/tests/master/vmtests/vmSha3Test.json", &tests)
- if err != nil {
- log.Fatal(err)
- }
+ helper.CreateTests(t, url, &tests)
for name, test := range tests {
state := ethstate.New(helper.NewTrie())
@@ -54,7 +50,10 @@ func TestRemote(t *testing.T) {
state.SetStateObject(obj)
}
- ret, gas := helper.RunVm(state, test.Env, test.Exec)
+ ret, gas, err := helper.RunVm(state, test.Env, test.Exec)
+ if err != nil {
+ t.Errorf("%s's execution failed. %v\n", name, err)
+ }
rexp := helper.FromHex(test.Out)
if bytes.Compare(rexp, ret) != 0 {
@@ -79,3 +78,17 @@ func TestRemote(t *testing.T) {
}
}
}
+
+// I've created a new function for each tests so it's easier to identify where the problem lies if any of them fail.
+func TestVMSha3(t *testing.T) {
+ helper.Logger.SetLogLevel(0)
+ defer helper.Logger.SetLogLevel(4)
+
+ const url = "https://raw.githubusercontent.com/ethereum/tests/master/vmtests/vmSha3Test.json"
+ RunVmTest(url, t)
+}
+
+func TestVMArithmetic(t *testing.T) {
+ const url = "https://raw.githubusercontent.com/ethereum/tests/master/vmtests/vmArithmeticTest.json"
+ RunVmTest(url, t)
+}