add coin cache exclude

Author: hal3e

packages/fuels-accounts/src/coin_cache.rs

@@ -41,6 +41,15 @@ impl CoinsCache {
         }
     }
 
+    pub fn get_all_active(&mut self) -> Vec<CoinTypeId> {
+        self.remove_all_expired_entries();
+
+        self.items
+            .iter()
+            .flat_map(|(_key, entry)| entry.iter().map(|cci| cci.id.clone()))
+            .collect()
+    }
+
     pub fn get_active(&mut self, key: &CoinCacheKey) -> HashSet<CoinTypeId> {
         self.remove_expired_entries(key);
 
@@ -76,6 +85,12 @@ impl CoinsCache {
             entry.retain(|item| item.is_valid(self.ttl));
         }
     }
+
+    fn remove_all_expired_entries(&mut self) {
+        for (_key, entry) in self.items.iter_mut() {
+            entry.retain(|item| item.is_valid(self.ttl));
+        }
+    }
 }
 
 #[derive(Eq, Debug, Clone)]
@@ -175,8 +190,42 @@ mod tests {
         assert!(active_coins.is_empty());
     }
 
+    #[tokio::test]
+    async fn get_all_active() {
+        let mut cache = CoinsCache::new(Duration::from_secs(10));
+
+        let key = CoinCacheKey::default();
+        let (item1, _) = get_items();
+        let items = HashMap::from([(key.clone(), vec![item1.clone()])]);
+
+        cache.insert_multiple(items);
+
+        // Advance time by more than the cache's TTL
+        tokio::time::pause();
+        tokio::time::advance(Duration::from_secs(12)).await;
+
+        let (_, item2) = get_items();
+        let items = HashMap::from([(key.clone(), vec![item2.clone()])]);
+        cache.insert_multiple(items);
+
+        let active_coins = cache.get_all_active();
+
+        assert_eq!(active_coins.len(), 1);
+        assert!(!active_coins.contains(&item1));
+        assert!(active_coins.contains(&item2));
+    }
+
+    #[test]
+    fn get_all_active_no_items() {
+        let mut cache = CoinsCache::new(Duration::from_secs(60));
+
+        let active_coins = cache.get_all_active();
+
+        assert!(active_coins.is_empty());
+    }
+
     #[test]
-    fn test_remove_items() {
+    fn remove_items() {
         let mut cache = CoinsCache::new(Duration::from_secs(60));
 
         let key: CoinCacheKey = Default::default();

packages/fuels-accounts/src/provider.rs

@@ -47,6 +47,8 @@ use fuels_core::{
     },
 };
 use futures::StreamExt;
+#[cfg(feature = "coin-cache")]
+use itertools::{Either, Itertools};
 pub use retry_util::{Backoff, RetryConfig};
 pub use supported_fuel_core_version::SUPPORTED_FUEL_CORE_VERSION;
 use tai64::Tai64;
@@ -399,6 +401,29 @@ impl Provider {
         estimate_predicates: bool,
         reserve_gas: Option<u64>,
     ) -> Result<AssembleTransactionResult> {
+        #[cfg(feature = "coin-cache")]
+        let (cache_utxos, cache_nonces) = self
+            .coins_cache
+            .lock()
+            .await
+            .get_all_active()
+            .into_iter()
+            .partition_map(|coin_type_id| match coin_type_id {
+                CoinTypeId::UtxoId(utxo_id) => Either::Left(utxo_id),
+                CoinTypeId::Nonce(nonce) => Either::Right(nonce),
+            });
+
+        #[cfg(feature = "coin-cache")]
+        let exclude = match exclude {
+            Some((mut utxos, mut nonces)) => {
+                utxos.extend(cache_utxos);
+                nonces.extend(cache_nonces);
+
+                Some((utxos, nonces))
+            }
+            None => Some((cache_utxos, cache_nonces)),
+        };
+
         Ok(self
             .uncached_client()
             .assemble_tx(