openzeppelin_relayer/repositories/transaction/

transaction_in_memory.rs

//! This module defines an in-memory transaction repository for managing
//! transaction data. It provides asynchronous methods for creating, retrieving,
//! updating, and deleting transactions, as well as querying transactions by
//! various criteria such as relayer ID, status, and nonce. The repository
//! is implemented using a `Mutex`-protected `HashMap` to store transaction
//! data, ensuring thread-safe access in an asynchronous context.
use crate::{
    models::{
        NetworkTransactionData, TransactionRepoModel, TransactionStatus, TransactionUpdateRequest,
    },
    repositories::*,
};
use async_trait::async_trait;
use eyre::Result;
use itertools::Itertools;
use std::collections::HashMap;
use tokio::sync::{Mutex, MutexGuard};

#[derive(Debug)]
pub struct InMemoryTransactionRepository {
    store: Mutex<HashMap<String, TransactionRepoModel>>,
}

impl Clone for InMemoryTransactionRepository {
    fn clone(&self) -> Self {
        // Try to get the current data, or use empty HashMap if lock fails
        let data = self
            .store
            .try_lock()
            .map(|guard| guard.clone())
            .unwrap_or_else(|_| HashMap::new());

        Self {
            store: Mutex::new(data),
        }
    }
}

impl InMemoryTransactionRepository {
    pub fn new() -> Self {
        Self {
            store: Mutex::new(HashMap::new()),
        }
    }

    async fn acquire_lock<T>(lock: &Mutex<T>) -> Result<MutexGuard<'_, T>, RepositoryError> {
        Ok(lock.lock().await)
    }

    /// Get the sort key for a transaction based on its status.
    /// - For Confirmed status: use confirmed_at (on-chain confirmation order)
    /// - For all other statuses: use created_at (queue/processing order)
    ///
    /// Returns a tuple (timestamp_string, is_confirmed) for consistent sorting.
    fn get_sort_key(tx: &TransactionRepoModel) -> (&str, bool) {
        if tx.status == TransactionStatus::Confirmed {
            if let Some(ref confirmed_at) = tx.confirmed_at {
                return (confirmed_at, true);
            }
            // Fallback to created_at if confirmed_at not set (shouldn't happen)
        }
        (&tx.created_at, false)
    }

    /// Compare two transactions for sorting (newest first).
    /// Uses the same logic as Redis implementation: confirmed_at for Confirmed, created_at for others.
    fn compare_for_sort(a: &TransactionRepoModel, b: &TransactionRepoModel) -> std::cmp::Ordering {
        let (a_key, _) = Self::get_sort_key(a);
        let (b_key, _) = Self::get_sort_key(b);
        b_key
            .cmp(a_key) // Descending (newest first)
            .then_with(|| b.id.cmp(&a.id)) // Tie-breaker: sort by ID for deterministic ordering
    }

    fn is_final_state(status: &TransactionStatus) -> bool {
        matches!(
            status,
            TransactionStatus::Confirmed
                | TransactionStatus::Failed
                | TransactionStatus::Expired
                | TransactionStatus::Canceled
        )
    }
}

// Implement both traits for InMemoryTransactionRepository

#[async_trait]
impl Repository<TransactionRepoModel, String> for InMemoryTransactionRepository {
    async fn create(
        &self,
        tx: TransactionRepoModel,
    ) -> Result<TransactionRepoModel, RepositoryError> {
        let mut store = Self::acquire_lock(&self.store).await?;
        if store.contains_key(&tx.id) {
            return Err(RepositoryError::ConstraintViolation(format!(
                "Transaction with ID {} already exists",
                tx.id
            )));
        }
        store.insert(tx.id.clone(), tx.clone());
        Ok(tx)
    }

    async fn get_by_id(&self, id: String) -> Result<TransactionRepoModel, RepositoryError> {
        let store = Self::acquire_lock(&self.store).await?;
        store
            .get(&id)
            .cloned()
            .ok_or_else(|| RepositoryError::NotFound(format!("Transaction with ID {id} not found")))
    }

    #[allow(clippy::map_entry)]
    async fn update(
        &self,
        id: String,
        tx: TransactionRepoModel,
    ) -> Result<TransactionRepoModel, RepositoryError> {
        let mut store = Self::acquire_lock(&self.store).await?;
        if store.contains_key(&id) {
            let mut updated_tx = tx;
            updated_tx.id = id.clone();
            store.insert(id, updated_tx.clone());
            Ok(updated_tx)
        } else {
            Err(RepositoryError::NotFound(format!(
                "Transaction with ID {id} not found"
            )))
        }
    }

    async fn delete_by_id(&self, id: String) -> Result<(), RepositoryError> {
        let mut store = Self::acquire_lock(&self.store).await?;
        if store.remove(&id).is_some() {
            Ok(())
        } else {
            Err(RepositoryError::NotFound(format!(
                "Transaction with ID {id} not found"
            )))
        }
    }

    async fn list_all(&self) -> Result<Vec<TransactionRepoModel>, RepositoryError> {
        let store = Self::acquire_lock(&self.store).await?;
        Ok(store.values().cloned().collect())
    }

    async fn list_paginated(
        &self,
        query: PaginationQuery,
    ) -> Result<PaginatedResult<TransactionRepoModel>, RepositoryError> {
        let total = self.count().await?;
        let start = ((query.page - 1) * query.per_page) as usize;
        let store = Self::acquire_lock(&self.store).await?;
        let items: Vec<TransactionRepoModel> = store
            .values()
            .skip(start)
            .take(query.per_page as usize)
            .cloned()
            .collect();

        Ok(PaginatedResult {
            items,
            total: total as u64,
            page: query.page,
            per_page: query.per_page,
        })
    }

    async fn count(&self) -> Result<usize, RepositoryError> {
        let store = Self::acquire_lock(&self.store).await?;
        Ok(store.len())
    }

    async fn has_entries(&self) -> Result<bool, RepositoryError> {
        let store = Self::acquire_lock(&self.store).await?;
        Ok(!store.is_empty())
    }

    async fn drop_all_entries(&self) -> Result<(), RepositoryError> {
        let mut store = Self::acquire_lock(&self.store).await?;
        store.clear();
        Ok(())
    }
}

#[async_trait]
impl TransactionRepository for InMemoryTransactionRepository {
    async fn find_by_relayer_id(
        &self,
        relayer_id: &str,
        query: PaginationQuery,
    ) -> Result<PaginatedResult<TransactionRepoModel>, RepositoryError> {
        let store = Self::acquire_lock(&self.store).await?;
        let filtered: Vec<TransactionRepoModel> = store
            .values()
            .filter(|tx| tx.relayer_id == relayer_id)
            .cloned()
            .collect();

        let total = filtered.len() as u64;

        if total == 0 {
            return Ok(PaginatedResult::<TransactionRepoModel> {
                items: vec![],
                total: 0,
                page: query.page,
                per_page: query.per_page,
            });
        }

        let start = ((query.page - 1) * query.per_page) as usize;

        // Sort and paginate (newest first)
        let items = filtered
            .into_iter()
            .sorted_by(|a, b| b.created_at.cmp(&a.created_at)) // Sort by created_at descending (newest first)
            .skip(start)
            .take(query.per_page as usize)
            .collect();

        Ok(PaginatedResult {
            items,
            total,
            page: query.page,
            per_page: query.per_page,
        })
    }

    async fn find_by_status(
        &self,
        relayer_id: &str,
        statuses: &[TransactionStatus],
    ) -> Result<Vec<TransactionRepoModel>, RepositoryError> {
        let store = Self::acquire_lock(&self.store).await?;
        let filtered: Vec<TransactionRepoModel> = store
            .values()
            .filter(|tx| tx.relayer_id == relayer_id && statuses.contains(&tx.status))
            .cloned()
            .collect();

        // Sort by created_at (newest first)
        let sorted = filtered
            .into_iter()
            .sorted_by(|a, b| b.created_at.cmp(&a.created_at))
            .collect();

        Ok(sorted)
    }

    async fn find_by_status_paginated(
        &self,
        relayer_id: &str,
        statuses: &[TransactionStatus],
        query: PaginationQuery,
        oldest_first: bool,
    ) -> Result<PaginatedResult<TransactionRepoModel>, RepositoryError> {
        let store = Self::acquire_lock(&self.store).await?;

        // Filter by relayer_id and statuses
        let filtered: Vec<TransactionRepoModel> = store
            .values()
            .filter(|tx| tx.relayer_id == relayer_id && statuses.contains(&tx.status))
            .cloned()
            .collect();

        let total = filtered.len() as u64;
        let start = ((query.page.saturating_sub(1)) * query.per_page) as usize;

        // Sort using status-aware ordering: confirmed_at for Confirmed, created_at for others
        // oldest_first: ascending order, otherwise descending (newest first)
        let items: Vec<TransactionRepoModel> = if oldest_first {
            filtered
                .into_iter()
                .sorted_by(|a, b| {
                    let (a_key, _) = Self::get_sort_key(a);
                    let (b_key, _) = Self::get_sort_key(b);
                    a_key
                        .cmp(b_key) // Ascending (oldest first)
                        .then_with(|| a.id.cmp(&b.id)) // Tie-breaker: sort by ID for deterministic ordering
                })
                .skip(start)
                .take(query.per_page as usize)
                .collect()
        } else {
            filtered
                .into_iter()
                .sorted_by(Self::compare_for_sort) // Descending (newest first)
                .skip(start)
                .take(query.per_page as usize)
                .collect()
        };

        Ok(PaginatedResult {
            items,
            total,
            page: query.page,
            per_page: query.per_page,
        })
    }

