uncle as rlp in the api

ethcore/src/client/client.rs

@@ -22,7 +22,7 @@ use util::*;
 use util::panics::*;
 use views::BlockView;
 use error::{Error, ImportError, ExecutionError, BlockError, ImportResult};
-use header::{BlockNumber, Header};
+use header::{BlockNumber};
 use state::State;
 use spec::Spec;
 use engine::Engine;
@@ -50,6 +50,7 @@ pub use types::blockchain_info::BlockChainInfo;
 pub use types::block_status::BlockStatus;
 use evm::Factory as EvmFactory;
 use miner::{Miner, MinerService, TransactionImportResult, AccountDetails};
+use basic_types::*;
 
 const MAX_TX_QUEUE_SIZE: usize = 4096;
 
@@ -579,9 +580,9 @@ impl BlockChainClient for Client {
 		self.transaction_address(id).and_then(|address| self.chain.transaction(&address))
 	}
 
-	fn uncle(&self, id: UncleID) -> Option<Header> {
-		let index = id.1;
-		self.block(id.0).and_then(|block| BlockView::new(&block).uncle_at(index))
+	fn uncle(&self, id: UncleID) -> Option<Bytes> {
+		let index = id.position;
+		self.block(id.block).and_then(|block| BlockView::new(&block).uncle_at(index).and_then(|u| Some(u.rlp(Seal::With))))
 	}
 
 	fn transaction_receipt(&self, id: TransactionID) -> Option<LocalizedReceipt> {

ethcore/src/client/mod.rs

@@ -38,7 +38,7 @@ use util::Itertools;
 use blockchain::TreeRoute;
 use block_queue::BlockQueueInfo;
 use block::{OpenBlock, SealedBlock};
-use header::{BlockNumber, Header};
+use header::{BlockNumber};
 use transaction::{LocalizedTransaction, SignedTransaction};
 use log_entry::LocalizedLogEntry;
 use filter::Filter;
@@ -126,7 +126,7 @@ pub trait BlockChainClient : Sync + Send {
 	fn transaction(&self, id: TransactionID) -> Option<LocalizedTransaction>;
 
 	/// Get uncle with given id.
-	fn uncle(&self, id: UncleID) -> Option<Header>;
+	fn uncle(&self, id: UncleID) -> Option<Bytes>;
 
 	/// Get transaction receipt with given hash.
 	fn transaction_receipt(&self, id: TransactionID) -> Option<LocalizedReceipt>;

ethcore/src/client/test_client.rs

@@ -298,7 +298,7 @@ impl BlockChainClient for TestBlockChainClient {
 		unimplemented!();
 	}
 
-	fn uncle(&self, _id: UncleID) -> Option<BlockHeader> {
+	fn uncle(&self, _id: UncleID) -> Option<Bytes> {
 		unimplemented!();
 	}
 

ethcore/src/types/ids.rs

@@ -55,10 +55,10 @@ pub struct TraceId {
 }
 
 /// Uniquely identifies Uncle.
-#[derive(Debug)]
-pub struct UncleID (
+#[derive(Debug, Binary)]
+pub struct UncleID {
 	/// Block id.
-	pub BlockID,
+	pub block: BlockID,
 	/// Position in block.
-	pub usize
-);
+	pub position: usize
+}

rpc/src/v1/impls/eth.rs

@@ -41,6 +41,7 @@ use v1::traits::Eth;
 use v1::types::{Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo, Transaction, CallRequest, OptionalValue, Index, Filter, Log, Receipt};
 use v1::impls::{default_gas_price, dispatch_transaction, error_codes};
 use serde;
+use ethcore::header::Header as BlockHeader;
 
 /// Eth rpc implementation.
 pub struct EthClient<C, S, M, EM> where
@@ -126,8 +127,16 @@ impl<C, S, M, EM> EthClient<C, S, M, EM> where
 
 	fn uncle(&self, id: UncleID) -> Result<Value, Error> {
 		let client = take_weak!(self.client);
-		match client.uncle(id).and_then(|u| client.block_total_difficulty(BlockID::Hash(u.parent_hash().clone())).map(|diff| (diff, u))) {
-			Some((parent_difficulty, uncle)) => {
+
+		let uncle: BlockHeader = match client.uncle(id) {
+			Some(rlp) => decode(&rlp),
+			None => { return Ok(Value::Null); }
+		};
+		let parent_difficulty = match client.block_total_difficulty(BlockID::Hash(uncle.parent_hash().clone())) {
+			Some(difficulty) => difficulty,
+			None => { return Ok(Value::Null); }
+		};
+
 		let block = Block {
 			hash: OptionalValue::Value(uncle.hash()),
 			parent_hash: uncle.parent_hash,
@@ -150,9 +159,6 @@ impl<C, S, M, EM> EthClient<C, S, M, EM> where
 			transactions: BlockTransactions::Hashes(vec![]),
 		};
 		to_value(&block)
-			},
-			None => Ok(Value::Null)
-		}
 	}
 
 	fn sign_call(&self, request: CallRequest) -> Result<SignedTransaction, Error> {
@@ -435,12 +441,12 @@ impl<C, S, M, EM> Eth for EthClient<C, S, M, EM> where
 
 	fn uncle_by_block_hash_and_index(&self, params: Params) -> Result<Value, Error> {
 		from_params::<(H256, Index)>(params)
-			.and_then(|(hash, index)| self.uncle(UncleID(BlockID::Hash(hash), index.value())))
+			.and_then(|(hash, index)| self.uncle(UncleID { block: BlockID::Hash(hash), position: index.value() }))
 	}
 
 	fn uncle_by_block_number_and_index(&self, params: Params) -> Result<Value, Error> {
 		from_params::<(BlockNumber, Index)>(params)
-			.and_then(|(number, index)| self.uncle(UncleID(number.into(), index.value())))
+			.and_then(|(number, index)| self.uncle(UncleID { block: number.into(), position: index.value() }))
 	}
 
 	fn compilers(&self, params: Params) -> Result<Value, Error> {