merge upstream

7 files changed, 611 insertions, 0 deletions

diff --git a/ethereum/repl/javascript_runtime.go b/ethereum/repl/javascript_runtime.go
new file mode 100644
index 000000000..091e758e1
--- /dev/null
+++ b/ethereum/repl/javascript_runtime.go
@@ -0,0 +1,232 @@
+package ethrepl
+
+import (
+	"fmt"
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethpub"
+	"github.com/ethereum/eth-go/ethreact"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/go-ethereum/utils"
+	"github.com/obscuren/otto"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+)
+
+var jsrelogger = ethlog.NewLogger("JSRE")
+
+type JSRE struct {
+	ethereum *eth.Ethereum
+	vm       *otto.Otto
+	lib      *ethpub.PEthereum
+
+	blockChan  chan ethreact.Event
+	changeChan chan ethreact.Event
+	quitChan   chan bool
+
+	objectCb map[string][]otto.Value
+}
+
+func (jsre *JSRE) LoadExtFile(path string) {
+	result, err := ioutil.ReadFile(path)
+	if err == nil {
+		jsre.vm.Run(result)
+	} else {
+		jsrelogger.Debugln("Could not load file:", path)
+	}
+}
+
+func (jsre *JSRE) LoadIntFile(file string) {
+	assetPath := path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "ethereal", "assets", "ext")
+	jsre.LoadExtFile(path.Join(assetPath, file))
+}
+
+func NewJSRE(ethereum *eth.Ethereum) *JSRE {
+	re := &JSRE{
+		ethereum,
+		otto.New(),
+		ethpub.NewPEthereum(ethereum),
+		make(chan ethreact.Event, 10),
+		make(chan ethreact.Event, 10),
+		make(chan bool),
+		make(map[string][]otto.Value),
+	}
+
+	// Init the JS lib
+	re.vm.Run(jsLib)
+
+	// Load extra javascript files
+	re.LoadIntFile("string.js")
+	re.LoadIntFile("big.js")
+
+	// We have to make sure that, whoever calls this, calls "Stop"
+	go re.mainLoop()
+
+	// Subscribe to events
+	reactor := ethereum.Reactor()
+	reactor.Subscribe("newBlock", self.blockChan)
+
+	re.Bind("eth", &JSEthereum{re.lib, re.vm})
+
+	re.initStdFuncs()
+
+	jsrelogger.Infoln("started")
+
+	return re
+}
+
+func (self *JSRE) Bind(name string, v interface{}) {
+	self.vm.Set(name, v)
+}
+
+func (self *JSRE) Run(code string) (otto.Value, error) {
+	return self.vm.Run(code)
+}
+
+func (self *JSRE) Require(file string) error {
+	if len(filepath.Ext(file)) == 0 {
+		file += ".js"
+	}
+
+	fh, err := os.Open(file)
+	if err != nil {
+		return err
+	}
+
+	content, _ := ioutil.ReadAll(fh)
+	self.Run("exports = {};(function() {" + string(content) + "})();")
+
+	return nil
+}
+
+func (self *JSRE) Stop() {
+	// Kill the main loop
+	self.quitChan <- true
+
+	close(self.blockChan)
+	close(self.quitChan)
+	close(self.changeChan)
+	jsrelogger.Infoln("stopped")
+}
+
+func (self *JSRE) mainLoop() {
+out:
+	for {
+		select {
+		case <-self.quitChan:
+			break out
+		case block := <-self.blockChan:
+			if _, ok := block.Resource.(*ethchain.Block); ok {
+			}
+		case object := <-self.changeChan:
+			if stateObject, ok := object.Resource.(*ethchain.StateObject); ok {
+				for _, cb := range self.objectCb[ethutil.Bytes2Hex(stateObject.Address())] {
+					val, _ := self.vm.ToValue(ethpub.NewPStateObject(stateObject))
+					cb.Call(cb, val)
+				}
+			} else if storageObject, ok := object.Resource.(*ethchain.StorageState); ok {
+				for _, cb := range self.objectCb[ethutil.Bytes2Hex(storageObject.StateAddress)+ethutil.Bytes2Hex(storageObject.Address)] {
+					val, _ := self.vm.ToValue(ethpub.NewPStorageState(storageObject))
+					cb.Call(cb, val)
+				}
+			}
+		}
+	}
+}
+
+func (self *JSRE) initStdFuncs() {
+	t, _ := self.vm.Get("eth")
+	eth := t.Object()
+	eth.Set("watch", self.watch)
+	eth.Set("addPeer", self.addPeer)
+	eth.Set("require", self.require)
+	eth.Set("stopMining", self.stopMining)
+	eth.Set("startMining", self.startMining)
+	eth.Set("execBlock", self.execBlock)
+}
+
+/*
+ * The following methods are natively implemented javascript functions
+ */
+
+func (self *JSRE) stopMining(call otto.FunctionCall) otto.Value {
+	v, _ := self.vm.ToValue(utils.StopMining(self.ethereum))
+	return v
+}
+
+func (self *JSRE) startMining(call otto.FunctionCall) otto.Value {
+	v, _ := self.vm.ToValue(utils.StartMining(self.ethereum))
+	return v
+}
+
+// eth.watch
+func (self *JSRE) watch(call otto.FunctionCall) otto.Value {
+	addr, _ := call.Argument(0).ToString()
+	var storageAddr string
+	var cb otto.Value
+	var storageCallback bool
+	if len(call.ArgumentList) > 2 {
+		storageCallback = true
+		storageAddr, _ = call.Argument(1).ToString()
+		cb = call.Argument(2)
+	} else {
+		cb = call.Argument(1)
+	}
+
+	if storageCallback {
+		self.objectCb[addr+storageAddr] = append(self.objectCb[addr+storageAddr], cb)
+
+		event := "storage:" + string(ethutil.Hex2Bytes(addr)) + ":" + string(ethutil.Hex2Bytes(storageAddr))
+		self.ethereum.Reactor().Subscribe(event, self.changeChan)
+	} else {
+		self.objectCb[addr] = append(self.objectCb[addr], cb)
+
+		event := "object:" + string(ethutil.Hex2Bytes(addr))
+		self.ethereum.Reactor().Subscribe(event, self.changeChan)
+	}
+
+	return otto.UndefinedValue()
+}
+
+func (self *JSRE) addPeer(call otto.FunctionCall) otto.Value {
+	host, err := call.Argument(0).ToString()
+	if err != nil {
+		return otto.FalseValue()
+	}
+	self.ethereum.ConnectToPeer(host)
+
+	return otto.TrueValue()
+}
+
+func (self *JSRE) require(call otto.FunctionCall) otto.Value {
+	file, err := call.Argument(0).ToString()
+	if err != nil {
+		return otto.UndefinedValue()
+	}
+	if err := self.Require(file); err != nil {
+		fmt.Println("err:", err)
+		return otto.UndefinedValue()
+	}
+
+	t, _ := self.vm.Get("exports")
+
+	return t
+}
+
+func (self *JSRE) execBlock(call otto.FunctionCall) otto.Value {
+	hash, err := call.Argument(0).ToString()
+	if err != nil {
+		return otto.UndefinedValue()
+	}
+
+	err = utils.BlockDo(self.ethereum, ethutil.Hex2Bytes(hash))
+	if err != nil {
+		fmt.Println(err)
+		return otto.FalseValue()
+	}
+
+	return otto.TrueValue()
+}
diff --git a/ethereum/repl/js_lib.go b/ethereum/repl/js_lib.go
new file mode 100644
index 000000000..c781c43d0
--- /dev/null
+++ b/ethereum/repl/js_lib.go
@@ -0,0 +1,53 @@
+package ethrepl
+
+const jsLib = `
+function pp(object) {
+    var str = "";
+
+    if(object instanceof Array) {
+        str += "[ ";
+        for(var i = 0, l = object.length; i < l; i++) {
+            str += pp(object[i]);
+
+            if(i < l-1) {
+                str += ", ";
+            }
+        }
+        str += " ]";
+    } else if(typeof(object) === "object") {
+        str += "{ ";
+        var last = Object.keys(object).sort().pop()
+        for(var k in object) {
+            str += k + ": " + pp(object[k]);
+
+            if(k !== last) {
+                str += ", ";
+            }
+        }
+        str += " }";
+    } else if(typeof(object) === "string") {
+        str += "\033[32m'" + object + "'";
+    } else if(typeof(object) === "undefined") {
+        str += "\033[1m\033[30m" + object;
+    } else if(typeof(object) === "number") {
+        str += "\033[31m" + object;
+    } else if(typeof(object) === "function") {
+	str += "\033[35m[Function]";
+    } else {
+        str += object;                    
+    }
+
+    str += "\033[0m";
+
+    return str;
+}
+
+function prettyPrint(/* */) {
+    var args = arguments;
+    for(var i = 0, l = args.length; i < l; i++) {
+	    console.log(pp(args[i]))
+    }
+}
+
+var print = prettyPrint;
+`
diff --git a/ethereum/repl/repl.go b/ethereum/repl/repl.go
new file mode 100644
index 000000000..92d4ad86a
--- /dev/null
+++ b/ethereum/repl/repl.go
@@ -0,0 +1,83 @@
+package ethrepl
+
+import (
+	"bufio"
+	"fmt"
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethutil"
+	"io"
+	"os"
+	"path"
+)
+
+var logger = ethlog.NewLogger("REPL")
+
+type Repl interface {
+	Start()
+	Stop()
+}
+
+type JSRepl struct {
+	re *JSRE
+
+	prompt string
+
+	history *os.File
+
+	running bool
+}
+
+func NewJSRepl(ethereum *eth.Ethereum) *JSRepl {
+	hist, err := os.OpenFile(path.Join(ethutil.Config.ExecPath, "history"), os.O_RDWR|os.O_CREATE, os.ModePerm)
+	if err != nil {
+		panic(err)
+	}
+
+	return &JSRepl{re: NewJSRE(ethereum), prompt: "> ", history: hist}
+}
+
+func (self *JSRepl) Start() {
+	if !self.running {
+		self.running = true
+		logger.Infoln("init JS Console")
+		reader := bufio.NewReader(self.history)
+		for {
+			line, err := reader.ReadString('\n')
+			if err != nil && err == io.EOF {
+				break
+			} else if err != nil {
+				fmt.Println("error reading history", err)
+				break
+			}
+
+			addHistory(line[:len(line)-1])
+		}
+		self.read()
+	}
+}
+
+func (self *JSRepl) Stop() {
+	if self.running {
+		self.running = false
+		self.re.Stop()
+		logger.Infoln("exit JS Console")
+		self.history.Close()
+	}
+}
+
+func (self *JSRepl) parseInput(code string) {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("[native] error", r)
+		}
+	}()
+
+	value, err := self.re.Run(code)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	self.PrintValue(value)
+}
diff --git a/ethereum/repl/repl_darwin.go b/ethereum/repl/repl_darwin.go
new file mode 100644
index 000000000..3a91b0d44
--- /dev/null
+++ b/ethereum/repl/repl_darwin.go
@@ -0,0 +1,123 @@
+package ethrepl
+
+// #cgo darwin CFLAGS: -I/usr/local/opt/readline/include
+// #cgo darwin LDFLAGS: -L/usr/local/opt/readline/lib
+// #cgo LDFLAGS: -lreadline
+// #include <stdio.h>
+// #include <stdlib.h>
+// #include <readline/readline.h>
+// #include <readline/history.h>
+import "C"
+import (
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"unsafe"
+)
+
+func initReadLine() {
+	C.rl_catch_sigwinch = 0
+	C.rl_catch_signals = 0
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, syscall.SIGWINCH)
+	signal.Notify(c, os.Interrupt)
+	go func() {
+		for sig := range c {
+			switch sig {
+			case syscall.SIGWINCH:
+				C.rl_resize_terminal()
+
+			case os.Interrupt:
+				C.rl_cleanup_after_signal()
+			default:
+
+			}
+		}
+	}()
+}
+
+func readLine(prompt *string) *string {
+	var p *C.char
+
+	//readline allows an empty prompt(NULL)
+	if prompt != nil {
+		p = C.CString(*prompt)
+	}
+
+	ret := C.readline(p)
+
+	if p != nil {
+		C.free(unsafe.Pointer(p))
+	}
+
+	if ret == nil {
+		return nil
+	} //EOF
+
+	s := C.GoString(ret)
+	C.free(unsafe.Pointer(ret))
+	return &s
+}
+
+func addHistory(s string) {
+	p := C.CString(s)
+	C.add_history(p)
+	C.free(unsafe.Pointer(p))
+}
+
+var indentCount = 0
+var str = ""
+
+func (self *JSRepl) setIndent() {
+	open := strings.Count(str, "{")
+	open += strings.Count(str, "(")
+	closed := strings.Count(str, "}")
+	closed += strings.Count(str, ")")
+	indentCount = open - closed
+	if indentCount <= 0 {
+		self.prompt = "> "
+	} else {
+		self.prompt = strings.Join(make([]string, indentCount*2), "..")
+		self.prompt += " "
+	}
+}
+
+func (self *JSRepl) read() {
+	initReadLine()
+L:
+	for {
+		switch result := readLine(&self.prompt); true {
+		case result == nil:
+			break L
+
+		case *result != "":
+			str += *result + "\n"
+
+			self.setIndent()
+
+			if indentCount <= 0 {
+				if *result == "exit" {
+					self.Stop()
+					break L
+				}
+
+				hist := str[:len(str)-1]
+				addHistory(hist) //allow user to recall this line
+				self.history.WriteString(str)
+
+				self.parseInput(str)
+
+				str = ""
+			}
+		}
+	}
+}
+
+func (self *JSRepl) PrintValue(v interface{}) {
+	method, _ := self.re.vm.Get("prettyPrint")
+	v, err := self.re.vm.ToValue(v)
+	if err == nil {
+		method.Call(method, v)
+	}
+}
diff --git a/ethereum/repl/repl_linux.go b/ethereum/repl/repl_linux.go
new file mode 120000
index 000000000..276f135d7
--- /dev/null
+++ b/ethereum/repl/repl_linux.go
@@ -0,0 +1 @@
+repl_darwin.go
\ No newline at end of file
diff --git a/ethereum/repl/repl_windows.go b/ethereum/repl/repl_windows.go
new file mode 100644
index 000000000..4106c89bc
--- /dev/null
+++ b/ethereum/repl/repl_windows.go
@@ -0,0 +1,24 @@
+package ethrepl
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+func (self *JSRepl) read() {
+	reader := bufio.NewReader(os.Stdin)
+	for {
+		fmt.Printf(self.prompt)
+		str, _, err := reader.ReadLine()
+		if err != nil {
+			fmt.Println("Error reading input", err)
+		} else {
+			self.parseInput(string(str))
+		}
+	}
+}
+
+func (self *JSRepl) PrintValue(value otto.Value) {
+	fmt.Println(value)
+}
diff --git a/ethereum/repl/types.go b/ethereum/repl/types.go
new file mode 100644
index 000000000..16a18e6e5
--- /dev/null
+++ b/ethereum/repl/types.go
@@ -0,0 +1,95 @@
+package ethrepl
+
+import (
+	"fmt"
+	"github.com/ethereum/eth-go/ethpub"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/obscuren/otto"
+)
+
+type JSStateObject struct {
+	*ethpub.PStateObject
+	eth *JSEthereum
+}
+
+func (self *JSStateObject) EachStorage(call otto.FunctionCall) otto.Value {
+	cb := call.Argument(0)
+	self.PStateObject.EachStorage(func(key string, value *ethutil.Value) {
+		value.Decode()
+
+		cb.Call(self.eth.toVal(self), self.eth.toVal(key), self.eth.toVal(ethutil.Bytes2Hex(value.Bytes())))
+	})
+
+	return otto.UndefinedValue()
+}
+
+// The JSEthereum object attempts to wrap the PEthereum object and returns
+// meaningful javascript objects
+type JSBlock struct {
+	*ethpub.PBlock
+	eth *JSEthereum
+}
+
+func (self *JSBlock) GetTransaction(hash string) otto.Value {
+	return self.eth.toVal(self.PBlock.GetTransaction(hash))
+}
+
+type JSEthereum struct {
+	*ethpub.PEthereum
+	vm *otto.Otto
+}
+
+func (self *JSEthereum) GetBlock(hash string) otto.Value {
+	return self.toVal(&JSBlock{self.PEthereum.GetBlock(hash), self})
+}
+
+func (self *JSEthereum) GetPeers() otto.Value {
+	return self.toVal(self.PEthereum.GetPeers())
+}
+
+func (self *JSEthereum) GetKey() otto.Value {
+	return self.toVal(self.PEthereum.GetKey())
+}
+
+func (self *JSEthereum) GetStateObject(addr string) otto.Value {
+	return self.toVal(&JSStateObject{self.PEthereum.GetStateObject(addr), self})
+}
+
+func (self *JSEthereum) GetStateKeyVals(addr string) otto.Value {
+	return self.toVal(self.PEthereum.GetStateObject(addr).StateKeyVal(false))
+}
+
+func (self *JSEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) otto.Value {
+	r, err := self.PEthereum.Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr)
+	if err != nil {
+		fmt.Println(err)
+
+		return otto.UndefinedValue()
+	}
+
+	return self.toVal(r)
+}
+
+func (self *JSEthereum) Create(key, valueStr, gasStr, gasPriceStr, scriptStr string) otto.Value {
+	r, err := self.PEthereum.Create(key, valueStr, gasStr, gasPriceStr, scriptStr)
+
+	if err != nil {
+		fmt.Println(err)
+
+		return otto.UndefinedValue()
+	}
+
+	return self.toVal(r)
+}
+
+func (self *JSEthereum) toVal(v interface{}) otto.Value {
+	result, err := self.vm.ToValue(v)
+
+	if err != nil {
+		fmt.Println("Value unknown:", err)
+
+		return otto.UndefinedValue()
+	}
+
+	return result
+}