feat: add starknet provider metrics

rust/main/chains/hyperlane-starknet/Cargo.toml

@@ -28,6 +28,7 @@ url.workspace = true
 hyperlane-core = { path = "../../hyperlane-core", features = ["async"] }
 hyperlane-operation-verifier = { path = "../../applications/hyperlane-operation-verifier" }
 hyperlane-warp-route = { path = "../../applications/hyperlane-warp-route" }
+hyperlane-metric = { path = "../../hyperlane-metric" }
 
 [build-dependencies]
 abigen = { path = "../../utils/abigen", features = ["starknet"] }

rust/main/chains/hyperlane-starknet/src/indexer.rs

@@ -13,8 +13,8 @@ use crate::contracts::mailbox::MailboxReader as StarknetMailboxReader;
 use crate::contracts::merkle_tree_hook::MerkleTreeHookReader as StarknetMerkleTreeHookReader;
 use crate::types::HyH256;
 use crate::{
-    build_json_provider, get_block_height_u32, try_parse_hyperlane_message_from_event,
-    ConnectionConf, HyperlaneStarknetError, JsonProvider,
+    get_block_height_u32, try_parse_hyperlane_message_from_event, HyperlaneStarknetError,
+    JsonProvider, StarknetProvider,
 };
 
 const CHUNK_SIZE: u64 = 50;
