Use timestamp to calc block time; Misc. review resp.

src/lib.rs

@@ -162,8 +162,8 @@ impl<T: Runtime> ClientBuilder<T> {
     }
 
     /// Set the mortal period. Must be set if `Metadata::derive_mortal_period` results in an error.
-    pub fn set_mortal_period(mut self, mortal_period: u64) -> Self {
-        self.mortal_period = Some(Some(mortal_period));
+    pub fn set_mortal_period(mut self, mortal_period: Option<u64>) -> Self {
+        self.mortal_period = Some(mortal_period);
         self
     }
 
@@ -193,7 +193,8 @@ impl<T: Runtime> ClientBuilder<T> {
         } else {
             match metadata.derive_mortal_period() {
                 Err(e) => {
-                    log::error!("`Metadata::derive_mortal_period` failed. Set `mortal_period` prior to invoking `Client::build`.");
+                    log::error!("{}", e);
+                    log::error!("`Metadata::derive_mortal_period` failed. You may need to set `mortal_period` prior to invoking `Client::build`");
                     return Err(e.into())
                 }
                 Ok(period) => Some(period),
@@ -318,7 +319,7 @@ impl<T: Runtime> Client<T> {
         &self.signed_options.mortal_period
     }
 
-    /// Set the mortal period for signed extrinsics
+    /// Set the mortal period
     pub fn set_mortal_period(mut self, mortal_period: Option<u64>) -> Self {
         self.signed_options.mortal_period = mortal_period;
         self

src/metadata.rs

@@ -79,9 +79,9 @@ pub enum MetadataError {
     /// Constant is not in metadata.
     #[error("Constant {0} not found")]
     ConstantNotFound(&'static str),
-    /// A value was 0 when a non-zero value was expected.
-    #[error("A value was unexpectedly 0: {0}")]
-    ZeroValue(&'static str),
+    /// Failed trying to derive mortal period
+    #[error("Failed trying to derive mortal period: {0}")]
+    MortalPeriodError(&'static str),
 }
 
 /// Runtime metadata.
@@ -180,12 +180,20 @@ impl Metadata {
             .and_then(|count| count.value::<u32>())
             .map(Into::into)?;
         let expected_block_time = self
-            .module("Babe")
-            .and_then(|babe| babe.constant("ExpectedBlockTime"))
-            .and_then(|e| e.value::<u64>())?;
+            .module("Timestamp")
+            .and_then(|babe| babe.constant("MinimumPeriod"))
+            .and_then(|e| e.value::<u64>())?
+            .checked_mul(2)
+            .ok_or(MetadataError::MortalPeriodError(
+                "Underflow or overflow attempting `TimeStamp::MinimumPeriod.checked_mul(2)`",
+            ))?;
 
         match expected_block_time {
-            0 => Err(MetadataError::ZeroValue("Babe::ExpectedBlockTime")),
+            0 => {
+                Err(MetadataError::MortalPeriodError(
+                    "`Babe::ExpectedBlockTime` was 0 when a value > 0 was expected",
+                ))
+            }
             expected_block_time => {
                 Ok((BASELINE_MORTAL_PERIOD / expected_block_time)
                     .next_power_of_two()