use blocktime and fix tests

Author: mangas

chain/ethereum/src/chain.rs

@@ -1131,6 +1131,9 @@ pub struct FirehoseMapper {
 impl BlockStreamMapper<Chain> for FirehoseMapper {
     fn decode_block(
         &self,
+        // We share the trait with substreams but for firehose the timestamp
+        // is in the block header so we don't need to use it here.
+        _timestamp: BlockTime,
         output: Option<&[u8]>,
     ) -> Result<Option<BlockFinality>, BlockStreamError> {
         let block = match output {
@@ -1199,12 +1202,19 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
         // Check about adding basic information about the block in the firehose::Response or maybe
         // define a slimmed down stuct that would decode only a few fields and ignore all the rest.
         let block = codec::Block::decode(any_block.value.as_ref())?;
+        let timestamp = block
+            .header()
+            .timestamp
+            .map(|ts| BlockTime::since_epoch(ts.seconds, ts.nanos as u32))
+            .unwrap_or_default();
 
         use firehose::ForkStep::*;
         match step {
             StepNew => {
                 // unwrap: Input cannot be None so output will be error or block.
-                let block = self.decode_block(Some(any_block.value.as_ref()))?.unwrap();
+                let block = self
+                    .decode_block(timestamp, Some(any_block.value.as_ref()))?
+                    .unwrap();
                 let block_with_triggers = self.block_with_triggers(logger, block).await?;
 
                 Ok(BlockStreamEvent::ProcessBlock(

chain/near/src/chain.rs

@@ -3,8 +3,8 @@ use graph::blockchain::client::ChainClient;
 use graph::blockchain::firehose_block_ingestor::FirehoseBlockIngestor;
 use graph::blockchain::substreams_block_stream::SubstreamsBlockStream;
 use graph::blockchain::{
-    BasicBlockchainBuilder, BlockIngestor, BlockchainBuilder, BlockchainKind, NoopDecoderHook,
-    NoopRuntimeAdapter, Trigger, TriggerFilterWrapper,
+    BasicBlockchainBuilder, BlockIngestor, BlockTime, BlockchainBuilder, BlockchainKind,
+    NoopDecoderHook, NoopRuntimeAdapter, Trigger, TriggerFilterWrapper,
 };
 use graph::cheap_clone::CheapClone;
 use graph::components::network_provider::ChainName;
@@ -432,6 +432,7 @@ pub struct FirehoseMapper {
 impl BlockStreamMapper<Chain> for FirehoseMapper {
     fn decode_block(
         &self,
+        _timestamp: BlockTime,
         output: Option<&[u8]>,
     ) -> Result<Option<codec::Block>, BlockStreamError> {
         let block = match output {
@@ -528,7 +529,10 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
         // Check about adding basic information about the block in the bstream::BlockResponseV2 or maybe
         // define a slimmed down stuct that would decode only a few fields and ignore all the rest.
         // unwrap: Input cannot be None so output will be error or block.
-        let block = self.decode_block(Some(any_block.value.as_ref()))?.unwrap();
+        let block = self
+            // the block time is inside the block.
+            .decode_block(BlockTime::MIN, Some(any_block.value.as_ref()))?
+            .unwrap();
 
         use ForkStep::*;
         match step {

chain/substreams/src/chain.rs

@@ -43,6 +43,7 @@ pub enum ParsedChanges {
 pub struct Block {
     pub hash: BlockHash,
     pub number: BlockNumber,
+    pub timestamp: BlockTime,
     pub changes: EntityChanges,
     pub parsed_changes: Vec<ParsedChanges>,
 }
@@ -60,7 +61,7 @@ impl blockchain::Block for Block {
     }
 
     fn timestamp(&self) -> BlockTime {
-        BlockTime::NONE
+        self.timestamp
     }
 }
 

chain/substreams/src/mapper.rs

@@ -32,6 +32,7 @@ pub struct WasmBlockMapper {
 impl BlockStreamMapper<Chain> for WasmBlockMapper {
     fn decode_block(
         &self,
+        _timestamp: BlockTime,
         _output: Option<&[u8]>,
     ) -> Result<Option<crate::Block>, BlockStreamError> {
         unreachable!("WasmBlockMapper does not do block decoding")
@@ -104,7 +105,11 @@ pub struct Mapper {
 
 #[async_trait]
 impl BlockStreamMapper<Chain> for Mapper {
-    fn decode_block(&self, output: Option<&[u8]>) -> Result<Option<Block>, BlockStreamError> {
+    fn decode_block(
+        &self,
+        timestamp: BlockTime,
+        output: Option<&[u8]>,
+    ) -> Result<Option<Block>, BlockStreamError> {
         let changes: EntityChanges = match output {
             Some(msg) => Message::decode(msg).map_err(SubstreamsError::DecodingError)?,
             None => EntityChanges {
@@ -125,6 +130,7 @@ impl BlockStreamMapper<Chain> for Mapper {
             number,
             changes,
             parsed_changes,
+            timestamp,
         };
 
         Ok(Some(block))
@@ -152,9 +158,13 @@ impl BlockStreamMapper<Chain> for Mapper {
     ) -> Result<BlockStreamEvent<Chain>, BlockStreamError> {
         let block_number: BlockNumber = clock.number.try_into().map_err(Error::from)?;
         let block_hash = clock.id.as_bytes().to_vec().into();
+        let timestamp = clock
+            .timestamp
+            .map(|ts| BlockTime::since_epoch(ts.seconds, ts.nanos as u32))
+            .unwrap_or_default();
 
         let block = self
-            .decode_block(Some(&block))?
+            .decode_block(timestamp, Some(&block))?
             .ok_or_else(|| anyhow!("expected block to not be empty"))?;
 
         let block = self.block_with_triggers(logger, block).await.map(|bt| {

graph/src/blockchain/block_stream.rs

@@ -685,7 +685,11 @@ pub trait FirehoseMapper<C: Blockchain>: Send + Sync {
 
 #[async_trait]
 pub trait BlockStreamMapper<C: Blockchain>: Send + Sync {
-    fn decode_block(&self, output: Option<&[u8]>) -> Result<Option<C::Block>, BlockStreamError>;
+    fn decode_block(
+        &self,
+        timestamp: BlockTime,
+        output: Option<&[u8]>,
+    ) -> Result<Option<C::Block>, BlockStreamError>;
 
     async fn block_with_triggers(
         &self,

graph/src/blockchain/types.rs

@@ -1,4 +1,5 @@
 use anyhow::anyhow;
+use chrono::DateTime;
 use diesel::deserialize::FromSql;
 use diesel::pg::Pg;
 use diesel::serialize::{Output, ToSql};
@@ -7,6 +8,7 @@ use diesel::sql_types::{Bytea, Nullable, Text};
 use diesel_derives::{AsExpression, FromSqlRow};
 use serde::{Deserialize, Deserializer};
 use std::convert::TryFrom;
+use std::num::ParseIntError;
 use std::time::Duration;
 use std::{fmt, str::FromStr};
 use web3::types::{Block, H256, U256, U64};
@@ -16,9 +18,9 @@ use crate::components::store::BlockNumber;
 use crate::data::graphql::IntoValue;
 use crate::data::store::scalar::Timestamp;
 use crate::derive::CheapClone;
-use crate::object;
 use crate::prelude::{r, Value};
 use crate::util::stable_hash_glue::{impl_stable_hash, AsBytes};
+use crate::{bail, object};
 
 /// A simple marker for byte arrays that are really block hashes
 #[derive(Clone, Default, PartialEq, Eq, Hash, FromSqlRow, AsExpression)]
@@ -477,10 +479,7 @@ impl TryFrom<(Option<H256>, Option<U64>, H256, U256)> for ExtendedBlockPtr {
         let block_number =
             i32::try_from(number).map_err(|_| anyhow!("Block number out of range"))?;
 
-        // Convert `U256` to `BlockTime`
-        let secs =
-            i64::try_from(timestamp_u256).map_err(|_| anyhow!("Timestamp out of range for i64"))?;
-        let block_time = BlockTime::since_epoch(secs, 0);
+        let block_time = BlockTime::try_from(timestamp_u256)?;
 
         Ok(ExtendedBlockPtr {
             hash: hash.into(),
@@ -497,16 +496,13 @@ impl TryFrom<(H256, i32, H256, U256)> for ExtendedBlockPtr {
     fn try_from(tuple: (H256, i32, H256, U256)) -> Result<Self, Self::Error> {
         let (hash, block_number, parent_hash, timestamp_u256) = tuple;
 
-        // Convert `U256` to `BlockTime`
-        let secs =
-            i64::try_from(timestamp_u256).map_err(|_| anyhow!("Timestamp out of range for i64"))?;
-        let block_time = BlockTime::since_epoch(secs, 0);
+        let timestamp = BlockTime::try_from(timestamp_u256)?;
 
         Ok(ExtendedBlockPtr {
             hash: hash.into(),
             number: block_number,
             parent_hash: parent_hash.into(),
-            timestamp: block_time,
+            timestamp,
         })
     }
 }
@@ -562,14 +558,67 @@ impl fmt::Display for ChainIdentifier {
 #[diesel(sql_type = Timestamptz)]
 pub struct BlockTime(Timestamp);
 
+impl Default for BlockTime {
+    fn default() -> Self {
+        BlockTime::NONE
+    }
+}
+
+impl TryFrom<BlockTime> for U256 {
+    type Error = anyhow::Error;
+
+    fn try_from(value: BlockTime) -> Result<Self, Self::Error> {
+        if value.as_secs_since_epoch() < 0 {
+            bail!("unable to convert block time into U256");
+        }
+
+        Ok(U256::from(value.as_secs_since_epoch() as u64))
+    }
+}
+
+impl TryFrom<U256> for BlockTime {
+    type Error = anyhow::Error;
+
+    fn try_from(value: U256) -> Result<Self, Self::Error> {
+        i64::try_from(value)
+            .map_err(|_| anyhow!("Timestamp out of range for i64"))
+            .map(|ts| BlockTime::since_epoch(ts, 0))
+    }
+}
+
+impl TryFrom<Option<String>> for BlockTime {
+    type Error = ParseIntError;
+
+    fn try_from(ts: Option<String>) -> Result<Self, Self::Error> {
+        match ts {
+            Some(str) => return BlockTime::from_str(&str),
+            None => return Ok(BlockTime::NONE),
+        };
+    }
+}
+
+impl FromStr for BlockTime {
+    type Err = ParseIntError;
+
+    fn from_str(ts: &str) -> Result<Self, Self::Err> {
+        let (radix, idx) = if ts.starts_with("0x") {
+            (16, 2)
+        } else {
+            (10, 0)
+        };
+
+        u64::from_str_radix(&ts[idx..], radix).map(|ts| BlockTime::since_epoch(ts as i64, 0))
+    }
+}
+
 impl BlockTime {
-    /// A timestamp from a long long time ago used to indicate that we don't
-    /// have a timestamp
-    pub const NONE: Self = Self(Timestamp::NONE);
+    // /// A timestamp from a long long time ago used to indicate that we don't
+    // /// have a timestamp
+    pub const NONE: Self = Self::MIN;
 
     pub const MAX: Self = Self(Timestamp::MAX);
 
-    pub const MIN: Self = Self(Timestamp::MIN);
+    pub const MIN: Self = Self(Timestamp(DateTime::from_timestamp_nanos(0)));
 
     /// Construct a block time that is the given number of seconds and
     /// nanoseconds after the Unix epoch
@@ -586,7 +635,12 @@ impl BlockTime {
     /// hourly rollups in tests
     #[cfg(debug_assertions)]
     pub fn for_test(ptr: &BlockPtr) -> Self {
-        Self::since_epoch(ptr.number as i64 * 45 * 60, 0)
+        Self::for_test_number(&ptr.number)
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn for_test_number(number: &BlockNumber) -> Self {
+        Self::since_epoch(*number as i64 * 45 * 60, 0)
     }
 
     pub fn as_secs_since_epoch(&self) -> i64 {

graph/src/data_source/offchain.rs

@@ -216,7 +216,7 @@ impl DataSource {
             data_source::MappingTrigger::Offchain(trigger.clone()),
             self.mapping.handler.clone(),
             BlockPtr::new(Default::default(), self.creation_block.unwrap_or(0)),
-            BlockTime::NONE,
+            BlockTime::MIN,
         ))
     }