Merge branch 'master' into fix_infinite_expand

Author: AurelienFT

CHANGELOG.md

@@ -10,6 +10,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - [2551](https://github.com/FuelLabs/fuel-core/pull/2551): Enhanced the DA compressed block header to include block id.
 - [2579](https://github.com/FuelLabs/fuel-core/pull/2579): Clear expiration txs cache in transaction pool based on inserted transactions
 
+### Fixed
+- [2609](https://github.com/FuelLabs/fuel-core/pull/2609): Check response before trying to deserialize, return error instead
+- [2599](https://github.com/FuelLabs/fuel-core/pull/2599): Use the proper `url` apis to construct full url path in `BlockCommitterHttpApi` client
+- [2593](https://github.com/FuelLabs/fuel-core/pull/2593): Fixed utxo id decompression
+
 ## [Version 0.41.0]
 
 ### Added

Cargo.lock

@@ -20,7 +20,6 @@ use fuel_core_types::{
         BlockHeight,
         Bytes32,
     },
-    fuel_vm::SecretKey,
 };
 use serde::{
     Deserialize,
@@ -75,41 +74,6 @@ impl From<CoinConfig> for TableEntry<Coins> {
     }
 }
 
-/// Generates a new coin config with a unique utxo id for testing
-#[derive(Default, Debug)]
-pub struct CoinConfigGenerator {
-    count: usize,
-}
-
-impl CoinConfigGenerator {
-    pub fn new() -> Self {
-        Self { count: 0 }
-    }
-
-    pub fn generate(&mut self) -> CoinConfig {
-        let mut bytes = [0u8; 32];
-        bytes[..std::mem::size_of::<usize>()].copy_from_slice(&self.count.to_be_bytes());
-
-        let config = CoinConfig {
-            tx_id: Bytes32::from(bytes),
-            ..Default::default()
-        };
-        self.count = self.count.checked_add(1).expect("Max coin count reached");
-
-        config
-    }
-
-    pub fn generate_with(&mut self, secret: SecretKey, amount: u64) -> CoinConfig {
-        let owner = Address::from(*secret.public_key().hash());
-
-        CoinConfig {
-            amount,
-            owner,
-            ..self.generate()
-        }
-    }
-}
-
 impl CoinConfig {
     pub fn utxo_id(&self) -> UtxoId {
         UtxoId::new(self.tx_id, self.output_index)
@@ -157,6 +121,62 @@ impl GenesisCommitment for Coin {
     }
 }
 
+#[cfg(feature = "test-helpers")]
+pub mod coin_config_helpers {
+    use crate::CoinConfig;
+    use fuel_core_types::{
+        fuel_types::{
+            Address,
+            Bytes32,
+        },
+        fuel_vm::SecretKey,
+    };
+
+    type CoinCount = u16;
+
+    /// Generates a new coin config with a unique utxo id for testing
+    #[derive(Default, Debug)]
+    pub struct CoinConfigGenerator {
+        count: CoinCount,
+    }
+
+    pub fn tx_id(count: CoinCount) -> Bytes32 {
+        let mut bytes = [0u8; 32];
+        bytes[..size_of::<CoinCount>()].copy_from_slice(&count.to_be_bytes());
+        bytes.into()
+    }
+
+    impl CoinConfigGenerator {
+        pub fn new() -> Self {
+            Self { count: 0 }
+        }
+
+        pub fn generate(&mut self) -> CoinConfig {
+            let tx_id = tx_id(self.count);
+
+            let config = CoinConfig {
+                tx_id,
+                output_index: self.count,
+                ..Default::default()
+            };
+
+            self.count = self.count.checked_add(1).expect("Max coin count reached");
+
+            config
+        }
+
+        pub fn generate_with(&mut self, secret: SecretKey, amount: u64) -> CoinConfig {
+            let owner = Address::from(*secret.public_key().hash());
+
+            CoinConfig {
+                amount,
+                owner,
+                ..self.generate()
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -167,7 +187,7 @@ mod tests {
 
     #[test]
     fn test_generate_unique_utxo_id() {
-        let mut generator = CoinConfigGenerator::new();
+        let mut generator = coin_config_helpers::CoinConfigGenerator::new();
         let config1 = generator.generate();
         let config2 = generator.generate();
 
@@ -180,7 +200,7 @@ mod tests {
         let secret = SecretKey::random(&mut rng);
         let amount = 1000;
 
-        let mut generator = CoinConfigGenerator::new();
+        let mut generator = coin_config_helpers::CoinConfigGenerator::new();
         let config = generator.generate_with(secret, amount);
 
         assert_eq!(config.owner, Address::from(*secret.public_key().hash()));

crates/chain-config/src/config/coin.rs

@@ -46,7 +46,7 @@ use serde::{
 use crate::SnapshotMetadata;
 
 #[cfg(feature = "test-helpers")]
-use crate::CoinConfigGenerator;
+use crate::coin_config_helpers::CoinConfigGenerator;
 #[cfg(feature = "test-helpers")]
 use bech32::{
     ToBase32,

crates/chain-config/src/config/state.rs

@@ -18,6 +18,7 @@ use fuel_core_types::{
         RegistryKey,
     },
     fuel_tx::{
+        field::TxPointer,
         input::{
             coin::{
                 Coin,
@@ -35,6 +36,7 @@ use fuel_core_types::{
         Mint,
         ScriptCode,
         Transaction,
+        TxPointer as FuelTxPointer,
         UtxoId,
     },
     fuel_types::{
@@ -68,12 +70,29 @@ where
         db,
     };
 
-    let transactions = <Vec<Transaction> as DecompressibleBy<_>>::decompress_with(
+    let mut transactions = <Vec<Transaction> as DecompressibleBy<_>>::decompress_with(
         block.transactions(),
         &ctx,
     )
     .await?;
 
+    let transaction_count = transactions.len();
+
+    // patch mint transaction
+    let mint_tx = transactions
+        .last_mut()
+        .ok_or_else(|| anyhow::anyhow!("No transactions"))?;
+    if let Transaction::Mint(mint) = mint_tx {
+        let tx_pointer = mint.tx_pointer_mut();
+        *tx_pointer = FuelTxPointer::new(
+            block.consensus_header().height,
+            #[allow(clippy::arithmetic_side_effects)]
+            u16::try_from(transaction_count - 1)?,
+        );
+    } else {
+        anyhow::bail!("Last transaction is not a mint");
+    }
+
     Ok(PartialFuelBlock {
         header: block.partial_block_header(),
         transactions,
@@ -211,7 +230,7 @@ where
         ctx: &DecompressCtx<D>,
     ) -> anyhow::Result<Self> {
         Ok(Transaction::mint(
-            Default::default(), // TODO: what should this we do with this?
+            Default::default(), // TODO: what should we do with this?
             c.input_contract.decompress(ctx).await?,
             c.output_contract.decompress(ctx).await?,
             c.mint_amount.decompress(ctx).await?,

crates/compression/src/decompress.rs

@@ -285,6 +285,20 @@ pub async fn select_coins_to_spend(
     // See also "let upper_target = target.saturating_mul(2);" in "fn random_improve()".
     const TOTAL_AMOUNT_ADJUSTMENT_FACTOR: u64 = 2;
 
+    // After selecting large coins that cover at least twice the required amount,
+    // we include a limited number of small (dust) coins. The maximum number of dust coins
+    // is determined by the multiplier defined below. Specifically, the number of dust coins
+    // will never exceed FACTOR times the number of large coins selected.
+    //
+    // This limit prevents excessive dust coins from being included in cases where
+    // the query lacks a specified maximum limit (defaulting to 255).
+    //
+    // Example:
+    // - If 3 large coins are selected (and FACTOR is 5), up to 15 dust coins may be included (0..=15).
+    // - Still, if the selected dust can cover the amount of some big coins, the
+    //   latter will be removed from the set
+    const DUST_TO_BIG_COINS_FACTOR: u16 = 5;
+
     if total == 0 || max == 0 {
         return Err(CoinsQueryError::IncorrectQueryParameters {
             provided_total: total,
@@ -327,7 +341,8 @@ pub async fn select_coins_to_spend(
         }
     })?;
 
-    let max_dust_count = max_dust_count(max, number_of_big_coins);
+    let max_dust_count =
+        max_dust_count(max, number_of_big_coins, DUST_TO_BIG_COINS_FACTOR);
     let (dust_coins_total, selected_dust_coins) = dust_coins(
         dust_coins_stream,
         last_selected_big_coin,
@@ -408,9 +423,14 @@ fn is_excluded(key: &CoinsToSpendIndexKey, excluded_ids: &ExcludedCoinIds) -> bo
     }
 }
 
-fn max_dust_count(max: u16, big_coins_len: u16) -> u16 {
+fn max_dust_count(max: u16, big_coins_len: u16, dust_to_big_coins_factor: u16) -> u16 {
     let mut rng = rand::thread_rng();
-    rng.gen_range(0..=max.saturating_sub(big_coins_len))
+
+    let max_from_factor = big_coins_len.saturating_mul(dust_to_big_coins_factor);
+    let max_adjusted = max.saturating_sub(big_coins_len);
+    let upper_bound = max_from_factor.min(max_adjusted);
+
+    rng.gen_range(0..=upper_bound)
 }
 
 fn skip_big_coins_up_to_amount(
@@ -442,6 +462,7 @@ mod tests {
     use crate::{
         coins_query::{
             largest_first,
+            max_dust_count,
             random_improve,
             CoinsQueryError,
             SpendQuery,
@@ -491,6 +512,10 @@ mod tests {
     };
     use futures::TryStreamExt;
     use itertools::Itertools;
+    use proptest::{
+        prelude::*,
+        proptest,
+    };
     use rand::{
         rngs::StdRng,
         Rng,
@@ -1537,6 +1562,27 @@ mod tests {
         )
     }
 
+    proptest! {
+        #[test]
+        fn max_dust_count_respects_limits(
+            max in 1u16..255,
+            number_of_big_coins in 1u16..255,
+            factor in 1u16..10,
+        ) {
+            // We're at the stage of the algorithm where we have already selected the big coins and
+            // we're trying to select the dust coins.
+            // So we're sure that the following assumptions hold:
+            // 1. number_of_big_coins <= max - big coin selection algo is capped at 'max'.
+            // 2. there must be at least one big coin selected, otherwise we'll break
+            //    with the `InsufficientCoinsForTheMax` error earlier.
+            prop_assume!(number_of_big_coins <= max && number_of_big_coins >= 1);
+
+            let max_dust_count = max_dust_count(max, number_of_big_coins, factor);
+            prop_assert!(number_of_big_coins + max_dust_count <= max);
+            prop_assert!(max_dust_count <= number_of_big_coins.saturating_mul(factor));
+        }
+    }
+
     #[test_case::test_case(
         TestCase {
             db_amount: vec![u64::MAX, u64::MAX],

crates/fuel-core/src/coins_query.rs

@@ -273,10 +273,7 @@ impl_temporal_registry!(ContractId);
 impl_temporal_registry!(ScriptCode);
 impl_temporal_registry!(PredicateCode);
 
-impl<'a, Tx> UtxoIdToPointer for CompressDbTx<'a, Tx>
-where
-    Tx: OffChainDatabaseTransaction,
-{
+impl<'a, Tx> UtxoIdToPointer for CompressDbTx<'a, Tx> {
     fn lookup(
         &self,
         utxo_id: fuel_core_types::fuel_tx::UtxoId,
@@ -301,7 +298,6 @@ where
 
 impl<'a, Tx, Onchain> HistoryLookup for DecompressDbTx<'a, Tx, Onchain>
 where
-    Tx: OffChainDatabaseTransaction,
     Onchain: StorageInspect<Coins, Error = fuel_core_storage::Error>
         + StorageInspect<Messages, Error = fuel_core_storage::Error>
         + StorageInspect<FuelBlocks, Error = fuel_core_storage::Error>,
@@ -310,17 +306,16 @@ where
         &self,
         c: fuel_core_types::fuel_tx::CompressedUtxoId,
     ) -> anyhow::Result<fuel_core_types::fuel_tx::UtxoId> {
+        #[cfg(feature = "test-helpers")]
         if c.tx_pointer.block_height() == 0u32.into() {
             // This is a genesis coin, which is handled differently.
             // See CoinConfigGenerator::generate which generates the genesis coins.
-            let mut bytes = [0u8; 32];
-            let tx_index = c.tx_pointer.tx_index();
-            bytes[..std::mem::size_of_val(&tx_index)]
-                .copy_from_slice(&tx_index.to_be_bytes());
-            return Ok(fuel_core_types::fuel_tx::UtxoId::new(
-                fuel_core_types::fuel_tx::TxId::from(bytes),
-                0,
-            ));
+            let tx_id =
+                fuel_core_chain_config::coin_config_helpers::tx_id(c.output_index);
+
+            let utxo_id = fuel_core_types::fuel_tx::UtxoId::new(tx_id, c.output_index);
+
+            return Ok(utxo_id);
         }
 
         let block_info = self

crates/fuel-core/src/graphql_api/da_compression.rs

@@ -2,8 +2,8 @@
 
 use crate::{
     chain_config::{
+        coin_config_helpers::CoinConfigGenerator,
         CoinConfig,
-        CoinConfigGenerator,
     },
     combined_database::CombinedDatabase,
     database::{
@@ -246,7 +246,7 @@ pub async fn make_nodes(
                     let initial_coin = CoinConfig {
                         // set idx to prevent overlapping utxo_ids when
                         // merging with existing coins from config
-                        output_index: 2,
+                        output_index: 10,
                         ..coin_generator.generate_with(secret, 10000)
                     };
                     let tx = TransactionBuilder::script(

crates/fuel-core/src/p2p_test_helpers.rs

@@ -22,7 +22,7 @@ num_enum = { workspace = true }
 parking_lot = { workspace = true }
 reqwest = { workspace = true, features = ["json"] }
 serde = { workspace = true }
-serde_json = { workspace = true, optional = true }
+serde_json = { workspace = true }
 strum = { workspace = true, features = ["derive"] }
 strum_macros = { workspace = true }
 thiserror = { workspace = true }
@@ -39,4 +39,4 @@ mockito = { version = "1.6.1" }
 serde_json = { workspace = true }
 
 [features]
-test-helpers = ["dep:mockito", "dep:serde_json"]
+test-helpers = ["dep:mockito"]