expose blockchain kind

mangas · mangas · commit 8297527f5e4d · 2022-07-20T12:49:31.000+01:00
diff --git a/chain/ethereum/src/ethereum_adapter.rs b/chain/ethereum/src/ethereum_adapter.rs
@@ -2,6 +2,7 @@ use futures::future;
 use futures::prelude::*;
 use futures03::{future::BoxFuture, stream::FuturesUnordered};
 use graph::blockchain::BlockHash;
+use graph::blockchain::BlockchainKind;
 use graph::blockchain::ChainIdentifier;
 use graph::components::transaction_receipt::LightTransactionReceipt;
 use graph::data::subgraph::UnifiedMappingApiVersion;
diff --git a/graph/src/blockchain/types.rs b/graph/src/blockchain/types.rs
@@ -9,6 +9,8 @@ use crate::prelude::{r, BigInt, TryFromValue, ValueMap};
 use crate::util::stable_hash_glue::{impl_stable_hash, AsBytes};
 use crate::{cheap_clone::CheapClone, components::store::BlockNumber};
 
+use super::BlockchainKind;
+
 /// A simple marker for byte arrays that are really block hashes
 #[derive(Clone, Default, PartialEq, Eq, Hash)]
 pub struct BlockHash(pub Box<[u8]>);
diff --git a/node/src/store_builder.rs b/node/src/store_builder.rs
@@ -2,7 +2,7 @@ use std::iter::FromIterator;
 use std::{collections::HashMap, sync::Arc};
 
 use futures::future::join_all;
