Start stubbing out Signatures and other types required by RET, which …

…requires more fixed size BagOfBytes, introducing: Hex64Bytes, Hex65Bytes, Hex33Bytes, generated with macro.

src/core/error/common_error.rs

@@ -52,8 +52,8 @@ pub enum CommonError {
     #[error("String not hex {bad_value}")]
     StringNotHex { bad_value: String } = 10011,
 
-    #[error("Invalid byte count, expected 32, found: {bad_value}")]
-    InvalidByteCountExpected32 { bad_value: u64 } = 10012,
+    #[error("Invalid byte count, expected {expected}, found: {found}")]
+    InvalidByteCount { expected: u64, found: u64 } = 10012,
 
     #[error("Invalid BIP32 path '{bad_value}'.")]
     InvalidBIP32Path { bad_value: String } = 10013,

src/core/secure_random_bytes.rs

@@ -17,6 +17,13 @@ pub fn generate_32_bytes() -> Vec<u8> {
     generate_bytes::<32>()
 }
 
+/// Generates `64` random bytes using a cryptographically
+/// secure random generator and returns these bytes as
+/// a Vec<u8>.
+pub fn generate_64_bytes() -> Vec<u8> {
+    generate_bytes::<64>()
+}
+
 #[cfg(test)]
 mod tests {
     use std::collections::HashSet;

src/core/types/epoch.rs

@@ -0,0 +1,62 @@
+pub use crate::prelude::*;
+
+// use radix_engine_common::types::Epoch as ScryptoEpoch;
+
+// Generate the FfiConverter needed by UniFFI for newtype `Epoch`.
+uniffi::custom_newtype!(Epoch, u64);
+
+/// A type-safe consensus epoch number.
+#[derive(
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    Hash,
+    Ord,
+    PartialOrd,
+    derive_more::Display,
+    derive_more::Debug,
+)]
+pub struct Epoch(pub u64);
+
+impl From<u64> for Epoch {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+
+impl From<Epoch> for u64 {
+    fn from(value: Epoch) -> Self {
+        value.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::prelude::*;
+
+    #[test]
+    fn from_u64() {
+        let test =
+            |u: u64| assert_eq!(Into::<u64>::into(Into::<Epoch>::into(u)), u);
+        test(0);
+        test(1);
+        test(2);
+        test(1337);
+    }
+
+    #[test]
+    fn to_u64() {
+        let test = |u: u64| {
+            assert_eq!(
+                Into::<Epoch>::into(Into::<u64>::into(Into::<Epoch>::into(u)))
+                    .0,
+                u
+            )
+        };
+        test(0);
+        test(1);
+        test(2);
+        test(1337);
+    }
+}