Add SDK support for CAP-78 host functions (limited TTL extensions).

This introduces the wrappers for persistent (including contract code) and instance storage extensions only, the temporary storage is technically supported by host, but it doesn't seem useful (most likely using it would be a footgun).

Author: dmkozh

soroban-sdk/src/deploy.rs

@@ -124,8 +124,9 @@
 //! ```
 
 use crate::{
-    env::internal::Env as _, unwrap::UnwrapInfallible, Address, Bytes, BytesN, ConstructorArgs,
-    Env, IntoVal,
+    env::internal::{ContractTtlExtension, Env as _},
+    unwrap::UnwrapInfallible,
+    Address, Bytes, BytesN, ConstructorArgs, Env, IntoVal,
 };
 
 /// Deployer provides access to deploying contracts.
@@ -272,6 +273,77 @@ impl Deployer {
             )
             .unwrap_infallible();
     }
+
+    /// Extend the TTL of the contract instance and code with limits on the extension.
+    ///
+    /// Extends the TTL of the instance and code to be up to `extend_to` ledgers.
+    /// The extension only happens if it exceeds `min_extension` ledgers, otherwise
+    /// this is a no-op. The amount of extension will not exceed `max_extension` ledgers.
+    ///
+    /// Note that the extension is applied to both the contract code and contract instance,
+    /// so it's possible that one is extended but not the other depending on their current TTLs.
+    ///
+    /// The TTL is the number of ledgers between the current ledger and the final ledger
+    /// the data can still be accessed.
+    pub fn extend_ttl_with_limits(
+        &self,
+        contract_address: Address,
+        extend_to: u32,
+        min_extension: u32,
+        max_extension: u32,
+    ) {
+        self.env
+            .extend_contract_instance_and_code_ttl_v2(
+                contract_address.to_object(),
+                ContractTtlExtension::InstanceAndCode,
+                extend_to.into(),
+                min_extension.into(),
+                max_extension.into(),
+            )
+            .unwrap_infallible();
+    }
+
+    /// Extend the TTL of the contract instance with limits on the extension.
+    ///
+    /// Same as [`extend_ttl_with_limits`](Self::extend_ttl_with_limits) but only for contract instance.
+    pub fn extend_ttl_for_contract_instance_with_limits(
+        &self,
+        contract_address: Address,
+        extend_to: u32,
+        min_extension: u32,
+        max_extension: u32,
+    ) {
+        self.env
+            .extend_contract_instance_and_code_ttl_v2(
+                contract_address.to_object(),
+                ContractTtlExtension::Instance,
+                extend_to.into(),
+                min_extension.into(),
+                max_extension.into(),
+            )
+            .unwrap_infallible();
+    }
+
+    /// Extend the TTL of the contract code with limits on the extension.
+    ///
+    /// Same as [`extend_ttl_with_limits`](Self::extend_ttl_with_limits) but only for contract code.
+    pub fn extend_ttl_for_code_with_limits(
+        &self,
+        contract_address: Address,
+        extend_to: u32,
+        min_extension: u32,
+        max_extension: u32,
+    ) {
+        self.env
+            .extend_contract_instance_and_code_ttl_v2(
+                contract_address.to_object(),
+                ContractTtlExtension::Code,
+                extend_to.into(),
+                min_extension.into(),
+                max_extension.into(),
+            )
+            .unwrap_infallible();
+    }
 }
 
 /// A deployer that deploys a contract that has its ID derived from the provided

soroban-sdk/src/storage.rs

@@ -2,7 +2,7 @@
 use core::fmt::Debug;
 
 use crate::{
-    env::internal::{self, StorageType, Val},
+    env::internal::{self, ContractTtlExtension, StorageType, Val},
     unwrap::{UnwrapInfallible, UnwrapOptimized},
     Env, IntoVal, TryFromVal,
 };
@@ -274,6 +274,36 @@ impl Storage {
         .unwrap_infallible();
     }
 
+    /// Extend the TTL of the data with limits on the extension.
+    ///
+    /// Extends the TTL of the data to be up to `extend_to` ledgers. The extension
+    /// only happens if it exceeds `min_extension` ledgers, otherwise this is a no-op.
+    /// The amount of extension will not exceed `max_extension` ledgers.
+    ///
+    /// The TTL is the number of ledgers between the current ledger and the final
+    /// ledger the data can still be accessed.
+    pub(crate) fn extend_ttl_with_limits<K>(
+        &self,
+        key: &K,
+        storage_type: StorageType,
+        extend_to: u32,
+        min_extension: u32,
+        max_extension: u32,
+    ) where
+        K: IntoVal<Env, Val>,
+    {
+        let env = &self.env;
+        internal::Env::extend_contract_data_ttl_v2(
+            env,
+            key.into_val(env),
+            storage_type,
+            extend_to.into(),
+            min_extension.into(),
+            max_extension.into(),
+        )
+        .unwrap_infallible();
+    }
+
     /// Removes the key and the corresponding value from the currently executing
     /// contract's storage.
     ///
@@ -378,6 +408,32 @@ impl Persistent {
             .extend_ttl(key, StorageType::Persistent, threshold, extend_to)
     }
 
+    /// Extend the TTL of the data under the key with limits on the extension.
+    ///
+    /// Extends the TTL of the data to be up to `extend_to` ledgers. The extension
+    /// only happens if it exceeds `min_extension` ledgers, otherwise this is a no-op.
+    /// The amount of extension will not exceed `max_extension` ledgers.
+    ///
+    /// The TTL is the number of ledgers between the current ledger and the final
+    /// ledger the data can still be accessed.
+    pub fn extend_ttl_with_limits<K>(
+        &self,
+        key: &K,
+        extend_to: u32,
+        min_extension: u32,
+        max_extension: u32,
+    ) where
+        K: IntoVal<Env, Val>,
+    {
+        self.storage.extend_ttl_with_limits(
+            key,
+            StorageType::Persistent,
+            extend_to,
+            min_extension,
+            max_extension,
+        )
+    }
+
     #[inline(always)]
     pub fn remove<K>(&self, key: &K)
     where
@@ -566,6 +622,29 @@ impl Instance {
         )
         .unwrap_infallible();
     }
+
+    /// Extend the TTL of the contract instance and code with limits on the extension.
+    ///
+    /// Extends the TTL of the instance and code to be up to `extend_to` ledgers.
+    /// The extension only happens if it exceeds `min_extension` ledgers, otherwise
+    /// this is a no-op. The amount of extension will not exceed `max_extension` ledgers.
+    ///
+    /// Note that the extension is applied to both the contract code and contract instance,
+    /// so it's possible that one is extended but not the other depending on their current TTLs.
+    ///
+    /// The TTL is the number of ledgers between the current ledger and the final ledger
+    /// the data can still be accessed.
+    pub fn extend_ttl_with_limits(&self, extend_to: u32, min_extension: u32, max_extension: u32) {
+        internal::Env::extend_contract_instance_and_code_ttl_v2(
+            &self.storage.env,
+            self.storage.env.current_contract_address().to_object(),
+            ContractTtlExtension::InstanceAndCode,
+            extend_to.into(),
+            min_extension.into(),
+            max_extension.into(),
+        )
+        .unwrap_infallible();
+    }
 }
 
 #[cfg(any(test, feature = "testutils"))]