aboutsummaryrefslogtreecommitdiffstats
path: root/javascript/types.go
blob: a6a0bc8e2b8c80868e4fbf7f75463837c59b4cde (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
package javascript

import (
    "fmt"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/state"
    "github.com/ethereum/go-ethereum/xeth"
    "github.com/obscuren/otto"
)

type JSStateObject struct {
    *xeth.Object
    eth *JSEthereum
}

func (self *JSStateObject) EachStorage(call otto.FunctionCall) otto.Value {
    cb := call.Argument(0)

    it := self.Object.Trie().Iterator()
    for it.Next() {
        cb.Call(self.eth.toVal(self), self.eth.toVal(common.Bytes2Hex(it.Key)), self.eth.toVal(common.Bytes2Hex(it.Value)))
    }

    return otto.UndefinedValue()
}

// The JSEthereum object attempts to wrap the PEthereum object and returns
// meaningful javascript objects
type JSBlock struct {
    *xeth.Block
    eth *JSEthereum
}

func (self *JSBlock) GetTransaction(hash string) otto.Value {
    return self.eth.toVal(self.Block.GetTransaction(hash))
}

type JSLog struct {
    Address string   `json:address`
    Topics  []string `json:topics`
    Number  int32    `json:number`
    Data    string   `json:data`
}

func NewJSLog(log state.Log) JSLog {
    return JSLog{
        Address: common.Bytes2Hex(log.Address()),
        Topics:  nil, //common.Bytes2Hex(log.Address()),
        Number:  0,
        Data:    common.Bytes2Hex(log.Data()),
    }
}

type JSEthereum struct {
    *xeth.XEth
    vm *otto.Otto
}

func (self *JSEthereum) Block(v interface{}) otto.Value {
    if number, ok := v.(int64); ok {
        return self.toVal(&JSBlock{self.XEth.BlockByNumber(number), self})
    } else if hash, ok := v.(string); ok {
        return self.toVal(&JSBlock{self.XEth.BlockByHash(hash), self})
    }

    return otto.UndefinedValue()
}

func (self *JSEthereum) GetStateObject(addr string) otto.Value {
    return self.toVal(&JSStateObject{self.XEth.State().SafeGet(addr), self})
}

func (self *JSEthereum) Transact(fromStr, recipient, valueStr, gasStr, gasPriceStr, dataStr string) otto.Value {
    r, err := self.XEth.Transact(fromStr, recipient, valueStr, gasStr, gasPriceStr, dataStr)
    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
}