Move src/ into core/src. Top-level crate is now called solana-workspace

core/src/poh.rs

@@ -0,0 +1,194 @@
+//! The `Poh` module provhashes an object for generating a Proof of History.
+//! It records Hashes items on behalf of its users.
+use solana_sdk::hash::{hash, hashv, Hash};
+
+pub struct Poh {
+    pub hash: Hash,
+    num_hashes: u64,
+    pub tick_height: u64,
+}
+
+#[derive(Debug)]
+pub struct PohEntry {
+    pub tick_height: u64,
+    pub num_hashes: u64,
+    pub hash: Hash,
+    pub mixin: Option<Hash>,
+}
+
+impl Poh {
+    pub fn new(hash: Hash, tick_height: u64) -> Self {
+        Poh {
+            num_hashes: 0,
+            hash,
+            tick_height,
+        }
+    }
+
+    pub fn hash(&mut self) {
+        self.hash = hash(&self.hash.as_ref());
+        self.num_hashes += 1;
+    }
+
+    pub fn record(&mut self, mixin: Hash) -> PohEntry {
+        self.hash = hashv(&[&self.hash.as_ref(), &mixin.as_ref()]);
+
+        let num_hashes = self.num_hashes + 1;
+        self.num_hashes = 0;
+
+        PohEntry {
+            tick_height: self.tick_height,
+            num_hashes,
+            hash: self.hash,
+            mixin: Some(mixin),
+        }
+    }
+
+    // emissions of Ticks (i.e. PohEntries without a mixin) allows
+    //  valhashators to parallelize the work of catching up
+    pub fn tick(&mut self) -> PohEntry {
+        self.hash();
+
+        let num_hashes = self.num_hashes;
+        self.num_hashes = 0;
+        self.tick_height += 1;
+
+        PohEntry {
+            tick_height: self.tick_height,
+            num_hashes,
+            hash: self.hash,
+            mixin: None,
+        }
+    }
+}
+
+#[cfg(test)]
+pub fn verify(initial_hash: Hash, entries: &[PohEntry]) -> bool {
+    let mut current_hash = initial_hash;
+
+    for entry in entries {
+        assert!(entry.num_hashes != 0);
+
+        for _ in 1..entry.num_hashes {
+            current_hash = hash(&current_hash.as_ref());
+        }
+        current_hash = match entry.mixin {
+            Some(mixin) => hashv(&[&current_hash.as_ref(), &mixin.as_ref()]),
+            None => hash(&current_hash.as_ref()),
+        };
+        if current_hash != entry.hash {
+            return false;
+        }
+    }
+
+    true
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::poh::{verify, Poh, PohEntry};
+    use solana_sdk::hash::{hash, hashv, Hash};
+
+    #[test]
+    fn test_poh_verify() {
+        let zero = Hash::default();
+        let one = hash(&zero.as_ref());
+        let two = hash(&one.as_ref());
+        let one_with_zero = hashv(&[&zero.as_ref(), &zero.as_ref()]);
+
+        let mut poh = Poh::new(zero, 0);
+        assert_eq!(
+            verify(
+                zero,
+                &[poh.tick(), poh.record(zero), poh.record(zero), poh.tick(),],
+            ),
+            true
+        );
+
+        assert_eq!(
+            verify(
+                zero,
+                &[PohEntry {
+                    tick_height: 0,
+                    num_hashes: 1,
+                    hash: one,
+                    mixin: None,
+                }],
+            ),
+            true
+        );
+        assert_eq!(
+            verify(
+                zero,
+                &[PohEntry {
+                    tick_height: 0,
+                    num_hashes: 2,
+                    hash: two,
+                    mixin: None,
+                }]
+            ),
+            true
+        );
+
+        assert_eq!(
+            verify(
+                zero,
+                &[PohEntry {
+                    tick_height: 0,
+                    num_hashes: 1,
+                    hash: one_with_zero,
+                    mixin: Some(zero),
+                }]
+            ),
+            true
+        );
+        assert_eq!(
+            verify(
+                zero,
+                &[PohEntry {
+                    tick_height: 0,
+                    num_hashes: 1,
+                    hash: zero,
+                    mixin: None
+                }]
+            ),
+            false
+        );
+
+        assert_eq!(
+            verify(
+                zero,
+                &[
+                    PohEntry {
+                        tick_height: 0,
+                        num_hashes: 1,
+                        hash: one_with_zero,
+                        mixin: Some(zero),
+                    },
+                    PohEntry {
+                        tick_height: 0,
+                        num_hashes: 1,
+                        hash: hash(&one_with_zero.as_ref()),
+                        mixin: None
+                    },
+                ]
+            ),
+            true
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_poh_verify_assert() {
+        verify(
+            Hash::default(),
+            &[PohEntry {
+                tick_height: 0,
+                num_hashes: 0,
+                hash: Hash::default(),
+                mixin: None,
+            }],
+        );
+    }
+
+}