@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

package/contracts/common-macros/src/tests/storage/parse_no_ttl_extension.rs

@@ -0,0 +1,124 @@
+//! Unit tests for the `parse_no_ttl_extension` function.
+
+use crate::storage::test::parse_no_ttl_extension_for_test;
+use quote::quote;
+
+use super::test_setup::parse_attrs;
+
+#[test]
+fn test_no_attribute_returns_false() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_ok());
+    assert!(!result.unwrap());
+}
+
+#[test]
+fn test_attribute_present_returns_true() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[no_ttl_extension]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_ok());
+    assert!(result.unwrap());
+}
+
+#[test]
+fn test_attribute_before_storage_type() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[no_ttl_extension]
+            #[persistent(u32)]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_ok());
+    assert!(result.unwrap());
+}
+
+#[test]
+fn test_error_attribute_with_parens() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[no_ttl_extension()]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("does not accept arguments"));
+}
+
+#[test]
+fn test_error_attribute_with_value() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[no_ttl_extension(true)]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("does not accept arguments"));
+}
+
+#[test]
+fn test_error_attribute_with_key_value() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[no_ttl_extension = true]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("does not accept arguments"));
+}
+
+#[test]
+fn test_error_multiple_attributes() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[no_ttl_extension]
+            #[no_ttl_extension]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("multiple #[no_ttl_extension]"));
+}
+
+#[test]
+fn test_empty_attrs_returns_false() {
+    let attrs: Vec<syn::Attribute> = vec![];
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_ok());
+    assert!(!result.unwrap());
+}

package/contracts/common-macros/src/tests/storage/parse_storage_type.rs

