removed old rpc structure and added new inproc api client

1 files changed, 0 insertions, 646 deletions

diff --git a/rpc/api.go b/rpc/api.go
deleted file mode 100644
index a344a8294..000000000
--- a/rpc/api.go
+++ /dev/null
@@ -1,646 +0,0 @@
-package rpc
-
-import (
-	"bytes"
-	"encoding/json"
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/logger"
-	"github.com/ethereum/go-ethereum/logger/glog"
-	"github.com/ethereum/go-ethereum/xeth"
-)
-
-type EthereumApi struct {
-	eth *xeth.XEth
-}
-
-func NewEthereumApi(xeth *xeth.XEth) *EthereumApi {
-	api := &EthereumApi{
-		eth: xeth,
-	}
-
-	return api
-}
-
-func (api *EthereumApi) xeth() *xeth.XEth {
-	return api.eth
-}
-
-func (api *EthereumApi) xethAtStateNum(num int64) *xeth.XEth {
-	return api.xeth().AtStateNum(num)
-}
-
-func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error {
-	// Spec at https://github.com/ethereum/wiki/wiki/JSON-RPC
-	glog.V(logger.Debug).Infof("%s %s", req.Method, req.Params)
-
-	switch req.Method {
-	case "web3_sha3":
-		args := new(Sha3Args)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		*reply = common.ToHex(crypto.Sha3(common.FromHex(args.Data)))
-	case "web3_clientVersion":
-		*reply = api.xeth().ClientVersion()
-	case "net_version":
-		*reply = api.xeth().NetworkVersion()
-	case "net_listening":
-		*reply = api.xeth().IsListening()
-	case "net_peerCount":
-		*reply = newHexNum(api.xeth().PeerCount())
-	case "eth_protocolVersion":
-		*reply = api.xeth().EthVersion()
-	case "eth_coinbase":
-		*reply = newHexData(api.xeth().Coinbase())
-	case "eth_mining":
-		*reply = api.xeth().IsMining()
-	case "eth_gasPrice":
-		v := api.xeth().DefaultGasPrice()
-		*reply = newHexNum(v.Bytes())
-	case "eth_accounts":
-		*reply = api.xeth().Accounts()
-	case "eth_blockNumber":
-		v := api.xeth().CurrentBlock().Number()
-		*reply = newHexNum(v.Bytes())
-	case "eth_getBalance":
-		args := new(GetBalanceArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		*reply = api.xethAtStateNum(args.BlockNumber).BalanceAt(args.Address)
-		//v := api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address).Balance()
-		//*reply = common.ToHex(v.Bytes())
-	case "eth_getStorage", "eth_storageAt":
-		args := new(GetStorageArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		*reply = api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address).Storage()
-	case "eth_getStorageAt":
-		args := new(GetStorageAtArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		*reply = api.xethAtStateNum(args.BlockNumber).StorageAt(args.Address, args.Key)
-	case "eth_getTransactionCount":
-		args := new(GetTxCountArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		count := api.xethAtStateNum(args.BlockNumber).TxCountAt(args.Address)
-		*reply = newHexNum(big.NewInt(int64(count)).Bytes())
-	case "eth_getBlockTransactionCountByHash":
-		args := new(HashArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		block := NewBlockRes(api.xeth().EthBlockByHash(args.Hash), false)
-		if block == nil {
-			*reply = nil
-		} else {
-			*reply = newHexNum(big.NewInt(int64(len(block.Transactions))).Bytes())
-		}
-	case "eth_getBlockTransactionCountByNumber":
-		args := new(BlockNumArg)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		block := NewBlockRes(api.xeth().EthBlockByNumber(args.BlockNumber), false)
-		if block == nil {
-			*reply = nil
-			break
-		}
-
-		*reply = newHexNum(big.NewInt(int64(len(block.Transactions))).Bytes())
-	case "eth_getUncleCountByBlockHash":
-		args := new(HashArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		block := api.xeth().EthBlockByHash(args.Hash)
-		br := NewBlockRes(block, false)
-		if br == nil {
-			*reply = nil
-			break
-		}
-
-		*reply = newHexNum(big.NewInt(int64(len(br.Uncles))).Bytes())
-	case "eth_getUncleCountByBlockNumber":
-		args := new(BlockNumArg)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		block := api.xeth().EthBlockByNumber(args.BlockNumber)
-		br := NewBlockRes(block, false)
-		if br == nil {
-			*reply = nil
-			break
-		}
-
-		*reply = newHexNum(big.NewInt(int64(len(br.Uncles))).Bytes())
-
-	case "eth_getData", "eth_getCode":
-		args := new(GetDataArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		v := api.xethAtStateNum(args.BlockNumber).CodeAtBytes(args.Address)
-		*reply = newHexData(v)
-
-	case "eth_sign":
-		args := new(NewSigArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		v, err := api.xeth().Sign(args.From, args.Data, false)
-		if err != nil {
-			return err
-		}
-		*reply = v
-
-	case "eth_sendRawTransaction":
-		args := new(NewDataArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		v, err := api.xeth().PushTx(args.Data)
-		if err != nil {
-			return err
-		}
-		*reply = v
-
-	case "eth_sendTransaction", "eth_transact":
-		args := new(NewTxArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		// nonce may be nil ("guess" mode)
-		var nonce string
-		if args.Nonce != nil {
-			nonce = args.Nonce.String()
-		}
-
-		var gas string
-		if args.Gas == nil {
-			gas = ""
-		} else {
-			gas = args.Gas.String()
-		}
-
-		var gasprice string
-		if args.GasPrice == nil {
-			gasprice = ""
-		} else {
-			gasprice = args.GasPrice.String()
-		}
-
-		v, err := api.xeth().Transact(args.From, args.To, nonce, args.Value.String(), gas, gasprice, args.Data)
-		if err != nil {
-			return err
-		}
-		*reply = v
-	case "eth_estimateGas":
-		_, gas, err := api.doCall(req.Params)
-		if err != nil {
-			return err
-		}
-
-		// TODO unwrap the parent method's ToHex call
-		if len(gas) == 0 {
-			*reply = newHexNum(0)
-		} else {
-			*reply = newHexNum(gas)
-		}
-	case "eth_call":
-		v, _, err := api.doCall(req.Params)
-		if err != nil {
-			return err
-		}
-
-		// TODO unwrap the parent method's ToHex call
-		if v == "0x0" {
-			*reply = newHexData([]byte{})
-		} else {
-			*reply = newHexData(common.FromHex(v))
-		}
-	case "eth_flush":
-		return NewNotImplementedError(req.Method)
-	case "eth_getBlockByHash":
-		args := new(GetBlockByHashArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		block := api.xeth().EthBlockByHash(args.BlockHash)
-		br := NewBlockRes(block, args.IncludeTxs)
-
-		*reply = br
-	case "eth_getBlockByNumber":
-		args := new(GetBlockByNumberArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		block := api.xeth().EthBlockByNumber(args.BlockNumber)
-		br := NewBlockRes(block, args.IncludeTxs)
-		// If request was for "pending", nil nonsensical fields
-		if args.BlockNumber == -2 {
-			br.BlockHash = nil
-			br.BlockNumber = nil
-			br.Miner = nil
-			br.Nonce = nil
-			br.LogsBloom = nil
-		}
-		*reply = br
-	case "eth_getTransactionByHash":
-		args := new(HashArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		tx, bhash, bnum, txi := api.xeth().EthTransactionByHash(args.Hash)
-		if tx != nil {
-			v := NewTransactionRes(tx)
-			// if the blockhash is 0, assume this is a pending transaction
-			if bytes.Compare(bhash.Bytes(), bytes.Repeat([]byte{0}, 32)) != 0 {
-				v.BlockHash = newHexData(bhash)
-				v.BlockNumber = newHexNum(bnum)
-				v.TxIndex = newHexNum(txi)
-			}
-			*reply = v
-		}
-	case "eth_getTransactionByBlockHashAndIndex":
-		args := new(HashIndexArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		block := api.xeth().EthBlockByHash(args.Hash)
-		br := NewBlockRes(block, true)
-		if br == nil {
-			*reply = nil
-			break
-		}
-
-		if args.Index >= int64(len(br.Transactions)) || args.Index < 0 {
-			// return NewValidationError("Index", "does not exist")
-			*reply = nil
-		} else {
-			*reply = br.Transactions[args.Index]
-		}
-	case "eth_getTransactionByBlockNumberAndIndex":
-		args := new(BlockNumIndexArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		block := api.xeth().EthBlockByNumber(args.BlockNumber)
-		v := NewBlockRes(block, true)
-		if v == nil {
-			*reply = nil
-			break
-		}
-
-		if args.Index >= int64(len(v.Transactions)) || args.Index < 0 {
-			// return NewValidationError("Index", "does not exist")
-			*reply = nil
-		} else {
-			*reply = v.Transactions[args.Index]
-		}
-	case "eth_getUncleByBlockHashAndIndex":
-		args := new(HashIndexArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		br := NewBlockRes(api.xeth().EthBlockByHash(args.Hash), false)
-		if br == nil {
-			*reply = nil
-			return nil
-		}
-
-		if args.Index >= int64(len(br.Uncles)) || args.Index < 0 {
-			// return NewValidationError("Index", "does not exist")
-			*reply = nil
-		} else {
-			*reply = br.Uncles[args.Index]
-		}
-	case "eth_getUncleByBlockNumberAndIndex":
-		args := new(BlockNumIndexArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		block := api.xeth().EthBlockByNumber(args.BlockNumber)
-		v := NewBlockRes(block, true)
-
-		if v == nil {
-			*reply = nil
-			return nil
-		}
-
-		if args.Index >= int64(len(v.Uncles)) || args.Index < 0 {
-			// return NewValidationError("Index", "does not exist")
-			*reply = nil
-		} else {
-			*reply = v.Uncles[args.Index]
-		}
-
-	case "eth_getCompilers":
-		var lang string
-		if solc, _ := api.xeth().Solc(); solc != nil {
-			lang = "Solidity"
-		}
-		c := []string{lang}
-		*reply = c
-
-	case "eth_compileLLL", "eth_compileSerpent":
-		return NewNotImplementedError(req.Method)
-
-	case "eth_compileSolidity":
-		solc, _ := api.xeth().Solc()
-		if solc == nil {
-			return NewNotAvailableError(req.Method, "solc (solidity compiler) not found")
-		}
-
-		args := new(SourceArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		contracts, err := solc.Compile(args.Source)
-		if err != nil {
-			return err
-		}
-		*reply = contracts
-
-	case "eth_newFilter":
-		args := new(BlockFilterArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		id := api.xeth().NewLogFilter(args.Earliest, args.Latest, args.Skip, args.Max, args.Address, args.Topics)
-		*reply = newHexNum(big.NewInt(int64(id)).Bytes())
-
-	case "eth_newBlockFilter":
-		*reply = newHexNum(api.xeth().NewBlockFilter())
-	case "eth_newPendingTransactionFilter":
-		*reply = newHexNum(api.xeth().NewTransactionFilter())
-	case "eth_uninstallFilter":
-		args := new(FilterIdArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		*reply = api.xeth().UninstallFilter(args.Id)
-	case "eth_getFilterChanges":
-		args := new(FilterIdArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		switch api.xeth().GetFilterType(args.Id) {
-		case xeth.BlockFilterTy:
-			*reply = NewHashesRes(api.xeth().BlockFilterChanged(args.Id))
-		case xeth.TransactionFilterTy:
-			*reply = NewHashesRes(api.xeth().TransactionFilterChanged(args.Id))
-		case xeth.LogFilterTy:
-			*reply = NewLogsRes(api.xeth().LogFilterChanged(args.Id))
-		default:
-			*reply = []string{} // reply empty string slice
-		}
-	case "eth_getFilterLogs":
-		args := new(FilterIdArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		*reply = NewLogsRes(api.xeth().Logs(args.Id))
-	case "eth_getLogs":
-		args := new(BlockFilterArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		*reply = NewLogsRes(api.xeth().AllLogs(args.Earliest, args.Latest, args.Skip, args.Max, args.Address, args.Topics))
-	case "eth_getWork":
-		api.xeth().SetMining(true, 0)
-		*reply = api.xeth().RemoteMining().GetWork()
-	case "eth_submitWork":
-		args := new(SubmitWorkArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		*reply = api.xeth().RemoteMining().SubmitWork(args.Nonce, common.HexToHash(args.Digest), common.HexToHash(args.Header))
-	case "db_putString":
-		args := new(DbArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		if err := args.requirements(); err != nil {
-			return err
-		}
-
-		api.xeth().DbPut([]byte(args.Database+args.Key), args.Value)
-
-		*reply = true
-	case "db_getString":
-		args := new(DbArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		if err := args.requirements(); err != nil {
-			return err
-		}
-
-		res, _ := api.xeth().DbGet([]byte(args.Database + args.Key))
-		*reply = string(res)
-	case "db_putHex":
-		args := new(DbHexArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		if err := args.requirements(); err != nil {
-			return err
-		}
-
-		api.xeth().DbPut([]byte(args.Database+args.Key), args.Value)
-		*reply = true
-	case "db_getHex":
-		args := new(DbHexArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		if err := args.requirements(); err != nil {
-			return err
-		}
-
-		res, _ := api.xeth().DbGet([]byte(args.Database + args.Key))
-		*reply = newHexData(res)
-
-	case "shh_version":
-		// Short circuit if whisper is not running
-		if api.xeth().Whisper() == nil {
-			return NewNotAvailableError(req.Method, "whisper offline")
-		}
-		// Retrieves the currently running whisper protocol version
-		*reply = api.xeth().WhisperVersion()
-
-	case "shh_post":
-		// Short circuit if whisper is not running
-		if api.xeth().Whisper() == nil {
-			return NewNotAvailableError(req.Method, "whisper offline")
-		}
-		// Injects a new message into the whisper network
-		args := new(WhisperMessageArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		err := api.xeth().Whisper().Post(args.Payload, args.To, args.From, args.Topics, args.Priority, args.Ttl)
-		if err != nil {
-			return err
-		}
-		*reply = true
-
-	case "shh_newIdentity":
-		// Short circuit if whisper is not running
-		if api.xeth().Whisper() == nil {
-			return NewNotAvailableError(req.Method, "whisper offline")
-		}
-		// Creates a new whisper identity to use for sending/receiving messages
-		*reply = api.xeth().Whisper().NewIdentity()
-
-	case "shh_hasIdentity":
-		// Short circuit if whisper is not running
-		if api.xeth().Whisper() == nil {
-			return NewNotAvailableError(req.Method, "whisper offline")
-		}
-		// Checks if an identity if owned or not
-		args := new(WhisperIdentityArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		*reply = api.xeth().Whisper().HasIdentity(args.Identity)
-
-	case "shh_newFilter":
-		// Short circuit if whisper is not running
-		if api.xeth().Whisper() == nil {
-			return NewNotAvailableError(req.Method, "whisper offline")
-		}
-		// Create a new filter to watch and match messages with
-		args := new(WhisperFilterArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		id := api.xeth().NewWhisperFilter(args.To, args.From, args.Topics)
-		*reply = newHexNum(big.NewInt(int64(id)).Bytes())
-
-	case "shh_uninstallFilter":
-		// Short circuit if whisper is not running
-		if api.xeth().Whisper() == nil {
-			return NewNotAvailableError(req.Method, "whisper offline")
-		}
-		// Remove an existing filter watching messages
-		args := new(FilterIdArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		*reply = api.xeth().UninstallWhisperFilter(args.Id)
-
-	case "shh_getFilterChanges":
-		// Short circuit if whisper is not running
-		if api.xeth().Whisper() == nil {
-			return NewNotAvailableError(req.Method, "whisper offline")
-		}
-		// Retrieve all the new messages arrived since the last request
-		args := new(FilterIdArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		*reply = api.xeth().WhisperMessagesChanged(args.Id)
-
-	case "shh_getMessages":
-		// Short circuit if whisper is not running
-		if api.xeth().Whisper() == nil {
-			return NewNotAvailableError(req.Method, "whisper offline")
-		}
-		// Retrieve all the cached messages matching a specific, existing filter
-		args := new(FilterIdArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		*reply = api.xeth().WhisperMessages(args.Id)
-
-	case "eth_hashrate":
-		*reply = newHexNum(api.xeth().HashRate())
-	case "ext_disasm":
-		args := new(SourceArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-
-		*reply = vm.Disasm(common.FromHex(args.Source))
-
-	// case "eth_register":
-	// 	// Placeholder for actual type
-	// 	args := new(HashIndexArgs)
-	// 	if err := json.Unmarshal(req.Params, &args); err != nil {
-	// 		return err
-	// 	}
-	// 	*reply = api.xeth().Register(args.Hash)
-	// case "eth_unregister":
-	// 	args := new(HashIndexArgs)
-	// 	if err := json.Unmarshal(req.Params, &args); err != nil {
-	// 		return err
-	// 	}
-	// 	*reply = api.xeth().Unregister(args.Hash)
-	// case "eth_watchTx":
-	// 	args := new(HashIndexArgs)
-	// 	if err := json.Unmarshal(req.Params, &args); err != nil {
-	// 		return err
-	// 	}
-	// 	*reply = api.xeth().PullWatchTx(args.Hash)
-	default:
-		return NewNotImplementedError(req.Method)
-	}
-
-	// glog.V(logger.Detail).Infof("Reply: %v\n", reply)
-	return nil
-}
-
-func (api *EthereumApi) doCall(params json.RawMessage) (string, string, error) {
-	args := new(CallArgs)
-	if err := json.Unmarshal(params, &args); err != nil {
-		return "", "", err
-	}
-
-	var gas string
-	if args.Gas == nil {
-		gas = ""
-	} else {
-		gas = args.Gas.String()
-	}
-
-	var gasprice string
-	if args.GasPrice == nil {
-		gasprice = ""
-	} else {
-		gasprice = args.GasPrice.String()
-	}
-
-	return api.xethAtStateNum(args.BlockNumber).Call(args.From, args.To, args.Value.String(), gas, gasprice, args.Data)
-}