aboutsummaryrefslogtreecommitdiffstats
path: root/cmd/geth/js.go
blob: 95cf85e4ba3ec9729258ec8b8b762de977f83860 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
// Copyright 2015 The go-ethereum Authors
// This file is part of go-ethereum.
//
// go-ethereum is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// go-ethereum 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.

package main

import (
    "fmt"
    "math/big"
    "os"
    "os/signal"
    "path/filepath"
    "regexp"
    "sort"
    "strings"

    "github.com/codegangsta/cli"
    "github.com/ethereum/go-ethereum/accounts"
    "github.com/ethereum/go-ethereum/cmd/utils"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/common/registrar"
    "github.com/ethereum/go-ethereum/eth"
    re "github.com/ethereum/go-ethereum/jsre"
    "github.com/ethereum/go-ethereum/node"
    "github.com/ethereum/go-ethereum/rpc"
    "github.com/peterh/liner"
    "github.com/robertkrimen/otto"
)

var (
    passwordRegexp = regexp.MustCompile("personal.[nu]")
    leadingSpace   = regexp.MustCompile("^ ")
    onlyws         = regexp.MustCompile("^\\s*$")
    exit           = regexp.MustCompile("^\\s*exit\\s*;*\\s*$")
)

type jsre struct {
    re         *re.JSRE
    stack      *node.Node
    wait       chan *big.Int
    ps1        string
    atexit     func()
    corsDomain string
    client     rpc.Client
}

func makeCompleter(re *jsre) liner.WordCompleter {
    return func(line string, pos int) (head string, completions []string, tail string) {
        if len(line) == 0 || pos == 0 {
            return "", nil, ""
        }
        // chuck data to relevant part for autocompletion, e.g. in case of nested lines eth.getBalance(eth.coinb<tab><tab>
        i := 0
        for i = pos - 1; i > 0; i-- {
            if line[i] == '.' || (line[i] >= 'a' && line[i] <= 'z') || (line[i] >= 'A' && line[i] <= 'Z') {
                continue
            }
            if i >= 3 && line[i] == '3' && line[i-3] == 'w' && line[i-2] == 'e' && line[i-1] == 'b' {
                continue
            }
            i += 1
            break
        }
        return line[:i], re.re.CompleteKeywords(line[i:pos]), line[pos:]
    }
}

func newLightweightJSRE(docRoot string, client rpc.Client, datadir string, interactive bool) *jsre {
    js := &jsre{ps1: "> "}
    js.wait = make(chan *big.Int)
    js.client = client
    js.re = re.New(docRoot)
    if err := js.apiBindings(); err != nil {
        utils.Fatalf("Unable to initialize console - %v", err)
    }
    js.setupInput(datadir)
    return js
}

func newJSRE(stack *node.Node, docRoot, corsDomain string, client rpc.Client, interactive bool) *jsre {
    js := &jsre{stack: stack, ps1: "> "}
    // set default cors domain used by startRpc from CLI flag
    js.corsDomain = corsDomain
    js.wait = make(chan *big.Int)
    js.client = client
    js.re = re.New(docRoot)
    if err := js.apiBindings(); err != nil {
        utils.Fatalf("Unable to connect - %v", err)
    }
    js.setupInput(stack.DataDir())
    return js
}

func (self *jsre) setupInput(datadir string) {
    self.withHistory(datadir, func(hist *os.File) { utils.Stdin.ReadHistory(hist) })
    utils.Stdin.SetCtrlCAborts(true)
    utils.Stdin.SetWordCompleter(makeCompleter(self))
    utils.Stdin.SetTabCompletionStyle(liner.TabPrints)
    self.atexit = func() {
        self.withHistory(datadir, func(hist *os.File) {
            hist.Truncate(0)
            utils.Stdin.WriteHistory(hist)
        })
        utils.Stdin.Close()
        close(self.wait)
    }
}

func (self *jsre) batch(statement string) {
    err := self.re.EvalAndPrettyPrint(statement)

    if err != nil {
        fmt.Printf("error: %v", err)
    }

    if self.atexit != nil {
        self.atexit()
    }

    self.re.Stop(false)
}

// show summary of current geth instance
func (self *jsre) welcome() {
    self.re.Run(`
    (function () {
      console.log('instance: ' + web3.version.node);
      console.log("coinbase: " + eth.coinbase);
      var ts = 1000 * eth.getBlock(eth.blockNumber).timestamp;
      console.log("at block: " + eth.blockNumber + " (" + new Date(ts) + ")");
      console.log(' datadir: ' + admin.datadir);
    })();
  `)
    if modules, err := self.supportedApis(); err == nil {
        loadedModules := make([]string, 0)
        for api, version := range modules {
            loadedModules = append(loadedModules, fmt.Sprintf("%s:%s", api, version))
        }
        sort.Strings(loadedModules)
    }
}

