Merge remote-tracking branch 'origin/master' into chain-storage

.circleci/config.yml

@@ -54,6 +54,9 @@ jobs:
             done
       - store_test_results:
           path: ~/test-results
+      - store_artifacts:
+          path: ~/test-results
+          destination: test_results
       - persist_to_workspace:
           root: "."
           paths:
@@ -80,6 +83,9 @@ jobs:
           command: cargo junit --name ~/test-results/${CIRCLE_JOB}/results.xml
       - store_test_results:
           path: ~/test-results
+      - store_artifacts:
+          path: ~/test-results
+          destination: test_results
   test_nightly:
     docker:
       - image: rustlang/rust:nightly
@@ -102,6 +108,9 @@ jobs:
           command: cargo junit --name ~/test-results/${CIRCLE_JOB}/results.xml
       - store_test_results:
           path: ~/test-results
+      - store_artifacts:
+          path: ~/test-results
+          destination: test_results
   coverage:
     docker:
       - image: ragnaroek/kcov:v33

Cargo.toml

@@ -5,6 +5,7 @@ members = [
     "chain-storage-sqlite",
     "chain-impl-mockchain",
     "cardano",
+    "network-grpc",
     "protocol",
     "protocol-tokio",
     "storage-units",

cardano/src/block/block.rs

@@ -80,6 +80,8 @@ pub enum BlockHeader {
     MainBlockHeader(normal::BlockHeader),
 }
 
+impl core::property::Header for BlockHeader {}
+
 /// BlockHeaders is a vector of block headers, as produced by
 /// MsgBlocks.
 #[derive(Debug, Clone)]
@@ -204,6 +206,8 @@ impl fmt::Display for Block {
 
 impl chain_core::property::Block for Block {
     type Id = HeaderHash;
+    type Date = BlockDate;
+    type Header = BlockHeader;
 
     fn id(&self) -> Self::Id {
         self.get_header().compute_hash()
@@ -213,21 +217,39 @@ impl chain_core::property::Block for Block {
         self.get_header().get_previous_header()
     }
 
-    type Date = BlockDate;
-
     fn date(&self) -> Self::Date {
-        self.get_header().get_blockdate()
+        match self {
+            Block::MainBlock(ref block) => block.header.consensus.slot_id.into(),
+            Block::BoundaryBlock(ref block) => block.header.consensus.epoch.into(),
+        }
+    }
+
+    fn header(&self) -> BlockHeader {
+        self.get_header()
     }
 }
 
-impl chain_core::property::Serializable for Block {
+impl core::property::HasTransaction<TxAux> for Block {
+    fn transactions<'a>(&'a self) -> std::slice::Iter<'a, TxAux> {
+        match self {
+            &Block::BoundaryBlock(_) => [].iter(),
+            &Block::MainBlock(ref blk) => blk.body.tx.iter(),
+        }
+    }
+}
+
+impl core::property::Serialize for Block {
     type Error = cbor_event::Error;
 
     fn serialize<W: std::io::Write>(&self, mut writer: W) -> Result<(), Self::Error> {
         let bytes = cbor!(self)?;
         writer.write(&bytes)?;
         Ok(())
     }
+}
+
+impl core::property::Deserialize for Block {
+    type Error = cbor_event::Error;
 
     fn deserialize<R: std::io::BufRead>(reader: R) -> Result<Self, Self::Error> {
         Deserialize::deserialize(&mut Deserializer::from(reader))

cardano/src/block/date.rs

@@ -1,5 +1,7 @@
 use super::types::{EpochId, EpochSlotId, SlotId};
 
+use chain_core::property;
+
 use std::{
     cmp::{Ord, Ordering},
     error::Error,
@@ -16,6 +18,9 @@ pub enum BlockDate {
     Boundary(EpochId),
     Normal(EpochSlotId),
 }
+
+impl property::BlockDate for BlockDate {}
+
 impl ::std::ops::Sub<BlockDate> for BlockDate {
     type Output = usize;
     fn sub(self, rhs: Self) -> Self::Output {

cardano/src/block/types.rs

@@ -1,5 +1,6 @@
 use super::normal::SscPayload;
 use cbor_event::{self, de::Deserializer, se::Serializer};
+use chain_core::property;
 use hash::Blake2b256;
 use util::try_from_slice::TryFromSlice;
 
@@ -47,6 +48,9 @@ impl HeaderHash {
         self.0.as_hash_bytes()
     }
 }
+
+impl property::BlockId for HeaderHash {}
+
 impl fmt::Display for HeaderHash {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Display::fmt(&self.0, f)

cardano/src/lib.rs

@@ -15,11 +15,14 @@
 //!
 #![cfg_attr(feature = "with-bench", feature(test))]
 
+extern crate chain_core;
+
 #[cfg(feature = "generic-serialization")]
 #[macro_use]
 extern crate serde_derive;
 #[cfg(feature = "generic-serialization")]
 extern crate serde;
+
 #[cfg(test)]
 extern crate serde_json;
 #[cfg(test)]

cardano/src/tx.rs

@@ -11,7 +11,15 @@ use std::{
     io::{BufRead, Write},
 };
 
-use hash::Blake2b256;
+use crate::{
+    address::{AddrType, Attributes, ExtendedAddr, SpendingData},
+    coin::{self, Coin},
+    config::ProtocolMagic,
+    hash::Blake2b256,
+    hdwallet::{Signature, XPrv, XPub, SIGNATURE_SIZE, XPUB_SIZE},
+    merkle, redeem,
+    tags::SigningTag,
+};
 
 use cbor_event::{self, de::Deserializer, se::Serializer};
 use config::ProtocolMagic;
@@ -29,6 +37,9 @@ use chain_core;
 // given Tx, or a hash of a redeem address.
 pub type TxId = Blake2b256;
 
+// FIXME: This is dodgy because TxId is not currently a dedicated type.
+impl property::TransactionId for TxId {}
+
 pub fn redeem_pubkey_to_txid(
     pubkey: &redeem::PublicKey,
     protocol_magic: ProtocolMagic,
@@ -624,7 +635,7 @@ impl cbor_event::de::Deserialize for TxProof {
     }
 }
 
-impl chain_core::property::Serializable for Tx {
+impl chain_core::property::Serialize for Tx {
     type Error = cbor_event::Error;
 
     fn serialize<W: std::io::Write>(&self, writer: W) -> Result<(), Self::Error> {
@@ -633,13 +644,18 @@ impl chain_core::property::Serializable for Tx {
         serializer.finalize();
         Ok(())
     }
+}
+
+impl chain_core::property::Deserialize for Tx {
+    type Error = cbor_event::Error;
 
     fn deserialize<R: std::io::BufRead>(reader: R) -> Result<Self, Self::Error> {
         let mut deserializer = cbor_event::de::Deserializer::from(reader);
         deserializer.deserialize::<Self>()
     }
 }
-impl chain_core::property::Serializable for TxAux {
+
+impl chain_core::property::Serialize for TxAux {
     type Error = cbor_event::Error;
 
     fn serialize<W: std::io::Write>(&self, writer: W) -> Result<(), Self::Error> {
@@ -648,6 +664,10 @@ impl chain_core::property::Serializable for TxAux {
         serializer.finalize();
         Ok(())
     }
+}
+
+impl chain_core::property::Deserialize for TxAux {
+    type Error = cbor_event::Error;
 
     fn deserialize<R: std::io::BufRead>(reader: R) -> Result<Self, Self::Error> {
         let mut deserializer = cbor_event::de::Deserializer::from(reader);

chain-core/src/property.rs

@@ -38,6 +38,29 @@
 use std::fmt::Debug;
 use std::hash::Hash;
 
+/// Trait identifying the block identifier type.
+pub trait BlockId: Eq + Ord + Clone + Debug + Hash + AsRef<[u8]> {
+    // FIXME: constant representing id length?
+
+    /// Construct a BlockId from a slice. FIXME: use TryFromSlice trait.
+    fn try_from_slice(slice: &[u8]) -> Option<Self>;
+}
+
+/// A trait representing block dates. Dates can be compared, ordered
+/// and serialized as integers.
+pub trait BlockDate: Eq + Ord + Clone {
+    fn serialize(&self) -> u64;
+    fn deserialize(n: u64) -> Self;
+}
+
+/// Trait identifying the transaction identifier type.
+pub trait TransactionId: Eq + Hash {}
+
+/// Trait identifying the block header type.
+pub trait Header {}
+
+impl Header for () {}
+
 /// Block property
 ///
 /// a block is part of a chain of block called Blockchain.
@@ -48,7 +71,7 @@ use std::hash::Hash;
 /// recent block to the furthest/oldest block.
 ///
 /// The Oldest block is called the Genesis Block.
-pub trait Block: Serializable {
+pub trait Block: Serialize + Deserialize {
     /// the Block identifier. It must be unique. This mean that
     /// 2 different blocks have 2 different identifiers.
     ///
@@ -62,6 +85,13 @@ pub trait Block: Serializable {
     /// identifying the position of a block in a given epoch or era.
     type Date: BlockDate;
 
+    /// The block header. If provided by the blockchain, the header
+    /// can be used to transmit block's metadata via a network protocol
+    /// or in other uses where the full content of the block is not desirable.
+    /// An implementation that does not feature headers can use the unit
+    /// type `()`.
+    type Header: Header;
+
     /// return the Block's identifier.
     fn id(&self) -> Self::Id;
 
@@ -71,34 +101,23 @@ pub trait Block: Serializable {
 
     /// get the block date of the block
     fn date(&self) -> Self::Date;
-}
-
-pub trait BlockId: Eq + Ord + Clone + Debug + Hash + AsRef<[u8]> {
-    // FIXME: constant representing id length?
 
-    /// Construct a BlockId from a slice. FIXME: use TryFromSlice trait.
-    fn try_from_slice(slice: &[u8]) -> Option<Self>;
-}
-
-/// A trait representing block dates. Dates can be compared, ordered
-/// and serialized as integers.
-pub trait BlockDate: Eq + Ord + Clone {
-    fn serialize(&self) -> u64;
-    fn deserialize(n: u64) -> Self;
+    /// Gets the block's header.
+    fn header(&self) -> Self::Header;
 }
 
 /// define a transaction within the blockchain. This transaction can be used
 /// for the UTxO model. However it can also be used for any other elements that
 /// the blockchain has (a transaction type to add Stacking Pools and so on...).
 ///
-pub trait Transaction: Serializable {
+pub trait Transaction: Serialize + Deserialize {
     /// the input type of the transaction (if none use `()`).
     type Input;
     /// the output type of the transaction (if none use `()`).
     type Output;
     /// a unique identifier of the transaction. For 2 different transactions
     /// we must have 2 different `Id` values.
-    type Id;
+    type Id: TransactionId;
 
     fn inputs<'a>(&'a self) -> std::slice::Iter<'a, Self::Input>;
     fn outputs<'a>(&'a self) -> std::slice::Iter<'a, Self::Output>;
@@ -213,15 +232,12 @@ pub trait LeaderSelection {
     fn is_leader_at(&self, date: <Self::Block as Block>::Date) -> Result<bool, Self::Error>;
 }
 
-/// Define that an object can be written in a `Write` object or read from the
-/// `Read` object.
-pub trait Serializable: Sized {
+/// Define that an object can be written to a `Write` object.
+pub trait Serialize {
     type Error: std::error::Error + From<std::io::Error>;
 
     fn serialize<W: std::io::Write>(&self, writer: W) -> Result<(), Self::Error>;
 
-    fn deserialize<R: std::io::BufRead>(reader: R) -> Result<Self, Self::Error>;
-
     /// Convenience method to serialize into a byte vector.
     fn serialize_as_vec(&self) -> Result<Vec<u8>, Self::Error> {
         let mut data = vec![];
@@ -230,23 +246,36 @@ pub trait Serializable: Sized {
     }
 }
 
+/// Define that an object can be read from a `Read` object.
+pub trait Deserialize: Sized {
+    type Error: std::error::Error + From<std::io::Error>;
+
+    fn deserialize<R: std::io::BufRead>(reader: R) -> Result<Self, Self::Error>;
+}
+
+impl<T: Serialize> Serialize for &T {
+    type Error = T::Error;
+
+    fn serialize<W: std::io::Write>(&self, writer: W) -> Result<(), T::Error> {
+        (**self).serialize(writer)
+    }
+}
+
 #[cfg(feature = "property-test-api")]
 pub mod testing {
     use super::*;
     use quickcheck::{Arbitrary, Gen};
-    use std::io::Cursor;
 
     /// test that any arbitrary given object can serialize and deserialize
     /// back into itself (i.e. it is a bijection,  or a one to one match
     /// between the serialized bytes and the object)
     pub fn serialization_bijection<T>(t: T) -> bool
     where
-        T: Arbitrary + Serializable + Eq,
+        T: Arbitrary + Serialize + Deserialize + Eq,
     {
         let mut vec = Vec::new();
         t.serialize(&mut vec).unwrap();
-        let cursor = Cursor::new(vec);
-        let decoded_t = <T as Serializable>::deserialize(cursor).unwrap();
+        let decoded_t = T::deserialize(&mut &vec[..]).unwrap();
         decoded_t == t
     }