Some renames lost in the merge

sdk/src/wallet/operations/balance.rs

@@ -34,7 +34,7 @@ where
         wallet_data: &WalletData,
     ) -> Result<Balance> {
         let network_id = self.client().get_network_id().await?;
-        let storage_params = self.client().get_storage_score_parameters().await?;
+        let storage_score_params = self.client().get_storage_score_parameters().await?;
         let mut balance = Balance::default();
         let mut total_rent_amount = 0;
         let mut total_native_tokens = NativeTokensBuilder::default();
@@ -58,7 +58,7 @@ where
             }
 
             let output = &output_data.output;
-            let storage_cost = output.storage_cost(storage_params);
+            let storage_cost = output.storage_cost(storage_score_params);
 
             // Add account and foundry outputs here because they can't have a
             // [`StorageDepositReturnUnlockCondition`] or time related unlock conditions

sdk/src/wallet/operations/transaction/high_level/create_account.rs

@@ -74,7 +74,7 @@ where
         options: impl Into<Option<TransactionOptions>> + Send,
     ) -> crate::wallet::Result<PreparedTransactionData> {
         log::debug!("[TRANSACTION] prepare_create_account_output");
-        let storage_params = self.client().get_storage_score_parameters().await?;
+        let storage_score_params = self.client().get_storage_score_parameters().await?;
 
         let address = match params.as_ref().and_then(|options| options.address.as_ref()) {
             Some(bech32_address) => {
@@ -85,7 +85,7 @@ where
         };
 
         let mut account_output_builder =
-            AccountOutputBuilder::new_with_minimum_amount(storage_params, AccountId::null())
+            AccountOutputBuilder::new_with_minimum_amount(storage_score_params, AccountId::null())
                 .with_foundry_counter(0)
                 .add_unlock_condition(AddressUnlockCondition::new(address.clone()));
         if let Some(CreateAccountParams {

sdk/src/wallet/operations/transaction/high_level/minting/create_native_token.rs

@@ -133,7 +133,7 @@ where
         options: impl Into<Option<TransactionOptions>> + Send,
     ) -> crate::wallet::Result<PreparedCreateNativeTokenTransaction> {
         log::debug!("[TRANSACTION] create_native_token");
-        let storage_params = self.client().get_storage_score_parameters().await?;
+        let storage_score_params = self.client().get_storage_score_parameters().await?;
 
         let (account_id, account_output) = self
             .get_account_output(params.account_id)
@@ -158,7 +158,7 @@ where
                 new_account_output_builder.finish_output()?,
                 {
                     let mut foundry_builder = FoundryOutputBuilder::new_with_minimum_amount(
-                        storage_params,
+                        storage_score_params,
                         account_output.foundry_counter() + 1,
                         TokenScheme::Simple(SimpleTokenScheme::new(
                             params.circulating_supply,

sdk/src/wallet/operations/transaction/high_level/minting/mint_nfts.rs

@@ -161,7 +161,7 @@ where
         I::IntoIter: Send,
     {
         log::debug!("[TRANSACTION] prepare_mint_nfts");
-        let storage_params = self.client().get_storage_score_parameters().await?;
+        let storage_score_params = self.client().get_storage_score_parameters().await?;
         let wallet_address = self.address().await.into_inner();
         let mut outputs = Vec::new();
 
@@ -183,7 +183,7 @@ where
             };
 
             // NftId needs to be set to 0 for the creation
-            let mut nft_builder = NftOutputBuilder::new_with_minimum_amount(storage_params, NftId::null())
+            let mut nft_builder = NftOutputBuilder::new_with_minimum_amount(storage_score_params, NftId::null())
                 // Address which will own the nft
                 .add_unlock_condition(AddressUnlockCondition::new(address));
 

sdk/src/wallet/operations/transaction/high_level/send.rs

@@ -137,7 +137,7 @@ where
     {
         log::debug!("[TRANSACTION] prepare_send");
         let options = options.into();
-        let storage_params = self.client().get_storage_score_parameters().await?;
+        let storage_score_params = self.client().get_storage_score_parameters().await?;
         let token_supply = self.client().get_token_supply().await?;
 
         let wallet_address = self.address().await;
@@ -173,7 +173,7 @@ where
                 .add_unlock_condition(AddressUnlockCondition::new(address))
                 .finish()?;
 
-            if amount >= output.storage_cost(storage_params) {
+            if amount >= output.storage_cost(storage_score_params) {
                 outputs.push(output.into())
             } else {
                 let expiration_slot_index = expiration
@@ -187,7 +187,7 @@ where
                         return_address.clone(),
                         expiration_slot_index,
                     )?)
-                    .with_sufficient_storage_deposit(return_address, storage_params, token_supply)?
+                    .with_sufficient_storage_deposit(return_address, storage_score_params, token_supply)?
                     .finish_output()?;
 
                 if !options.as_ref().map(|o| o.allow_micro_amount).unwrap_or_default() {

sdk/src/wallet/operations/transaction/high_level/send_native_tokens.rs

@@ -127,7 +127,7 @@ where
         I::IntoIter: Send,
     {
         log::debug!("[TRANSACTION] prepare_send_native_tokens");
-        let storage_params = self.client().get_storage_score_parameters().await?;
+        let storage_score_params = self.client().get_storage_score_parameters().await?;
         let token_supply = self.client().get_token_supply().await?;
 
         let wallet_address = self.address().await;
@@ -179,7 +179,7 @@ where
                         return_address.clone(),
                         expiration_slot_index,
                     )?)
-                    .with_sufficient_storage_deposit(return_address, storage_params, token_supply)?
+                    .with_sufficient_storage_deposit(return_address, storage_score_params, token_supply)?
                     .finish_output()?,
             )
         }

sdk/src/wallet/operations/transaction/prepare_output.rs

@@ -49,12 +49,12 @@ where
 
         self.client().bech32_hrp_matches(params.recipient_address.hrp()).await?;
 
-        let storage_params = self.client().get_storage_score_parameters().await?;
+        let storage_score_params = self.client().get_storage_score_parameters().await?;
 
         let nft_id = params.assets.as_ref().and_then(|a| a.nft_id);
 
         let (mut first_output_builder, existing_nft_output_data) = self
-            .create_initial_output_builder(params.recipient_address, nft_id, storage_params)
+            .create_initial_output_builder(params.recipient_address, nft_id, storage_score_params)
             .await?;
 
         if let Some(assets) = &params.assets {
@@ -105,7 +105,7 @@ where
 
         // Build output with minimum required storage deposit so we can use the amount in the next step
         let first_output = first_output_builder
-            .with_minimum_amount(storage_params)
+            .with_minimum_amount(storage_score_params)
             .finish_output(token_supply)?;
 
         let mut second_output_builder = if nft_id.is_some() {
@@ -115,12 +115,12 @@ where
         };
 
         // TODO: Probably not good to use ed25519 always here, even if technically it's the same for now..
-        let min_storage_deposit_basic_output = BasicOutputBuilder::new_with_minimum_amount(storage_params)
+        let min_storage_deposit_basic_output = BasicOutputBuilder::new_with_minimum_amount(storage_score_params)
             .add_unlock_condition(AddressUnlockCondition::new(Ed25519Address::null()))
             .finish()?
             .amount();
 
-        let min_required_storage_deposit = first_output.storage_cost(storage_params);
+        let min_required_storage_deposit = first_output.storage_cost(storage_score_params);
 
         if params.amount > min_required_storage_deposit {
             second_output_builder = second_output_builder.with_amount(params.amount);
@@ -152,7 +152,7 @@ where
                 // need to check the min required storage deposit again
                 let min_storage_deposit_new_amount = second_output_builder
                     .clone()
-                    .with_minimum_amount(storage_params)
+                    .with_minimum_amount(storage_score_params)
                     .finish_output(token_supply)?
                     .amount();
 
@@ -182,7 +182,7 @@ where
         // If we're sending an existing NFT, its minimum required storage deposit is not part of the available base_coin
         // balance, so we add it here
         if let Some(existing_nft_output_data) = existing_nft_output_data {
-            available_base_coin += existing_nft_output_data.output.storage_cost(storage_params);
+            available_base_coin += existing_nft_output_data.output.storage_cost(storage_score_params);
         }
 
         if final_amount > available_base_coin {