store: Remove argument from

Author: leoyvens

chain/ethereum/src/network_indexer/network_indexer.rs

@@ -357,11 +357,7 @@ fn revert_local_head(context: &Context, local_head: EthereumBlockPointer) -> Rev
                 future::result(
                     store
                         .clone()
-                        .revert_block_operations(
-                            subgraph_id.clone(),
-                            local_head.clone(),
-                            parent_block.clone(),
-                        )
+                        .revert_block_operations(subgraph_id.clone(), parent_block.clone())
                         .map_err(|e| e.into())
                         .map(|_| (local_head, parent_block)),
                 )

core/src/subgraph/instance_manager.rs

@@ -514,7 +514,6 @@ where
                                 .store
                                 .revert_block_operations(
                                     ctx.inputs.deployment_id.clone(),
-                                    subgraph_ptr,
                                     parent_ptr,
                                 )
                                 .map_err(Into::into)

graph/src/components/ethereum/stream.rs

@@ -5,8 +5,6 @@ use crate::prelude::*;
 
 pub enum BlockStreamEvent {
     Block(EthereumBlockWithTriggers),
-
-    /// Signals that a revert happened and was processed.
     Revert(EthereumBlockPointer),
 }
 

graph/src/components/store.rs

@@ -987,14 +987,12 @@ pub trait Store: Send + Sync + 'static {
     ) -> Result<(), StoreError>;
 
     /// Revert the entity changes from a single block atomically in the store, and update the
-    /// subgraph block pointer from `block_ptr_from` to `block_ptr_to`.
+    /// subgraph block pointer to `block_ptr_to`.
     ///
-    /// `block_ptr_from` must match the current value of the subgraph block pointer.
-    /// `block_ptr_to` must point to the parent block of `block_ptr_from`.
+    /// `block_ptr_to` must point to the parent block of the subgraph block pointer.
     fn revert_block_operations(
         &self,
         subgraph_id: SubgraphDeploymentId,
-        block_ptr_from: EthereumBlockPointer,
         block_ptr_to: EthereumBlockPointer,
     ) -> Result<(), StoreError>;
 
