Merge branch 'main' into add-robust-subscription

Author: LeoPatOZ

src/robust_provider/provider.rs

@@ -3,7 +3,7 @@ use std::{fmt::Debug, time::Duration};
 use alloy::{
     eips::{BlockId, BlockNumberOrTag},
     network::{Ethereum, Network},
-    primitives::BlockHash,
+    primitives::{BlockHash, BlockNumber},
     providers::{Provider, RootProvider},
     rpc::types::{Filter, Log},
     transports::{RpcError, TransportErrorKind},
@@ -89,7 +89,7 @@ impl<N: Network> RobustProvider<N> {
     /// # Errors
     ///
     /// See [retry errors](#retry-errors).
-    pub async fn get_block_number(&self) -> Result<u64, Error> {
+    pub async fn get_block_number(&self) -> Result<BlockNumber, Error> {
         info!("eth_getBlockNumber called");
         let result = self
             .try_operation_with_failover(
@@ -114,7 +114,7 @@ impl<N: Network> RobustProvider<N> {
     /// # Errors
     ///
     /// See [retry errors](#retry-errors).
-    pub async fn get_block_number_by_id(&self, block_id: BlockId) -> Result<u64, Error> {
+    pub async fn get_block_number_by_id(&self, block_id: BlockId) -> Result<BlockNumber, Error> {
         info!("get_block_number_by_id called");
         let result = self
             .try_operation_with_failover(
@@ -358,11 +358,31 @@ mod tests {
         RobustProviderBuilder, builder::DEFAULT_SUBSCRIPTION_TIMEOUT,
         subscription::DEFAULT_RECONNECT_INTERVAL,
     };
-    use alloy::providers::{ProviderBuilder, WsConnect};
-    use alloy_node_bindings::Anvil;
+    use alloy::providers::{ProviderBuilder, WsConnect, ext::AnvilApi};
+    use alloy_node_bindings::{Anvil, AnvilInstance};
     use std::sync::atomic::{AtomicUsize, Ordering};
     use tokio::time::sleep;
 
+    async fn setup_anvil() -> anyhow::Result<(AnvilInstance, RobustProvider, impl Provider)> {
+        let anvil = Anvil::new().try_spawn()?;
+        let alloy_provider = ProviderBuilder::new().connect_http(anvil.endpoint_url());
+
+        let robust = RobustProviderBuilder::new(alloy_provider.clone())
+            .call_timeout(Duration::from_secs(5))
+            .build()
+            .await?;
+
+        Ok((anvil, robust, alloy_provider))
+    }
+
+    async fn setup_anvil_with_blocks(
+        num_blocks: u64,
+    ) -> anyhow::Result<(AnvilInstance, RobustProvider, impl Provider)> {
+        let (anvil, robust, alloy_provider) = setup_anvil().await?;
+        alloy_provider.anvil_mine(Some(num_blocks), None).await?;
+        Ok((anvil, robust, alloy_provider))
+    }
+
     fn test_provider(timeout: u64, max_retries: usize, min_delay: u64) -> RobustProvider {
         RobustProvider {
             primary_provider: RootProvider::new_http("http://localhost:8545".parse().unwrap()),
@@ -505,4 +525,255 @@ mod tests {
 
         Ok(())
     }
+
+    #[tokio::test]
+    async fn test_ws_fails_http_fallback_returns_primary_error() -> anyhow::Result<()> {
+        let anvil_1 = Anvil::new().try_spawn()?;
+
+        let ws_provider =
+            ProviderBuilder::new().connect(anvil_1.ws_endpoint_url().as_str()).await?;
+
+        let anvil_2 = Anvil::new().try_spawn()?;
+        let http_provider = ProviderBuilder::new().connect_http(anvil_2.endpoint_url());
+
+        let robust = RobustProviderBuilder::fragile(ws_provider.clone())
+            .fallback(http_provider)
+            .call_timeout(Duration::from_millis(500))
+            .build()
+            .await?;
+
+        // force ws_provider to fail and return BackendGone
+        drop(anvil_1);
+
+        let err = robust.subscribe_blocks().await.unwrap_err();
+
+        // The error should be either a Timeout or BackendGone from the primary WS provider,
+        // NOT a PubsubUnavailable error (which would indicate HTTP fallback was attempted)
+        match err {
+            Error::Timeout => {}
+            Error::RpcError(e) => {
+                assert!(matches!(e.as_ref(), RpcError::Transport(TransportErrorKind::BackendGone)));
+            }
+            Error::BlockNotFound(id) => panic!("Unexpected error type: BlockNotFound({id})"),
+        }
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_get_block_by_number_succeeds() -> anyhow::Result<()> {
+        let (_anvil, robust, alloy_provider) = setup_anvil_with_blocks(100).await?;
+
+        let tags = [
+            BlockNumberOrTag::Number(50),
+            BlockNumberOrTag::Latest,
+            BlockNumberOrTag::Earliest,
+            BlockNumberOrTag::Safe,
+            BlockNumberOrTag::Finalized,
+        ];
+
+        for tag in tags {
+            let robust_block = robust.get_block_by_number(tag).await?;
+            let alloy_block =
+                alloy_provider.get_block_by_number(tag).await?.expect("block should exist");
+
+            assert_eq!(robust_block.header.number, alloy_block.header.number);
+            assert_eq!(robust_block.header.hash, alloy_block.header.hash);
+        }
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_get_block_by_number_future_block_fails() -> anyhow::Result<()> {
+        let (_anvil, robust, _alloy_provider) = setup_anvil().await?;
+
+        let future_block = 999_999;
+        let result = robust.get_block_by_number(BlockNumberOrTag::Number(future_block)).await;
+
+        assert!(matches!(result, Err(Error::BlockNotFound(_))));
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_get_block_succeeds() -> anyhow::Result<()> {
+        let (_anvil, robust, alloy_provider) = setup_anvil_with_blocks(100).await?;
+
+        let block_ids = [
+            BlockId::number(50),
+            BlockId::latest(),
+            BlockId::earliest(),
+            BlockId::safe(),
+            BlockId::finalized(),
+        ];
+
+        for block_id in block_ids {
+            let robust_block = robust.get_block(block_id).await?;
+            let alloy_block =
+                alloy_provider.get_block(block_id).await?.expect("block should exist");
+
+            assert_eq!(robust_block.header.number, alloy_block.header.number);
+            assert_eq!(robust_block.header.hash, alloy_block.header.hash);
+        }
+
+        // test block hash
+        let block = alloy_provider
+            .get_block_by_number(BlockNumberOrTag::Number(50))
+            .await?
+            .expect("block should exist");
+        let block_hash = block.header.hash;
+        let block_id = BlockId::hash(block_hash);
+        let robust_block = robust.get_block(block_id).await?;
+        assert_eq!(robust_block.header.hash, block_hash);
+        assert_eq!(robust_block.header.number, 50);
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_get_block_fails() -> anyhow::Result<()> {
+        let (_anvil, robust, _alloy_provider) = setup_anvil().await?;
+
+        // Future block number
+        let result = robust.get_block(BlockId::number(999_999)).await;
+        assert!(matches!(result, Err(Error::BlockNotFound(_))));
+
+        // Non-existent hash
+        let result = robust.get_block(BlockId::hash(BlockHash::ZERO)).await;
+        assert!(matches!(result, Err(Error::BlockNotFound(_))));
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_get_block_number_succeeds() -> anyhow::Result<()> {
+        let (_anvil, robust, alloy_provider) = setup_anvil_with_blocks(100).await?;
+
+        let robust_block_num = robust.get_block_number().await?;
+        let alloy_block_num = alloy_provider.get_block_number().await?;
+        assert_eq!(robust_block_num, alloy_block_num);
+        assert_eq!(robust_block_num, 100);
+
+        alloy_provider.anvil_mine(Some(10), None).await?;
+        let new_block = robust.get_block_number().await?;
+        assert_eq!(new_block, 110);
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_get_block_number_by_id_succeeds() -> anyhow::Result<()> {
+        let (_anvil, robust, alloy_provider) = setup_anvil_with_blocks(100).await?;
+
+        let block_num = robust.get_block_number_by_id(BlockId::number(50)).await?;
+        assert_eq!(block_num, 50);
+
+        let block = alloy_provider
+            .get_block_by_number(BlockNumberOrTag::Number(50))
+            .await?
+            .expect("block should exist");
+        let block_num = robust.get_block_number_by_id(BlockId::hash(block.header.hash)).await?;
+        assert_eq!(block_num, 50);
+
+        let block_num = robust.get_block_number_by_id(BlockId::latest()).await?;
+        assert_eq!(block_num, 100);
+
+        let block_num = robust.get_block_number_by_id(BlockId::earliest()).await?;
+        assert_eq!(block_num, 0);
+
+        // Returns block number even if it doesnt 'exist' on chain
+        let block_num = robust.get_block_number_by_id(BlockId::number(999_999)).await?;
+        let alloy_block_num = alloy_provider
+            .get_block_number_by_id(BlockId::number(999_999))
+            .await?
+            .expect("Should return block num");
+        assert_eq!(alloy_block_num, block_num);
+        assert_eq!(block_num, 999_999);
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_get_block_number_by_id_fails() -> anyhow::Result<()> {
+        let (_anvil, robust, _alloy_provider) = setup_anvil().await?;
+
+        let result = robust.get_block_number_by_id(BlockId::hash(BlockHash::ZERO)).await;
+        assert!(matches!(result, Err(Error::BlockNotFound(_))));
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_get_latest_confirmed_succeeds() -> anyhow::Result<()> {
+        let (_anvil, robust, _alloy_provider) = setup_anvil_with_blocks(100).await?;
+
+        // With confirmations
+        let confirmed_block = robust.get_latest_confirmed(10).await?;
+        assert_eq!(confirmed_block, 90);
+
+        // Zero confirmations returns latest
+        let confirmed_block = robust.get_latest_confirmed(0).await?;
+        assert_eq!(confirmed_block, 100);
+
+        // Single confirmation
+        let confirmed_block = robust.get_latest_confirmed(1).await?;
+        assert_eq!(confirmed_block, 99);
+
+        // confirmations = latest - 1
+        let confirmed_block = robust.get_latest_confirmed(99).await?;
+        assert_eq!(confirmed_block, 1);
+
+        // confirmations = latest (should return 0)
+        let confirmed_block = robust.get_latest_confirmed(100).await?;
+        assert_eq!(confirmed_block, 0);
+
+        // confirmations = latest + 1 (saturates at zero)
+        let confirmed_block = robust.get_latest_confirmed(101).await?;
+        assert_eq!(confirmed_block, 0);
+
+        // Saturates at zero when confirmations > latest
+        let confirmed_block = robust.get_latest_confirmed(200).await?;
+        assert_eq!(confirmed_block, 0);
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_get_block_by_hash_succeeds() -> anyhow::Result<()> {
+        let (_anvil, robust, alloy_provider) = setup_anvil_with_blocks(100).await?;
+
+        let block = alloy_provider
+            .get_block_by_number(BlockNumberOrTag::Number(50))
+            .await?
+            .expect("block should exist");
+        let block_hash = block.header.hash;
+
+        let robust_block = robust.get_block_by_hash(block_hash).await?;
+        let alloy_block =
+            alloy_provider.get_block_by_hash(block_hash).await?.expect("block should exist");
+        assert_eq!(robust_block.header.hash, alloy_block.header.hash);
+        assert_eq!(robust_block.header.number, alloy_block.header.number);
+
+        let genesis = alloy_provider
+            .get_block_by_number(BlockNumberOrTag::Earliest)
+            .await?
+            .expect("genesis should exist");
+        let genesis_hash = genesis.header.hash;
+        let robust_block = robust.get_block_by_hash(genesis_hash).await?;
+        assert_eq!(robust_block.header.number, 0);
+        assert_eq!(robust_block.header.hash, genesis_hash);
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_get_block_by_hash_fails() -> anyhow::Result<()> {
+        let (_anvil, robust, _alloy_provider) = setup_anvil().await?;
+
+        let result = robust.get_block_by_hash(BlockHash::ZERO).await;
+        assert!(matches!(result, Err(Error::BlockNotFound(_))));
+
+        Ok(())
+    }
 }