From ce8f24e57a3ba31d17c34db284bd3d9efa15e7d8 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 11 Aug 2014 16:24:17 +0200 Subject: Moved JSRE to it's own package for sharing between ethere(um/al) --- ethereum/repl/javascript_runtime.go | 266 ------------------------------------ ethereum/repl/js_lib.go | 53 ------- ethereum/repl/types.go | 95 ------------- javascript/javascript_runtime.go | 266 ++++++++++++++++++++++++++++++++++++ javascript/js_lib.go | 53 +++++++ javascript/types.go | 170 +++++++++++++++++++++++ 6 files changed, 489 insertions(+), 414 deletions(-) delete mode 100644 ethereum/repl/javascript_runtime.go delete mode 100644 ethereum/repl/js_lib.go delete mode 100644 ethereum/repl/types.go create mode 100644 javascript/javascript_runtime.go create mode 100644 javascript/js_lib.go create mode 100644 javascript/types.go diff --git a/ethereum/repl/javascript_runtime.go b/ethereum/repl/javascript_runtime.go deleted file mode 100644 index 026e6f374..000000000 --- a/ethereum/repl/javascript_runtime.go +++ /dev/null @@ -1,266 +0,0 @@ -package ethrepl - -import ( - "fmt" - "io/ioutil" - "os" - "path" - "path/filepath" - - "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/ethstate" - "github.com/ethereum/eth-go/ethutil" - "github.com/ethereum/go-ethereum/utils" - "github.com/obscuren/otto" -) - -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", re.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.(*ethstate.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.(*ethstate.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) - eth.Set("dump", self.dump) -} - -/* - * The following methods are natively implemented javascript functions - */ - -func (self *JSRE) dump(call otto.FunctionCall) otto.Value { - var state *ethstate.State - - if len(call.ArgumentList) > 0 { - var block *ethchain.Block - if call.Argument(0).IsNumber() { - num, _ := call.Argument(0).ToInteger() - block = self.ethereum.BlockChain().GetBlockByNumber(uint64(num)) - } else if call.Argument(0).IsString() { - hash, _ := call.Argument(0).ToString() - block = self.ethereum.BlockChain().GetBlock(ethutil.Hex2Bytes(hash)) - } else { - fmt.Println("invalid argument for dump. Either hex string or number") - } - - if block == nil { - fmt.Println("block not found") - - return otto.UndefinedValue() - } - - state = block.State() - } else { - state = self.ethereum.StateManager().CurrentState() - } - - v, _ := self.vm.ToValue(state.Dump()) - - return v -} - -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 deleted file mode 100644 index c781c43d0..000000000 --- a/ethereum/repl/js_lib.go +++ /dev/null @@ -1,53 +0,0 @@ -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/types.go b/ethereum/repl/types.go deleted file mode 100644 index 16a18e6e5..000000000 --- a/ethereum/repl/types.go +++ /dev/null @@ -1,95 +0,0 @@ -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 -} diff --git a/javascript/javascript_runtime.go b/javascript/javascript_runtime.go new file mode 100644 index 000000000..158fc93cf --- /dev/null +++ b/javascript/javascript_runtime.go @@ -0,0 +1,266 @@ +package javascript + +import ( + "fmt" + "io/ioutil" + "os" + "path" + "path/filepath" + + "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/ethstate" + "github.com/ethereum/eth-go/ethutil" + "github.com/ethereum/go-ethereum/utils" + "github.com/obscuren/otto" +) + +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.Infoln("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", re.blockChan) + + re.Bind("eth", &JSEthereum{re.lib, re.Vm, ethereum}) + + 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.(*ethstate.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.(*ethstate.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) + eth.Set("dump", self.dump) +} + +/* + * The following methods are natively implemented javascript functions + */ + +func (self *JSRE) dump(call otto.FunctionCall) otto.Value { + var state *ethstate.State + + if len(call.ArgumentList) > 0 { + var block *ethchain.Block + if call.Argument(0).IsNumber() { + num, _ := call.Argument(0).ToInteger() + block = self.ethereum.BlockChain().GetBlockByNumber(uint64(num)) + } else if call.Argument(0).IsString() { + hash, _ := call.Argument(0).ToString() + block = self.ethereum.BlockChain().GetBlock(ethutil.Hex2Bytes(hash)) + } else { + fmt.Println("invalid argument for dump. Either hex string or number") + } + + if block == nil { + fmt.Println("block not found") + + return otto.UndefinedValue() + } + + state = block.State() + } else { + state = self.ethereum.StateManager().CurrentState() + } + + v, _ := self.Vm.ToValue(state.Dump()) + + return v +} + +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/javascript/js_lib.go b/javascript/js_lib.go new file mode 100644 index 000000000..a3e9b8a5b --- /dev/null +++ b/javascript/js_lib.go @@ -0,0 +1,53 @@ +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).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/javascript/types.go b/javascript/types.go new file mode 100644 index 000000000..f9d18b26a --- /dev/null +++ b/javascript/types.go @@ -0,0 +1,170 @@ +package javascript + +import ( + "fmt" + + "github.com/ethereum/eth-go" + "github.com/ethereum/eth-go/ethchain" + "github.com/ethereum/eth-go/ethpub" + "github.com/ethereum/eth-go/ethstate" + "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 JSMessage struct { + To, From string + Input string + Output string + Path int + Origin string + Timestamp int32 + Coinbase string + Block string + Number int32 +} + +func NewJSMessage(message *ethstate.Message) JSMessage { + return JSMessage{ + To: ethutil.Bytes2Hex(message.To), + From: ethutil.Bytes2Hex(message.From), + Input: ethutil.Bytes2Hex(message.Input), + Output: ethutil.Bytes2Hex(message.Output), + Path: message.Path, + Origin: ethutil.Bytes2Hex(message.Origin), + Timestamp: int32(message.Timestamp), + Coinbase: ethutil.Bytes2Hex(message.Origin), + Block: ethutil.Bytes2Hex(message.Block), + Number: int32(message.Number.Int64()), + } +} + +type JSEthereum struct { + *ethpub.PEthereum + vm *otto.Otto + ethereum *eth.Ethereum +} + +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 +} + +func (self *JSEthereum) Messages(object map[string]interface{}) otto.Value { + filter := ethchain.NewFilter(self.ethereum) + + if object["earliest"] != nil { + earliest := object["earliest"] + if e, ok := earliest.(string); ok { + filter.SetEarliestBlock(ethutil.Hex2Bytes(e)) + } else { + filter.SetEarliestBlock(earliest) + } + } + if object["latest"] != nil { + latest := object["latest"] + if l, ok := latest.(string); ok { + filter.SetLatestBlock(ethutil.Hex2Bytes(l)) + } else { + filter.SetLatestBlock(latest) + } + } + if object["to"] != nil { + filter.SetTo(ethutil.Hex2Bytes(object["to"].(string))) + } + if object["from"] != nil { + filter.SetFrom(ethutil.Hex2Bytes(object["from"].(string))) + } + if object["max"] != nil { + filter.SetMax(object["max"].(int)) + } + if object["skip"] != nil { + filter.SetSkip(object["skip"].(int)) + } + + messages := filter.Find() + var msgs []JSMessage + for _, m := range messages { + msgs = append(msgs, NewJSMessage(m)) + } + + v, _ := self.vm.ToValue(msgs) + + return v +} -- cgit v1.2.3