Upstreaming OBFT stuff

cardano/src/block/block.rs

@@ -12,7 +12,8 @@ use super::super::config::ProtocolMagic;
 use super::boundary;
 use super::date::BlockDate;
 use super::normal;
-use super::types::{BlockVersion, HeaderHash};
+use super::types::{BlockVersion, ChainDifficulty, HeaderHash};
+use crate::tx::TxAux;
 use cbor_event::{self, de::Deserialize, de::Deserializer, se::Serializer};
 use chain_core;
 
@@ -204,6 +205,13 @@ impl<'a> BlockHeaderView<'a> {
     pub fn compute_hash(&self) -> HeaderHash {
         HeaderHash::new(&self.to_cbor())
     }
+
+    pub fn difficulty(&self) -> ChainDifficulty {
+        match self {
+            BlockHeaderView::Boundary(h) => h.consensus.chain_difficulty,
+            BlockHeaderView::Normal(h) => h.consensus.chain_difficulty,
+        }
+    }
 }
 
 impl BlockHeader {
@@ -248,6 +256,13 @@ impl BlockHeader {
         let v = cbor!(self).unwrap();
         HeaderHash::new(&v[..])
     }
+
+    pub fn difficulty(&self) -> ChainDifficulty {
+        match self {
+            BlockHeader::BoundaryBlockHeader(h) => h.consensus.chain_difficulty,
+            BlockHeader::MainBlockHeader(h) => h.consensus.chain_difficulty,
+        }
+    }
 }
 
 impl fmt::Display for BlockHeader {

cardano/src/block/chain_state.rs

@@ -18,6 +18,7 @@ pub struct ChainState {
     pub last_block: HeaderHash,
     pub last_date: Option<super::BlockDate>,
     pub last_boundary_block: Option<HeaderHash>,
+    pub last_boundary_block_epoch: Option<EpochId>,
     pub slot_leaders: Vec<address::StakeholderId>,
     pub utxos: Utxos,
     pub chain_length: u64,
@@ -62,6 +63,7 @@ impl ChainState {
             last_block: genesis_data.genesis_prev.clone(),
             last_date: None,
             last_boundary_block: None,
+            last_boundary_block_epoch: None,
             slot_leaders: vec![],
             utxos,
             chain_length: 0,

cardano/src/block/date.rs

@@ -65,6 +65,15 @@ impl BlockDate {
             &BlockDate::Normal(ref s) => s.epoch,
         }
     }
+    pub fn slotid(&self) -> Option<SlotId> {
+        match self {
+            &BlockDate::Boundary(_) => None,
+            &BlockDate::Normal(ref s) => Some(s.slotid),
+        }
+    }
+    pub fn epoch_and_slot(&self) -> (EpochId, Option<SlotId>) {
+        (self.get_epochid(), self.slotid())
+    }
     pub fn next(&self) -> Self {
         match self {
             &BlockDate::Boundary(e) => BlockDate::Normal(EpochSlotId {

cardano/src/block/types.rs

@@ -1,7 +1,7 @@
 use super::normal::SscPayload;
 use cbor_event::{self, de::Deserializer, se::Serializer};
 use hash::Blake2b256;
-use util::try_from_slice::TryFromSlice;
+use util::{hex, try_from_slice::TryFromSlice};
 
 use std::{
     fmt,
@@ -46,6 +46,10 @@ impl HeaderHash {
     pub fn as_hash_bytes(&self) -> &[u8; Blake2b256::HASH_SIZE] {
         self.0.as_hash_bytes()
     }
+
+    pub fn as_hex(&self) -> String {
+        hex::encode(self.as_hash_bytes())
+    }
 }
 
 impl fmt::Display for HeaderHash {
@@ -240,10 +244,35 @@ impl From<u64> for ChainDifficulty {
         ChainDifficulty(f)
     }
 }
+impl From<ChainDifficulty> for u64 {
+    fn from(cd: ChainDifficulty) -> Self {
+        cd.0
+    }
+}
 
 pub type EpochId = u64; // == EpochIndex
 pub type SlotId = u16; // == LocalSlotIndex
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct EpochFlags {
+    pub is_ebb: bool,
+}
+impl EpochFlags {
+    pub fn to_mask(&self) -> u8 {
+        let mut mask = 0u8;
+        if self.is_ebb {
+            mask |= 1;
+        }
+        return mask;
+    }
+
+    pub fn from_mask(mask: u8) -> EpochFlags {
+        EpochFlags {
+            is_ebb: (mask & 1) > 0,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "generic-serialization", derive(Serialize, Deserialize))]
 pub struct EpochSlotId {

cardano/src/block/verify_chain.rs

@@ -14,20 +14,34 @@ impl ChainState {
 
         add_error(&mut res, self.do_verify(block_hash, blk));
 
-        self.last_block = block_hash.clone();
-        self.last_date = Some(blk.header().blockdate());
-        // FIXME: count boundary blocks as part of the chain length?
-        self.chain_length += 1;
-
         match blk {
             Block::BoundaryBlock(blk) => {
                 self.last_boundary_block = Some(block_hash.clone());
+                self.last_boundary_block_epoch = Some(blk.header.consensus.epoch);
                 self.slot_leaders = blk.body.slot_leaders.clone();
             }
-
-            Block::MainBlock(_) => {}
+            Block::MainBlock(blk) => {
+                if self.last_boundary_block.is_some() {
+                    let block_epoch = blk.header.consensus.slot_id.epoch;
+                    let local_epoch = self.last_date.map(|d| d.get_epochid()).unwrap_or(0);
+                    if block_epoch > local_epoch {
+                        // We are in OBFT and switched epochs without EBB
+                        // Remove last boundary block state
+
+                        // TODO: should cleanup EBB state here?
+                        //self.last_boundary_block = None;
+                        //self.last_boundary_block_epoch = None;
+                        //self.slot_leaders = vec![];
+                    }
+                }
+            }
         };
 
+        self.last_block = block_hash.clone();
+        self.last_date = Some(blk.header().blockdate());
+        // FIXME: count boundary blocks as part of the chain length?
+        self.chain_length += 1;
+
         // Update the utxos from the transactions.
         if let Block::MainBlock(blk) = blk {
             for txaux in blk.body.tx.iter() {
@@ -65,17 +79,21 @@ impl ChainState {
                     return Err(Error::BlockDateInPast);
                 }
 
-                // If this is a genesis block, it should be the next
-                // epoch; otherwise it should be in the current epoch.
-                if date.get_epochid()
-                    != (last_date.get_epochid() + if date.is_boundary() { 1 } else { 0 })
-                {
-                    return Err(Error::BlockDateInFuture);
+                // New date should be this or next epoch, not further
+                if date.get_epochid() > last_date.get_epochid() {
+                    if date.get_epochid() > last_date.get_epochid() + 1 {
+                        return Err(Error::BlockDateInFuture);
+                    }
+                    // First next-epoch block supposed to be EBB,
+                    // unless we are in OBFT era
+                    if !date.is_boundary() {
+                        // TODO: validate we are in OBFT?
+                    }
                 }
             }
 
             None => {
-                if date != BlockDate::Boundary(0) {
+                if date.get_epochid() != 0 {
                     // FIXME: use epoch_start
                     return Err(Error::BlockDateInFuture);
                 }
@@ -87,19 +105,33 @@ impl ChainState {
             Block::BoundaryBlock(_) => {}
 
             Block::MainBlock(blk) => {
-                let slot_id = blk.header.consensus.slot_id.slotid as usize;
+                let epoch_id = blk.header.consensus.slot_id.epoch;
+                let epoch_with_ebb = match &self.last_boundary_block_epoch {
+                    Some(last_ebb_epoch) => epoch_id == *last_ebb_epoch,
+                    _ => false,
+                };
 
-                if slot_id >= self.slot_leaders.len() {
-                    return Err(Error::NonExistentSlot);
-                }
+                if epoch_with_ebb {
+                    // If epoch contains EBB - validate block using the leader-list
+
+                    let slot_id = blk.header.consensus.slot_id.slotid as usize;
+
+                    if slot_id >= self.slot_leaders.len() {
+                        return Err(Error::NonExistentSlot);
+                    }
+
+                    let slot_leader = &self.slot_leaders[slot_id];
 
-                let slot_leader = &self.slot_leaders[slot_id];
+                    // Note: the block signature was already checked in
+                    // verify_block, so here we only check the leader key
+                    // against the genesis block.
+                    if slot_leader != &address::StakeholderId::new(&blk.header.consensus.leader_key)
+                    {
+                        return Err(Error::WrongSlotLeader);
+                    }
+                } else {
 
-                // Note: the block signature was already checked in
-                // verify_block, so here we only check the leader key
-                // against the genesis block.
-                if slot_leader != &address::StakeholderId::new(&blk.header.consensus.leader_key) {
-                    return Err(Error::WrongSlotLeader);
+                    // TODO: validate OBFT leader
                 }
             }
         };