rpc: migrated the RPC insterface to a new reflection based RPC layer

8 files changed, 0 insertions, 1773 deletions

diff --git a/xeth/frontend.go b/xeth/frontend.go
deleted file mode 100644
index 70d99ebc4..000000000
--- a/xeth/frontend.go
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package xeth
-
-// Frontend should be implemented by users of XEth. Its methods are
-// called whenever XEth makes a decision that requires user input.
-type Frontend interface {
-	// AskPassword is called when a new account is created or updated
-	AskPassword() (string, bool)
-
-	// UnlockAccount is called when a transaction needs to be signed
-	// but the key corresponding to the transaction's sender is
-	// locked.
-	//
-	// It should unlock the account with the given address and return
-	// true if unlocking succeeded.
-	UnlockAccount(address []byte) bool
-
-	// This is called for all transactions inititated through
-	// Transact. It should prompt the user to confirm the transaction
-	// and return true if the transaction was acknowledged.
-	//
-	// ConfirmTransaction is not used for Call transactions
-	// because they cannot change any state.
-	ConfirmTransaction(tx string) bool
-}
-
-// dummyFrontend is a non-interactive frontend that allows all
-// transactions but cannot not unlock any keys.
-type dummyFrontend struct{}
-
-func (dummyFrontend) AskPassword() (string, bool)    { return "", false }
-func (dummyFrontend) UnlockAccount([]byte) bool      { return false }
-func (dummyFrontend) ConfirmTransaction(string) bool { return true }
diff --git a/xeth/state.go b/xeth/state.go
deleted file mode 100644
index 7daccb525..000000000
--- a/xeth/state.go
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package xeth
-
-import (
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/state"
-)
-
-type State struct {
-	xeth  *XEth
-	state *state.StateDB
-}
-
-func NewState(xeth *XEth, statedb *state.StateDB) *State {
-	return &State{xeth, statedb}
-}
-
-func (self *State) State() *state.StateDB {
-	return self.state
-}
-
-func (self *State) Get(addr string) *Object {
-	return &Object{self.state.GetStateObject(common.HexToAddress(addr))}
-}
-
-func (self *State) SafeGet(addr string) *Object {
-	return &Object{self.safeGet(addr)}
-}
-
-func (self *State) safeGet(addr string) *state.StateObject {
-	object := self.state.GetStateObject(common.HexToAddress(addr))
-	if object == nil {
-		object = state.NewStateObject(common.HexToAddress(addr), self.xeth.EthereumService().ChainDb())
-	}
-	return object
-}
diff --git a/xeth/types.go b/xeth/types.go
deleted file mode 100644
index 090115b7e..000000000
--- a/xeth/types.go
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2014 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package xeth
-
-import (
-	"bytes"
-	"fmt"
-	"math/big"
-	"strings"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/state"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-type Object struct {
-	*state.StateObject
-}
-
-func NewObject(state *state.StateObject) *Object {
-	return &Object{state}
-}
-
-func (self *Object) StorageString(str string) []byte {
-	if common.IsHex(str) {
-		return self.storage(common.Hex2Bytes(str[2:]))
-	} else {
-		return self.storage(common.RightPadBytes([]byte(str), 32))
-	}
-}
-
-func (self *Object) storage(addr []byte) []byte {
-	return self.StateObject.GetState(common.BytesToHash(addr)).Bytes()
-}
-
-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[common.ToHex(self.Trie().GetKey(it.Key))] = common.ToHex(data)
-	}
-
-	return
-}
-
-// Block interface exposed to QML
-type Block struct {
-	//Transactions string `json:"transactions"`
-	ref          *types.Block
-	Size         string       `json:"size"`
-	Number       int          `json:"number"`
-	Hash         string       `json:"hash"`
-	Transactions *common.List `json:"transactions"`
-	Uncles       *common.List `json:"uncles"`
-	Time         *big.Int     `json:"time"`
-	Coinbase     string       `json:"coinbase"`
-	Name         string       `json:"name"`
-	GasLimit     string       `json:"gasLimit"`
-	GasUsed      string       `json:"gasUsed"`
-	PrevHash     string       `json:"prevHash"`
-	Bloom        string       `json:"bloom"`
-	Raw          string       `json:"raw"`
-}
-
-// Creates a new QML Block from a chain block
-func NewBlock(block *types.Block) *Block {
-	if block == nil {
-		return &Block{}
-	}
-
-	ptxs := make([]*Transaction, len(block.Transactions()))
-	/*
-		for i, tx := range block.Transactions() {
-			ptxs[i] = NewTx(tx)
-		}
-	*/
-	txlist := common.NewList(ptxs)
-
-	puncles := make([]*Block, len(block.Uncles()))
-	/*
-		for i, uncle := range block.Uncles() {
-			puncles[i] = NewBlock(types.NewBlockWithHeader(uncle))
-		}
-	*/
-	ulist := common.NewList(puncles)
-
-	return &Block{
-		ref: block, Size: block.Size().String(),
-		Number: int(block.NumberU64()), GasUsed: block.GasUsed().String(),
-		GasLimit: block.GasLimit().String(), Hash: block.Hash().Hex(),
-		Transactions: txlist, Uncles: ulist,
-		Time:     block.Time(),
-		Coinbase: block.Coinbase().Hex(),
-		PrevHash: block.ParentHash().Hex(),
-		Bloom:    common.ToHex(block.Bloom().Bytes()),
-		Raw:      block.String(),
-	}
-}
-
-func (self *Block) ToString() string {
-	if self.ref != nil {
-		return self.ref.String()
-	}
-
-	return ""
-}
-
-func (self *Block) GetTransaction(hash string) *Transaction {
-	tx := self.ref.Transaction(common.HexToHash(hash))
-	if tx == nil {
-		return nil
-	}
-
-	return NewTx(tx)
-}
-
-type Transaction struct {
-	ref *types.Transaction
-
-	Value           string `json:"value"`
-	Gas             string `json:"gas"`
-	GasPrice        string `json:"gasPrice"`
-	Hash            string `json:"hash"`
-	Address         string `json:"address"`
-	Sender          string `json:"sender"`
-	RawData         string `json:"rawData"`
-	Data            string `json:"data"`
-	Contract        bool   `json:"isContract"`
-	CreatesContract bool   `json:"createsContract"`
-	Confirmations   int    `json:"confirmations"`
-}
-
-func NewTx(tx *types.Transaction) *Transaction {
-	sender, err := tx.From()
-	if err != nil {
-		return nil
-	}
-	hash := tx.Hash().Hex()
-
-	var receiver string
-	if to := tx.To(); to != nil {
-		receiver = to.Hex()
-	} else {
-		from, _ := tx.From()
-		receiver = crypto.CreateAddress(from, tx.Nonce()).Hex()
-	}
-	createsContract := core.MessageCreatesContract(tx)
-
-	var data string
-	if createsContract {
-		data = strings.Join(core.Disassemble(tx.Data()), "\n")
-	} else {
-		data = common.ToHex(tx.Data())
-	}
-
-	return &Transaction{ref: tx, Hash: hash, Value: common.CurrencyToString(tx.Value()), Address: receiver, Contract: createsContract, Gas: tx.Gas().String(), GasPrice: tx.GasPrice().String(), Data: data, Sender: sender.Hex(), CreatesContract: createsContract, RawData: common.ToHex(tx.Data())}
-}
-
-func (self *Transaction) ToString() string {
-	return self.ref.String()
-}
-
-type PReceipt struct {
-	CreatedContract bool   `json:"createdContract"`
-	Address         string `json:"address"`
-	Hash            string `json:"hash"`
-	Sender          string `json:"sender"`
-}
-
-func NewPReciept(contractCreation bool, creationAddress, hash, address []byte) *PReceipt {
-	return &PReceipt{
-		contractCreation,
-		common.ToHex(creationAddress),
-		common.ToHex(hash),
-		common.ToHex(address),
-	}
-}
-
-// Peer interface exposed to QML
-
-type Peer struct {
-	ref     *p2p.Peer
-	Ip      string `json:"ip"`
-	Version string `json:"version"`
-	Caps    string `json:"caps"`
-}
-
-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 &Peer{
-		ref:     peer,
-		Ip:      fmt.Sprintf("%v", peer.RemoteAddr()),
-		Version: fmt.Sprintf("%v", peer.ID()),
-		Caps:    fmt.Sprintf("%v", caps),
-	}
-}
-
-type Receipt struct {
-	CreatedContract bool   `json:"createdContract"`
-	Address         string `json:"address"`
-	Hash            string `json:"hash"`
-	Sender          string `json:"sender"`
-}
-
-func NewReciept(contractCreation bool, creationAddress, hash, address []byte) *Receipt {
-	return &Receipt{
-		contractCreation,
-		common.ToHex(creationAddress),
-		common.ToHex(hash),
-		common.ToHex(address),
-	}
-}
diff --git a/xeth/whisper.go b/xeth/whisper.go
deleted file mode 100644
index e7130978f..000000000
--- a/xeth/whisper.go
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// Contains the external API to the whisper sub-protocol.
-
-package xeth
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/logger"
-	"github.com/ethereum/go-ethereum/whisper"
-)
-
-var qlogger = logger.NewLogger("XSHH")
-
-// Whisper represents the API wrapper around the internal whisper implementation.
-type Whisper struct {
-	*whisper.Whisper
-}
-
-// NewWhisper wraps an internal whisper client into an external API version.
-func NewWhisper(w *whisper.Whisper) *Whisper {
-	return &Whisper{w}
-}
-
-// NewIdentity generates a new cryptographic identity for the client, and injects
-// it into the known identities for message decryption.
-func (self *Whisper) NewIdentity() string {
-	identity := self.Whisper.NewIdentity()
-	return common.ToHex(crypto.FromECDSAPub(&identity.PublicKey))
-}
-
-// HasIdentity checks if the the whisper node is configured with the private key
-// of the specified public pair.
-func (self *Whisper) HasIdentity(key string) bool {
-	return self.Whisper.HasIdentity(crypto.ToECDSAPub(common.FromHex(key)))
-}
-
-// Post injects a message into the whisper network for distribution.
-func (self *Whisper) Post(payload string, to, from string, topics []string, priority, ttl uint32) error {
-	// Decode the topic strings
-	topicsDecoded := make([][]byte, len(topics))
-	for i, topic := range topics {
-		topicsDecoded[i] = common.FromHex(topic)
-	}
-	// Construct the whisper message and transmission options
-	message := whisper.NewMessage(common.FromHex(payload))
-	options := whisper.Options{
-		To:     crypto.ToECDSAPub(common.FromHex(to)),
-		TTL:    time.Duration(ttl) * time.Second,
-		Topics: whisper.NewTopics(topicsDecoded...),
-	}
-	if len(from) != 0 {
-		if key := self.Whisper.GetIdentity(crypto.ToECDSAPub(common.FromHex(from))); key != nil {
-			options.From = key
-		} else {
-			return fmt.Errorf("unknown identity to send from: %s", from)
-		}
-	}
-	// Wrap and send the message
-	pow := time.Duration(priority) * time.Millisecond
-	envelope, err := message.Wrap(pow, options)
-	if err != nil {
-		return err
-	}
-	if err := self.Whisper.Send(envelope); err != nil {
-		return err
-	}
-	return nil
-}
-
-// Watch installs a new message handler to run in case a matching packet arrives
-// from the whisper network.
-func (self *Whisper) Watch(to, from string, topics [][]string, fn func(WhisperMessage)) int {
-	// Decode the topic strings
-	topicsDecoded := make([][][]byte, len(topics))
-	for i, condition := range topics {
-		topicsDecoded[i] = make([][]byte, len(condition))
-		for j, topic := range condition {
-			topicsDecoded[i][j] = common.FromHex(topic)
-		}
-	}
-	// Assemble and inject the filter into the whisper client
-	filter := whisper.Filter{
-		To:     crypto.ToECDSAPub(common.FromHex(to)),
-		From:   crypto.ToECDSAPub(common.FromHex(from)),
-		Topics: whisper.NewFilterTopics(topicsDecoded...),
-	}
-	filter.Fn = func(message *whisper.Message) {
-		fn(NewWhisperMessage(message))
-	}
-	return self.Whisper.Watch(filter)
-}
-
-// Messages retrieves all the currently pooled messages matching a filter id.
-func (self *Whisper) Messages(id int) []WhisperMessage {
-	pool := self.Whisper.Messages(id)
-
-	messages := make([]WhisperMessage, len(pool))
-	for i, message := range pool {
-		messages[i] = NewWhisperMessage(message)
-	}
-	return messages
-}
diff --git a/xeth/whisper_filter.go b/xeth/whisper_filter.go
deleted file mode 100644
index fdf5cebae..000000000
--- a/xeth/whisper_filter.go
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// Contains the external API side message filter for watching, pooling and polling
-// matched whisper messages, also serializing data access to avoid duplications.
-
-package xeth
-
-import (
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-// whisperFilter is the message cache matching a specific filter, accumulating
-// inbound messages until the are requested by the client.
-type whisperFilter struct {
-	id  int      // Filter identifier for old message retrieval
-	ref *Whisper // Whisper reference for old message retrieval
-
-	cache  []WhisperMessage         // Cache of messages not yet polled
-	skip   map[common.Hash]struct{} // List of retrieved messages to avoid duplication
-	update time.Time                // Time of the last message query
-
-	lock sync.RWMutex // Lock protecting the filter internals
-}
-
-// newWhisperFilter creates a new serialized, poll based whisper topic filter.
-func newWhisperFilter(id int, ref *Whisper) *whisperFilter {
-	return &whisperFilter{
-		id:  id,
-		ref: ref,
-
-		update: time.Now(),
-		skip:   make(map[common.Hash]struct{}),
-	}
-}
-
-// messages retrieves all the cached messages from the entire pool matching the
-// filter, resetting the filter's change buffer.
-func (w *whisperFilter) messages() []WhisperMessage {
-	w.lock.Lock()
-	defer w.lock.Unlock()
-
-	w.cache = nil
-	w.update = time.Now()
-
-	w.skip = make(map[common.Hash]struct{})
-	messages := w.ref.Messages(w.id)
-	for _, message := range messages {
-		w.skip[message.ref.Hash] = struct{}{}
-	}
-	return messages
-}
-
-// insert injects a new batch of messages into the filter cache.
-func (w *whisperFilter) insert(messages ...WhisperMessage) {
-	w.lock.Lock()
-	defer w.lock.Unlock()
-
-	for _, message := range messages {
-		if _, ok := w.skip[message.ref.Hash]; !ok {
-			w.cache = append(w.cache, messages...)
-		}
-	}
-}
-
-// retrieve fetches all the cached messages from the filter.
-func (w *whisperFilter) retrieve() (messages []WhisperMessage) {
-	w.lock.Lock()
-	defer w.lock.Unlock()
-
-	messages, w.cache = w.cache, nil
-	w.update = time.Now()
-
-	return
-}
-
-// activity returns the last time instance when client requests were executed on
-// the filter.
-func (w *whisperFilter) activity() time.Time {
-	w.lock.RLock()
-	defer w.lock.RUnlock()
-
-	return w.update
-}
diff --git a/xeth/whisper_message.go b/xeth/whisper_message.go
deleted file mode 100644
index b3014a697..000000000
--- a/xeth/whisper_message.go
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// Contains the external API representation of a whisper message.
-
-package xeth
-
-import (
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/whisper"
-)
-
-// WhisperMessage is the external API representation of a whisper.Message.
-type WhisperMessage struct {
-	ref *whisper.Message
-
-	Payload string `json:"payload"`
-	To      string `json:"to"`
-	From    string `json:"from"`
-	Sent    int64  `json:"sent"`
-	TTL     int64  `json:"ttl"`
-	Hash    string `json:"hash"`
-}
-
-// NewWhisperMessage converts an internal message into an API version.
-func NewWhisperMessage(message *whisper.Message) WhisperMessage {
-	return WhisperMessage{
-		ref: message,
-
-		Payload: common.ToHex(message.Payload),
-		From:    common.ToHex(crypto.FromECDSAPub(message.Recover())),
-		To:      common.ToHex(crypto.FromECDSAPub(message.To)),
-		Sent:    message.Sent.Unix(),
-		TTL:     int64(message.TTL / time.Second),
-		Hash:    common.ToHex(message.Hash.Bytes()),
-	}
-}
diff --git a/xeth/xeth.go b/xeth/xeth.go
deleted file mode 100644
index 5a5399a3e..000000000
--- a/xeth/xeth.go
+++ /dev/null
@@ -1,1137 +0,0 @@
-// Copyright 2014 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// Package xeth is the interface to all Ethereum functionality.
-package xeth
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"math/big"
-	"regexp"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/compiler"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/state"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/eth"
-	"github.com/ethereum/go-ethereum/eth/filters"
-	"github.com/ethereum/go-ethereum/logger"
-	"github.com/ethereum/go-ethereum/logger/glog"
-	"github.com/ethereum/go-ethereum/miner"
-	"github.com/ethereum/go-ethereum/node"
-	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/ethereum/go-ethereum/whisper"
-)
-
-var (
-	filterTickerTime = 5 * time.Minute
-	defaultGasPrice  = big.NewInt(10000000000000) //150000000000
-	defaultGas       = big.NewInt(90000)          //500000
-	dappStorePre     = []byte("dapp-")
-	addrReg          = regexp.MustCompile(`^(0x)?[a-fA-F0-9]{40}$`)
-)
-
-// byte will be inferred
-const (
-	UnknownFilterTy = iota
-	BlockFilterTy
-	TransactionFilterTy
-	LogFilterTy
-)
-
-type XEth struct {
-	quit chan struct{}
-
-	logMu    sync.RWMutex
-	logQueue map[int]*logQueue
-
-	blockMu    sync.RWMutex
-	blockQueue map[int]*hashQueue
-
-	transactionMu    sync.RWMutex
-	transactionQueue map[int]*hashQueue
-
-	messagesMu sync.RWMutex
-	messages   map[int]*whisperFilter
-
-	transactMu sync.Mutex
-
-	// read-only fields
-	backend       *node.Node
-	frontend      Frontend
-	agent         *miner.RemoteAgent
-	gpo           *eth.GasPriceOracle
-	state         *State
-	whisper       *Whisper
-	filterManager *filters.FilterSystem
-}
-
-func NewTest(stack *node.Node, frontend Frontend) *XEth {
-	return &XEth{backend: stack, frontend: frontend}
-}
-
-// New creates an XEth that uses the given frontend.
-// If a nil Frontend is provided, a default frontend which
-// confirms all transactions will be used.
-func New(stack *node.Node, frontend Frontend) *XEth {
-	var (
-		ethereum *eth.Ethereum
-		whisper  *whisper.Whisper
-	)
-	stack.Service(&ethereum)
-	stack.Service(&whisper)
-
-	xeth := &XEth{
-		backend:          stack,
-		frontend:         frontend,
-		quit:             make(chan struct{}),
-		filterManager:    filters.NewFilterSystem(stack.EventMux()),
-		logQueue:         make(map[int]*logQueue),
-		blockQueue:       make(map[int]*hashQueue),
-		transactionQueue: make(map[int]*hashQueue),
-		messages:         make(map[int]*whisperFilter),
-		agent:            miner.NewRemoteAgent(),
-		gpo:              eth.NewGasPriceOracle(ethereum),
-	}
-	if whisper != nil {
-		xeth.whisper = NewWhisper(whisper)
-	}
-	ethereum.Miner().Register(xeth.agent)
-	if frontend == nil {
-		xeth.frontend = dummyFrontend{}
-	}
-	state, _ := ethereum.BlockChain().State()
-	xeth.state = NewState(xeth, state)
-	go xeth.start()
-	return xeth
-}
-
-func (self *XEth) EthereumService() *eth.Ethereum {
-	var ethereum *eth.Ethereum
-	if err := self.backend.Service(&ethereum); err != nil {
-		return nil
-	}
-	return ethereum
-}
-
-func (self *XEth) WhisperService() *whisper.Whisper {
-	var whisper *whisper.Whisper
-	if err := self.backend.Service(&whisper); err != nil {
-		return nil
-	}
-	return whisper
-}
-
-func (self *XEth) start() {
-	timer := time.NewTicker(2 * time.Second)
-	defer timer.Stop()
-done:
-	for {
-		select {
-		case <-timer.C:
-			self.logMu.Lock()
-			for id, filter := range self.logQueue {
-				if time.Since(filter.timeout) > filterTickerTime {
-					self.filterManager.Remove(id)
-					delete(self.logQueue, id)
-				}
-			}
-			self.logMu.Unlock()
-
-			self.blockMu.Lock()
-			for id, filter := range self.blockQueue {
-				if time.Since(filter.timeout) > filterTickerTime {
-					self.filterManager.Remove(id)
-					delete(self.blockQueue, id)
-				}
-			}
-			self.blockMu.Unlock()
-
-			self.transactionMu.Lock()
-			for id, filter := range self.transactionQueue {
-				if time.Since(filter.timeout) > filterTickerTime {
-					self.filterManager.Remove(id)
-					delete(self.transactionQueue, id)
-				}
-			}
-			self.transactionMu.Unlock()
-
-			self.messagesMu.Lock()
-			for id, filter := range self.messages {
-				if time.Since(filter.activity()) > filterTickerTime {
-					self.Whisper().Unwatch(id)
-					delete(self.messages, id)
-				}
-			}
-			self.messagesMu.Unlock()
-		case <-self.quit:
-			break done
-		}
-	}
-}
-
-// Stop releases any resources associated with self.
-// It may not be called more than once.
-func (self *XEth) Stop() {
-	close(self.quit)
-	self.filterManager.Stop()
-	self.EthereumService().Miner().Unregister(self.agent)
-}
-
-func cAddress(a []string) []common.Address {
-	bslice := make([]common.Address, len(a))
-	for i, addr := range a {
-		bslice[i] = common.HexToAddress(addr)
-	}
-	return bslice
-}
-
-func cTopics(t [][]string) [][]common.Hash {
-	topics := make([][]common.Hash, len(t))
-	for i, iv := range t {
-		topics[i] = make([]common.Hash, len(iv))
-		for j, jv := range iv {
-			topics[i][j] = common.HexToHash(jv)
-		}
-	}
-	return topics
-}
-
-func DefaultGas() *big.Int { return new(big.Int).Set(defaultGas) }
-
-func (self *XEth) DefaultGasPrice() *big.Int {
-	return self.gpo.SuggestPrice()
-}
-
-func (self *XEth) RemoteMining() *miner.RemoteAgent { return self.agent }
-
-func (self *XEth) AtStateNum(num int64) *XEth {
-	var st *state.StateDB
-	var err error
-	switch num {
-	case -2:
-		st = self.EthereumService().Miner().PendingState().Copy()
-	default:
-		if block := self.getBlockByHeight(num); block != nil {
-			st, err = state.New(block.Root(), self.EthereumService().ChainDb())
-			if err != nil {
-				return nil
-			}
-		} else {
-			st, err = state.New(self.EthereumService().BlockChain().GetBlockByNumber(0).Root(), self.EthereumService().ChainDb())
-			if err != nil {
-				return nil
-			}
-		}
-	}
-	return self.WithState(st)
-}
-
-func (self *XEth) WithState(statedb *state.StateDB) *XEth {
-	xeth := &XEth{
-		backend:  self.backend,
-		frontend: self.frontend,
-		gpo:      self.gpo,
-	}
-
-	xeth.state = NewState(xeth, statedb)
-	return xeth
-}
-
-func (self *XEth) State() *State { return self.state }
-
-// subscribes to new head block events and
-// waits until blockchain height is greater n at any time
-// given the current head, waits for the next chain event
-// sets the state to the current head
-// loop is async and quit by closing the channel
-// used in tests and JS console debug module to control advancing private chain manually
-// Note: this is not threadsafe, only called in JS single process and tests
-func (self *XEth) UpdateState() (wait chan *big.Int) {
-	wait = make(chan *big.Int)
-	go func() {
-		eventSub := self.backend.EventMux().Subscribe(core.ChainHeadEvent{})
-		defer eventSub.Unsubscribe()
-
-		var m, n *big.Int
-		var ok bool
-
-		eventCh := eventSub.Chan()
-		for {
-			select {
-			case event, ok := <-eventCh:
-				if !ok {
-					// Event subscription closed, set the channel to nil to stop spinning
-					eventCh = nil
-					continue
-				}
-				// A real event arrived, process if new head block assignment
-				if event, ok := event.Data.(core.ChainHeadEvent); ok {
-					m = event.Block.Number()
-					if n != nil && n.Cmp(m) < 0 {
-						wait <- n
-						n = nil
-					}
-					statedb, err := state.New(event.Block.Root(), self.EthereumService().ChainDb())
-					if err != nil {
-						glog.V(logger.Error).Infoln("Could not create new state: %v", err)
-						return
-					}
-					self.state = NewState(self, statedb)
-				}
-			case n, ok = <-wait:
-				if !ok {
-					return
-				}
-			}
-		}
-	}()
-	return
-}
-
-func (self *XEth) Whisper() *Whisper { return self.whisper }
-
-func (self *XEth) getBlockByHeight(height int64) *types.Block {
-	var num uint64
-
-	switch height {
-	case -2:
-		return self.EthereumService().Miner().PendingBlock()
-	case -1:
-		return self.CurrentBlock()
-	default:
-		if height < 0 {
-			return nil
-		}
-
-		num = uint64(height)
-	}
-
-	return self.EthereumService().BlockChain().GetBlockByNumber(num)
-}
-
-func (self *XEth) BlockByHash(strHash string) *Block {
-	hash := common.HexToHash(strHash)
-	block := self.EthereumService().BlockChain().GetBlock(hash)
-
-	return NewBlock(block)
-}
-
-func (self *XEth) EthBlockByHash(strHash string) *types.Block {
-	hash := common.HexToHash(strHash)
-	block := self.EthereumService().BlockChain().GetBlock(hash)
-
-	return block
-}
-
-func (self *XEth) EthTransactionByHash(hash string) (*types.Transaction, common.Hash, uint64, uint64) {
-	ethereum := self.EthereumService()
-	if tx, hash, number, index := core.GetTransaction(ethereum.ChainDb(), common.HexToHash(hash)); tx != nil {
-		return tx, hash, number, index
-	}
-	return ethereum.TxPool().GetTransaction(common.HexToHash(hash)), common.Hash{}, 0, 0
-}
-
-func (self *XEth) BlockByNumber(num int64) *Block {
-	return NewBlock(self.getBlockByHeight(num))
-}
-
-func (self *XEth) EthBlockByNumber(num int64) *types.Block {
-	return self.getBlockByHeight(num)
-}
-
-func (self *XEth) Td(hash common.Hash) *big.Int {
-	return self.EthereumService().BlockChain().GetTd(hash)
-}
-
-func (self *XEth) CurrentBlock() *types.Block {
-	return self.EthereumService().BlockChain().CurrentBlock()
-}
-
-func (self *XEth) GetBlockReceipts(bhash common.Hash) types.Receipts {
-	return core.GetBlockReceipts(self.EthereumService().ChainDb(), bhash)
-}
-
-func (self *XEth) GetTxReceipt(txhash common.Hash) *types.Receipt {
-	return core.GetReceipt(self.EthereumService().ChainDb(), txhash)
-}
-
-func (self *XEth) GasLimit() *big.Int {
-	return self.EthereumService().BlockChain().GasLimit()
-}
-
-func (self *XEth) Block(v interface{}) *Block {
-	if n, ok := v.(int32); ok {
-		return self.BlockByNumber(int64(n))
-	} else if str, ok := v.(string); ok {
-		return self.BlockByHash(str)
-	} else if f, ok := v.(float64); ok { // JSON numbers are represented as float64
-		return self.BlockByNumber(int64(f))
-	}
-
-	return nil
-}
-
-func (self *XEth) Accounts() []string {
-	// TODO: check err?
-	accounts, _ := self.EthereumService().AccountManager().Accounts()
-	accountAddresses := make([]string, len(accounts))
-	for i, ac := range accounts {
-		accountAddresses[i] = ac.Address.Hex()
-	}
-	return accountAddresses
-}
-
-// accessor for solidity compiler.
-// memoized if available, retried on-demand if not
-func (self *XEth) Solc() (*compiler.Solidity, error) {
-	return self.EthereumService().Solc()
-}
-
-// set in js console via admin interface or wrapper from cli flags
-func (self *XEth) SetSolc(solcPath string) (*compiler.Solidity, error) {
-	self.EthereumService().SetSolc(solcPath)
-	return self.Solc()
-}
-
-// store DApp value in extra database
-func (self *XEth) DbPut(key, val []byte) bool {
-	self.EthereumService().DappDb().Put(append(dappStorePre, key...), val)
-	return true
-}
-
-// retrieve DApp value from extra database
-func (self *XEth) DbGet(key []byte) ([]byte, error) {
-	val, err := self.EthereumService().DappDb().Get(append(dappStorePre, key...))
-	return val, err
-}
-
-func (self *XEth) PeerCount() int {
-	return self.backend.Server().PeerCount()
-}
-
-func (self *XEth) IsMining() bool {
-	return self.EthereumService().IsMining()
-}
-
-func (self *XEth) HashRate() int64 {
-	return self.EthereumService().Miner().HashRate()
-}
-
-func (self *XEth) EthVersion() string {
-	return fmt.Sprintf("%d", self.EthereumService().EthVersion())
-}
-
-func (self *XEth) NetworkVersion() string {
-	return fmt.Sprintf("%d", self.EthereumService().NetVersion())
-}
-
-func (self *XEth) WhisperVersion() string {
-	return fmt.Sprintf("%d", self.WhisperService().Version())
-}
-
-func (self *XEth) ClientVersion() string {
-	return self.backend.Server().Name
-}
-
-func (self *XEth) SetMining(shouldmine bool, threads int) bool {
-	ismining := self.EthereumService().IsMining()
-	if shouldmine && !ismining {
-		err := self.EthereumService().StartMining(threads, "")
-		return err == nil
-	}
-	if ismining && !shouldmine {
-		self.EthereumService().StopMining()
-	}
-	return self.EthereumService().IsMining()
-}
-
-func (self *XEth) IsListening() bool {
-	return true
-}
-
-func (self *XEth) Coinbase() string {
-	eb, err := self.EthereumService().Etherbase()
-	if err != nil {
-		return "0x0"
-	}
-	return eb.Hex()
-}
-
-func (self *XEth) NumberToHuman(balance string) string {
-	b := common.Big(balance)
-
-	return common.CurrencyToString(b)
-}
-
-func (self *XEth) StorageAt(addr, storageAddr string) string {
-	return self.State().state.GetState(common.HexToAddress(addr), common.HexToHash(storageAddr)).Hex()
-}
-
-func (self *XEth) BalanceAt(addr string) string {
-	return common.ToHex(self.State().state.GetBalance(common.HexToAddress(addr)).Bytes())
-}
-
-func (self *XEth) TxCountAt(address string) int {
-	return int(self.State().state.GetNonce(common.HexToAddress(address)))
-}
-
-func (self *XEth) CodeAt(address string) string {
-	return common.ToHex(self.State().state.GetCode(common.HexToAddress(address)))
-}
-
-func (self *XEth) CodeAtBytes(address string) []byte {
-	return self.State().SafeGet(address).Code()
-}
-
-func (self *XEth) IsContract(address string) bool {
-	return len(self.State().SafeGet(address).Code()) > 0
-}
-
-func (self *XEth) UninstallFilter(id int) bool {
-	defer self.filterManager.Remove(id)
-
-	if _, ok := self.logQueue[id]; ok {
-		self.logMu.Lock()
-		defer self.logMu.Unlock()
-		delete(self.logQueue, id)
-		return true
-	}
-	if _, ok := self.blockQueue[id]; ok {
-		self.blockMu.Lock()
-		defer self.blockMu.Unlock()
-		delete(self.blockQueue, id)
-		return true
-	}
-	if _, ok := self.transactionQueue[id]; ok {
-		self.transactionMu.Lock()
-		defer self.transactionMu.Unlock()
-		delete(self.transactionQueue, id)
-		return true
-	}
-
-	return false
-}
-
-func (self *XEth) NewLogFilter(earliest, latest int64, skip, max int, address []string, topics [][]string) int {
-	self.logMu.Lock()
-	defer self.logMu.Unlock()
-
-	filter := filters.New(self.EthereumService().ChainDb())
-	id := self.filterManager.Add(filter)
-	self.logQueue[id] = &logQueue{timeout: time.Now()}
-
-	filter.SetBeginBlock(earliest)
-	filter.SetEndBlock(latest)
-	filter.SetAddresses(cAddress(address))
-	filter.SetTopics(cTopics(topics))
-	filter.LogsCallback = func(logs vm.Logs) {
-		self.logMu.Lock()
-		defer self.logMu.Unlock()
-
-		if queue := self.logQueue[id]; queue != nil {
-			queue.add(logs...)
-		}
-	}
-
-	return id
-}
-
-func (self *XEth) NewTransactionFilter() int {
-	self.transactionMu.Lock()
-	defer self.transactionMu.Unlock()
-
-	filter := filters.New(self.EthereumService().ChainDb())
-	id := self.filterManager.Add(filter)
-	self.transactionQueue[id] = &hashQueue{timeout: time.Now()}
-
-	filter.TransactionCallback = func(tx *types.Transaction) {
-		self.transactionMu.Lock()
-		defer self.transactionMu.Unlock()
-
-		if queue := self.transactionQueue[id]; queue != nil {
-			queue.add(tx.Hash())
-		}
-	}
-	return id
-}
-
-func (self *XEth) NewBlockFilter() int {
-	self.blockMu.Lock()
-	defer self.blockMu.Unlock()
-
-	filter := filters.New(self.EthereumService().ChainDb())
-	id := self.filterManager.Add(filter)
-	self.blockQueue[id] = &hashQueue{timeout: time.Now()}
-
-	filter.BlockCallback = func(block *types.Block, logs vm.Logs) {
-		self.blockMu.Lock()
-		defer self.blockMu.Unlock()
-
-		if queue := self.blockQueue[id]; queue != nil {
-			queue.add(block.Hash())
-		}
-	}
-	return id
-}
-
-func (self *XEth) GetFilterType(id int) byte {
-	if _, ok := self.blockQueue[id]; ok {
-		return BlockFilterTy
-	} else if _, ok := self.transactionQueue[id]; ok {
-		return TransactionFilterTy
-	} else if _, ok := self.logQueue[id]; ok {
-		return LogFilterTy
-	}
-
-	return UnknownFilterTy
-}
-
-func (self *XEth) LogFilterChanged(id int) vm.Logs {
-	self.logMu.Lock()
-	defer self.logMu.Unlock()
-
-	if self.logQueue[id] != nil {
-		return self.logQueue[id].get()
-	}
-	return nil
-}
-
-func (self *XEth) BlockFilterChanged(id int) []common.Hash {
-	self.blockMu.Lock()
-	defer self.blockMu.Unlock()
-
-	if self.blockQueue[id] != nil {
-		return self.blockQueue[id].get()
-	}
-	return nil
-}
-
-func (self *XEth) TransactionFilterChanged(id int) []common.Hash {
-	self.blockMu.Lock()
-	defer self.blockMu.Unlock()
-
-	if self.transactionQueue[id] != nil {
-		return self.transactionQueue[id].get()
-	}
-	return nil
-}
-
-func (self *XEth) Logs(id int) vm.Logs {
-	filter := self.filterManager.Get(id)
-	if filter != nil {
-		return filter.Find()
-	}
-
-	return nil
-}
-
-func (self *XEth) AllLogs(earliest, latest int64, skip, max int, address []string, topics [][]string) vm.Logs {
-	filter := filters.New(self.EthereumService().ChainDb())
-	filter.SetBeginBlock(earliest)
-	filter.SetEndBlock(latest)
-	filter.SetAddresses(cAddress(address))
-	filter.SetTopics(cTopics(topics))
-
-	return filter.Find()
-}
-
-// NewWhisperFilter creates and registers a new message filter to watch for
-// inbound whisper messages. All parameters at this point are assumed to be
-// HEX encoded.
-func (p *XEth) NewWhisperFilter(to, from string, topics [][]string) int {
-	// Pre-define the id to be filled later
-	var id int
-
-	// Callback to delegate core whisper messages to this xeth filter
-	callback := func(msg WhisperMessage) {
-		p.messagesMu.RLock() // Only read lock to the filter pool
-		defer p.messagesMu.RUnlock()
-		if p.messages[id] != nil {
-			p.messages[id].insert(msg)
-		}
-	}
-	// Initialize the core whisper filter and wrap into xeth
-	id = p.Whisper().Watch(to, from, topics, callback)
-
-	p.messagesMu.Lock()
-	p.messages[id] = newWhisperFilter(id, p.Whisper())
-	p.messagesMu.Unlock()
-
-	return id
-}
-
-// UninstallWhisperFilter disables and removes an existing filter.
-func (p *XEth) UninstallWhisperFilter(id int) bool {
-	p.messagesMu.Lock()
-	defer p.messagesMu.Unlock()
-
-	if _, ok := p.messages[id]; ok {
-		delete(p.messages, id)
-		return true
-	}
-	return false
-}
-
-// WhisperMessages retrieves all the known messages that match a specific filter.
-func (self *XEth) WhisperMessages(id int) []WhisperMessage {
-	self.messagesMu.RLock()
-	defer self.messagesMu.RUnlock()
-
-	if self.messages[id] != nil {
-		return self.messages[id].messages()
-	}
-	return nil
-}
-
-// WhisperMessagesChanged retrieves all the new messages matched by a filter
-// since the last retrieval
-func (self *XEth) WhisperMessagesChanged(id int) []WhisperMessage {
-	self.messagesMu.RLock()
-	defer self.messagesMu.RUnlock()
-
-	if self.messages[id] != nil {
-		return self.messages[id].retrieve()
-	}
-	return nil
-}
-
-// func (self *XEth) Register(args string) bool {
-// 	self.regmut.Lock()
-// 	defer self.regmut.Unlock()
-
-// 	if _, ok := self.register[args]; ok {
-// 		self.register[args] = nil // register with empty
-// 	}
-// 	return true
-// }
-
-// func (self *XEth) Unregister(args string) bool {
-// 	self.regmut.Lock()
-// 	defer self.regmut.Unlock()
-
-// 	if _, ok := self.register[args]; ok {
-// 		delete(self.register, args)
-// 		return true
-// 	}
-
-// 	return false
-// }
-
-// // TODO improve return type
-// func (self *XEth) PullWatchTx(args string) []*interface{} {
-// 	self.regmut.Lock()
-// 	defer self.regmut.Unlock()
-
-// 	txs := self.register[args]
-// 	self.register[args] = nil
-
-// 	return txs
-// }
-
-type KeyVal struct {
-	Key   string `json:"key"`
-	Value string `json:"value"`
-}
-
-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{common.ToHex(object.Trie().GetKey(it.Key)), common.ToHex(it.Value)})
-	}
-
-	valuesJson, err := json.Marshal(values)
-	if err != nil {
-		return ""
-	}
-
-	return string(valuesJson)
-}
-
-func (self *XEth) ToAscii(str string) string {
-	padded := common.RightPadBytes([]byte(str), 32)
-
-	return "0x" + common.ToHex(padded)
-}
-
-func (self *XEth) FromAscii(str string) string {
-	if common.IsHex(str) {
-		str = str[2:]
-	}
-
-	return string(bytes.Trim(common.FromHex(str), "\x00"))
-}
-
-func (self *XEth) FromNumber(str string) string {
-	if common.IsHex(str) {
-		str = str[2:]
-	}
-
-	return common.BigD(common.FromHex(str)).String()
-}
-
-func (self *XEth) PushTx(encodedTx string) (string, error) {
-	tx := new(types.Transaction)
-	err := rlp.DecodeBytes(common.FromHex(encodedTx), tx)
-	if err != nil {
-		glog.V(logger.Error).Infoln(err)
-		return "", err
-	}
-
-	err = self.EthereumService().TxPool().Add(tx)
-	if err != nil {
-		return "", err
-	}
-
-	if tx.To() == nil {
-		from, err := tx.From()
-		if err != nil {
-			return "", err
-		}
-
-		addr := crypto.CreateAddress(from, tx.Nonce())
-		glog.V(logger.Info).Infof("Tx(%x) created: %x\n", tx.Hash(), addr)
-	} else {
-		glog.V(logger.Info).Infof("Tx(%x) to: %x\n", tx.Hash(), tx.To())
-	}
-
-	return tx.Hash().Hex(), nil
-}
-
-func (self *XEth) Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, dataStr string) (string, string, error) {
-	statedb := self.State().State().Copy()
-	var from *state.StateObject
-	if len(fromStr) == 0 {
-		accounts, err := self.EthereumService().AccountManager().Accounts()
-		if err != nil || len(accounts) == 0 {
-			from = statedb.GetOrNewStateObject(common.Address{})
-		} else {
-			from = statedb.GetOrNewStateObject(accounts[0].Address)
-		}
-	} else {
-		from = statedb.GetOrNewStateObject(common.HexToAddress(fromStr))
-	}
-
-	from.SetBalance(common.MaxBig)
-
-	msg := callmsg{
-		from:     from,
-		gas:      common.Big(gasStr),
-		gasPrice: common.Big(gasPriceStr),
-		value:    common.Big(valueStr),
-		data:     common.FromHex(dataStr),
-	}
-	if len(toStr) > 0 {
-		addr := common.HexToAddress(toStr)
-		msg.to = &addr
-	}
-
-	if msg.gas.Cmp(big.NewInt(0)) == 0 {
-		msg.gas = big.NewInt(50000000)
-	}
-
-	if msg.gasPrice.Cmp(big.NewInt(0)) == 0 {
-		msg.gasPrice = self.DefaultGasPrice()
-	}
-
-	header := self.CurrentBlock().Header()
-	vmenv := core.NewEnv(statedb, self.EthereumService().BlockChain(), msg, header)
-	gp := new(core.GasPool).AddGas(common.MaxBig)
-	res, gas, err := core.ApplyMessage(vmenv, msg, gp)
-	return common.ToHex(res), gas.String(), err
-}
-
-func (self *XEth) ConfirmTransaction(tx string) bool {
-	return self.frontend.ConfirmTransaction(tx)
-}
-
-func (self *XEth) doSign(from common.Address, hash common.Hash, didUnlock bool) ([]byte, error) {
-	sig, err := self.EthereumService().AccountManager().Sign(accounts.Account{Address: from}, hash.Bytes())
-	if err == accounts.ErrLocked {
-		if didUnlock {
-			return nil, fmt.Errorf("signer account still locked after successful unlock")
-		}
-		if !self.frontend.UnlockAccount(from.Bytes()) {
-			return nil, fmt.Errorf("could not unlock signer account")
-		}
-		// retry signing, the account should now be unlocked.
-		return self.doSign(from, hash, true)
-	} else if err != nil {
-		return nil, err
-	}
-	return sig, nil
-}
-
-func (self *XEth) Sign(fromStr, hashStr string, didUnlock bool) (string, error) {
-	var (
-		from = common.HexToAddress(fromStr)
-		hash = common.HexToHash(hashStr)
-	)
-	sig, err := self.doSign(from, hash, didUnlock)
-	if err != nil {
-		return "", err
-	}
-	return common.ToHex(sig), nil
-}
-
-func isAddress(addr string) bool {
-	return addrReg.MatchString(addr)
-}
-
-func (self *XEth) Frontend() Frontend {
-	return self.frontend
-}
-
-func (self *XEth) SignTransaction(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (*types.Transaction, error) {
-	if len(toStr) > 0 && toStr != "0x" && !isAddress(toStr) {
-		return nil, errors.New("Invalid address")
-	}
-
-	var (
-		from             = common.HexToAddress(fromStr)
-		to               = common.HexToAddress(toStr)
-		value            = common.Big(valueStr)
-		gas              *big.Int
-		price            *big.Int
-		data             []byte
-		contractCreation bool
-	)
-
-	if len(gasStr) == 0 {
-		gas = DefaultGas()
-	} else {
-		gas = common.Big(gasStr)
-	}
-
-	if len(gasPriceStr) == 0 {
-		price = self.DefaultGasPrice()
-	} else {
-		price = common.Big(gasPriceStr)
-	}
-
-	data = common.FromHex(codeStr)
-	if len(toStr) == 0 {
-		contractCreation = true
-	}
-
-	var nonce uint64
-	if len(nonceStr) != 0 {
-		nonce = common.Big(nonceStr).Uint64()
-	} else {
-		state := self.EthereumService().TxPool().State()
-		nonce = state.GetNonce(from)
-	}
-	var tx *types.Transaction
-	if contractCreation {
-		tx = types.NewContractCreation(nonce, value, gas, price, data)
-	} else {
-		tx = types.NewTransaction(nonce, to, value, gas, price, data)
-	}
-
-	signed, err := self.sign(tx, from, false)
-	if err != nil {
-		return nil, err
-	}
-
-	return signed, nil
-}
-
-func (self *XEth) Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
-
-	// this minimalistic recoding is enough (works for natspec.js)
-	var jsontx = fmt.Sprintf(`{"params":[{"to":"%s","data": "%s"}]}`, toStr, codeStr)
-	if !self.ConfirmTransaction(jsontx) {
-		err := fmt.Errorf("Transaction not confirmed")
-		return "", err
-	}
-
-	if len(toStr) > 0 && toStr != "0x" && !isAddress(toStr) {
-		return "", errors.New("Invalid address")
-	}
-
-	var (
-		from             = common.HexToAddress(fromStr)
-		to               = common.HexToAddress(toStr)
-		value            = common.Big(valueStr)
-		gas              *big.Int
-		price            *big.Int
-		data             []byte
-		contractCreation bool
-	)
-
-	if len(gasStr) == 0 {
-		gas = DefaultGas()
-	} else {
-		gas = common.Big(gasStr)
-	}
-
-	if len(gasPriceStr) == 0 {
-		price = self.DefaultGasPrice()
-	} else {
-		price = common.Big(gasPriceStr)
-	}
-
-	data = common.FromHex(codeStr)
-	if len(toStr) == 0 {
-		contractCreation = true
-	}
-
-	// 2015-05-18 Is this still needed?
-	// TODO if no_private_key then
-	//if _, exists := p.register[args.From]; exists {
-	//	p.register[args.From] = append(p.register[args.From], args)
-	//} else {
-	/*
-		account := accounts.Get(common.FromHex(args.From))
-		if account != nil {
-			if account.Unlocked() {
-				if !unlockAccount(account) {
-					return
-				}
-			}
-
-			result, _ := account.Transact(common.FromHex(args.To), common.FromHex(args.Value), common.FromHex(args.Gas), common.FromHex(args.GasPrice), common.FromHex(args.Data))
-			if len(result) > 0 {
-				*reply = common.ToHex(result)
-			}
-		} else if _, exists := p.register[args.From]; exists {
-			p.register[ags.From] = append(p.register[args.From], args)
-		}
-	*/
-
-	self.transactMu.Lock()
-	defer self.transactMu.Unlock()
-
-	var nonce uint64
-	if len(nonceStr) != 0 {
-		nonce = common.Big(nonceStr).Uint64()
-	} else {
-		state := self.EthereumService().TxPool().State()
-		nonce = state.GetNonce(from)
-	}
-	var tx *types.Transaction
-	if contractCreation {
-		tx = types.NewContractCreation(nonce, value, gas, price, data)
-	} else {
-		tx = types.NewTransaction(nonce, to, value, gas, price, data)
-	}
-
-	signed, err := self.sign(tx, from, false)
-	if err != nil {
-		return "", err
-	}
-	self.EthereumService().TxPool().SetLocal(signed)
-	if err = self.EthereumService().TxPool().Add(signed); err != nil {
-		return "", err
-	}
-
-	if contractCreation {
-		addr := crypto.CreateAddress(from, nonce)
-		glog.V(logger.Info).Infof("Tx(%s) created: %s\n", signed.Hash().Hex(), addr.Hex())
-	} else {
-		glog.V(logger.Info).Infof("Tx(%s) to: %s\n", signed.Hash().Hex(), tx.To().Hex())
-	}
-
-	return signed.Hash().Hex(), nil
-}
-
-func (self *XEth) sign(tx *types.Transaction, from common.Address, didUnlock bool) (*types.Transaction, error) {
-	hash := tx.SigHash()
-	sig, err := self.doSign(from, hash, didUnlock)
-	if err != nil {
-		return tx, err
-	}
-	return tx.WithSignature(sig)
-}
-
-// callmsg is the message type used for call transations.
-type callmsg struct {
-	from          *state.StateObject
-	to            *common.Address
-	gas, gasPrice *big.Int
-	value         *big.Int
-	data          []byte
-}
-
-// accessor boilerplate to implement core.Message
-func (m callmsg) From() (common.Address, error) { return m.from.Address(), nil }
-func (m callmsg) Nonce() uint64                 { return m.from.Nonce() }
-func (m callmsg) To() *common.Address           { return m.to }
-func (m callmsg) GasPrice() *big.Int            { return m.gasPrice }
-func (m callmsg) Gas() *big.Int                 { return m.gas }
-func (m callmsg) Value() *big.Int               { return m.value }
-func (m callmsg) Data() []byte                  { return m.data }
-
-type logQueue struct {
-	mu sync.Mutex
-
-	logs    vm.Logs
-	timeout time.Time
-	id      int
-}
-
-func (l *logQueue) add(logs ...*vm.Log) {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-
-	l.logs = append(l.logs, logs...)
-}
-
-func (l *logQueue) get() vm.Logs {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-
-	l.timeout = time.Now()
-	tmp := l.logs
-	l.logs = nil
-	return tmp
-}
-
-type hashQueue struct {
-	mu sync.Mutex
-
-	hashes  []common.Hash
-	timeout time.Time
-	id      int
-}
-
-func (l *hashQueue) add(hashes ...common.Hash) {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-
-	l.hashes = append(l.hashes, hashes...)
-}
-
-func (l *hashQueue) get() []common.Hash {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-
-	l.timeout = time.Now()
-	tmp := l.hashes
-	l.hashes = nil
-	return tmp
-}
diff --git a/xeth/xeth_test.go b/xeth/xeth_test.go
deleted file mode 100644
index e649d20ef..000000000
--- a/xeth/xeth_test.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package xeth
-
-import "testing"
-
-func TestIsAddress(t *testing.T) {
-	for _, invalid := range []string{
-		"0x00",
-		"0xNN",
-		"0x00000000000000000000000000000000000000NN",
-		"0xAAar000000000000000000000000000000000000",
-	} {
-		if isAddress(invalid) {
-			t.Error("Expected", invalid, "to be invalid")
-		}
-	}
-
-	for _, valid := range []string{
-		"0x0000000000000000000000000000000000000000",
-		"0xAABBbbCCccff9900000000000000000000000000",
-		"AABBbbCCccff9900000000000000000000000000",
-	} {
-		if !isAddress(valid) {
-			t.Error("Expected", valid, "to be valid")
-		}
-	}
-}