    async fn find_by_status_paginated_filtered(
        &self,
        relayer_id: &str,
        statuses: &[TransactionStatus],
        query: PaginationQuery,
        oldest_first: bool,
        exclude_canceled: bool,
    ) -> Result<PaginatedResult<TransactionRepoModel>, RepositoryError> {
        if !exclude_canceled {
            return self
                .find_by_status_paginated(relayer_id, statuses, query, oldest_first)
                .await;
        }

        let store = Self::acquire_lock(&self.store).await?;

        // Drop cancelled-in-progress transactions BEFORE counting/paginating so the
        // page and total stay consistent.
        let filtered: Vec<TransactionRepoModel> = store
            .values()
            .filter(|tx| {
                tx.relayer_id == relayer_id
                    && statuses.contains(&tx.status)
                    && tx.is_canceled != Some(true)
            })
            .cloned()
            .collect();

        let total = filtered.len() as u64;
        let start = ((query.page.saturating_sub(1)) * query.per_page) as usize;

        let items: Vec<TransactionRepoModel> = if oldest_first {
            filtered
                .into_iter()
                .sorted_by(|a, b| {
                    let (a_key, _) = Self::get_sort_key(a);
                    let (b_key, _) = Self::get_sort_key(b);
                    a_key.cmp(b_key).then_with(|| a.id.cmp(&b.id))
                })
                .skip(start)
                .take(query.per_page as usize)
                .collect()
        } else {
            filtered
                .into_iter()
                .sorted_by(Self::compare_for_sort)
                .skip(start)
                .take(query.per_page as usize)
                .collect()
        };

        Ok(PaginatedResult {
            items,
            total,
            page: query.page,
            per_page: query.per_page,
        })
    }

    async fn find_by_nonce(
        &self,
        relayer_id: &str,
        nonce: u64,
    ) -> Result<Option<TransactionRepoModel>, RepositoryError> {
        let store = Self::acquire_lock(&self.store).await?;
        let filtered: Vec<TransactionRepoModel> = store
            .values()
            .filter(|tx| {
                tx.relayer_id == relayer_id
                    && match &tx.network_data {
                        NetworkTransactionData::Evm(data) => data.nonce == Some(nonce),
                        _ => false,
                    }
            })
            .cloned()
            .collect();

        Ok(filtered.into_iter().next())
    }

    async fn get_nonce_occupancy(
        &self,
        relayer_id: &str,
        from_nonce: u64,
        to_nonce: u64,
    ) -> Result<Vec<(u64, Option<TransactionStatus>)>, RepositoryError> {
        let mut results = Vec::new();
        for nonce in from_nonce..to_nonce {
            let tx = self.find_by_nonce(relayer_id, nonce).await?;
            results.push((nonce, tx.map(|t| t.status)));
        }
        Ok(results)
    }

    async fn update_status(
        &self,
        tx_id: String,
        status: TransactionStatus,
    ) -> Result<TransactionRepoModel, RepositoryError> {
        let update = TransactionUpdateRequest {
            status: Some(status),
            ..Default::default()
        };
        self.partial_update(tx_id, update).await
    }

    async fn partial_update(
        &self,
        tx_id: String,
        update: TransactionUpdateRequest,
    ) -> Result<TransactionRepoModel, RepositoryError> {
        let mut store = Self::acquire_lock(&self.store).await?;

        if let Some(tx) = store.get_mut(&tx_id) {
            // Apply partial updates using the model's business logic
            tx.apply_partial_update(update);
            Ok(tx.clone())
        } else {
            Err(RepositoryError::NotFound(format!(
                "Transaction with ID {tx_id} not found"
            )))
        }
    }

    async fn update_network_data(
        &self,
        tx_id: String,
        network_data: NetworkTransactionData,
    ) -> Result<TransactionRepoModel, RepositoryError> {
        let mut tx = self.get_by_id(tx_id.clone()).await?;
        tx.network_data = network_data;
        self.update(tx_id, tx).await
    }

    async fn set_sent_at(
        &self,
        tx_id: String,
        sent_at: String,
    ) -> Result<TransactionRepoModel, RepositoryError> {
        let update = TransactionUpdateRequest {
            sent_at: Some(sent_at),
            ..Default::default()
        };
        self.partial_update(tx_id, update).await
    }

    async fn increment_status_check_failures(
        &self,
        tx_id: String,
    ) -> Result<TransactionRepoModel, RepositoryError> {
        let mut store = Self::acquire_lock(&self.store).await?;

        if let Some(tx) = store.get_mut(&tx_id) {
            if Self::is_final_state(&tx.status) {
                return Ok(tx.clone());
            }
            let mut metadata = tx.metadata.clone().unwrap_or_default();
            metadata.consecutive_failures = metadata.consecutive_failures.saturating_add(1);
            metadata.total_failures = metadata.total_failures.saturating_add(1);
            tx.metadata = Some(metadata);
            Ok(tx.clone())
        } else {
            Err(RepositoryError::NotFound(format!(
                "Transaction with ID {tx_id} not found"
            )))
        }
    }

    async fn reset_status_check_consecutive_failures(
        &self,
        tx_id: String,
    ) -> Result<TransactionRepoModel, RepositoryError> {
        let mut store = Self::acquire_lock(&self.store).await?;

        if let Some(tx) = store.get_mut(&tx_id) {
            if Self::is_final_state(&tx.status) {
                return Ok(tx.clone());
            }
            let mut metadata = tx.metadata.clone().unwrap_or_default();
            metadata.consecutive_failures = 0;
            tx.metadata = Some(metadata);
            Ok(tx.clone())
        } else {
            Err(RepositoryError::NotFound(format!(
                "Transaction with ID {tx_id} not found"
            )))
        }
    }

    async fn record_stellar_insufficient_fee_retry(
        &self,
        tx_id: String,
        sent_at: String,
    ) -> Result<TransactionRepoModel, RepositoryError> {
        let mut store = Self::acquire_lock(&self.store).await?;

        if let Some(tx) = store.get_mut(&tx_id) {
            if Self::is_final_state(&tx.status) {
                return Ok(tx.clone());
            }
            let mut metadata = tx.metadata.clone().unwrap_or_default();
            metadata.insufficient_fee_retries = metadata.insufficient_fee_retries.saturating_add(1);
            tx.metadata = Some(metadata);
            tx.sent_at = Some(sent_at);
            Ok(tx.clone())
        } else {
            Err(RepositoryError::NotFound(format!(
                "Transaction with ID {tx_id} not found"
            )))
        }
    }

    async fn record_stellar_try_again_later_retry(
        &self,
        tx_id: String,
        sent_at: String,
    ) -> Result<TransactionRepoModel, RepositoryError> {
        let mut store = Self::acquire_lock(&self.store).await?;

        if let Some(tx) = store.get_mut(&tx_id) {
            if Self::is_final_state(&tx.status) {
                return Ok(tx.clone());
            }
            let mut metadata = tx.metadata.clone().unwrap_or_default();
            metadata.try_again_later_retries = metadata.try_again_later_retries.saturating_add(1);
            tx.metadata = Some(metadata);
            tx.sent_at = Some(sent_at);
            Ok(tx.clone())
        } else {
            Err(RepositoryError::NotFound(format!(
                "Transaction with ID {tx_id} not found"
            )))
        }
    }

    async fn set_confirmed_at(
        &self,
        tx_id: String,
        confirmed_at: String,
    ) -> Result<TransactionRepoModel, RepositoryError> {
        let mut tx = self.get_by_id(tx_id.clone()).await?;
        tx.confirmed_at = Some(confirmed_at);
        self.update(tx_id, tx).await
    }

    async fn count_by_status(
        &self,
        relayer_id: &str,
        statuses: &[TransactionStatus],
    ) -> Result<u64, RepositoryError> {
        let store = Self::acquire_lock(&self.store).await?;
        let count = store
            .values()
            .filter(|tx| tx.relayer_id == relayer_id && statuses.contains(&tx.status))
            .count() as u64;
        Ok(count)
    }

    async fn delete_by_ids(&self, ids: Vec<String>) -> Result<BatchDeleteResult, RepositoryError> {
        if ids.is_empty() {
            return Ok(BatchDeleteResult::default());
        }

        let mut store = Self::acquire_lock(&self.store).await?;
        let mut deleted_count = 0;
        let mut failed = Vec::new();

        for id in ids {
            if store.remove(&id).is_some() {
                deleted_count += 1;
            } else {
                failed.push((id.clone(), format!("Transaction with ID {id} not found")));
            }
        }

        Ok(BatchDeleteResult {
            deleted_count,
            failed,
        })
    }

    async fn delete_by_requests(
        &self,
        requests: Vec<TransactionDeleteRequest>,
    ) -> Result<BatchDeleteResult, RepositoryError> {
        if requests.is_empty() {
            return Ok(BatchDeleteResult::default());
        }

        // For in-memory storage, we only need the IDs (no separate indexes to clean up)
        let ids: Vec<String> = requests.into_iter().map(|r| r.id).collect();
        self.delete_by_ids(ids).await
    }
}

impl Default for InMemoryTransactionRepository {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use crate::models::{evm::Speed, EvmTransactionData, NetworkType};
    use lazy_static::lazy_static;
    use std::str::FromStr;

    use crate::models::U256;

    use super::*;

    use tokio::sync::Mutex;

    lazy_static! {
        static ref ENV_MUTEX: Mutex<()> = Mutex::new(());
    }
    // Helper function to create test transactions
    fn create_test_transaction(id: &str) -> TransactionRepoModel {
        TransactionRepoModel {
            id: id.to_string(),
            relayer_id: "relayer-1".to_string(),
            status: TransactionStatus::Pending,
            status_reason: None,
            created_at: "2025-01-27T15:31:10.777083+00:00".to_string(),
            sent_at: Some("2025-01-27T15:31:10.777083+00:00".to_string()),
            confirmed_at: Some("2025-01-27T15:31:10.777083+00:00".to_string()),
            valid_until: None,
            delete_at: None,
            network_type: NetworkType::Evm,
            priced_at: None,
            hashes: vec![],
            network_data: NetworkTransactionData::Evm(EvmTransactionData {
                gas_price: Some(1000000000),
                gas_limit: Some(21000),
                nonce: Some(1),
                value: U256::from_str("1000000000000000000").unwrap(),
                data: Some("0x".to_string()),
                from: "0xSender".to_string(),
                to: Some("0xRecipient".to_string()),
                chain_id: 1,
                signature: None,
                hash: Some(format!("0x{id}")),
                speed: Some(Speed::Fast),
                max_fee_per_gas: None,
                max_priority_fee_per_gas: None,
                raw: None,
            }),
            noop_count: None,
            is_canceled: Some(false),
            metadata: None,
        }
    }