func (self *jsre) supportedApis() (map[string]string, error) {
    return self.client.SupportedModules()
}

func (js *jsre) apiBindings() error {
    apis, err := js.supportedApis()
    if err != nil {
        return err
    }

    apiNames := make([]string, 0, len(apis))
    for a, _ := range apis {
        apiNames = append(apiNames, a)
    }

    jeth := utils.NewJeth(js.re, js.client)
    js.re.Set("jeth", struct{}{})
    t, _ := js.re.Get("jeth")
    jethObj := t.Object()

    jethObj.Set("send", jeth.Send)
    jethObj.Set("sendAsync", jeth.Send)

    err = js.re.Compile("bignumber.js", re.BigNumber_JS)
    if err != nil {
        utils.Fatalf("Error loading bignumber.js: %v", err)
    }

    err = js.re.Compile("web3.js", re.Web3_JS)
    if err != nil {
        utils.Fatalf("Error loading web3.js: %v", err)
    }

    _, err = js.re.Run("var Web3 = require('web3');")
    if err != nil {
        utils.Fatalf("Error requiring web3: %v", err)
    }

    _, err = js.re.Run("var web3 = new Web3(jeth);")
    if err != nil {
        utils.Fatalf("Error setting web3 provider: %v", err)
    }

    // load only supported API's in javascript runtime
    shortcuts := "var eth = web3.eth; var personal = web3.personal; "
    for _, apiName := range apiNames {
        if apiName == "web3" || apiName == "rpc" {
            continue // manually mapped or ignore
        }

        if jsFile, ok := rpc.WEB3Extensions[apiName]; ok {
            if err = js.re.Compile(fmt.Sprintf("%s.js", apiName), jsFile); err == nil {
                shortcuts += fmt.Sprintf("var %s = web3.%s; ", apiName, apiName)
            } else {
                utils.Fatalf("Error loading %s.js: %v", apiName, err)
            }
        }
    }

    _, err = js.re.Run(shortcuts)
    if err != nil {
        utils.Fatalf("Error setting namespaces: %v", err)
    }

    js.re.Run(`var GlobalRegistrar = eth.contract(` + registrar.GlobalRegistrarAbi + `);   registrar = GlobalRegistrar.at("` + registrar.GlobalRegistrarAddr + `");`)

    // overrule some of the methods that require password as input and ask for it interactively
    p, err := js.re.Get("personal")
    if err != nil {
        fmt.Println("Unable to overrule sensitive methods in personal module")
        return nil
    }

    // Override the unlockAccount and newAccount methods on the personal object since these require user interaction.
    // Assign the jeth.unlockAccount and jeth.newAccount in the jsre 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 persObj := p.Object(); persObj != nil { // make sure the personal api is enabled over the interface
        js.re.Run(`jeth.unlockAccount = personal.unlockAccount;`)
        persObj.Set("unlockAccount", jeth.UnlockAccount)
        js.re.Run(`jeth.newAccount = personal.newAccount;`)
        persObj.Set("newAccount", jeth.NewAccount)
    }

    // The admin.sleep and admin.sleepBlocks are offered by the console and not by the RPC layer.
    // Bind these if the admin module is available.
    if a, err := js.re.Get("admin"); err == nil {
        if adminObj := a.Object(); adminObj != nil {
            adminObj.Set("sleepBlocks", jeth.SleepBlocks)
            adminObj.Set("sleep", jeth.Sleep)
        }
    }

    return nil
}

func (self *jsre) AskPassword() (string, bool) {
    pass, err := utils.Stdin.PasswordPrompt("Passphrase: ")
    if err != nil {
        return "", false
    }
    return pass, true
}

func (self *jsre) ConfirmTransaction(tx string) bool {
    // Retrieve the Ethereum instance from the node
    var ethereum *eth.Ethereum
    if err := self.stack.Service(&ethereum); err != nil {
        return false
    }
    // If natspec is enabled, ask for permission
    if ethereum.NatSpec && false /* disabled for now */ {
        //      notice := natspec.GetNotice(self.xeth, tx, ethereum.HTTPClient())
        //      fmt.Println(notice)
        //      answer, _ := self.Prompt("Confirm Transaction [y/n]")
        //      return strings.HasPrefix(strings.Trim(answer, " "), "y")
    }
    return true
}

