Timelock/Expiration validation with a CommitmentInput

bindings/core/src/method/secret_manager.rs

@@ -5,7 +5,7 @@ use crypto::keys::bip44::Bip44;
 use derivative::Derivative;
 use iota_sdk::{
     client::api::{GetAddressesOptions, PreparedTransactionDataDto},
-    types::block::UnsignedBlockDto,
+    types::block::{protocol::ProtocolParameters, UnsignedBlockDto},
     utils::serde::bip44::Bip44Def,
 };
 use serde::{Deserialize, Serialize};
@@ -61,6 +61,7 @@ pub enum SecretManagerMethod {
     SignTransaction {
         /// Prepared transaction data
         prepared_transaction_data: PreparedTransactionDataDto,
+        protocol_parameters: ProtocolParameters,
     },
     // Sign a block.
     #[serde(rename_all = "camelCase")]

bindings/core/src/method_handler/secret_manager.rs

@@ -75,9 +75,13 @@ where
         }
         SecretManagerMethod::SignTransaction {
             prepared_transaction_data,
+            protocol_parameters,
         } => {
             let transaction = &secret_manager
-                .sign_transaction(PreparedTransactionData::try_from_dto(prepared_transaction_data)?)
+                .sign_transaction(
+                    PreparedTransactionData::try_from_dto(prepared_transaction_data)?,
+                    &protocol_parameters,
+                )
                 .await
                 .map_err(iota_sdk::client::Error::from)?;
             Response::SignedTransaction(transaction.into())

cli/src/wallet_cli/mod.rs

@@ -932,6 +932,7 @@ async fn print_wallet_address(wallet: &Wallet) -> Result<(), Error> {
 
     let unspent_outputs = wallet.unspent_outputs(None).await;
     let slot_index = wallet.client().get_slot_index().await?;
+    let protocol_parameters = wallet.client().get_protocol_parameters().await?;
 
     let mut output_ids = Vec::new();
     let mut amount = 0;
@@ -947,9 +948,15 @@ async fn print_wallet_address(wallet: &Wallet) -> Result<(), Error> {
         output_ids.push(output_id);
 
         // Output might be associated with the address, but can't be unlocked by it, so we check that here.
-        let (required_address, _) = &output_data
+        let required_address = &output_data
             .output
-            .required_and_unlocked_address(slot_index, &output_id)?;
+            .required_address(
+                slot_index,
+                protocol_parameters.min_committable_age(),
+                protocol_parameters.max_committable_age(),
+            )?
+            // TODO
+            .unwrap();
 
         if address.inner() == required_address {
             if let Some(nts) = output_data.output.native_tokens() {

sdk/examples/wallet/offline_signing/2_sign_transaction.rs

@@ -16,7 +16,10 @@ use iota_sdk::{
         },
         secret::{stronghold::StrongholdSecretManager, SecretManage, SecretManager},
     },
-    types::{block::payload::SignedTransactionPayload, TryFromDto},
+    types::{
+        block::{payload::SignedTransactionPayload, protocol::protocol_parameters},
+        TryFromDto,
+    },
     wallet::Result,
 };
 
@@ -38,7 +41,7 @@ async fn main() -> Result<()> {
 
     // Signs prepared transaction offline.
     let unlocks = SecretManager::Stronghold(secret_manager)
-        .transaction_unlocks(&prepared_transaction_data)
+        .transaction_unlocks(&prepared_transaction_data, &protocol_parameters())
         .await?;
 
     let signed_transaction = SignedTransactionPayload::new(prepared_transaction_data.transaction.clone(), unlocks)?;

sdk/src/client/api/block_builder/input_selection/mod.rs

@@ -60,8 +60,13 @@ impl InputSelection {
     fn required_account_nft_addresses(&self, input: &InputSigningData) -> Result<Option<Requirement>, Error> {
         let required_address = input
             .output
-            .required_and_unlocked_address(self.slot_index, input.output_id())?
-            .0;
+            .required_address(
+                self.slot_index,
+                self.protocol_parameters.min_committable_age(),
+                self.protocol_parameters.max_committable_age(),
+            )?
+            // TODO
+            .unwrap();
 
         match required_address {
             Address::Ed25519(_) => Ok(None),
@@ -223,17 +228,22 @@ impl InputSelection {
             // PANIC: safe to unwrap as non basic/account/foundry/nft outputs are already filtered out.
             let unlock_conditions = input.output.unlock_conditions().unwrap();
 
-            if unlock_conditions.is_time_locked(self.slot_index) {
+            if unlock_conditions.is_timelocked(self.slot_index, self.protocol_parameters.min_committable_age()) {
                 return false;
             }
 
             let required_address = input
                 .output
                 // Account transition is irrelevant here as we keep accounts anyway.
-                .required_and_unlocked_address(self.slot_index, input.output_id())
-                // PANIC: safe to unwrap as non basic/account/foundry/nft outputs are already filtered out.
+                .required_address(
+                    self.slot_index,
+                    self.protocol_parameters.min_committable_age(),
+                    self.protocol_parameters.max_committable_age(),
+                )
+                // PANIC: safe to unwrap as non basic/alias/foundry/nft outputs are already filtered out.
                 .unwrap()
-                .0;
+                // TODO
+                .unwrap();
 
             if let Address::Restricted(restricted_address) = required_address {
                 self.addresses.contains(restricted_address.address())
@@ -247,6 +257,8 @@ impl InputSelection {
     pub(crate) fn sort_input_signing_data(
         mut inputs: Vec<InputSigningData>,
         slot_index: SlotIndex,
+        min_committable_age: u32,
+        max_committable_age: u32,
     ) -> Result<Vec<InputSigningData>, Error> {
         // initially sort by output to make it deterministic
         // TODO: rethink this, we only need it deterministic for tests, for the protocol it doesn't matter, also there
@@ -255,38 +267,44 @@ impl InputSelection {
         // filter for ed25519 address first
         let (mut sorted_inputs, account_nft_address_inputs): (Vec<InputSigningData>, Vec<InputSigningData>) =
             inputs.into_iter().partition(|input_signing_data| {
-                let (input_address, _) = input_signing_data
+                let input_address = input_signing_data
                     .output
-                    .required_and_unlocked_address(slot_index, input_signing_data.output_id())
-                    // PANIC: safe to unwrap, because we filtered irrelevant outputs out before
+                    .required_address(slot_index, min_committable_age, max_committable_age)
+                    // PANIC: safe to unwrap as non basic/alias/foundry/nft outputs are already filtered out.
+                    .unwrap()
+                    // TODO
                     .unwrap();
 
                 input_address.is_ed25519()
             });
 
         for input in account_nft_address_inputs {
-            let (input_address, _) = input
+            let required_address = input
                 .output
-                .required_and_unlocked_address(slot_index, input.output_id())?;
+                .required_address(slot_index, min_committable_age, max_committable_age)?
+                // TODO
+                .unwrap();
 
-            match sorted_inputs.iter().position(|input_signing_data| match input_address {
-                Address::Account(unlock_address) => {
-                    if let Output::Account(account_output) = &input_signing_data.output {
-                        *unlock_address.account_id()
-                            == account_output.account_id_non_null(input_signing_data.output_id())
-                    } else {
-                        false
+            match sorted_inputs
+                .iter()
+                .position(|input_signing_data| match required_address {
+                    Address::Account(unlock_address) => {
+                        if let Output::Account(account_output) = &input_signing_data.output {
+                            *unlock_address.account_id()
+                                == account_output.account_id_non_null(input_signing_data.output_id())
+                        } else {
+                            false
+                        }
                     }
-                }
-                Address::Nft(unlock_address) => {
-                    if let Output::Nft(nft_output) = &input_signing_data.output {
-                        *unlock_address.nft_id() == nft_output.nft_id_non_null(input_signing_data.output_id())
-                    } else {
-                        false
+                    Address::Nft(unlock_address) => {
+                        if let Output::Nft(nft_output) = &input_signing_data.output {
+                            *unlock_address.nft_id() == nft_output.nft_id_non_null(input_signing_data.output_id())
+                        } else {
+                            false
+                        }
                     }
-                }
-                _ => false,
-            }) {
+                    _ => false,
+                }) {
                 Some(position) => {
                     // Insert after the output we need
                     sorted_inputs.insert(position + 1, input);
@@ -306,13 +324,16 @@ impl InputSelection {
                     if let Some(account_or_nft_address) = account_or_nft_address {
                         // Check for existing outputs for this address, and insert before
                         match sorted_inputs.iter().position(|input_signing_data| {
-                            let (input_address, _) = input_signing_data
+                            let required_address = input_signing_data
                                 .output
-                                .required_and_unlocked_address(slot_index, input.output_id())
-                                // PANIC: safe to unwrap, because we filtered irrelevant outputs out before
+                                .required_address(slot_index, min_committable_age, max_committable_age)
+                                // PANIC: safe to unwrap as non basic/alias/foundry/nft outputs are already filtered
+                                // out.
+                                .unwrap()
+                                // TODO
                                 .unwrap();
 
-                            input_address == account_or_nft_address
+                            required_address == account_or_nft_address
                         }) {
                             Some(position) => {
                                 // Insert before the output with this address required for unlocking
@@ -382,7 +403,12 @@ impl InputSelection {
         self.validate_transitions()?;
 
         Ok(Selected {
-            inputs: Self::sort_input_signing_data(self.selected_inputs, self.slot_index)?,
+            inputs: Self::sort_input_signing_data(
+                self.selected_inputs,
+                self.slot_index,
+                self.protocol_parameters.min_committable_age(),
+                self.protocol_parameters.max_committable_age(),
+            )?,
             outputs: self.outputs,
             remainder,
         })

sdk/src/client/api/block_builder/input_selection/remainder.rs

@@ -24,9 +24,15 @@ impl InputSelection {
         if let Some(remainder_address) = &self.remainder_address {
             // Search in inputs for the Bip44 chain for the remainder address, so the ledger can regenerate it
             for input in self.available_inputs.iter().chain(self.selected_inputs.iter()) {
-                let (required_address, _) = input
+                let required_address = input
                     .output
-                    .required_and_unlocked_address(self.slot_index, input.output_id())?;
+                    .required_address(
+                        self.slot_index,
+                        self.protocol_parameters.min_committable_age(),
+                        self.protocol_parameters.max_committable_age(),
+                    )?
+                    // TODO
+                    .unwrap();
 
                 if &required_address == remainder_address {
                     return Ok(Some((remainder_address.clone(), input.chain)));
@@ -38,8 +44,13 @@ impl InputSelection {
         for input in &self.selected_inputs {
             let required_address = input
                 .output
-                .required_and_unlocked_address(self.slot_index, input.output_id())?
-                .0;
+                .required_address(
+                    self.slot_index,
+                    self.protocol_parameters.min_committable_age(),
+                    self.protocol_parameters.max_committable_age(),
+                )?
+                // TODO
+                .unwrap();
 
             if required_address.is_ed25519() {
                 return Ok(Some((required_address, input.chain)));

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

@@ -347,7 +347,14 @@ impl InputSelection {
             if let Output::Basic(output) = &input.output {
                 output
                     .unlock_conditions()
-                    .locked_address(output.address(), self.slot_index)
+                    .locked_address(
+                        output.address(),
+                        self.slot_index,
+                        self.protocol_parameters.min_committable_age(),
+                        self.protocol_parameters.max_committable_age(),
+                    )
+                    // TODO
+                    .unwrap()
                     .is_ed25519()
             } else {
                 false
@@ -362,7 +369,14 @@ impl InputSelection {
             if let Output::Basic(output) = &input.output {
                 !output
                     .unlock_conditions()
-                    .locked_address(output.address(), self.slot_index)
+                    .locked_address(
+                        output.address(),
+                        self.slot_index,
+                        self.protocol_parameters.min_committable_age(),
+                        self.protocol_parameters.max_committable_age(),
+                    )
+                    // TODO
+                    .unwrap()
                     .is_ed25519()
             } else {
                 false

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

@@ -10,19 +10,31 @@ impl InputSelection {
         // PANIC: safe to unwrap as outputs with no address have been filtered out already.
         let required_address = input
             .output
-            .required_and_unlocked_address(self.slot_index, input.output_id())
+            .required_address(
+                self.slot_index,
+                self.protocol_parameters.min_committable_age(),
+                self.protocol_parameters.max_committable_age(),
+            )
+            // PANIC: safe to unwrap as outputs with no address have been filtered out already.
             .unwrap()
-            .0;
+            // TODO
+            .unwrap();
 
         &required_address == address
     }
 
     // Checks if an available input can unlock a given ED25519 address.
     // In case an account input is selected, also tells if it needs to be state or governance transitioned.
     fn available_has_ed25519_address(&self, input: &InputSigningData, address: &Address) -> bool {
-        let (required_address, _) = input
+        let required_address = input
             .output
-            .required_and_unlocked_address(self.slot_index, input.output_id())
+            .required_address(
+                self.slot_index,
+                self.protocol_parameters.min_committable_age(),
+                self.protocol_parameters.max_committable_age(),
+            )
+            .unwrap()
+            // TODO
             .unwrap();
 
         &required_address == address

sdk/src/client/api/block_builder/transaction.rs

@@ -10,6 +10,7 @@ use crate::{
     types::block::{
         output::{Output, OutputId},
         payload::signed_transaction::{SignedTransactionPayload, Transaction},
+        protocol::ProtocolParameters,
         semantic::{SemanticValidationContext, TransactionFailureReason},
         signature::Ed25519Signature,
         BlockId, SignedBlock,
@@ -29,6 +30,7 @@ const REFERENCE_ACCOUNT_NFT_UNLOCK_LENGTH: usize = 1 + 2;
 pub fn verify_semantic(
     input_signing_data: &[InputSigningData],
     transaction_payload: &SignedTransactionPayload,
+    protocol_parameters: ProtocolParameters,
 ) -> crate::client::Result<Option<TransactionFailureReason>> {
     let transaction_id = transaction_payload.transaction().id();
     let inputs = input_signing_data
@@ -37,6 +39,7 @@ pub fn verify_semantic(
         .collect::<Vec<(&OutputId, &Output)>>();
 
     let context = SemanticValidationContext::new(
+        protocol_parameters,
         transaction_payload.transaction(),
         &transaction_id,
         &inputs,