moved err check

Author: obscuren

core/chain_manager.go

@@ -148,6 +148,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)
@@ -181,7 +191,6 @@ func (self *ChainManager) GetChainHashesFromHash(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 {

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

core/execution.go

@@ -40,6 +40,12 @@ func (self *Execution) exec(code, contextAddr []byte, caller vm.ClosureRef) (ret
 	// 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()
@@ -50,23 +56,17 @@ func (self *Execution) exec(code, contextAddr []byte, caller vm.ClosureRef) (ret
 		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
+	// 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)
 	}
 
 	return

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

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)

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