func (self *jsre) UnlockAccount(addr []byte) bool {
    fmt.Printf("Please unlock account %x.\n", addr)
    pass, err := utils.Stdin.PasswordPrompt("Passphrase: ")
    if err != nil {
        return false
    }
    // TODO: allow retry
    var ethereum *eth.Ethereum
    if err := self.stack.Service(&ethereum); err != nil {
        return false
    }
    a := accounts.Account{Address: common.BytesToAddress(addr)}
    if err := ethereum.AccountManager().Unlock(a, pass); err != nil {
        return false
    } else {
        fmt.Println("Account is now unlocked for this session.")
        return true
    }
}

// preloadJSFiles loads JS files that the user has specified with ctx.PreLoadJSFlag into
// the JSRE. If not all files could be loaded it will return an error describing the error.
func (self *jsre) preloadJSFiles(ctx *cli.Context) error {
    if ctx.GlobalString(utils.PreLoadJSFlag.Name) != "" {
        assetPath := ctx.GlobalString(utils.JSpathFlag.Name)
        jsFiles := strings.Split(ctx.GlobalString(utils.PreLoadJSFlag.Name), ",")
        for _, file := range jsFiles {
            filename := common.AbsolutePath(assetPath, strings.TrimSpace(file))
            if err := self.re.Exec(filename); err != nil {
                return fmt.Errorf("%s: %v", file, err)
            }
        }
    }
    return nil
}

// exec executes the JS file with the given filename and stops the JSRE
func (self *jsre) exec(filename string) error {
    if err := self.re.Exec(filename); err != nil {
        self.re.Stop(false)
        return fmt.Errorf("Javascript Error: %v", err)
    }
    self.re.Stop(true)
    return nil
}

func (self *jsre) interactive() {
    // Read input lines.
    prompt := make(chan string)
    inputln := make(chan string)
    go func() {
        defer close(inputln)
        for {
            line, err := utils.Stdin.Prompt(<-prompt)
            if err != nil {
                if err == liner.ErrPromptAborted { // ctrl-C
                    self.resetPrompt()
                    inputln <- ""
                    continue
                }
                return
            }
            inputln <- line
        }
    }()
    // Wait for Ctrl-C, too.
    sig := make(chan os.Signal, 1)
    signal.Notify(sig, os.Interrupt)

    defer func() {
        if self.atexit != nil {
            self.atexit()
        }
        self.re.Stop(false)
    }()
    for {
        prompt <- self.ps1
        select {
        case <-sig:
            fmt.Println("caught interrupt, exiting")
            return
        case input, ok := <-inputln:
            if !ok || indentCount <= 0 && exit.MatchString(input) {
                return
            }
            if onlyws.MatchString(input) {
                continue
            }
            str += input + "\n"
            self.setIndent()
            if indentCount <= 0 {
                if mustLogInHistory(str) {
                    utils.Stdin.AppendHistory(str[:len(str)-1])
                }
                self.parseInput(str)
                str = ""
            }
        }
    }
}

func mustLogInHistory(input string) bool {
    return len(input) == 0 ||
        passwordRegexp.MatchString(input) ||
        !leadingSpace.MatchString(input)
}

func (self *jsre) withHistory(datadir string, op func(*os.File)) {
    hist, err := os.OpenFile(filepath.Join(datadir, "history"), os.O_RDWR|os.O_CREATE, os.ModePerm)
    if err != nil {
        fmt.Printf("unable to open history file: %v\n", err)
        return
    }
    op(hist)
    hist.Close()
}

func (self *jsre) parseInput(code string) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("[native] error", r)
        }
    }()
    if err := self.re.EvalAndPrettyPrint(code); err != nil {
        if ottoErr, ok := err.(*otto.Error); ok {
            fmt.Println(ottoErr.String())
        } else {
            fmt.Println(err)
        }
        return
    }
}

var indentCount = 0
var str = ""

func (self *jsre) resetPrompt() {
    indentCount = 0
    str = ""
    self.ps1 = "> "
}

func (self *jsre) setIndent() {
    open := strings.Count(str, "{")
    open += strings.Count(str, "(")
    closed := strings.Count(str, "}")
    closed += strings.Count(str, ")")
    indentCount = open - closed
    if indentCount <= 0 {
        self.ps1 = "> "
    } else {
        self.ps1 = strings.Join(make([]string, indentCount*2), "..")
        self.ps1 += " "
    }
}