diff --git a/core/chain_manager.go b/core/chain_manager.go
index f9fb3b3f827c7104c97c99750ec0e24319654391..a4ff5cb5cc3548e0a2b799d3d429e28e6ade89de 100644
--- a/core/chain_manager.go
+++ b/core/chain_manager.go
@@ -152,6 +152,16 @@ func (bc *ChainManager) Reset() {
bc.TD = ethutil.BigD(ethutil.Config.Db.LastKnownTD())
}
+func (self *ChainManager) Export() []byte {
+ chainlogger.Infoln("exporting", self.CurrentBlock.Number, "blocks")
+
+ blocks := make(types.Blocks, int(self.CurrentBlock.Number.Int64())+1)
+ for block := self.CurrentBlock; block != nil; block = self.GetBlock(block.PrevHash) {
+ blocks[block.Number.Int64()] = block
+ }
+ return ethutil.Encode(blocks)
+}
+
func (bc *ChainManager) insert(block *types.Block) {
encodedBlock := block.RlpEncode()
ethutil.Config.Db.Put([]byte("LastBlock"), encodedBlock)
@@ -185,7 +195,6 @@ func (self *ChainManager) GetBlockHashesFromHash(hash []byte, max uint64) (chain
// XXX Could be optimised by using a different database which only holds hashes (i.e., linked list)
for i := uint64(0); i < max; i++ {
-
chain = append(chain, block.Hash())
if block.Number.Cmp(ethutil.Big0) <= 0 {
diff --git a/core/chain_manager_test.go b/core/chain_manager_test.go
index 9a8bc9592b0bcef7115b5159d4f426ba4fbd39f8..a84e3ff3b9dcc9b9a9652aff6b149094f74ac5af 100644
--- a/core/chain_manager_test.go
+++ b/core/chain_manager_test.go
@@ -1 +1,19 @@
package core
+
+import (
+ "fmt"
+ "path"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+func TestChainInsertions(t *testing.T) {
+ c1, err := ethutil.ReadAllFile(path.Join("..", "_data", "chain1"))
+ if err != nil {
+ fmt.Println(err)
+ t.FailNow()
+ }
+ data1, _ := ethutil.Decode([]byte(c1), 0)
+ fmt.Println(data1)
+}
diff --git a/core/execution.go b/core/execution.go
index a464abc66a5f17124ac29bdd60d98b9802f59794..827e1ee0ede5b74c4025eb6ba06f0ae73bd668d1 100644
--- a/core/execution.go
+++ b/core/execution.go
@@ -4,7 +4,6 @@ import (
"fmt"
"math/big"
- "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/vm"
)
@@ -36,38 +35,33 @@ func (self *Execution) exec(code, contextAddr []byte, caller vm.ClosureRef) (ret
env := self.vm.Env()
chainlogger.Debugf("pre state %x\n", env.State().Root())
+ if self.vm.Env().Depth() == vm.MaxCallDepth {
+ // Consume all gas (by not returning it) and return a depth error
+ return nil, vm.DepthError{}
+ }
+
from, to := env.State().GetStateObject(caller.Address()), env.State().GetOrNewStateObject(self.address)
// Skipping transfer is used on testing for the initial call
if !self.SkipTransfer {
err = env.Transfer(from, to, self.value)
+ if err != nil {
+ caller.ReturnGas(self.Gas, self.price)
+
+ err = fmt.Errorf("Insufficient funds to transfer value. Req %v, has %v", self.value, from.Balance)
+ return
+ }
}
snapshot := env.State().Copy()
defer func() {
- if vm.IsDepthErr(err) || vm.IsOOGErr(err) {
+ if /*vm.IsDepthErr(err) ||*/ vm.IsOOGErr(err) {
env.State().Set(snapshot)
}
chainlogger.Debugf("post state %x\n", env.State().Root())
}()
- if err != nil {
- caller.ReturnGas(self.Gas, self.price)
-
- err = fmt.Errorf("Insufficient funds to transfer value. Req %v, has %v", self.value, from.Balance)
- } else {
- self.object = to
- // Pre-compiled contracts (address.go) 1, 2 & 3.
- naddr := ethutil.BigD(contextAddr).Uint64()
- if p := vm.Precompiled[naddr]; p != nil {
- if self.Gas.Cmp(p.Gas(len(self.input))) >= 0 {
- ret = p.Call(self.input)
- self.vm.Printf("NATIVE_FUNC(%x) => %x", naddr, ret)
- self.vm.Endl()
- }
- } else {
- ret, err = self.vm.Run(to, caller, code, self.value, self.Gas, self.price, self.input)
- }
- }
+ self.object = to
+ ret, err = self.vm.Run(to, caller, code, self.value, self.Gas, self.price, self.input)
return
}
diff --git a/ethutil/rlp.go b/ethutil/rlp.go
index 1fff2b28a6a5b7f81037e0d0595290454ab05daf..157dd4dd9f3a335d9124febd141dcdba140283f1 100644
--- a/ethutil/rlp.go
+++ b/ethutil/rlp.go
@@ -2,8 +2,10 @@ package ethutil
import (
"bytes"
+ "encoding/binary"
"fmt"
"math/big"
+ "reflect"
)
type RlpEncode interface {
@@ -97,6 +99,14 @@ var (
zeroRlp = big.NewInt(0x0)
)
+func intlen(i int64) (length int) {
+ for i > 0 {
+ i = i >> 8
+ length++
+ }
+ return
+}
+
func Encode(object interface{}) []byte {
var buff bytes.Buffer
@@ -168,6 +178,26 @@ func Encode(object interface{}) []byte {
}
WriteSliceHeader(len(b.Bytes()))
buff.Write(b.Bytes())
+ default:
+ // This is how it should have been from the start
+ // needs refactoring (@fjl)
+ v := reflect.ValueOf(t)
+ switch v.Kind() {
+ case reflect.Slice:
+ var b bytes.Buffer
+ for i := 0; i < v.Len(); i++ {
+ b.Write(Encode(v.Index(i).Interface()))
+ }
+
+ blen := b.Len()
+ if blen < 56 {
+ buff.WriteByte(byte(blen) + 0xc0)
+ } else {
+ buff.WriteByte(byte(intlen(int64(blen))) + 0xf7)
+ binary.Write(&buff, binary.BigEndian, int64(blen))
+ }
+ buff.ReadFrom(&b)
+ }
}
} else {
// Empty list for nil
diff --git a/ethutil/rlp_test.go b/ethutil/rlp_test.go
index 90057ab42d5f3b32db47ebde8c01eb427872f09d..ff98d3269957da110c538ea54398a86495eacf1f 100644
--- a/ethutil/rlp_test.go
+++ b/ethutil/rlp_test.go
@@ -7,6 +7,16 @@ import (
"testing"
)
+func TestNonInterfaceSlice(t *testing.T) {
+ vala := []string{"value1", "value2", "value3"}
+ valb := []interface{}{"value1", "value2", "value3"}
+ resa := Encode(vala)
+ resb := Encode(valb)
+ if !bytes.Equal(resa, resb) {
+ t.Errorf("expected []string & []interface{} to be equal")
+ }
+}
+
func TestRlpValueEncoding(t *testing.T) {
val := EmptyValue()
val.AppendList().Append(1).Append(2).Append(3)
diff --git a/javascript/javascript_runtime.go b/javascript/javascript_runtime.go
index 169ed509e6175cddbaca06c4c13aee13d0267105..af1405049f30234b7564f59c6c3e28d539fbefc7 100644
--- a/javascript/javascript_runtime.go
+++ b/javascript/javascript_runtime.go
@@ -121,6 +121,7 @@ func (self *JSRE) initStdFuncs() {
eth.Set("startMining", self.startMining)
eth.Set("execBlock", self.execBlock)
eth.Set("dump", self.dump)
+ eth.Set("export", self.export)
}
/*
@@ -236,3 +237,20 @@ func (self *JSRE) execBlock(call otto.FunctionCall) otto.Value {
return otto.TrueValue()
}
+
+func (self *JSRE) export(call otto.FunctionCall) otto.Value {
+ fn, err := call.Argument(0).ToString()
+ if err != nil {
+ fmt.Println(err)
+ return otto.FalseValue()
+ }
+
+ data := self.ethereum.ChainManager().Export()
+
+ if err := ethutil.WriteFile(fn, data); err != nil {
+ fmt.Println(err)
+ return otto.FalseValue()
+ }
+
+ return otto.TrueValue()
+}
diff --git a/vm/address.go b/vm/address.go
index be8921a3b1c243129a6afe729caa50c3b38d9ff2..611979c94137d0b21b35a15c01574878d455265a 100644
--- a/vm/address.go
+++ b/vm/address.go
@@ -11,25 +11,25 @@ type Address interface {
Call(in []byte) []byte
}
-type PrecompiledAddress struct {
+type PrecompiledAccount struct {
Gas func(l int) *big.Int
fn func(in []byte) []byte
}
-func (self PrecompiledAddress) Call(in []byte) []byte {
+func (self PrecompiledAccount) Call(in []byte) []byte {
return self.fn(in)
}
-var Precompiled = map[uint64]*PrecompiledAddress{
- 1: &PrecompiledAddress{func(l int) *big.Int {
+var Precompiled = map[string]*PrecompiledAccount{
+ string(ethutil.LeftPadBytes([]byte{1}, 20)): &PrecompiledAccount{func(l int) *big.Int {
return GasEcrecover
}, ecrecoverFunc},
- 2: &PrecompiledAddress{func(l int) *big.Int {
+ string(ethutil.LeftPadBytes([]byte{2}, 20)): &PrecompiledAccount{func(l int) *big.Int {
n := big.NewInt(int64(l+31)/32 + 1)
n.Mul(n, GasSha256)
return n
}, sha256Func},
- 3: &PrecompiledAddress{func(l int) *big.Int {
+ string(ethutil.LeftPadBytes([]byte{3}, 20)): &PrecompiledAccount{func(l int) *big.Int {
n := big.NewInt(int64(l+31)/32 + 1)
n.Mul(n, GasRipemd)
return n
diff --git a/vm/common.go b/vm/common.go
index 592d44ccd33f6758d7270702d996be3b0129f679..3d6d377ca6527f38969df927627cdb08cfb32dcf 100644
--- a/vm/common.go
+++ b/vm/common.go
@@ -48,7 +48,7 @@ var (
S256 = ethutil.S256
)
-const MaxCallDepth = 1025
+const MaxCallDepth = 1024
func calcMemSize(off, l *big.Int) *big.Int {
if l.Cmp(ethutil.Big0) == 0 {
diff --git a/vm/vm_debug.go b/vm/vm_debug.go
index 8af1979b19295f206cc8380b98ffc3141f79935c..9da832a792efd00ebfffb8780292f29c5701edcf 100644
--- a/vm/vm_debug.go
+++ b/vm/vm_debug.go
@@ -48,9 +48,8 @@ func (self *DebugVm) Run(me, caller ClosureRef, code []byte, value, gas, price *
})
closure := NewClosure(msg, caller, me, code, gas, price)
- if self.env.Depth() == MaxCallDepth {
- //closure.UseGas(gas)
- return closure.Return(nil), DepthError{}
+ if p := Precompiled[string(me.Address())]; p != nil {
+ return self.RunPrecompiled(p, callData, closure)
}
if self.Recoverable {
@@ -941,6 +940,25 @@ func (self *DebugVm) Run(me, caller ClosureRef, code []byte, value, gas, price *
}
}
+func (self *DebugVm) RunPrecompiled(p *PrecompiledAccount, callData []byte, closure *Closure) (ret []byte, err error) {
+ gas := p.Gas(len(callData))
+ if closure.UseGas(gas) {
+ ret = p.Call(callData)
+ self.Printf("NATIVE_FUNC => %x", ret)
+ self.Endl()
+
+ return closure.Return(ret), nil
+ } else {
+ self.Endl()
+
+ tmp := new(big.Int).Set(closure.Gas)
+
+ closure.UseGas(closure.Gas)
+
+ return closure.Return(nil), OOG(gas, tmp)
+ }
+}
+
func (self *DebugVm) Printf(format string, v ...interface{}) VirtualMachine {
if self.logTy == LogTyPretty {
self.logStr += fmt.Sprintf(format, v...)