aboutsummaryrefslogtreecommitdiffstats
path: root/eth
diff options
context:
space:
mode:
authorBas van Kervel <bas@ethdev.com>2015-10-15 22:07:19 +0800
committerBas van Kervel <bas@ethdev.com>2015-12-14 23:34:05 +0800
commiteae81465c1c815c317cd30e4de6bdf4d59df2340 (patch)
treeb6f4b7787967a58416171adb79fd12ac29d89577 /eth
parent8db9d44ca9fb6baf406256cae491c475de2f4989 (diff)
downloaddexon-eae81465c1c815c317cd30e4de6bdf4d59df2340.tar
dexon-eae81465c1c815c317cd30e4de6bdf4d59df2340.tar.gz
dexon-eae81465c1c815c317cd30e4de6bdf4d59df2340.tar.bz2
dexon-eae81465c1c815c317cd30e4de6bdf4d59df2340.tar.lz
dexon-eae81465c1c815c317cd30e4de6bdf4d59df2340.tar.xz
dexon-eae81465c1c815c317cd30e4de6bdf4d59df2340.tar.zst
dexon-eae81465c1c815c317cd30e4de6bdf4d59df2340.zip
rpc: new RPC implementation with pub/sub support
Diffstat (limited to 'eth')
-rw-r--r--eth/api.go1216
-rw-r--r--eth/backend.go60
-rw-r--r--eth/downloader/api.go64
-rw-r--r--eth/filters/api.go575
4 files changed, 1915 insertions, 0 deletions
diff --git a/eth/api.go b/eth/api.go
new file mode 100644
index 000000000..06fc2deb1
--- /dev/null
+++ b/eth/api.go
@@ -0,0 +1,1216 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package eth
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "math/big"
+ "sync"
+ "time"
+
+ "gopkg.in/fatih/set.v0"
+
+ "github.com/ethereum/ethash"
+ "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/ethdb"
+ "github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/logger"
+ "github.com/ethereum/go-ethereum/logger/glog"
+ "github.com/ethereum/go-ethereum/rlp"
+ rpc "github.com/ethereum/go-ethereum/rpc/v2"
+)
+
+const (
+ defaultGasPrice = uint64(10000000000000)
+ defaultGas = uint64(90000)
+)
+
+// PublicEthereumAPI provides an API to access Ethereum related information.
+// It offers only methods that operate on public data that is freely available to anyone.
+type PublicEthereumAPI struct {
+ e *Ethereum
+ gpo *GasPriceOracle
+}
+
+// NewPublicEthereumAPI creates a new Etheruem protocol API.
+func NewPublicEthereumAPI(e *Ethereum) *PublicEthereumAPI {
+ return &PublicEthereumAPI{e, NewGasPriceOracle(e)}
+}
+
+// GasPrice returns a suggestion for a gas price.
+func (s *PublicEthereumAPI) GasPrice() *big.Int {
+ return s.gpo.SuggestPrice()
+}
+
+// GetCompilers returns the collection of available smart contract compilers
+func (s *PublicEthereumAPI) GetCompilers() ([]string, error) {
+ solc, err := s.e.Solc()
+ if err != nil {
+ return nil, err
+ }
+
+ if solc != nil {
+ return []string{"Solidity"}, nil
+ }
+
+ return []string{}, nil
+}
+
+// CompileSolidity compiles the given solidity source
+func (s *PublicEthereumAPI) CompileSolidity(source string) (map[string]*compiler.Contract, error) {
+ solc, err := s.e.Solc()
+ if err != nil {
+ return nil, err
+ }
+
+ if solc == nil {
+ return nil, errors.New("solc (solidity compiler) not found")
+ }
+
+ return solc.Compile(source)
+}
+
+// Etherbase is the address that mining rewards will be send to
+func (s *PublicEthereumAPI) Etherbase() (common.Address, error) {
+ return s.e.Etherbase()
+}
+
+// see Etherbase
+func (s *PublicEthereumAPI) Coinbase() (common.Address, error) {
+ return s.Etherbase()
+}
+
+// ProtocolVersion returns the current Ethereum protocol version this node supports
+func (s *PublicEthereumAPI) ProtocolVersion() *rpc.HexNumber {
+ return rpc.NewHexNumber(s.e.EthVersion())
+}
+
+// Hashrate returns the POW hashrate
+func (s *PublicEthereumAPI) Hashrate() *rpc.HexNumber {
+ return rpc.NewHexNumber(s.e.Miner().HashRate())
+}
+
+// Syncing returns false in case the node is currently not synching with the network. It can be up to date or has not
+// yet received the latest block headers from its pears. In case it is synchronizing an object with 3 properties is
+// returned:
+// - startingBlock: block number this node started to synchronise from
+// - currentBlock: block number this node is currently importing
+// - highestBlock: block number of the highest block header this node has received from peers
+func (s *PublicEthereumAPI) Syncing() (interface{}, error) {
+ origin, current, height := s.e.Downloader().Progress()
+ if current < height {
+ return map[string]interface{}{
+ "startingBlock": rpc.NewHexNumber(origin),
+ "currentBlock": rpc.NewHexNumber(current),
+ "highestBlock": rpc.NewHexNumber(height),
+ }, nil
+ }
+ return false, nil
+}
+
+// PrivateMinerAPI provides private RPC methods to control the miner.
+// These methods can be abused by external users and must be considered insecure for use by untrusted users.
+type PrivateMinerAPI struct {
+ e *Ethereum
+}
+
+// NewPrivateMinerAPI create a new RPC service which controls the miner of this node.
+func NewPrivateMinerAPI(e *Ethereum) *PrivateMinerAPI {
+ return &PrivateMinerAPI{e: e}
+}
+
+// Start the miner with the given number of threads
+func (s *PrivateMinerAPI) Start(threads rpc.HexNumber) (bool, error) {
+ s.e.StartAutoDAG()
+ err := s.e.StartMining(threads.Int(), "")
+ if err == nil {
+ return true, nil
+ }
+ return false, err
+}
+
+// Stop the miner
+func (s *PrivateMinerAPI) Stop() bool {
+ s.e.StopMining()
+ return true
+}
+
+// SetExtra sets the extra data string that is included when this miner mines a block.
+func (s *PrivateMinerAPI) SetExtra(extra string) (bool, error) {
+ if err := s.e.Miner().SetExtra([]byte(extra)); err != nil {
+ return false, err
+ }
+ return true, nil
+}
+
+// SetGasPrice sets the minimum accepted gas price for the miner.
+func (s *PrivateMinerAPI) SetGasPrice(gasPrice rpc.Number) bool {
+ s.e.Miner().SetGasPrice(gasPrice.BigInt())
+ return true
+}
+
+// SetEtherbase sets the etherbase of the miner
+func (s *PrivateMinerAPI) SetEtherbase(etherbase common.Address) bool {
+ s.e.SetEtherbase(etherbase)
+ return true
+}
+
+// StartAutoDAG starts auto DAG generation. This will prevent the DAG generating on epoch change
+// which will cause the node to stop mining during the generation process.
+func (s *PrivateMinerAPI) StartAutoDAG() bool {
+ s.e.StartAutoDAG()
+ return true
+}
+
+// StopAutoDAG stops auto DAG generation
+func (s *PrivateMinerAPI) StopAutoDAG() bool {
+ s.e.StopAutoDAG()
+ return true
+}
+
+// MakeDAG creates the new DAG for the given block number
+func (s *PrivateMinerAPI) MakeDAG(blockNr rpc.BlockNumber) (bool, error) {
+ if err := ethash.MakeDAG(uint64(blockNr.Int64()), ""); err != nil {
+ return false, err
+ }
+ return true, nil
+}
+
+// PublicTxPoolAPI offers and API for the transaction pool. It only operates on data that is non confidential.
+type PublicTxPoolAPI struct {
+ e *Ethereum
+}
+
+// NewPublicTxPoolAPI creates a new tx pool service that gives information about the transaction pool.
+func NewPublicTxPoolAPI(e *Ethereum) *PublicTxPoolAPI {
+ return &PublicTxPoolAPI{e}
+}
+
+// Status returns the number of pending and queued transaction in the pool.
+func (s *PublicTxPoolAPI) Status() map[string]*rpc.HexNumber {
+ pending, queue := s.e.TxPool().Stats()
+ return map[string]*rpc.HexNumber{
+ "pending": rpc.NewHexNumber(pending),
+ "queued": rpc.NewHexNumber(queue),
+ }
+}
+
+// PublicAccountAPI provides an API to access accounts managed by this node.
+// It offers only methods that can retrieve accounts.
+type PublicAccountAPI struct {
+ am *accounts.Manager
+}
+
+// NewPublicAccountAPI creates a new PublicAccountAPI.
+func NewPublicAccountAPI(am *accounts.Manager) *PublicAccountAPI {
+ return &PublicAccountAPI{am: am}
+}
+
+// Accounts returns the collection of accounts this node manages
+func (s *PublicAccountAPI) Accounts() ([]accounts.Account, error) {
+ return s.am.Accounts()
+}
+
+// PrivateAccountAPI provides an API to access accounts managed by this node.
+// It offers methods to create, (un)lock en list accounts.
+type PrivateAccountAPI struct {
+ am *accounts.Manager
+}
+
+// NewPrivateAccountAPI create a new PrivateAccountAPI.
+func NewPrivateAccountAPI(am *accounts.Manager) *PrivateAccountAPI {
+ return &PrivateAccountAPI{am}
+}
+
+// ListAccounts will return a list of addresses for accounts this node manages.
+func (s *PrivateAccountAPI) ListAccounts() ([]common.Address, error) {
+ accounts, err := s.am.Accounts()
+ if err != nil {
+ return nil, err
+ }
+
+ addresses := make([]common.Address, len(accounts))
+ for i, acc := range accounts {
+ addresses[i] = acc.Address
+ }
+ return addresses, nil
+}
+
+// NewAccount will create a new account and returns the address for the new account.
+func (s *PrivateAccountAPI) NewAccount(password string) (common.Address, error) {
+ acc, err := s.am.NewAccount(password)
+ if err == nil {
+ return acc.Address, nil
+ }
+ return common.Address{}, err
+}
+
+// UnlockAccount will unlock the account associated with the given address with the given password for duration seconds.
+// It returns an indication if the action was successful.
+func (s *PrivateAccountAPI) UnlockAccount(addr common.Address, password string, duration int) bool {
+ if err := s.am.TimedUnlock(addr, password, time.Duration(duration)*time.Second); err != nil {
+ glog.V(logger.Info).Infof("%v\n", err)
+ return false
+ }
+ return true
+}
+
+// LockAccount will lock the account associated with the given address when it's unlocked.
+func (s *PrivateAccountAPI) LockAccount(addr common.Address) bool {
+ return s.am.Lock(addr) == nil
+}
+
+// PublicBlockChainAPI provides an API to access the Ethereum blockchain.
+// It offers only methods that operate on public data that is freely available to anyone.
+type PublicBlockChainAPI struct {
+ bc *core.BlockChain
+ chainDb ethdb.Database
+ eventMux *event.TypeMux
+ am *accounts.Manager
+}
+
+// NewPublicBlockChainAPI creates a new Etheruem blockchain API.
+func NewPublicBlockChainAPI(bc *core.BlockChain, chainDb ethdb.Database, eventMux *event.TypeMux, am *accounts.Manager) *PublicBlockChainAPI {
+ return &PublicBlockChainAPI{bc: bc, chainDb: chainDb, eventMux: eventMux, am: am}
+}
+
+// BlockNumber returns the block number of the chain head.
+func (s *PublicBlockChainAPI) BlockNumber() *big.Int {
+ return s.bc.CurrentHeader().Number
+}
+
+// GetBalance returns the amount of wei for the given address in the state of the given block number.
+// When block number equals rpc.LatestBlockNumber the current block is used.
+func (s *PublicBlockChainAPI) GetBalance(address common.Address, blockNr rpc.BlockNumber) (*big.Int, error) {
+ block := blockByNumber(s.bc, blockNr)
+ if block == nil {
+ return nil, nil
+ }
+
+ state, err := state.New(block.Root(), s.chainDb)
+ if err != nil {
+ return nil, err
+ }
+ return state.GetBalance(address), nil
+}
+
+// blockByNumber is a commonly used helper function which retrieves and returns the block for the given block number. It
+// returns nil when no block could be found.
+func blockByNumber(bc *core.BlockChain, blockNr rpc.BlockNumber) *types.Block {
+ if blockNr == rpc.LatestBlockNumber {
+ return bc.CurrentBlock()
+ }
+
+ return bc.GetBlockByNumber(uint64(blockNr))
+}
+
+// GetBlockByNumber returns the requested block. When blockNr is -1 the chain head is returned. When fullTx is true all
+// transactions in the block are returned in full detail, otherwise only the transaction hash is returned.
+func (s *PublicBlockChainAPI) GetBlockByNumber(blockNr rpc.BlockNumber, fullTx bool) (map[string]interface{}, error) {
+ if block := blockByNumber(s.bc, blockNr); block != nil {
+ return s.rpcOutputBlock(block, true, fullTx)
+ }
+ return nil, nil
+}
+
+// GetBlockByHash returns the requested block. When fullTx is true all transactions in the block are returned in full
+// detail, otherwise only the transaction hash is returned.
+func (s *PublicBlockChainAPI) GetBlockByHash(blockHash common.Hash, fullTx bool) (map[string]interface{}, error) {
+ if block := s.bc.GetBlock(blockHash); block != nil {
+ return s.rpcOutputBlock(block, true, fullTx)
+ }
+ return nil, nil
+}
+
+// GetUncleByBlockNumberAndIndex returns the uncle block for the given block hash and index. When fullTx is true
+// all transactions in the block are returned in full detail, otherwise only the transaction hash is returned.
+func (s *PublicBlockChainAPI) GetUncleByBlockNumberAndIndex(blockNr rpc.BlockNumber, index rpc.HexNumber) (map[string]interface{}, error) {
+ if blockNr == rpc.PendingBlockNumber {
+ return nil, nil
+ }
+
+ if block := blockByNumber(s.bc, blockNr); block != nil {
+ uncles := block.Uncles()
+ if index.Int() < 0 || index.Int() >= len(uncles) {
+ glog.V(logger.Debug).Infof("uncle block on index %d not found for block #%d", index.Int(), blockNr)
+ return nil, nil
+ }
+ block = types.NewBlockWithHeader(uncles[index.Int()])
+ return s.rpcOutputBlock(block, false, false)
+ }
+ return nil, nil
+}
+
+// GetUncleByBlockHashAndIndex returns the uncle block for the given block hash and index. When fullTx is true
+// all transactions in the block are returned in full detail, otherwise only the transaction hash is returned.
+func (s *PublicBlockChainAPI) GetUncleByBlockHashAndIndex(blockHash common.Hash, index rpc.HexNumber) (map[string]interface{}, error) {
+ if block := s.bc.GetBlock(blockHash); block != nil {
+ uncles := block.Uncles()
+ if index.Int() < 0 || index.Int() >= len(uncles) {
+ glog.V(logger.Debug).Infof("uncle block on index %d not found for block %s", index.Int(), blockHash.Hex())
+ return nil, nil
+ }
+ block = types.NewBlockWithHeader(uncles[index.Int()])
+ return s.rpcOutputBlock(block, false, false)
+ }
+ return nil, nil
+}
+
+// GetUncleCountByBlockNumber returns number of uncles in the block for the given block number
+func (s *PublicBlockChainAPI) GetUncleCountByBlockNumber(blockNr rpc.BlockNumber) *rpc.HexNumber {
+ if blockNr == rpc.PendingBlockNumber {
+ return rpc.NewHexNumber(0)
+ }
+
+ if block := blockByNumber(s.bc, blockNr); block != nil {
+ return rpc.NewHexNumber(len(block.Uncles()))
+ }
+ return nil
+}
+
+// GetUncleCountByBlockHash returns number of uncles in the block for the given block hash
+func (s *PublicBlockChainAPI) GetUncleCountByBlockHash(blockHash common.Hash) *rpc.HexNumber {
+ if block := s.bc.GetBlock(blockHash); block != nil {
+ return rpc.NewHexNumber(len(block.Uncles()))
+ }
+ return nil
+}
+
+// NewBlocksArgs allows the user to specify if the returned block should include transactions and in which format.
+type NewBlocksArgs struct {
+ IncludeTransactions bool `json:"includeTransactions"`
+ TransactionDetails bool `json:"transactionDetails"`
+}
+
+// NewBlocks triggers a new block event each time a block is appended to the chain. It accepts an argument which allows
+// the caller to specify whether the output should contain transactions and in what format.
+func (s *PublicBlockChainAPI) NewBlocks(args NewBlocksArgs) (rpc.Subscription, error) {
+ sub := s.eventMux.Subscribe(core.ChainEvent{})
+
+ output := func(rawBlock interface{}) interface{} {
+ if event, ok := rawBlock.(core.ChainEvent); ok {
+ notification, err := s.rpcOutputBlock(event.Block, args.IncludeTransactions, args.TransactionDetails)
+ if err == nil {
+ return notification
+ }
+ }
+ return rawBlock
+ }
+
+ return rpc.NewSubscriptionWithOutputFormat(sub, output), nil
+}
+
+// GetCode returns the code stored at the given address in the state for the given block number.
+func (s *PublicBlockChainAPI) GetCode(address common.Address, blockNr rpc.BlockNumber) (string, error) {
+ return s.GetData(address, blockNr)
+}
+
+// GetData returns the data stored at the given address in the state for the given block number.
+func (s *PublicBlockChainAPI) GetData(address common.Address, blockNr rpc.BlockNumber) (string, error) {
+ if block := blockByNumber(s.bc, blockNr); block != nil {
+ state, err := state.New(block.Root(), s.chainDb)
+ if err != nil {
+ return "", err
+ }
+ res := state.GetCode(address)
+ if len(res) == 0 { // backwards compatibility
+ return "0x", nil
+ }
+ return common.ToHex(res), nil
+ }
+
+ return "0x", nil
+}
+
+// GetStorageAt returns the storage from the state at the given address, key and block number.
+func (s *PublicBlockChainAPI) GetStorageAt(address common.Address, key string, blockNr rpc.BlockNumber) (string, error) {
+ if block := blockByNumber(s.bc, blockNr); block != nil {
+ state, err := state.New(block.Root(), s.chainDb)
+ if err != nil {
+ return "", err
+ }
+
+ return state.GetState(address, common.HexToHash(key)).Hex(), nil
+ }
+
+ return "0x", nil
+}
+
+// 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 CallArgs struct {
+ From common.Address `json:"from"`
+ To common.Address `json:"to"`
+ Gas rpc.HexNumber `json:"gas"`
+ GasPrice rpc.HexNumber `json:"gasPrice"`
+ Value rpc.HexNumber `json:"value"`
+ Data string `json:"data"`
+}
+
+func (s *PublicBlockChainAPI) doCall(args CallArgs, blockNr rpc.BlockNumber) (string, *big.Int, error) {
+ if block := blockByNumber(s.bc, blockNr); block != nil {
+ stateDb, err := state.New(block.Root(), s.chainDb)
+ if err != nil {
+ return "0x", nil, err
+ }
+
+ stateDb = stateDb.Copy()
+ var from *state.StateObject
+ if args.From == (common.Address{}) {
+ accounts, err := s.am.Accounts()
+ if err != nil || len(accounts) == 0 {
+ from = stateDb.GetOrNewStateObject(common.Address{})
+ } else {
+ from = stateDb.GetOrNewStateObject(accounts[0].Address)
+ }
+ } else {
+ from = stateDb.GetOrNewStateObject(args.From)
+ }
+
+ from.SetBalance(common.MaxBig)
+
+ msg := callmsg{
+ from: from,
+ to: &args.To,
+ gas: args.Gas.BigInt(),
+ gasPrice: args.GasPrice.BigInt(),
+ value: args.Value.BigInt(),
+ data: common.FromHex(args.Data),
+ }
+
+ if msg.gas.Cmp(common.Big0) == 0 {
+ msg.gas = big.NewInt(50000000)
+ }
+
+ if msg.gasPrice.Cmp(common.Big0) == 0 {
+ msg.gasPrice = new(big.Int).Mul(big.NewInt(50), common.Shannon)
+ }
+
+ header := s.bc.CurrentBlock().Header()
+ vmenv := core.NewEnv(stateDb, s.bc, msg, header)
+ gp := new(core.GasPool).AddGas(common.MaxBig)
+ res, gas, err := core.ApplyMessage(vmenv, msg, gp)
+ if len(res) == 0 { // backwards compatability
+ return "0x", gas, err
+ }
+ return common.ToHex(res), gas, err
+ }
+
+ return "0x", common.Big0, nil
+}
+
+// Call executes the given transaction on the state for the given block number.
+// It doesn't make and changes in the state/blockchain and is usefull to execute and retrieve values.
+func (s *PublicBlockChainAPI) Call(args CallArgs, blockNr rpc.BlockNumber) (string, error) {
+ result, _, err := s.doCall(args, blockNr)
+ return result, err
+}
+
+// EstimateGas returns an estimate of the amount of gas needed to execute the given transaction.
+func (s *PublicBlockChainAPI) EstimateGas(args CallArgs) (*rpc.HexNumber, error) {
+ _, gas, err := s.doCall(args, rpc.LatestBlockNumber)
+ return rpc.NewHexNumber(gas), err
+}
+
+// rpcOutputBlock converts the given block to the RPC output which depends on fullTx. If inclTx is true transactions are
+// returned. When fullTx is true the returned block contains full transaction details, otherwise it will only contain
+// transaction hashes.
+func (s *PublicBlockChainAPI) rpcOutputBlock(b *types.Block, inclTx bool, fullTx bool) (map[string]interface{}, error) {
+ fields := map[string]interface{}{
+ "number": rpc.NewHexNumber(b.Number()),
+ "hash": b.Hash(),
+ "parentHash": b.ParentHash(),
+ "nonce": b.Header().Nonce,
+ "sha3Uncles": b.UncleHash(),
+ "logsBloom": b.Bloom(),
+ "stateRoot": b.Root(),
+ "miner": b.Coinbase(),
+ "difficulty": rpc.NewHexNumber(b.Difficulty()),
+ "totalDifficulty": rpc.NewHexNumber(s.bc.GetTd(b.Hash())),
+ "extraData": fmt.Sprintf("0x%x", b.Extra()),
+ "size": rpc.NewHexNumber(b.Size().Int64()),
+ "gasLimit": rpc.NewHexNumber(b.GasLimit()),
+ "gasUsed": rpc.NewHexNumber(b.GasUsed()),
+ "timestamp": rpc.NewHexNumber(b.Time()),
+ "transactionsRoot": b.TxHash(),
+ "receiptRoot": b.ReceiptHash(),
+ }
+
+ if inclTx {
+ formatTx := func(tx *types.Transaction) (interface{}, error) {
+ return tx.Hash(), nil
+ }
+
+ if fullTx {
+ formatTx = func(tx *types.Transaction) (interface{}, error) {
+ return newRPCTransaction(b, tx.Hash())
+ }
+ }
+
+ txs := b.Transactions()
+ transactions := make([]interface{}, len(txs))
+ var err error
+ for i, tx := range b.Transactions() {
+ if transactions[i], err = formatTx(tx); err != nil {
+ return nil, err
+ }
+ }
+ fields["transactions"] = transactions
+ }
+
+ uncles := b.Uncles()
+ uncleHashes := make([]common.Hash, len(uncles))
+ for i, uncle := range uncles {
+ uncleHashes[i] = uncle.Hash()
+ }
+ fields["uncles"] = uncleHashes
+
+ return fields, nil
+}
+
+// RPCTransaction represents a transaction that will serialize to the RPC representation of a transaction
+type RPCTransaction struct {
+ BlockHash common.Hash `json:"blockHash"`
+ BlockNumber *rpc.HexNumber `json:"blockNumber"`
+ From common.Address `json:"from"`
+ Gas *rpc.HexNumber `json:"gas"`
+ GasPrice *rpc.HexNumber `json:"gasPrice"`
+ Hash common.Hash `json:"hash"`
+ Input string `json:"input"`
+ Nonce *rpc.HexNumber `json:"nonce"`
+ To *common.Address `json:"to"`
+ TransactionIndex *rpc.HexNumber `json:"transactionIndex"`
+ Value *rpc.HexNumber `json:"value"`
+}
+
+// newRPCPendingTransaction returns a pending transaction that will serialize to the RPC representation
+func newRPCPendingTransaction(tx *types.Transaction) *RPCTransaction {
+ from, _ := tx.From()
+
+ return &RPCTransaction{
+ From: from,
+ Gas: rpc.NewHexNumber(tx.Gas()),
+ GasPrice: rpc.NewHexNumber(tx.GasPrice()),
+ Hash: tx.Hash(),
+ Input: fmt.Sprintf("0x%x", tx.Data()),
+ Nonce: rpc.NewHexNumber(tx.Nonce()),
+ To: tx.To(),
+ Value: rpc.NewHexNumber(tx.Value()),
+ }
+}
+
+// newRPCTransaction returns a transaction that will serialize to the RPC representation.
+func newRPCTransactionFromBlockIndex(b *types.Block, txIndex int) (*RPCTransaction, error) {
+ if txIndex >= 0 && txIndex < len(b.Transactions()) {
+ tx := b.Transactions()[txIndex]
+ from, err := tx.From()
+ if err != nil {
+ return nil, err
+ }
+
+ return &RPCTransaction{
+ BlockHash: b.Hash(),
+ BlockNumber: rpc.NewHexNumber(b.Number()),
+ From: from,
+ Gas: rpc.NewHexNumber(tx.Gas()),
+ GasPrice: rpc.NewHexNumber(tx.GasPrice()),
+ Hash: tx.Hash(),
+ Input: fmt.Sprintf("0x%x", tx.Data()),
+ Nonce: rpc.NewHexNumber(tx.Nonce()),
+ To: tx.To(),
+ TransactionIndex: rpc.NewHexNumber(txIndex),
+ Value: rpc.NewHexNumber(tx.Value()),
+ }, nil
+ }
+
+ return nil, nil
+}
+
+// newRPCTransaction returns a transaction that will serialize to the RPC representation.
+func newRPCTransaction(b *types.Block, txHash common.Hash) (*RPCTransaction, error) {
+ for idx, tx := range b.Transactions() {
+ if tx.Hash() == txHash {
+ return newRPCTransactionFromBlockIndex(b, idx)
+ }
+ }
+
+ return nil, nil
+}
+
+// PublicTransactionPoolAPI exposes methods for the RPC interface
+type PublicTransactionPoolAPI struct {
+ eventMux *event.TypeMux
+ chainDb ethdb.Database
+ bc *core.BlockChain
+ am *accounts.Manager
+ txPool *core.TxPool
+ txMu sync.Mutex
+}
+
+// NewPublicTransactionPoolAPI creates a new RPC service with methods specific for the transaction pool.
+func NewPublicTransactionPoolAPI(txPool *core.TxPool, chainDb ethdb.Database, eventMux *event.TypeMux, bc *core.BlockChain, am *accounts.Manager) *PublicTransactionPoolAPI {
+ return &PublicTransactionPoolAPI{
+ eventMux: eventMux,
+ chainDb: chainDb,
+ bc: bc,
+ am: am,
+ txPool: txPool,
+ }
+}
+
+func getTransaction(chainDb ethdb.Database, txPool *core.TxPool, txHash common.Hash) (*types.Transaction, bool, error) {
+ txData, err := chainDb.Get(txHash.Bytes())
+ isPending := false
+ tx := new(types.Transaction)
+
+ if err == nil && len(txData) > 0 {
+ if err := rlp.DecodeBytes(txData, tx); err != nil {
+ return nil, isPending, err
+ }
+ } else {
+ // pending transaction?
+ tx = txPool.GetTransaction(txHash)
+ isPending = true
+ }
+
+ return tx, isPending, nil
+}
+
+// GetBlockTransactionCountByNumber returns the number of transactions in the block with the given block number.
+func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByNumber(blockNr rpc.BlockNumber) *rpc.HexNumber {
+ if blockNr == rpc.PendingBlockNumber {
+ return rpc.NewHexNumber(0)
+ }
+
+ if block := blockByNumber(s.bc, blockNr); block != nil {
+ return rpc.NewHexNumber(len(block.Transactions()))
+ }
+
+ return nil
+}
+
+// GetBlockTransactionCountByHash returns the number of transactions in the block with the given hash.
+func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByHash(blockHash common.Hash) *rpc.HexNumber {
+ if block := s.bc.GetBlock(blockHash); block != nil {
+ return rpc.NewHexNumber(len(block.Transactions()))
+ }
+ return nil
+}
+
+// GetTransactionByBlockNumberAndIndex returns the transaction for the given block number and index.
+func (s *PublicTransactionPoolAPI) GetTransactionByBlockNumberAndIndex(blockNr rpc.BlockNumber, index rpc.HexNumber) (*RPCTransaction, error) {
+ if block := blockByNumber(s.bc, blockNr); block != nil {
+ return newRPCTransactionFromBlockIndex(block, index.Int())
+ }
+ return nil, nil
+}
+
+// GetTransactionByBlockHashAndIndex returns the transaction for the given block hash and index.
+func (s *PublicTransactionPoolAPI) GetTransactionByBlockHashAndIndex(blockHash common.Hash, index rpc.HexNumber) (*RPCTransaction, error) {
+ if block := s.bc.GetBlock(blockHash); block != nil {
+ return newRPCTransactionFromBlockIndex(block, index.Int())
+ }
+ return nil, nil
+}
+
+// GetTransactionCount returns the number of transactions the given address has sent for the given block number
+func (s *PublicTransactionPoolAPI) GetTransactionCount(address common.Address, blockNr rpc.BlockNumber) (*rpc.HexNumber, error) {
+ block := blockByNumber(s.bc, blockNr)
+ if block == nil {
+ return nil, nil
+ }
+
+ state, err := state.New(block.Root(), s.chainDb)
+ if err != nil {
+ return nil, err
+ }
+ return rpc.NewHexNumber(state.GetNonce(address)), nil
+}
+
+// getTransactionBlockData fetches the meta data for the given transaction from the chain database. This is useful to
+// retrieve block information for a hash. It returns the block hash, block index and transaction index.
+func getTransactionBlockData(chainDb ethdb.Database, txHash common.Hash) (common.Hash, uint64, uint64, error) {
+ var txBlock struct {
+ BlockHash common.Hash
+ BlockIndex uint64
+ Index uint64
+ }
+
+ blockData, err := chainDb.Get(append(txHash.Bytes(), 0x0001))
+ if err != nil {
+ return common.Hash{}, uint64(0), uint64(0), err
+ }
+
+ reader := bytes.NewReader(blockData)
+ if err = rlp.Decode(reader, &txBlock); err != nil {
+ return common.Hash{}, uint64(0), uint64(0), err
+ }
+
+ return txBlock.BlockHash, txBlock.BlockIndex, txBlock.Index, nil
+}
+
+// GetTransactionByHash returns the transaction for the given hash
+func (s *PublicTransactionPoolAPI) GetTransactionByHash(txHash common.Hash) (*RPCTransaction, error) {
+ var tx *types.Transaction
+ var isPending bool
+ var err error
+
+ if tx, isPending, err = getTransaction(s.chainDb, s.txPool, txHash); err != nil {
+ glog.V(logger.Debug).Infof("%v\n", err)
+ return nil, nil
+ } else if tx == nil {
+ return nil, nil
+ }
+
+ if isPending {
+ return newRPCPendingTransaction(tx), nil
+ }
+
+ blockHash, _, _, err := getTransactionBlockData(s.chainDb, txHash)
+ if err != nil {
+ glog.V(logger.Debug).Infof("%v\n", err)
+ return nil, nil
+ }
+
+ if block := s.bc.GetBlock(blockHash); block != nil {
+ return newRPCTransaction(block, txHash)
+ }
+
+ return nil, nil
+}
+
+// GetTransactionReceipt returns the transaction receipt for the given transaction hash.
+func (s *PublicTransactionPoolAPI) GetTransactionReceipt(txHash common.Hash) (map[string]interface{}, error) {
+ receipt := core.GetReceipt(s.chainDb, txHash)
+ if receipt == nil {
+ glog.V(logger.Debug).Infof("receipt not found for transaction %s", txHash.Hex())
+ return nil, nil
+ }
+
+ tx, _, err := getTransaction(s.chainDb, s.txPool, txHash)
+ if err != nil {
+ glog.V(logger.Debug).Infof("%v\n", err)
+ return nil, nil
+ }
+
+ txBlock, blockIndex, index, err := getTransactionBlockData(s.chainDb, txHash)
+ if err != nil {
+ glog.V(logger.Debug).Infof("%v\n", err)
+ return nil, nil
+ }
+
+ from, err := tx.From()
+ if err != nil {
+ glog.V(logger.Debug).Infof("%v\n", err)
+ return nil, nil
+ }
+
+ fields := map[string]interface{}{
+ "blockHash": txBlock,
+ "blockNumber": rpc.NewHexNumber(blockIndex),
+ "transactionHash": txHash,
+ "transactionIndex": rpc.NewHexNumber(index),
+ "from": from,
+ "to": tx.To(),
+ "gasUsed": rpc.NewHexNumber(receipt.GasUsed),
+ "cumulativeGasUsed": rpc.NewHexNumber(receipt.CumulativeGasUsed),
+ "contractAddress": nil,
+ "logs": receipt.Logs,
+ }
+
+ if receipt.Logs == nil {
+ fields["logs"] = []vm.Logs{}
+ }
+
+ // If the ContractAddress is 20 0x0 bytes, assume it is not a contract creation
+ if bytes.Compare(receipt.ContractAddress.Bytes(), bytes.Repeat([]byte{0}, 20)) != 0 {
+ fields["contractAddress"] = receipt.ContractAddress
+ }
+
+ return fields, nil
+}
+
+// sign is a helper function that signs a transaction with the private key of the given address.
+func (s *PublicTransactionPoolAPI) sign(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
+ acc := accounts.Account{address}
+ signature, err := s.am.Sign(acc, tx.SigHash().Bytes())
+ if err != nil {
+ return nil, err
+ }
+ return tx.WithSignature(signature)
+}
+
+type SendTxArgs struct {
+ From common.Address `json:"from"`
+ To common.Address `json:"to"`
+ Gas *rpc.HexNumber `json:"gas"`
+ GasPrice *rpc.HexNumber `json:"gasPrice"`
+ Value *rpc.HexNumber `json:"value"`
+ Data string `json:"data"`
+ Nonce *rpc.HexNumber `json:"nonce"`
+}
+
+// SendTransaction will create a transaction for the given transaction argument, sign it and submit it to the
+// transaction pool.
+func (s *PublicTransactionPoolAPI) SendTransaction(args SendTxArgs) (common.Hash, error) {
+ if args.Gas == nil {
+ args.Gas = rpc.NewHexNumber(defaultGas)
+ }
+ if args.GasPrice == nil {
+ args.GasPrice = rpc.NewHexNumber(defaultGasPrice)
+ }
+ if args.Value == nil {
+ args.Value = rpc.NewHexNumber(0)
+ }
+
+ s.txMu.Lock()
+ defer s.txMu.Unlock()
+
+ if args.Nonce == nil {
+ args.Nonce = rpc.NewHexNumber(s.txPool.State().GetNonce(args.From))
+ }
+
+ var tx *types.Transaction
+ contractCreation := (args.To == common.Address{})
+
+ if contractCreation {
+ tx = types.NewContractCreation(args.Nonce.Uint64(), args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
+ } else {
+ tx = types.NewTransaction(args.Nonce.Uint64(), args.To, args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
+ }
+
+ signedTx, err := s.sign(args.From, tx)
+ if err != nil {
+ return common.Hash{}, err
+ }
+
+ if err := s.txPool.Add(signedTx); err != nil {
+ return common.Hash{}, nil
+ }
+
+ if contractCreation {
+ addr := crypto.CreateAddress(args.From, args.Nonce.Uint64())
+ glog.V(logger.Info).Infof("Tx(%s) created: %s\n", signedTx.Hash().Hex(), addr.Hex())
+ } else {
+ glog.V(logger.Info).Infof("Tx(%s) to: %s\n", signedTx.Hash().Hex(), tx.To().Hex())
+ }
+
+ return signedTx.Hash(), nil
+}
+
+// SendRawTransaction will add the signed transaction to the transaction pool.
+// The sender is responsible for signing the transaction and using the correct nonce.
+func (s *PublicTransactionPoolAPI) SendRawTransaction(encodedTx string) (string, error) {
+ tx := new(types.Transaction)
+ if err := rlp.DecodeBytes(common.FromHex(encodedTx), tx); err != nil {
+ return "", err
+ }
+
+ if err := s.txPool.Add(tx); 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
+}
+
+// Sign will sign the given data string with the given address. The account corresponding with the address needs to
+// be unlocked.
+func (s *PublicTransactionPoolAPI) Sign(address common.Address, data string) (string, error) {
+ signature, error := s.am.Sign(accounts.Account{Address: address}, common.HexToHash(data).Bytes())
+ return common.ToHex(signature), error
+}
+
+type SignTransactionArgs struct {
+ From common.Address
+ To common.Address
+ Nonce *rpc.HexNumber
+ Value *rpc.HexNumber
+ Gas *rpc.HexNumber
+ GasPrice *rpc.HexNumber
+ Data string
+
+ BlockNumber int64
+}
+
+// Tx is a helper object for argument and return values
+type Tx struct {
+ tx *types.Transaction
+
+ To *common.Address `json:"to"`
+ From common.Address `json:"from"`
+ Nonce *rpc.HexNumber `json:"nonce"`
+ Value *rpc.HexNumber `json:"value"`
+ Data string `json:"data"`
+ GasLimit *rpc.HexNumber `json:"gas"`
+ GasPrice *rpc.HexNumber `json:"gasPrice"`
+ Hash common.Hash `json:"hash"`
+}
+
+func (tx *Tx) UnmarshalJSON(b []byte) (err error) {
+ req := struct {
+ To common.Address `json:"to"`
+ From common.Address `json:"from"`
+ Nonce *rpc.HexNumber `json:"nonce"`
+ Value *rpc.HexNumber `json:"value"`
+ Data string `json:"data"`
+ GasLimit *rpc.HexNumber `json:"gas"`
+ GasPrice *rpc.HexNumber `json:"gasPrice"`
+ Hash common.Hash `json:"hash"`
+ }{}
+
+ if err := json.Unmarshal(b, &req); err != nil {
+ return err
+ }
+
+ contractCreation := (req.To == (common.Address{}))
+
+ tx.To = &req.To
+ tx.From = req.From
+ tx.Nonce = req.Nonce
+ tx.Value = req.Value
+ tx.Data = req.Data
+ tx.GasLimit = req.GasLimit
+ tx.GasPrice = req.GasPrice
+ tx.Hash = req.Hash
+
+ data := common.Hex2Bytes(tx.Data)
+
+ if tx.Nonce == nil {
+ return fmt.Errorf("need nonce")
+ }
+ if tx.Value == nil {
+ tx.Value = rpc.NewHexNumber(0)
+ }
+ if tx.GasLimit == nil {
+ tx.GasLimit = rpc.NewHexNumber(0)
+ }
+ if tx.GasPrice == nil {
+ tx.GasPrice = rpc.NewHexNumber(defaultGasPrice)
+ }
+
+ if contractCreation {
+ tx.tx = types.NewContractCreation(tx.Nonce.Uint64(), tx.Value.BigInt(), tx.GasLimit.BigInt(), tx.GasPrice.BigInt(), data)
+ } else {
+ if tx.To == nil {
+ return fmt.Errorf("need to address")
+ }
+ tx.tx = types.NewTransaction(tx.Nonce.Uint64(), *tx.To, tx.Value.BigInt(), tx.GasLimit.BigInt(), tx.GasPrice.BigInt(), data)
+ }
+
+ return nil
+}
+
+type SignTransactionResult struct {
+ Raw string `json:"raw"`
+ Tx *Tx `json:"tx"`
+}
+
+func newTx(t *types.Transaction) *Tx {
+ from, _ := t.From()
+ return &Tx{
+ tx: t,
+ To: t.To(),
+ From: from,
+ Value: rpc.NewHexNumber(t.Value()),
+ Nonce: rpc.NewHexNumber(t.Nonce()),
+ Data: "0x" + common.Bytes2Hex(t.Data()),
+ GasLimit: rpc.NewHexNumber(t.Gas()),
+ GasPrice: rpc.NewHexNumber(t.GasPrice()),
+ Hash: t.Hash(),
+ }
+}
+
+// SignTransaction will sign the given transaction with the from account.
+// The node needs to have the private key of the account corresponding with
+// the given from address and it needs to be unlocked.
+func (s *PublicTransactionPoolAPI) SignTransaction(args *SignTransactionArgs) (*SignTransactionResult, error) {
+ if args.Gas == nil {
+ args.Gas = rpc.NewHexNumber(defaultGas)
+ }
+ if args.GasPrice == nil {
+ args.GasPrice = rpc.NewHexNumber(defaultGasPrice)
+ }
+ if args.Value == nil {
+ args.Value = rpc.NewHexNumber(0)
+ }
+
+ s.txMu.Lock()
+ defer s.txMu.Unlock()
+
+ if args.Nonce == nil {
+ args.Nonce = rpc.NewHexNumber(s.txPool.State().GetNonce(args.From))
+ }
+
+ var tx *types.Transaction
+ contractCreation := (args.To == common.Address{})
+
+ if contractCreation {
+ tx = types.NewContractCreation(args.Nonce.Uint64(), args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
+ } else {
+ tx = types.NewTransaction(args.Nonce.Uint64(), args.To, args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
+ }
+
+ signedTx, err := s.sign(args.From, tx)
+ if err != nil {
+ return nil, err
+ }
+
+ data, err := rlp.EncodeToBytes(signedTx)
+ if err != nil {
+ return nil, err
+ }
+
+ return &SignTransactionResult{"0x" + common.Bytes2Hex(data), newTx(tx)}, nil
+}
+
+// PendingTransactions returns the transactions that are in the transaction pool and have a from address that is one of
+// the accounts this node manages.
+func (s *PublicTransactionPoolAPI) PendingTransactions() ([]*RPCTransaction, error) {
+ accounts, err := s.am.Accounts()
+ if err != nil {
+ return nil, err
+ }
+
+ accountSet := set.New()
+ for _, account := range accounts {
+ accountSet.Add(account.Address)
+ }
+
+ pending := s.txPool.GetTransactions()
+ transactions := make([]*RPCTransaction, 0)
+ for _, tx := range pending {
+ if from, _ := tx.From(); accountSet.Has(from) {
+ transactions = append(transactions, newRPCPendingTransaction(tx))
+ }
+ }
+
+ return transactions, nil
+}
+
+// NewPendingTransaction creates a subscription that is triggered each time a transaction enters the transaction pool
+// and is send from one of the transactions this nodes manages.
+func (s *PublicTransactionPoolAPI) NewPendingTransactions() (rpc.Subscription, error) {
+ sub := s.eventMux.Subscribe(core.TxPreEvent{})
+
+ accounts, err := s.am.Accounts()
+ if err != nil {
+ return rpc.Subscription{}, err
+ }
+ accountSet := set.New()
+ for _, account := range accounts {
+ accountSet.Add(account.Address)
+ }
+ accountSetLastUpdates := time.Now()
+
+ output := func(transaction interface{}) interface{} {
+ if time.Since(accountSetLastUpdates) > (time.Duration(2) * time.Second) {
+ if accounts, err = s.am.Accounts(); err != nil {
+ accountSet.Clear()
+ for _, account := range accounts {
+ accountSet.Add(account.Address)
+ }
+ accountSetLastUpdates = time.Now()
+ }
+ }
+
+ tx := transaction.(core.TxPreEvent)
+ if from, err := tx.Tx.From(); err == nil {
+ if accountSet.Has(from) {
+ return tx.Tx.Hash()
+ }
+ }
+ return nil
+ }
+
+ return rpc.NewSubscriptionWithOutputFormat(sub, output), nil
+}
+
+// Resend accepts an existing transaction and a new gas price and limit. It will remove the given transaction from the
+// pool and reinsert it with the new gas price and limit.
+func (s *PublicTransactionPoolAPI) Resend(tx *Tx, gasPrice, gasLimit *rpc.HexNumber) (common.Hash, error) {
+
+ pending := s.txPool.GetTransactions()
+ for _, p := range pending {
+ if pFrom, err := p.From(); err == nil && pFrom == tx.From && p.SigHash() == tx.tx.SigHash() {
+ if gasPrice == nil {
+ gasPrice = rpc.NewHexNumber(tx.tx.GasPrice())
+ }
+ if gasLimit == nil {
+ gasLimit = rpc.NewHexNumber(tx.tx.Gas())
+ }
+
+ var newTx *types.Transaction
+ contractCreation := (*tx.tx.To() == common.Address{})
+ if contractCreation {
+ newTx = types.NewContractCreation(tx.tx.Nonce(), tx.tx.Value(), gasPrice.BigInt(), gasLimit.BigInt(), tx.tx.Data())
+ } else {
+ newTx = types.NewTransaction(tx.tx.Nonce(), *tx.tx.To(), tx.tx.Value(), gasPrice.BigInt(), gasLimit.BigInt(), tx.tx.Data())
+ }
+
+ signedTx, err := s.sign(tx.From, newTx)
+ if err != nil {
+ return common.Hash{}, err
+ }
+
+ s.txPool.RemoveTx(tx.Hash)
+ if err = s.txPool.Add(signedTx); err != nil {
+ return common.Hash{}, err
+ }
+
+ return signedTx.Hash(), nil
+ }
+ }
+
+ return common.Hash{}, fmt.Errorf("Transaction %#x not found", tx.Hash)
+}
diff --git a/eth/backend.go b/eth/backend.go
index 91f02db72..ad98635a5 100644
--- a/eth/backend.go
+++ b/eth/backend.go
@@ -35,6 +35,7 @@ import (
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/eth/downloader"
+ "github.com/ethereum/go-ethereum/eth/filters"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/logger"
@@ -43,6 +44,7 @@ import (
"github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/rlp"
+ rpc "github.com/ethereum/go-ethereum/rpc/v2"
)
const (
@@ -239,6 +241,64 @@ func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) {
return eth, nil
}
+// APIs returns the collection of RPC services the ethereum package offers.
+// NOTE, some of these services probably need to be moved to somewhere else.
+func (s *Ethereum) APIs() []rpc.API {
+ return []rpc.API{
+ {
+ Namespace: "eth",
+ Version: "1.0",
+ Service: NewPublicEthereumAPI(s),
+ Public: true,
+ }, {
+ Namespace: "eth",
+ Version: "1.0",
+ Service: NewPublicAccountAPI(s.AccountManager()),
+ Public: true,
+ }, {
+ Namespace: "personal",
+ Version: "1.0",
+ Service: NewPrivateAccountAPI(s.AccountManager()),
+ Public: false,
+ }, {
+ Namespace: "eth",
+ Version: "1.0",
+ Service: NewPublicBlockChainAPI(s.BlockChain(), s.ChainDb(), s.EventMux(), s.AccountManager()),
+ Public: true,
+ }, {
+ Namespace: "eth",
+ Version: "1.0",
+ Service: NewPublicTransactionPoolAPI(s.TxPool(), s.ChainDb(), s.EventMux(), s.BlockChain(), s.AccountManager()),
+ Public: true,
+ }, {
+ Namespace: "eth",
+ Version: "1.0",
+ Service: miner.NewPublicMinerAPI(s.Miner()),
+ Public: true,
+ }, {
+ Namespace: "eth",
+ Version: "1.0",
+ Service: downloader.NewPublicDownloaderAPI(s.Downloader()),
+ Public: true,
+ }, {
+ Namespace: "miner",
+ Version: "1.0",
+ Service: NewPrivateMinerAPI(s),
+ Public: false,
+ }, {
+ Namespace: "txpool",
+ Version: "1.0",
+ Service: NewPublicTxPoolAPI(s),
+ Public: true,
+ }, {
+ Namespace: "eth",
+ Version: "1.0",
+ Service: filters.NewPublicFilterAPI(s.ChainDb(), s.EventMux()),
+ Public: true,
+ },
+ }
+}
+
func (s *Ethereum) ResetWithGenesisBlock(gb *types.Block) {
s.blockchain.ResetWithGenesisBlock(gb)
}
diff --git a/eth/downloader/api.go b/eth/downloader/api.go
new file mode 100644
index 000000000..9deff22a1
--- /dev/null
+++ b/eth/downloader/api.go
@@ -0,0 +1,64 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package downloader
+
+import (
+ rpc "github.com/ethereum/go-ethereum/rpc/v2"
+)
+
+// PublicDownloaderAPI provides an API which gives informatoin about the current synchronisation status.
+// It offers only methods that operates on data that can be available to anyone without security risks.
+type PublicDownloaderAPI struct {
+ d *Downloader
+}
+
+// NewPublicDownloaderAPI create a new PublicDownloaderAPI.
+func NewPublicDownloaderAPI(d *Downloader) *PublicDownloaderAPI {
+ return &PublicDownloaderAPI{d}
+}
+
+// Progress gives progress indications when the node is synchronising with the Ethereum network.
+type Progress struct {
+ Origin uint64 `json:"startingBlock"`
+ Current uint64 `json:"currentBlock"`
+ Height uint64 `json:"highestBlock"`
+}
+
+// SyncingResult provides information about the current synchronisation status for this node.
+type SyncingResult struct {
+ Syncing bool `json:"syncing"`
+ Status Progress `json:"status"`
+}
+
+// Syncing provides information when this nodes starts synchronising with the Ethereumn network and when it's finished.
+func (s *PublicDownloaderAPI) Syncing() (rpc.Subscription, error) {
+ sub := s.d.mux.Subscribe(StartEvent{}, DoneEvent{}, FailedEvent{})
+
+ output := func(event interface{}) interface{} {
+ switch event.(type) {
+ case StartEvent:
+ result := &SyncingResult{Syncing: true}
+ result.Status.Origin, result.Status.Current, result.Status.Height = s.d.Progress()
+ return result
+ case DoneEvent, FailedEvent:
+ return false
+ }
+ return nil
+ }
+
+ return rpc.NewSubscriptionWithOutputFormat(sub, output), nil
+}
diff --git a/eth/filters/api.go b/eth/filters/api.go
new file mode 100644
index 000000000..411d8e5a3
--- /dev/null
+++ b/eth/filters/api.go
@@ -0,0 +1,575 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package filters
+
+import (
+ "sync"
+ "time"
+
+ "crypto/rand"
+ "encoding/hex"
+ "errors"
+
+ "encoding/json"
+ "fmt"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/event"
+ rpc "github.com/ethereum/go-ethereum/rpc/v2"
+)
+
+var (
+ filterTickerTime = 5 * time.Minute
+)
+
+// byte will be inferred
+const (
+ unknownFilterTy = iota
+ blockFilterTy
+ transactionFilterTy
+ logFilterTy
+)
+
+// PublicFilterAPI offers support to create and manage filters. This will allow externa clients to retrieve various
+// information related to the Ethereum protocol such als blocks, transactions and logs.
+type PublicFilterAPI struct {
+ mux *event.TypeMux
+
+ quit chan struct{}
+ chainDb ethdb.Database
+
+ filterManager *FilterSystem
+
+ filterMapMu sync.RWMutex
+ filterMapping map[string]int // maps between filter internal filter identifiers and external filter identifiers
+
+ logMu sync.RWMutex
+ logQueue map[int]*logQueue
+
+ blockMu sync.RWMutex
+ blockQueue map[int]*hashQueue
+
+ transactionMu sync.RWMutex
+ transactionQueue map[int]*hashQueue
+
+ transactMu sync.Mutex
+}
+
+// NewPublicFilterAPI returns a new PublicFilterAPI instance.
+func NewPublicFilterAPI(chainDb ethdb.Database, mux *event.TypeMux) *PublicFilterAPI {
+ svc := &PublicFilterAPI{
+ mux: mux,
+ chainDb: chainDb,
+ filterManager: NewFilterSystem(mux),
+ filterMapping: make(map[string]int),
+ logQueue: make(map[int]*logQueue),
+ blockQueue: make(map[int]*hashQueue),
+ transactionQueue: make(map[int]*hashQueue),
+ }
+ go svc.start()
+ return svc
+}
+
+// Stop quits the work loop.
+func (s *PublicFilterAPI) Stop() {
+ close(s.quit)
+}
+
+// start the work loop, wait and process events.
+func (s *PublicFilterAPI) start() {
+ timer := time.NewTicker(2 * time.Second)
+ defer timer.Stop()
+done:
+ for {
+ select {
+ case <-timer.C:
+ s.logMu.Lock()
+ for id, filter := range s.logQueue {
+ if time.Since(filter.timeout) > filterTickerTime {
+ s.filterManager.Remove(id)
+ delete(s.logQueue, id)
+ }
+ }
+ s.logMu.Unlock()
+
+ s.blockMu.Lock()
+ for id, filter := range s.blockQueue {
+ if time.Since(filter.timeout) > filterTickerTime {
+ s.filterManager.Remove(id)
+ delete(s.blockQueue, id)
+ }
+ }
+ s.blockMu.Unlock()
+
+ s.transactionMu.Lock()
+ for id, filter := range s.transactionQueue {
+ if time.Since(filter.timeout) > filterTickerTime {
+ s.filterManager.Remove(id)
+ delete(s.transactionQueue, id)
+ }
+ }
+ s.transactionMu.Unlock()
+ case <-s.quit:
+ break done
+ }
+ }
+
+}
+
+// NewBlockFilter create a new filter that returns blocks that are included into the canonical chain.
+func (s *PublicFilterAPI) NewBlockFilter() (string, error) {
+ externalId, err := newFilterId()
+ if err != nil {
+ return "", err
+ }
+
+ s.blockMu.Lock()
+ filter := New(s.chainDb)
+ id := s.filterManager.Add(filter)
+ s.blockQueue[id] = &hashQueue{timeout: time.Now()}
+
+ filter.BlockCallback = func(block *types.Block, logs vm.Logs) {
+ s.blockMu.Lock()
+ defer s.blockMu.Unlock()
+
+ if queue := s.blockQueue[id]; queue != nil {
+ queue.add(block.Hash())
+ }
+ }
+
+ defer s.blockMu.Unlock()
+
+ s.filterMapMu.Lock()
+ s.filterMapping[externalId] = id
+ s.filterMapMu.Unlock()
+
+ return externalId, nil
+}
+
+// NewPendingTransactionFilter creates a filter that returns new pending transactions.
+func (s *PublicFilterAPI) NewPendingTransactionFilter() (string, error) {
+ externalId, err := newFilterId()
+ if err != nil {
+ return "", err
+ }
+
+ s.transactionMu.Lock()
+ defer s.transactionMu.Unlock()
+
+ filter := New(s.chainDb)
+ id := s.filterManager.Add(filter)
+ s.transactionQueue[id] = &hashQueue{timeout: time.Now()}
+
+ filter.TransactionCallback = func(tx *types.Transaction) {
+ s.transactionMu.Lock()
+ defer s.transactionMu.Unlock()
+
+ if queue := s.transactionQueue[id]; queue != nil {
+ queue.add(tx.Hash())
+ }
+ }
+
+ s.filterMapMu.Lock()
+ s.filterMapping[externalId] = id
+ s.filterMapMu.Unlock()
+
+ return externalId, nil
+}
+
+// newLogFilter creates a new log filter.
+func (s *PublicFilterAPI) newLogFilter(earliest, latest int64, addresses []common.Address, topics [][]common.Hash) int {
+ s.logMu.Lock()
+ defer s.logMu.Unlock()
+
+ filter := New(s.chainDb)
+ id := s.filterManager.Add(filter)
+ s.logQueue[id] = &logQueue{timeout: time.Now()}
+
+ filter.SetBeginBlock(earliest)
+ filter.SetEndBlock(latest)
+ filter.SetAddresses(addresses)
+ filter.SetTopics(topics)
+ filter.LogsCallback = func(logs vm.Logs) {
+ s.logMu.Lock()
+ defer s.logMu.Unlock()
+
+ if queue := s.logQueue[id]; queue != nil {
+ queue.add(logs...)
+ }
+ }
+
+ return id
+}
+
+// NewFilterArgs represents a request to create a new filter.
+type NewFilterArgs struct {
+ FromBlock rpc.BlockNumber
+ ToBlock rpc.BlockNumber
+ Addresses []common.Address
+ Topics [][]common.Hash
+}
+
+func (args *NewFilterArgs) UnmarshalJSON(data []byte) error {
+ type input struct {
+ From *rpc.BlockNumber `json:"fromBlock"`
+ ToBlock *rpc.BlockNumber `json:"toBlock"`
+ Addresses interface{} `json:"address"`
+ Topics interface{} `json:"topics"`
+ }
+
+ var raw input
+ if err := json.Unmarshal(data, &raw); err != nil {
+ return err
+ }
+
+ if raw.From == nil {
+ args.FromBlock = rpc.LatestBlockNumber
+ } else {
+ args.FromBlock = *raw.From
+ }
+
+ if raw.ToBlock == nil {
+ args.ToBlock = rpc.LatestBlockNumber
+ } else {
+ args.ToBlock = *raw.ToBlock
+ }
+
+ args.Addresses = []common.Address{}
+
+ if raw.Addresses != nil {
+ // raw.Address can contain a single address or an array of addresses
+ var addresses []common.Address
+
+ if strAddrs, ok := raw.Addresses.([]interface{}); ok {
+ for i, addr := range strAddrs {
+ if strAddr, ok := addr.(string); ok {
+ if len(strAddr) >= 2 && strAddr[0] == '0' && (strAddr[1] == 'x' || strAddr[1] == 'X') {
+ strAddr = strAddr[2:]
+ }
+ if decAddr, err := hex.DecodeString(strAddr); err == nil {
+ addresses = append(addresses, common.BytesToAddress(decAddr))
+ } else {
+ fmt.Errorf("invalid address given")
+ }
+ } else {
+ return fmt.Errorf("invalid address on index %d", i)
+ }
+ }
+ } else if singleAddr, ok := raw.Addresses.(string); ok {
+ if len(singleAddr) >= 2 && singleAddr[0] == '0' && (singleAddr[1] == 'x' || singleAddr[1] == 'X') {
+ singleAddr = singleAddr[2:]
+ }
+ if decAddr, err := hex.DecodeString(singleAddr); err == nil {
+ addresses = append(addresses, common.BytesToAddress(decAddr))
+ } else {
+ fmt.Errorf("invalid address given")
+ }
+ } else {
+ errors.New("invalid address(es) given")
+ }
+ args.Addresses = addresses
+ }
+
+ topicConverter := func(raw string) (common.Hash, error) {
+ if len(raw) == 0 {
+ return common.Hash{}, nil
+ }
+
+ if len(raw) >= 2 && raw[0] == '0' && (raw[1] == 'x' || raw[1] == 'X') {
+ raw = raw[2:]
+ }
+
+ if decAddr, err := hex.DecodeString(raw); err == nil {
+ return common.BytesToHash(decAddr), nil
+ }
+
+ return common.Hash{}, errors.New("invalid topic given")
+ }
+
+ // topics is an array consisting of strings or arrays of strings
+ if raw.Topics != nil {
+ topics, ok := raw.Topics.([]interface{})
+ if ok {
+ parsedTopics := make([][]common.Hash, len(topics))
+ for i, topic := range topics {
+ if topic == nil {
+ parsedTopics[i] = []common.Hash{common.StringToHash("")}
+ } else if strTopic, ok := topic.(string); ok {
+ if t, err := topicConverter(strTopic); err != nil {
+ return fmt.Errorf("invalid topic on index %d", i)
+ } else {
+ parsedTopics[i] = []common.Hash{t}
+ }
+ } else if arrTopic, ok := topic.([]interface{}); ok {
+ parsedTopics[i] = make([]common.Hash, len(arrTopic))
+ for j := 0; j < len(parsedTopics[i]); i++ {
+ if arrTopic[j] == nil {
+ parsedTopics[i][j] = common.StringToHash("")
+ } else if str, ok := arrTopic[j].(string); ok {
+ if t, err := topicConverter(str); err != nil {
+ return fmt.Errorf("invalid topic on index %d", i)
+ } else {
+ parsedTopics[i] = []common.Hash{t}
+ }
+ } else {
+ fmt.Errorf("topic[%d][%d] not a string", i, j)
+ }
+ }
+ } else {
+ return fmt.Errorf("topic[%d] invalid", i)
+ }
+ }
+ args.Topics = parsedTopics
+ }
+ }
+
+ return nil
+}
+
+// NewFilter creates a new filter and returns the filter id. It can be uses to retrieve logs.
+func (s *PublicFilterAPI) NewFilter(args NewFilterArgs) (string, error) {
+ externalId, err := newFilterId()
+ if err != nil {
+ return "", err
+ }
+
+ var id int
+ if len(args.Addresses) > 0 {
+ id = s.newLogFilter(args.FromBlock.Int64(), args.ToBlock.Int64(), args.Addresses, args.Topics)
+ } else {
+ id = s.newLogFilter(args.FromBlock.Int64(), args.ToBlock.Int64(), nil, args.Topics)
+ }
+
+ s.filterMapMu.Lock()
+ s.filterMapping[externalId] = id
+ s.filterMapMu.Unlock()
+
+ return externalId, nil
+}
+
+// GetLogs returns the logs matching the given argument.
+func (s *PublicFilterAPI) GetLogs(args NewFilterArgs) vm.Logs {
+ filter := New(s.chainDb)
+ filter.SetBeginBlock(args.FromBlock.Int64())
+ filter.SetEndBlock(args.ToBlock.Int64())
+ filter.SetAddresses(args.Addresses)
+ filter.SetTopics(args.Topics)
+
+ return returnLogs(filter.Find())
+}
+
+// UninstallFilter removes the filter with the given filter id.
+func (s *PublicFilterAPI) UninstallFilter(filterId string) bool {
+ s.filterMapMu.Lock()
+ defer s.filterMapMu.Unlock()
+
+ id, ok := s.filterMapping[filterId]
+ if !ok {
+ return false
+ }
+
+ defer s.filterManager.Remove(id)
+ delete(s.filterMapping, filterId)
+
+ if _, ok := s.logQueue[id]; ok {
+ s.logMu.Lock()
+ defer s.logMu.Unlock()
+ delete(s.logQueue, id)
+ return true
+ }
+ if _, ok := s.blockQueue[id]; ok {
+ s.blockMu.Lock()
+ defer s.blockMu.Unlock()
+ delete(s.blockQueue, id)
+ return true
+ }
+ if _, ok := s.transactionQueue[id]; ok {
+ s.transactionMu.Lock()
+ defer s.transactionMu.Unlock()
+ delete(s.transactionQueue, id)
+ return true
+ }
+
+ return false
+}
+
+// getFilterType is a helper utility that determine the type of filter for the given filter id.
+func (s *PublicFilterAPI) getFilterType(id int) byte {
+ if _, ok := s.blockQueue[id]; ok {
+ return blockFilterTy
+ } else if _, ok := s.transactionQueue[id]; ok {
+ return transactionFilterTy
+ } else if _, ok := s.logQueue[id]; ok {
+ return logFilterTy
+ }
+
+ return unknownFilterTy
+}
+
+// blockFilterChanged returns a collection of block hashes for the block filter with the given id.
+func (s *PublicFilterAPI) blockFilterChanged(id int) []common.Hash {
+ s.blockMu.Lock()
+ defer s.blockMu.Unlock()
+
+ if s.blockQueue[id] != nil {
+ return s.blockQueue[id].get()
+ }
+ return nil
+}
+
+// transactionFilterChanged returns a collection of transaction hashes for the pending
+// transaction filter with the given id.
+func (s *PublicFilterAPI) transactionFilterChanged(id int) []common.Hash {
+ s.blockMu.Lock()
+ defer s.blockMu.Unlock()
+
+ if s.transactionQueue[id] != nil {
+ return s.transactionQueue[id].get()
+ }
+ return nil
+}
+
+// logFilterChanged returns a collection of logs for the log filter with the given id.
+func (s *PublicFilterAPI) logFilterChanged(id int) vm.Logs {
+ s.logMu.Lock()
+ defer s.logMu.Unlock()
+
+ if s.logQueue[id] != nil {
+ return s.logQueue[id].get()
+ }
+ return nil
+}
+
+// GetFilterLogs returns the logs for the filter with the given id.
+func (s *PublicFilterAPI) GetFilterLogs(filterId string) vm.Logs {
+ id, ok := s.filterMapping[filterId]
+ if !ok {
+ return returnLogs(nil)
+ }
+
+ if filter := s.filterManager.Get(id); filter != nil {
+ return returnLogs(filter.Find())
+ }
+
+ return returnLogs(nil)
+}
+
+// GetFilterChanges returns the logs for the filter with the given id since last time is was called.
+// This can be used for polling.
+func (s *PublicFilterAPI) GetFilterChanges(filterId string) interface{} {
+ s.filterMapMu.Lock()
+ id, ok := s.filterMapping[filterId]
+ s.filterMapMu.Unlock()
+
+ if !ok { // filter not found
+ return []interface{}{}
+ }
+
+ switch s.getFilterType(id) {
+ case blockFilterTy:
+ return returnHashes(s.blockFilterChanged(id))
+ case transactionFilterTy:
+ return returnHashes(s.transactionFilterChanged(id))
+ case logFilterTy:
+ return returnLogs(s.logFilterChanged(id))
+ }
+
+ return []interface{}{}
+}
+
+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
+}
+
+// newFilterId generates a new random filter identifier that can be exposed to the outer world. By publishing random
+// identifiers it is not feasible for DApp's to guess filter id's for other DApp's and uninstall or poll for them
+// causing the affected DApp to miss data.
+func newFilterId() (string, error) {
+ var subid [16]byte
+ n, _ := rand.Read(subid[:])
+ if n != 16 {
+ return "", errors.New("Unable to generate filter id")
+ }
+ return "0x" + hex.EncodeToString(subid[:]), nil
+}
+
+// returnLogs is a helper that will return an empty logs array case the given logs is nil, otherwise is will return the
+// given logs. The RPC interfaces defines that always an array is returned.
+func returnLogs(logs vm.Logs) vm.Logs {
+ if logs == nil {
+ return vm.Logs{}
+ }
+ return logs
+}
+
+// returnHashes is a helper that will return an empty hash array case the given hash array is nil, otherwise is will
+// return the given hashes. The RPC interfaces defines that always an array is returned.
+func returnHashes(hashes []common.Hash) []common.Hash {
+ if hashes == nil {
+ return []common.Hash{}
+ }
+ return hashes
+}