aboutsummaryrefslogblamecommitdiffstats
path: root/console/bridge.go
blob: 22ed7192bb4a9fc64eeee6abce2a10c4f8e50d97 (plain) (tree)
































                                                                                  
                                                                                




                                                                                  
                                                                                      





















































































































































                                                                                                






                                                   
                                                                     


                                                               


                                             
             


                                                
         



                                             
                             

                                                
         
 



























                                                                                                            
                 

                                        
 





                                                                    
         

                                                                     
                                            
         








                                                                                                                        










                                                                                                       
// 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); fn.Class() == "Function" {
        fn.Call(otto.NullValue(), otto.NullValue(), 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)
}