Merge branch 'main' into jeff/nonce-update

Author: kamiyaa

rust/main/Cargo.lock

@@ -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/Cargo.toml

@@ -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/indexer.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/interchain_gas.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/aggregation_ism.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/interchain_security_module.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/multisig_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/ism/routing_ism.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/mailbox.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(),
         })
     }