further cleaned up xeth interface

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),

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)

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)
 }
 

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)
 }
 

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
 	}

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 {

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),
 	}

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)
 

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
 }
 

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":

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)
 

xeth/object.go

-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))
-}

xeth/js_types.go → 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),

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}
 }
 

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 {