Refactor rent cost traits

bindings/core/src/method/client.rs

@@ -37,7 +37,7 @@ pub enum ClientMethod {
     #[allow(missing_docs)]
     #[serde(rename_all = "camelCase")]
     BuildAccountOutput {
-        // If not provided, minimum storage deposit will be used
+        // If not provided, minimum amount will be used
         #[serde(default, with = "option_string")]
         amount: Option<u64>,
         // TODO: Determine if `default` is wanted here
@@ -55,7 +55,7 @@ pub enum ClientMethod {
     #[allow(missing_docs)]
     #[serde(rename_all = "camelCase")]
     BuildBasicOutput {
-        // If not provided, minimum storage deposit will be used
+        // If not provided, minimum amount will be used
         #[serde(default, with = "option_string")]
         amount: Option<u64>,
         // TODO: Determine if `default` is wanted here
@@ -70,7 +70,7 @@ pub enum ClientMethod {
     #[allow(missing_docs)]
     #[serde(rename_all = "camelCase")]
     BuildFoundryOutput {
-        // If not provided, minimum storage deposit will be used
+        // If not provided, minimum amount will be used
         #[serde(default, with = "option_string")]
         amount: Option<u64>,
         native_tokens: Option<Vec<NativeToken>>,
@@ -85,7 +85,7 @@ pub enum ClientMethod {
     #[allow(missing_docs)]
     #[serde(rename_all = "camelCase")]
     BuildNftOutput {
-        // If not provided, minimum storage deposit will be used
+        // If not provided, minimum amount will be used
         #[serde(default, with = "option_string")]
         amount: Option<u64>,
         // TODO: Determine if `default` is wanted here
@@ -351,10 +351,10 @@ pub enum ClientMethod {
         /// Human readable part
         bech32_hrp: Option<Hrp>,
     },
-    /// Calculate the minimum required storage deposit for an output.
+    /// Calculate the minimum required amount for an output.
     /// Expected response:
-    /// [`MinimumRequiredStorageDeposit`](crate::Response::MinimumRequiredStorageDeposit)
-    MinimumRequiredStorageDeposit { output: OutputDto },
+    /// [`OutputAmount`](crate::Response::OutputAmount)
+    ComputeMinimumOutputAmount { output: OutputDto },
     /// Requests funds for a given address from the faucet, for example `https://faucet.testnet.shimmer.network/api/enqueue` or `http://localhost:8091/api/enqueue`.
     RequestFundsFromFaucet {
         /// Faucet URL

bindings/core/src/method/utils.rs

@@ -4,7 +4,7 @@
 use derivative::Derivative;
 use iota_sdk::types::block::{
     address::{Bech32Address, Hrp},
-    output::{dto::OutputDto, AccountId, NftId, OutputId, RentStructure},
+    output::{dto::OutputDto, AccountId, NftId, OutputId, StorageScoreParameters},
     payload::signed_transaction::{
         dto::{SignedTransactionPayloadDto, TransactionDto},
         TransactionId,
@@ -128,8 +128,12 @@ pub enum UtilsMethod {
         /// The transaction.
         transaction: TransactionDto,
     },
-    /// Computes the required storage deposit of an output.
-    ComputeStorageDeposit { output: OutputDto, rent: RentStructure },
+    /// Computes the minimum required amount of an output.
+    #[serde(rename_all = "camelCase")]
+    ComputeMinimumOutputAmount {
+        output: OutputDto,
+        storage_score_parameters: StorageScoreParameters,
+    },
     /// Checks if the given mnemonic is valid.
     /// Expected response: [`Ok`](crate::Response::Ok)
     VerifyMnemonic {

bindings/core/src/method_handler/client.rs

@@ -9,7 +9,8 @@ use iota_sdk::{
         api::core::OutputWithMetadataResponse,
         block::{
             output::{
-                dto::OutputDto, AccountOutput, BasicOutput, FoundryOutput, NftOutput, Output, OutputBuilderAmount, Rent,
+                dto::OutputDto, AccountOutput, BasicOutput, FoundryOutput, MinimumOutputAmount, NftOutput, Output,
+                OutputBuilderAmount,
             },
             payload::Payload,
             SignedBlock, SignedBlockDto, UnsignedBlockDto,
@@ -69,7 +70,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
                 if let Some(amount) = amount {
                     OutputBuilderAmount::Amount(amount)
                 } else {
-                    OutputBuilderAmount::MinimumStorageDeposit(client.get_rent_structure().await?)
+                    OutputBuilderAmount::MinimumAmount(client.get_storage_score_parameters().await?)
                 },
                 mana,
                 native_tokens,
@@ -94,7 +95,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
                 if let Some(amount) = amount {
                     OutputBuilderAmount::Amount(amount)
                 } else {
-                    OutputBuilderAmount::MinimumStorageDeposit(client.get_rent_structure().await?)
+                    OutputBuilderAmount::MinimumAmount(client.get_storage_score_parameters().await?)
                 },
                 mana,
                 native_tokens,
@@ -118,7 +119,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
                 if let Some(amount) = amount {
                     OutputBuilderAmount::Amount(amount)
                 } else {
-                    OutputBuilderAmount::MinimumStorageDeposit(client.get_rent_structure().await?)
+                    OutputBuilderAmount::MinimumAmount(client.get_storage_score_parameters().await?)
                 },
                 native_tokens,
                 serial_number,
@@ -144,7 +145,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
                 if let Some(amount) = amount {
                     OutputBuilderAmount::Amount(amount)
                 } else {
-                    OutputBuilderAmount::MinimumStorageDeposit(client.get_rent_structure().await?)
+                    OutputBuilderAmount::MinimumAmount(client.get_storage_score_parameters().await?)
                 },
                 mana,
                 native_tokens,
@@ -294,13 +295,11 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
         ClientMethod::HexPublicKeyToBech32Address { hex, bech32_hrp } => {
             Response::Bech32Address(client.hex_public_key_to_bech32_address(&hex, bech32_hrp).await?)
         }
-        ClientMethod::MinimumRequiredStorageDeposit { output } => {
+        ClientMethod::ComputeMinimumOutputAmount { output } => {
             let output = Output::try_from_dto_with_params(output, client.get_token_supply().await?)?;
-            let rent_structure = client.get_rent_structure().await?;
+            let storage_score_params = client.get_storage_score_parameters().await?;
 
-            let minimum_storage_deposit = output.rent_cost(rent_structure);
-
-            Response::MinimumRequiredStorageDeposit(minimum_storage_deposit.to_string())
+            Response::OutputAmount(output.minimum_amount(storage_score_params))
         }
         ClientMethod::RequestFundsFromFaucet { url, address } => {
             Response::Faucet(request_funds_from_faucet(&url, &address).await?)

bindings/core/src/method_handler/utils.rs

@@ -8,7 +8,7 @@ use iota_sdk::{
         block::{
             address::{AccountAddress, Address, ToBech32Ext},
             input::UtxoInput,
-            output::{AccountId, FoundryId, NftId, Output, OutputId, Rent, TokenId},
+            output::{AccountId, FoundryId, MinimumOutputAmount, NftId, Output, OutputId, TokenId},
             payload::{signed_transaction::Transaction, SignedTransactionPayload},
             SignedBlock,
         },
@@ -72,9 +72,12 @@ pub(crate) fn call_utils_method_internal(method: UtilsMethod) -> Result<Response
         UtilsMethod::TransactionSigningHash { transaction } => {
             Response::Hash(Transaction::try_from_dto(transaction)?.signing_hash().to_string())
         }
-        UtilsMethod::ComputeStorageDeposit { output, rent } => {
+        UtilsMethod::ComputeMinimumOutputAmount {
+            output,
+            storage_score_parameters: storage_params,
+        } => {
             let out = Output::try_from_dto(output)?;
-            Response::MinimumRequiredStorageDeposit(out.rent_cost(rent).to_string())
+            Response::OutputAmount(out.minimum_amount(storage_params))
         }
         UtilsMethod::VerifyMnemonic { mnemonic } => {
             let mnemonic = Mnemonic::from(mnemonic);

bindings/core/src/response.rs

@@ -33,6 +33,7 @@ use iota_sdk::{
             BlockId, SignedBlockDto, UnsignedBlockDto,
         },
     },
+    utils::serde::string,
     wallet::{
         types::{Balance, OutputDataDto, TransactionWithMetadataDto},
         PreparedCreateNativeTokenTransactionDto,
@@ -256,9 +257,9 @@ pub enum Response {
     /// - [`GetAddress`](crate::method::WalletMethod::GetAddress)
     Address(Bech32Address),
     /// Response for:
-    /// - [`MinimumRequiredStorageDeposit`](crate::method::ClientMethod::MinimumRequiredStorageDeposit)
-    /// - [`ComputeStorageDeposit`](crate::method::UtilsMethod::ComputeStorageDeposit)
-    MinimumRequiredStorageDeposit(String),
+    /// - [`ClientMethod::ComputeMinimumOutputAmount`](crate::method::ClientMethod::ComputeMinimumOutputAmount)
+    /// - [`UtilsMethod::ComputeMinimumOutputAmount`](crate::method::UtilsMethod::ComputeMinimumOutputAmount)
+    OutputAmount(#[serde(with = "string")] u64),
     /// Response for:
     /// - [`ClaimableOutputs`](crate::method::WalletMethod::ClaimableOutputs)
     OutputIds(Vec<OutputId>),

bindings/nodejs/examples/wallet/06-send-micro-transaction.ts

@@ -11,7 +11,7 @@ const SEND_MICRO_AMOUNT = BigInt(1);
 const RECV_ADDRESS =
     'rms1qpszqzadsym6wpppd6z037dvlejmjuke7s24hm95s9fg9vpua7vluaw60xu';
 
-// In this example we will send an amount below the minimum storage deposit.
+// In this example we will send an amount below the minimum output amount.
 //
 // Make sure that `STRONGHOLD_SNAPSHOT_PATH` and `WALLET_DB_PATH` already exist by
 // running the `how_tos/accounts_and_addresses/create-wallet` example!

bindings/nodejs/lib/client/client.ts

@@ -692,14 +692,14 @@ export class Client {
     }
 
     /**
-     * Calculate the minimum required storage deposit for an output.
+     * Calculate the minimum required amount for an output.
      *
-     * @param output The output to calculate the minimum deposit amount for.
+     * @param output The output to calculate the minimum amount for.
      * @returns The minimum required amount.
      */
-    async minimumRequiredStorageDeposit(output: Output): Promise<number> {
+    async computeMinimumOutputAmount(output: Output): Promise<number> {
         const response = await this.methodHandler.callMethod({
-            name: 'minimumRequiredStorageDeposit',
+            name: 'computeMinimumOutputAmount',
             data: {
                 output,
             },

bindings/nodejs/lib/types/client/bridge/client.ts

@@ -256,8 +256,8 @@ export interface __ClearListenersMethod__ {
     };
 }
 
-export type __MinimumRequiredStorageDepositMethod__ = {
-    name: 'minimumRequiredStorageDeposit';
+export type __ComputeMinimumOutputAmountMethod__ = {
+    name: 'computeMinimumOutputAmount';
     data: {
         output: Output;
     };

bindings/nodejs/lib/types/client/bridge/index.ts

@@ -49,7 +49,7 @@ import type {
     __BuildNftOutputMethod__,
     __ClearListenersMethod__,
     __SignatureUnlockMethod__,
-    __MinimumRequiredStorageDepositMethod__,
+    __ComputeMinimumOutputAmountMethod__,
     __RequestFundsFromFaucetMethod__,
     __CallPluginRouteMethod__,
 } from './client';
@@ -102,6 +102,6 @@ export type __ClientMethods__ =
     | __BuildFoundryOutputMethod__
     | __BuildNftOutputMethod__
     | __ClearListenersMethod__
-    | __MinimumRequiredStorageDepositMethod__
+    | __ComputeMinimumOutputAmountMethod__
     | __RequestFundsFromFaucetMethod__
     | __CallPluginRouteMethod__;

bindings/nodejs/lib/types/client/output_builder_params/basic-output-params.ts

@@ -14,7 +14,7 @@ import {
  */
 export interface BasicOutputBuilderParams {
     /**
-     * If not provided, minimum storage deposit will be used
+     * If not provided, minimum amount will be used
      */
     amount?: u64 | NumericString;
     /**

bindings/nodejs/lib/types/wallet/output-params.ts

@@ -58,7 +58,7 @@ export interface StorageDeposit {
     returnStrategy?: ReturnStrategy;
     /**
      * Determines whether the storage deposit will automatically add excess small funds when necessary.
-     * For example, given an account has 20 tokens and wants to send 15 tokens, and the minimum storage deposit
+     * For example, given an account has 20 tokens and wants to send 15 tokens, and the minimum amount
      * is 10 tokens, it wouldn't be possible to create an output with the 5 token remainder. If this flag is enabled,
      * the 5 tokens will be added to the output automatically.
      */
@@ -67,8 +67,8 @@ export interface StorageDeposit {
 
 /** Return strategy for the storage deposit. */
 export enum ReturnStrategy {
-    /** A storage deposit return unlock condition will be added with the required minimum storage deposit. */
+    /** A storage deposit return unlock condition will be added with the additional amount needed to satisfy storage costs. */
     Return = 'Return',
-    /** The recipient address will get the additional amount to reach the minimum storage deposit gifted. */
+    /** The recipient address will receive the additional amount needed to satisfy storage costs. */
     Gift = 'Gift',
 }

bindings/python/examples/how_tos/advanced_transactions/send_micro_transaction.py

@@ -6,7 +6,7 @@
 
 load_dotenv()
 
-# In this example we will send an amount below the minimum storage deposit
+# In this example we will send an amount below the minimum amount
 
 wallet = Wallet(os.environ['WALLET_DB_PATH'])
 

bindings/python/iota_sdk/client/_utils.py

@@ -49,11 +49,11 @@ def hex_public_key_to_bech32_address(
             'bech32Hrp': bech32_hrp
         })
 
-    def minimum_required_storage_deposit(self, output: Output) -> int:
-        """Minimum required storage deposit.
+    def computer_minimum_output_amount(self, output: Output) -> int:
+        """Minimum required output amount.
         """
         return int(self._call_method(
-            'minimumRequiredStorageDeposit', {
+            'computeMinimumOutputAmount', {
                 'output': output.to_dict()
             }
         ))

cli/src/wallet_cli/mod.rs

@@ -730,11 +730,11 @@ pub async fn send_native_token_command(
     let address = address.convert()?;
     let transaction = if gift_storage_deposit.unwrap_or(false) {
         // Send native tokens together with the required storage deposit
-        let rent_structure = wallet.client().get_rent_structure().await?;
+        let storage_params = wallet.client().get_storage_score_parameters().await?;
 
         wallet.client().bech32_hrp_matches(address.hrp()).await?;
 
-        let outputs = [BasicOutputBuilder::new_with_minimum_storage_deposit(rent_structure)
+        let outputs = [BasicOutputBuilder::new_with_minimum_amount(storage_params)
             .add_unlock_condition(AddressUnlockCondition::new(address))
             .with_native_tokens([NativeToken::new(
                 TokenId::from_str(&token_id)?,

sdk/examples/client/output/build_account_output.rs

@@ -34,15 +34,15 @@ async fn main() -> Result<()> {
         .finish()
         .await?;
 
-    let rent_structure = client.get_rent_structure().await?;
+    let storage_score_params = client.get_storage_score_parameters().await?;
 
     let address = std::env::args()
         .nth(1)
         .unwrap_or("rms1qpllaj0pyveqfkwxmnngz2c488hfdtmfrj3wfkgxtk4gtyrax0jaxzt70zy".to_string());
     let address = Address::try_from_bech32(address)?;
 
     // Account id needs to be null the first time
-    let account_output = AccountOutputBuilder::new_with_minimum_storage_deposit(rent_structure, AccountId::null())
+    let account_output = AccountOutputBuilder::new_with_minimum_amount(storage_score_params, AccountId::null())
         .add_feature(SenderFeature::new(address.clone()))
         .add_feature(MetadataFeature::new(metadata)?)
         .add_immutable_feature(IssuerFeature::new(address.clone()))

sdk/examples/client/output/build_nft_output.rs

@@ -34,7 +34,7 @@ async fn main() -> Result<()> {
         .finish()
         .await?;
 
-    let rent_structure = client.get_rent_structure().await?;
+    let storage_score_params = client.get_storage_score_parameters().await?;
 
     let address = std::env::args()
         .nth(1)
@@ -55,7 +55,7 @@ async fn main() -> Result<()> {
     .to_string();
 
     // NftId needs to be null the first time
-    let nft_output = NftOutputBuilder::new_with_minimum_storage_deposit(rent_structure, NftId::null())
+    let nft_output = NftOutputBuilder::new_with_minimum_amount(storage_score_params, NftId::null())
         .add_unlock_condition(AddressUnlockCondition::new(address.clone()))
         .add_feature(SenderFeature::new(address.clone()))
         .add_feature(MetadataFeature::new(MUTABLE_METADATA)?)

sdk/examples/how_tos/advanced_transactions/send_micro_transaction.rs

@@ -1,7 +1,7 @@
 // Copyright 2023 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-//! In this example we will send an amount below the minimum storage deposit.
+//! In this example we will send an amount below the minimum amount.
 //!
 //! Make sure that `STRONGHOLD_SNAPSHOT_PATH` and `WALLET_DB_PATH` already exist by
 //! running the `./how_tos/accounts_and_addresses/create_wallet.rs` example!

sdk/examples/how_tos/outputs/features.rs

@@ -31,11 +31,11 @@ async fn main() -> Result<()> {
     // Create a client instance.
     let client = Client::builder().with_node(&node_url)?.finish().await?;
 
-    let rent_structure = client.get_rent_structure().await?;
+    let storage_score_params = client.get_storage_score_parameters().await?;
 
     let address = Address::try_from_bech32("rms1qpllaj0pyveqfkwxmnngz2c488hfdtmfrj3wfkgxtk4gtyrax0jaxzt70zy")?;
 
-    let nft_output_builder = NftOutputBuilder::new_with_minimum_storage_deposit(rent_structure, NftId::null())
+    let nft_output_builder = NftOutputBuilder::new_with_minimum_amount(storage_score_params, NftId::null())
         .add_unlock_condition(AddressUnlockCondition::new(address.clone()));
 
     let outputs = [

sdk/examples/how_tos/outputs/unlock_conditions.rs

@@ -34,17 +34,16 @@ async fn main() -> Result<()> {
     let client = Client::builder().with_node(&node_url)?.finish().await?;
 
     let token_supply = client.get_token_supply().await?;
-    let rent_structure = client.get_rent_structure().await?;
+    let storage_score_params = client.get_storage_score_parameters().await?;
 
     let address = Address::try_from_bech32("rms1qpllaj0pyveqfkwxmnngz2c488hfdtmfrj3wfkgxtk4gtyrax0jaxzt70zy")?;
     let account_address = Address::try_from_bech32("rms1pr59qm43mjtvhcajfmupqf23x29llam88yecn6pyul80rx099krmv2fnnux")?;
 
     let token_scheme = TokenScheme::Simple(SimpleTokenScheme::new(50, 0, 100)?);
 
-    let basic_output_builder = BasicOutputBuilder::new_with_minimum_storage_deposit(rent_structure)
+    let basic_output_builder = BasicOutputBuilder::new_with_minimum_amount(storage_score_params)
         .add_unlock_condition(AddressUnlockCondition::new(address.clone()));
-    let foundry_output_builder =
-        FoundryOutputBuilder::new_with_minimum_storage_deposit(rent_structure, 1, token_scheme);
+    let foundry_output_builder = FoundryOutputBuilder::new_with_minimum_amount(storage_score_params, 1, token_scheme);
 
     let outputs = [
         //// most simple output