@@ -29,14 +29,13 @@ pub struct StarknetMailboxIndexer {
 impl StarknetMailboxIndexer {
     /// create new Starknet Mailbox Indexer
     pub fn new(
-        conf: ConnectionConf,
+        provider: StarknetProvider,
         locator: ContractLocator,
         reorg_period: &ReorgPeriod,
     ) -> ChainResult<Self> {
-        let rpc_client = build_json_provider(&conf);
         let contract = StarknetMailboxReader::new(
             Felt::from_bytes_be(&locator.address.to_fixed_bytes()),
-            rpc_client,
+            provider.rpc_client().clone(),
         );
 
         Ok(Self {
@@ -138,14 +137,13 @@ pub struct StarknetMerkleTreeHookIndexer {
 impl StarknetMerkleTreeHookIndexer {
     /// create new Starknet MerkleTreeHook Indexer
     pub fn new(
-        conf: ConnectionConf,
+        provider: StarknetProvider,
         locator: ContractLocator,
         reorg_period: &ReorgPeriod,
     ) -> ChainResult<Self> {
-        let rpc_client = build_json_provider(&conf);
         let contract = StarknetMerkleTreeHookReader::new(
             Felt::from_bytes_be(&locator.address.to_fixed_bytes()),
-            rpc_client,
+            provider.rpc_client().clone(),
         );
 
         Ok(Self {

rust/main/chains/hyperlane-starknet/src/interchain_gas.rs

@@ -3,8 +3,8 @@
 
 use async_trait::async_trait;
 use hyperlane_core::{
-    ChainResult, ContractLocator, HyperlaneChain, HyperlaneContract, HyperlaneDomain,
-    HyperlaneProvider, InterchainGasPaymaster, H256,
+    ChainResult, HyperlaneChain, HyperlaneContract, HyperlaneDomain, HyperlaneProvider,
+    InterchainGasPaymaster, H256,
 };
 
 use crate::{ConnectionConf, StarknetProvider};
@@ -18,9 +18,9 @@ pub struct StarknetInterchainGasPaymaster {
 }
 
 impl StarknetInterchainGasPaymaster {
-    pub fn new(conn: &ConnectionConf, locator: &ContractLocator) -> ChainResult<Self> {
+    pub fn new(provider: StarknetProvider, conn: ConnectionConf) -> ChainResult<Self> {
         Ok(Self {
-            provider: StarknetProvider::new(locator.domain.clone(), conn),
+            provider,
             conn: conn.clone(),
         })
     }

rust/main/chains/hyperlane-starknet/src/ism/aggregation_ism.rs

@@ -12,7 +12,7 @@ use tracing::instrument;
 use crate::contracts::aggregation_ism::{AggregationIsmReader, Message as StarknetMessage};
 use crate::error::HyperlaneStarknetError;
 use crate::types::HyH256;
-use crate::{build_json_provider, ConnectionConf, JsonProvider, StarknetProvider};
+use crate::{ConnectionConf, JsonProvider, StarknetProvider};
 
 /// A reference to a AggregationISM contract on some Starknet chain
 #[derive(Debug)]
@@ -26,14 +26,18 @@ pub struct StarknetAggregationIsm {
 impl StarknetAggregationIsm {
     /// Create a reference to a AggregationISM at a specific Starknet address on some
     /// chain
-    pub fn new(conn: &ConnectionConf, locator: &ContractLocator<'_>) -> ChainResult<Self> {
-        let provider = build_json_provider(conn);
+    pub fn new(
+        provider: StarknetProvider,
+        conn: &ConnectionConf,
+        locator: &ContractLocator<'_>,
+    ) -> ChainResult<Self> {
         let ism_address: Felt = HyH256(locator.address).into();
-        let contract = AggregationIsmReader::new(ism_address, provider);
+        let json_provider = provider.rpc_client().clone();
+        let contract = AggregationIsmReader::new(ism_address, json_provider);
 
         Ok(Self {
             contract,
-            provider: StarknetProvider::new(locator.domain.clone(), conn),
+            provider,
             conn: conn.clone(),
         })
     }

rust/main/chains/hyperlane-starknet/src/ism/interchain_security_module.rs

@@ -12,9 +12,7 @@ use tracing::instrument;
 use crate::contracts::interchain_security_module::InterchainSecurityModuleReader;
 use crate::error::HyperlaneStarknetError;
 use crate::types::HyH256;
-use crate::{
-    build_json_provider, to_hpl_module_type, ConnectionConf, JsonProvider, StarknetProvider,
-};
+use crate::{to_hpl_module_type, ConnectionConf, JsonProvider, StarknetProvider};
 
 /// A reference to a ISM contract on some Starknet chain
 #[derive(Debug)]
@@ -28,14 +26,18 @@ pub struct StarknetInterchainSecurityModule {
 impl StarknetInterchainSecurityModule {
     /// Create a reference to a ISM at a specific Starknet address on some
     /// chain
-    pub fn new(conn: &ConnectionConf, locator: &ContractLocator<'_>) -> ChainResult<Self> {
-        let provider = build_json_provider(conn);
+    pub fn new(
+        provider: StarknetProvider,
+        conn: &ConnectionConf,
+        locator: &ContractLocator<'_>,
+    ) -> ChainResult<Self> {
+        let json_provider = provider.rpc_client().clone();
         let ism_address: Felt = HyH256(locator.address).into();
-        let contract = InterchainSecurityModuleReader::new(ism_address, provider);
+        let contract = InterchainSecurityModuleReader::new(ism_address, json_provider);
 
         Ok(Self {
             contract,
-            provider: StarknetProvider::new(locator.domain.clone(), conn),
+            provider,
             conn: conn.clone(),
         })
     }

rust/main/chains/hyperlane-starknet/src/ism/multisig_ism.rs

@@ -12,7 +12,7 @@ use tracing::instrument;
 use crate::contracts::multisig_ism::MultisigIsmReader;
 use crate::error::HyperlaneStarknetError;
 use crate::types::HyH256;
-use crate::{build_json_provider, ConnectionConf, JsonProvider, StarknetProvider};
+use crate::{ConnectionConf, JsonProvider, StarknetProvider};
 
 /// A reference to a MultisigISM contract on some Starknet chain
 #[derive(Debug)]
@@ -26,14 +26,18 @@ pub struct StarknetMultisigIsm {
 impl StarknetMultisigIsm {
     /// Create a reference to a MultisigISM at a specific Starknet address on some
     /// chain
-    pub fn new(conn: &ConnectionConf, locator: &ContractLocator<'_>) -> ChainResult<Self> {
-        let provider = build_json_provider(conn);
+    pub fn new(
+        provider: StarknetProvider,
+        conn: &ConnectionConf,
+        locator: &ContractLocator<'_>,
+    ) -> ChainResult<Self> {
+        let json_provider = provider.rpc_client().clone();
         let ism_address: Felt = HyH256(locator.address).into();
-        let contract = MultisigIsmReader::new(ism_address, provider);
+        let contract = MultisigIsmReader::new(ism_address, json_provider);
 
         Ok(Self {
             contract,
-            provider: StarknetProvider::new(locator.domain.clone(), conn),
+            provider,
             conn: conn.clone(),
         })
     }

rust/main/chains/hyperlane-starknet/src/ism/routing_ism.rs

@@ -12,7 +12,7 @@ use tracing::instrument;
 use crate::contracts::routing_ism::RoutingIsmReader;
 use crate::error::HyperlaneStarknetError;
 use crate::types::HyH256;
-use crate::{build_json_provider, ConnectionConf, JsonProvider, StarknetProvider};
+use crate::{ConnectionConf, JsonProvider, StarknetProvider};
 
 /// A reference to a RoutingISM contract on some Starknet chain
 #[derive(Debug)]
@@ -25,15 +25,18 @@ pub struct StarknetRoutingIsm {
 
 impl StarknetRoutingIsm {
     /// Create a reference to a RoutingISM at a specific Starknet address on some
-    /// chain
-    pub fn new(conn: &ConnectionConf, locator: &ContractLocator<'_>) -> ChainResult<Self> {
-        let provider = build_json_provider(conn);
+    pub fn new(
+        provider: StarknetProvider,
+        conn: &ConnectionConf,
+        locator: &ContractLocator<'_>,
+    ) -> ChainResult<Self> {
+        let json_provider = provider.rpc_client().clone();
         let ism_address: Felt = HyH256(locator.address).into();
-        let contract = RoutingIsmReader::new(ism_address, provider);
+        let contract = RoutingIsmReader::new(ism_address, json_provider);
 
         Ok(Self {
             contract,
-            provider: StarknetProvider::new(locator.domain.clone(), conn),
+            provider,
             conn: conn.clone(),
         })
     }

rust/main/chains/hyperlane-starknet/src/mailbox.rs

@@ -38,19 +38,20 @@ impl StarknetMailbox {
     /// Create a reference to a mailbox at a specific Starknet address on some
     /// chain
     pub async fn new(
+        provider: StarknetProvider,
         conn: &ConnectionConf,
         locator: &ContractLocator<'_>,
         signer: Option<Signer>,
     ) -> ChainResult<Self> {
-        let account = build_single_owner_account(conn.urls.clone(), signer).await?;
+        let account = build_single_owner_account(signer, provider.rpc_client()).await?;
 
         let mailbox_address: Felt = HyH256(locator.address).into();
 
         let contract = StarknetMailboxInternal::new(mailbox_address, account);
 
         Ok(Self {
             contract,
-            provider: StarknetProvider::new(locator.domain.clone(), conn),
+            provider,
             conn: conn.clone(),
         })
     }

rust/main/chains/hyperlane-starknet/src/merkle_tree_hook.rs

@@ -15,10 +15,7 @@ use tracing::instrument;
 use crate::contracts::merkle_tree_hook::MerkleTreeHookReader;
 use crate::error::HyperlaneStarknetError;
 use crate::types::HyH256;
-use crate::{
-    build_json_provider, get_block_height_for_reorg_period, ConnectionConf, JsonProvider,
-    StarknetProvider,
-};
+use crate::{get_block_height_for_reorg_period, ConnectionConf, JsonProvider, StarknetProvider};
 
 /// A reference to a Merkle Tree Hook contract on some Starknet chain
 #[derive(Debug)]
@@ -32,14 +29,17 @@ pub struct StarknetMerkleTreeHook {
 impl StarknetMerkleTreeHook {
     /// Create a reference to a merkle tree hook at a specific Starknet address on some
     /// chain
-    pub fn new(conn: &ConnectionConf, locator: &ContractLocator<'_>) -> ChainResult<Self> {
-        let provider = build_json_provider(conn);
+    pub fn new(
+        provider: StarknetProvider,
+        conn: &ConnectionConf,
+        locator: &ContractLocator<'_>,
+    ) -> ChainResult<Self> {
         let hook_address: Felt = HyH256(locator.address).into();
-        let contract = MerkleTreeHookReader::new(hook_address, provider);
+        let contract = MerkleTreeHookReader::new(hook_address, provider.rpc_client().clone());
 
         Ok(Self {
             contract,
-            provider: StarknetProvider::new(locator.domain.clone(), conn),
+            provider,
             conn: conn.clone(),
         })
     }

rust/main/chains/hyperlane-starknet/src/provider/client.rs

@@ -2,9 +2,10 @@ use std::fmt::Debug;
 
 use async_trait::async_trait;
 use hyperlane_core::{
-    h512_to_bytes, BlockInfo, ChainCommunicationError, ChainInfo, ChainResult, HyperlaneChain,
+    h512_to_bytes, BlockInfo, ChainCommunicationError, ChainResult, HyperlaneChain,
     HyperlaneDomain, HyperlaneProvider, TxnInfo, TxnReceiptInfo, H256, H512, U256,
 };
+use hyperlane_metric::prometheus_metric::{ChainInfo, PrometheusClientMetrics};
 use starknet::core::types::{
     BlockId, BlockTag, Felt, FunctionCall, InvokeTransaction, MaybePendingBlockWithTxHashes,
     Transaction, TransactionReceipt,
@@ -20,11 +21,6 @@ use crate::{ConnectionConf, HyperlaneStarknetError};
 /// JsonProvider type, that includes the fallback behavior
 pub type JsonProvider = JsonRpcClient<FallbackHttpTransport>;
 
-/// Builds a new starknet json provider that has fallback behavior
-pub(crate) fn build_json_provider(conn: &ConnectionConf) -> JsonProvider {
-    JsonRpcClient::new(FallbackHttpTransport::new(conn.urls.clone()))
-}
-
 #[derive(Debug, Clone)]
 /// A wrapper over the Starknet provider to provide a more ergonomic interface.
 pub struct StarknetProvider {
@@ -35,8 +31,17 @@ pub struct StarknetProvider {
 
 impl StarknetProvider {
     /// Create a new Starknet provider.
-    pub fn new(domain: HyperlaneDomain, conf: &ConnectionConf) -> Self {
-        let provider = JsonRpcClient::new(FallbackHttpTransport::new(conf.urls.clone()));
+    pub fn new(
+        domain: HyperlaneDomain,
+        conf: &ConnectionConf,
+        metrics: PrometheusClientMetrics,
+        chain: Option<ChainInfo>,
+    ) -> Self {
+        let provider = JsonRpcClient::new(FallbackHttpTransport::new(
+            conf.urls.clone(),
+            metrics,
+            chain,
+        ));
 
         // Fee token address is used to check balances
         let fee_token_address = Felt::from_bytes_be(conf.native_token_address.as_fixed_bytes());
@@ -73,7 +78,7 @@ impl HyperlaneChain for StarknetProvider {
 impl HyperlaneProvider for StarknetProvider {
     #[instrument(err, skip(self))]
     async fn get_block_by_height(&self, height: u64) -> ChainResult<BlockInfo> {
-        let block = self
+        let block: MaybePendingBlockWithTxHashes = self
             .rpc_client()
             .get_block_with_tx_hashes(BlockId::Number(height))
             .await
@@ -187,7 +192,13 @@ impl HyperlaneProvider for StarknetProvider {
         Ok(balance.0)
     }
 
-    async fn get_chain_metrics(&self) -> ChainResult<Option<ChainInfo>> {
-        Ok(None)
+    async fn get_chain_metrics(&self) -> ChainResult<Option<hyperlane_core::ChainInfo>> {
+        let block_height = self
+            .rpc_client
+            .block_number()
+            .await
+            .map_err(HyperlaneStarknetError::from)?;
+        let block_info = self.get_block_by_height(block_height).await?;
+        Ok(Some(hyperlane_core::ChainInfo::new(block_info, None)))
     }
 }