Merge pull request #1171 from rphmeier/rpc-unimplemented

implement missing rpc methods and tests
This commit is contained in:
Nikolay Volf 2016-05-30 18:15:24 +02:00
commit 13e5c19be7
13 changed files with 207 additions and 114 deletions

View File

@ -395,6 +395,7 @@ impl MinerService for Miner {
Err(ref e) => { Err(ref e) => {
trace!(target: "own_tx", "Failed to import transaction {:?} (hash: {:?})", e, hash); trace!(target: "own_tx", "Failed to import transaction {:?} (hash: {:?})", e, hash);
trace!(target: "own_tx", "Status: {:?}", transaction_queue.status()); trace!(target: "own_tx", "Status: {:?}", transaction_queue.status());
warn!(target: "own_tx", "Error importing transaction: {:?}", e);
}, },
} }
import import

View File

@ -27,6 +27,7 @@ use jsonrpc_core::*;
use util::numbers::*; use util::numbers::*;
use util::sha3::*; use util::sha3::*;
use util::rlp::{encode, decode, UntrustedRlp, View}; use util::rlp::{encode, decode, UntrustedRlp, View};
use util::keys::store::AccountProvider;
use ethcore::client::{BlockChainClient, BlockID, TransactionID, UncleID}; use ethcore::client::{BlockChainClient, BlockID, TransactionID, UncleID};
use ethcore::block::IsBlock; use ethcore::block::IsBlock;
use ethcore::views::*; use ethcore::views::*;
@ -39,7 +40,6 @@ use v1::traits::{Eth, EthFilter};
use v1::types::{Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo, Transaction, TransactionRequest, CallRequest, OptionalValue, Index, Filter, Log, Receipt}; use v1::types::{Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo, Transaction, TransactionRequest, CallRequest, OptionalValue, Index, Filter, Log, Receipt};
use v1::helpers::{PollFilter, PollManager}; use v1::helpers::{PollFilter, PollManager};
use v1::impls::{dispatch_transaction, sign_and_dispatch}; use v1::impls::{dispatch_transaction, sign_and_dispatch};
use util::keys::store::AccountProvider;
use serde; use serde;
/// Eth rpc implementation. /// Eth rpc implementation.
@ -494,6 +494,12 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM> where
}) })
} }
fn sign(&self, params: Params) -> Result<Value, Error> {
from_params::<(Address, H256)>(params).and_then(|(addr, msg)| {
to_value(&take_weak!(self.accounts).sign(&addr, &msg).unwrap_or(H520::zero()))
})
}
fn send_transaction(&self, params: Params) -> Result<Value, Error> { fn send_transaction(&self, params: Params) -> Result<Value, Error> {
from_params::<(TransactionRequest, )>(params) from_params::<(TransactionRequest, )>(params)
.and_then(|(request, )| { .and_then(|(request, )| {
@ -542,6 +548,18 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM> where
to_value(&r.map(|res| res.gas_used + res.refunded).unwrap_or(From::from(0))) to_value(&r.map(|res| res.gas_used + res.refunded).unwrap_or(From::from(0)))
}) })
} }
fn compile_lll(&self, _: Params) -> Result<Value, Error> {
rpc_unimplemented!()
}
fn compile_serpent(&self, _: Params) -> Result<Value, Error> {
rpc_unimplemented!()
}
fn compile_solidity(&self, _: Params) -> Result<Value, Error> {
rpc_unimplemented!()
}
} }
/// Eth filter rpc implementation. /// Eth filter rpc implementation.

View File

