chain/near,chain/ethereum: improved revert code and fixed NEAR on revert to pass parent_ptr (#3122)

* chain/near,chain/ethereum: improved revert code and fixed NEAR on revert to pass parent_ptr

Author: Matthieu Vachon

chain/ethereum/src/chain.rs

@@ -602,17 +602,17 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
                 ))
             }
 
-            StepUndo => Ok(BlockStreamEvent::Revert(
-                BlockPtr {
-                    hash: BlockHash::from(block.hash),
-                    number: block.number as i32,
-                },
-                FirehoseCursor::Some(response.cursor.clone()),
-                Some(BlockPtr {
-                    hash: BlockHash::from(block.header.unwrap().parent_hash),
-                    number: (block.number.checked_sub(1).unwrap() as i32), // Will never receive undo on blocknum 0
-                }),
-            )),
+            StepUndo => {
+                let parent_ptr = block
+                    .parent_ptr()
+                    .expect("Genesis block should never be reverted");
+
+                Ok(BlockStreamEvent::Revert(
+                    block.ptr(),
+                    FirehoseCursor::Some(response.cursor.clone()),
+                    Some(parent_ptr),
+                ))
+            }
 
             StepIrreversible => {
                 unreachable!("irreversible step is not handled and should not be requested in the Firehose request")

chain/near/src/chain.rs

@@ -15,7 +15,6 @@ use graph::{
     },
     components::store::DeploymentLocator,
     firehose::{self as firehose, ForkStep},
-    log::factory::{ComponentLoggerConfig, ElasticComponentLoggerConfig},
     prelude::{async_trait, o, BlockNumber, ChainStore, Error, Logger, LoggerFactory},
 };
 use prost::Message;
@@ -154,20 +153,7 @@ impl Blockchain for Chain {
     }
 
     fn ingestor_adapter(&self) -> Arc<Self::IngestorAdapter> {
-        let logger = self
-            .logger_factory
-            .component_logger(
-                "BlockIngestor",
-                Some(ComponentLoggerConfig {
-                    elastic: Some(ElasticComponentLoggerConfig {
-                        index: String::from("block-ingestor-logs"),
-                    }),
-                }),
-            )
-            .new(o!());
-
-        let adapter = IngestorAdapter { logger };
-        Arc::new(adapter)
+        Arc::new(IngestorAdapter {})
     }
 
     fn chain_store(&self) -> Arc<dyn ChainStore> {
@@ -298,6 +284,7 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
                 response.step
             )
         });
+
         let any_block = response
             .block
             .as_ref()
@@ -321,14 +308,14 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
 
             StepUndo => {
                 let header = block.header();
+                let parent_ptr = header
+                    .parent_ptr()
+                    .expect("Genesis block should never be reverted");
 
                 Ok(BlockStreamEvent::Revert(
-                    BlockPtr {
-                        hash: BlockHash::from(header.hash.as_ref().unwrap().bytes.clone()),
-                        number: header.height as i32,
-                    },
+                    block.ptr(),
                     Some(response.cursor.clone()),
-                    None, // FIXME: we should get the parent block pointer when we have access to parent block height
+                    Some(parent_ptr),
                 ))
             }
 
@@ -343,42 +330,34 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
     }
 }
 
-pub struct IngestorAdapter {
-    logger: Logger,
-}
+pub struct IngestorAdapter {}
 
 #[async_trait]
 impl IngestorAdapterTrait<Chain> for IngestorAdapter {
     fn logger(&self) -> &Logger {
-        &self.logger
+        panic!("Should never be called, FirehoseBlockIngestor must be used instead")
     }
 
     fn ancestor_count(&self) -> BlockNumber {
-        0
+        panic!("Should never be called, FirehoseBlockIngestor must be used instead")
     }
 
     async fn latest_block(&self) -> Result<BlockPtr, IngestorError> {
-        Ok(BlockPtr {
-            hash: BlockHash::from(vec![0xff; 32]),
-            number: 0,
-        })
+        panic!("Should never be called, FirehoseBlockIngestor must be used instead")
     }
 
     async fn ingest_block(
         &self,
         _block_hash: &BlockHash,
     ) -> Result<Option<BlockHash>, IngestorError> {
-        // FIXME (NEAR):  Might not be necessary for NEAR support for now
-        Ok(None)
+        panic!("Should never be called, FirehoseBlockIngestor must be used instead")
     }
 
     fn chain_head_ptr(&self) -> Result<Option<BlockPtr>, Error> {
-        // FIXME (NEAR):  Might not be necessary for NEAR support for now
-        Ok(None)
+        panic!("Should never be called, FirehoseBlockIngestor must be used instead")
     }
 
     fn cleanup_cached_blocks(&self) -> Result<Option<(i32, usize)>, Error> {
-        // FIXME (NEAR):  Might not be necessary for NEAR support for now
-        Ok(None)
+        panic!("Should never be called, FirehoseBlockIngestor must be used instead")
     }
 }

chain/near/src/codec.rs

@@ -43,14 +43,12 @@ impl Block {
         self.header.as_ref().unwrap()
     }
 
-    pub fn parent_ptr(&self) -> Option<BlockPtr> {
-        self.header().parent_ptr()
+    pub fn ptr(&self) -> BlockPtr {
+        BlockPtr::from(self.header())
     }
-}
 
-impl From<Block> for BlockPtr {
-    fn from(b: Block) -> BlockPtr {
-        (&b).into()
+    pub fn parent_ptr(&self) -> Option<BlockPtr> {
+        self.header().parent_ptr()
     }
 }