Remove chain_getParcelInvoices and add chain_getParcelInvoice

Currently, chain_getParcelInvoices returns the transaction invoices that the parcel contains. It is because a parcel itself doesn't have an invoice. But the next patch will make some parcels contain an invoice instead of a transaction invoice. This patch changes the RPC to prepare the next patch.

Author: Seulgi Kim

core/src/block.rs

@@ -23,7 +23,7 @@ use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
 use trie::TrieFactory;
 use unexpected::Mismatch;
 
-use super::blockchain::ParcelInvoices;
+use super::blockchain::ParcelInvoice;
 use super::consensus::CodeChainEngine;
 use super::error::{BlockError, Error};
 use super::header::{Header, Seal};
@@ -73,7 +73,7 @@ pub struct ExecutedBlock {
  header: Header,
  state: State<StateDB>,
  parcels: Vec<SignedParcel>,
- invoices: Vec<ParcelInvoices>,
+ invoices: Vec<ParcelInvoice>,
  parcels_set: HashSet<H256>,
 }
 
@@ -356,7 +356,7 @@ pub trait IsBlock {
  }
 
  /// Get all information on receipts in this block.
- fn invoices(&self) -> &[ParcelInvoices] {
+ fn invoices(&self) -> &[ParcelInvoice] {
  &self.block().invoices
  }
 

core/src/blockchain/blockchain.rs

@@ -32,7 +32,7 @@ use super::super::views::{BlockView, HeaderView};
 use super::block_info::BlockLocation;
 use super::body_db::{BodyDB, BodyProvider};
 use super::extras::{
- BlockDetails, BlockInvoices, EpochTransitions, ParcelAddress, ParcelInvoices, TransactionAddress, EPOCH_KEY_PREFIX,
+ BlockDetails, BlockInvoices, EpochTransitions, ParcelAddress, ParcelInvoice, TransactionAddress, EPOCH_KEY_PREFIX,
 };
 use super::headerchain::{HeaderChain, HeaderProvider};
 use super::invoice_db::{InvoiceDB, InvoiceProvider};
@@ -96,7 +96,7 @@ impl BlockChain {
  /// Inserts the block into backing cache database.
  /// Expects the block to be valid and already verified.
  /// If the block is already known, does nothing.
- pub fn insert_block(&self, batch: &mut DBTransaction, bytes: &[u8], invoices: Vec<ParcelInvoices>) -> ImportRoute {
+ pub fn insert_block(&self, batch: &mut DBTransaction, bytes: &[u8], invoices: Vec<ParcelInvoice>) -> ImportRoute {
  // create views onto rlp
  let block = BlockView::new(bytes);
  let header = block.header_view();
@@ -427,8 +427,8 @@ impl InvoiceProvider for BlockChain {
  }
 
  /// Get parcel invoice.
- fn parcel_invoices(&self, address: &ParcelAddress) -> Option<ParcelInvoices> {
- self.invoice_db.parcel_invoices(address)
+ fn parcel_invoice(&self, address: &ParcelAddress) -> Option<ParcelInvoice> {
+ self.invoice_db.parcel_invoice(address)
  }
 }
 

core/src/blockchain/extras.rs

@@ -194,50 +194,68 @@ pub struct TransactionAddress {
 }
 
 
-#[derive(Clone, Debug, PartialEq, RlpEncodableWrapper, RlpDecodableWrapper)]
-pub struct ParcelInvoices {
- pub invoices: Vec<Invoice>,
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(untagged)]
+pub enum ParcelInvoice {
+ Single(Invoice),
+ Multiple(Vec<Invoice>),
 }
 
-impl ParcelInvoices {
+impl ParcelInvoice {
  pub fn new(invoices: Vec<Invoice>) -> Self {
- Self {
- invoices,
+ ParcelInvoice::Multiple(invoices)
+ }
+
+ pub fn iter<'a>(&'a self) -> Box<::std::iter::Iterator<Item = &'a Invoice> + 'a> {
+ match self {
+ ParcelInvoice::Single(invoice) => Box::new(::std::iter::once(invoice)),
+ ParcelInvoice::Multiple(invoices) => Box::new(invoices.iter()),
  }
  }
+}
 
- pub fn iter(&self) -> ::std::slice::Iter<Invoice> {
- self.invoices.iter()
+impl Encodable for ParcelInvoice {
+ fn rlp_append(&self, s: &mut RlpStream) {
+ match self {
+ ParcelInvoice::Single(invoice) => {
+ s.append(invoice);
+ }
+ ParcelInvoice::Multiple(invoices) => {
+ s.append_list(invoices);
+ }
+ }
  }
 }
 
-impl Into<Vec<Invoice>> for ParcelInvoices {
- fn into(self) -> Vec<Invoice> {
- self.invoices
+impl Decodable for ParcelInvoice {
+ fn decode(rlp: &UntrustedRlp) -> Result<ParcelInvoice, DecoderError> {
+ Ok(if rlp.is_list() {
+ ParcelInvoice::Multiple(rlp.as_list()?)
+ } else {
+ ParcelInvoice::Single(rlp.as_val()?)
+ })
  }
 }
 
-impl<'a> Into<&'a Vec<Invoice>> for &'a ParcelInvoices {
- fn into(self) -> &'a Vec<Invoice> {
- &self.invoices
+impl Into<Vec<Invoice>> for ParcelInvoice {
+ fn into(self) -> Vec<Invoice> {
+ self.iter().cloned().collect()
  }
 }
 
-impl From<Vec<Invoice>> for ParcelInvoices {
+impl From<Vec<Invoice>> for ParcelInvoice {
  fn from(invoices: Vec<Invoice>) -> Self {
- Self {
- invoices,
- }
+ ParcelInvoice::Multiple(invoices)
  }
 }
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct BlockInvoices {
- pub invoices: Vec<ParcelInvoices>,
+ pub invoices: Vec<ParcelInvoice>,
 }
 
 impl BlockInvoices {
- pub fn new(invoices: Vec<ParcelInvoices>) -> Self {
+ pub fn new(invoices: Vec<ParcelInvoice>) -> Self {
  Self {
  invoices,
  }
@@ -248,7 +266,7 @@ impl Decodable for BlockInvoices {
  fn decode(rlp: &UntrustedRlp) -> Result<Self, DecoderError> {
  let invoices = rlp.as_list::<Vec<u8>>()?
  .iter()
- .map(|parcel_invoices| UntrustedRlp::new(&parcel_invoices).as_val::<ParcelInvoices>())
+ .map(|parcel_invoice| UntrustedRlp::new(&parcel_invoice).as_val::<ParcelInvoice>())
  .collect::<Result<Vec<_>, _>>()?;
  Ok(Self {
  invoices,
@@ -279,7 +297,7 @@ mod tests {
  use rlp::{Encodable, UntrustedRlp};
 
  #[test]
- fn rlp_encode_and_decode_parcel_invoices() {
+ fn rlp_encode_and_decode_parcel_invoice() {
  let invoices = vec![
  Invoice::Success,
  Invoice::Success,
@@ -288,33 +306,100 @@ mod tests {
  Invoice::Success,
  Invoice::Success,
  ];
- let parcel_invoices = ParcelInvoices {
- invoices,
- };
- let rlp_encoded = parcel_invoices.rlp_bytes();
+ let parcel_invoice = ParcelInvoice::new(invoices);
+ let rlp_encoded = parcel_invoice.rlp_bytes();
  let stream = UntrustedRlp::new(&rlp_encoded);
  let rlp_decoded = stream.as_val();
- assert_eq!(Ok(parcel_invoices), rlp_decoded);
+ assert_eq!(Ok(parcel_invoice), rlp_decoded);
  }
 
  #[test]
  fn rlp_encode_and_decode_block_invoices() {
  let invoices = vec![Invoice::Success, Invoice::Failed];
- let parcel_invoices = ParcelInvoices {
- invoices,
- };
+ let parcel_invoice = ParcelInvoice::new(invoices);
  let block_invoices = BlockInvoices {
  invoices: vec![
- parcel_invoices.clone(),
- parcel_invoices.clone(),
- parcel_invoices.clone(),
- parcel_invoices.clone(),
+ parcel_invoice.clone(),
+ parcel_invoice.clone(),
+ parcel_invoice.clone(),
+ parcel_invoice.clone(),
  ],
  };
  let rlp_encoded = block_invoices.rlp_bytes();
- println!("..:{:?}:", rlp_encoded);
  let rlp = UntrustedRlp::new(&rlp_encoded);
  let rlp_decoded = rlp.as_val();
  assert_eq!(Ok(block_invoices), rlp_decoded);
  }
+
+ #[test]
+ fn encode_and_decode_single_success_parcel_invoice() {
+ let parcel_invoice = ParcelInvoice::Single(Invoice::Success);
+
+ let encoded = parcel_invoice.rlp_bytes();
+ let rlp = UntrustedRlp::new(&encoded);
+ let decoded = rlp.as_val();
+
+ assert_eq!(Ok(parcel_invoice), decoded);
+ }
+
+ #[test]
+ fn encode_and_decode_single_failed_parcel_invoice() {
+ let parcel_invoice = ParcelInvoice::Single(Invoice::Failed);
+
+ let encoded = parcel_invoice.rlp_bytes();
+ let rlp = UntrustedRlp::new(&encoded);
+ let decoded = rlp.as_val();
+
+ assert_eq!(Ok(parcel_invoice), decoded);
+ }
+
+ #[test]
+ fn encode_and_decode_empty_multiple_parcel_invoice() {
+ let parcel_invoice = ParcelInvoice::Multiple(vec![]);
+
+ let encoded = parcel_invoice.rlp_bytes();
+ let rlp = UntrustedRlp::new(&encoded);
+ let decoded = rlp.as_val();
+
+ assert_eq!(Ok(parcel_invoice), decoded);
+ }
+
+ #[test]
+ fn encode_and_decode_multiple_parcel_invoice_with_success() {
+ let parcel_invoice = ParcelInvoice::Multiple(vec![Invoice::Success]);
+
+ let encoded = parcel_invoice.rlp_bytes();
+ let rlp = UntrustedRlp::new(&encoded);
+ let decoded = rlp.as_val();
+
+ assert_eq!(Ok(parcel_invoice), decoded);
+ }
+
+ #[test]
+ fn encode_and_decode_multiple_parcel_invoice_with_failed() {
+ let parcel_invoice = ParcelInvoice::Multiple(vec![Invoice::Failed]);
+
+ let encoded = parcel_invoice.rlp_bytes();
+ let rlp = UntrustedRlp::new(&encoded);
+ let decoded = rlp.as_val();
+
+ assert_eq!(Ok(parcel_invoice), decoded);
+ }
+
+ #[test]
+ fn encode_and_decode_multiple_parcel_invoice() {
+ let parcel_invoice = ParcelInvoice::Multiple(vec![
+ Invoice::Failed,
+ Invoice::Success,
+ Invoice::Success,
+ Invoice::Success,
+ Invoice::Success,
+ ]);
+
+ let encoded = parcel_invoice.rlp_bytes();
+ let rlp = UntrustedRlp::new(&encoded);
+ let decoded = rlp.as_val();
+
+ assert_eq!(Ok(parcel_invoice), decoded);
+ }
 }

core/src/blockchain/invoice_db.rs

@@ -22,7 +22,7 @@ use kvdb::{DBTransaction, KeyValueDB};
 use parking_lot::RwLock;
 
 use super::super::db::{self, CacheUpdatePolicy, Readable, Writable};
-use super::extras::{BlockInvoices, ParcelAddress, ParcelInvoices};
+use super::extras::{BlockInvoices, ParcelAddress, ParcelInvoice};
 
 /// Structure providing fast access to blockchain data.
 ///
@@ -46,7 +46,7 @@ impl InvoiceDB {
  /// Inserts the block into backing cache database.
  /// Expects the block to be valid and already verified.
  /// If the block is already known, does nothing.
- pub fn insert_invoice(&self, batch: &mut DBTransaction, hash: &H256, invoices: Vec<ParcelInvoices>) {
+ pub fn insert_invoice(&self, batch: &mut DBTransaction, hash: &H256, invoices: Vec<ParcelInvoice>) {
  if self.is_known_invoice(hash) {
  return
  }
@@ -68,7 +68,7 @@ pub trait InvoiceProvider {
  fn block_invoices(&self, hash: &H256) -> Option<BlockInvoices>;
 
  /// Get parcel invoice.
- fn parcel_invoices(&self, address: &ParcelAddress) -> Option<ParcelInvoices>;
+ fn parcel_invoice(&self, address: &ParcelAddress) -> Option<ParcelInvoice>;
 }
 
 impl InvoiceProvider for InvoiceDB {
@@ -83,7 +83,7 @@ impl InvoiceProvider for InvoiceDB {
  }
 
  /// Get parcel invoice.
- fn parcel_invoices(&self, address: &ParcelAddress) -> Option<ParcelInvoices> {
+ fn parcel_invoice(&self, address: &ParcelAddress) -> Option<ParcelInvoice> {
  self.block_invoices(&address.block_hash)
  .and_then(|bi| bi.invoices.into_iter().nth(address.index))
  .map(Into::into)

core/src/blockchain/mod.rs

@@ -24,7 +24,7 @@ mod route;
 
 pub use self::blockchain::{BlockChain, BlockProvider};
 pub use self::body_db::BodyProvider;
-pub use self::extras::{BlockDetails, ParcelAddress, ParcelInvoices, TransactionAddress};
+pub use self::extras::{BlockDetails, ParcelAddress, ParcelInvoice, TransactionAddress};
 pub use self::headerchain::HeaderProvider;
 pub use self::invoice_db::InvoiceProvider;
 pub use self::route::ImportRoute;

core/src/client/client.rs

@@ -31,7 +31,7 @@ use trie::{TrieFactory, TrieSpec};
 use super::super::block::{enact, ClosedBlock, Drain, IsBlock, LockedBlock, OpenBlock, SealedBlock};
 use super::super::blockchain::{
  BlockChain, BlockProvider, BodyProvider, HeaderProvider, ImportRoute, InvoiceProvider, ParcelAddress,
- ParcelInvoices, TransactionAddress,
+ ParcelInvoice, TransactionAddress,
 };
 use super::super::consensus::epoch::Transition as EpochTransition;
 use super::super::consensus::CodeChainEngine;
@@ -383,18 +383,20 @@ impl BlockChainClient for Client {
  self.parcel_address(id).and_then(|address| chain.parcel(&address))
  }
 
- fn parcel_invoices(&self, id: ParcelId) -> Option<ParcelInvoices> {
+ fn parcel_invoice(&self, id: ParcelId) -> Option<ParcelInvoice> {
  let chain = self.chain.read();
- self.parcel_address(id).and_then(|address| chain.parcel_invoices(&address))
+ self.parcel_address(id).and_then(|address| chain.parcel_invoice(&address))
  }
 
  fn transaction_invoice(&self, id: TransactionId) -> Option<Invoice> {
  self.transaction_address(id).and_then(|transaction_address| {
  let parcel_address = transaction_address.parcel_address.clone();
  let parcel_id = parcel_address.into();
 
- self.parcel_invoices(parcel_id)
- .and_then(|invoices| invoices.invoices.get(transaction_address.index).cloned())
+ self.parcel_invoice(parcel_id).and_then(|parcel_invoice| match parcel_invoice {
+ ParcelInvoice::Multiple(invoices) => invoices.get(transaction_address.index).cloned(),
+ ParcelInvoice::Single(_) => None,
+ })
  })
  }
 }

core/src/client/mod.rs

@@ -31,7 +31,7 @@ use cnetwork::NodeId;
 use ctypes::{Address, Bytes, H256, Public, U256};
 
 use super::block::{ClosedBlock, OpenBlock, SealedBlock};
-use super::blockchain::ParcelInvoices;
+use super::blockchain::ParcelInvoice;
 use super::blockchain_info::BlockChainInfo;
 use super::encoded;
 use super::error::BlockImportError;
@@ -184,7 +184,7 @@ pub trait BlockChainClient: Sync + Send + AccountData + BlockChain + ImportBlock
  fn parcel(&self, id: ParcelId) -> Option<LocalizedParcel>;
 
  /// Get parcel invoice with given hash.
- fn parcel_invoices(&self, id: ParcelId) -> Option<ParcelInvoices>;
+ fn parcel_invoice(&self, id: ParcelId) -> Option<ParcelInvoice>;
 
  fn transaction_invoice(&self, id: TransactionId) -> Option<Invoice>;
 }

core/src/client/test_client.rs

@@ -46,7 +46,7 @@ use rlp::*;
 use trie;
 
 use super::super::block::{ClosedBlock, OpenBlock, SealedBlock};
-use super::super::blockchain::ParcelInvoices;
+use super::super::blockchain::ParcelInvoice;
 use super::super::blockchain_info::BlockChainInfo;
 use super::super::client::ImportResult;
 use super::super::client::{
@@ -507,7 +507,7 @@ impl BlockChainClient for TestBlockChainClient {
  unimplemented!();
  }
 
- fn parcel_invoices(&self, _id: ParcelId) -> Option<ParcelInvoices> {
+ fn parcel_invoice(&self, _id: ParcelId) -> Option<ParcelInvoice> {
  unimplemented!();
  }
 

core/src/lib.rs

@@ -86,6 +86,7 @@ mod tests;
 
 pub use account_provider::AccountProvider;
 pub use block::Block;
+pub use blockchain::ParcelInvoice;
 pub use client::{
  Balance, BlockChainClient, BlockInfo, ChainInfo, ChainNotify, Client, ImportBlock, Nonce, RegularKey,
  TestBlockChainClient,