@ -25,6 +25,10 @@ macro_rules! take_weak {
} }
} }
macro_rules! rpc_unimplemented {
() => (Err(Error::internal_error()))
}
mod web3; mod web3;
mod eth; mod eth;
mod net; mod net;
@ -55,22 +59,14 @@ fn dispatch_transaction<C, M>(client: &C, miner: &M, signed_transaction: SignedT
where C: BlockChainClient, M: MinerService { where C: BlockChainClient, M: MinerService {
let hash = signed_transaction.hash(); let hash = signed_transaction.hash();
let import = { let import = miner.import_own_transaction(client, signed_transaction, |a: &Address| {
miner.import_own_transaction(client, signed_transaction, |a: &Address| { AccountDetails {
AccountDetails { nonce: client.latest_nonce(&a),
nonce: client.latest_nonce(&a), balance: client.latest_balance(&a),
balance: client.latest_balance(&a),
}
})
};
match import {
Ok(_) => to_value(&hash),
Err(e) => {
warn!("Error sending transaction: {:?}", e);
to_value(&H256::zero())
} }
} });
to_value(&import.map(|_| hash).unwrap_or(H256::zero()))
} }
fn sign_and_dispatch<C, M>(client: &Weak<C>, miner: &Weak<M>, request: TransactionRequest, secret: H256) -> Result<Value, Error> fn sign_and_dispatch<C, M>(client: &Weak<C>, miner: &Weak<M>, request: TransactionRequest, secret: H256) -> Result<Value, Error>

View File

@ -27,7 +27,7 @@ use ethcore::transaction::{Transaction, Action};
use ethminer::{MinerService, ExternalMiner}; use ethminer::{MinerService, ExternalMiner};
use devtools::RandomTempPath; use devtools::RandomTempPath;
use util::io::IoChannel; use util::io::IoChannel;
use util::hash::{Address, FixedHash}; use util::hash::Address;
use util::numbers::{Uint, U256}; use util::numbers::{Uint, U256};
use util::keys::{AccountProvider, TestAccount, TestAccountProvider}; use util::keys::{AccountProvider, TestAccount, TestAccountProvider};
use jsonrpc_core::IoHandler; use jsonrpc_core::IoHandler;

View File

@ -20,14 +20,16 @@ use std::sync::{Arc, RwLock};
use jsonrpc_core::IoHandler; use jsonrpc_core::IoHandler;
use util::hash::{Address, H256, FixedHash}; use util::hash::{Address, H256, FixedHash};
use util::numbers::{Uint, U256}; use util::numbers::{Uint, U256};
use util::keys::{TestAccount, TestAccountProvider}; use util::keys::{AccountProvider, TestAccount, TestAccountProvider};
use ethcore::client::{TestBlockChainClient, EachBlockWith, Executed, TransactionID}; use ethcore::client::{TestBlockChainClient, EachBlockWith, Executed, TransactionID};
use ethcore::log_entry::{LocalizedLogEntry, LogEntry}; use ethcore::log_entry::{LocalizedLogEntry, LogEntry};
use ethcore::receipt::LocalizedReceipt; use ethcore::receipt::LocalizedReceipt;
use ethcore::transaction::{Transaction, Action}; use ethcore::transaction::{Transaction, Action};
use ethminer::ExternalMiner; use ethminer::{ExternalMiner, MinerService};
use ethsync::SyncState;
use v1::{Eth, EthClient}; use v1::{Eth, EthClient};
use v1::tests::helpers::{TestSyncProvider, Config, TestMinerService}; use v1::tests::helpers::{TestSyncProvider, Config, TestMinerService};
use rustc_serialize::hex::ToHex;
fn blockchain_client() -> Arc<TestBlockChainClient> { fn blockchain_client() -> Arc<TestBlockChainClient> {
let client = TestBlockChainClient::new(); let client = TestBlockChainClient::new();
@ -92,9 +94,28 @@ fn rpc_eth_protocol_version() {
} }
#[test] #[test]
#[ignore]
fn rpc_eth_syncing() { fn rpc_eth_syncing() {
unimplemented!() let request = r#"{"jsonrpc": "2.0", "method": "eth_syncing", "params": [], "id": 1}"#;
let tester = EthTester::default();
let false_res = r#"{"jsonrpc":"2.0","result":false,"id":1}"#;
assert_eq!(tester.io.handle_request(request), Some(false_res.to_owned()));
{
let mut status = tester.sync.status.write().unwrap();
status.state = SyncState::Blocks;
status.highest_block_number = Some(2500);
// causes TestBlockChainClient to return 1000 for its best block number.
let mut blocks = tester.client.blocks.write().unwrap();
for i in 0..1000 {
blocks.insert(H256::from(i), Vec::new());
}
}
let true_res = r#"{"jsonrpc":"2.0","result":{"currentBlock":"0x03e8","highestBlock":"0x09c4","startingBlock":"0x00"},"id":1}"#;
assert_eq!(tester.io.handle_request(request), Some(true_res.to_owned()));
} }
#[test] #[test]
@ -130,9 +151,47 @@ fn rpc_eth_submit_hashrate() {
} }
#[test] #[test]
#[ignore] fn rpc_eth_sign() {
let tester = EthTester::default();
let account = tester.accounts_provider.new_account("abcd").unwrap();
let message = H256::from("0x0cc175b9c0f1b6a831c399e26977266192eb5ffee6ae2fec3ad71c777531578f");
let signed = tester.accounts_provider.sign(&account, &message).unwrap();
let req = r#"{
"jsonrpc": "2.0",
"method": "eth_sign",
"params": [
""#.to_owned() + &format!("0x{:?}", account) + r#"",
"0x0cc175b9c0f1b6a831c399e26977266192eb5ffee6ae2fec3ad71c777531578f"
],
"id": 1
}"#;
let res = r#"{"jsonrpc":"2.0","result":""#.to_owned() + &format!("0x{:?}", signed) + r#"","id":1}"#;
assert_eq!(tester.io.handle_request(&req), Some(res));
}
#[test]
fn rpc_eth_author() { fn rpc_eth_author() {
unimplemented!() let make_res = |addr| r#"{"jsonrpc":"2.0","result":""#.to_owned() + &format!("0x{:?}", addr) + r#"","id":1}"#;
let tester = EthTester::default();
let req = r#"{
"jsonrpc": "2.0",
"method": "eth_coinbase",
"params": [],
"id": 1
}"#;
assert_eq!(tester.io.handle_request(req), Some(make_res(Address::zero())));
for i in 0..20 {
let addr = tester.accounts_provider.new_account(&format!("{}", i)).unwrap();
tester.miner.set_author(addr.clone());
assert_eq!(tester.io.handle_request(req), Some(make_res(addr)));
}
} }
#[test] #[test]
@ -193,18 +252,22 @@ fn rpc_eth_balance() {
assert_eq!(tester.io.handle_request(request), Some(response.to_owned())); assert_eq!(tester.io.handle_request(request), Some(response.to_owned()));
} }
#[ignore] //TODO: propert test
#[test] #[test]
fn rpc_eth_balance_pending() { fn rpc_eth_balance_pending() {
let tester = EthTester::default(); let tester = EthTester::default();
tester.client.set_balance(Address::from(1), U256::from(5));
let request = r#"{ let request = r#"{
"jsonrpc": "2.0", "jsonrpc": "2.0",
"method": "eth_getBalance", "method": "eth_getBalance",
"params": ["0x0000000000000000000000000000000000000001", "latest"], "params": ["0x0000000000000000000000000000000000000001", "pending"],
"id": 1 "id": 1
}"#; }"#;
let response = r#"{"jsonrpc":"2.0","result":"0x","id":1}"#;
// the TestMinerService doesn't communicate with the the TestBlockChainClient in any way.
// if this returns zero, we know that the "pending" call is being properly forwarded to the
// miner.
let response = r#"{"jsonrpc":"2.0","result":"0x00","id":1}"#;
assert_eq!(tester.io.handle_request(request), Some(response.to_owned())); assert_eq!(tester.io.handle_request(request), Some(response.to_owned()));
} }
@ -503,7 +566,7 @@ fn rpc_eth_send_transaction() {
let response = r#"{"jsonrpc":"2.0","result":""#.to_owned() + format!("0x{:?}", t.hash()).as_ref() + r#"","id":1}"#; let response = r#"{"jsonrpc":"2.0","result":""#.to_owned() + format!("0x{:?}", t.hash()).as_ref() + r#"","id":1}"#;
assert_eq!(tester.io.handle_request(request.as_ref()), Some(response)); assert_eq!(tester.io.handle_request(&request), Some(response));
tester.miner.last_nonces.write().unwrap().insert(address.clone(), U256::zero()); tester.miner.last_nonces.write().unwrap().insert(address.clone(), U256::zero());
@ -518,19 +581,38 @@ fn rpc_eth_send_transaction() {
let response = r#"{"jsonrpc":"2.0","result":""#.to_owned() + format!("0x{:?}", t.hash()).as_ref() + r#"","id":1}"#; let response = r#"{"jsonrpc":"2.0","result":""#.to_owned() + format!("0x{:?}", t.hash()).as_ref() + r#"","id":1}"#;
assert_eq!(tester.io.handle_request(request.as_ref()), Some(response)); assert_eq!(tester.io.handle_request(&request), Some(response));
} }
#[test] #[test]
#[ignore]
fn rpc_eth_send_raw_transaction() { fn rpc_eth_send_raw_transaction() {
unimplemented!() let tester = EthTester::default();
} let address = tester.accounts_provider.new_account("abcd").unwrap();
let secret = tester.accounts_provider.account_secret(&address).unwrap();
#[test] let t = Transaction {
#[ignore] nonce: U256::zero(),
fn rpc_eth_sign() { gas_price: U256::from(0x9184e72a000u64),
unimplemented!() gas: U256::from(0x76c0),
action: Action::Call(Address::from_str("d46e8dd67c5d32be8058bb8eb970870f07244567").unwrap()),
value: U256::from(0x9184e72au64),
data: vec![]
}.sign(&secret);
let rlp = ::util::rlp::encode(&t).to_vec().to_hex();
let req = r#"{
"jsonrpc": "2.0",
"method": "eth_sendRawTransaction",
"params": [
"0x"#.to_owned() + &rlp + r#""
],
"id": 1
}"#;
let res = r#"{"jsonrpc":"2.0","result":""#.to_owned() + &format!("0x{:?}", t.hash()) + r#"","id":1}"#;
assert_eq!(tester.io.handle_request(&req), Some(res));
} }
#[test] #[test]

