Replace unixTime with slotIndex in Timelock/Expiration

cli/Cargo.toml

@@ -40,7 +40,6 @@ dialoguer = { version = "0.10.4", default-features = false, features = [
 ] }
 dotenvy = { version = "0.15.7", default-features = false }
 fern-logger = { version = "0.5.0", default-features = false }
-humantime = { version = "2.1.0", default-features = false }
 log = { version = "0.4.20", default-features = false }
 prefix-hex = { version = "0.7.1", default-features = false, features = ["std"] }
 serde_json = { version = "1.0.105", default-features = false }

cli/src/account.rs

@@ -146,7 +146,7 @@ pub async fn account_prompt_internal(account: Account, history: &mut AccountHist
                         address,
                         amount,
                         return_address,
-                        expiration.map(|e| e.as_secs() as u32),
+                        expiration,
                         allow_micro_amount,
                     )
                     .await

cli/src/command/account.rs

@@ -15,6 +15,7 @@ use iota_sdk::{
                 Output, OutputId, TokenId,
             },
             payload::transaction::TransactionId,
+            slot::SlotIndex,
             ConvertTo,
         },
     },
@@ -163,11 +164,11 @@ pub enum AccountCommand {
         /// default to the first address of the account.
         #[arg(long)]
         return_address: Option<Bech32Address>,
-        /// Expiration in seconds, after which the output will be available for the sender again, if not spent by the
-        /// receiver already. The expiration will only be used if one is necessary given the provided amount. If an
-        /// expiration is needed but not provided, it will default to one day.
+        /// Expiration in slot indices, after which the output will be available for the sender again, if not spent by
+        /// the receiver already. The expiration will only be used if one is necessary given the provided
+        /// amount. If an expiration is needed but not provided, it will default to one day.
         #[arg(long)]
-        expiration: Option<humantime::Duration>,
+        expiration: Option<SlotIndex>,
         /// Whether to send micro amounts. This will automatically add Storage Deposit Return and Expiration unlock
         /// conditions if necessary. This flag is implied by the existence of a return address or expiration.
         #[arg(long, default_value_t = false)]
@@ -382,9 +383,16 @@ pub async fn claimable_outputs_command(account: &Account) -> Result<(), Error> {
             println_log_info!("  - base coin amount: {}", amount);
 
             if let Some(expiration) = unlock_conditions.expiration() {
-                let current_time = iota_sdk::utils::unix_timestamp_now().as_secs() as u32;
-                let time_left = expiration.timestamp() - current_time;
-                println_log_info!("  - expires in: {} seconds", time_left);
+                let slot_index = account.client().get_slot_index().await?;
+
+                if *expiration.slot_index() > *slot_index {
+                    println_log_info!("  - expires in {} slot indices", *expiration.slot_index() - *slot_index);
+                } else {
+                    println_log_info!(
+                        "  - expired {} slot indices ago",
+                        *slot_index - *expiration.slot_index()
+                    );
+                }
             }
         }
     }