-use graph::blockchain::ChainIdentifier;
+use graph::blockchain::{BlockchainKind, ChainIdentifier};
 use graph::prelude::{o, MetricsRegistry, NodeId};
 use graph::url::Url;
 use graph::{
@@ -25,7 +25,7 @@ pub struct StoreBuilder {
     subscription_manager: Arc<SubscriptionManager>,
     chain_head_update_listener: Arc<PostgresChainHeadUpdateListener>,
     /// Map network names to the shards where they are/should be stored
-    chains: HashMap<String, ShardName>,
+    chains: HashMap<String, ShardName, BlockchainKind>,
 }
 
 impl StoreBuilder {
@@ -61,11 +61,12 @@ impl StoreBuilder {
         // using the pool
         join_all(pools.iter().map(|(_, pool)| pool.setup())).await;
 
-        let chains = HashMap::from_iter(config.chains.chains.iter().map(|(name, chain)| {
-            let shard = ShardName::new(chain.shard.to_string())
-                .expect("config validation catches invalid names");
-            (name.to_string(), shard)
-        }));
+        let chains: HashMap<String, ShardName, BlockchainKind> =
+            HashMap::from_iter(config.chains.chains.iter().map(|(name, chain)| {
+                let shard = ShardName::new(chain.shard.to_string())
+                    .expect("config validation catches invalid names");
+                (name.to_string(), shard, chain.protocol)
+            }));
 
         let chain_head_update_listener = Arc::new(PostgresChainHeadUpdateListener::new(
             &logger,
@@ -154,13 +155,17 @@ impl StoreBuilder {
         logger: &Logger,
         pools: HashMap<ShardName, ConnectionPool>,
         subgraph_store: Arc<SubgraphStore>,
-        chains: HashMap<String, ShardName>,
+        chains: HashMap<String, (Option<ShardName>, BlockchainKind)>,
         networks: Vec<(String, Vec<ChainIdentifier>)>,
     ) -> Arc<DieselStore> {
         let networks = networks
             .into_iter()
             .map(|(name, idents)| {
-                let shard = chains.get(&name).unwrap_or(&*PRIMARY_SHARD).clone();
+                let shard = chains
+                    .get(&name)
+                    .map(|v| v.0)
+                    .unwrap_or(&*PRIMARY_SHARD)
+                    .clone();
                 (name, idents, shard)
             })
             .collect();
diff --git a/store/postgres/src/block_store.rs b/store/postgres/src/block_store.rs
@@ -6,7 +6,7 @@ use std::{
 };
 
 use graph::{
-    blockchain::ChainIdentifier,
+    blockchain::{BlockchainKind, ChainIdentifier},
     components::store::BlockStore as BlockStoreTrait,
     prelude::{error, warn, BlockNumber, BlockPtr, Logger},
 };
@@ -200,7 +200,7 @@ impl BlockStore {
     pub fn new(
         logger: Logger,
         // (network, ident, shard)
-        chains: Vec<(String, Vec<ChainIdentifier>, Shard)>,
+        chains: Vec<(String, Vec<(ChainIdentifier, BlockchainKind)>, Shard)>,
         // shard -> pool
         pools: HashMap<Shard, ConnectionPool>,
         sender: Arc<NotificationSender>,
@@ -222,11 +222,28 @@ impl BlockStore {
             chain_head_cache,
         };
 
+        let chains: Vec<(String, Vec<ChainIdentifierExt>, Shard)> = chains
+            .into_iter()
+            .map(|(name, idents, shard)| {
+                let idents = idents
+                    .into_iter()
+                    .map(|(ident, kind)| ChainIdentifierExt { ident, kind })
+                    .collect();
+                (name, idents, shard)
+            })
+            .collect();
+
+        #[derive(Debug, Eq, PartialEq, Hash, Clone)]
+        struct ChainIdentifierExt {
+            ident: ChainIdentifier,
+            kind: BlockchainKind,
+        }
+
         fn reduce_idents(
             chain_name: &str,
-            idents: Vec<ChainIdentifier>,
-        ) -> Result<Option<ChainIdentifier>, StoreError> {
-            let mut idents: HashSet<ChainIdentifier> = HashSet::from_iter(idents.into_iter());
+            idents: Vec<ChainIdentifierExt>,
+        ) -> Result<Option<ChainIdentifierExt>, StoreError> {
+            let mut idents: HashSet<ChainIdentifierExt> = HashSet::from_iter(idents.into_iter());
             match idents.len() {
                 0 => Ok(None),
                 1 => Ok(idents.drain().next()),
@@ -245,7 +262,7 @@ impl BlockStore {
             logger: &Logger,
             chain: &primary::Chain,
             shard: &Shard,
-            ident: &Option<ChainIdentifier>,
+            ident: &Option<ChainIdentifierExt>,
         ) -> bool {
             if &chain.shard != shard {
                 error!(
@@ -258,7 +275,7 @@ impl BlockStore {
                 return false;
             }
             match ident {
-                Some(ident) => {
+                Some(ChainIdentifierExt { ident, kind: _ }) => {
                     if chain.net_version != ident.net_version {
                         error!(logger,
                         "the net version for chain {} has changed from {} to {} since the last time we ran",
@@ -301,16 +318,21 @@ impl BlockStore {
                     } else {
                         ChainStatus::ReadOnly
                     };
-                    block_store.add_chain_store(chain, status, false)?;
+                    block_store.add_chain_store(chain, status, ident.map(|id| id.kind), false)?;
                 }
                 (None, Some(ident)) => {
                     let chain = primary::add_chain(
                         block_store.mirror.primary(),
                         &chain_name,
-                        &ident,
+                        &ident.ident,
                         &shard,
                     )?;
-                    block_store.add_chain_store(&chain, ChainStatus::Ingestible, true)?;
+                    block_store.add_chain_store(
+                        &chain,
+                        ChainStatus::Ingestible,
+                        Some(ident.kind),
+                        true,
+                    )?;
                 }
                 (None, None) => {
                     error!(
@@ -335,7 +357,9 @@ impl BlockStore {
             .iter()
             .filter(|chain| !configured_chains.contains(&chain.name))
         {
-            block_store.add_chain_store(chain, ChainStatus::ReadOnly, false)?;
+            // Here we pass None to blockchain kind because we don't have a way of knowing whether this chain was an EVM chain.
+            // This should only affect the determinism of the meta block in
+            block_store.add_chain_store(chain, ChainStatus::ReadOnly, None, false)?;
         }
         Ok(block_store)
     }
@@ -352,6 +376,7 @@ impl BlockStore {
         &self,
         chain: &primary::Chain,
         status: ChainStatus,
+        kind: Option<BlockchainKind>,
         create: bool,
     ) -> Result<Arc<ChainStore>, StoreError> {
         let pool = self
@@ -372,6 +397,7 @@ impl BlockStore {
             status,
             sender,
             pool,
+            kind,
         );
         if create {
             store.create(&ident)?;
@@ -425,7 +451,7 @@ impl BlockStore {
         self.mirror.read(|conn| {
             primary::find_chain(conn, chain).and_then(|chain| {
                 chain
-                    .map(|chain| self.add_chain_store(&chain, ChainStatus::ReadOnly, false))
+                    .map(|chain| self.add_chain_store(&chain, ChainStatus::ReadOnly, None, false))
                     .transpose()
             })
         })
diff --git a/store/postgres/src/chain_store.rs b/store/postgres/src/chain_store.rs
@@ -12,7 +12,7 @@ use std::{
     time::Duration,
 };
 
-use graph::blockchain::{Block, BlockHash, ChainIdentifier};
+use graph::blockchain::{Block, BlockHash, BlockchainKind, ChainIdentifier};
 use graph::cheap_clone::CheapClone;
 use graph::prelude::web3::types::H256;
 use graph::prelude::{
@@ -1268,6 +1268,7 @@ pub struct ChainStore {
     status: ChainStatus,
     chain_head_update_sender: ChainHeadUpdateSender,
     block_cache: TimedCache<&'static str, BlockPtr>,
+    blockchain_kind: Option<BlockchainKind>,
 }
 
 impl ChainStore {
@@ -1278,6 +1279,7 @@ impl ChainStore {
         status: ChainStatus,
         chain_head_update_sender: ChainHeadUpdateSender,
         pool: ConnectionPool,
+        blockchain_kind: Option<BlockchainKind>,
     ) -> Self {
         ChainStore {
             pool,
@@ -1287,6 +1289,7 @@ impl ChainStore {
             status,
             chain_head_update_sender,
             block_cache: TimedCache::new(Duration::from_secs(5)),
+            blockchain_kind,
         }
     }
 
