core, graph, store: Remove WritableStore.supports_proof_of_indexing

Subgraphs have in fact supported proof of indexing for almost 5 years since
commit 40fd330 and we can therefore stop pretending that that method would
ever return `false`

Author: lutter

core/src/subgraph/runner.rs

@@ -367,14 +367,10 @@ where
         debug!(logger, "Start processing block";
                "triggers" => triggers.len());
 
-        let proof_of_indexing = if self.inputs.store.supports_proof_of_indexing().await? {
-            Some(Arc::new(AtomicRefCell::new(ProofOfIndexing::new(
-                block_ptr.number,
-                self.inputs.poi_version,
-            ))))
-        } else {
-            None
-        };
+        let proof_of_indexing = Some(Arc::new(AtomicRefCell::new(ProofOfIndexing::new(
+            block_ptr.number,
+            self.inputs.poi_version,
+        ))));
 
         // Causality region for onchain triggers.
         let causality_region = PoICausalityRegion::from_network(&self.inputs.network);
@@ -1318,14 +1314,10 @@ where
             .deployment_head
             .set(block_ptr.number as f64);
 
-        let proof_of_indexing = if self.inputs.store.supports_proof_of_indexing().await? {
-            Some(Arc::new(AtomicRefCell::new(ProofOfIndexing::new(
-                block_ptr.number,
-                self.inputs.poi_version,
-            ))))
-        } else {
-            None
-        };
+        let proof_of_indexing = Some(Arc::new(AtomicRefCell::new(ProofOfIndexing::new(
+            block_ptr.number,
+            self.inputs.poi_version,
+        ))));
 
         // Causality region for onchain triggers.
         let causality_region = PoICausalityRegion::from_network(&self.inputs.network);

graph/src/components/store/traits.rs

@@ -365,8 +365,6 @@ pub trait WritableStore: ReadStore + DeploymentCursorTracker {
     /// Set subgraph status to failed with the given error as the cause.
     async fn fail_subgraph(&self, error: SubgraphError) -> Result<(), StoreError>;
 
-    async fn supports_proof_of_indexing(&self) -> Result<bool, StoreError>;
-
     /// Transact the entity changes from a single block atomically into the store, and update the
     /// subgraph block pointer to `block_ptr_to`, and update the firehose cursor to `firehose_cursor`
     ///

store/postgres/src/deployment_store.rs

@@ -916,20 +916,6 @@ impl DeploymentStore {
         }
     }
 
-    pub(crate) async fn supports_proof_of_indexing<'a>(
-        &self,
-        site: Arc<Site>,
-    ) -> Result<bool, StoreError> {
-        let store = self.clone();
-        self.with_conn(move |conn, cancel| {
-            cancel.check_cancel()?;
-            let layout = store.layout(conn, site)?;
-            Ok(layout.supports_proof_of_indexing())
-        })
-        .await
-        .map_err(Into::into)
-    }
-
     pub(crate) async fn get_proof_of_indexing(
         &self,
         site: Arc<Site>,
@@ -950,10 +936,6 @@ impl DeploymentStore {
 
                 let layout = store.layout(conn, site.cheap_clone())?;
 
-                if !layout.supports_proof_of_indexing() {
-                    return Ok(None);
-                }
-
                 conn.transaction::<_, CancelableError<anyhow::Error>, _>(move |conn| {
                     let mut block_ptr = block.cheap_clone();
                     let latest_block_ptr =

store/postgres/src/relational.rs

@@ -375,10 +375,6 @@ impl Layout {
         }
     }
 
-    pub fn supports_proof_of_indexing(&self) -> bool {
-        self.tables.contains_key(&self.input_schema.poi_type())
-    }
-
     pub fn create_relational_schema(
         conn: &mut PgConnection,
         site: Arc<Site>,

store/postgres/src/writable.rs

@@ -279,15 +279,6 @@ impl SyncStore {
         .await
     }
 
-    async fn supports_proof_of_indexing(&self) -> Result<bool, StoreError> {
-        retry::forever_async(&self.logger, "supports_proof_of_indexing", || async {
-            self.writable
-                .supports_proof_of_indexing(self.site.clone())
-                .await
-        })
-        .await
-    }
-
     fn get(&self, key: &EntityKey, block: BlockNumber) -> Result<Option<Entity>, StoreError> {
         retry::forever(&self.logger, "get", || {
             self.writable.get(self.site.cheap_clone(), key, block)
@@ -1667,10 +1658,6 @@ impl WritableStoreTrait for WritableStore {
         self.store.fail_subgraph(error).await
     }
 
-    async fn supports_proof_of_indexing(&self) -> Result<bool, StoreError> {
-        self.store.supports_proof_of_indexing().await
-    }
-
     async fn transact_block_operations(
         &self,
         block_ptr_to: BlockPtr,

store/test-store/tests/graph/entity_cache.rs

@@ -121,10 +121,6 @@ impl WritableStore for MockStore {
         unimplemented!()
     }
 
-    async fn supports_proof_of_indexing(&self) -> Result<bool, StoreError> {
-        unimplemented!()
-    }
-
     async fn transact_block_operations(
         &self,
         _: BlockPtr,