mirror of https://github.com/ethereum/go-ethereum
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
281 lines
8.7 KiB
281 lines
8.7 KiB
// Copyright 2015 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package console
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/logger"
|
|
"github.com/ethereum/go-ethereum/logger/glog"
|
|
"github.com/ethereum/go-ethereum/rpc"
|
|
"github.com/robertkrimen/otto"
|
|
)
|
|
|
|
// 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
|
|
}
|
|
|
|
// newBridge creates a new JavaScript wrapper around an RPC client.
|
|
func newBridge(client *rpc.Client, prompter UserPrompter, printer io.Writer) *bridge {
|
|
return &bridge{
|
|
client: client,
|
|
prompter: prompter,
|
|
printer: printer,
|
|
}
|
|
}
|
|
|
|
// NewAccount is a wrapper around the personal.newAccount RPC method that uses a
|
|
// non-echoing password prompt to aquire 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 otto.FunctionCall) (response otto.Value) {
|
|
var (
|
|
password string
|
|
confirm string
|
|
err error
|
|
)
|
|
switch {
|
|
// No password was specified, prompt the user for it
|
|
case len(call.ArgumentList) == 0:
|
|
if password, err = b.prompter.PromptPassword("Passphrase: "); err != nil {
|
|
throwJSException(err.Error())
|
|
}
|
|
if confirm, err = b.prompter.PromptPassword("Repeat passphrase: "); err != nil {
|
|
throwJSException(err.Error())
|
|
}
|
|
if password != confirm {
|
|
throwJSException("passphrases don't match!")
|
|
}
|
|
|
|
// A single string password was specified, use that
|
|
case len(call.ArgumentList) == 1 && call.Argument(0).IsString():
|
|
password, _ = call.Argument(0).ToString()
|
|
|
|
// Otherwise fail with some error
|
|
default:
|
|
throwJSException("expected 0 or 1 string argument")
|
|
}
|
|
// Password aquired, execute the call and return
|
|
ret, err := call.Otto.Call("jeth.newAccount", nil, password)
|
|
if err != nil {
|
|
throwJSException(err.Error())
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// UnlockAccount is a wrapper around the personal.unlockAccount RPC method that
|
|
// uses a non-echoing password prompt to aquire 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 otto.FunctionCall) (response otto.Value) {
|
|
// Make sure we have an account specified to unlock
|
|
if !call.Argument(0).IsString() {
|
|
throwJSException("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
|
|
var passwd otto.Value
|
|
|
|
if call.Argument(1).IsUndefined() || call.Argument(1).IsNull() {
|
|
fmt.Fprintf(b.printer, "Unlock account %s\n", account)
|
|
if input, err := b.prompter.PromptPassword("Passphrase: "); err != nil {
|
|
throwJSException(err.Error())
|
|
} else {
|
|
passwd, _ = otto.ToValue(input)
|
|
}
|
|
} else {
|
|
if !call.Argument(1).IsString() {
|
|
throwJSException("password must be a string")
|
|
}
|
|
passwd = call.Argument(1)
|
|
}
|
|
// Third argument is the duration how long the account must be unlocked.
|
|
duration := otto.NullValue()
|
|
if call.Argument(2).IsDefined() && !call.Argument(2).IsNull() {
|
|
if !call.Argument(2).IsNumber() {
|
|
throwJSException("unlock duration must be a number")
|
|
}
|
|
duration = call.Argument(2)
|
|
}
|
|
// Send the request to the backend and return
|
|
val, err := call.Otto.Call("jeth.unlockAccount", nil, account, passwd, duration)
|
|
if err != nil {
|
|
throwJSException(err.Error())
|
|
}
|
|
return val
|
|
}
|
|
|
|
// Sleep will block the console for the specified number of seconds.
|
|
func (b *bridge) Sleep(call otto.FunctionCall) (response otto.Value) {
|
|
if call.Argument(0).IsNumber() {
|
|
sleep, _ := call.Argument(0).ToInteger()
|
|
time.Sleep(time.Duration(sleep) * time.Second)
|
|
return otto.TrueValue()
|
|
}
|
|
return throwJSException("usage: sleep(<number of seconds>)")
|
|
}
|
|
|
|
// SleepBlocks will block the console for a specified number of new blocks optionally
|
|
// until the given timeout is reached.
|
|
func (b *bridge) SleepBlocks(call otto.FunctionCall) (response otto.Value) {
|
|
var (
|
|
blocks = int64(0)
|
|
sleep = int64(9999999999999999) // indefinitely
|
|
)
|
|
// Parse the input parameters for the sleep
|
|
nArgs := len(call.ArgumentList)
|
|
if nArgs == 0 {
|
|
throwJSException("usage: sleepBlocks(<n blocks>[, max sleep in seconds])")
|
|
}
|
|
if nArgs >= 1 {
|
|
if call.Argument(0).IsNumber() {
|
|
blocks, _ = call.Argument(0).ToInteger()
|
|
} else {
|
|
throwJSException("expected number as first argument")
|
|
}
|
|
}
|
|
if nArgs >= 2 {
|
|
if call.Argument(1).IsNumber() {
|
|
sleep, _ = call.Argument(1).ToInteger()
|
|
} else {
|
|
throwJSException("expected number as second argument")
|
|
}
|
|
}
|
|
// go through the console, this will allow web3 to call the appropriate
|
|
// callbacks if a delayed response or notification is received.
|
|
blockNumber := func() int64 {
|
|
result, err := call.Otto.Run("eth.blockNumber")
|
|
if err != nil {
|
|
throwJSException(err.Error())
|
|
}
|
|
block, err := result.ToInteger()
|
|
if err != nil {
|
|
throwJSException(err.Error())
|
|
}
|
|
return block
|
|
}
|
|
// 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)
|
|
|
|
for time.Now().Before(deadline) {
|
|
if blockNumber() >= targetBlockNr {
|
|
return otto.TrueValue()
|
|
}
|
|
time.Sleep(time.Second)
|
|
}
|
|
return otto.FalseValue()
|
|
}
|
|
|
|
type jsonrpcCall struct {
|
|
Id int64
|
|
Method string
|
|
Params []interface{}
|
|
}
|
|
|
|
// Send implements the web3 provider "send" method.
|
|
func (b *bridge) Send(call otto.FunctionCall) (response otto.Value) {
|
|
// Remarshal the request into a Go value.
|
|
JSON, _ := call.Otto.Object("JSON")
|
|
reqVal, err := JSON.Call("stringify", call.Argument(0))
|
|
if err != nil {
|
|
throwJSException(err.Error())
|
|
}
|
|
var (
|
|
rawReq = []byte(reqVal.String())
|
|
reqs []jsonrpcCall
|
|
batch bool
|
|
)
|
|
if rawReq[0] == '[' {
|
|
batch = true
|
|
json.Unmarshal(rawReq, &reqs)
|
|
} else {
|
|
batch = false
|
|
reqs = make([]jsonrpcCall, 1)
|
|
json.Unmarshal(rawReq, &reqs[0])
|
|
}
|
|
|
|
// Execute the requests.
|
|
resps, _ := call.Otto.Object("new Array()")
|
|
for _, req := range reqs {
|
|
resp, _ := call.Otto.Object(`({"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) {
|
|
case nil:
|
|
if result == nil {
|
|
// Special case null because it is decoded as an empty
|
|
// raw message for some reason.
|
|
resp.Set("result", otto.NullValue())
|
|
} else {
|
|
resultVal, err := JSON.Call("parse", string(result))
|
|
if err != nil {
|
|
resp = newErrorResponse(call, -32603, err.Error(), &req.Id).Object()
|
|
} else {
|
|
resp.Set("result", resultVal)
|
|
}
|
|
}
|
|
case rpc.Error:
|
|
resp.Set("error", map[string]interface{}{
|
|
"code": err.ErrorCode(),
|
|
"message": err.Error(),
|
|
})
|
|
default:
|
|
resp = newErrorResponse(call, -32603, err.Error(), &req.Id).Object()
|
|
}
|
|
resps.Call("push", resp)
|
|
}
|
|
|
|
// Return the responses either to the callback (if supplied)
|
|
// or directly as the return value.
|
|
if batch {
|
|
response = resps.Value()
|
|
} else {
|
|
response, _ = resps.Get("0")
|
|
}
|
|
if fn := call.Argument(1).Object(); fn != nil && fn.Class() == "function" {
|
|
fn.Call("apply", response)
|
|
return otto.UndefinedValue()
|
|
}
|
|
return response
|
|
}
|
|
|
|
func newErrorResponse(call otto.FunctionCall, code int, msg string, id interface{}) otto.Value {
|
|
// Bundle the error into a JSON RPC call response
|
|
m := map[string]interface{}{"version": "2.0", "id": id, "error": map[string]interface{}{"code": code, msg: msg}}
|
|
res, _ := json.Marshal(m)
|
|
val, _ := call.Otto.Run("(" + string(res) + ")")
|
|
return val
|
|
}
|
|
|
|
// throwJSException panics on an otto.Value. The Otto VM will recover from the
|
|
// Go panic and throw msg as a JavaScript error.
|
|
func throwJSException(msg interface{}) otto.Value {
|
|
val, err := otto.ToValue(msg)
|
|
if err != nil {
|
|
glog.V(logger.Error).Infof("Failed to serialize JavaScript exception %v: %v", msg, err)
|
|
}
|
|
panic(val)
|
|
}
|
|
|