diff --git a/miner/src/miner.rs b/miner/src/miner.rs index 3860a79e6..fc63aec6c 100644 --- a/miner/src/miner.rs +++ b/miner/src/miner.rs @@ -395,6 +395,7 @@ impl MinerService for Miner { Err(ref e) => { trace!(target: "own_tx", "Failed to import transaction {:?} (hash: {:?})", e, hash); trace!(target: "own_tx", "Status: {:?}", transaction_queue.status()); + warn!(target: "own_tx", "Error importing transaction: {:?}", e); }, } import diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs index 7627dd61e..100770ae1 100644 --- a/rpc/src/v1/impls/eth.rs +++ b/rpc/src/v1/impls/eth.rs @@ -27,6 +27,7 @@ use jsonrpc_core::*; use util::numbers::*; use util::sha3::*; use util::rlp::{encode, decode, UntrustedRlp, View}; +use util::keys::store::AccountProvider; use ethcore::client::{BlockChainClient, BlockID, TransactionID, UncleID}; use ethcore::block::IsBlock; 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::helpers::{PollFilter, PollManager}; use v1::impls::{dispatch_transaction, sign_and_dispatch}; -use util::keys::store::AccountProvider; use serde; /// Eth rpc implementation. @@ -494,6 +494,12 @@ impl Eth for EthClient where }) } + fn sign(&self, params: Params) -> Result { + 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 { from_params::<(TransactionRequest, )>(params) .and_then(|(request, )| { @@ -542,6 +548,18 @@ impl Eth for EthClient where to_value(&r.map(|res| res.gas_used + res.refunded).unwrap_or(From::from(0))) }) } + + fn compile_lll(&self, _: Params) -> Result { + rpc_unimplemented!() + } + + fn compile_serpent(&self, _: Params) -> Result { + rpc_unimplemented!() + } + + fn compile_solidity(&self, _: Params) -> Result { + rpc_unimplemented!() + } } /// Eth filter rpc implementation. diff --git a/rpc/src/v1/impls/mod.rs b/rpc/src/v1/impls/mod.rs index b79772103..7ee8b8b8a 100644 --- a/rpc/src/v1/impls/mod.rs +++ b/rpc/src/v1/impls/mod.rs @@ -25,6 +25,10 @@ macro_rules! take_weak { } } +macro_rules! rpc_unimplemented { + () => (Err(Error::internal_error())) +} + mod web3; mod eth; mod net; @@ -55,22 +59,14 @@ fn dispatch_transaction(client: &C, miner: &M, signed_transaction: SignedT where C: BlockChainClient, M: MinerService { let hash = signed_transaction.hash(); - let import = { - miner.import_own_transaction(client, signed_transaction, |a: &Address| { - AccountDetails { - nonce: client.latest_nonce(&a), - balance: client.latest_balance(&a), - } - }) - }; - - match import { - Ok(_) => to_value(&hash), - Err(e) => { - warn!("Error sending transaction: {:?}", e); - to_value(&H256::zero()) + let import = miner.import_own_transaction(client, signed_transaction, |a: &Address| { + AccountDetails { + nonce: client.latest_nonce(&a), + balance: client.latest_balance(&a), } - } + }); + + to_value(&import.map(|_| hash).unwrap_or(H256::zero())) } fn sign_and_dispatch(client: &Weak, miner: &Weak, request: TransactionRequest, secret: H256) -> Result diff --git a/rpc/src/v1/tests/eth.rs b/rpc/src/v1/tests/eth.rs index eac5bafcb..80a856aca 100644 --- a/rpc/src/v1/tests/eth.rs +++ b/rpc/src/v1/tests/eth.rs @@ -27,7 +27,7 @@ use ethcore::transaction::{Transaction, Action}; use ethminer::{MinerService, ExternalMiner}; use devtools::RandomTempPath; use util::io::IoChannel; -use util::hash::{Address, FixedHash}; +use util::hash::Address; use util::numbers::{Uint, U256}; use util::keys::{AccountProvider, TestAccount, TestAccountProvider}; use jsonrpc_core::IoHandler; diff --git a/rpc/src/v1/tests/mocked/eth.rs b/rpc/src/v1/tests/mocked/eth.rs index 32a2cd99a..aa0955751 100644 --- a/rpc/src/v1/tests/mocked/eth.rs +++ b/rpc/src/v1/tests/mocked/eth.rs @@ -20,14 +20,16 @@ use std::sync::{Arc, RwLock}; use jsonrpc_core::IoHandler; use util::hash::{Address, H256, FixedHash}; 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::log_entry::{LocalizedLogEntry, LogEntry}; use ethcore::receipt::LocalizedReceipt; use ethcore::transaction::{Transaction, Action}; -use ethminer::ExternalMiner; +use ethminer::{ExternalMiner, MinerService}; +use ethsync::SyncState; use v1::{Eth, EthClient}; use v1::tests::helpers::{TestSyncProvider, Config, TestMinerService}; +use rustc_serialize::hex::ToHex; fn blockchain_client() -> Arc { let client = TestBlockChainClient::new(); @@ -92,9 +94,28 @@ fn rpc_eth_protocol_version() { } #[test] -#[ignore] 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] @@ -130,9 +151,47 @@ fn rpc_eth_submit_hashrate() { } #[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() { - 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] @@ -193,18 +252,22 @@ fn rpc_eth_balance() { assert_eq!(tester.io.handle_request(request), Some(response.to_owned())); } -#[ignore] //TODO: propert test #[test] fn rpc_eth_balance_pending() { let tester = EthTester::default(); + tester.client.set_balance(Address::from(1), U256::from(5)); let request = r#"{ "jsonrpc": "2.0", "method": "eth_getBalance", - "params": ["0x0000000000000000000000000000000000000001", "latest"], + "params": ["0x0000000000000000000000000000000000000001", "pending"], "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())); } @@ -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}"#; - 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()); @@ -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}"#; - assert_eq!(tester.io.handle_request(request.as_ref()), Some(response)); + assert_eq!(tester.io.handle_request(&request), Some(response)); } #[test] -#[ignore] 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] -#[ignore] -fn rpc_eth_sign() { - unimplemented!() + let t = Transaction { + nonce: U256::zero(), + gas_price: U256::from(0x9184e72a000u64), + 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] diff --git a/rpc/src/v1/traits/eth.rs b/rpc/src/v1/traits/eth.rs index a28f72c5c..1577053f4 100644 --- a/rpc/src/v1/traits/eth.rs +++ b/rpc/src/v1/traits/eth.rs @@ -21,115 +21,115 @@ use jsonrpc_core::*; /// Eth rpc interface. pub trait Eth: Sized + Send + Sync + 'static { /// Returns protocol version. - fn protocol_version(&self, _: Params) -> Result { rpc_unimplemented!() } + fn protocol_version(&self, _: Params) -> Result; /// Returns an object with data about the sync status or false. (wtf?) - fn syncing(&self, _: Params) -> Result { rpc_unimplemented!() } + fn syncing(&self, _: Params) -> Result; /// Returns the number of hashes per second that the node is mining with. - fn hashrate(&self, _: Params) -> Result { rpc_unimplemented!() } + fn hashrate(&self, _: Params) -> Result; /// Returns block author. - fn author(&self, _: Params) -> Result { rpc_unimplemented!() } + fn author(&self, _: Params) -> Result; /// Returns true if client is actively mining new blocks. - fn is_mining(&self, _: Params) -> Result { rpc_unimplemented!() } + fn is_mining(&self, _: Params) -> Result; /// Returns current gas_price. - fn gas_price(&self, _: Params) -> Result { rpc_unimplemented!() } + fn gas_price(&self, _: Params) -> Result; /// Returns accounts list. - fn accounts(&self, _: Params) -> Result { rpc_unimplemented!() } + fn accounts(&self, _: Params) -> Result; /// Returns highest block number. - fn block_number(&self, _: Params) -> Result { rpc_unimplemented!() } + fn block_number(&self, _: Params) -> Result; /// Returns balance of the given account. - fn balance(&self, _: Params) -> Result { rpc_unimplemented!() } + fn balance(&self, _: Params) -> Result; /// Returns content of the storage at given address. - fn storage_at(&self, _: Params) -> Result { rpc_unimplemented!() } + fn storage_at(&self, _: Params) -> Result; /// Returns block with given hash. - fn block_by_hash(&self, _: Params) -> Result { rpc_unimplemented!() } + fn block_by_hash(&self, _: Params) -> Result; /// Returns block with given number. - fn block_by_number(&self, _: Params) -> Result { rpc_unimplemented!() } + fn block_by_number(&self, _: Params) -> Result; /// Returns the number of transactions sent from given address at given time (block number). - fn transaction_count(&self, _: Params) -> Result { rpc_unimplemented!() } + fn transaction_count(&self, _: Params) -> Result; /// Returns the number of transactions in a block with given hash. - fn block_transaction_count_by_hash(&self, _: Params) -> Result { rpc_unimplemented!() } + fn block_transaction_count_by_hash(&self, _: Params) -> Result; /// Returns the number of transactions in a block with given block number. - fn block_transaction_count_by_number(&self, _: Params) -> Result { rpc_unimplemented!() } + fn block_transaction_count_by_number(&self, _: Params) -> Result; /// Returns the number of uncles in a block with given hash. - fn block_uncles_count_by_hash(&self, _: Params) -> Result { rpc_unimplemented!() } + fn block_uncles_count_by_hash(&self, _: Params) -> Result; /// Returns the number of uncles in a block with given block number. - fn block_uncles_count_by_number(&self, _: Params) -> Result { rpc_unimplemented!() } + fn block_uncles_count_by_number(&self, _: Params) -> Result; /// Returns the code at given address at given time (block number). - fn code_at(&self, _: Params) -> Result { rpc_unimplemented!() } + fn code_at(&self, _: Params) -> Result; /// Signs the data with given address signature. - fn sign(&self, _: Params) -> Result { rpc_unimplemented!() } + fn sign(&self, _: Params) -> Result; /// Sends transaction. - fn send_transaction(&self, _: Params) -> Result { rpc_unimplemented!() } + fn send_transaction(&self, _: Params) -> Result; /// Sends signed transaction. - fn send_raw_transaction(&self, _: Params) -> Result { rpc_unimplemented!() } + fn send_raw_transaction(&self, _: Params) -> Result; /// Call contract. - fn call(&self, _: Params) -> Result { rpc_unimplemented!() } + fn call(&self, _: Params) -> Result; /// Estimate gas needed for execution of given contract. - fn estimate_gas(&self, _: Params) -> Result { rpc_unimplemented!() } + fn estimate_gas(&self, _: Params) -> Result; /// Get transaction by it's hash. - fn transaction_by_hash(&self, _: Params) -> Result { rpc_unimplemented!() } + fn transaction_by_hash(&self, _: Params) -> Result; /// Returns transaction at given block hash and index. - fn transaction_by_block_hash_and_index(&self, _: Params) -> Result { rpc_unimplemented!() } + fn transaction_by_block_hash_and_index(&self, _: Params) -> Result; /// Returns transaction by given block number and index. - fn transaction_by_block_number_and_index(&self, _: Params) -> Result { rpc_unimplemented!() } + fn transaction_by_block_number_and_index(&self, _: Params) -> Result; /// Returns transaction receipt. - fn transaction_receipt(&self, _: Params) -> Result { rpc_unimplemented!() } + fn transaction_receipt(&self, _: Params) -> Result; /// Returns an uncles at given block and index. - fn uncle_by_block_hash_and_index(&self, _: Params) -> Result { rpc_unimplemented!() } + fn uncle_by_block_hash_and_index(&self, _: Params) -> Result; /// Returns an uncles at given block and index. - fn uncle_by_block_number_and_index(&self, _: Params) -> Result { rpc_unimplemented!() } + fn uncle_by_block_number_and_index(&self, _: Params) -> Result; /// Returns available compilers. - fn compilers(&self, _: Params) -> Result { rpc_unimplemented!() } + fn compilers(&self, _: Params) -> Result; /// Compiles lll code. - fn compile_lll(&self, _: Params) -> Result { rpc_unimplemented!() } + fn compile_lll(&self, _: Params) -> Result; /// Compiles solidity. - fn compile_solidity(&self, _: Params) -> Result { rpc_unimplemented!() } + fn compile_solidity(&self, _: Params) -> Result; /// Compiles serpent. - fn compile_serpent(&self, _: Params) -> Result { rpc_unimplemented!() } + fn compile_serpent(&self, _: Params) -> Result; /// Returns logs matching given filter object. - fn logs(&self, _: Params) -> Result { rpc_unimplemented!() } + fn logs(&self, _: Params) -> Result; /// Returns the hash of the current block, the seedHash, and the boundary condition to be met. - fn work(&self, _: Params) -> Result { rpc_unimplemented!() } + fn work(&self, _: Params) -> Result; /// Used for submitting a proof-of-work solution. - fn submit_work(&self, _: Params) -> Result { rpc_unimplemented!() } + fn submit_work(&self, _: Params) -> Result; /// Used for submitting mining hashrate. - fn submit_hashrate(&self, _: Params) -> Result { rpc_unimplemented!() } + fn submit_hashrate(&self, _: Params) -> Result; /// Should be used to convert object to io delegate. fn to_delegate(self) -> IoDelegate { @@ -179,22 +179,22 @@ pub trait Eth: Sized + Send + Sync + 'static { // TODO: do filters api properly pub trait EthFilter: Sized + Send + Sync + 'static { /// Returns id of new filter. - fn new_filter(&self, _: Params) -> Result { rpc_unimplemented!() } + fn new_filter(&self, _: Params) -> Result; /// Returns id of new block filter. - fn new_block_filter(&self, _: Params) -> Result { rpc_unimplemented!() } + fn new_block_filter(&self, _: Params) -> Result; /// Returns id of new block filter. - fn new_pending_transaction_filter(&self, _: Params) -> Result { rpc_unimplemented!() } + fn new_pending_transaction_filter(&self, _: Params) -> Result; /// Returns filter changes since last poll. - fn filter_changes(&self, _: Params) -> Result { rpc_unimplemented!() } + fn filter_changes(&self, _: Params) -> Result; /// Returns all logs matching given filter (in a range 'from' - 'to'). - fn filter_logs(&self, _: Params) -> Result { rpc_unimplemented!() } + fn filter_logs(&self, _: Params) -> Result; /// Uninstalls filter. - fn uninstall_filter(&self, _: Params) -> Result { rpc_unimplemented!() } + fn uninstall_filter(&self, _: Params) -> Result; /// Should be used to convert object to io delegate. fn to_delegate(self) -> IoDelegate { diff --git a/rpc/src/v1/traits/ethcore.rs b/rpc/src/v1/traits/ethcore.rs index 2a2159bd9..3646f6c5a 100644 --- a/rpc/src/v1/traits/ethcore.rs +++ b/rpc/src/v1/traits/ethcore.rs @@ -22,55 +22,55 @@ use jsonrpc_core::*; pub trait Ethcore: Sized + Send + Sync + 'static { /// Sets new minimal gas price for mined blocks. - fn set_min_gas_price(&self, _: Params) -> Result { rpc_unimplemented!() } + fn set_min_gas_price(&self, _: Params) -> Result; /// Sets new gas floor target for mined blocks. - fn set_gas_floor_target(&self, _: Params) -> Result { rpc_unimplemented!() } + fn set_gas_floor_target(&self, _: Params) -> Result; /// Sets new extra data for mined blocks. - fn set_extra_data(&self, _: Params) -> Result { rpc_unimplemented!() } + fn set_extra_data(&self, _: Params) -> Result; /// Sets new author for mined block. - fn set_author(&self, _: Params) -> Result { rpc_unimplemented!() } + fn set_author(&self, _: Params) -> Result; /// Sets the limits for transaction queue. - fn set_transactions_limit(&self, _: Params) -> Result { rpc_unimplemented!() } + fn set_transactions_limit(&self, _: Params) -> Result; /// Returns current transactions limit. - fn transactions_limit(&self, _: Params) -> Result { rpc_unimplemented!() } + fn transactions_limit(&self, _: Params) -> Result; /// Returns mining extra data. - fn extra_data(&self, _: Params) -> Result { rpc_unimplemented!() } + fn extra_data(&self, _: Params) -> Result; /// Returns mining gas floor target. - fn gas_floor_target(&self, _: Params) -> Result { rpc_unimplemented!() } + fn gas_floor_target(&self, _: Params) -> Result; /// Returns minimal gas price for transaction to be included in queue. - fn min_gas_price(&self, _: Params) -> Result { rpc_unimplemented!() } + fn min_gas_price(&self, _: Params) -> Result; /// Returns latest logs - fn dev_logs(&self, _: Params) -> Result { rpc_unimplemented!() } + fn dev_logs(&self, _: Params) -> Result; /// Returns logs levels - fn dev_logs_levels(&self, _: Params) -> Result { rpc_unimplemented!() } + fn dev_logs_levels(&self, _: Params) -> Result; /// Returns chain name - fn net_chain(&self, _: Params) -> Result { rpc_unimplemented!() } + fn net_chain(&self, _: Params) -> Result; /// Returns max peers - fn net_max_peers(&self, _: Params) -> Result { rpc_unimplemented!() } + fn net_max_peers(&self, _: Params) -> Result; /// Returns network port - fn net_port(&self, _: Params) -> Result { rpc_unimplemented!() } + fn net_port(&self, _: Params) -> Result; /// Returns rpc settings - fn rpc_settings(&self, _: Params) -> Result { rpc_unimplemented!() } + fn rpc_settings(&self, _: Params) -> Result; /// Returns node name - fn node_name(&self, _: Params) -> Result { rpc_unimplemented!() } + fn node_name(&self, _: Params) -> Result; /// Returns default extra data - fn default_extra_data(&self, _: Params) -> Result { rpc_unimplemented!() } + fn default_extra_data(&self, _: Params) -> Result; /// Should be used to convert object to io delegate. diff --git a/rpc/src/v1/traits/mod.rs b/rpc/src/v1/traits/mod.rs index bebf95bb7..0728fd06a 100644 --- a/rpc/src/v1/traits/mod.rs +++ b/rpc/src/v1/traits/mod.rs @@ -16,10 +16,6 @@ //! Ethereum rpc interfaces. -macro_rules! rpc_unimplemented { - () => (Err(Error::internal_error())) -} - pub mod web3; pub mod eth; pub mod net; diff --git a/rpc/src/v1/traits/net.rs b/rpc/src/v1/traits/net.rs index 732d6efb2..56fba3e32 100644 --- a/rpc/src/v1/traits/net.rs +++ b/rpc/src/v1/traits/net.rs @@ -21,14 +21,14 @@ use jsonrpc_core::*; /// Net rpc interface. pub trait Net: Sized + Send + Sync + 'static { /// Returns protocol version. - fn version(&self, _: Params) -> Result { rpc_unimplemented!() } + fn version(&self, _: Params) -> Result; /// Returns number of peers connected to node. - fn peer_count(&self, _: Params) -> Result { rpc_unimplemented!() } + fn peer_count(&self, _: Params) -> Result; /// Returns true if client is actively listening for network connections. /// Otherwise false. - fn is_listening(&self, _: Params) -> Result { rpc_unimplemented!() } + fn is_listening(&self, _: Params) -> Result; /// Should be used to convert object to io delegate. fn to_delegate(self) -> IoDelegate { diff --git a/rpc/src/v1/traits/personal.rs b/rpc/src/v1/traits/personal.rs index 0619d7ada..d66161c54 100644 --- a/rpc/src/v1/traits/personal.rs +++ b/rpc/src/v1/traits/personal.rs @@ -22,16 +22,16 @@ use jsonrpc_core::*; pub trait Personal: Sized + Send + Sync + 'static { /// Lists all stored accounts - fn accounts(&self, _: Params) -> Result { rpc_unimplemented!() } + fn accounts(&self, _: Params) -> Result; /// Creates new account (it becomes new current unlocked account) - fn new_account(&self, _: Params) -> Result { rpc_unimplemented!() } + fn new_account(&self, _: Params) -> Result; /// Unlocks specified account for use (can only be one unlocked account at one moment) - fn unlock_account(&self, _: Params) -> Result { rpc_unimplemented!() } + fn unlock_account(&self, _: Params) -> Result; /// Sends transaction and signs it in single call. The account is not unlocked in such case. - fn sign_and_send_transaction(&self, _: Params) -> Result { rpc_unimplemented!() } + fn sign_and_send_transaction(&self, _: Params) -> Result; /// Should be used to convert object to io delegate. fn to_delegate(self) -> IoDelegate { diff --git a/rpc/src/v1/traits/rpc.rs b/rpc/src/v1/traits/rpc.rs index 5c981c8a1..669d0d8c6 100644 --- a/rpc/src/v1/traits/rpc.rs +++ b/rpc/src/v1/traits/rpc.rs @@ -23,10 +23,10 @@ use jsonrpc_core::*; pub trait Rpc: Sized + Send + Sync + 'static { /// Returns supported modules for Geth 1.3.6 - fn modules(&self, _: Params) -> Result { rpc_unimplemented!() } + fn modules(&self, _: Params) -> Result; /// Returns supported modules for Geth 1.4.0 - fn rpc_modules(&self, _: Params) -> Result { rpc_unimplemented!() } + fn rpc_modules(&self, _: Params) -> Result; /// Should be used to convert object to io delegate. fn to_delegate(self) -> IoDelegate { diff --git a/rpc/src/v1/traits/traces.rs b/rpc/src/v1/traits/traces.rs index b42feede5..54d04b954 100644 --- a/rpc/src/v1/traits/traces.rs +++ b/rpc/src/v1/traits/traces.rs @@ -21,16 +21,16 @@ use jsonrpc_core::*; /// Traces specific rpc interface. pub trait Traces: Sized + Send + Sync + 'static { /// Returns traces matching given filter. - fn filter(&self, _: Params) -> Result { rpc_unimplemented!() } + fn filter(&self, _: Params) -> Result; /// Returns transaction trace at given index. - fn trace(&self, _: Params) -> Result { rpc_unimplemented!() } + fn trace(&self, _: Params) -> Result; /// Returns all traces of given transaction. - fn transaction_traces(&self, _: Params) -> Result { rpc_unimplemented!() } + fn transaction_traces(&self, _: Params) -> Result; /// Returns all traces produced at given block. - fn block_traces(&self, _: Params) -> Result { rpc_unimplemented!() } + fn block_traces(&self, _: Params) -> Result; /// Should be used to convert object to io delegate. fn to_delegate(self) -> IoDelegate { diff --git a/rpc/src/v1/traits/web3.rs b/rpc/src/v1/traits/web3.rs index c7b21a1a1..335911025 100644 --- a/rpc/src/v1/traits/web3.rs +++ b/rpc/src/v1/traits/web3.rs @@ -21,10 +21,10 @@ use jsonrpc_core::*; /// Web3 rpc interface. pub trait Web3: Sized + Send + Sync + 'static { /// Returns current client version. - fn client_version(&self, _: Params) -> Result { rpc_unimplemented!() } + fn client_version(&self, _: Params) -> Result; /// Returns sha3 of the given data - fn sha3(&self, _: Params) -> Result { rpc_unimplemented!() } + fn sha3(&self, _: Params) -> Result; /// Should be used to convert object to io delegate. fn to_delegate(self) -> IoDelegate {