Refactor rent cost traits

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,
+                RentCost,
             },
             payload::Payload,
             Block, BlockDto,

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, RentCost, TokenId},
             payload::{transaction::TransactionEssence, TransactionPayload},
             Block,
         },

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, RentCost,
         },
     },
 };

sdk/src/types/block/address/ed25519.rs

@@ -24,6 +24,11 @@ impl Ed25519Address {
     pub fn new(address: [u8; Self::LENGTH]) -> Self {
         Self::from(address)
     }
+
+    #[allow(dead_code)]
+    pub(crate) fn null() -> Self {
+        Self::new([0; Self::LENGTH])
+    }
 }
 
 impl FromStr for Ed25519Address {

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

@@ -13,7 +13,10 @@ use packable::{
     Packable,
 };
 
-use super::verify_output_amount_packable;
+use super::{
+    rent::{RentBuilder, RentCost},
+    verify_output_amount_packable,
+};
 use crate::types::{
     block::{
         address::{AccountAddress, Address},
@@ -256,6 +259,10 @@ impl AccountOutputBuilder {
 
     ///
     pub fn finish(self) -> Result<AccountOutput, Error> {
+        let amount = match self.amount {
+            OutputBuilderAmount::Amount(amount) => amount,
+            OutputBuilderAmount::MinimumStorageDeposit(rent_structure) => self.rent_cost(rent_structure),
+        };
         let state_index = self.state_index.unwrap_or(0);
         let foundry_counter = self.foundry_counter.unwrap_or(0);
 
@@ -279,8 +286,8 @@ impl AccountOutputBuilder {
 
         verify_allowed_features(&immutable_features, AccountOutput::ALLOWED_IMMUTABLE_FEATURES)?;
 
-        let mut output = AccountOutput {
-            amount: 1,
+        Ok(AccountOutput {
+            amount,
             mana: self.mana,
             native_tokens: NativeTokens::from_set(self.native_tokens)?,
             account_id: self.account_id,
@@ -290,16 +297,7 @@ impl AccountOutputBuilder {
             unlock_conditions,
             features,
             immutable_features,
-        };
-
-        output.amount = match self.amount {
-            OutputBuilderAmount::Amount(amount) => amount,
-            OutputBuilderAmount::MinimumStorageDeposit(rent_structure) => {
-                Output::Account(output.clone()).rent_cost(rent_structure)
-            }
-        };
-
-        Ok(output)
+        })
     }
 
     ///
@@ -339,6 +337,43 @@ impl From<&AccountOutput> for AccountOutputBuilder {
     }
 }
 
+impl Rent for AccountOutputBuilder {
+    fn build_weighted_bytes(&self, builder: &mut RentBuilder) {
+        builder
+            // Kind
+            .data_field::<u8>()
+            // Amount
+            .data_field::<u64>()
+            // Mana
+            .data_field::<u64>()
+            // Native Tokens
+            .data_field::<u8>()
+            .weighted_field(&self.native_tokens)
+            // State Index
+            .data_field::<u32>()
+            // State Metadata
+            .data_field::<u16>()
+            .bytes(self.state_metadata.len() as _)
+            // Foundry Counter
+            .data_field::<u32>()
+            // Unlock Conditions
+            .data_field::<u8>()
+            .weighted_field(&self.unlock_conditions)
+            // Features
+            .data_field::<u8>()
+            .weighted_field(&self.features)
+            // Immutable Features
+            .data_field::<u8>()
+            .weighted_field(&self.features);
+    }
+}
+
+impl RentCost for AccountOutputBuilder {
+    fn build_byte_offset(builder: &mut RentBuilder) {
+        Output::build_byte_offset(builder)
+    }
+}
+
 pub(crate) type StateMetadataLength = BoundedU16<0, { AccountOutput::STATE_METADATA_LENGTH_MAX }>;
 
 /// Describes an account in the ledger that can be controlled by the state and governance controllers.
@@ -625,6 +660,38 @@ impl StateTransitionVerifier for AccountOutput {
     }
 }
 
+impl Rent for AccountOutput {
+    fn build_weighted_bytes(&self, builder: &mut RentBuilder) {
+        builder
+            // Kind
+            .data_field::<u8>()
+            // Amount
+            .data_field::<u64>()
+            // Mana
+            .data_field::<u64>()
+            // Native Tokens
+            .packable_field(&self.native_tokens)
+            // State Index
+            .data_field::<u32>()
+            // State Metadata
+            .packable_field(&self.state_metadata)
+            // Foundry Counter
+            .data_field::<u32>()
+            // Unlock Conditions
+            .packable_field(&self.unlock_conditions)
+            // Features
+            .packable_field(&self.features)
+            // Immutable Features
+            .packable_field(&self.immutable_features);
+    }
+}
+
+impl RentCost for AccountOutput {
+    fn build_byte_offset(builder: &mut RentBuilder) {
+        Output::build_byte_offset(builder)
+    }
+}
+
 impl Packable for AccountOutput {
     type UnpackError = Error;
     type UnpackVisitor = ProtocolParameters;
@@ -964,10 +1031,7 @@ mod tests {
             .finish_with_params(ValidationParams::default().with_protocol_parameters(protocol_parameters.clone()))
             .unwrap();
 
-        assert_eq!(
-            output.amount(),
-            Output::Account(output.clone()).rent_cost(protocol_parameters.rent_structure())
-        );
+        assert_eq!(output.amount(), output.rent_cost(protocol_parameters.rent_structure()));
         assert_eq!(output.features().metadata(), Some(&metadata));
         assert_eq!(output.features().sender(), Some(&sender_1));
         assert_eq!(output.immutable_features().metadata(), Some(&metadata));

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

@@ -5,7 +5,11 @@ use alloc::{collections::BTreeSet, vec::Vec};
 
 use packable::Packable;
 
-use super::verify_output_amount_packable;
+use super::{
+    rent::{RentBuilder, RentCost},
+    unlock_condition::StorageDepositReturnUnlockCondition,
+    verify_output_amount_packable, AddressUnlockCondition,
+};
 use crate::types::{
     block::{
         address::Address,
@@ -152,8 +156,64 @@ impl BasicOutputBuilder {
         self
     }
 
+    /// Adds a storage deposit return unlock condition if one is needed to cover the current amount
+    /// (i.e. `amount < rent_cost`). This will increase the total amount to equal the `rent_cost` with
+    /// the additional unlock condition that will return the remainder to the provided `return_address`.
+    pub fn with_sufficient_storage_deposit(
+        mut self,
+        return_address: impl Into<Address>,
+        rent_structure: RentStructure,
+        token_supply: u64,
+    ) -> Result<Self, Error> {
+        Ok(match self.amount {
+            OutputBuilderAmount::Amount(amount) => {
+                let return_address = return_address.into();
+                // Get the current rent requirement
+                let rent_cost = self.rent_cost(rent_structure);
+                // Check whether we already have enough funds to cover it
+                if amount < rent_cost {
+                    // Get the projected rent cost of the return output
+                    let return_rent_cost = Self::new_with_amount(0)
+                        .add_unlock_condition(AddressUnlockCondition::new(return_address))
+                        .rent_cost(rent_structure);
+                    // Add a temporary storage deposit unlock condition so the new rent requirement can be calculated
+                    self = self.add_unlock_condition(StorageDepositReturnUnlockCondition::new(
+                        return_address,
+                        0,
+                        token_supply,
+                    )?);
+                    // Get the rent cost of the output with the added storage deposit return unlock condition
+                    let rent_cost_with_sdruc = self.rent_cost(rent_structure);
+                    // If the return rent cost and amount are less than the required min
+                    let (amount, sdruc_amount) = if rent_cost_with_sdruc >= return_rent_cost + amount {
+                        // Then sending rent_cost_with_sdruc covers both minimum requirements
+                        (rent_cost_with_sdruc, rent_cost_with_sdruc - amount)
+                    } else {
+                        // Otherwise we must use the total of the return minimum and the original amount
+                        // which is unfortunately more than the rent_cost_with_sdruc
+                        (return_rent_cost + amount, return_rent_cost)
+                    };
+                    // Add the required storage deposit unlock condition and the additional rent amount
+                    self.with_amount(amount)
+                        .replace_unlock_condition(StorageDepositReturnUnlockCondition::new(
+                            return_address,
+                            sdruc_amount,
+                            token_supply,
+                        )?)
+                } else {
+                    self
+                }
+            }
+            OutputBuilderAmount::MinimumStorageDeposit(_) => self,
+        })
+    }
+
     ///
     pub fn finish(self) -> Result<BasicOutput, Error> {
+        let amount = match self.amount {
+            OutputBuilderAmount::Amount(amount) => amount,
+            OutputBuilderAmount::MinimumStorageDeposit(rent_structure) => self.rent_cost(rent_structure),
+        };
         let unlock_conditions = UnlockConditions::from_set(self.unlock_conditions)?;
 
         verify_unlock_conditions::<true>(&unlock_conditions)?;
@@ -162,22 +222,13 @@ impl BasicOutputBuilder {
 
         verify_features::<true>(&features)?;
 
-        let mut output = BasicOutput {
-            amount: 1u64,
+        Ok(BasicOutput {
+            amount,
             mana: self.mana,
             native_tokens: NativeTokens::from_set(self.native_tokens)?,
             unlock_conditions,
             features,
-        };
-
-        output.amount = match self.amount {
-            OutputBuilderAmount::Amount(amount) => amount,
-            OutputBuilderAmount::MinimumStorageDeposit(rent_structure) => {
-                Output::Basic(output.clone()).rent_cost(rent_structure)
-            }
-        };
-
-        Ok(output)
+        })
     }
 
     ///
@@ -197,6 +248,33 @@ impl BasicOutputBuilder {
     }
 }
 
+impl Rent for BasicOutputBuilder {
+    fn build_weighted_bytes(&self, builder: &mut RentBuilder) {
+        builder
+            // Kind
+            .data_field::<u8>()
+            // Amount
+            .data_field::<u64>()
+            // Mana
+            .data_field::<u64>()
+            // Native Tokens
+            .data_field::<u8>()
+            .weighted_field(&self.native_tokens)
+            // Unlock Conditions
+            .data_field::<u8>()
+            .weighted_field(&self.unlock_conditions)
+            // Features
+            .data_field::<u8>()
+            .weighted_field(&self.features);
+    }
+}
+
+impl RentCost for BasicOutputBuilder {
+    fn build_byte_offset(builder: &mut RentBuilder) {
+        Output::build_byte_offset(builder)
+    }
+}
+
 impl From<&BasicOutput> for BasicOutputBuilder {
     fn from(output: &BasicOutput) -> Self {
         Self {
@@ -319,6 +397,30 @@ impl BasicOutput {
     }
 }
 
+impl Rent for BasicOutput {
+    fn build_weighted_bytes(&self, builder: &mut RentBuilder) {
+        builder
+            // Kind
+            .data_field::<u8>()
+            // Amount
+            .data_field::<u64>()
+            // Mana
+            .data_field::<u64>()
+            // Native Tokens
+            .packable_field(&self.native_tokens)
+            // Unlock Conditions
+            .packable_field(&self.unlock_conditions)
+            // Features
+            .packable_field(&self.features);
+    }
+}
+
+impl RentCost for BasicOutput {
+    fn build_byte_offset(builder: &mut RentBuilder) {
+        Output::build_byte_offset(builder)
+    }
+}
+
 fn verify_unlock_conditions<const VERIFY: bool>(unlock_conditions: &UnlockConditions) -> Result<(), Error> {
     if VERIFY {
         if unlock_conditions.address().is_none() {
@@ -506,10 +608,7 @@ mod tests {
             .finish_with_params(ValidationParams::default().with_protocol_parameters(protocol_parameters.clone()))
             .unwrap();
 
-        assert_eq!(
-            output.amount(),
-            Output::Basic(output.clone()).rent_cost(protocol_parameters.rent_structure())
-        );
+        assert_eq!(output.amount(), output.rent_cost(protocol_parameters.rent_structure()));
         assert_eq!(output.features().metadata(), Some(&metadata));
         assert_eq!(output.features().sender(), Some(&sender_1));
     }