    fn create_test_transaction_pending_state(id: &str) -> TransactionRepoModel {
        TransactionRepoModel {
            id: id.to_string(),
            relayer_id: "relayer-1".to_string(),
            status: TransactionStatus::Pending,
            status_reason: None,
            created_at: "2025-01-27T15:31:10.777083+00:00".to_string(),
            sent_at: None,
            confirmed_at: None,
            valid_until: None,
            delete_at: None,
            network_type: NetworkType::Evm,
            priced_at: None,
            hashes: vec![],
            network_data: NetworkTransactionData::Evm(EvmTransactionData {
                gas_price: Some(1000000000),
                gas_limit: Some(21000),
                nonce: Some(1),
                value: U256::from_str("1000000000000000000").unwrap(),
                data: Some("0x".to_string()),
                from: "0xSender".to_string(),
                to: Some("0xRecipient".to_string()),
                chain_id: 1,
                signature: None,
                hash: Some(format!("0x{id}")),
                speed: Some(Speed::Fast),
                max_fee_per_gas: None,
                max_priority_fee_per_gas: None,
                raw: None,
            }),
            noop_count: None,
            is_canceled: Some(false),
            metadata: None,
        }
    }

    #[tokio::test]
    async fn test_create_transaction() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction("test-1");

        let result = repo.create(tx.clone()).await.unwrap();
        assert_eq!(result.id, tx.id);
        assert_eq!(repo.count().await.unwrap(), 1);
    }

    #[tokio::test]
    async fn test_get_transaction() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction("test-1");

        repo.create(tx.clone()).await.unwrap();
        let stored = repo.get_by_id("test-1".to_string()).await.unwrap();
        if let NetworkTransactionData::Evm(stored_data) = &stored.network_data {
            if let NetworkTransactionData::Evm(tx_data) = &tx.network_data {
                assert_eq!(stored_data.hash, tx_data.hash);
            }
        }
    }

    #[tokio::test]
    async fn test_update_transaction() {
        let repo = InMemoryTransactionRepository::new();
        let mut tx = create_test_transaction("test-1");

        repo.create(tx.clone()).await.unwrap();
        tx.status = TransactionStatus::Confirmed;

        let updated = repo.update("test-1".to_string(), tx).await.unwrap();
        assert!(matches!(updated.status, TransactionStatus::Confirmed));
    }

    #[tokio::test]
    async fn test_delete_transaction() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction("test-1");

        repo.create(tx).await.unwrap();
        repo.delete_by_id("test-1".to_string()).await.unwrap();

        let result = repo.get_by_id("test-1".to_string()).await;
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn test_list_all_transactions() {
        let repo = InMemoryTransactionRepository::new();
        let tx1 = create_test_transaction("test-1");
        let tx2 = create_test_transaction("test-2");

        repo.create(tx1).await.unwrap();
        repo.create(tx2).await.unwrap();

        let transactions = repo.list_all().await.unwrap();
        assert_eq!(transactions.len(), 2);
    }

    #[tokio::test]
    async fn test_count_transactions() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction("test-1");

        assert_eq!(repo.count().await.unwrap(), 0);
        repo.create(tx).await.unwrap();
        assert_eq!(repo.count().await.unwrap(), 1);
    }

    #[tokio::test]
    async fn test_get_nonexistent_transaction() {
        let repo = InMemoryTransactionRepository::new();
        let result = repo.get_by_id("nonexistent".to_string()).await;
        assert!(matches!(result, Err(RepositoryError::NotFound(_))));
    }

    #[tokio::test]
    async fn test_duplicate_transaction_creation() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction("test-1");

        repo.create(tx.clone()).await.unwrap();
        let result = repo.create(tx).await;

        assert!(matches!(
            result,
            Err(RepositoryError::ConstraintViolation(_))
        ));
    }

    #[tokio::test]
    async fn test_update_nonexistent_transaction() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction("test-1");

        let result = repo.update("nonexistent".to_string(), tx).await;
        assert!(matches!(result, Err(RepositoryError::NotFound(_))));
    }

    #[tokio::test]
    async fn test_partial_update() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction_pending_state("test-tx-id");
        repo.create(tx.clone()).await.unwrap();

        // Test updating only status
        let update1 = TransactionUpdateRequest {
            status: Some(TransactionStatus::Sent),
            status_reason: None,
            sent_at: None,
            confirmed_at: None,
            network_data: None,
            hashes: None,
            priced_at: None,
            noop_count: None,
            is_canceled: None,
            delete_at: None,
            metadata: None,
        };
        let updated_tx1 = repo
            .partial_update("test-tx-id".to_string(), update1)
            .await
            .unwrap();
        assert_eq!(updated_tx1.status, TransactionStatus::Sent);
        assert_eq!(updated_tx1.sent_at, None);

        // Test updating multiple fields
        let update2 = TransactionUpdateRequest {
            status: Some(TransactionStatus::Confirmed),
            status_reason: None,
            sent_at: Some("2023-01-01T12:00:00Z".to_string()),
            confirmed_at: Some("2023-01-01T12:05:00Z".to_string()),
            network_data: None,
            hashes: None,
            priced_at: None,
            noop_count: None,
            is_canceled: None,
            delete_at: None,
            metadata: None,
        };
        let updated_tx2 = repo
            .partial_update("test-tx-id".to_string(), update2)
            .await
            .unwrap();
        assert_eq!(updated_tx2.status, TransactionStatus::Confirmed);
        assert_eq!(
            updated_tx2.sent_at,
            Some("2023-01-01T12:00:00Z".to_string())
        );
        assert_eq!(
            updated_tx2.confirmed_at,
            Some("2023-01-01T12:05:00Z".to_string())
        );

        // Test updating non-existent transaction
        let update3 = TransactionUpdateRequest {
            status: Some(TransactionStatus::Failed),
            status_reason: None,
            sent_at: None,
            confirmed_at: None,
            network_data: None,
            hashes: None,
            priced_at: None,
            noop_count: None,
            is_canceled: None,
            delete_at: None,
            metadata: None,
        };
        let result = repo
            .partial_update("non-existent-id".to_string(), update3)
            .await;
        assert!(result.is_err());
        assert!(matches!(result.unwrap_err(), RepositoryError::NotFound(_)));
    }

    #[tokio::test]
    async fn test_update_status() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction("test-1");

        repo.create(tx).await.unwrap();

        // Update status to Confirmed
        let updated = repo
            .update_status("test-1".to_string(), TransactionStatus::Confirmed)
            .await
            .unwrap();

        // Verify the status was updated in the returned transaction
        assert_eq!(updated.status, TransactionStatus::Confirmed);

        // Also verify by getting the transaction directly
        let stored = repo.get_by_id("test-1".to_string()).await.unwrap();
        assert_eq!(stored.status, TransactionStatus::Confirmed);

        // Update status to Failed
        let updated = repo
            .update_status("test-1".to_string(), TransactionStatus::Failed)
            .await
            .unwrap();

        // Verify the status was updated
        assert_eq!(updated.status, TransactionStatus::Failed);

        // Verify updating a non-existent transaction
        let result = repo
            .update_status("non-existent".to_string(), TransactionStatus::Confirmed)
            .await;
        assert!(matches!(result, Err(RepositoryError::NotFound(_))));
    }

    #[tokio::test]
    async fn test_list_paginated() {
        let repo = InMemoryTransactionRepository::new();

        // Create multiple transactions
        for i in 1..=10 {
            let tx = create_test_transaction(&format!("test-{i}"));
            repo.create(tx).await.unwrap();
        }

        // Test first page with 3 items per page
        let query = PaginationQuery {
            page: 1,
            per_page: 3,
        };
        let result = repo.list_paginated(query).await.unwrap();
        assert_eq!(result.items.len(), 3);
        assert_eq!(result.total, 10);
        assert_eq!(result.page, 1);
        assert_eq!(result.per_page, 3);

        // Test second page with 3 items per page
        let query = PaginationQuery {
            page: 2,
            per_page: 3,
        };
        let result = repo.list_paginated(query).await.unwrap();
        assert_eq!(result.items.len(), 3);
        assert_eq!(result.total, 10);
        assert_eq!(result.page, 2);
        assert_eq!(result.per_page, 3);

        // Test page with fewer items than per_page
        let query = PaginationQuery {
            page: 4,
            per_page: 3,
        };
        let result = repo.list_paginated(query).await.unwrap();
        assert_eq!(result.items.len(), 1);
        assert_eq!(result.total, 10);
        assert_eq!(result.page, 4);
        assert_eq!(result.per_page, 3);

        // Test empty page (beyond total items)
        let query = PaginationQuery {
            page: 5,
            per_page: 3,
        };
        let result = repo.list_paginated(query).await.unwrap();
        assert_eq!(result.items.len(), 0);
        assert_eq!(result.total, 10);
    }

    #[tokio::test]
    async fn test_find_by_nonce() {
        let repo = InMemoryTransactionRepository::new();

        // Create transactions with different nonces
        let tx1 = create_test_transaction("test-1");

        let mut tx2 = create_test_transaction("test-2");
        if let NetworkTransactionData::Evm(ref mut data) = tx2.network_data {
            data.nonce = Some(2);
        }

        let mut tx3 = create_test_transaction("test-3");
        tx3.relayer_id = "relayer-2".to_string();
        if let NetworkTransactionData::Evm(ref mut data) = tx3.network_data {
            data.nonce = Some(1);
        }

        repo.create(tx1).await.unwrap();
        repo.create(tx2).await.unwrap();
        repo.create(tx3).await.unwrap();

        // Test finding transaction with specific relayer_id and nonce
        let result = repo.find_by_nonce("relayer-1", 1).await.unwrap();
        assert!(result.is_some());
        assert_eq!(result.as_ref().unwrap().id, "test-1");

        // Test finding transaction with a different nonce
        let result = repo.find_by_nonce("relayer-1", 2).await.unwrap();
        assert!(result.is_some());
        assert_eq!(result.as_ref().unwrap().id, "test-2");

        // Test finding transaction from a different relayer
        let result = repo.find_by_nonce("relayer-2", 1).await.unwrap();
        assert!(result.is_some());
        assert_eq!(result.as_ref().unwrap().id, "test-3");

        // Test finding transaction that doesn't exist
        let result = repo.find_by_nonce("relayer-1", 99).await.unwrap();
        assert!(result.is_none());
    }

    #[tokio::test]
    async fn test_get_nonce_occupancy_mixed_slots() {
        let repo = InMemoryTransactionRepository::new();

        // nonce 1 → Pending (active), nonce 2 → Failed (gap), nonce 3 → empty
        let tx1 = create_test_transaction("tx-1"); // nonce=1, status=Pending
        repo.create(tx1).await.unwrap();

        let mut tx2 = create_test_transaction("tx-2");
        tx2.status = TransactionStatus::Failed;
        if let NetworkTransactionData::Evm(ref mut data) = tx2.network_data {
            data.nonce = Some(2);
        }
        repo.create(tx2).await.unwrap();

        let result = repo.get_nonce_occupancy("relayer-1", 1, 4).await.unwrap();

        assert_eq!(result.len(), 3);
        assert_eq!(result[0], (1, Some(TransactionStatus::Pending)));
        assert_eq!(result[1], (2, Some(TransactionStatus::Failed)));
        assert_eq!(result[2], (3, None));
    }

    #[tokio::test]
    async fn test_get_nonce_occupancy_empty_range() {
        let repo = InMemoryTransactionRepository::new();

        // from >= to → empty result
        let result = repo.get_nonce_occupancy("relayer-1", 5, 5).await.unwrap();
        assert!(result.is_empty());

        let result = repo.get_nonce_occupancy("relayer-1", 10, 5).await.unwrap();
        assert!(result.is_empty());
    }

    #[tokio::test]
    async fn test_get_nonce_occupancy_wrong_relayer() {
        let repo = InMemoryTransactionRepository::new();

        let tx1 = create_test_transaction("tx-1"); // relayer-1, nonce=1
        repo.create(tx1).await.unwrap();

        // Different relayer should see empty slots
        let result = repo.get_nonce_occupancy("relayer-999", 1, 2).await.unwrap();
        assert_eq!(result, vec![(1, None)]);
    }

    #[tokio::test]
    async fn test_update_network_data() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction("test-1");

        repo.create(tx.clone()).await.unwrap();

        // Create new network data with updated values
        let updated_network_data = NetworkTransactionData::Evm(EvmTransactionData {
            gas_price: Some(2000000000),
            gas_limit: Some(30000),
            nonce: Some(2),
            value: U256::from_str("2000000000000000000").unwrap(),
            data: Some("0xUpdated".to_string()),
            from: "0xSender".to_string(),
            to: Some("0xRecipient".to_string()),
            chain_id: 1,
            signature: None,
            hash: Some("0xUpdated".to_string()),
            raw: None,
            speed: None,
            max_fee_per_gas: None,
            max_priority_fee_per_gas: None,
        });

        let updated = repo
            .update_network_data("test-1".to_string(), updated_network_data)
            .await
            .unwrap();

        // Verify the network data was updated
        if let NetworkTransactionData::Evm(data) = &updated.network_data {
            assert_eq!(data.gas_price, Some(2000000000));
            assert_eq!(data.gas_limit, Some(30000));
            assert_eq!(data.nonce, Some(2));
            assert_eq!(data.hash, Some("0xUpdated".to_string()));
            assert_eq!(data.data, Some("0xUpdated".to_string()));
        } else {
            panic!("Expected EVM network data");
        }
    }

    #[tokio::test]
    async fn test_set_sent_at() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction("test-1");

        repo.create(tx).await.unwrap();

        // Updated sent_at timestamp
        let new_sent_at = "2025-02-01T10:00:00.000000+00:00".to_string();

        let updated = repo
            .set_sent_at("test-1".to_string(), new_sent_at.clone())
            .await
            .unwrap();

        // Verify the sent_at timestamp was updated
        assert_eq!(updated.sent_at, Some(new_sent_at.clone()));

        // Also verify by getting the transaction directly
        let stored = repo.get_by_id("test-1".to_string()).await.unwrap();
        assert_eq!(stored.sent_at, Some(new_sent_at.clone()));
    }

    #[tokio::test]
    async fn test_set_confirmed_at() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction("test-1");

        repo.create(tx).await.unwrap();

        // Updated confirmed_at timestamp
        let new_confirmed_at = "2025-02-01T11:30:45.123456+00:00".to_string();

        let updated = repo
            .set_confirmed_at("test-1".to_string(), new_confirmed_at.clone())
            .await
            .unwrap();

        // Verify the confirmed_at timestamp was updated
        assert_eq!(updated.confirmed_at, Some(new_confirmed_at.clone()));

        // Also verify by getting the transaction directly
        let stored = repo.get_by_id("test-1".to_string()).await.unwrap();
        assert_eq!(stored.confirmed_at, Some(new_confirmed_at.clone()));
    }

    #[tokio::test]
    async fn test_find_by_relayer_id() {
        let repo = InMemoryTransactionRepository::new();
        let tx1 = create_test_transaction("test-1");
        let tx2 = create_test_transaction("test-2");

        // Create a transaction with a different relayer_id
        let mut tx3 = create_test_transaction("test-3");
        tx3.relayer_id = "relayer-2".to_string();

        repo.create(tx1).await.unwrap();
        repo.create(tx2).await.unwrap();
        repo.create(tx3).await.unwrap();

        // Test finding transactions for relayer-1
        let query = PaginationQuery {
            page: 1,
            per_page: 10,
        };
        let result = repo
            .find_by_relayer_id("relayer-1", query.clone())
            .await
            .unwrap();
        assert_eq!(result.total, 2);
        assert_eq!(result.items.len(), 2);
        assert!(result.items.iter().all(|tx| tx.relayer_id == "relayer-1"));

        // Test finding transactions for relayer-2
        let result = repo
            .find_by_relayer_id("relayer-2", query.clone())
            .await
            .unwrap();
        assert_eq!(result.total, 1);
        assert_eq!(result.items.len(), 1);
        assert!(result.items.iter().all(|tx| tx.relayer_id == "relayer-2"));

        // Test finding transactions for non-existent relayer
        let result = repo
            .find_by_relayer_id("non-existent", query.clone())
            .await
            .unwrap();
        assert_eq!(result.total, 0);
        assert_eq!(result.items.len(), 0);
    }

    #[tokio::test]
    async fn test_find_by_relayer_id_sorted_by_created_at_newest_first() {
        let repo = InMemoryTransactionRepository::new();

        // Create transactions with different created_at timestamps
        let mut tx1 = create_test_transaction("test-1");
        tx1.created_at = "2025-01-27T10:00:00.000000+00:00".to_string(); // Oldest

        let mut tx2 = create_test_transaction("test-2");
        tx2.created_at = "2025-01-27T12:00:00.000000+00:00".to_string(); // Middle

        let mut tx3 = create_test_transaction("test-3");
        tx3.created_at = "2025-01-27T14:00:00.000000+00:00".to_string(); // Newest

        // Create transactions in non-chronological order to ensure sorting works
        repo.create(tx2.clone()).await.unwrap(); // Middle first
        repo.create(tx1.clone()).await.unwrap(); // Oldest second
        repo.create(tx3.clone()).await.unwrap(); // Newest last

        let query = PaginationQuery {
            page: 1,
            per_page: 10,
        };
        let result = repo.find_by_relayer_id("relayer-1", query).await.unwrap();

        assert_eq!(result.total, 3);
        assert_eq!(result.items.len(), 3);

        // Verify transactions are sorted by created_at descending (newest first)
        assert_eq!(
            result.items[0].id, "test-3",
            "First item should be newest (test-3)"
        );
        assert_eq!(
            result.items[0].created_at,
            "2025-01-27T14:00:00.000000+00:00"
        );

        assert_eq!(
            result.items[1].id, "test-2",
            "Second item should be middle (test-2)"
        );
        assert_eq!(
            result.items[1].created_at,
            "2025-01-27T12:00:00.000000+00:00"
        );

        assert_eq!(
            result.items[2].id, "test-1",
            "Third item should be oldest (test-1)"
        );
        assert_eq!(
            result.items[2].created_at,
            "2025-01-27T10:00:00.000000+00:00"
        );
    }

    #[tokio::test]
    async fn test_find_by_status() {
        let repo = InMemoryTransactionRepository::new();
        let tx1 = create_test_transaction_pending_state("tx1");
        let mut tx2 = create_test_transaction_pending_state("tx2");
        tx2.status = TransactionStatus::Submitted;
        let mut tx3 = create_test_transaction_pending_state("tx3");
        tx3.relayer_id = "relayer-2".to_string();
        tx3.status = TransactionStatus::Pending;

        repo.create(tx1.clone()).await.unwrap();
        repo.create(tx2.clone()).await.unwrap();
        repo.create(tx3.clone()).await.unwrap();

        // Test finding by single status
        let pending_txs = repo
            .find_by_status("relayer-1", &[TransactionStatus::Pending])
            .await
            .unwrap();
        assert_eq!(pending_txs.len(), 1);
        assert_eq!(pending_txs[0].id, "tx1");

        let submitted_txs = repo
            .find_by_status("relayer-1", &[TransactionStatus::Submitted])
            .await
            .unwrap();
        assert_eq!(submitted_txs.len(), 1);
        assert_eq!(submitted_txs[0].id, "tx2");

        // Test finding by multiple statuses
        let multiple_status_txs = repo
            .find_by_status(
                "relayer-1",
                &[TransactionStatus::Pending, TransactionStatus::Submitted],
            )
            .await
            .unwrap();
        assert_eq!(multiple_status_txs.len(), 2);

        // Test finding for different relayer
        let relayer2_pending = repo
            .find_by_status("relayer-2", &[TransactionStatus::Pending])
            .await
            .unwrap();
        assert_eq!(relayer2_pending.len(), 1);
        assert_eq!(relayer2_pending[0].id, "tx3");

        // Test finding for non-existent relayer
        let no_txs = repo
            .find_by_status("non-existent", &[TransactionStatus::Pending])
            .await
            .unwrap();
        assert_eq!(no_txs.len(), 0);
    }

    #[tokio::test]
    async fn test_find_by_status_sorted_by_created_at() {
        let repo = InMemoryTransactionRepository::new();

        // Helper function to create transaction with custom created_at timestamp
        let create_tx_with_timestamp = |id: &str, timestamp: &str| -> TransactionRepoModel {
            let mut tx = create_test_transaction_pending_state(id);
            tx.created_at = timestamp.to_string();
            tx.status = TransactionStatus::Pending;
            tx
        };

        // Create transactions with different timestamps (out of chronological order)
        let tx3 = create_tx_with_timestamp("tx3", "2025-01-27T17:00:00.000000+00:00"); // Latest
        let tx1 = create_tx_with_timestamp("tx1", "2025-01-27T15:00:00.000000+00:00"); // Earliest
        let tx2 = create_tx_with_timestamp("tx2", "2025-01-27T16:00:00.000000+00:00"); // Middle

        // Create them in reverse chronological order to test sorting
        repo.create(tx3.clone()).await.unwrap();
        repo.create(tx1.clone()).await.unwrap();
        repo.create(tx2.clone()).await.unwrap();

        // Find by status
        let result = repo
            .find_by_status("relayer-1", &[TransactionStatus::Pending])
            .await
            .unwrap();

        // Verify they are sorted by created_at (newest first) for Pending status
        assert_eq!(result.len(), 3);
        assert_eq!(result[0].id, "tx3"); // Latest
        assert_eq!(result[1].id, "tx2"); // Middle
        assert_eq!(result[2].id, "tx1"); // Earliest

        // Verify the timestamps are in descending order
        assert_eq!(result[0].created_at, "2025-01-27T17:00:00.000000+00:00");
        assert_eq!(result[1].created_at, "2025-01-27T16:00:00.000000+00:00");
        assert_eq!(result[2].created_at, "2025-01-27T15:00:00.000000+00:00");
    }

    #[tokio::test]
    async fn test_find_by_status_paginated() {
        let repo = InMemoryTransactionRepository::new();

        // Helper function to create transaction with custom created_at timestamp
        let create_tx_with_timestamp =
            |id: &str, timestamp: &str, status: TransactionStatus| -> TransactionRepoModel {
                let mut tx = create_test_transaction_pending_state(id);
                tx.created_at = timestamp.to_string();
                tx.status = status;
                tx
            };

        // Create 5 pending transactions
        for i in 1..=5 {
            let tx = create_tx_with_timestamp(
                &format!("tx{i}"),
                &format!("2025-01-27T{:02}:00:00.000000+00:00", 10 + i),
                TransactionStatus::Pending,
            );
            repo.create(tx).await.unwrap();
        }

        // Create 2 confirmed transactions
        for i in 6..=7 {
            let tx = create_tx_with_timestamp(
                &format!("tx{i}"),
                &format!("2025-01-27T{:02}:00:00.000000+00:00", 10 + i),
                TransactionStatus::Confirmed,
            );
            repo.create(tx).await.unwrap();
        }

        // Test first page (2 items per page)
        let query = PaginationQuery {
            page: 1,
            per_page: 2,
        };
        let result = repo
            .find_by_status_paginated("relayer-1", &[TransactionStatus::Pending], query, false)
            .await
            .unwrap();

        assert_eq!(result.total, 5);
        assert_eq!(result.items.len(), 2);
        assert_eq!(result.page, 1);
        assert_eq!(result.per_page, 2);
        // Should be newest first (tx5, tx4)
        assert_eq!(result.items[0].id, "tx5");
        assert_eq!(result.items[1].id, "tx4");

        // Test second page
        let query = PaginationQuery {
            page: 2,
            per_page: 2,
        };
        let result = repo
            .find_by_status_paginated("relayer-1", &[TransactionStatus::Pending], query, false)
            .await
            .unwrap();

        assert_eq!(result.total, 5);
        assert_eq!(result.items.len(), 2);
        assert_eq!(result.page, 2);
        // Should be tx3, tx2
        assert_eq!(result.items[0].id, "tx3");
        assert_eq!(result.items[1].id, "tx2");

        // Test last page (partial)
        let query = PaginationQuery {
            page: 3,
            per_page: 2,
        };
        let result = repo
            .find_by_status_paginated("relayer-1", &[TransactionStatus::Pending], query, false)
            .await
            .unwrap();

        assert_eq!(result.total, 5);
        assert_eq!(result.items.len(), 1);
        assert_eq!(result.page, 3);
        assert_eq!(result.items[0].id, "tx1");

        // Test beyond last page
        let query = PaginationQuery {
            page: 10,
            per_page: 2,
        };
        let result = repo
            .find_by_status_paginated("relayer-1", &[TransactionStatus::Pending], query, false)
            .await
            .unwrap();

        assert_eq!(result.total, 5);
        assert_eq!(result.items.len(), 0);

        // Test multiple statuses
        let query = PaginationQuery {
            page: 1,
            per_page: 10,
        };
        let result = repo
            .find_by_status_paginated(
                "relayer-1",
                &[TransactionStatus::Pending, TransactionStatus::Confirmed],
                query,
                false,
            )
            .await
            .unwrap();

        assert_eq!(result.total, 7);
        assert_eq!(result.items.len(), 7);

        // Test empty result
        let query = PaginationQuery {
            page: 1,
            per_page: 10,
        };
        let result = repo
            .find_by_status_paginated("relayer-1", &[TransactionStatus::Failed], query, false)
            .await
            .unwrap();

        assert_eq!(result.total, 0);
        assert_eq!(result.items.len(), 0);
    }

    #[tokio::test]
    async fn test_find_by_status_paginated_filtered_excludes_canceled() {
        let repo = InMemoryTransactionRepository::new();

        let make = |id: &str, ts: &str, is_canceled: Option<bool>| -> TransactionRepoModel {
            let mut tx = create_test_transaction_pending_state(id);
            tx.created_at = ts.to_string();
            tx.status = TransactionStatus::Submitted;
            tx.is_canceled = is_canceled;
            tx
        };

        // 3 normal Submitted txs and 1 cancelled-in-progress (still Submitted) in the middle.
        repo.create(make("tx1", "2025-01-27T11:00:00.000000+00:00", None))
            .await
            .unwrap();
        repo.create(make("tx2", "2025-01-27T12:00:00.000000+00:00", Some(true)))
            .await
            .unwrap();
        repo.create(make("tx3", "2025-01-27T13:00:00.000000+00:00", Some(false)))
            .await
            .unwrap();
        repo.create(make("tx4", "2025-01-27T14:00:00.000000+00:00", None))
            .await
            .unwrap();

        let statuses = [TransactionStatus::Submitted];
        let query = PaginationQuery {
            page: 1,
            per_page: 10,
        };

        // exclude_canceled = false → all 4 returned (unchanged behaviour).
        let all = repo
            .find_by_status_paginated_filtered("relayer-1", &statuses, query.clone(), false, false)
            .await
            .unwrap();
        assert_eq!(all.total, 4);
        assert_eq!(all.items.len(), 4);

        // exclude_canceled = true → the cancelled tx is dropped BEFORE counting, so total
        // and items are both consistent (no short/empty page, no over-counted total).
        let filtered = repo
            .find_by_status_paginated_filtered("relayer-1", &statuses, query, false, true)
            .await
            .unwrap();
        assert_eq!(filtered.total, 3, "total must reflect the filtered set");
        assert_eq!(filtered.items.len(), 3);
        let ids: Vec<&str> = filtered.items.iter().map(|t| t.id.as_str()).collect();
        assert!(
            !ids.contains(&"tx2"),
            "cancelled tx must be excluded, got {ids:?}"
        );

        // Pagination stays consistent across pages: 2 per page → page 1 has 2, page 2 has 1,
        // and tx2 never appears, with no empty intermediate page.
        let p1 = repo
            .find_by_status_paginated_filtered(
                "relayer-1",
                &statuses,
                PaginationQuery {
                    page: 1,
                    per_page: 2,
                },
                false,
                true,
            )
            .await
            .unwrap();
        assert_eq!(p1.total, 3);
        assert_eq!(p1.items.len(), 2);
        let p2 = repo
            .find_by_status_paginated_filtered(
                "relayer-1",
                &statuses,
                PaginationQuery {
                    page: 2,
                    per_page: 2,
                },
                false,
                true,
            )
            .await
            .unwrap();
        assert_eq!(p2.total, 3);
        assert_eq!(p2.items.len(), 1);
    }

    #[tokio::test]
    async fn test_find_by_status_paginated_oldest_first() {
        let repo = InMemoryTransactionRepository::new();

        // Helper function to create transaction with custom created_at timestamp
        let create_tx_with_timestamp =
            |id: &str, timestamp: &str, status: TransactionStatus| -> TransactionRepoModel {
                let mut tx = create_test_transaction_pending_state(id);
                tx.created_at = timestamp.to_string();
                tx.status = status;
                tx
            };

        // Create 5 pending transactions with ascending timestamps
        for i in 1..=5 {
            let tx = create_tx_with_timestamp(
                &format!("tx{i}"),
                &format!("2025-01-27T{:02}:00:00.000000+00:00", 10 + i),
                TransactionStatus::Pending,
            );
            repo.create(tx).await.unwrap();
        }

        // Test oldest_first: true - should return tx1, tx2, tx3... (ascending order)
        let query = PaginationQuery {
            page: 1,
            per_page: 3,
        };
        let result = repo
            .find_by_status_paginated("relayer-1", &[TransactionStatus::Pending], query, true)
            .await
            .unwrap();

        assert_eq!(result.total, 5);
        assert_eq!(result.items.len(), 3);
        // Should be oldest first (tx1, tx2, tx3)
        assert_eq!(
            result.items[0].id, "tx1",
            "First item should be oldest (tx1)"
        );
        assert_eq!(result.items[1].id, "tx2", "Second item should be tx2");
        assert_eq!(result.items[2].id, "tx3", "Third item should be tx3");

        // Test second page with oldest_first
        let query = PaginationQuery {
            page: 2,
            per_page: 3,
        };
        let result = repo
            .find_by_status_paginated("relayer-1", &[TransactionStatus::Pending], query, true)
            .await
            .unwrap();

        assert_eq!(result.total, 5);
        assert_eq!(result.items.len(), 2);
        // Should be tx4, tx5
        assert_eq!(result.items[0].id, "tx4");
        assert_eq!(result.items[1].id, "tx5");
    }

    #[tokio::test]
    async fn test_find_by_status_paginated_oldest_first_single_item() {
        let repo = InMemoryTransactionRepository::new();

        // Create 3 pending transactions with different timestamps
        let timestamps = [
            ("tx-oldest", "2025-01-27T08:00:00.000000+00:00"),
            ("tx-middle", "2025-01-27T10:00:00.000000+00:00"),
            ("tx-newest", "2025-01-27T12:00:00.000000+00:00"),
        ];

        for (id, timestamp) in timestamps {
            let mut tx = create_test_transaction_pending_state(id);
            tx.created_at = timestamp.to_string();
            tx.status = TransactionStatus::Pending;
            repo.create(tx).await.unwrap();
        }

        // Request just 1 item with oldest_first: true - should get the oldest
        let query = PaginationQuery {
            page: 1,
            per_page: 1,
        };
        let result = repo
            .find_by_status_paginated(
                "relayer-1",
                &[TransactionStatus::Pending],
                query.clone(),
                true,
            )
            .await
            .unwrap();

        assert_eq!(result.total, 3);
        assert_eq!(result.items.len(), 1);
        assert_eq!(
            result.items[0].id, "tx-oldest",
            "With oldest_first and per_page=1, should return the oldest transaction"
        );

        // Contrast with oldest_first: false - should get the newest
        let result = repo
            .find_by_status_paginated("relayer-1", &[TransactionStatus::Pending], query, false)
            .await
            .unwrap();

        assert_eq!(result.items.len(), 1);
        assert_eq!(
            result.items[0].id, "tx-newest",
            "With oldest_first=false and per_page=1, should return the newest transaction"
        );
    }

    #[tokio::test]
    async fn test_find_by_status_paginated_multi_status_oldest_first() {
        let repo = InMemoryTransactionRepository::new();

        // Create transactions with different statuses and timestamps
        let transactions = [
            (
                "tx-pending-old",
                "2025-01-27T08:00:00.000000+00:00",
                TransactionStatus::Pending,
            ),
            (
                "tx-sent-mid",
                "2025-01-27T10:00:00.000000+00:00",
                TransactionStatus::Sent,
            ),
            (
                "tx-pending-new",
                "2025-01-27T12:00:00.000000+00:00",
                TransactionStatus::Pending,
            ),
            (
                "tx-sent-old",
                "2025-01-27T07:00:00.000000+00:00",
                TransactionStatus::Sent,
            ),
        ];

        for (id, timestamp, status) in transactions {
            let mut tx = create_test_transaction_pending_state(id);
            tx.created_at = timestamp.to_string();
            tx.status = status;
            repo.create(tx).await.unwrap();
        }

        // Query multiple statuses with oldest_first: true
        let query = PaginationQuery {
            page: 1,
            per_page: 10,
        };
        let result = repo
            .find_by_status_paginated(
                "relayer-1",
                &[TransactionStatus::Pending, TransactionStatus::Sent],
                query,
                true,
            )
            .await
            .unwrap();

        assert_eq!(result.total, 4);
        assert_eq!(result.items.len(), 4);
        // Should be sorted by created_at ascending (oldest first)
        assert_eq!(result.items[0].id, "tx-sent-old", "Oldest should be first");
        assert_eq!(result.items[1].id, "tx-pending-old");
        assert_eq!(result.items[2].id, "tx-sent-mid");
        assert_eq!(
            result.items[3].id, "tx-pending-new",
            "Newest should be last"
        );
    }

    #[tokio::test]
    async fn test_has_entries() {
        let repo = InMemoryTransactionRepository::new();
        assert!(!repo.has_entries().await.unwrap());

        let tx = create_test_transaction("test");
        repo.create(tx.clone()).await.unwrap();

        assert!(repo.has_entries().await.unwrap());
    }

    #[tokio::test]
    async fn test_drop_all_entries() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction("test");
        repo.create(tx.clone()).await.unwrap();

        assert!(repo.has_entries().await.unwrap());

        repo.drop_all_entries().await.unwrap();
        assert!(!repo.has_entries().await.unwrap());
    }

    // Tests for delete_at field setting on final status updates

    #[tokio::test]
    async fn test_update_status_sets_delete_at_for_final_statuses() {
        let _lock = ENV_MUTEX.lock().await;

        use chrono::{DateTime, Duration, Utc};
        use std::env;

        // Use a unique test environment variable to avoid conflicts
        env::set_var("TRANSACTION_EXPIRATION_HOURS", "6");

        let repo = InMemoryTransactionRepository::new();

        let final_statuses = [
            TransactionStatus::Canceled,
            TransactionStatus::Confirmed,
            TransactionStatus::Failed,
            TransactionStatus::Expired,
        ];

        for (i, status) in final_statuses.iter().enumerate() {
            let tx_id = format!("test-final-{i}");
            let tx = create_test_transaction_pending_state(&tx_id);

            // Ensure transaction has no delete_at initially
            assert!(tx.delete_at.is_none());

            repo.create(tx).await.unwrap();

            let before_update = Utc::now();

            // Update to final status
            let updated = repo
                .update_status(tx_id.clone(), status.clone())
                .await
                .unwrap();

            // Should have delete_at set
            assert!(
                updated.delete_at.is_some(),
                "delete_at should be set for status: {status:?}"
            );

            // Verify the timestamp is reasonable (approximately 6 hours from now)
            let delete_at_str = updated.delete_at.unwrap();
            let delete_at = DateTime::parse_from_rfc3339(&delete_at_str)
                .expect("delete_at should be valid RFC3339")
                .with_timezone(&Utc);

            let duration_from_before = delete_at.signed_duration_since(before_update);
            let expected_duration = Duration::hours(6);
            let tolerance = Duration::minutes(5);

            assert!(
                duration_from_before >= expected_duration - tolerance &&
                duration_from_before <= expected_duration + tolerance,
                "delete_at should be approximately 6 hours from now for status: {status:?}. Duration: {duration_from_before:?}"
            );
        }

        // Cleanup
        env::remove_var("TRANSACTION_EXPIRATION_HOURS");
    }

    #[tokio::test]
    async fn test_update_status_does_not_set_delete_at_for_non_final_statuses() {
        let _lock = ENV_MUTEX.lock().await;

        use std::env;

        env::set_var("TRANSACTION_EXPIRATION_HOURS", "4");

        let repo = InMemoryTransactionRepository::new();

        let non_final_statuses = [
            TransactionStatus::Pending,
            TransactionStatus::Sent,
            TransactionStatus::Submitted,
            TransactionStatus::Mined,
        ];

        for (i, status) in non_final_statuses.iter().enumerate() {
            let tx_id = format!("test-non-final-{i}");
            let tx = create_test_transaction_pending_state(&tx_id);

            repo.create(tx).await.unwrap();

            // Update to non-final status
            let updated = repo
                .update_status(tx_id.clone(), status.clone())
                .await
                .unwrap();

            // Should NOT have delete_at set
            assert!(
                updated.delete_at.is_none(),
                "delete_at should NOT be set for status: {status:?}"
            );
        }

        // Cleanup
        env::remove_var("TRANSACTION_EXPIRATION_HOURS");
    }

    #[tokio::test]
    async fn test_partial_update_sets_delete_at_for_final_statuses() {
        let _lock = ENV_MUTEX.lock().await;

        use chrono::{DateTime, Duration, Utc};
        use std::env;

        env::set_var("TRANSACTION_EXPIRATION_HOURS", "8");

        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction_pending_state("test-partial-final");

        repo.create(tx).await.unwrap();

        let before_update = Utc::now();

        // Use partial_update to set status to Confirmed (final status)
        let update = TransactionUpdateRequest {
            status: Some(TransactionStatus::Confirmed),
            status_reason: Some("Transaction completed".to_string()),
            confirmed_at: Some("2023-01-01T12:05:00Z".to_string()),
            ..Default::default()
        };

        let updated = repo
            .partial_update("test-partial-final".to_string(), update)
            .await
            .unwrap();

        // Should have delete_at set
        assert!(
            updated.delete_at.is_some(),
            "delete_at should be set when updating to Confirmed status"
        );

        // Verify the timestamp is reasonable (approximately 8 hours from now)
        let delete_at_str = updated.delete_at.unwrap();
        let delete_at = DateTime::parse_from_rfc3339(&delete_at_str)
            .expect("delete_at should be valid RFC3339")
            .with_timezone(&Utc);

        let duration_from_before = delete_at.signed_duration_since(before_update);
        let expected_duration = Duration::hours(8);
        let tolerance = Duration::minutes(5);

        assert!(
            duration_from_before >= expected_duration - tolerance
                && duration_from_before <= expected_duration + tolerance,
            "delete_at should be approximately 8 hours from now. Duration: {duration_from_before:?}"
        );

        // Also verify other fields were updated
        assert_eq!(updated.status, TransactionStatus::Confirmed);
        assert_eq!(
            updated.status_reason,
            Some("Transaction completed".to_string())
        );
        assert_eq!(
            updated.confirmed_at,
            Some("2023-01-01T12:05:00Z".to_string())
        );

        // Cleanup
        env::remove_var("TRANSACTION_EXPIRATION_HOURS");
    }

    #[tokio::test]
    async fn test_update_status_preserves_existing_delete_at() {
        let _lock = ENV_MUTEX.lock().await;

        use std::env;

        env::set_var("TRANSACTION_EXPIRATION_HOURS", "2");

        let repo = InMemoryTransactionRepository::new();
        let mut tx = create_test_transaction_pending_state("test-preserve-delete-at");

        // Set an existing delete_at value
        let existing_delete_at = "2025-01-01T12:00:00Z".to_string();
        tx.delete_at = Some(existing_delete_at.clone());

        repo.create(tx).await.unwrap();

        // Update to final status
        let updated = repo
            .update_status(
                "test-preserve-delete-at".to_string(),
                TransactionStatus::Confirmed,
            )
            .await
            .unwrap();

        // Should preserve the existing delete_at value
        assert_eq!(
            updated.delete_at,
            Some(existing_delete_at),
            "Existing delete_at should be preserved when updating to final status"
        );

        // Cleanup
        env::remove_var("TRANSACTION_EXPIRATION_HOURS");
    }

    #[tokio::test]
    async fn test_partial_update_without_status_change_preserves_delete_at() {
        let _lock = ENV_MUTEX.lock().await;

        use std::env;

        env::set_var("TRANSACTION_EXPIRATION_HOURS", "3");

        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction_pending_state("test-preserve-no-status");

        repo.create(tx).await.unwrap();

        // First, update to final status to set delete_at
        let updated1 = repo
            .update_status(
                "test-preserve-no-status".to_string(),
                TransactionStatus::Confirmed,
            )
            .await
            .unwrap();

        assert!(updated1.delete_at.is_some());
        let original_delete_at = updated1.delete_at.clone();

        // Now update other fields without changing status
        let update = TransactionUpdateRequest {
            status: None, // No status change
            status_reason: Some("Updated reason".to_string()),
            confirmed_at: Some("2023-01-01T12:10:00Z".to_string()),
            ..Default::default()
        };

        let updated2 = repo
            .partial_update("test-preserve-no-status".to_string(), update)
            .await
            .unwrap();

        // delete_at should be preserved
        assert_eq!(
            updated2.delete_at, original_delete_at,
            "delete_at should be preserved when status is not updated"
        );

        // Other fields should be updated
        assert_eq!(updated2.status, TransactionStatus::Confirmed); // Unchanged
        assert_eq!(updated2.status_reason, Some("Updated reason".to_string()));
        assert_eq!(
            updated2.confirmed_at,
            Some("2023-01-01T12:10:00Z".to_string())
        );

        // Cleanup
        env::remove_var("TRANSACTION_EXPIRATION_HOURS");
    }

    #[tokio::test]
    async fn test_update_status_multiple_updates_idempotent() {
        let _lock = ENV_MUTEX.lock().await;

        use std::env;

        env::set_var("TRANSACTION_EXPIRATION_HOURS", "12");

        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction_pending_state("test-idempotent");

        repo.create(tx).await.unwrap();

        // First update to final status
        let updated1 = repo
            .update_status("test-idempotent".to_string(), TransactionStatus::Confirmed)
            .await
            .unwrap();

        assert!(updated1.delete_at.is_some());
        let first_delete_at = updated1.delete_at.clone();

        // Second update to another final status
        let updated2 = repo
            .update_status("test-idempotent".to_string(), TransactionStatus::Failed)
            .await
            .unwrap();

        // delete_at should remain the same (idempotent)
        assert_eq!(
            updated2.delete_at, first_delete_at,
            "delete_at should not change on subsequent final status updates"
        );

        // Status should be updated
        assert_eq!(updated2.status, TransactionStatus::Failed);

        // Cleanup
        env::remove_var("TRANSACTION_EXPIRATION_HOURS");
    }

    // Tests for delete_by_ids batch delete functionality

    #[tokio::test]
    async fn test_delete_by_ids_empty_list() {
        let repo = InMemoryTransactionRepository::new();

        // Create a transaction to ensure repo is not empty
        let tx = create_test_transaction("test-1");
        repo.create(tx).await.unwrap();

        // Delete with empty list should succeed and not affect existing data
        let result = repo.delete_by_ids(vec![]).await.unwrap();

        assert_eq!(result.deleted_count, 0);
        assert!(result.failed.is_empty());

        // Original transaction should still exist
        assert!(repo.get_by_id("test-1".to_string()).await.is_ok());
    }

    #[tokio::test]
    async fn test_delete_by_ids_single_transaction() {
        let repo = InMemoryTransactionRepository::new();

        let tx = create_test_transaction("test-1");
        repo.create(tx).await.unwrap();

        let result = repo
            .delete_by_ids(vec!["test-1".to_string()])
            .await
            .unwrap();

        assert_eq!(result.deleted_count, 1);
        assert!(result.failed.is_empty());

        // Verify transaction was deleted
        assert!(repo.get_by_id("test-1".to_string()).await.is_err());
    }

    #[tokio::test]
    async fn test_delete_by_ids_multiple_transactions() {
        let repo = InMemoryTransactionRepository::new();

        // Create multiple transactions
        for i in 1..=5 {
            let tx = create_test_transaction(&format!("test-{i}"));
            repo.create(tx).await.unwrap();
        }

        assert_eq!(repo.count().await.unwrap(), 5);

        // Delete 3 of them
        let ids_to_delete = vec![
            "test-1".to_string(),
            "test-3".to_string(),
            "test-5".to_string(),
        ];
        let result = repo.delete_by_ids(ids_to_delete).await.unwrap();

        assert_eq!(result.deleted_count, 3);
        assert!(result.failed.is_empty());

        // Verify correct transactions were deleted
        assert!(repo.get_by_id("test-1".to_string()).await.is_err());
        assert!(repo.get_by_id("test-2".to_string()).await.is_ok()); // Not deleted
        assert!(repo.get_by_id("test-3".to_string()).await.is_err());
        assert!(repo.get_by_id("test-4".to_string()).await.is_ok()); // Not deleted
        assert!(repo.get_by_id("test-5".to_string()).await.is_err());

        assert_eq!(repo.count().await.unwrap(), 2);
    }

    #[tokio::test]
    async fn test_delete_by_ids_nonexistent_transactions() {
        let repo = InMemoryTransactionRepository::new();

        // Try to delete transactions that don't exist
        let ids_to_delete = vec!["nonexistent-1".to_string(), "nonexistent-2".to_string()];
        let result = repo.delete_by_ids(ids_to_delete).await.unwrap();

        assert_eq!(result.deleted_count, 0);
        assert_eq!(result.failed.len(), 2);

        // Verify error messages contain the IDs
        assert!(result.failed.iter().any(|(id, _)| id == "nonexistent-1"));
        assert!(result.failed.iter().any(|(id, _)| id == "nonexistent-2"));
    }

    #[tokio::test]
    async fn test_delete_by_ids_mixed_existing_and_nonexistent() {
        let repo = InMemoryTransactionRepository::new();

        // Create some transactions
        for i in 1..=3 {
            let tx = create_test_transaction(&format!("test-{i}"));
            repo.create(tx).await.unwrap();
        }

        // Try to delete mix of existing and non-existing
        let ids_to_delete = vec![
            "test-1".to_string(),        // exists
            "nonexistent-1".to_string(), // doesn't exist
            "test-2".to_string(),        // exists
            "nonexistent-2".to_string(), // doesn't exist
        ];
        let result = repo.delete_by_ids(ids_to_delete).await.unwrap();

        assert_eq!(result.deleted_count, 2);
        assert_eq!(result.failed.len(), 2);

        // Verify existing transactions were deleted
        assert!(repo.get_by_id("test-1".to_string()).await.is_err());
        assert!(repo.get_by_id("test-2".to_string()).await.is_err());

        // Verify remaining transaction still exists
        assert!(repo.get_by_id("test-3".to_string()).await.is_ok());

        // Verify failed IDs are reported
        let failed_ids: Vec<&String> = result.failed.iter().map(|(id, _)| id).collect();
        assert!(failed_ids.contains(&&"nonexistent-1".to_string()));
        assert!(failed_ids.contains(&&"nonexistent-2".to_string()));
    }

    #[tokio::test]
    async fn test_delete_by_ids_all_transactions() {
        let repo = InMemoryTransactionRepository::new();

        // Create transactions
        for i in 1..=10 {
            let tx = create_test_transaction(&format!("test-{i}"));
            repo.create(tx).await.unwrap();
        }

        assert_eq!(repo.count().await.unwrap(), 10);

        // Delete all
        let ids_to_delete: Vec<String> = (1..=10).map(|i| format!("test-{i}")).collect();
        let result = repo.delete_by_ids(ids_to_delete).await.unwrap();

        assert_eq!(result.deleted_count, 10);
        assert!(result.failed.is_empty());
        assert_eq!(repo.count().await.unwrap(), 0);
        assert!(!repo.has_entries().await.unwrap());
    }

    #[tokio::test]
    async fn test_delete_by_ids_duplicate_ids() {
        let repo = InMemoryTransactionRepository::new();

        let tx = create_test_transaction("test-1");
        repo.create(tx).await.unwrap();

        // Try to delete same ID multiple times in one call
        let ids_to_delete = vec![
            "test-1".to_string(),
            "test-1".to_string(), // duplicate
            "test-1".to_string(), // duplicate
        ];
        let result = repo.delete_by_ids(ids_to_delete).await.unwrap();

        // First delete succeeds, subsequent ones fail (already deleted)
        assert_eq!(result.deleted_count, 1);
        assert_eq!(result.failed.len(), 2);

        // Verify transaction was deleted
        assert!(repo.get_by_id("test-1".to_string()).await.is_err());
    }

    #[tokio::test]
    async fn test_delete_by_ids_preserves_other_relayer_transactions() {
        let repo = InMemoryTransactionRepository::new();

        // Create transactions for different relayers
        let mut tx1 = create_test_transaction("tx-relayer-1");
        tx1.relayer_id = "relayer-1".to_string();

        let mut tx2 = create_test_transaction("tx-relayer-2");
        tx2.relayer_id = "relayer-2".to_string();

        repo.create(tx1).await.unwrap();
        repo.create(tx2).await.unwrap();

        // Delete only relayer-1's transaction
        let result = repo
            .delete_by_ids(vec!["tx-relayer-1".to_string()])
            .await
            .unwrap();

        assert_eq!(result.deleted_count, 1);

        // relayer-2's transaction should still exist
        let remaining = repo.get_by_id("tx-relayer-2".to_string()).await.unwrap();
        assert_eq!(remaining.relayer_id, "relayer-2");
    }

    // ── increment_status_check_failures ─────────────────────────────

    #[tokio::test]
    async fn test_increment_status_check_failures_no_prior_metadata() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction_pending_state("tx-inc-1");
        repo.create(tx).await.unwrap();

        let updated = repo
            .increment_status_check_failures("tx-inc-1".to_string())
            .await
            .unwrap();

        let meta = updated.metadata.expect("metadata should be set");
        assert_eq!(meta.consecutive_failures, 1);
        assert_eq!(meta.total_failures, 1);
        assert_eq!(meta.insufficient_fee_retries, 0);
    }

    #[tokio::test]
    async fn test_increment_status_check_failures_accumulates() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction_pending_state("tx-inc-2");
        repo.create(tx).await.unwrap();

        repo.increment_status_check_failures("tx-inc-2".to_string())
            .await
            .unwrap();
        repo.increment_status_check_failures("tx-inc-2".to_string())
            .await
            .unwrap();
        let updated = repo
            .increment_status_check_failures("tx-inc-2".to_string())
            .await
            .unwrap();

        let meta = updated.metadata.unwrap();
        assert_eq!(meta.consecutive_failures, 3);
        assert_eq!(meta.total_failures, 3);
    }

    #[tokio::test]
    async fn test_increment_status_check_failures_noop_on_final_state() {
        let repo = InMemoryTransactionRepository::new();
        let mut tx = create_test_transaction_pending_state("tx-inc-final");
        tx.status = TransactionStatus::Confirmed;
        repo.create(tx).await.unwrap();

        let result = repo
            .increment_status_check_failures("tx-inc-final".to_string())
            .await
            .unwrap();

        // Should return unchanged — no metadata set
        assert!(result.metadata.is_none());
        assert_eq!(result.status, TransactionStatus::Confirmed);
    }

    #[tokio::test]
    async fn test_increment_status_check_failures_not_found() {
        let repo = InMemoryTransactionRepository::new();
        let result = repo
            .increment_status_check_failures("nonexistent".to_string())
            .await;

        assert!(matches!(result, Err(RepositoryError::NotFound(_))));
    }

    // ── reset_status_check_consecutive_failures ─────────────────────

    #[tokio::test]
    async fn test_reset_consecutive_failures() {
        let repo = InMemoryTransactionRepository::new();
        let tx = create_test_transaction_pending_state("tx-reset-1");
        repo.create(tx).await.unwrap();

        // Increment a few times first
        repo.increment_status_check_failures("tx-reset-1".to_string())
            .await
            .unwrap();
        repo.increment_status_check_failures("tx-reset-1".to_string())
            .await
            .unwrap();

        let updated = repo
            .reset_status_check_consecutive_failures("tx-reset-1".to_string())
            .await
            .unwrap();

        let meta = updated.metadata.unwrap();
        assert_eq!(meta.consecutive_failures, 0);
        // total_failures should be preserved
        assert_eq!(meta.total_failures, 2);
    }

    #[tokio::test]
    async fn test_reset_consecutive_failures_noop_on_final_state() {
        let repo = InMemoryTransactionRepository::new();
        let mut tx = create_test_transaction_pending_state("tx-reset-final");
        tx.status = TransactionStatus::Failed;
        tx.metadata = Some(crate::models::TransactionMetadata {
            consecutive_failures: 5,
            total_failures: 10,
            insufficient_fee_retries: 0,
            try_again_later_retries: 0,
            nonce_too_high_retries: 0,
        });
        repo.create(tx).await.unwrap();

        let result = repo
            .reset_status_check_consecutive_failures("tx-reset-final".to_string())
            .await
            .unwrap();

        // Should return unchanged
        let meta = result.metadata.unwrap();
        assert_eq!(meta.consecutive_failures, 5);
    }

    #[tokio::test]
    async fn test_reset_consecutive_failures_not_found() {
        let repo = InMemoryTransactionRepository::new();
        let result = repo
            .reset_status_check_consecutive_failures("nonexistent".to_string())
            .await;

        assert!(matches!(result, Err(RepositoryError::NotFound(_))));
    }

    // ── record_stellar_insufficient_fee_retry ───────────────────────

    #[tokio::test]
    async fn test_record_insufficient_fee_retry() {
        let repo = InMemoryTransactionRepository::new();
        let mut tx = create_test_transaction_pending_state("tx-fee-1");
        tx.status = TransactionStatus::Sent;
        tx.sent_at = None;
        repo.create(tx).await.unwrap();

        let updated = repo
            .record_stellar_insufficient_fee_retry(
                "tx-fee-1".to_string(),
                "2025-03-18T10:00:00Z".to_string(),
            )
            .await
            .unwrap();

        assert_eq!(updated.sent_at.as_deref(), Some("2025-03-18T10:00:00Z"));
        let meta = updated.metadata.unwrap();
        assert_eq!(meta.insufficient_fee_retries, 1);
        assert_eq!(meta.consecutive_failures, 0);
        assert_eq!(meta.total_failures, 0);
    }

    #[tokio::test]
    async fn test_record_insufficient_fee_retry_accumulates() {
        let repo = InMemoryTransactionRepository::new();
        let mut tx = create_test_transaction_pending_state("tx-fee-2");
        tx.status = TransactionStatus::Sent;
        repo.create(tx).await.unwrap();

        repo.record_stellar_insufficient_fee_retry(
            "tx-fee-2".to_string(),
            "2025-03-18T10:00:00Z".to_string(),
        )
        .await
        .unwrap();

        let updated = repo
            .record_stellar_insufficient_fee_retry(
                "tx-fee-2".to_string(),
                "2025-03-18T10:01:00Z".to_string(),
            )
            .await
            .unwrap();

        assert_eq!(updated.sent_at.as_deref(), Some("2025-03-18T10:01:00Z"));
        let meta = updated.metadata.unwrap();
        assert_eq!(meta.insufficient_fee_retries, 2);
    }

    #[tokio::test]
    async fn test_record_insufficient_fee_retry_noop_on_final_state() {
        let repo = InMemoryTransactionRepository::new();
        let mut tx = create_test_transaction_pending_state("tx-fee-final");
        tx.status = TransactionStatus::Confirmed;
        tx.sent_at = Some("old-time".to_string());
        repo.create(tx).await.unwrap();

        let result = repo
            .record_stellar_insufficient_fee_retry(
                "tx-fee-final".to_string(),
                "new-time".to_string(),
            )
            .await
            .unwrap();

        // Should return unchanged
        assert_eq!(result.sent_at.as_deref(), Some("old-time"));
        assert!(result.metadata.is_none());
    }

    #[tokio::test]
    async fn test_record_insufficient_fee_retry_not_found() {
        let repo = InMemoryTransactionRepository::new();
        let result = repo
            .record_stellar_insufficient_fee_retry(
                "nonexistent".to_string(),
                "2025-03-18T10:00:00Z".to_string(),
            )
            .await;

        assert!(matches!(result, Err(RepositoryError::NotFound(_))));
    }

    // ── record_stellar_try_again_later_retry ───────────────────────

    #[tokio::test]
    async fn test_record_try_again_later_retry() {
        let repo = InMemoryTransactionRepository::new();
        let mut tx = create_test_transaction_pending_state("tx-tal-1");
        tx.status = TransactionStatus::Sent;
        tx.sent_at = None;
        repo.create(tx).await.unwrap();

        let updated = repo
            .record_stellar_try_again_later_retry(
                "tx-tal-1".to_string(),
                "2025-03-18T10:00:00Z".to_string(),
            )
            .await
            .unwrap();

        assert_eq!(updated.sent_at.as_deref(), Some("2025-03-18T10:00:00Z"));
        let meta = updated.metadata.unwrap();
        assert_eq!(meta.try_again_later_retries, 1);
        assert_eq!(meta.consecutive_failures, 0);
        assert_eq!(meta.total_failures, 0);
    }

    #[tokio::test]
    async fn test_record_try_again_later_retry_accumulates() {
        let repo = InMemoryTransactionRepository::new();
        let mut tx = create_test_transaction_pending_state("tx-tal-2");
        tx.status = TransactionStatus::Sent;
        repo.create(tx).await.unwrap();

        repo.record_stellar_try_again_later_retry(
            "tx-tal-2".to_string(),
            "2025-03-18T10:00:00Z".to_string(),
        )
        .await
        .unwrap();

        let updated = repo
            .record_stellar_try_again_later_retry(
                "tx-tal-2".to_string(),
                "2025-03-18T10:01:00Z".to_string(),
            )
            .await
            .unwrap();

        assert_eq!(updated.sent_at.as_deref(), Some("2025-03-18T10:01:00Z"));
        let meta = updated.metadata.unwrap();
        assert_eq!(meta.try_again_later_retries, 2);
    }

    #[tokio::test]
    async fn test_record_try_again_later_retry_noop_on_final_state() {
        let repo = InMemoryTransactionRepository::new();
        let mut tx = create_test_transaction_pending_state("tx-tal-final");
        tx.status = TransactionStatus::Confirmed;
        tx.sent_at = Some("old-time".to_string());
        repo.create(tx).await.unwrap();

        let result = repo
            .record_stellar_try_again_later_retry(
                "tx-tal-final".to_string(),
                "new-time".to_string(),
            )
            .await
            .unwrap();

        // Should return unchanged
        assert_eq!(result.sent_at.as_deref(), Some("old-time"));
        assert!(result.metadata.is_none());
    }

    #[tokio::test]
    async fn test_record_try_again_later_retry_not_found() {
        let repo = InMemoryTransactionRepository::new();
        let result = repo
            .record_stellar_try_again_later_retry(
                "nonexistent".to_string(),
                "2025-03-18T10:00:00Z".to_string(),
            )
            .await;

        assert!(matches!(result, Err(RepositoryError::NotFound(_))));
    }
}