diff options
Diffstat (limited to 'javascript')
| -rw-r--r-- | javascript/javascript_runtime.go | 102 | ||||
| -rw-r--r-- | javascript/js_lib.go | 55 | ||||
| -rw-r--r-- | javascript/types.go | 94 |
3 files changed, 251 insertions, 0 deletions
diff --git a/javascript/javascript_runtime.go b/javascript/javascript_runtime.go new file mode 100644 index 000000000..36b14a057 --- /dev/null +++ b/javascript/javascript_runtime.go @@ -0,0 +1,102 @@ +package javascript + +import ( + "fmt" + "io/ioutil" + "os" + "path" + "path/filepath" + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/xeth" + "github.com/obscuren/otto" +) + +var jsrelogger = logger.NewLogger("JSRE") + +type JSRE struct { + Vm *otto.Otto + xeth *xeth.XEth + + 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.Infoln("Could not load file:", path) + } +} + +func (jsre *JSRE) LoadIntFile(file string) { + assetPath := path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "cmd", "mist", "assets", "ext") + jsre.LoadExtFile(path.Join(assetPath, file)) +} + +func NewJSRE(xeth *xeth.XEth) *JSRE { + re := &JSRE{ + otto.New(), + xeth, + make(map[string][]otto.Value), + } + + // Init the JS lib + re.Vm.Run(jsLib) + + // Load extra javascript files + re.LoadIntFile("bignumber.min.js") + + re.Bind("eth", &JSEthereum{re.xeth, 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) initStdFuncs() { + t, _ := self.Vm.Get("eth") + eth := t.Object() + eth.Set("require", self.require) +} + +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) 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 +} diff --git a/javascript/js_lib.go b/javascript/js_lib.go new file mode 100644 index 000000000..f828ca389 --- /dev/null +++ b/javascript/js_lib.go @@ -0,0 +1,55 @@ +package javascript + +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).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; + var ret = ""; + for(var i = 0, l = args.length; i < l; i++) { + ret += pp(args[i]) + "\n"; + } + return ret; +} + +var print = prettyPrint; +` diff --git a/javascript/types.go b/javascript/types.go new file mode 100644 index 000000000..77e209d19 --- /dev/null +++ b/javascript/types.go @@ -0,0 +1,94 @@ +package javascript + +import ( + "fmt" + "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/state" + "github.com/ethereum/go-ethereum/xeth" + "github.com/obscuren/otto" +) + +type JSStateObject struct { + *xeth.Object + eth *JSEthereum +} + +func (self *JSStateObject) EachStorage(call otto.FunctionCall) otto.Value { + cb := call.Argument(0) + + it := self.Object.Trie().Iterator() + for it.Next() { + cb.Call(self.eth.toVal(self), self.eth.toVal(ethutil.Bytes2Hex(it.Key)), self.eth.toVal(ethutil.Bytes2Hex(it.Value))) + } + + return otto.UndefinedValue() +} + +// The JSEthereum object attempts to wrap the PEthereum object and returns +// meaningful javascript objects +type JSBlock struct { + *xeth.Block + eth *JSEthereum +} + +func (self *JSBlock) GetTransaction(hash string) otto.Value { + return self.eth.toVal(self.Block.GetTransaction(hash)) +} + +type JSLog struct { + Address string `json:address` + Topics []string `json:topics` + Number int32 `json:number` + Data string `json:data` +} + +func NewJSLog(log state.Log) JSLog { + return JSLog{ + Address: ethutil.Bytes2Hex(log.Address()), + Topics: nil, //ethutil.Bytes2Hex(log.Address()), + Number: 0, + Data: ethutil.Bytes2Hex(log.Data()), + } +} + +type JSEthereum struct { + *xeth.XEth + vm *otto.Otto +} + +func (self *JSEthereum) Block(v interface{}) otto.Value { + if number, ok := v.(int64); ok { + return self.toVal(&JSBlock{self.XEth.BlockByNumber(int32(number)), self}) + } else if hash, ok := v.(string); ok { + return self.toVal(&JSBlock{self.XEth.BlockByHash(hash), self}) + } + + return otto.UndefinedValue() +} + +func (self *JSEthereum) GetStateObject(addr string) otto.Value { + return self.toVal(&JSStateObject{self.XEth.State().SafeGet(addr), self}) +} + +func (self *JSEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) otto.Value { + r, err := self.XEth.Transact(recipient, valueStr, gasStr, gasPriceStr, dataStr) + 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 +} |