From 1146f25015b6d84072b71c490aba246e3010bd87 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 28 Jan 2015 18:25:50 +0100 Subject: [PATCH 1/2] clean up of xeth --- xeth/config.go | 37 --------- xeth/hexface.go | 211 ------------------------------------------------ xeth/xeth.go | 211 +++++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 210 insertions(+), 249 deletions(-) delete mode 100644 xeth/config.go delete mode 100644 xeth/hexface.go diff --git a/xeth/config.go b/xeth/config.go deleted file mode 100644 index db6cce3bd..000000000 --- a/xeth/config.go +++ /dev/null @@ -1,37 +0,0 @@ -package xeth - -/* -import "github.com/ethereum/go-ethereum/ethutil" - -var cnfCtr = ethutil.Hex2Bytes("661005d2720d855f1d9976f88bb10c1a3398c77f") - -type Config struct { - pipe *XEth -} - -func (self *Config) Get(name string) *Object { - configCtrl := self.pipe.World().safeGet(cnfCtr) - var addr []byte - - switch name { - case "NameReg": - addr = []byte{0} - case "DnsReg": - objectAddr := configCtrl.GetStorage(ethutil.BigD([]byte{0})) - domainAddr := (&Object{self.pipe.World().safeGet(objectAddr.Bytes())}).StorageString("DnsReg").Bytes() - return &Object{self.pipe.World().safeGet(domainAddr)} - case "MergeMining": - addr = []byte{4} - default: - addr = ethutil.RightPadBytes([]byte(name), 32) - } - - objectAddr := configCtrl.GetStorage(ethutil.BigD(addr)) - - return &Object{self.pipe.World().safeGet(objectAddr.Bytes())} -} - -func (self *Config) Exist() bool { - return self.pipe.World().Get(cnfCtr) != nil -} -*/ diff --git a/xeth/hexface.go b/xeth/hexface.go deleted file mode 100644 index 3eb535724..000000000 --- a/xeth/hexface.go +++ /dev/null @@ -1,211 +0,0 @@ -package xeth - -import ( - "bytes" - "encoding/json" - - "github.com/ethereum/go-ethereum/core" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" - "github.com/ethereum/go-ethereum/state" -) - -// to resolve the import cycle -type Backend interface { - BlockProcessor() *core.BlockProcessor - ChainManager() *core.ChainManager - Coinbase() []byte - KeyManager() *crypto.KeyManager - IsMining() bool - IsListening() bool - PeerCount() int - Db() ethutil.Database - TxPool() *core.TxPool -} - -type JSXEth struct { - eth Backend - blockProcessor *core.BlockProcessor - chainManager *core.ChainManager - world *State -} - -func NewJSXEth(eth Backend) *JSXEth { - xeth := &JSXEth{ - eth: eth, - blockProcessor: eth.BlockProcessor(), - chainManager: eth.ChainManager(), - } - xeth.world = NewState(xeth) - - return xeth -} - -func (self *JSXEth) State() *State { return self.world } - -func (self *JSXEth) BlockByHash(strHash string) *JSBlock { - hash := fromHex(strHash) - block := self.chainManager.GetBlock(hash) - - return NewJSBlock(block) -} - -func (self *JSXEth) BlockByNumber(num int32) *JSBlock { - if num == -1 { - return NewJSBlock(self.chainManager.CurrentBlock()) - } - - return NewJSBlock(self.chainManager.GetBlockByNumber(uint64(num))) -} - -func (self *JSXEth) Block(v interface{}) *JSBlock { - if n, ok := v.(int32); ok { - return self.BlockByNumber(n) - } else if str, ok := v.(string); ok { - return self.BlockByHash(str) - } else if f, ok := v.(float64); ok { // Don't ask ... - return self.BlockByNumber(int32(f)) - } - - return nil -} - -func (self *JSXEth) Accounts() []string { - return []string{toHex(self.eth.KeyManager().Address())} -} - -/* -func (self *JSXEth) StateObject(addr string) *JSObject { - object := &Object{self.State().safeGet(fromHex(addr))} - - return NewJSObject(object) -} -*/ - -func (self *JSXEth) PeerCount() int { - return self.eth.PeerCount() -} - -func (self *JSXEth) IsMining() bool { - return self.eth.IsMining() -} - -func (self *JSXEth) IsListening() bool { - return self.eth.IsListening() -} - -func (self *JSXEth) Coinbase() string { - return toHex(self.eth.KeyManager().Address()) -} - -func (self *JSXEth) NumberToHuman(balance string) string { - b := ethutil.Big(balance) - - return ethutil.CurrencyToString(b) -} - -func (self *JSXEth) StorageAt(addr, storageAddr string) string { - storage := self.State().SafeGet(addr).StorageString(storageAddr) - - return toHex(storage.Bytes()) -} - -func (self *JSXEth) BalanceAt(addr string) string { - return self.State().SafeGet(addr).Balance().String() -} - -func (self *JSXEth) TxCountAt(address string) int { - return int(self.State().SafeGet(address).Nonce) -} - -func (self *JSXEth) CodeAt(address string) string { - return toHex(self.State().SafeGet(address).Code) -} - -func (self *JSXEth) IsContract(address string) bool { - return len(self.State().SafeGet(address).Code) > 0 -} - -func (self *JSXEth) SecretToAddress(key string) string { - pair, err := crypto.NewKeyPairFromSec(fromHex(key)) - if err != nil { - return "" - } - - return toHex(pair.Address()) -} - -func (self *JSXEth) Execute(addr, value, gas, price, data string) (string, error) { - return "", nil -} - -type KeyVal struct { - Key string `json:"key"` - Value string `json:"value"` -} - -func (self *JSXEth) EachStorage(addr string) string { - var values []KeyVal - object := self.State().SafeGet(addr) - it := object.Trie().Iterator() - for it.Next() { - values = append(values, KeyVal{toHex(it.Key), toHex(it.Value)}) - } - - valuesJson, err := json.Marshal(values) - if err != nil { - return "" - } - - return string(valuesJson) -} - -func (self *JSXEth) ToAscii(str string) string { - padded := ethutil.RightPadBytes([]byte(str), 32) - - return "0x" + toHex(padded) -} - -func (self *JSXEth) FromAscii(str string) string { - if ethutil.IsHex(str) { - str = str[2:] - } - - return string(bytes.Trim(fromHex(str), "\x00")) -} - -func (self *JSXEth) FromNumber(str string) string { - if ethutil.IsHex(str) { - str = str[2:] - } - - return ethutil.BigD(fromHex(str)).String() -} - -func (self *JSXEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) { - return "", nil -} - -func ToJSMessages(messages state.Messages) *ethutil.List { - var msgs []JSMessage - for _, m := range messages { - msgs = append(msgs, NewJSMessage(m)) - } - - return ethutil.NewList(msgs) -} - -func (self *JSXEth) PushTx(encodedTx string) (string, error) { - tx := types.NewTransactionFromBytes(fromHex(encodedTx)) - err := self.eth.TxPool().Add(tx) - if err != nil { - return "", err - } - - if tx.To() == nil { - addr := core.AddressFromMessage(tx) - return toHex(addr), nil - } - return toHex(tx.Hash()), nil -} diff --git a/xeth/xeth.go b/xeth/xeth.go index 92b9bc995..6b491b0fe 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -4,6 +4,215 @@ package xeth * eXtended ETHereum */ -import "github.com/ethereum/go-ethereum/logger" +import ( + "bytes" + "encoding/json" + + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/state" +) var pipelogger = logger.NewLogger("XETH") + +// to resolve the import cycle +type Backend interface { + BlockProcessor() *core.BlockProcessor + ChainManager() *core.ChainManager + Coinbase() []byte + KeyManager() *crypto.KeyManager + IsMining() bool + IsListening() bool + PeerCount() int + Db() ethutil.Database + TxPool() *core.TxPool +} + +type JSXEth struct { + eth Backend + blockProcessor *core.BlockProcessor + chainManager *core.ChainManager + world *State +} + +func NewJSXEth(eth Backend) *JSXEth { + xeth := &JSXEth{ + eth: eth, + blockProcessor: eth.BlockProcessor(), + chainManager: eth.ChainManager(), + } + xeth.world = NewState(xeth) + + return xeth +} + +func (self *JSXEth) State() *State { return self.world } + +func (self *JSXEth) BlockByHash(strHash string) *JSBlock { + hash := fromHex(strHash) + block := self.chainManager.GetBlock(hash) + + return NewJSBlock(block) +} + +func (self *JSXEth) BlockByNumber(num int32) *JSBlock { + if num == -1 { + return NewJSBlock(self.chainManager.CurrentBlock()) + } + + return NewJSBlock(self.chainManager.GetBlockByNumber(uint64(num))) +} + +func (self *JSXEth) Block(v interface{}) *JSBlock { + if n, ok := v.(int32); ok { + return self.BlockByNumber(n) + } else if str, ok := v.(string); ok { + return self.BlockByHash(str) + } else if f, ok := v.(float64); ok { // Don't ask ... + return self.BlockByNumber(int32(f)) + } + + return nil +} + +func (self *JSXEth) Accounts() []string { + return []string{toHex(self.eth.KeyManager().Address())} +} + +/* +func (self *JSXEth) StateObject(addr string) *JSObject { + object := &Object{self.State().safeGet(fromHex(addr))} + + return NewJSObject(object) +} +*/ + +func (self *JSXEth) PeerCount() int { + return self.eth.PeerCount() +} + +func (self *JSXEth) IsMining() bool { + return self.eth.IsMining() +} + +func (self *JSXEth) IsListening() bool { + return self.eth.IsListening() +} + +func (self *JSXEth) Coinbase() string { + return toHex(self.eth.KeyManager().Address()) +} + +func (self *JSXEth) NumberToHuman(balance string) string { + b := ethutil.Big(balance) + + return ethutil.CurrencyToString(b) +} + +func (self *JSXEth) StorageAt(addr, storageAddr string) string { + storage := self.State().SafeGet(addr).StorageString(storageAddr) + + return toHex(storage.Bytes()) +} + +func (self *JSXEth) BalanceAt(addr string) string { + return self.State().SafeGet(addr).Balance().String() +} + +func (self *JSXEth) TxCountAt(address string) int { + return int(self.State().SafeGet(address).Nonce) +} + +func (self *JSXEth) CodeAt(address string) string { + return toHex(self.State().SafeGet(address).Code) +} + +func (self *JSXEth) IsContract(address string) bool { + return len(self.State().SafeGet(address).Code) > 0 +} + +func (self *JSXEth) SecretToAddress(key string) string { + pair, err := crypto.NewKeyPairFromSec(fromHex(key)) + if err != nil { + return "" + } + + return toHex(pair.Address()) +} + +func (self *JSXEth) Execute(addr, value, gas, price, data string) (string, error) { + return "", nil +} + +type KeyVal struct { + Key string `json:"key"` + Value string `json:"value"` +} + +func (self *JSXEth) EachStorage(addr string) string { + var values []KeyVal + object := self.State().SafeGet(addr) + it := object.Trie().Iterator() + for it.Next() { + values = append(values, KeyVal{toHex(it.Key), toHex(it.Value)}) + } + + valuesJson, err := json.Marshal(values) + if err != nil { + return "" + } + + return string(valuesJson) +} + +func (self *JSXEth) ToAscii(str string) string { + padded := ethutil.RightPadBytes([]byte(str), 32) + + return "0x" + toHex(padded) +} + +func (self *JSXEth) FromAscii(str string) string { + if ethutil.IsHex(str) { + str = str[2:] + } + + return string(bytes.Trim(fromHex(str), "\x00")) +} + +func (self *JSXEth) FromNumber(str string) string { + if ethutil.IsHex(str) { + str = str[2:] + } + + return ethutil.BigD(fromHex(str)).String() +} + +func (self *JSXEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) { + return "", nil +} + +func ToJSMessages(messages state.Messages) *ethutil.List { + var msgs []JSMessage + for _, m := range messages { + msgs = append(msgs, NewJSMessage(m)) + } + + return ethutil.NewList(msgs) +} + +func (self *JSXEth) PushTx(encodedTx string) (string, error) { + tx := types.NewTransactionFromBytes(fromHex(encodedTx)) + err := self.eth.TxPool().Add(tx) + if err != nil { + return "", err + } + + if tx.To() == nil { + addr := core.AddressFromMessage(tx) + return toHex(addr), nil + } + return toHex(tx.Hash()), nil +} From 872b2497114209119becf2e8a4d4a5818e2084ee Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 28 Jan 2015 18:35:49 +0100 Subject: [PATCH 2/2] further cleaned up xeth interface --- cmd/mist/ext_app.go | 4 +- cmd/mist/gui.go | 12 ++--- cmd/mist/html_container.go | 2 +- cmd/mist/qml_container.go | 2 +- cmd/mist/ui_lib.go | 12 ++--- cmd/utils/cmd.go | 2 +- javascript/javascript_runtime.go | 4 +- javascript/types.go | 18 +++---- rpc/http/server.go | 4 +- rpc/packages.go | 10 ++-- rpc/ws/server.go | 2 +- xeth/object.go | 26 ---------- xeth/{js_types.go => types.go} | 86 +++++++++++++++++++------------- xeth/world.go | 4 +- xeth/xeth.go | 68 ++++++++++++------------- 15 files changed, 123 insertions(+), 133 deletions(-) delete mode 100644 xeth/object.go rename xeth/{js_types.go => types.go} (72%) diff --git a/cmd/mist/ext_app.go b/cmd/mist/ext_app.go index 012c94923..bc856cd72 100644 --- a/cmd/mist/ext_app.go +++ b/cmd/mist/ext_app.go @@ -47,7 +47,7 @@ type AppContainer interface { } type ExtApplication struct { - *xeth.JSXEth + *xeth.XEth eth core.EthManager events event.Subscription @@ -61,7 +61,7 @@ type ExtApplication struct { func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication { return &ExtApplication{ - JSXEth: xeth.NewJSXEth(lib.eth), + XEth: xeth.New(lib.eth), eth: lib.eth, watcherQuitChan: make(chan bool), filters: make(map[string]*core.Filter), diff --git a/cmd/mist/gui.go b/cmd/mist/gui.go index 6522c865d..e053c82c4 100644 --- a/cmd/mist/gui.go +++ b/cmd/mist/gui.go @@ -75,7 +75,7 @@ type Gui struct { logLevel logger.LogLevel open bool - xeth *xeth.JSXEth + xeth *xeth.XEth Session string clientIdentity *p2p.SimpleClientIdentity @@ -93,7 +93,7 @@ func NewWindow(ethereum *eth.Ethereum, config *ethutil.ConfigManager, clientIden panic(err) } - xeth := xeth.NewJSXEth(ethereum) + xeth := xeth.New(ethereum) gui := &Gui{eth: ethereum, txDb: db, xeth: xeth, @@ -120,9 +120,9 @@ func (gui *Gui) Start(assetPath string) { // Register ethereum functions qml.RegisterTypes("Ethereum", 1, 0, []qml.TypeSpec{{ - Init: func(p *xeth.JSBlock, obj qml.Object) { p.Number = 0; p.Hash = "" }, + Init: func(p *xeth.Block, obj qml.Object) { p.Number = 0; p.Hash = "" }, }, { - Init: func(p *xeth.JSTransaction, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" }, + Init: func(p *xeth.Transaction, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" }, }, { Init: func(p *xeth.KeyVal, obj qml.Object) { p.Key = ""; p.Value = "" }, }}) @@ -276,7 +276,7 @@ func (gui *Gui) insertTransaction(window string, tx *types.Transaction) { } var ( - ptx = xeth.NewJSTx(tx) + ptx = xeth.NewTx(tx) send = ethutil.Bytes2Hex(tx.From()) rec = ethutil.Bytes2Hex(tx.To()) ) @@ -303,7 +303,7 @@ func (gui *Gui) readPreviousTransactions() { func (gui *Gui) processBlock(block *types.Block, initial bool) { name := ethutil.Bytes2Hex(block.Coinbase()) - b := xeth.NewJSBlock(block) + b := xeth.NewBlock(block) b.Name = name gui.getObjectByName("chainView").Call("addBlock", b, initial) diff --git a/cmd/mist/html_container.go b/cmd/mist/html_container.go index f2ba6fbe2..516dcb6b3 100644 --- a/cmd/mist/html_container.go +++ b/cmd/mist/html_container.go @@ -142,7 +142,7 @@ func (app *HtmlApplication) Window() *qml.Window { } func (app *HtmlApplication) NewBlock(block *types.Block) { - b := &xeth.JSBlock{Number: int(block.NumberU64()), Hash: ethutil.Bytes2Hex(block.Hash())} + b := &xeth.Block{Number: int(block.NumberU64()), Hash: ethutil.Bytes2Hex(block.Hash())} app.webView.Call("onNewBlockCb", b) } diff --git a/cmd/mist/qml_container.go b/cmd/mist/qml_container.go index 7f5d97bec..5fbe3c01e 100644 --- a/cmd/mist/qml_container.go +++ b/cmd/mist/qml_container.go @@ -70,7 +70,7 @@ func (app *QmlApplication) NewWatcher(quitChan chan bool) { // Events func (app *QmlApplication) NewBlock(block *types.Block) { - pblock := &xeth.JSBlock{Number: int(block.NumberU64()), Hash: ethutil.Bytes2Hex(block.Hash())} + pblock := &xeth.Block{Number: int(block.NumberU64()), Hash: ethutil.Bytes2Hex(block.Hash())} app.win.Call("onNewBlockCb", pblock) } diff --git a/cmd/mist/ui_lib.go b/cmd/mist/ui_lib.go index ca3884a82..0bffc4cd1 100644 --- a/cmd/mist/ui_lib.go +++ b/cmd/mist/ui_lib.go @@ -44,7 +44,7 @@ type memAddr struct { // UI Library that has some basic functionality exposed type UiLib struct { - *xeth.JSXEth + *xeth.XEth engine *qml.Engine eth *eth.Ethereum connected bool @@ -63,7 +63,7 @@ type UiLib struct { } func NewUiLib(engine *qml.Engine, eth *eth.Ethereum, assetPath string) *UiLib { - lib := &UiLib{JSXEth: xeth.NewJSXEth(eth), engine: engine, eth: eth, assetPath: assetPath, jsEngine: javascript.NewJSRE(eth), filterCallbacks: make(map[int][]int)} //, filters: make(map[int]*xeth.JSFilter)} + lib := &UiLib{XEth: xeth.New(eth), engine: engine, eth: eth, assetPath: assetPath, jsEngine: javascript.NewJSRE(eth), filterCallbacks: make(map[int][]int)} //, filters: make(map[int]*xeth.JSFilter)} lib.miner = miner.New(eth.KeyManager().Address(), eth) lib.filterManager = filter.NewFilterManager(eth.EventMux()) go lib.filterManager.Start() @@ -180,7 +180,7 @@ func (self *UiLib) StartDebugger() { func (self *UiLib) Transact(params map[string]interface{}) (string, error) { object := mapToTxParams(params) - return self.JSXEth.Transact( + return self.XEth.Transact( object["from"], object["to"], object["value"], @@ -202,7 +202,7 @@ func (self *UiLib) Compile(code string) (string, error) { func (self *UiLib) Call(params map[string]interface{}) (string, error) { object := mapToTxParams(params) - return self.JSXEth.Execute( + return self.XEth.Execute( object["to"], object["value"], object["gas"], @@ -261,7 +261,7 @@ func (self *UiLib) ToAscii(data string) string { func (self *UiLib) NewFilter(object map[string]interface{}, view *qml.Common) (id int) { filter := qt.NewFilterFromMap(object, self.eth) filter.MessageCallback = func(messages state.Messages) { - view.Call("messages", xeth.ToJSMessages(messages), id) + view.Call("messages", xeth.ToMessages(messages), id) } id = self.filterManager.InstallFilter(filter) return id @@ -279,7 +279,7 @@ func (self *UiLib) NewFilterString(typ string, view *qml.Common) (id int) { func (self *UiLib) Messages(id int) *ethutil.List { filter := self.filterManager.GetFilter(id) if filter != nil { - messages := xeth.ToJSMessages(filter.Find()) + messages := xeth.ToMessages(filter.Find()) return messages } diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go index 9cdd8b5d1..1d4655433 100644 --- a/cmd/utils/cmd.go +++ b/cmd/utils/cmd.go @@ -194,7 +194,7 @@ func KeyTasks(keyManager *crypto.KeyManager, KeyRing string, GenAddr bool, Secre func StartRpc(ethereum *eth.Ethereum, RpcPort int) { var err error - ethereum.RpcServer, err = rpchttp.NewRpcHttpServer(xeth.NewJSXEth(ethereum), RpcPort) + ethereum.RpcServer, err = rpchttp.NewRpcHttpServer(xeth.New(ethereum), RpcPort) if err != nil { clilogger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err) } else { diff --git a/javascript/javascript_runtime.go b/javascript/javascript_runtime.go index adc9022b7..c780eb754 100644 --- a/javascript/javascript_runtime.go +++ b/javascript/javascript_runtime.go @@ -24,7 +24,7 @@ var jsrelogger = logger.NewLogger("JSRE") type JSRE struct { ethereum *eth.Ethereum Vm *otto.Otto - pipe *xeth.JSXEth + pipe *xeth.XEth events event.Subscription @@ -49,7 +49,7 @@ func NewJSRE(ethereum *eth.Ethereum) *JSRE { re := &JSRE{ ethereum, otto.New(), - xeth.NewJSXEth(ethereum), + xeth.New(ethereum), nil, make(map[string][]otto.Value), } diff --git a/javascript/types.go b/javascript/types.go index 3f30fa92b..7fb2082b9 100644 --- a/javascript/types.go +++ b/javascript/types.go @@ -12,14 +12,14 @@ import ( ) type JSStateObject struct { - *xeth.JSObject + *xeth.Object eth *JSEthereum } func (self *JSStateObject) EachStorage(call otto.FunctionCall) otto.Value { cb := call.Argument(0) - it := self.JSObject.Trie().Iterator() + it := self.Object.Trie().Iterator() for it.Next() { cb.Call(self.eth.toVal(self), self.eth.toVal(ethutil.Bytes2Hex(it.Key)), self.eth.toVal(ethutil.Bytes2Hex(it.Value))) } @@ -30,12 +30,12 @@ func (self *JSStateObject) EachStorage(call otto.FunctionCall) otto.Value { // The JSEthereum object attempts to wrap the PEthereum object and returns // meaningful javascript objects type JSBlock struct { - *xeth.JSBlock + *xeth.Block eth *JSEthereum } func (self *JSBlock) GetTransaction(hash string) otto.Value { - return self.eth.toVal(self.JSBlock.GetTransaction(hash)) + return self.eth.toVal(self.Block.GetTransaction(hash)) } type JSMessage struct { @@ -67,27 +67,27 @@ func NewJSMessage(message *state.Message) JSMessage { } type JSEthereum struct { - *xeth.JSXEth + *xeth.XEth vm *otto.Otto ethereum *eth.Ethereum } func (self *JSEthereum) Block(v interface{}) otto.Value { if number, ok := v.(int64); ok { - return self.toVal(&JSBlock{self.JSXEth.BlockByNumber(int32(number)), self}) + return self.toVal(&JSBlock{self.XEth.BlockByNumber(int32(number)), self}) } else if hash, ok := v.(string); ok { - return self.toVal(&JSBlock{self.JSXEth.BlockByHash(hash), self}) + return self.toVal(&JSBlock{self.XEth.BlockByHash(hash), self}) } return otto.UndefinedValue() } func (self *JSEthereum) GetStateObject(addr string) otto.Value { - return self.toVal(&JSStateObject{xeth.NewJSObject(self.JSXEth.State().SafeGet(addr)), self}) + return self.toVal(&JSStateObject{self.XEth.State().SafeGet(addr), self}) } func (self *JSEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) otto.Value { - r, err := self.JSXEth.Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr) + r, err := self.XEth.Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr) if err != nil { fmt.Println(err) diff --git a/rpc/http/server.go b/rpc/http/server.go index 2a492f465..965727a4e 100644 --- a/rpc/http/server.go +++ b/rpc/http/server.go @@ -29,7 +29,7 @@ import ( var rpchttplogger = logger.NewLogger("RPC-HTTP") var JSON rpc.JsonWrapper -func NewRpcHttpServer(pipe *xeth.JSXEth, port int) (*RpcHttpServer, error) { +func NewRpcHttpServer(pipe *xeth.XEth, port int) (*RpcHttpServer, error) { sport := fmt.Sprintf(":%d", port) l, err := net.Listen("tcp", sport) if err != nil { @@ -47,7 +47,7 @@ func NewRpcHttpServer(pipe *xeth.JSXEth, port int) (*RpcHttpServer, error) { type RpcHttpServer struct { quit chan bool listener net.Listener - pipe *xeth.JSXEth + pipe *xeth.XEth port int } diff --git a/rpc/packages.go b/rpc/packages.go index e6d4859d2..700b9b2b3 100644 --- a/rpc/packages.go +++ b/rpc/packages.go @@ -19,8 +19,8 @@ For each request type, define the following: 1. RpcRequest "To" method [message.go], which does basic validation and conversion to "Args" type via json.Decoder() -2. json.Decoder() calls "UnmarshalJSON" defined on each "Args" struct -3. EthereumApi method, taking the "Args" type and replying with an interface to be marshalled to JSON +2. json.Decoder() calls "UnmarshalON" defined on each "Args" struct +3. EthereumApi method, taking the "Args" type and replying with an interface to be marshalled to ON */ package rpc @@ -38,12 +38,12 @@ type RpcServer interface { Stop() } -func NewEthereumApi(xeth *xeth.JSXEth) *EthereumApi { +func NewEthereumApi(xeth *xeth.XEth) *EthereumApi { return &EthereumApi{xeth: xeth} } type EthereumApi struct { - xeth *xeth.JSXEth + xeth *xeth.XEth } func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *interface{}) error { @@ -162,7 +162,7 @@ func (p *EthereumApi) GetCodeAt(args *GetCodeAtArgs, reply *interface{}) error { } func (p *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error { - // Spec at https://github.com/ethereum/wiki/wiki/Generic-JSON-RPC + // Spec at https://github.com/ethereum/wiki/wiki/Generic-ON-RPC rpclogger.DebugDetailf("%T %s", req.Params, req.Params) switch req.Method { case "eth_coinbase": diff --git a/rpc/ws/server.go b/rpc/ws/server.go index 248ebc585..37b08ebd9 100644 --- a/rpc/ws/server.go +++ b/rpc/ws/server.go @@ -75,7 +75,7 @@ func (self *WebSocketServer) Start() { wslogger.Infof("Starting RPC-WS server on port %d", self.port) go self.handlerLoop() - api := rpc.NewEthereumApi(xeth.NewJSXEth(self.eth)) + api := rpc.NewEthereumApi(xeth.New(self.eth)) h := self.apiHandler(api) http.Handle("/ws", h) diff --git a/xeth/object.go b/xeth/object.go deleted file mode 100644 index a4ac41e89..000000000 --- a/xeth/object.go +++ /dev/null @@ -1,26 +0,0 @@ -package xeth - -import ( - "github.com/ethereum/go-ethereum/ethutil" - "github.com/ethereum/go-ethereum/state" -) - -type Object struct { - *state.StateObject -} - -func (self *Object) StorageString(str string) *ethutil.Value { - if ethutil.IsHex(str) { - return self.Storage(ethutil.Hex2Bytes(str[2:])) - } else { - return self.Storage(ethutil.RightPadBytes([]byte(str), 32)) - } -} - -func (self *Object) StorageValue(addr *ethutil.Value) *ethutil.Value { - return self.Storage(addr.Bytes()) -} - -func (self *Object) Storage(addr []byte) *ethutil.Value { - return self.StateObject.GetStorage(ethutil.BigD(addr)) -} diff --git a/xeth/js_types.go b/xeth/types.go similarity index 72% rename from xeth/js_types.go rename to xeth/types.go index a0be996ff..4d8543eb1 100644 --- a/xeth/js_types.go +++ b/xeth/types.go @@ -25,8 +25,32 @@ func fromHex(s string) []byte { return nil } +type Object struct { + *state.StateObject +} + +func NewObject(state *state.StateObject) *Object { + return &Object{state} +} + +func (self *Object) StorageString(str string) *ethutil.Value { + if ethutil.IsHex(str) { + return self.Storage(ethutil.Hex2Bytes(str[2:])) + } else { + return self.Storage(ethutil.RightPadBytes([]byte(str), 32)) + } +} + +func (self *Object) StorageValue(addr *ethutil.Value) *ethutil.Value { + return self.Storage(addr.Bytes()) +} + +func (self *Object) Storage(addr []byte) *ethutil.Value { + return self.StateObject.GetStorage(ethutil.BigD(addr)) +} + // Block interface exposed to QML -type JSBlock struct { +type Block struct { //Transactions string `json:"transactions"` ref *types.Block Size string `json:"size"` @@ -45,24 +69,24 @@ type JSBlock struct { } // Creates a new QML Block from a chain block -func NewJSBlock(block *types.Block) *JSBlock { +func NewBlock(block *types.Block) *Block { if block == nil { - return &JSBlock{} + return &Block{} } - ptxs := make([]*JSTransaction, len(block.Transactions())) + ptxs := make([]*Transaction, len(block.Transactions())) for i, tx := range block.Transactions() { - ptxs[i] = NewJSTx(tx) + ptxs[i] = NewTx(tx) } txlist := ethutil.NewList(ptxs) - puncles := make([]*JSBlock, len(block.Uncles())) + puncles := make([]*Block, len(block.Uncles())) for i, uncle := range block.Uncles() { - puncles[i] = NewJSBlock(types.NewBlockWithHeader(uncle)) + puncles[i] = NewBlock(types.NewBlockWithHeader(uncle)) } ulist := ethutil.NewList(puncles) - return &JSBlock{ + return &Block{ ref: block, Size: block.Size().String(), Number: int(block.NumberU64()), GasUsed: block.GasUsed().String(), GasLimit: block.GasLimit().String(), Hash: toHex(block.Hash()), @@ -75,7 +99,7 @@ func NewJSBlock(block *types.Block) *JSBlock { } } -func (self *JSBlock) ToString() string { +func (self *Block) ToString() string { if self.ref != nil { return self.ref.String() } @@ -83,16 +107,16 @@ func (self *JSBlock) ToString() string { return "" } -func (self *JSBlock) GetTransaction(hash string) *JSTransaction { +func (self *Block) GetTransaction(hash string) *Transaction { tx := self.ref.Transaction(fromHex(hash)) if tx == nil { return nil } - return NewJSTx(tx) + return NewTx(tx) } -type JSTransaction struct { +type Transaction struct { ref *types.Transaction Value string `json:"value"` @@ -108,7 +132,7 @@ type JSTransaction struct { Confirmations int `json:"confirmations"` } -func NewJSTx(tx *types.Transaction) *JSTransaction { +func NewTx(tx *types.Transaction) *Transaction { hash := toHex(tx.Hash()) receiver := toHex(tx.To()) if receiver == "0000000000000000000000000000000000000000" { @@ -124,29 +148,21 @@ func NewJSTx(tx *types.Transaction) *JSTransaction { data = toHex(tx.Data()) } - return &JSTransaction{ref: tx, Hash: hash, Value: ethutil.CurrencyToString(tx.Value()), Address: receiver, Contract: createsContract, Gas: tx.Gas().String(), GasPrice: tx.GasPrice().String(), Data: data, Sender: sender, CreatesContract: createsContract, RawData: toHex(tx.Data())} + return &Transaction{ref: tx, Hash: hash, Value: ethutil.CurrencyToString(tx.Value()), Address: receiver, Contract: createsContract, Gas: tx.Gas().String(), GasPrice: tx.GasPrice().String(), Data: data, Sender: sender, CreatesContract: createsContract, RawData: toHex(tx.Data())} } -func (self *JSTransaction) ToString() string { +func (self *Transaction) ToString() string { return self.ref.String() } -type JSKey struct { +type Key struct { Address string `json:"address"` PrivateKey string `json:"privateKey"` PublicKey string `json:"publicKey"` } -func NewJSKey(key *crypto.KeyPair) *JSKey { - return &JSKey{toHex(key.Address()), toHex(key.PrivateKey), toHex(key.PublicKey)} -} - -type JSObject struct { - *Object -} - -func NewJSObject(object *Object) *JSObject { - return &JSObject{object} +func NewKey(key *crypto.KeyPair) *Key { + return &Key{toHex(key.Address()), toHex(key.PrivateKey), toHex(key.PublicKey)} } type PReceipt struct { @@ -167,20 +183,20 @@ func NewPReciept(contractCreation bool, creationAddress, hash, address []byte) * // Peer interface exposed to QML -type JSPeer struct { +type Peer struct { ref *p2p.Peer Ip string `json:"ip"` Version string `json:"version"` Caps string `json:"caps"` } -func NewJSPeer(peer *p2p.Peer) *JSPeer { +func NewPeer(peer *p2p.Peer) *Peer { var caps []string for _, cap := range peer.Caps() { caps = append(caps, fmt.Sprintf("%s/%d", cap.Name, cap.Version)) } - return &JSPeer{ + return &Peer{ ref: peer, Ip: fmt.Sprintf("%v", peer.RemoteAddr()), Version: fmt.Sprintf("%v", peer.Identity()), @@ -188,15 +204,15 @@ func NewJSPeer(peer *p2p.Peer) *JSPeer { } } -type JSReceipt struct { +type Receipt struct { CreatedContract bool `json:"createdContract"` Address string `json:"address"` Hash string `json:"hash"` Sender string `json:"sender"` } -func NewJSReciept(contractCreation bool, creationAddress, hash, address []byte) *JSReceipt { - return &JSReceipt{ +func NewReciept(contractCreation bool, creationAddress, hash, address []byte) *Receipt { + return &Receipt{ contractCreation, toHex(creationAddress), toHex(hash), @@ -204,7 +220,7 @@ func NewJSReciept(contractCreation bool, creationAddress, hash, address []byte) } } -type JSMessage struct { +type Message struct { To string `json:"to"` From string `json:"from"` Input string `json:"input"` @@ -218,8 +234,8 @@ type JSMessage struct { Value string `json:"value"` } -func NewJSMessage(message *state.Message) JSMessage { - return JSMessage{ +func NewMessage(message *state.Message) Message { + return Message{ To: toHex(message.To), From: toHex(message.From), Input: toHex(message.Input), diff --git a/xeth/world.go b/xeth/world.go index 60d4bbb57..cdceec50d 100644 --- a/xeth/world.go +++ b/xeth/world.go @@ -3,10 +3,10 @@ package xeth import "github.com/ethereum/go-ethereum/state" type State struct { - xeth *JSXEth + xeth *XEth } -func NewState(xeth *JSXEth) *State { +func NewState(xeth *XEth) *State { return &State{xeth} } diff --git a/xeth/xeth.go b/xeth/xeth.go index 6b491b0fe..96e545b35 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -31,15 +31,15 @@ type Backend interface { TxPool() *core.TxPool } -type JSXEth struct { +type XEth struct { eth Backend blockProcessor *core.BlockProcessor chainManager *core.ChainManager world *State } -func NewJSXEth(eth Backend) *JSXEth { - xeth := &JSXEth{ +func New(eth Backend) *XEth { + xeth := &XEth{ eth: eth, blockProcessor: eth.BlockProcessor(), chainManager: eth.ChainManager(), @@ -49,24 +49,24 @@ func NewJSXEth(eth Backend) *JSXEth { return xeth } -func (self *JSXEth) State() *State { return self.world } +func (self *XEth) State() *State { return self.world } -func (self *JSXEth) BlockByHash(strHash string) *JSBlock { +func (self *XEth) BlockByHash(strHash string) *Block { hash := fromHex(strHash) block := self.chainManager.GetBlock(hash) - return NewJSBlock(block) + return NewBlock(block) } -func (self *JSXEth) BlockByNumber(num int32) *JSBlock { +func (self *XEth) BlockByNumber(num int32) *Block { if num == -1 { - return NewJSBlock(self.chainManager.CurrentBlock()) + return NewBlock(self.chainManager.CurrentBlock()) } - return NewJSBlock(self.chainManager.GetBlockByNumber(uint64(num))) + return NewBlock(self.chainManager.GetBlockByNumber(uint64(num))) } -func (self *JSXEth) Block(v interface{}) *JSBlock { +func (self *XEth) Block(v interface{}) *Block { if n, ok := v.(int32); ok { return self.BlockByNumber(n) } else if str, ok := v.(string); ok { @@ -78,63 +78,63 @@ func (self *JSXEth) Block(v interface{}) *JSBlock { return nil } -func (self *JSXEth) Accounts() []string { +func (self *XEth) Accounts() []string { return []string{toHex(self.eth.KeyManager().Address())} } /* -func (self *JSXEth) StateObject(addr string) *JSObject { +func (self *XEth) StateObject(addr string) *Object { object := &Object{self.State().safeGet(fromHex(addr))} - return NewJSObject(object) + return NewObject(object) } */ -func (self *JSXEth) PeerCount() int { +func (self *XEth) PeerCount() int { return self.eth.PeerCount() } -func (self *JSXEth) IsMining() bool { +func (self *XEth) IsMining() bool { return self.eth.IsMining() } -func (self *JSXEth) IsListening() bool { +func (self *XEth) IsListening() bool { return self.eth.IsListening() } -func (self *JSXEth) Coinbase() string { +func (self *XEth) Coinbase() string { return toHex(self.eth.KeyManager().Address()) } -func (self *JSXEth) NumberToHuman(balance string) string { +func (self *XEth) NumberToHuman(balance string) string { b := ethutil.Big(balance) return ethutil.CurrencyToString(b) } -func (self *JSXEth) StorageAt(addr, storageAddr string) string { +func (self *XEth) StorageAt(addr, storageAddr string) string { storage := self.State().SafeGet(addr).StorageString(storageAddr) return toHex(storage.Bytes()) } -func (self *JSXEth) BalanceAt(addr string) string { +func (self *XEth) BalanceAt(addr string) string { return self.State().SafeGet(addr).Balance().String() } -func (self *JSXEth) TxCountAt(address string) int { +func (self *XEth) TxCountAt(address string) int { return int(self.State().SafeGet(address).Nonce) } -func (self *JSXEth) CodeAt(address string) string { +func (self *XEth) CodeAt(address string) string { return toHex(self.State().SafeGet(address).Code) } -func (self *JSXEth) IsContract(address string) bool { +func (self *XEth) IsContract(address string) bool { return len(self.State().SafeGet(address).Code) > 0 } -func (self *JSXEth) SecretToAddress(key string) string { +func (self *XEth) SecretToAddress(key string) string { pair, err := crypto.NewKeyPairFromSec(fromHex(key)) if err != nil { return "" @@ -143,7 +143,7 @@ func (self *JSXEth) SecretToAddress(key string) string { return toHex(pair.Address()) } -func (self *JSXEth) Execute(addr, value, gas, price, data string) (string, error) { +func (self *XEth) Execute(addr, value, gas, price, data string) (string, error) { return "", nil } @@ -152,7 +152,7 @@ type KeyVal struct { Value string `json:"value"` } -func (self *JSXEth) EachStorage(addr string) string { +func (self *XEth) EachStorage(addr string) string { var values []KeyVal object := self.State().SafeGet(addr) it := object.Trie().Iterator() @@ -168,13 +168,13 @@ func (self *JSXEth) EachStorage(addr string) string { return string(valuesJson) } -func (self *JSXEth) ToAscii(str string) string { +func (self *XEth) ToAscii(str string) string { padded := ethutil.RightPadBytes([]byte(str), 32) return "0x" + toHex(padded) } -func (self *JSXEth) FromAscii(str string) string { +func (self *XEth) FromAscii(str string) string { if ethutil.IsHex(str) { str = str[2:] } @@ -182,7 +182,7 @@ func (self *JSXEth) FromAscii(str string) string { return string(bytes.Trim(fromHex(str), "\x00")) } -func (self *JSXEth) FromNumber(str string) string { +func (self *XEth) FromNumber(str string) string { if ethutil.IsHex(str) { str = str[2:] } @@ -190,20 +190,20 @@ func (self *JSXEth) FromNumber(str string) string { return ethutil.BigD(fromHex(str)).String() } -func (self *JSXEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) { +func (self *XEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) { return "", nil } -func ToJSMessages(messages state.Messages) *ethutil.List { - var msgs []JSMessage +func ToMessages(messages state.Messages) *ethutil.List { + var msgs []Message for _, m := range messages { - msgs = append(msgs, NewJSMessage(m)) + msgs = append(msgs, NewMessage(m)) } return ethutil.NewList(msgs) } -func (self *JSXEth) PushTx(encodedTx string) (string, error) { +func (self *XEth) PushTx(encodedTx string) (string, error) { tx := types.NewTransactionFromBytes(fromHex(encodedTx)) err := self.eth.TxPool().Add(tx) if err != nil {