@@ -1221,7 +1219,6 @@ impl Store for MockStore {
     fn revert_block_operations(
         &self,
         _subgraph_id: SubgraphDeploymentId,
-        _block_ptr_from: EthereumBlockPointer,
         _block_ptr_to: EthereumBlockPointer,
     ) -> Result<(), StoreError> {
         unimplemented!()

graphql/tests/query.rs

@@ -1547,7 +1547,7 @@ fn query_detects_reorg() {
 
         // Revert one block
         STORE
-            .revert_block_operations(id.clone(), BLOCK_ONE.clone(), GENESIS_PTR.clone())
+            .revert_block_operations(id.clone(), GENESIS_PTR.clone())
             .unwrap();
         // A query is still fine since we implicitly query at block 0; we were
         // at block 1 when we got `state`, and reorged once by one block, which
@@ -1726,7 +1726,7 @@ fn non_fatal_errors() {
 
             // Test error reverts.
             STORE
-                .revert_block_operations(id.clone(), BLOCK_TWO.block_ptr(), *BLOCK_ONE)
+                .revert_block_operations(id.clone(), *BLOCK_ONE)
                 .unwrap();
             let query = "query { musician(id: \"m1\") { id }  _meta { hasIndexingErrors } }";
             let query = graphql_parser::parse_query(query).unwrap().into_static();

mock/src/store.rs

@@ -117,7 +117,6 @@ impl Store for MockStore {
     fn revert_block_operations(
         &self,
         _subgraph_id: SubgraphDeploymentId,
-        _block_ptr_from: EthereumBlockPointer,
         _block_ptr_to: EthereumBlockPointer,
     ) -> Result<(), StoreError> {
         unimplemented!()

store/postgres/src/network_store.rs

@@ -141,11 +141,10 @@ impl StoreTrait for NetworkStore {
     fn revert_block_operations(
         &self,
         subgraph_id: graph::prelude::SubgraphDeploymentId,
-        block_ptr_from: EthereumBlockPointer,
         block_ptr_to: EthereumBlockPointer,
     ) -> Result<(), graph::prelude::StoreError> {
         self.store
-            .revert_block_operations(subgraph_id, block_ptr_from, block_ptr_to)
+            .revert_block_operations(subgraph_id, block_ptr_to)
     }
 
     fn subscribe(

store/postgres/src/sharded_store.rs

@@ -415,11 +415,10 @@ impl StoreTrait for ShardedStore {
     fn revert_block_operations(
         &self,
         id: SubgraphDeploymentId,
-        block_ptr_from: EthereumBlockPointer,
         block_ptr_to: EthereumBlockPointer,
     ) -> Result<(), StoreError> {
         let (store, site) = self.store(&id)?;
-        let event = store.revert_block_operations(site.as_ref(), block_ptr_from, block_ptr_to)?;
+        let event = store.revert_block_operations(site.as_ref(), block_ptr_to)?;
         self.send_store_event(&event)
     }
 

store/postgres/src/store.rs

@@ -1030,35 +1030,35 @@ impl Store {
     pub(crate) fn revert_block_operations(
         &self,
         site: &Site,
-        block_ptr_from: EthereumBlockPointer,
         block_ptr_to: EthereumBlockPointer,
     ) -> Result<StoreEvent, StoreError> {
-        // Sanity check on block numbers
-        if block_ptr_from.number != block_ptr_to.number + 1 {
-            panic!("revert_block_operations must revert a single block only");
-        }
-        // Don't revert past a graft point
         let econn = self.get_entity_conn(site, ReplicaId::Main)?;
-        let info = self.subgraph_info_with_conn(&econn.conn, &site.deployment)?;
-        if let Some(graft_block) = info.graft_block {
-            if graft_block as u64 > block_ptr_to.number {
-                return Err(anyhow!(
-                    "Can not revert subgraph `{}` to block {} as it was \
-                    grafted at block {} and reverting past a graft point \
-                    is not possible",
-                    site.deployment.clone(),
-                    block_ptr_to.number,
-                    graft_block
-                )
-                .into());
-            }
-        }
 
         let event = econn.transaction(|| -> Result<_, StoreError> {
-            assert_eq!(
-                Some(block_ptr_from),
-                Self::block_ptr_with_conn(&site.deployment, &econn)?
-            );
+            // Unwrap: If we are reverting then the block ptr is not `None`.
+            let block_ptr_from = Self::block_ptr_with_conn(&site.deployment, &econn)?.unwrap();
+
+            // Sanity check on block numbers
+            if block_ptr_from.number != block_ptr_to.number + 1 {
+                panic!("revert_block_operations must revert a single block only");
+            }
+
+            // Don't revert past a graft point
+            let info = self.subgraph_info_with_conn(&econn.conn, &site.deployment)?;
+            if let Some(graft_block) = info.graft_block {
+                if graft_block as u64 > block_ptr_to.number {
+                    return Err(anyhow!(
+                        "Can not revert subgraph `{}` to block {} as it was \
+                        grafted at block {} and reverting past a graft point \
+                        is not possible",
+                        site.deployment.clone(),
+                        block_ptr_to.number,
+                        graft_block
+                    )
+                    .into());
+                }
+            }
+
             let metadata_event =
                 deployment::revert_block_ptr(&econn.conn, &site.deployment, block_ptr_to)?;
 

store/postgres/tests/graft.rs

@@ -306,11 +306,11 @@ fn graft() {
         transact_entity_operations(&store, subgraph_id.clone(), BLOCKS[2], vec![op]).unwrap();
 
         store
-            .revert_block_operations(subgraph_id.clone(), BLOCKS[2], BLOCKS[1])
+            .revert_block_operations(subgraph_id.clone(), BLOCKS[1])
             .expect("We can revert a block we just created");
 
         let err = store
-            .revert_block_operations(subgraph_id.clone(), BLOCKS[1], BLOCKS[0])
+            .revert_block_operations(subgraph_id.clone(), BLOCKS[0])
             .expect_err("Reverting past graft point is not allowed");
 
         assert!(err.to_string().contains("Can not revert subgraph"));