aboutsummaryrefslogtreecommitdiffstats
path: root/javascript
diff options
context:
space:
mode:
Diffstat (limited to 'javascript')
-rw-r--r--javascript/javascript_runtime.go266
-rw-r--r--javascript/js_lib.go53
-rw-r--r--javascript/types.go170
3 files changed, 489 insertions, 0 deletions
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
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-06 07:20:32 +0800