From 87e0aa707f4ad0f6605871ab358e09b5898e8a52 Mon Sep 17 00:00:00 2001 From: Felix Lange Date: Wed, 22 Jan 2020 01:59:37 +0100 Subject: [PATCH] console: port to JSRE changes Also improve a few minor details in the bridge. We can now sleep for sub-second amounts, for example. --- console/bridge.go | 346 +++++++++++++++++++++------------------------ console/console.go | 169 +++++++++++----------- 2 files changed, 244 insertions(+), 271 deletions(-) diff --git a/console/bridge.go b/console/bridge.go index 0382a7311f..2625c481d5 100644 --- a/console/bridge.go +++ b/console/bridge.go @@ -27,50 +27,40 @@ import ( "github.com/dop251/goja" "github.com/ethereum/go-ethereum/accounts/scwallet" "github.com/ethereum/go-ethereum/accounts/usbwallet" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/internal/jsre" "github.com/ethereum/go-ethereum/rpc" ) // bridge is a collection of JavaScript utility methods to bride the .js runtime // environment and the Go RPC connection backing the remote method calls. type bridge struct { - client *rpc.Client // RPC client to execute Ethereum requests through - prompter UserPrompter // Input prompter to allow interactive user feedback - printer io.Writer // Output writer to serialize any display strings to - runtime *goja.Runtime // Pointer to the JS runtime + client *rpc.Client // RPC client to execute Ethereum requests through + prompter UserPrompter // Input prompter to allow interactive user feedback + printer io.Writer // Output writer to serialize any display strings to } // newBridge creates a new JavaScript wrapper around an RPC client. -func newBridge(client *rpc.Client, prompter UserPrompter, printer io.Writer, runtime *goja.Runtime) *bridge { +func newBridge(client *rpc.Client, prompter UserPrompter, printer io.Writer) *bridge { return &bridge{ client: client, prompter: prompter, printer: printer, - runtime: runtime, } } -// IsNumber returns `true` if input value `v` is a number. -func IsNumber(v goja.Value) bool { - switch v.ExportType().Kind() { - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - return true - default: - return false +func getJeth(vm *goja.Runtime) *goja.Object { + jeth := vm.Get("jeth") + if jeth == nil { + panic(vm.ToValue("jeth object does not exist")) } -} - -func getJeth(r *goja.Runtime) *goja.Object { - jethObj := r.Get("jeth") - if jethObj == nil { - panic(r.ToValue("jeth object does not exist")) - } - return jethObj.ToObject(r) + return jeth.ToObject(vm) } // NewAccount is a wrapper around the personal.newAccount RPC method that uses a // non-echoing password prompt to acquire the passphrase and executes the original // RPC method (saved in jeth.newAccount) with it to actually execute the RPC call. -func (b *bridge) NewAccount(call goja.FunctionCall) (response goja.Value) { +func (b *bridge) NewAccount(call jsre.Call) (goja.Value, error) { var ( password string confirm string @@ -80,58 +70,55 @@ func (b *bridge) NewAccount(call goja.FunctionCall) (response goja.Value) { // No password was specified, prompt the user for it case len(call.Arguments) == 0: if password, err = b.prompter.PromptPassword("Passphrase: "); err != nil { - throwJSException(b.runtime, err.Error()) + return nil, err } if confirm, err = b.prompter.PromptPassword("Repeat passphrase: "); err != nil { - throwJSException(b.runtime, err.Error()) + return nil, err } if password != confirm { - throwJSException(b.runtime, "passwords don't match!") + return nil, fmt.Errorf("passwords don't match!") } - // A single string password was specified, use that case len(call.Arguments) == 1 && call.Argument(0).ToString() != nil: password = call.Argument(0).ToString().String() - - // Otherwise fail with some error default: - throwJSException(b.runtime, "expected 0 or 1 string argument") + return nil, fmt.Errorf("expected 0 or 1 string argument") } // Password acquired, execute the call and return - newAccount, callable := goja.AssertFunction(getJeth(b.runtime).Get("newAccount")) + newAccount, callable := goja.AssertFunction(getJeth(call.VM).Get("newAccount")) if !callable { - panic(b.runtime.ToValue("jeth.newAccount isn't callable")) + return nil, fmt.Errorf("jeth.newAccount is not callable") } - ret, err := newAccount(goja.Null(), b.runtime.ToValue(password)) + ret, err := newAccount(goja.Null(), call.VM.ToValue(password)) if err != nil { - throwJSException(b.runtime, err.Error()) + return nil, err } - return ret + return ret, nil } // OpenWallet is a wrapper around personal.openWallet which can interpret and // react to certain error messages, such as the Trezor PIN matrix request. -func (b *bridge) OpenWallet(call goja.FunctionCall) (response goja.Value) { +func (b *bridge) OpenWallet(call jsre.Call) (goja.Value, error) { // Make sure we have a wallet specified to open - if call.Argument(0).ToObject(b.runtime).ClassName() != "String" { - throwJSException(b.runtime, b.runtime.ToValue("first argument must be the wallet URL to open")) + if call.Argument(0).ToObject(call.VM).ClassName() != "String" { + return nil, fmt.Errorf("first argument must be the wallet URL to open") } wallet := call.Argument(0) var passwd goja.Value if goja.IsUndefined(call.Argument(1)) || goja.IsNull(call.Argument(1)) { - passwd = b.runtime.ToValue("") + passwd = call.VM.ToValue("") } else { passwd = call.Argument(1) } // Open the wallet and return if successful in itself - openWallet, callable := goja.AssertFunction(getJeth(b.runtime).Get("openWallet")) + openWallet, callable := goja.AssertFunction(getJeth(call.VM).Get("openWallet")) if !callable { - throwJSException(b.runtime, b.runtime.ToValue("jeth.openWallet is not callable")) + return nil, fmt.Errorf("jeth.openWallet is not callable") } val, err := openWallet(goja.Null(), wallet, passwd) if err == nil { - return val + return val, nil } // Wallet open failed, report error unless it's a PIN or PUK entry @@ -139,32 +126,31 @@ func (b *bridge) OpenWallet(call goja.FunctionCall) (response goja.Value) { case strings.HasSuffix(err.Error(), usbwallet.ErrTrezorPINNeeded.Error()): val, err = b.readPinAndReopenWallet(call) if err == nil { - return val + return val, nil } val, err = b.readPassphraseAndReopenWallet(call) if err != nil { - throwJSException(b.runtime, err.Error()) + return nil, err } case strings.HasSuffix(err.Error(), scwallet.ErrPairingPasswordNeeded.Error()): // PUK input requested, fetch from the user and call open again - if input, err := b.prompter.PromptPassword("Please enter the pairing password: "); err != nil { - throwJSException(b.runtime, err.Error()) - } else { - passwd = b.runtime.ToValue(input) + input, err := b.prompter.PromptPassword("Please enter the pairing password: ") + if err != nil { + return nil, err } + passwd = call.VM.ToValue(input) if val, err = openWallet(goja.Null(), wallet, passwd); err != nil { if !strings.HasSuffix(err.Error(), scwallet.ErrPINNeeded.Error()) { - throwJSException(b.runtime, err.Error()) + return nil, err } else { // PIN input requested, fetch from the user and call open again - if input, err := b.prompter.PromptPassword("Please enter current PIN: "); err != nil { - throwJSException(b.runtime, err.Error()) - } else { - passwd = b.runtime.ToValue(input) + input, err := b.prompter.PromptPassword("Please enter current PIN: ") + if err != nil { + return nil, err } - if val, err = openWallet(goja.Null(), wallet, passwd); err != nil { - throwJSException(b.runtime, err.Error()) + if val, err = openWallet(goja.Null(), wallet, call.VM.ToValue(input)); err != nil { + return nil, err } } } @@ -172,56 +158,52 @@ func (b *bridge) OpenWallet(call goja.FunctionCall) (response goja.Value) { case strings.HasSuffix(err.Error(), scwallet.ErrPINUnblockNeeded.Error()): // PIN unblock requested, fetch PUK and new PIN from the user var pukpin string - if input, err := b.prompter.PromptPassword("Please enter current PUK: "); err != nil { - throwJSException(b.runtime, err.Error()) - } else { - pukpin = input + input, err := b.prompter.PromptPassword("Please enter current PUK: ") + if err != nil { + return nil, err } - if input, err := b.prompter.PromptPassword("Please enter new PIN: "); err != nil { - throwJSException(b.runtime, err.Error()) - } else { - pukpin += input + pukpin = input + input, err = b.prompter.PromptPassword("Please enter new PIN: ") + if err != nil { + return nil, err } - passwd = b.runtime.ToValue(pukpin) - if val, err = openWallet(goja.Null(), wallet, passwd); err != nil { - throwJSException(b.runtime, err.Error()) + pukpin += input + + if val, err = openWallet(goja.Null(), wallet, call.VM.ToValue(pukpin)); err != nil { + return nil, err } case strings.HasSuffix(err.Error(), scwallet.ErrPINNeeded.Error()): // PIN input requested, fetch from the user and call open again - if input, err := b.prompter.PromptPassword("Please enter current PIN: "); err != nil { - throwJSException(b.runtime, err.Error()) - } else { - passwd = b.runtime.ToValue(input) + input, err := b.prompter.PromptPassword("Please enter current PIN: ") + if err != nil { + return nil, err } - if val, err = openWallet(goja.Null(), wallet, passwd); err != nil { - throwJSException(b.runtime, err.Error()) + if val, err = openWallet(goja.Null(), wallet, call.VM.ToValue(input)); err != nil { + return nil, err } default: // Unknown error occurred, drop to the user - throwJSException(b.runtime, err.Error()) + return nil, err } - return val + return val, nil } -func (b *bridge) readPassphraseAndReopenWallet(call goja.FunctionCall) (goja.Value, error) { - var passwd goja.Value +func (b *bridge) readPassphraseAndReopenWallet(call jsre.Call) (goja.Value, error) { wallet := call.Argument(0) - if input, err := b.prompter.PromptPassword("Please enter your passphrase: "); err != nil { - throwJSException(b.runtime, err.Error()) - } else { - passwd = b.runtime.ToValue(input) + input, err := b.prompter.PromptPassword("Please enter your passphrase: ") + if err != nil { + return nil, err } - openWallet, callable := goja.AssertFunction(getJeth(b.runtime).Get("openWallet")) + openWallet, callable := goja.AssertFunction(getJeth(call.VM).Get("openWallet")) if !callable { return nil, fmt.Errorf("jeth.openWallet is not callable") } - return openWallet(goja.Null(), wallet, passwd) + return openWallet(goja.Null(), wallet, call.VM.ToValue(input)) } -func (b *bridge) readPinAndReopenWallet(call goja.FunctionCall) (goja.Value, error) { - var passwd goja.Value +func (b *bridge) readPinAndReopenWallet(call jsre.Call) (goja.Value, error) { wallet := call.Argument(0) // Trezor PIN matrix input requested, display the matrix to the user and fetch the data fmt.Fprintf(b.printer, "Look at the device for number positions\n\n") @@ -231,69 +213,65 @@ func (b *bridge) readPinAndReopenWallet(call goja.FunctionCall) (goja.Value, err fmt.Fprintf(b.printer, "--+---+--\n") fmt.Fprintf(b.printer, "1 | 2 | 3\n\n") - if input, err := b.prompter.PromptPassword("Please enter current PIN: "); err != nil { - throwJSException(b.runtime, err.Error()) - } else { - passwd = b.runtime.ToValue(input) + input, err := b.prompter.PromptPassword("Please enter current PIN: ") + if err != nil { + return nil, err } - openWallet, callable := goja.AssertFunction(getJeth(b.runtime).Get("openWallet")) + openWallet, callable := goja.AssertFunction(getJeth(call.VM).Get("openWallet")) if !callable { return nil, fmt.Errorf("jeth.openWallet is not callable") } - return openWallet(goja.Null(), wallet, passwd) + return openWallet(goja.Null(), wallet, call.VM.ToValue(input)) } // UnlockAccount is a wrapper around the personal.unlockAccount RPC method that // uses a non-echoing password prompt to acquire the passphrase and executes the // original RPC method (saved in jeth.unlockAccount) with it to actually execute // the RPC call. -func (b *bridge) UnlockAccount(call goja.FunctionCall) (response goja.Value) { - // Make sure we have an account specified to unlock +func (b *bridge) UnlockAccount(call jsre.Call) (goja.Value, error) { + // Make sure we have an account specified to unlock. if call.Argument(0).ExportType().Kind() != reflect.String { - throwJSException(b.runtime, "first argument must be the account to unlock") + return nil, fmt.Errorf("first argument must be the account to unlock") } account := call.Argument(0) - // If password is not given or is the null value, prompt the user for it + // If password is not given or is the null value, prompt the user for it. var passwd goja.Value - if goja.IsUndefined(call.Argument(1)) || goja.IsNull(call.Argument(1)) { fmt.Fprintf(b.printer, "Unlock account %s\n", account) - if input, err := b.prompter.PromptPassword("Passphrase: "); err != nil { - throwJSException(b.runtime, err.Error()) - } else { - passwd = b.runtime.ToValue(input) + input, err := b.prompter.PromptPassword("Passphrase: ") + if err != nil { + return nil, err } + passwd = call.VM.ToValue(input) } else { if call.Argument(1).ExportType().Kind() != reflect.String { - throwJSException(b.runtime, "password must be a string") + return nil, fmt.Errorf("password must be a string") } passwd = call.Argument(1) } - // Third argument is the duration how long the account must be unlocked. + + // Third argument is the duration how long the account should be unlocked. duration := goja.Null() if !goja.IsUndefined(call.Argument(2)) && !goja.IsNull(call.Argument(2)) { - if !IsNumber(call.Argument(2)) { - throwJSException(b.runtime, "unlock duration must be a number") + if !isNumber(call.Argument(2)) { + return nil, fmt.Errorf("unlock duration must be a number") } duration = call.Argument(2) } - // Send the request to the backend and return - unlockAccount, callable := goja.AssertFunction(getJeth(b.runtime).Get("unlockAccount")) + + // Send the request to the backend and return. + unlockAccount, callable := goja.AssertFunction(getJeth(call.VM).Get("unlockAccount")) if !callable { - throwJSException(b.runtime, "jeth.unlockAccount is not callable") + return nil, fmt.Errorf("jeth.unlockAccount is not callable") } - val, err := unlockAccount(goja.Null(), account, passwd, duration) - if err != nil { - throwJSException(b.runtime, err.Error()) - } - return val + return unlockAccount(goja.Null(), account, passwd, duration) } // Sign is a wrapper around the personal.sign RPC method that uses a non-echoing password // prompt to acquire the passphrase and executes the original RPC method (saved in // jeth.sign) with it to actually execute the RPC call. -func (b *bridge) Sign(call goja.FunctionCall) (response goja.Value) { +func (b *bridge) Sign(call jsre.Call) (goja.Value, error) { var ( message = call.Argument(0) account = call.Argument(1) @@ -301,102 +279,88 @@ func (b *bridge) Sign(call goja.FunctionCall) (response goja.Value) { ) if message.ExportType().Kind() != reflect.String { - throwJSException(b.runtime, "first argument must be the message to sign") + return nil, fmt.Errorf("first argument must be the message to sign") } if account.ExportType().Kind() != reflect.String { - throwJSException(b.runtime, "second argument must be the account to sign with") + return nil, fmt.Errorf("second argument must be the account to sign with") } // if the password is not given or null ask the user and ensure password is a string if goja.IsUndefined(passwd) || goja.IsNull(passwd) { fmt.Fprintf(b.printer, "Give password for account %s\n", account) - if input, err := b.prompter.PromptPassword("Password: "); err != nil { - throwJSException(b.runtime, err.Error()) - } else { - passwd = b.runtime.ToValue(input) + input, err := b.prompter.PromptPassword("Password: ") + if err != nil { + return nil, err } - } - if passwd.ExportType().Kind() != reflect.String { - throwJSException(b.runtime, "third argument must be the password to unlock the account") + passwd = call.VM.ToValue(input) + } else if passwd.ExportType().Kind() != reflect.String { + return nil, fmt.Errorf("third argument must be the password to unlock the account") } // Send the request to the backend and return - sign, callable := goja.AssertFunction(getJeth(b.runtime).Get("unlockAccount")) + sign, callable := goja.AssertFunction(getJeth(call.VM).Get("unlockAccount")) if !callable { - throwJSException(b.runtime, "jeth.unlockAccount is not callable") + return nil, fmt.Errorf("jeth.unlockAccount is not callable") } - val, err := sign(goja.Null(), message, account, passwd) - if err != nil { - throwJSException(b.runtime, err.Error()) - } - return val + return sign(goja.Null(), message, account, passwd) } // Sleep will block the console for the specified number of seconds. -func (b *bridge) Sleep(call goja.FunctionCall) (response goja.Value) { - if IsNumber(call.Argument(0)) { - sleep := call.Argument(0).ToInteger() - time.Sleep(time.Duration(sleep) * time.Second) - return b.runtime.ToValue(true) +func (b *bridge) Sleep(call jsre.Call) (goja.Value, error) { + if !isNumber(call.Argument(0)) { + return nil, fmt.Errorf("usage: sleep()") } - return throwJSException(b.runtime, "usage: sleep()") + sleep := call.Argument(0).ToFloat() + time.Sleep(time.Duration(sleep * float64(time.Second))) + return call.VM.ToValue(true), nil } // SleepBlocks will block the console for a specified number of new blocks optionally // until the given timeout is reached. -func (b *bridge) SleepBlocks(call goja.FunctionCall) (response goja.Value) { +func (b *bridge) SleepBlocks(call jsre.Call) (goja.Value, error) { + // Parse the input parameters for the sleep. var ( blocks = int64(0) sleep = int64(9999999999999999) // indefinitely ) - // Parse the input parameters for the sleep nArgs := len(call.Arguments) if nArgs == 0 { - throwJSException(b.runtime, "usage: sleepBlocks([, max sleep in seconds])") + return nil, fmt.Errorf("usage: sleepBlocks([, max sleep in seconds])") } if nArgs >= 1 { - if IsNumber(call.Argument(0)) { - blocks = call.Argument(0).ToInteger() - - } else { - throwJSException(b.runtime, "expected number as first argument") + if !isNumber(call.Argument(0)) { + return nil, fmt.Errorf("expected number as first argument") } + blocks = call.Argument(0).ToInteger() } if nArgs >= 2 { - if IsNumber(call.Argument(1)) { - sleep = call.Argument(1).ToInteger() - } else { - throwJSException(b.runtime, "expected number as second argument") + if isNumber(call.Argument(1)) { + return nil, fmt.Errorf("expected number as second argument") } + sleep = call.Argument(1).ToInteger() } - // go through the console, this will allow web3 to call the appropriate - // callbacks if a delayed response or notification is received. - blockNumber := func() int64 { - blockNumber, isFunc := goja.AssertFunction(b.runtime.Get("eth.blockNumber")) - if !isFunc { - throwJSException(b.runtime, "eth.blockNumber isn't a function") - } - block, err := blockNumber(goja.Null()) - if err != nil { - throwJSException(b.runtime, err.Error()) - } - // XXX This will return 0 if blockNumber isn't an Integer. This is - // actually consistent with the current behavior (block number is 0 - // until the sync is done) but not safe enough. - return block.ToInteger() - - } - // Poll the current block number until either it ot a timeout is reached - targetBlockNr := blockNumber() + blocks - deadline := time.Now().Add(time.Duration(sleep) * time.Second) + // Poll the current block number until either it or a timeout is reached. + var ( + deadline = time.Now().Add(time.Duration(sleep) * time.Second) + lastNumber = ^hexutil.Uint64(0) + ) for time.Now().Before(deadline) { - if blockNumber() >= targetBlockNr { - return b.runtime.ToValue(true) + var number hexutil.Uint64 + err := b.client.Call(&number, "eth_blockNumber") + if err != nil { + return nil, err + } + if number != lastNumber { + lastNumber = number + blocks-- + } + if blocks <= 0 { + break } time.Sleep(time.Second) } - return b.runtime.ToValue(false) + return call.VM.ToValue(true), nil } type jsonrpcCall struct { @@ -406,12 +370,13 @@ type jsonrpcCall struct { } // Send implements the web3 provider "send" method. -func (b *bridge) Send(call goja.FunctionCall) (response goja.Value) { +func (b *bridge) Send(call jsre.Call) (goja.Value, error) { // Remarshal the request into a Go value. - reqVal, err := call.Argument(0).ToObject(b.runtime).MarshalJSON() + reqVal, err := call.Argument(0).ToObject(call.VM).MarshalJSON() if err != nil { - throwJSException(b.runtime, err.Error()) + return nil, err } + var ( rawReq = string(reqVal) dec = json.NewDecoder(strings.NewReader(rawReq)) @@ -431,9 +396,10 @@ func (b *bridge) Send(call goja.FunctionCall) (response goja.Value) { // Execute the requests. var resps []*goja.Object for _, req := range reqs { - v, _ := b.runtime.RunString(`({"jsonrpc":"2.0"})`) - resp := v.ToObject(b.runtime) + resp := call.VM.NewObject() + resp.Set("jsonrpc", "2.0") resp.Set("id", req.ID) + var result json.RawMessage err = b.client.Call(&result, req.Method, req.Params...) switch err := err.(type) { @@ -443,13 +409,12 @@ func (b *bridge) Send(call goja.FunctionCall) (response goja.Value) { // raw message for some reason. resp.Set("result", goja.Null()) } else { - JSON := b.runtime.Get("JSON").ToObject(b.runtime) + JSON := call.VM.Get("JSON").ToObject(call.VM) parse, callable := goja.AssertFunction(JSON.Get("parse")) if !callable { - panic("JSON.parse isn't a function") + return nil, fmt.Errorf("JSON.parse is not a function") } - - resultVal, err := parse(goja.Null(), b.runtime.ToValue(string(result))) + resultVal, err := parse(goja.Null(), call.VM.ToValue(string(result))) if err != nil { setError(resp, -32603, err.Error()) } else { @@ -466,24 +431,33 @@ func (b *bridge) Send(call goja.FunctionCall) (response goja.Value) { // Return the responses either to the callback (if supplied) // or directly as the return value. + var result goja.Value if batch { - response = b.runtime.ToValue(resps) + result = call.VM.ToValue(resps) } else { - response = resps[0] + result = resps[0] } if fn, isFunc := goja.AssertFunction(call.Argument(1)); isFunc { - fn(goja.Null(), goja.Null(), response) - return goja.Undefined() + fn(goja.Null(), goja.Null(), result) + return goja.Undefined(), nil } - return response + return result, nil } func setError(resp *goja.Object, code int, msg string) { resp.Set("error", map[string]interface{}{"code": code, "message": msg}) } -// throwJSException panics on an goja.Value. The Goja VM will recover from the -// Go panic and throw msg as a JavaScript error. -func throwJSException(runtime *goja.Runtime, msg interface{}) goja.Value { - panic(runtime.ToValue(msg)) +// isNumber returns true if input value is a JS number. +func isNumber(v goja.Value) bool { + k := v.ExportType().Kind() + return k >= reflect.Int && k <= reflect.Float64 +} + +func getObject(vm *goja.Runtime, name string) *goja.Object { + v := vm.Get(name) + if v == nil { + return nil + } + return v.ToObject(vm) } diff --git a/console/console.go b/console/console.go index 98cf5a5061..e2ffa2538b 100644 --- a/console/console.go +++ b/console/console.go @@ -64,14 +64,13 @@ type Config struct { // JavaScript console attached to a running node via an external or in-process RPC // client. type Console struct { - client *rpc.Client // RPC client to execute Ethereum requests through - jsre *jsre.JSRE // JavaScript runtime environment running the interpreter - prompt string // Input prompt prefix string - prompter UserPrompter // Input prompter to allow interactive user feedback - histPath string // Absolute path to the console scrollback history - history []string // Scroll history maintained by the console - printer io.Writer // Output writer to serialize any display strings to - runtime *goja.Runtime // The javascript runtime + client *rpc.Client // RPC client to execute Ethereum requests through + jsre *jsre.JSRE // JavaScript runtime environment running the interpreter + prompt string // Input prompt prefix string + prompter UserPrompter // Input prompter to allow interactive user feedback + histPath string // Absolute path to the console scrollback history + history []string // Scroll history maintained by the console + printer io.Writer // Output writer to serialize any display strings to } // New initializes a JavaScript interpreted runtime environment and sets defaults @@ -88,14 +87,10 @@ func New(config Config) (*Console, error) { config.Printer = colorable.NewColorableStdout() } - // Create the JS runtime - runtime := goja.New() - // Initialize the console and return console := &Console{ - runtime: runtime, client: config.Client, - jsre: jsre.New(config.DocRoot, config.Printer, runtime), + jsre: jsre.New(config.DocRoot, config.Printer), prompt: config.Prompt, prompter: config.Prompter, printer: config.Printer, @@ -113,32 +108,13 @@ func New(config Config) (*Console, error) { // init retrieves the available APIs from the remote RPC provider and initializes // the console's JavaScript namespaces based on the exposed modules. func (c *Console) init(preload []string) error { - // Initialize the JavaScript <-> Go RPC bridge - bridge := newBridge(c.client, c.prompter, c.printer, c.runtime) - c.jsre.Run("jeth = {};") - c.jsre.Run("console = {};") + // Initialize the JavaScript <-> Go RPC bridge. + bridge := newBridge(c.client, c.prompter, c.printer) + if err := c.initWeb3(bridge); err != nil { + return err + } + c.jsre.Do(func(vm *goja.Runtime) { c.initConsoleObject(vm) }) - jethObj := c.jsre.Get("jeth").ToObject(c.runtime) - jethObj.Set("send", bridge.Send) - jethObj.Set("sendAsync", bridge.Send) - - consoleObj := c.runtime.Get("console").ToObject(c.runtime) - consoleObj.Set("log", c.consoleOutput) - consoleObj.Set("error", c.consoleOutput) - - // Load all the internal utility JavaScript libraries - if err := c.jsre.Compile("bignumber.js", string(jsre.BignumberJs)); err != nil { - return fmt.Errorf("bignumber.js: %v", err) - } - if err := c.jsre.Compile("web3.js", string(jsre.Web3Js)); err != nil { - return fmt.Errorf("web3.js: %v", err) - } - if _, err := c.jsre.Run("var Web3 = require('web3');"); err != nil { - return fmt.Errorf("web3 require: %v", err) - } - if _, err := c.jsre.Run("var web3 = new Web3(jeth);"); err != nil { - return fmt.Errorf("web3 provider: %v", err) - } // Load the supported APIs into the JavaScript runtime environment apis, err := c.client.SupportedModules() if err != nil { @@ -155,7 +131,7 @@ func (c *Console) init(preload []string) error { return fmt.Errorf("%s.js: %v", api, err) } flatten += fmt.Sprintf("var %s = web3.%s; ", api, api) - } else if obj, err := c.jsre.Run("web3." + api); err == nil && obj.ToObject(c.runtime) != nil { + } else if _, err := c.jsre.Run("web3." + api); err == nil { // Enable web3.js built-in extension if available. flatten += fmt.Sprintf("var %s = web3.%s; ", api, api) } @@ -163,50 +139,12 @@ func (c *Console) init(preload []string) error { if _, err = c.jsre.Run(flatten); err != nil { return fmt.Errorf("namespace flattening: %v", err) } - // Initialize the global name register (disabled for now) - //c.jsre.Run(`var GlobalRegistrar = eth.contract(` + registrar.GlobalRegistrarAbi + `); registrar = GlobalRegistrar.at("` + registrar.GlobalRegistrarAddr + `");`) - // If the console is in interactive mode, instrument password related methods to query the user - if c.prompter != nil { - // Retrieve the account management object to instrument - personal := c.jsre.Get("personal") - if personal == nil { - return fmt.Errorf("could not find personal") - } - // Override the openWallet, unlockAccount, newAccount and sign methods since - // these require user interaction. Assign these method in the Console the - // original web3 callbacks. These will be called by the jeth.* methods after - // they got the password from the user and send the original web3 request to - // the backend. - if obj := personal.ToObject(c.runtime); obj != nil { // make sure the personal api is enabled over the interface - if _, err = c.jsre.Run(`jeth.openWallet = personal.openWallet;`); err != nil { - return fmt.Errorf("personal.openWallet: %v", err) - } - if _, err = c.jsre.Run(`jeth.unlockAccount = personal.unlockAccount;`); err != nil { - return fmt.Errorf("personal.unlockAccount: %v", err) - } - if _, err = c.jsre.Run(`jeth.newAccount = personal.newAccount;`); err != nil { - return fmt.Errorf("personal.newAccount: %v", err) - } - if _, err = c.jsre.Run(`jeth.sign = personal.sign;`); err != nil { - return fmt.Errorf("personal.sign: %v", err) - } - obj.Set("openWallet", bridge.OpenWallet) - obj.Set("unlockAccount", bridge.UnlockAccount) - obj.Set("newAccount", bridge.NewAccount) - obj.Set("sign", bridge.Sign) - } - } - // The admin.sleep and admin.sleepBlocks are offered by the console and not by the RPC layer. - admin := c.jsre.Get("admin") // Could be `nil` - if admin != nil { - // make sure the admin api is enabled over the interface - if obj := admin.ToObject(c.runtime); obj != nil { - obj.Set("sleepBlocks", bridge.SleepBlocks) - obj.Set("sleep", bridge.Sleep) - obj.Set("clearHistory", c.clearHistory) - } - } + c.jsre.Do(func(vm *goja.Runtime) { + c.initAdmin(vm, bridge) + c.initPersonal(vm, bridge) + }) + // Preload any JavaScript files before starting the console for _, path := range preload { if err := c.jsre.Exec(path); err != nil { @@ -217,7 +155,8 @@ func (c *Console) init(preload []string) error { return fmt.Errorf("%s: %v", path, failure) } } - // Configure the console's input prompter for scrollback and tab completion + + // Configure the console's input prompter for history and tab completion. if c.prompter != nil { if content, err := ioutil.ReadFile(c.histPath); err != nil { c.prompter.SetHistory(nil) @@ -230,6 +169,66 @@ func (c *Console) init(preload []string) error { return nil } +func (c *Console) initWeb3(bridge *bridge) error { + if err := c.jsre.Compile("bignumber.js", string(jsre.BignumberJs)); err != nil { + return fmt.Errorf("bignumber.js: %v", err) + } + if err := c.jsre.Compile("web3.js", string(jsre.Web3Js)); err != nil { + return fmt.Errorf("web3.js: %v", err) + } + if _, err := c.jsre.Run("var Web3 = require('web3');"); err != nil { + return fmt.Errorf("web3 require: %v", err) + } + var err error + c.jsre.Do(func(vm *goja.Runtime) { + transport := vm.NewObject() + transport.Set("send", jsre.MakeCallback(vm, bridge.Send)) + transport.Set("sendAsync", jsre.MakeCallback(vm, bridge.Send)) + vm.Set("_consoleWeb3Transport", transport) + _, err = vm.RunString("var web3 = new Web3(_consoleWeb3Transport)") + }) + return err +} + +func (c *Console) initConsoleObject(vm *goja.Runtime) { + console := vm.NewObject() + console.Set("log", c.consoleOutput) + console.Set("error", c.consoleOutput) + vm.Set("console", console) +} + +// initAdmin creates additional admin APIs implemented by the bridge. +func (c *Console) initAdmin(vm *goja.Runtime, bridge *bridge) { + if admin := getObject(vm, "admin"); admin != nil { + admin.Set("sleepBlocks", jsre.MakeCallback(vm, bridge.SleepBlocks)) + admin.Set("sleep", jsre.MakeCallback(vm, bridge.Sleep)) + admin.Set("clearHistory", c.clearHistory) + } +} + +// initPersonal redirects account-related API methods through the bridge. +// +// If the console is in interactive mode and the 'personal' API is available, override +// the openWallet, unlockAccount, newAccount and sign methods since these require user +// interaction. The original web3 callbacks are stored in 'jeth'. These will be called +// by the bridge after the prompt and send the original web3 request to the backend. +func (c *Console) initPersonal(vm *goja.Runtime, bridge *bridge) { + personal := getObject(vm, "personal") + if personal == nil || c.prompter == nil { + return + } + jeth := vm.NewObject() + vm.Set("jeth", jeth) + jeth.Set("openWallet", personal.Get("openWallet")) + jeth.Set("unlockAccount", personal.Get("unlockAccount")) + jeth.Set("newAccount", personal.Get("newAccount")) + jeth.Set("sign", personal.Get("sign")) + personal.Set("openWallet", jsre.MakeCallback(vm, bridge.OpenWallet)) + personal.Set("unlockAccount", jsre.MakeCallback(vm, bridge.UnlockAccount)) + personal.Set("newAccount", jsre.MakeCallback(vm, bridge.NewAccount)) + personal.Set("sign", jsre.MakeCallback(vm, bridge.Sign)) +} + func (c *Console) clearHistory() { c.history = nil c.prompter.ClearHistory() @@ -311,13 +310,13 @@ func (c *Console) Welcome() { // Evaluate executes code and pretty prints the result to the specified output // stream. -func (c *Console) Evaluate(statement string) error { +func (c *Console) Evaluate(statement string) { defer func() { if r := recover(); r != nil { fmt.Fprintf(c.printer, "[native] error: %v\n", r) } }() - return c.jsre.Evaluate(statement, c.printer) + c.jsre.Evaluate(statement, c.printer) } // Interactive starts an interactive user session, where input is propted from