refactor(types): vbyte -> storage score

bindings/core/src/method_handler/client.rs

@@ -9,7 +9,8 @@ use iota_sdk::{
         api::core::response::OutputWithMetadataResponse,
         block::{
             output::{
-                dto::OutputDto, AccountOutput, BasicOutput, FoundryOutput, NftOutput, Output, OutputBuilderAmount, Rent,
+                dto::OutputDto, AccountOutput, BasicOutput, FoundryOutput, NftOutput, Output, OutputBuilderAmount,
+                StorageScore,
             },
             payload::Payload,
             BlockWrapper, BlockWrapperDto,
@@ -297,7 +298,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
             let output = Output::try_from_dto_with_params(output, client.get_token_supply().await?)?;
             let rent_structure = client.get_rent_structure().await?;
 
-            let minimum_storage_deposit = output.rent_cost(rent_structure);
+            let minimum_storage_deposit = output.storage_score(rent_structure);
 
             Response::MinimumRequiredStorageDeposit(minimum_storage_deposit.to_string())
         }

bindings/core/src/method_handler/utils.rs

@@ -8,7 +8,7 @@ use iota_sdk::{
         block::{
             address::{AccountAddress, Address, ToBech32Ext},
             input::UtxoInput,
-            output::{AccountId, FoundryId, InputsCommitment, NftId, Output, OutputId, Rent, TokenId},
+            output::{AccountId, FoundryId, InputsCommitment, NftId, Output, OutputId, StorageScore, TokenId},
             payload::{transaction::TransactionEssence, TransactionPayload},
             BlockWrapper,
         },
@@ -80,7 +80,7 @@ pub(crate) fn call_utils_method_internal(method: UtilsMethod) -> Result<Response
         }
         UtilsMethod::ComputeStorageDeposit { output, rent } => {
             let out = Output::try_from_dto(output)?;
-            Response::MinimumRequiredStorageDeposit(out.rent_cost(rent).to_string())
+            Response::MinimumRequiredStorageDeposit(out.storage_score(rent).to_string())
         }
         UtilsMethod::VerifyMnemonic { mnemonic } => {
             let mnemonic = Mnemonic::from(mnemonic);

sdk/src/client/api/block_builder/input_selection/requirement/amount.rs

@@ -11,7 +11,7 @@ use crate::{
         input::INPUT_COUNT_MAX,
         output::{
             unlock_condition::StorageDepositReturnUnlockCondition, AccountOutputBuilder, AccountTransition,
-            FoundryOutputBuilder, NftOutputBuilder, Output, OutputId, Rent,
+            FoundryOutputBuilder, NftOutputBuilder, Output, OutputId, StorageScore,
         },
         slot::SlotIndex,
     },
@@ -240,7 +240,7 @@ impl InputSelection {
         for output in outputs {
             let diff = amount_selection.missing_amount();
             let amount = output.amount();
-            let rent = output.rent_cost(self.protocol_parameters.rent_structure());
+            let rent = output.storage_score(self.protocol_parameters.rent_structure());
 
             let new_amount = if amount >= diff + rent { amount - diff } else { rent };
 

sdk/src/types/block/output/account.rs

@@ -22,8 +22,8 @@ use crate::types::{
                 verify_allowed_unlock_conditions, UnlockCondition, UnlockConditionFlags, UnlockConditions,
             },
             verify_output_amount_min, verify_output_amount_packable, verify_output_amount_supply, ChainId, NativeToken,
-            NativeTokens, Output, OutputBuilderAmount, OutputId, Rent, RentStructure, StateTransitionError,
-            StateTransitionVerifier,
+            NativeTokens, Output, OutputBuilderAmount, OutputId, RentStructure, StateTransitionError,
+            StateTransitionVerifier, StorageScore,
         },
         protocol::ProtocolParameters,
         semantic::{TransactionFailureReason, ValidationContext},
@@ -319,7 +319,7 @@ impl AccountOutputBuilder {
         output.amount = match self.amount {
             OutputBuilderAmount::Amount(amount) => amount,
             OutputBuilderAmount::MinimumStorageDeposit(rent_structure) => {
-                Output::Account(output.clone()).rent_cost(rent_structure)
+                Output::Account(output.clone()).storage_score(rent_structure)
             }
         };
 

sdk/src/types/block/output/basic.rs

@@ -14,7 +14,7 @@ use crate::types::{
                 verify_allowed_unlock_conditions, UnlockCondition, UnlockConditionFlags, UnlockConditions,
             },
             verify_output_amount_min, verify_output_amount_packable, verify_output_amount_supply, NativeToken,
-            NativeTokens, Output, OutputBuilderAmount, OutputId, Rent, RentStructure,
+            NativeTokens, Output, OutputBuilderAmount, OutputId, RentStructure, StorageScore,
         },
         protocol::ProtocolParameters,
         semantic::{TransactionFailureReason, ValidationContext},
@@ -172,7 +172,7 @@ impl BasicOutputBuilder {
         output.amount = match self.amount {
             OutputBuilderAmount::Amount(amount) => amount,
             OutputBuilderAmount::MinimumStorageDeposit(rent_structure) => {
-                Output::Basic(output.clone()).rent_cost(rent_structure)
+                Output::Basic(output.clone()).storage_score(rent_structure)
             }
         };
 

sdk/src/types/block/output/delegation.rs

@@ -19,7 +19,7 @@ use crate::types::{
                 verify_allowed_unlock_conditions, UnlockCondition, UnlockConditionFlags, UnlockConditions,
             },
             verify_output_amount_min, verify_output_amount_packable, verify_output_amount_supply, Output,
-            OutputBuilderAmount, OutputId, Rent, RentStructure, StateTransitionError, StateTransitionVerifier,
+            OutputBuilderAmount, OutputId, RentStructure, StateTransitionError, StateTransitionVerifier, StorageScore,
         },
         protocol::ProtocolParameters,
         semantic::{TransactionFailureReason, ValidationContext},
@@ -195,7 +195,7 @@ impl DelegationOutputBuilder {
         output.amount = match self.amount {
             OutputBuilderAmount::Amount(amount) => amount,
             OutputBuilderAmount::MinimumStorageDeposit(rent_structure) => {
-                Output::Delegation(output.clone()).rent_cost(rent_structure)
+                Output::Delegation(output.clone()).storage_score(rent_structure)
             }
         };
 

sdk/src/types/block/output/foundry.rs

@@ -22,8 +22,8 @@ use crate::types::{
                 verify_allowed_unlock_conditions, UnlockCondition, UnlockConditionFlags, UnlockConditions,
             },
             verify_output_amount_min, verify_output_amount_packable, verify_output_amount_supply, ChainId, NativeToken,
-            NativeTokens, Output, OutputBuilderAmount, OutputId, Rent, RentStructure, StateTransitionError,
-            StateTransitionVerifier, TokenId, TokenScheme,
+            NativeTokens, Output, OutputBuilderAmount, OutputId, RentStructure, StateTransitionError,
+            StateTransitionVerifier, StorageScore, TokenId, TokenScheme,
         },
         protocol::ProtocolParameters,
         semantic::{TransactionFailureReason, ValidationContext},
@@ -283,7 +283,7 @@ impl FoundryOutputBuilder {
         output.amount = match self.amount {
             OutputBuilderAmount::Amount(amount) => amount,
             OutputBuilderAmount::MinimumStorageDeposit(rent_structure) => {
-                Output::Foundry(output.clone()).rent_cost(rent_structure)
+                Output::Foundry(output.clone()).storage_score(rent_structure)
             }
         };
 

sdk/src/types/block/output/mod.rs

@@ -53,7 +53,7 @@ pub use self::{
     native_token::{NativeToken, NativeTokens, NativeTokensBuilder, TokenId},
     nft::{NftId, NftOutput, NftOutputBuilder},
     output_id::OutputId,
-    rent::{MinimumStorageDepositBasicOutput, Rent, RentStructure},
+    rent::{MinimumStorageDepositBasicOutput, RentStructure, StorageScore},
     state_transition::{StateTransitionError, StateTransitionVerifier},
     token_scheme::{SimpleTokenScheme, TokenScheme},
     unlock_condition::{UnlockCondition, UnlockConditions},
@@ -384,7 +384,7 @@ impl Output {
     /// If there is a [`StorageDepositReturnUnlockCondition`](unlock_condition::StorageDepositReturnUnlockCondition),
     /// its amount is also checked.
     pub fn verify_storage_deposit(&self, rent_structure: RentStructure, token_supply: u64) -> Result<(), Error> {
-        let required_output_amount = self.rent_cost(rent_structure);
+        let required_output_amount = self.storage_score(rent_structure);
 
         if self.amount() < required_output_amount {
             return Err(Error::InsufficientStorageDepositAmount {
@@ -468,9 +468,9 @@ impl Packable for Output {
     }
 }
 
-impl Rent for Output {
+impl StorageScore for Output {
     fn weighted_bytes(&self, rent_structure: RentStructure) -> u64 {
-        self.packed_len() as u64 * rent_structure.byte_factor_data() as u64
+        self.packed_len() as u64 * rent_structure.storage_score_factor_data() as u64
     }
 }
 

sdk/src/types/block/output/nft.rs

@@ -19,8 +19,8 @@ use crate::types::{
                 verify_allowed_unlock_conditions, UnlockCondition, UnlockConditionFlags, UnlockConditions,
             },
             verify_output_amount_min, verify_output_amount_packable, verify_output_amount_supply, ChainId, NativeToken,
-            NativeTokens, Output, OutputBuilderAmount, OutputId, Rent, RentStructure, StateTransitionError,
-            StateTransitionVerifier,
+            NativeTokens, Output, OutputBuilderAmount, OutputId, RentStructure, StateTransitionError,
+            StateTransitionVerifier, StorageScore,
         },
         protocol::ProtocolParameters,
         semantic::{TransactionFailureReason, ValidationContext},
@@ -244,7 +244,7 @@ impl NftOutputBuilder {
         output.amount = match self.amount {
             OutputBuilderAmount::Amount(amount) => amount,
             OutputBuilderAmount::MinimumStorageDeposit(rent_structure) => {
-                Output::Nft(output.clone()).rent_cost(rent_structure)
+                Output::Nft(output.clone()).storage_score(rent_structure)
             }
         };