roysc/plugeth
1
0
Fork 0
forked from cerc-io/plugeth
Code Pull Requests Activity

Fixed remote Arithmetic tests

Browse Source
This commit is contained in:
obscuren 2014-10-15 17:12:26 +02:00
parent 266d212094
commit 311c6f8a3f
11 changed files with 187 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ethchain/state_transition.go
View File

@ -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)

9
ethstate/state.go
View File

@ -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
//

10
ethstate/state_object.go
View File

@ -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()
}

29
ethutil/big.go
View File

@ -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**

3
ethvm/common.go
View File

@ -35,7 +35,8 @@ var (
LogTyPretty byte = 0x1
LogTyDiff byte = 0x2
To256 = ethutil.To256
U256 = ethutil.U256
S256 = ethutil.S256
)
const MaxCallDepth = 1024

63
ethvm/vm.go
View File

@ -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)

115
ethvm/vm_debug.go
View File

@ -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)
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)
}
To256(base)
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)

11
tests/helper/http.go
View File

@ -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
}

5
tests/helper/init.go
View File

@ -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", "")
}

8
tests/helper/vm.go
View File

@ -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
}

27
tests/vm/gh_test.go
View File

@ -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)
}