View File

@ -21,115 +21,115 @@ use jsonrpc_core::*;
/// Eth rpc interface. /// Eth rpc interface.
pub trait Eth: Sized + Send + Sync + 'static { pub trait Eth: Sized + Send + Sync + 'static {
/// Returns protocol version. /// Returns protocol version.
fn protocol_version(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn protocol_version(&self, _: Params) -> Result<Value, Error>;
/// Returns an object with data about the sync status or false. (wtf?) /// Returns an object with data about the sync status or false. (wtf?)
fn syncing(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn syncing(&self, _: Params) -> Result<Value, Error>;
/// Returns the number of hashes per second that the node is mining with. /// Returns the number of hashes per second that the node is mining with.
fn hashrate(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn hashrate(&self, _: Params) -> Result<Value, Error>;
/// Returns block author. /// Returns block author.
fn author(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn author(&self, _: Params) -> Result<Value, Error>;
/// Returns true if client is actively mining new blocks. /// Returns true if client is actively mining new blocks.
fn is_mining(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn is_mining(&self, _: Params) -> Result<Value, Error>;
/// Returns current gas_price. /// Returns current gas_price.
fn gas_price(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn gas_price(&self, _: Params) -> Result<Value, Error>;
/// Returns accounts list. /// Returns accounts list.
fn accounts(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn accounts(&self, _: Params) -> Result<Value, Error>;
/// Returns highest block number. /// Returns highest block number.
fn block_number(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn block_number(&self, _: Params) -> Result<Value, Error>;
/// Returns balance of the given account. /// Returns balance of the given account.
fn balance(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn balance(&self, _: Params) -> Result<Value, Error>;
/// Returns content of the storage at given address. /// Returns content of the storage at given address.
fn storage_at(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn storage_at(&self, _: Params) -> Result<Value, Error>;
/// Returns block with given hash. /// Returns block with given hash.
fn block_by_hash(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn block_by_hash(&self, _: Params) -> Result<Value, Error>;
/// Returns block with given number. /// Returns block with given number.
fn block_by_number(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn block_by_number(&self, _: Params) -> Result<Value, Error>;
/// Returns the number of transactions sent from given address at given time (block number). /// Returns the number of transactions sent from given address at given time (block number).
fn transaction_count(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn transaction_count(&self, _: Params) -> Result<Value, Error>;
/// Returns the number of transactions in a block with given hash. /// Returns the number of transactions in a block with given hash.
fn block_transaction_count_by_hash(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn block_transaction_count_by_hash(&self, _: Params) -> Result<Value, Error>;
/// Returns the number of transactions in a block with given block number. /// Returns the number of transactions in a block with given block number.
fn block_transaction_count_by_number(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn block_transaction_count_by_number(&self, _: Params) -> Result<Value, Error>;
/// Returns the number of uncles in a block with given hash. /// Returns the number of uncles in a block with given hash.
fn block_uncles_count_by_hash(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn block_uncles_count_by_hash(&self, _: Params) -> Result<Value, Error>;
/// Returns the number of uncles in a block with given block number. /// Returns the number of uncles in a block with given block number.
fn block_uncles_count_by_number(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn block_uncles_count_by_number(&self, _: Params) -> Result<Value, Error>;
/// Returns the code at given address at given time (block number). /// Returns the code at given address at given time (block number).
fn code_at(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn code_at(&self, _: Params) -> Result<Value, Error>;
/// Signs the data with given address signature. /// Signs the data with given address signature.
fn sign(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn sign(&self, _: Params) -> Result<Value, Error>;
/// Sends transaction. /// Sends transaction.
fn send_transaction(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn send_transaction(&self, _: Params) -> Result<Value, Error>;
/// Sends signed transaction. /// Sends signed transaction.
fn send_raw_transaction(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn send_raw_transaction(&self, _: Params) -> Result<Value, Error>;
/// Call contract. /// Call contract.
fn call(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn call(&self, _: Params) -> Result<Value, Error>;
/// Estimate gas needed for execution of given contract. /// Estimate gas needed for execution of given contract.
fn estimate_gas(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn estimate_gas(&self, _: Params) -> Result<Value, Error>;
/// Get transaction by it's hash. /// Get transaction by it's hash.
fn transaction_by_hash(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn transaction_by_hash(&self, _: Params) -> Result<Value, Error>;
/// Returns transaction at given block hash and index. /// Returns transaction at given block hash and index.
fn transaction_by_block_hash_and_index(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn transaction_by_block_hash_and_index(&self, _: Params) -> Result<Value, Error>;
/// Returns transaction by given block number and index. /// Returns transaction by given block number and index.
fn transaction_by_block_number_and_index(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn transaction_by_block_number_and_index(&self, _: Params) -> Result<Value, Error>;
/// Returns transaction receipt. /// Returns transaction receipt.
fn transaction_receipt(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn transaction_receipt(&self, _: Params) -> Result<Value, Error>;
/// Returns an uncles at given block and index. /// Returns an uncles at given block and index.
fn uncle_by_block_hash_and_index(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn uncle_by_block_hash_and_index(&self, _: Params) -> Result<Value, Error>;
/// Returns an uncles at given block and index. /// Returns an uncles at given block and index.
fn uncle_by_block_number_and_index(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn uncle_by_block_number_and_index(&self, _: Params) -> Result<Value, Error>;
/// Returns available compilers. /// Returns available compilers.
fn compilers(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn compilers(&self, _: Params) -> Result<Value, Error>;
/// Compiles lll code. /// Compiles lll code.
fn compile_lll(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn compile_lll(&self, _: Params) -> Result<Value, Error>;
/// Compiles solidity. /// Compiles solidity.
fn compile_solidity(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn compile_solidity(&self, _: Params) -> Result<Value, Error>;
/// Compiles serpent. /// Compiles serpent.
fn compile_serpent(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn compile_serpent(&self, _: Params) -> Result<Value, Error>;
/// Returns logs matching given filter object. /// Returns logs matching given filter object.
fn logs(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn logs(&self, _: Params) -> Result<Value, Error>;
/// Returns the hash of the current block, the seedHash, and the boundary condition to be met. /// Returns the hash of the current block, the seedHash, and the boundary condition to be met.
fn work(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn work(&self, _: Params) -> Result<Value, Error>;
/// Used for submitting a proof-of-work solution. /// Used for submitting a proof-of-work solution.
fn submit_work(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn submit_work(&self, _: Params) -> Result<Value, Error>;
/// Used for submitting mining hashrate. /// Used for submitting mining hashrate.
fn submit_hashrate(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn submit_hashrate(&self, _: Params) -> Result<Value, Error>;
/// Should be used to convert object to io delegate. /// Should be used to convert object to io delegate.
fn to_delegate(self) -> IoDelegate<Self> { fn to_delegate(self) -> IoDelegate<Self> {
@ -179,22 +179,22 @@ pub trait Eth: Sized + Send + Sync + 'static {
// TODO: do filters api properly // TODO: do filters api properly
pub trait EthFilter: Sized + Send + Sync + 'static { pub trait EthFilter: Sized + Send + Sync + 'static {
/// Returns id of new filter. /// Returns id of new filter.
fn new_filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn new_filter(&self, _: Params) -> Result<Value, Error>;
/// Returns id of new block filter. /// Returns id of new block filter.
fn new_block_filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn new_block_filter(&self, _: Params) -> Result<Value, Error>;
/// Returns id of new block filter. /// Returns id of new block filter.
fn new_pending_transaction_filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn new_pending_transaction_filter(&self, _: Params) -> Result<Value, Error>;
/// Returns filter changes since last poll. /// Returns filter changes since last poll.
fn filter_changes(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn filter_changes(&self, _: Params) -> Result<Value, Error>;
/// Returns all logs matching given filter (in a range 'from' - 'to'). /// Returns all logs matching given filter (in a range 'from' - 'to').
fn filter_logs(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn filter_logs(&self, _: Params) -> Result<Value, Error>;
/// Uninstalls filter. /// Uninstalls filter.
fn uninstall_filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn uninstall_filter(&self, _: Params) -> Result<Value, Error>;
/// Should be used to convert object to io delegate. /// Should be used to convert object to io delegate.
fn to_delegate(self) -> IoDelegate<Self> { fn to_delegate(self) -> IoDelegate<Self> {

View File

@ -22,55 +22,55 @@ use jsonrpc_core::*;
pub trait Ethcore: Sized + Send + Sync + 'static { pub trait Ethcore: Sized + Send + Sync + 'static {
/// Sets new minimal gas price for mined blocks. /// Sets new minimal gas price for mined blocks.
fn set_min_gas_price(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn set_min_gas_price(&self, _: Params) -> Result<Value, Error>;
/// Sets new gas floor target for mined blocks. /// Sets new gas floor target for mined blocks.
fn set_gas_floor_target(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn set_gas_floor_target(&self, _: Params) -> Result<Value, Error>;
/// Sets new extra data for mined blocks. /// Sets new extra data for mined blocks.
fn set_extra_data(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn set_extra_data(&self, _: Params) -> Result<Value, Error>;
/// Sets new author for mined block. /// Sets new author for mined block.
fn set_author(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn set_author(&self, _: Params) -> Result<Value, Error>;
/// Sets the limits for transaction queue. /// Sets the limits for transaction queue.
fn set_transactions_limit(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn set_transactions_limit(&self, _: Params) -> Result<Value, Error>;
/// Returns current transactions limit. /// Returns current transactions limit.
fn transactions_limit(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn transactions_limit(&self, _: Params) -> Result<Value, Error>;
/// Returns mining extra data. /// Returns mining extra data.
fn extra_data(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn extra_data(&self, _: Params) -> Result<Value, Error>;
/// Returns mining gas floor target. /// Returns mining gas floor target.
fn gas_floor_target(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn gas_floor_target(&self, _: Params) -> Result<Value, Error>;
/// Returns minimal gas price for transaction to be included in queue. /// Returns minimal gas price for transaction to be included in queue.
fn min_gas_price(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn min_gas_price(&self, _: Params) -> Result<Value, Error>;
/// Returns latest logs /// Returns latest logs
fn dev_logs(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn dev_logs(&self, _: Params) -> Result<Value, Error>;
/// Returns logs levels /// Returns logs levels
fn dev_logs_levels(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn dev_logs_levels(&self, _: Params) -> Result<Value, Error>;
/// Returns chain name /// Returns chain name
fn net_chain(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn net_chain(&self, _: Params) -> Result<Value, Error>;
/// Returns max peers /// Returns max peers
fn net_max_peers(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn net_max_peers(&self, _: Params) -> Result<Value, Error>;
/// Returns network port /// Returns network port
fn net_port(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn net_port(&self, _: Params) -> Result<Value, Error>;
/// Returns rpc settings /// Returns rpc settings
fn rpc_settings(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn rpc_settings(&self, _: Params) -> Result<Value, Error>;
/// Returns node name /// Returns node name
fn node_name(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn node_name(&self, _: Params) -> Result<Value, Error>;
/// Returns default extra data /// Returns default extra data
fn default_extra_data(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn default_extra_data(&self, _: Params) -> Result<Value, Error>;
/// Should be used to convert object to io delegate. /// Should be used to convert object to io delegate.

View File

@ -16,10 +16,6 @@
//! Ethereum rpc interfaces. //! Ethereum rpc interfaces.
macro_rules! rpc_unimplemented {
() => (Err(Error::internal_error()))
}
pub mod web3; pub mod web3;
pub mod eth; pub mod eth;
pub mod net; pub mod net;

View File

@ -21,14 +21,14 @@ use jsonrpc_core::*;
/// Net rpc interface. /// Net rpc interface.
pub trait Net: Sized + Send + Sync + 'static { pub trait Net: Sized + Send + Sync + 'static {
/// Returns protocol version. /// Returns protocol version.
fn version(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn version(&self, _: Params) -> Result<Value, Error>;
/// Returns number of peers connected to node. /// Returns number of peers connected to node.
fn peer_count(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn peer_count(&self, _: Params) -> Result<Value, Error>;
/// Returns true if client is actively listening for network connections. /// Returns true if client is actively listening for network connections.
/// Otherwise false. /// Otherwise false.
fn is_listening(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn is_listening(&self, _: Params) -> Result<Value, Error>;
/// Should be used to convert object to io delegate. /// Should be used to convert object to io delegate.
fn to_delegate(self) -> IoDelegate<Self> { fn to_delegate(self) -> IoDelegate<Self> {

View File

@ -22,16 +22,16 @@ use jsonrpc_core::*;
pub trait Personal: Sized + Send + Sync + 'static { pub trait Personal: Sized + Send + Sync + 'static {
/// Lists all stored accounts /// Lists all stored accounts
fn accounts(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn accounts(&self, _: Params) -> Result<Value, Error>;
/// Creates new account (it becomes new current unlocked account) /// Creates new account (it becomes new current unlocked account)
fn new_account(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn new_account(&self, _: Params) -> Result<Value, Error>;
/// Unlocks specified account for use (can only be one unlocked account at one moment) /// Unlocks specified account for use (can only be one unlocked account at one moment)
fn unlock_account(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn unlock_account(&self, _: Params) -> Result<Value, Error>;
/// Sends transaction and signs it in single call. The account is not unlocked in such case. /// Sends transaction and signs it in single call. The account is not unlocked in such case.
fn sign_and_send_transaction(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn sign_and_send_transaction(&self, _: Params) -> Result<Value, Error>;
/// Should be used to convert object to io delegate. /// Should be used to convert object to io delegate.
fn to_delegate(self) -> IoDelegate<Self> { fn to_delegate(self) -> IoDelegate<Self> {

View File

@ -23,10 +23,10 @@ use jsonrpc_core::*;
pub trait Rpc: Sized + Send + Sync + 'static { pub trait Rpc: Sized + Send + Sync + 'static {
/// Returns supported modules for Geth 1.3.6 /// Returns supported modules for Geth 1.3.6
fn modules(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn modules(&self, _: Params) -> Result<Value, Error>;
/// Returns supported modules for Geth 1.4.0 /// Returns supported modules for Geth 1.4.0
fn rpc_modules(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn rpc_modules(&self, _: Params) -> Result<Value, Error>;
/// Should be used to convert object to io delegate. /// Should be used to convert object to io delegate.
fn to_delegate(self) -> IoDelegate<Self> { fn to_delegate(self) -> IoDelegate<Self> {

View File

@ -21,16 +21,16 @@ use jsonrpc_core::*;
/// Traces specific rpc interface. /// Traces specific rpc interface.
pub trait Traces: Sized + Send + Sync + 'static { pub trait Traces: Sized + Send + Sync + 'static {
/// Returns traces matching given filter. /// Returns traces matching given filter.
fn filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn filter(&self, _: Params) -> Result<Value, Error>;
/// Returns transaction trace at given index. /// Returns transaction trace at given index.
fn trace(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn trace(&self, _: Params) -> Result<Value, Error>;
/// Returns all traces of given transaction. /// Returns all traces of given transaction.
fn transaction_traces(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn transaction_traces(&self, _: Params) -> Result<Value, Error>;
/// Returns all traces produced at given block. /// Returns all traces produced at given block.
fn block_traces(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn block_traces(&self, _: Params) -> Result<Value, Error>;
/// Should be used to convert object to io delegate. /// Should be used to convert object to io delegate.
fn to_delegate(self) -> IoDelegate<Self> { fn to_delegate(self) -> IoDelegate<Self> {

View File

@ -21,10 +21,10 @@ use jsonrpc_core::*;
/// Web3 rpc interface. /// Web3 rpc interface.
pub trait Web3: Sized + Send + Sync + 'static { pub trait Web3: Sized + Send + Sync + 'static {
/// Returns current client version. /// Returns current client version.
fn client_version(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn client_version(&self, _: Params) -> Result<Value, Error>;
/// Returns sha3 of the given data /// Returns sha3 of the given data
fn sha3(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() } fn sha3(&self, _: Params) -> Result<Value, Error>;
/// Should be used to convert object to io delegate. /// Should be used to convert object to io delegate.
fn to_delegate(self) -> IoDelegate<Self> { fn to_delegate(self) -> IoDelegate<Self> {