@@ -640,7 +648,7 @@ pub async fn send_command(
     address: impl ConvertTo<Bech32Address>,
     amount: u64,
     return_address: Option<impl ConvertTo<Bech32Address>>,
-    expiration: Option<u32>,
+    expiration: Option<SlotIndex>,
     allow_micro_amount: bool,
 ) -> Result<(), Error> {
     let params = [SendParams::new(amount, address)?
@@ -876,7 +884,7 @@ async fn print_address(account: &Account, address: &Bip44Address) -> Result<(),
     }
 
     let addresses = account.addresses_with_unspent_outputs().await?;
-    let current_time = iota_sdk::utils::unix_timestamp_now().as_secs() as u32;
+    let slot_index = account.client().get_slot_index().await?;
 
     if let Ok(index) = addresses.binary_search_by_key(&(address.key_index(), address.internal()), |a| {
         (a.key_index(), a.internal())
@@ -885,10 +893,9 @@ async fn print_address(account: &Account, address: &Bip44Address) -> Result<(),
         for output_id in addresses[index].output_ids() {
             if let Some(output_data) = account.get_output(output_id).await {
                 // Output might be associated with the address, but can't unlocked by it, so we check that here
-                let (required_address, _) =
-                    output_data
-                        .output
-                        .required_and_unlocked_address(current_time, output_id, None)?;
+                let (required_address, _) = output_data
+                    .output
+                    .required_and_unlocked_address(slot_index, output_id, None)?;
                 if *address.address().as_ref() == required_address {
                     let unlock_conditions = output_data
                         .output

sdk/Cargo.toml

@@ -27,6 +27,8 @@ derive_more = { version = "0.99.17", default-features = false, features = [
     "deref",
     "deref_mut",
     "display",
+    "add",
+    "add_assign",
 ] }
 getset = { version = "0.1.2", default-features = false }
 hashbrown = { version = "0.14.0", default-features = false, features = [

sdk/examples/how_tos/advanced_transactions/advanced_transaction.rs

@@ -13,6 +13,7 @@ use iota_sdk::{
             unlock_condition::{AddressUnlockCondition, TimelockUnlockCondition},
             BasicOutputBuilder,
         },
+        slot::SlotIndex,
     },
     wallet::Result,
     Wallet,
@@ -37,18 +38,14 @@ async fn main() -> Result<()> {
             .set_stronghold_password(std::env::var("STRONGHOLD_PASSWORD").unwrap())
             .await?;
 
-        // Create an ouput with amount 1_000_000 and a timelock of 1 hour
-        let in_an_hour = (std::time::SystemTime::now() + std::time::Duration::from_secs(3600))
-            .duration_since(std::time::UNIX_EPOCH)
-            .expect("clock went backwards")
-            .as_secs()
-            .try_into()
-            .unwrap();
+        // TODO better time-based UX ?
+        // Create an output with amount 1_000_000 and a timelock of 1000 slots.
+        let slot_index = SlotIndex::from(1000);
         let basic_output = BasicOutputBuilder::new_with_amount(1_000_000)
             .add_unlock_condition(AddressUnlockCondition::new(Bech32Address::try_from_str(
                 "rms1qpszqzadsym6wpppd6z037dvlejmjuke7s24hm95s9fg9vpua7vluaw60xu",
             )?))
-            .add_unlock_condition(TimelockUnlockCondition::new(in_an_hour)?)
+            .add_unlock_condition(TimelockUnlockCondition::new(slot_index)?)
             .finish_output(account.client().get_token_supply().await?)?;
 
         let transaction = account.send_outputs(vec![basic_output], None).await?;

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

@@ -38,7 +38,7 @@ async fn main() -> Result<()> {
 
     // Signs prepared transaction offline.
     let unlocks = SecretManager::Stronghold(secret_manager)
-        .sign_transaction_essence(&prepared_transaction_data, None)
+        .sign_transaction_essence(&prepared_transaction_data)
         .await?;
 
     let signed_transaction = TransactionPayload::new(prepared_transaction_data.essence.as_regular().clone(), unlocks)?;

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

@@ -26,8 +26,8 @@ use crate::{
             OUTPUT_COUNT_RANGE,
         },
         protocol::ProtocolParameters,
+        slot::SlotIndex,
     },
-    utils::unix_timestamp_now,
 };
 
 /// Working state for the input selection algorithm.
@@ -41,7 +41,7 @@ pub struct InputSelection {
     burn: Option<Burn>,
     remainder_address: Option<Address>,
     protocol_parameters: ProtocolParameters,
-    timestamp: u32,
+    slot_index: SlotIndex,
     requirements: Vec<Requirement>,
     automatically_transitioned: HashMap<ChainId, Option<AccountTransition>>,
 }
@@ -63,7 +63,7 @@ impl InputSelection {
             is_account_transition(&input.output, *input.output_id(), &self.outputs, self.burn.as_ref());
         let required_address = input
             .output
-            .required_and_unlocked_address(self.timestamp, input.output_id(), account_transition)?
+            .required_and_unlocked_address(self.slot_index, input.output_id(), account_transition)?
             .0;
 
         match required_address {
@@ -186,7 +186,8 @@ impl InputSelection {
             burn: None,
             remainder_address: None,
             protocol_parameters,
-            timestamp: unix_timestamp_now().as_secs() as u32,
+            // TODO may want to make this mandatory at some point
+            slot_index: SlotIndex::from(0),
             requirements: Vec::new(),
             automatically_transitioned: HashMap::new(),
         }
@@ -216,9 +217,9 @@ impl InputSelection {
         self
     }
 
-    /// Sets the timestamp of an [`InputSelection`].
-    pub fn timestamp(mut self, timestamp: u32) -> Self {
-        self.timestamp = timestamp;
+    /// Sets the slot index of an [`InputSelection`].
+    pub fn slot_index(mut self, slot_index: impl Into<SlotIndex>) -> Self {
+        self.slot_index = slot_index.into();
         self
     }
 
@@ -237,14 +238,14 @@ 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.timestamp) {
+            if unlock_conditions.is_time_locked(self.slot_index) {
                 return false;
             }
 
             let required_address = input
                 .output
                 // Account transition is irrelevant here as we keep accounts anyway.
-                .required_and_unlocked_address(self.timestamp, input.output_id(), None)
+                .required_and_unlocked_address(self.slot_index, input.output_id(), None)
                 // PANIC: safe to unwrap as non basic/account/foundry/nft outputs are already filtered out.
                 .unwrap()
                 .0;
@@ -257,9 +258,8 @@ impl InputSelection {
     pub(crate) fn sort_input_signing_data(
         mut inputs: Vec<InputSigningData>,
         outputs: &[Output],
-        time: Option<u32>,
+        slot_index: SlotIndex,
     ) -> Result<Vec<InputSigningData>, Error> {
-        let time = time.unwrap_or_else(|| unix_timestamp_now().as_secs() as u32);
         // 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
         // might be a more efficient way to do this
@@ -275,7 +275,7 @@ impl InputSelection {
                 );
                 let (input_address, _) = input_signing_data
                     .output
-                    .required_and_unlocked_address(time, input_signing_data.output_id(), account_transition)
+                    .required_and_unlocked_address(slot_index, input_signing_data.output_id(), account_transition)
                     // PANIC: safe to unwrap, because we filtered irrelevant outputs out before
                     .unwrap();
 
@@ -287,7 +287,7 @@ impl InputSelection {
             let (input_address, _) =
                 input
                     .output
-                    .required_and_unlocked_address(time, input.output_id(), account_transition)?;
+                    .required_and_unlocked_address(slot_index, input.output_id(), account_transition)?;
 
             match sorted_inputs.iter().position(|input_signing_data| match input_address {
                 Address::Account(unlock_address) => {
@@ -334,7 +334,7 @@ impl InputSelection {
                             );
                             let (input_address, _) = input_signing_data
                                 .output
-                                .required_and_unlocked_address(time, input.output_id(), account_transition)
+                                .required_and_unlocked_address(slot_index, input.output_id(), account_transition)
                                 // PANIC: safe to unwrap, because we filtered irrelevant outputs out before
                                 .unwrap();
 
@@ -408,7 +408,7 @@ impl InputSelection {
         self.validate_transitions()?;
 
         Ok(Selected {
-            inputs: Self::sort_input_signing_data(self.selected_inputs, &self.outputs, Some(self.timestamp))?,
+            inputs: Self::sort_input_signing_data(self.selected_inputs, &self.outputs, self.slot_index)?,
             outputs: self.outputs,
             remainder,
         })

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

@@ -36,7 +36,7 @@ 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.timestamp, input.output_id(), account_transition)
+                .required_and_unlocked_address(self.slot_index, input.output_id(), account_transition)
                 .unwrap()
                 .0;
 
@@ -86,7 +86,7 @@ impl InputSelection {
         &self,
     ) -> Result<(Option<RemainderData>, Vec<Output>), Error> {
         let (inputs_sum, outputs_sum, inputs_sdr, outputs_sdr) =
-            amount_sums(&self.selected_inputs, &self.outputs, self.timestamp);
+            amount_sums(&self.selected_inputs, &self.outputs, self.slot_index);
         let mut storage_deposit_returns = Vec::new();
 
         for (address, amount) in inputs_sdr {