@@ -0,0 +1,174 @@
+//! Unit tests for the `parse_storage_type` function.
+
+use crate::storage::test::parse_storage_type_for_test;
+use crate::tests::test_helpers::assert_panics_contains;
+use quote::quote;
+
+use super::test_setup::parse_attrs;
+
+#[test]
+fn test_parses_instance_storage() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[instance(u32)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_ok());
+    let (kind_name, ty) = result.unwrap();
+    assert_eq!(kind_name, "instance");
+    assert_eq!(quote!(#ty).to_string(), "u32");
+}
+
+#[test]
+fn test_parses_persistent_storage() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(Address)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_ok());
+    let (kind_name, ty) = result.unwrap();
+    assert_eq!(kind_name, "persistent");
+    assert_eq!(quote!(#ty).to_string(), "Address");
+}
+
+#[test]
+fn test_parses_temporary_storage() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[temporary(bool)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_ok());
+    let (kind_name, ty) = result.unwrap();
+    assert_eq!(kind_name, "temporary");
+    assert_eq!(quote!(#ty).to_string(), "bool");
+}
+
+#[test]
+fn test_parses_complex_type() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(Option<Address>)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_ok());
+    let (kind_name, ty) = result.unwrap();
+    assert_eq!(kind_name, "persistent");
+    assert_eq!(quote!(#ty).to_string(), "Option < Address >");
+}
+
+#[test]
+fn test_parses_generic_type_with_multiple_params() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(Map<Address, u64>)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_ok());
+    let (_, ty) = result.unwrap();
+    assert_eq!(quote!(#ty).to_string(), "Map < Address , u64 >");
+}
+
+#[test]
+fn test_error_missing_storage_type() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[default(0)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("storage type must be specified exactly once"));
+}
+
+#[test]
+fn test_error_empty_attrs() {
+    let attrs: Vec<syn::Attribute> = vec![];
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("storage type must be specified exactly once"));
+}
+
+#[test]
+fn test_error_multiple_storage_types() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[instance(u32)]
+            #[persistent(u32)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("storage type must be specified exactly once"));
+}
+
+#[test]
+fn test_panics_missing_type_param() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[instance]
+            Variant,
+        }
+    });
+
+    assert_panics_contains("missing type param", "failed to parse storage type", || {
+        let _ = parse_storage_type_for_test(&attrs);
+    });
+}
+
+#[test]
+fn test_panics_invalid_type_param() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32, String)]
+            Variant,
+        }
+    });
+
+    assert_panics_contains("multiple type params", "failed to parse storage type", || {
+        let _ = parse_storage_type_for_test(&attrs);
+    });
+}
+
+#[test]
+fn test_ignores_non_storage_attrs() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            /// Doc comment
+            #[default(0)]
+            #[name("custom")]
+            #[persistent(u64)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_ok());
+    let (kind_name, ty) = result.unwrap();
+    assert_eq!(kind_name, "persistent");
+    assert_eq!(quote!(#ty).to_string(), "u64");
+}

package/contracts/common-macros/src/tests/storage/snapshots/common_macros__tests__storage__generate_storage__snapshot_generated_storage_code.snap

@@ -0,0 +1,412 @@
+---
+source: contracts/common-macros/src/tests/storage.rs
+assertion_line: 409
+expression: formatted
+---
+#[soroban_sdk::contracttype]
+pub enum StorageKeys {
+    Counter,
+    Message(Address),
+    Flag(String),
+    Owner,
+    OptionalData(BytesN<32>),
+    TempData,
+    PrimitiveKey(u32),
+    NonPrimitiveKey(String),
+    NamedVariant(u32, String, Address),
+    CachedValue(Address),
+}
+impl StorageKeys {
+    pub fn counter(env: &soroban_sdk::Env) -> u32 {
+        let key = StorageKeys::Counter;
+        let value = env.storage().instance().get::<_, u32>(&key);
+        value.unwrap_or(0)
+    }
+    pub fn set_counter(env: &soroban_sdk::Env, value: &u32) {
+        let key = StorageKeys::Counter;
+        env.storage().instance().set(&key, value);
+    }
+    pub fn remove_counter(env: &soroban_sdk::Env) {
+        let key = StorageKeys::Counter;
+        env.storage().instance().remove(&key);
+    }
+    pub fn set_or_remove_counter(env: &soroban_sdk::Env, value: &Option<u32>) {
+        match value.as_ref() {
+            Some(v) => Self::set_counter(env, v),
+            None => Self::remove_counter(env),
+        }
+    }
+    pub fn has_counter(env: &soroban_sdk::Env) -> bool {
+        let key = StorageKeys::Counter;
+        env.storage().instance().has(&key)
+    }
+    pub fn message(env: &soroban_sdk::Env, sender: &Address) -> String {
+        let key = StorageKeys::Message(sender.clone());
+        let value = env.storage().persistent().get::<_, String>(&key);
+        if value.is_some() {
+            utils::ttl_configurable::extend_persistent_ttl(env, &key);
+        }
+        value.unwrap_or(String::from_str(env, "hello"))
+    }
+    pub fn set_message(env: &soroban_sdk::Env, sender: &Address, value: &String) {
+        let key = StorageKeys::Message(sender.clone());
+        env.storage().persistent().set(&key, value);
+        utils::ttl_configurable::extend_persistent_ttl(env, &key);
+    }
+    pub fn remove_message(env: &soroban_sdk::Env, sender: &Address) {
+        let key = StorageKeys::Message(sender.clone());
+        env.storage().persistent().remove(&key);
+    }
+    pub fn set_or_remove_message(
+        env: &soroban_sdk::Env,
+        sender: &Address,
+        value: &Option<String>,
+    ) {
+        match value.as_ref() {
+            Some(v) => Self::set_message(env, sender, v),
+            None => Self::remove_message(env, sender),
+        }
+    }
+    pub fn has_message(env: &soroban_sdk::Env, sender: &Address) -> bool {
+        let key = StorageKeys::Message(sender.clone());
+        let exists = env.storage().persistent().has(&key);
+        if exists {
+            utils::ttl_configurable::extend_persistent_ttl(env, &key);
+        }
+        exists
+    }
+    pub fn extend_message_ttl(
+        env: &soroban_sdk::Env,
+        sender: &Address,
+        threshold: u32,
+        extend_to: u32,
+    ) {
+        let key = StorageKeys::Message(sender.clone());
+        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+    }
+    pub fn flag(env: &soroban_sdk::Env, key: &String) -> Option<bool> {
+        let key = StorageKeys::Flag(key.clone());
+        let value = env.storage().temporary().get::<_, bool>(&key);
+        value
+    }
+    pub fn set_flag(env: &soroban_sdk::Env, key: &String, value: &bool) {
+        let key = StorageKeys::Flag(key.clone());
+        env.storage().temporary().set(&key, value);
+    }
+    pub fn remove_flag(env: &soroban_sdk::Env, key: &String) {
+        let key = StorageKeys::Flag(key.clone());
+        env.storage().temporary().remove(&key);
+    }
+    pub fn set_or_remove_flag(
+        env: &soroban_sdk::Env,
+        key: &String,
+        value: &Option<bool>,
+    ) {
+        match value.as_ref() {
+            Some(v) => Self::set_flag(env, key, v),
+            None => Self::remove_flag(env, key),
+        }
+    }
+    pub fn has_flag(env: &soroban_sdk::Env, key: &String) -> bool {
+        let key = StorageKeys::Flag(key.clone());
+        env.storage().temporary().has(&key)
+    }
+    pub fn extend_flag_ttl(
+        env: &soroban_sdk::Env,
+        key: &String,
+        threshold: u32,
+        extend_to: u32,
+    ) {
+        let key = StorageKeys::Flag(key.clone());
+        env.storage().temporary().extend_ttl(&key, threshold, extend_to);
+    }
+    pub fn owner(env: &soroban_sdk::Env) -> Option<Address> {
+        let key = StorageKeys::Owner;
+        let value = env.storage().persistent().get::<_, Address>(&key);
+        if value.is_some() {
+            utils::ttl_configurable::extend_persistent_ttl(env, &key);
+        }
+        value
+    }
+    pub fn set_owner(env: &soroban_sdk::Env, value: &Address) {
+        let key = StorageKeys::Owner;
+        env.storage().persistent().set(&key, value);
+        utils::ttl_configurable::extend_persistent_ttl(env, &key);
+    }
+    pub fn remove_owner(env: &soroban_sdk::Env) {
+        let key = StorageKeys::Owner;
+        env.storage().persistent().remove(&key);
+    }
+    pub fn set_or_remove_owner(env: &soroban_sdk::Env, value: &Option<Address>) {
+        match value.as_ref() {
+            Some(v) => Self::set_owner(env, v),
+            None => Self::remove_owner(env),
+        }
+    }
+    pub fn has_owner(env: &soroban_sdk::Env) -> bool {
+        let key = StorageKeys::Owner;
+        let exists = env.storage().persistent().has(&key);
+        if exists {
+            utils::ttl_configurable::extend_persistent_ttl(env, &key);
+        }
+        exists
+    }
+    pub fn extend_owner_ttl(env: &soroban_sdk::Env, threshold: u32, extend_to: u32) {
+        let key = StorageKeys::Owner;
+        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+    }
+    pub fn custom_key_name(
+        env: &soroban_sdk::Env,
+        key: &BytesN<32>,
+    ) -> Option<Option<Address>> {
+        let key = StorageKeys::OptionalData(key.clone());
+        let value = env.storage().persistent().get::<_, Option<Address>>(&key);
+        if value.is_some() {
+            utils::ttl_configurable::extend_persistent_ttl(env, &key);
+        }
+        value
+    }
+    pub fn set_custom_key_name(
+        env: &soroban_sdk::Env,
+        key: &BytesN<32>,
+        value: &Option<Address>,
+    ) {
+        let key = StorageKeys::OptionalData(key.clone());
+        env.storage().persistent().set(&key, value);
+        utils::ttl_configurable::extend_persistent_ttl(env, &key);
+    }
+    pub fn remove_custom_key_name(env: &soroban_sdk::Env, key: &BytesN<32>) {
+        let key = StorageKeys::OptionalData(key.clone());
+        env.storage().persistent().remove(&key);
+    }
+    pub fn set_or_remove_custom_key_name(
+        env: &soroban_sdk::Env,
+        key: &BytesN<32>,
+        value: &Option<Option<Address>>,
+    ) {
+        match value.as_ref() {
+            Some(v) => Self::set_custom_key_name(env, key, v),
+            None => Self::remove_custom_key_name(env, key),
+        }
+    }
+    pub fn has_custom_key_name(env: &soroban_sdk::Env, key: &BytesN<32>) -> bool {
+        let key = StorageKeys::OptionalData(key.clone());
+        let exists = env.storage().persistent().has(&key);
+        if exists {
+            utils::ttl_configurable::extend_persistent_ttl(env, &key);
+        }
+        exists
+    }
+    pub fn extend_custom_key_name_ttl(
+        env: &soroban_sdk::Env,
+        key: &BytesN<32>,
+        threshold: u32,
+        extend_to: u32,
+    ) {
+        let key = StorageKeys::OptionalData(key.clone());
+        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+    }
+    pub fn temp_data(env: &soroban_sdk::Env) -> Option<u64> {
+        let key = StorageKeys::TempData;
+        let value = env.storage().temporary().get::<_, u64>(&key);
+        value
+    }
+    pub fn set_temp_data(env: &soroban_sdk::Env, value: &u64) {
+        let key = StorageKeys::TempData;
+        env.storage().temporary().set(&key, value);
+    }
+    pub fn remove_temp_data(env: &soroban_sdk::Env) {
+        let key = StorageKeys::TempData;
+        env.storage().temporary().remove(&key);
+    }
+    pub fn set_or_remove_temp_data(env: &soroban_sdk::Env, value: &Option<u64>) {
+        match value.as_ref() {
+            Some(v) => Self::set_temp_data(env, v),
+            None => Self::remove_temp_data(env),
+        }
+    }
+    pub fn has_temp_data(env: &soroban_sdk::Env) -> bool {
+        let key = StorageKeys::TempData;
+        env.storage().temporary().has(&key)
+    }
+    pub fn extend_temp_data_ttl(env: &soroban_sdk::Env, threshold: u32, extend_to: u32) {
+        let key = StorageKeys::TempData;
+        env.storage().temporary().extend_ttl(&key, threshold, extend_to);
+    }
+    pub fn primitive_key(env: &soroban_sdk::Env, key: u32) -> Option<u32> {
+        let key = StorageKeys::PrimitiveKey(key);
+        let value = env.storage().persistent().get::<_, u32>(&key);
+        if value.is_some() {
+            utils::ttl_configurable::extend_persistent_ttl(env, &key);
+        }
+        value
+    }
+    pub fn set_primitive_key(env: &soroban_sdk::Env, key: u32, value: &u32) {
+        let key = StorageKeys::PrimitiveKey(key);
+        env.storage().persistent().set(&key, value);
+        utils::ttl_configurable::extend_persistent_ttl(env, &key);
+    }
+    pub fn remove_primitive_key(env: &soroban_sdk::Env, key: u32) {
+        let key = StorageKeys::PrimitiveKey(key);
+        env.storage().persistent().remove(&key);
+    }
+    pub fn set_or_remove_primitive_key(
+        env: &soroban_sdk::Env,
+        key: u32,
+        value: &Option<u32>,
+    ) {
+        match value.as_ref() {
+            Some(v) => Self::set_primitive_key(env, key, v),
+            None => Self::remove_primitive_key(env, key),
+        }
+    }
+    pub fn has_primitive_key(env: &soroban_sdk::Env, key: u32) -> bool {
+        let key = StorageKeys::PrimitiveKey(key);
+        let exists = env.storage().persistent().has(&key);
+        if exists {
+            utils::ttl_configurable::extend_persistent_ttl(env, &key);
+        }
+        exists
+    }
+    pub fn extend_primitive_key_ttl(
+        env: &soroban_sdk::Env,
+        key: u32,
+        threshold: u32,
+        extend_to: u32,
+    ) {
+        let key = StorageKeys::PrimitiveKey(key);
+        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+    }
+    pub fn non_primitive_key(env: &soroban_sdk::Env, key: &String) -> Option<u32> {
+        let key = StorageKeys::NonPrimitiveKey(key.clone());
+        let value = env.storage().instance().get::<_, u32>(&key);
+        value
+    }
+    pub fn set_non_primitive_key(env: &soroban_sdk::Env, key: &String, value: &u32) {
+        let key = StorageKeys::NonPrimitiveKey(key.clone());
+        env.storage().instance().set(&key, value);
+    }
+    pub fn remove_non_primitive_key(env: &soroban_sdk::Env, key: &String) {
+        let key = StorageKeys::NonPrimitiveKey(key.clone());
+        env.storage().instance().remove(&key);
+    }
+    pub fn set_or_remove_non_primitive_key(
+        env: &soroban_sdk::Env,
+        key: &String,
+        value: &Option<u32>,
+    ) {
+        match value.as_ref() {
+            Some(v) => Self::set_non_primitive_key(env, key, v),
+            None => Self::remove_non_primitive_key(env, key),
+        }
+    }
+    pub fn has_non_primitive_key(env: &soroban_sdk::Env, key: &String) -> bool {
+        let key = StorageKeys::NonPrimitiveKey(key.clone());
+        env.storage().instance().has(&key)
+    }
+    pub fn named_variant(
+        env: &soroban_sdk::Env,
+        first: u32,
+        second: &String,
+        third: &Address,
+    ) -> Option<u32> {
+        let key = StorageKeys::NamedVariant(first, second.clone(), third.clone());
+        let value = env.storage().persistent().get::<_, u32>(&key);
+        if value.is_some() {
+            utils::ttl_configurable::extend_persistent_ttl(env, &key);
+        }
+        value
+    }
+    pub fn set_named_variant(
+        env: &soroban_sdk::Env,
+        first: u32,
+        second: &String,
+        third: &Address,
+        value: &u32,
+    ) {
+        let key = StorageKeys::NamedVariant(first, second.clone(), third.clone());
+        env.storage().persistent().set(&key, value);
+        utils::ttl_configurable::extend_persistent_ttl(env, &key);
+    }
+    pub fn remove_named_variant(
+        env: &soroban_sdk::Env,
+        first: u32,
+        second: &String,
+        third: &Address,
+    ) {
+        let key = StorageKeys::NamedVariant(first, second.clone(), third.clone());
+        env.storage().persistent().remove(&key);
+    }
+    pub fn set_or_remove_named_variant(
+        env: &soroban_sdk::Env,
+        first: u32,
+        second: &String,
+        third: &Address,
+        value: &Option<u32>,
+    ) {
+        match value.as_ref() {
+            Some(v) => Self::set_named_variant(env, first, second, third, v),
+            None => Self::remove_named_variant(env, first, second, third),
+        }
+    }
+    pub fn has_named_variant(
+        env: &soroban_sdk::Env,
+        first: u32,
+        second: &String,
+        third: &Address,
+    ) -> bool {
+        let key = StorageKeys::NamedVariant(first, second.clone(), third.clone());
+        let exists = env.storage().persistent().has(&key);
+        if exists {
+            utils::ttl_configurable::extend_persistent_ttl(env, &key);
+        }
+        exists
+    }
+    pub fn extend_named_variant_ttl(
+        env: &soroban_sdk::Env,
+        first: u32,
+        second: &String,
+        third: &Address,
+        threshold: u32,
+        extend_to: u32,
+    ) {
+        let key = StorageKeys::NamedVariant(first, second.clone(), third.clone());
+        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+    }
+    pub fn cached_value(env: &soroban_sdk::Env, key: &Address) -> Option<u64> {
+        let key = StorageKeys::CachedValue(key.clone());
+        let value = env.storage().persistent().get::<_, u64>(&key);
+        value
+    }
+    pub fn set_cached_value(env: &soroban_sdk::Env, key: &Address, value: &u64) {
+        let key = StorageKeys::CachedValue(key.clone());
+        env.storage().persistent().set(&key, value);
+    }
+    pub fn remove_cached_value(env: &soroban_sdk::Env, key: &Address) {
+        let key = StorageKeys::CachedValue(key.clone());
+        env.storage().persistent().remove(&key);
+    }
+    pub fn set_or_remove_cached_value(
+        env: &soroban_sdk::Env,
+        key: &Address,
+        value: &Option<u64>,
+    ) {
+        match value.as_ref() {
+            Some(v) => Self::set_cached_value(env, key, v),
+            None => Self::remove_cached_value(env, key),
+        }
+    }
+    pub fn has_cached_value(env: &soroban_sdk::Env, key: &Address) -> bool {
+        let key = StorageKeys::CachedValue(key.clone());
+        env.storage().persistent().has(&key)
+    }
+    pub fn extend_cached_value_ttl(
+        env: &soroban_sdk::Env,
+        key: &Address,
+        threshold: u32,
+        extend_to: u32,
+    ) {
+        let key = StorageKeys::CachedValue(key.clone());
+        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+    }
+}