Merge branch 'develop' into poc8

8 files changed, 428 insertions, 601 deletions

diff --git a/xeth/config.go b/xeth/config.go
deleted file mode 100644
index ad0660d75..000000000
--- a/xeth/config.go
+++ /dev/null
@@ -1,35 +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 c3d8cef86..000000000
--- a/xeth/hexface.go
+++ /dev/null
@@ -1,250 +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"
-)
-
-type JSXEth struct {
-	*XEth
-}
-
-func NewJSXEth(eth core.EthManager) *JSXEth {
-	return &JSXEth{New(eth)}
-}
-
-func (self *JSXEth) BlockByHash(strHash string) *JSBlock {
-	hash := ethutil.Hex2Bytes(strHash)
-	block := self.obj.ChainManager().GetBlock(hash)
-
-	return NewJSBlock(block)
-}
-
-func (self *JSXEth) BlockByNumber(num int32) *JSBlock {
-	if num == -1 {
-		return NewJSBlock(self.obj.ChainManager().CurrentBlock())
-	}
-
-	return NewJSBlock(self.obj.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) Key() *JSKey {
-	return NewJSKey(self.obj.KeyManager().KeyPair())
-}
-
-func (self *JSXEth) StateObject(addr string) *JSObject {
-	object := &Object{self.World().safeGet(ethutil.Hex2Bytes(addr))}
-
-	return NewJSObject(object)
-}
-
-func (self *JSXEth) PeerCount() int {
-	return self.obj.PeerCount()
-}
-
-func (self *JSXEth) Peers() []JSPeer {
-	var peers []JSPeer
-	for _, peer := range self.obj.Peers() {
-		peers = append(peers, *NewJSPeer(peer))
-	}
-
-	return peers
-}
-
-func (self *JSXEth) IsMining() bool {
-	return self.obj.IsMining()
-}
-
-func (self *JSXEth) IsListening() bool {
-	return self.obj.IsListening()
-}
-
-func (self *JSXEth) CoinBase() string {
-	return ethutil.Bytes2Hex(self.obj.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.World().SafeGet(ethutil.Hex2Bytes(addr)).Storage(ethutil.Hex2Bytes(storageAddr))
-
-	return ethutil.Bytes2Hex(storage.Bytes())
-}
-
-func (self *JSXEth) BalanceAt(addr string) string {
-	return self.World().SafeGet(ethutil.Hex2Bytes(addr)).Balance().String()
-}
-
-func (self *JSXEth) TxCountAt(address string) int {
-	return int(self.World().SafeGet(ethutil.Hex2Bytes(address)).Nonce)
-}
-
-func (self *JSXEth) CodeAt(address string) string {
-	return ethutil.Bytes2Hex(self.World().SafeGet(ethutil.Hex2Bytes(address)).Code)
-}
-
-func (self *JSXEth) IsContract(address string) bool {
-	return len(self.World().SafeGet(ethutil.Hex2Bytes(address)).Code) > 0
-}
-
-func (self *JSXEth) SecretToAddress(key string) string {
-	pair, err := crypto.NewKeyPairFromSec(ethutil.Hex2Bytes(key))
-	if err != nil {
-		return ""
-	}
-
-	return ethutil.Bytes2Hex(pair.Address())
-}
-
-func (self *JSXEth) Execute(addr, value, gas, price, data string) (string, error) {
-	ret, err := self.ExecuteObject(&Object{
-		self.World().safeGet(ethutil.Hex2Bytes(addr))},
-		ethutil.Hex2Bytes(data),
-		ethutil.NewValue(value),
-		ethutil.NewValue(gas),
-		ethutil.NewValue(price),
-	)
-
-	return ethutil.Bytes2Hex(ret), err
-}
-
-type KeyVal struct {
-	Key   string `json:"key"`
-	Value string `json:"value"`
-}
-
-func (self *JSXEth) EachStorage(addr string) string {
-	var values []KeyVal
-	object := self.World().SafeGet(ethutil.Hex2Bytes(addr))
-	it := object.Trie().Iterator()
-	for it.Next() {
-		values = append(values, KeyVal{ethutil.Bytes2Hex(it.Key), ethutil.Bytes2Hex(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" + ethutil.Bytes2Hex(padded)
-}
-
-func (self *JSXEth) FromAscii(str string) string {
-	if ethutil.IsHex(str) {
-		str = str[2:]
-	}
-
-	return string(bytes.Trim(ethutil.Hex2Bytes(str), "\x00"))
-}
-
-func (self *JSXEth) FromNumber(str string) string {
-	if ethutil.IsHex(str) {
-		str = str[2:]
-	}
-
-	return ethutil.BigD(ethutil.Hex2Bytes(str)).String()
-}
-
-func (self *JSXEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
-	var (
-		to       []byte
-		value    = ethutil.NewValue(valueStr)
-		gas      = ethutil.NewValue(gasStr)
-		gasPrice = ethutil.NewValue(gasPriceStr)
-		data     []byte
-	)
-
-	if ethutil.IsHex(codeStr) {
-		data = ethutil.Hex2Bytes(codeStr[2:])
-	} else {
-		data = ethutil.Hex2Bytes(codeStr)
-	}
-
-	if ethutil.IsHex(toStr) {
-		to = ethutil.Hex2Bytes(toStr[2:])
-	} else {
-		to = ethutil.Hex2Bytes(toStr)
-	}
-
-	var keyPair *crypto.KeyPair
-	var err error
-	if ethutil.IsHex(key) {
-		keyPair, err = crypto.NewKeyPairFromSec([]byte(ethutil.Hex2Bytes(key[2:])))
-	} else {
-		keyPair, err = crypto.NewKeyPairFromSec([]byte(ethutil.Hex2Bytes(key)))
-	}
-
-	if err != nil {
-		return "", err
-	}
-
-	tx, err := self.XEth.Transact(keyPair, to, value, gas, gasPrice, data)
-	if err != nil {
-		return "", err
-	}
-	if types.IsContractAddr(to) {
-		return ethutil.Bytes2Hex(core.AddressFromMessage(tx)), nil
-	}
-
-	return ethutil.Bytes2Hex(tx.Hash()), nil
-}
-
-func (self *JSXEth) PushTx(txStr string) (*JSReceipt, error) {
-	tx := types.NewTransactionFromBytes(ethutil.Hex2Bytes(txStr))
-	err := self.obj.TxPool().Add(tx)
-	if err != nil {
-		return nil, err
-	}
-
-	return NewJSReciept(core.MessageCreatesContract(tx), core.AddressFromMessage(tx), tx.Hash(), tx.From()), nil
-}
-
-func (self *JSXEth) CompileMutan(code string) string {
-	data, err := self.XEth.CompileMutan(code)
-	if err != nil {
-		return err.Error()
-	}
-
-	return ethutil.Bytes2Hex(data)
-}
-
-func (self *JSXEth) FindInConfig(str string) string {
-	return ethutil.Bytes2Hex(self.World().Config().Get(str).Address())
-}
-
-func ToJSMessages(messages state.Messages) *ethutil.List {
-	var msgs []JSMessage
-	for _, m := range messages {
-		msgs = append(msgs, NewJSMessage(m))
-	}
-
-	return ethutil.NewList(msgs)
-}
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
index dbddcb7a3..a903fccbb 100644
--- a/xeth/js_types.go
+++ b/xeth/types.go
@@ -1,6 +1,7 @@
 package xeth
 
 import (
+	"bytes"
 	"fmt"
 	"strings"
 
@@ -9,11 +10,62 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/p2p"
+	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/state"
 )
 
+func toHex(b []byte) string {
+	return "0x" + ethutil.Bytes2Hex(b)
+}
+func fromHex(s string) []byte {
+	if len(s) > 1 {
+		if s[0:2] == "0x" {
+			s = s[2:]
+		}
+		return ethutil.Hex2Bytes(s)
+	}
+	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))
+}
+
+func (self *Object) Storage() (storage map[string]string) {
+	storage = make(map[string]string)
+
+	it := self.StateObject.Trie().Iterator()
+	for it.Next() {
+		var data []byte
+		rlp.Decode(bytes.NewReader(it.Value), &data)
+		storage[toHex(it.Key)] = toHex(data)
+	}
+
+	return
+}
+
 // Block interface exposed to QML
-type JSBlock struct {
+type Block struct {
 	//Transactions string `json:"transactions"`
 	ref          *types.Block
 	Size         string        `json:"size"`
@@ -32,37 +84,37 @@ 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, block.State())
+		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: ethutil.Bytes2Hex(block.Hash()),
+		GasLimit: block.GasLimit().String(), Hash: toHex(block.Hash()),
 		Transactions: txlist, Uncles: ulist,
 		Time:     block.Time(),
-		Coinbase: ethutil.Bytes2Hex(block.Coinbase()),
-		PrevHash: ethutil.Bytes2Hex(block.ParentHash()),
-		Bloom:    ethutil.Bytes2Hex(block.Bloom()),
+		Coinbase: toHex(block.Coinbase()),
+		PrevHash: toHex(block.ParentHash()),
+		Bloom:    toHex(block.Bloom()),
 		Raw:      block.String(),
 	}
 }
 
-func (self *JSBlock) ToString() string {
+func (self *Block) ToString() string {
 	if self.ref != nil {
 		return self.ref.String()
 	}
@@ -70,16 +122,16 @@ func (self *JSBlock) ToString() string {
 	return ""
 }
 
-func (self *JSBlock) GetTransaction(hash string) *JSTransaction {
-	tx := self.ref.Transaction(ethutil.Hex2Bytes(hash))
+func (self *Block) GetTransaction(hash string) *Transaction {
+	tx := self.ref.Transaction(fromHex(hash))
 	if tx == nil {
 		return nil
 	}
 
-	return NewJSTx(tx, self.ref.State())
+	return NewTx(tx)
 }
 
-type JSTransaction struct {
+type Transaction struct {
 	ref *types.Transaction
 
 	Value           string `json:"value"`
@@ -95,45 +147,37 @@ type JSTransaction struct {
 	Confirmations   int    `json:"confirmations"`
 }
 
-func NewJSTx(tx *types.Transaction, state *state.StateDB) *JSTransaction {
-	hash := ethutil.Bytes2Hex(tx.Hash())
-	receiver := ethutil.Bytes2Hex(tx.To())
+func NewTx(tx *types.Transaction) *Transaction {
+	hash := toHex(tx.Hash())
+	receiver := toHex(tx.To())
 	if receiver == "0000000000000000000000000000000000000000" {
-		receiver = ethutil.Bytes2Hex(core.AddressFromMessage(tx))
+		receiver = toHex(core.AddressFromMessage(tx))
 	}
-	sender := ethutil.Bytes2Hex(tx.From())
+	sender := toHex(tx.From())
 	createsContract := core.MessageCreatesContract(tx)
 
 	var data string
 	if createsContract {
 		data = strings.Join(core.Disassemble(tx.Data()), "\n")
 	} else {
-		data = ethutil.Bytes2Hex(tx.Data())
+		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: ethutil.Bytes2Hex(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{ethutil.Bytes2Hex(key.Address()), ethutil.Bytes2Hex(key.PrivateKey), ethutil.Bytes2Hex(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 {
@@ -146,77 +190,47 @@ type PReceipt struct {
 func NewPReciept(contractCreation bool, creationAddress, hash, address []byte) *PReceipt {
 	return &PReceipt{
 		contractCreation,
-		ethutil.Bytes2Hex(creationAddress),
-		ethutil.Bytes2Hex(hash),
-		ethutil.Bytes2Hex(address),
+		toHex(creationAddress),
+		toHex(hash),
+		toHex(address),
 	}
 }
 
 // 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:      peer.RemoteAddr().String(),
-		Version: peer.Identity().String(),
+		Ip:      fmt.Sprintf("%v", peer.RemoteAddr()),
+		Version: fmt.Sprintf("%v", peer.ID()),
 		Caps:    fmt.Sprintf("%v", caps),
 	}
 }
 
-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,
-		ethutil.Bytes2Hex(creationAddress),
-		ethutil.Bytes2Hex(hash),
-		ethutil.Bytes2Hex(address),
-	}
-}
-
-type JSMessage struct {
-	To        string `json:"to"`
-	From      string `json:"from"`
-	Input     string `json:"input"`
-	Output    string `json:"output"`
-	Path      int32  `json:"path"`
-	Origin    string `json:"origin"`
-	Timestamp int32  `json:"timestamp"`
-	Coinbase  string `json:"coinbase"`
-	Block     string `json:"block"`
-	Number    int32  `json:"number"`
-	Value     string `json:"value"`
-}
-
-func NewJSMessage(message *state.Message) JSMessage {
-	return JSMessage{
-		To:        ethutil.Bytes2Hex(message.To),
-		From:      ethutil.Bytes2Hex(message.From),
-		Input:     ethutil.Bytes2Hex(message.Input),
-		Output:    ethutil.Bytes2Hex(message.Output),
-		Path:      int32(message.Path),
-		Origin:    ethutil.Bytes2Hex(message.Origin),
-		Timestamp: int32(message.Timestamp),
-		Coinbase:  ethutil.Bytes2Hex(message.Origin),
-		Block:     ethutil.Bytes2Hex(message.Block),
-		Number:    int32(message.Number.Int64()),
-		Value:     message.Value.String(),
+		toHex(creationAddress),
+		toHex(hash),
+		toHex(address),
 	}
 }
diff --git a/xeth/vm_env.go b/xeth/vm_env.go
deleted file mode 100644
index 1470b9eaa..000000000
--- a/xeth/vm_env.go
+++ /dev/null
@@ -1,72 +0,0 @@
-package xeth
-
-import (
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/state"
-	"github.com/ethereum/go-ethereum/vm"
-)
-
-type VMEnv struct {
-	chain  *core.ChainManager
-	state  *state.StateDB
-	block  *types.Block
-	value  *big.Int
-	sender []byte
-
-	depth int
-}
-
-func NewEnv(chain *core.ChainManager, state *state.StateDB, block *types.Block, value *big.Int, sender []byte) *VMEnv {
-	return &VMEnv{
-		state:  state,
-		block:  block,
-		value:  value,
-		sender: sender,
-	}
-}
-
-func (self *VMEnv) Origin() []byte        { return self.sender }
-func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number() }
-func (self *VMEnv) PrevHash() []byte      { return self.block.ParentHash() }
-func (self *VMEnv) Coinbase() []byte      { return self.block.Coinbase() }
-func (self *VMEnv) Time() int64           { return self.block.Time() }
-func (self *VMEnv) Difficulty() *big.Int  { return self.block.Difficulty() }
-func (self *VMEnv) GasLimit() *big.Int    { return self.block.GasLimit() }
-func (self *VMEnv) Value() *big.Int       { return self.value }
-func (self *VMEnv) State() *state.StateDB { return self.state }
-func (self *VMEnv) Depth() int            { return self.depth }
-func (self *VMEnv) SetDepth(i int)        { self.depth = i }
-func (self *VMEnv) GetHash(n uint64) []byte {
-	if block := self.chain.GetBlockByNumber(n); block != nil {
-		return block.Hash()
-	}
-
-	return nil
-}
-func (self *VMEnv) AddLog(log state.Log) {
-	self.state.AddLog(log)
-}
-func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
-	return vm.Transfer(from, to, amount)
-}
-
-func (self *VMEnv) vm(addr, data []byte, gas, price, value *big.Int) *core.Execution {
-	return core.NewExecution(self, addr, data, gas, price, value)
-}
-
-func (self *VMEnv) Call(me vm.ContextRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) {
-	exe := self.vm(addr, data, gas, price, value)
-	return exe.Call(addr, me)
-}
-func (self *VMEnv) CallCode(me vm.ContextRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) {
-	exe := self.vm(me.Address(), data, gas, price, value)
-	return exe.Call(addr, me)
-}
-
-func (self *VMEnv) Create(me vm.ContextRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ContextRef) {
-	exe := self.vm(addr, data, gas, price, value)
-	return exe.Create(me)
-}
diff --git a/xeth/whisper.go b/xeth/whisper.go
new file mode 100644
index 000000000..d9c7e1614
--- /dev/null
+++ b/xeth/whisper.go
@@ -0,0 +1,115 @@
+package xeth
+
+import (
+	"errors"
+	"time"
+
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/whisper"
+)
+
+var qlogger = logger.NewLogger("XSHH")
+
+type Whisper struct {
+	*whisper.Whisper
+}
+
+func NewWhisper(w *whisper.Whisper) *Whisper {
+	return &Whisper{w}
+}
+
+func (self *Whisper) Post(payload string, to, from string, topics []string, priority, ttl uint32) error {
+	if priority == 0 {
+		priority = 1000
+	}
+
+	if ttl == 0 {
+		ttl = 100
+	}
+
+	pk := crypto.ToECDSAPub(fromHex(from))
+	if key := self.Whisper.GetIdentity(pk); key != nil || len(from) == 0 {
+		msg := whisper.NewMessage(fromHex(payload))
+		envelope, err := msg.Seal(time.Duration(priority*100000), whisper.Opts{
+			Ttl:    time.Duration(ttl) * time.Second,
+			To:     crypto.ToECDSAPub(fromHex(to)),
+			From:   key,
+			Topics: whisper.TopicsFromString(topics...),
+		})
+
+		if err != nil {
+			return err
+		}
+
+		if err := self.Whisper.Send(envelope); err != nil {
+			return err
+		}
+	} else {
+		return errors.New("unmatched pub / priv for seal")
+	}
+
+	return nil
+}
+
+func (self *Whisper) NewIdentity() string {
+	key := self.Whisper.NewIdentity()
+
+	return toHex(crypto.FromECDSAPub(&key.PublicKey))
+}
+
+func (self *Whisper) HasIdentity(key string) bool {
+	return self.Whisper.HasIdentity(crypto.ToECDSAPub(fromHex(key)))
+}
+
+func (self *Whisper) Watch(opts *Options) int {
+	filter := whisper.Filter{
+		To:     crypto.ToECDSAPub(fromHex(opts.To)),
+		From:   crypto.ToECDSAPub(fromHex(opts.From)),
+		Topics: whisper.TopicsFromString(opts.Topics...),
+	}
+
+	var i int
+	filter.Fn = func(msg *whisper.Message) {
+		opts.Fn(NewWhisperMessage(msg))
+	}
+
+	i = self.Whisper.Watch(filter)
+
+	return i
+}
+
+func (self *Whisper) Messages(id int) (messages []WhisperMessage) {
+	msgs := self.Whisper.Messages(id)
+	messages = make([]WhisperMessage, len(msgs))
+	for i, message := range msgs {
+		messages[i] = NewWhisperMessage(message)
+	}
+
+	return
+}
+
+type Options struct {
+	To     string
+	From   string
+	Topics []string
+	Fn     func(msg WhisperMessage)
+}
+
+type WhisperMessage struct {
+	ref     *whisper.Message
+	Payload string `json:"payload"`
+	To      string `json:"to"`
+	From    string `json:"from"`
+	Sent    int64  `json:"sent"`
+}
+
+func NewWhisperMessage(msg *whisper.Message) WhisperMessage {
+	return WhisperMessage{
+		ref:     msg,
+		Payload: toHex(msg.Payload),
+		From:    toHex(crypto.FromECDSAPub(msg.Recover())),
+		To:      toHex(crypto.FromECDSAPub(msg.To)),
+		Sent:    msg.Sent,
+	}
+}
diff --git a/xeth/world.go b/xeth/world.go
index 008a08423..9cbdd9461 100644
--- a/xeth/world.go
+++ b/xeth/world.go
@@ -1,63 +1,32 @@
 package xeth
 
-import (
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/state"
-)
-
-type World struct {
-	pipe *XEth
-	cfg  *Config
-}
-
-func NewWorld(pipe *XEth) *World {
-	world := &World{pipe, nil}
-	world.cfg = &Config{pipe}
+import "github.com/ethereum/go-ethereum/state"
 
-	return world
+type State struct {
+	xeth *XEth
 }
 
-func (self *XEth) World() *World {
-	return self.world
+func NewState(xeth *XEth) *State {
+	return &State{xeth}
 }
 
-func (self *World) State() *state.StateDB {
-	return self.pipe.chainManager.State()
+func (self *State) State() *state.StateDB {
+	return self.xeth.chainManager.TransState()
 }
 
-func (self *World) Get(addr []byte) *Object {
-	return &Object{self.State().GetStateObject(addr)}
+func (self *State) Get(addr string) *Object {
+	return &Object{self.State().GetStateObject(fromHex(addr))}
 }
 
-func (self *World) SafeGet(addr []byte) *Object {
+func (self *State) SafeGet(addr string) *Object {
 	return &Object{self.safeGet(addr)}
 }
 
-func (self *World) safeGet(addr []byte) *state.StateObject {
-	object := self.State().GetStateObject(addr)
+func (self *State) safeGet(addr string) *state.StateObject {
+	object := self.State().GetStateObject(fromHex(addr))
 	if object == nil {
-		object = state.NewStateObject(addr)
+		object = state.NewStateObject(fromHex(addr), self.xeth.eth.Db())
 	}
 
 	return object
 }
-
-func (self *World) Coinbase() *state.StateObject {
-	return nil
-}
-
-func (self *World) IsMining() bool {
-	return self.pipe.obj.IsMining()
-}
-
-func (self *World) IsListening() bool {
-	return self.pipe.obj.IsListening()
-}
-
-func (self *World) Peers() []*p2p.Peer {
-	return self.pipe.obj.Peers()
-}
-
-func (self *World) Config() *Config {
-	return self.cfg
-}
diff --git a/xeth/xeth.go b/xeth/xeth.go
index a10ccfc8b..75d83f80b 100644
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@@ -5,130 +5,261 @@ 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/event"
 	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/whisper"
 )
 
 var pipelogger = logger.NewLogger("XETH")
 
-type VmVars struct {
-	State *state.StateDB
+// to resolve the import cycle
+type Backend interface {
+	BlockProcessor() *core.BlockProcessor
+	ChainManager() *core.ChainManager
+	TxPool() *core.TxPool
+	PeerCount() int
+	IsMining() bool
+	IsListening() bool
+	Peers() []*p2p.Peer
+	KeyManager() *crypto.KeyManager
+	Db() ethutil.Database
+	EventMux() *event.TypeMux
+	Whisper() *whisper.Whisper
 }
 
 type XEth struct {
-	obj            core.EthManager
+	eth            Backend
 	blockProcessor *core.BlockProcessor
 	chainManager   *core.ChainManager
-	world          *World
+	state          *State
+	whisper        *Whisper
+}
+
+func New(eth Backend) *XEth {
+	xeth := &XEth{
+		eth:            eth,
+		blockProcessor: eth.BlockProcessor(),
+		chainManager:   eth.ChainManager(),
+		whisper:        NewWhisper(eth.Whisper()),
+	}
+	xeth.state = NewState(xeth)
 
-	Vm VmVars
+	return xeth
 }
 
-func New(obj core.EthManager) *XEth {
-	pipe := &XEth{
-		obj:            obj,
-		blockProcessor: obj.BlockProcessor(),
-		chainManager:   obj.ChainManager(),
+func (self *XEth) Backend() Backend  { return self.eth }
+func (self *XEth) State() *State     { return self.state }
+func (self *XEth) Whisper() *Whisper { return self.whisper }
+
+func (self *XEth) BlockByHash(strHash string) *Block {
+	hash := fromHex(strHash)
+	block := self.chainManager.GetBlock(hash)
+
+	return NewBlock(block)
+}
+
+func (self *XEth) BlockByNumber(num int32) *Block {
+	if num == -1 {
+		return NewBlock(self.chainManager.CurrentBlock())
 	}
-	pipe.world = NewWorld(pipe)
 
-	return pipe
+	return NewBlock(self.chainManager.GetBlockByNumber(uint64(num)))
 }
 
-/*
- * State / Account accessors
- */
-func (self *XEth) Balance(addr []byte) *ethutil.Value {
-	return ethutil.NewValue(self.World().safeGet(addr).Balance)
+func (self *XEth) Block(v interface{}) *Block {
+	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 *XEth) Accounts() []string {
+	return []string{toHex(self.eth.KeyManager().Address())}
 }
 
-func (self *XEth) Nonce(addr []byte) uint64 {
-	return self.World().safeGet(addr).Nonce
+func (self *XEth) PeerCount() int {
+	return self.eth.PeerCount()
 }
 
-func (self *XEth) Block(hash []byte) *types.Block {
-	return self.chainManager.GetBlock(hash)
+func (self *XEth) IsMining() bool {
+	return self.eth.IsMining()
 }
 
-func (self *XEth) Storage(addr, storageAddr []byte) *ethutil.Value {
-	return self.World().safeGet(addr).GetStorage(ethutil.BigD(storageAddr))
+func (self *XEth) IsListening() bool {
+	return self.eth.IsListening()
+}
+
+func (self *XEth) Coinbase() string {
+	return toHex(self.eth.KeyManager().Address())
+}
+
+func (self *XEth) NumberToHuman(balance string) string {
+	b := ethutil.Big(balance)
+
+	return ethutil.CurrencyToString(b)
+}
+
+func (self *XEth) StorageAt(addr, storageAddr string) string {
+	storage := self.State().SafeGet(addr).StorageString(storageAddr)
+
+	return toHex(storage.Bytes())
 }
 
-func (self *XEth) Exists(addr []byte) bool {
-	return self.World().Get(addr) != nil
+func (self *XEth) BalanceAt(addr string) string {
+	return self.State().SafeGet(addr).Balance().String()
 }
 
-// Converts the given private key to an address
-func (self *XEth) ToAddress(priv []byte) []byte {
-	pair, err := crypto.NewKeyPairFromSec(priv)
+func (self *XEth) TxCountAt(address string) int {
+	return int(self.State().SafeGet(address).Nonce)
+}
+
+func (self *XEth) CodeAt(address string) string {
+	return toHex(self.State().SafeGet(address).Code)
+}
+
+func (self *XEth) IsContract(address string) bool {
+	return len(self.State().SafeGet(address).Code) > 0
+}
+
+func (self *XEth) SecretToAddress(key string) string {
+	pair, err := crypto.NewKeyPairFromSec(fromHex(key))
 	if err != nil {
-		return nil
+		return ""
 	}
 
-	return pair.Address()
+	return toHex(pair.Address())
 }
 
-/*
- * Execution helpers
- */
-func (self *XEth) Execute(addr []byte, data []byte, value, gas, price *ethutil.Value) ([]byte, error) {
-	return self.ExecuteObject(&Object{self.World().safeGet(addr)}, data, value, gas, price)
+func (self *XEth) Execute(addr, value, gas, price, data string) (string, error) {
+	return "", nil
 }
 
-func (self *XEth) ExecuteObject(object *Object, data []byte, value, gas, price *ethutil.Value) ([]byte, error) {
-	var (
-		initiator = state.NewStateObject(self.obj.KeyManager().KeyPair().Address())
-		block     = self.chainManager.CurrentBlock()
-	)
+type KeyVal struct {
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}
 
-	self.Vm.State = self.World().State().Copy()
+func (self *XEth) 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)})
+	}
 
-	vmenv := NewEnv(self.chainManager, self.Vm.State, block, value.BigInt(), initiator.Address())
-	return vmenv.Call(initiator, object.Address(), data, gas.BigInt(), price.BigInt(), value.BigInt())
+	valuesJson, err := json.Marshal(values)
+	if err != nil {
+		return ""
+	}
+
+	return string(valuesJson)
 }
 
-/*
- * Transactional methods
- */
-func (self *XEth) TransactString(key *crypto.KeyPair, rec string, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) {
-	// Check if an address is stored by this address
-	var hash []byte
-	addr := self.World().Config().Get("NameReg").StorageString(rec).Bytes()
-	if len(addr) > 0 {
-		hash = addr
-	} else if ethutil.IsHex(rec) {
-		hash = ethutil.Hex2Bytes(rec[2:])
-	} else {
-		hash = ethutil.Hex2Bytes(rec)
+func (self *XEth) ToAscii(str string) string {
+	padded := ethutil.RightPadBytes([]byte(str), 32)
+
+	return "0x" + toHex(padded)
+}
+
+func (self *XEth) FromAscii(str string) string {
+	if ethutil.IsHex(str) {
+		str = str[2:]
 	}
 
-	return self.Transact(key, hash, value, gas, price, data)
+	return string(bytes.Trim(fromHex(str), "\x00"))
 }
 
-func (self *XEth) Transact(key *crypto.KeyPair, to []byte, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) {
-	var hash []byte
-	var contractCreation bool
-	if types.IsContractAddr(to) {
+func (self *XEth) FromNumber(str string) string {
+	if ethutil.IsHex(str) {
+		str = str[2:]
+	}
+
+	return ethutil.BigD(fromHex(str)).String()
+}
+
+func (self *XEth) 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
+}
+
+func (self *XEth) Call(toStr, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) {
+	if len(gasStr) == 0 {
+		gasStr = "100000"
+	}
+	if len(gasPriceStr) == 0 {
+		gasPriceStr = "1"
+	}
+
+	var (
+		statedb = self.chainManager.TransState()
+		key     = self.eth.KeyManager().KeyPair()
+		from    = state.NewStateObject(key.Address(), self.eth.Db())
+		block   = self.chainManager.CurrentBlock()
+		to      = statedb.GetOrNewStateObject(fromHex(toStr))
+		data    = fromHex(dataStr)
+		gas     = ethutil.Big(gasStr)
+		price   = ethutil.Big(gasPriceStr)
+		value   = ethutil.Big(valueStr)
+	)
+
+	msg := types.NewTransactionMessage(fromHex(toStr), value, gas, price, data)
+	msg.Sign(key.PrivateKey)
+	vmenv := core.NewEnv(statedb, self.chainManager, msg, block)
+
+	res, err := vmenv.Call(from, to.Address(), data, gas, price, value)
+	if err != nil {
+		return "", err
+	}
+
+	return toHex(res), nil
+}
+
+func (self *XEth) Transact(toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
+
+	var (
+		to               []byte
+		value            = ethutil.NewValue(valueStr)
+		gas              = ethutil.NewValue(gasStr)
+		price            = ethutil.NewValue(gasPriceStr)
+		data             []byte
+		key              = self.eth.KeyManager().KeyPair()
+		contractCreation bool
+	)
+
+	data = fromHex(codeStr)
+	to = fromHex(toStr)
+	if len(to) == 0 {
 		contractCreation = true
-	} else {
-		// Check if an address is stored by this address
-		addr := self.World().Config().Get("NameReg").Storage(to).Bytes()
-		if len(addr) > 0 {
-			hash = addr
-		} else {
-			hash = to
-		}
 	}
 
 	var tx *types.Transaction
 	if contractCreation {
 		tx = types.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), data)
 	} else {
-		tx = types.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data)
+		tx = types.NewTransactionMessage(to, value.BigInt(), gas.BigInt(), price.BigInt(), data)
 	}
 
 	state := self.chainManager.TransState()
@@ -143,9 +274,9 @@ func (self *XEth) Transact(key *crypto.KeyPair, to []byte, value, gas, price *et
 	coinbase.SetGasPool(block.GasLimit())
 	self.blockProcessor.ApplyTransactions(coinbase, state, block, types.Transactions{tx}, true)
 
-	err := self.obj.TxPool().Add(tx)
+	err := self.eth.TxPool().Add(tx)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
 	state.SetNonce(key.Address(), nonce+1)
 
@@ -154,28 +285,9 @@ func (self *XEth) Transact(key *crypto.KeyPair, to []byte, value, gas, price *et
 		pipelogger.Infof("Contract addr %x\n", addr)
 	}
 
-	return tx, nil
-}
-
-func (self *XEth) PushTx(tx *types.Transaction) ([]byte, error) {
-	err := self.obj.TxPool().Add(tx)
-	if err != nil {
-		return nil, err
-	}
-
-	if tx.To() == nil {
-		addr := core.AddressFromMessage(tx)
-		pipelogger.Infof("Contract addr %x\n", addr)
-		return addr, nil
-	}
-	return tx.Hash(), nil
-}
-
-func (self *XEth) CompileMutan(code string) ([]byte, error) {
-	data, err := ethutil.Compile(code, false)
-	if err != nil {
-		return nil, err
+	if types.IsContractAddr(to) {
+		return toHex(core.AddressFromMessage(tx)), nil
 	}
 
-	return data, nil
+	return toHex(tx.Hash()), nil
 }