@layerzerolabs/protocol-stellar-v2 0.2.22 → 0.2.24

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__storage__snapshot_generated_storage_code.snap

@@ -1,1072 +0,0 @@
----
-source: contracts/common-macros/src/tests/storage.rs
-assertion_line: 374
-expression: formatted
----
-#[soroban_sdk::contracttype]
-pub enum StorageKeys {
-    Counter,
-    Message(Address),
-    Flag(String),
-    Data(u64, String),
-    Owner,
-    OptionalData(BytesN<32>),
-    TempData,
-    UserBalance(Address),
-    AnotherVariant(Address),
-    U32Value(u32),
-    I64Value(i64),
-    BoolValue(bool),
-    U8Value(u8),
-    UsizeValue(usize),
-    StringValue(String),
-    VecValue(Vec<u32>),
-    AddressValue(Address),
-    UnitVariant,
-    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 extend_counter_ttl(env: &soroban_sdk::Env, threshold: u32, extend_to: u32) {
-        let key = StorageKeys::Counter;
-        env.storage().instance().extend_ttl(threshold, extend_to);
-    }
-    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() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value.unwrap_or("hello".to_string())
-    }
-    pub fn set_message(env: &soroban_sdk::Env, sender: &Address, value: &String) {
-        let key = StorageKeys::Message(sender.clone());
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    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 {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        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 data(env: &soroban_sdk::Env, id: u64, name: &String) -> Option<Vec<u8>> {
-        let key = StorageKeys::Data(id, name.clone());
-        let value = env.storage().persistent().get::<_, Vec<u8>>(&key);
-        if value.is_some() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_data(env: &soroban_sdk::Env, id: u64, name: &String, value: &Vec<u8>) {
-        let key = StorageKeys::Data(id, name.clone());
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    pub fn remove_data(env: &soroban_sdk::Env, id: u64, name: &String) {
-        let key = StorageKeys::Data(id, name.clone());
-        env.storage().persistent().remove(&key);
-    }
-    pub fn set_or_remove_data(
-        env: &soroban_sdk::Env,
-        id: u64,
-        name: &String,
-        value: &Option<Vec<u8>>,
-    ) {
-        match value.as_ref() {
-            Some(v) => Self::set_data(env, id, name, v),
-            None => Self::remove_data(env, id, name),
-        }
-    }
-    pub fn has_data(env: &soroban_sdk::Env, id: u64, name: &String) -> bool {
-        let key = StorageKeys::Data(id, name.clone());
-        let exists = env.storage().persistent().has(&key);
-        if exists {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        exists
-    }
-    pub fn extend_data_ttl(
-        env: &soroban_sdk::Env,
-        id: u64,
-        name: &String,
-        threshold: u32,
-        extend_to: u32,
-    ) {
-        let key = StorageKeys::Data(id, name.clone());
-        env.storage().persistent().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() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_owner(env: &soroban_sdk::Env, value: &Address) {
-        let key = StorageKeys::Owner;
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    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 {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        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() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        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);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    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 {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        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 user_balance(env: &soroban_sdk::Env, user: &Address) -> Option<u32> {
-        let key = StorageKeys::UserBalance(user.clone());
-        let value = env.storage().persistent().get::<_, u32>(&key);
-        if value.is_some() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_user_balance(env: &soroban_sdk::Env, user: &Address, value: &u32) {
-        let key = StorageKeys::UserBalance(user.clone());
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    pub fn remove_user_balance(env: &soroban_sdk::Env, user: &Address) {
-        let key = StorageKeys::UserBalance(user.clone());
-        env.storage().persistent().remove(&key);
-    }
-    pub fn set_or_remove_user_balance(
-        env: &soroban_sdk::Env,
-        user: &Address,
-        value: &Option<u32>,
-    ) {
-        match value.as_ref() {
-            Some(v) => Self::set_user_balance(env, user, v),
-            None => Self::remove_user_balance(env, user),
-        }
-    }
-    pub fn has_user_balance(env: &soroban_sdk::Env, user: &Address) -> bool {
-        let key = StorageKeys::UserBalance(user.clone());
-        let exists = env.storage().persistent().has(&key);
-        if exists {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        exists
-    }
-    pub fn extend_user_balance_ttl(
-        env: &soroban_sdk::Env,
-        user: &Address,
-        threshold: u32,
-        extend_to: u32,
-    ) {
-        let key = StorageKeys::UserBalance(user.clone());
-        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-    }
-    pub fn custom(env: &soroban_sdk::Env, key: &Address) -> Option<u32> {
-        let key = StorageKeys::AnotherVariant(key.clone());
-        let value = env.storage().persistent().get::<_, u32>(&key);
-        if value.is_some() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_custom(env: &soroban_sdk::Env, key: &Address, value: &u32) {
-        let key = StorageKeys::AnotherVariant(key.clone());
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    pub fn remove_custom(env: &soroban_sdk::Env, key: &Address) {
-        let key = StorageKeys::AnotherVariant(key.clone());
-        env.storage().persistent().remove(&key);
-    }
-    pub fn set_or_remove_custom(
-        env: &soroban_sdk::Env,
-        key: &Address,
-        value: &Option<u32>,
-    ) {
-        match value.as_ref() {
-            Some(v) => Self::set_custom(env, key, v),
-            None => Self::remove_custom(env, key),
-        }
-    }
-    pub fn has_custom(env: &soroban_sdk::Env, key: &Address) -> bool {
-        let key = StorageKeys::AnotherVariant(key.clone());
-        let exists = env.storage().persistent().has(&key);
-        if exists {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        exists
-    }
-    pub fn extend_custom_ttl(
-        env: &soroban_sdk::Env,
-        key: &Address,
-        threshold: u32,
-        extend_to: u32,
-    ) {
-        let key = StorageKeys::AnotherVariant(key.clone());
-        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-    }
-    pub fn u32_value(env: &soroban_sdk::Env, key: u32) -> Option<u32> {
-        let key = StorageKeys::U32Value(key);
-        let value = env.storage().persistent().get::<_, u32>(&key);
-        if value.is_some() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_u32_value(env: &soroban_sdk::Env, key: u32, value: &u32) {
-        let key = StorageKeys::U32Value(key);
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    pub fn remove_u32_value(env: &soroban_sdk::Env, key: u32) {
-        let key = StorageKeys::U32Value(key);
-        env.storage().persistent().remove(&key);
-    }
-    pub fn set_or_remove_u32_value(
-        env: &soroban_sdk::Env,
-        key: u32,
-        value: &Option<u32>,
-    ) {
-        match value.as_ref() {
-            Some(v) => Self::set_u32_value(env, key, v),
-            None => Self::remove_u32_value(env, key),
-        }
-    }
-    pub fn has_u32_value(env: &soroban_sdk::Env, key: u32) -> bool {
-        let key = StorageKeys::U32Value(key);
-        let exists = env.storage().persistent().has(&key);
-        if exists {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        exists
-    }
-    pub fn extend_u32_value_ttl(
-        env: &soroban_sdk::Env,
-        key: u32,
-        threshold: u32,
-        extend_to: u32,
-    ) {
-        let key = StorageKeys::U32Value(key);
-        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-    }
-    pub fn i64_value(env: &soroban_sdk::Env, key: i64) -> Option<i64> {
-        let key = StorageKeys::I64Value(key);
-        let value = env.storage().persistent().get::<_, i64>(&key);
-        if value.is_some() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_i64_value(env: &soroban_sdk::Env, key: i64, value: &i64) {
-        let key = StorageKeys::I64Value(key);
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    pub fn remove_i64_value(env: &soroban_sdk::Env, key: i64) {
-        let key = StorageKeys::I64Value(key);
-        env.storage().persistent().remove(&key);
-    }
-    pub fn set_or_remove_i64_value(
-        env: &soroban_sdk::Env,
-        key: i64,
-        value: &Option<i64>,
-    ) {
-        match value.as_ref() {
-            Some(v) => Self::set_i64_value(env, key, v),
-            None => Self::remove_i64_value(env, key),
-        }
-    }
-    pub fn has_i64_value(env: &soroban_sdk::Env, key: i64) -> bool {
-        let key = StorageKeys::I64Value(key);
-        let exists = env.storage().persistent().has(&key);
-        if exists {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        exists
-    }
-    pub fn extend_i64_value_ttl(
-        env: &soroban_sdk::Env,
-        key: i64,
-        threshold: u32,
-        extend_to: u32,
-    ) {
-        let key = StorageKeys::I64Value(key);
-        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-    }
-    pub fn bool_value(env: &soroban_sdk::Env, key: bool) -> Option<bool> {
-        let key = StorageKeys::BoolValue(key);
-        let value = env.storage().persistent().get::<_, bool>(&key);
-        if value.is_some() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_bool_value(env: &soroban_sdk::Env, key: bool, value: &bool) {
-        let key = StorageKeys::BoolValue(key);
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    pub fn remove_bool_value(env: &soroban_sdk::Env, key: bool) {
-        let key = StorageKeys::BoolValue(key);
-        env.storage().persistent().remove(&key);
-    }
-    pub fn set_or_remove_bool_value(
-        env: &soroban_sdk::Env,
-        key: bool,
-        value: &Option<bool>,
-    ) {
-        match value.as_ref() {
-            Some(v) => Self::set_bool_value(env, key, v),
-            None => Self::remove_bool_value(env, key),
-        }
-    }
-    pub fn has_bool_value(env: &soroban_sdk::Env, key: bool) -> bool {
-        let key = StorageKeys::BoolValue(key);
-        let exists = env.storage().persistent().has(&key);
-        if exists {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        exists
-    }
-    pub fn extend_bool_value_ttl(
-        env: &soroban_sdk::Env,
-        key: bool,
-        threshold: u32,
-        extend_to: u32,
-    ) {
-        let key = StorageKeys::BoolValue(key);
-        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-    }
-    pub fn u8_value(env: &soroban_sdk::Env, key: &u8) -> Option<u32> {
-        let key = StorageKeys::U8Value(key.clone());
-        let value = env.storage().persistent().get::<_, u32>(&key);
-        if value.is_some() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_u8_value(env: &soroban_sdk::Env, key: &u8, value: &u32) {
-        let key = StorageKeys::U8Value(key.clone());
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    pub fn remove_u8_value(env: &soroban_sdk::Env, key: &u8) {
-        let key = StorageKeys::U8Value(key.clone());
-        env.storage().persistent().remove(&key);
-    }
-    pub fn set_or_remove_u8_value(
-        env: &soroban_sdk::Env,
-        key: &u8,
-        value: &Option<u32>,
-    ) {
-        match value.as_ref() {
-            Some(v) => Self::set_u8_value(env, key, v),
-            None => Self::remove_u8_value(env, key),
-        }
-    }
-    pub fn has_u8_value(env: &soroban_sdk::Env, key: &u8) -> bool {
-        let key = StorageKeys::U8Value(key.clone());
-        let exists = env.storage().persistent().has(&key);
-        if exists {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        exists
-    }
-    pub fn extend_u8_value_ttl(
-        env: &soroban_sdk::Env,
-        key: &u8,
-        threshold: u32,
-        extend_to: u32,
-    ) {
-        let key = StorageKeys::U8Value(key.clone());
-        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-    }
-    pub fn usize_value(env: &soroban_sdk::Env, key: &usize) -> Option<u32> {
-        let key = StorageKeys::UsizeValue(key.clone());
-        let value = env.storage().persistent().get::<_, u32>(&key);
-        if value.is_some() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_usize_value(env: &soroban_sdk::Env, key: &usize, value: &u32) {
-        let key = StorageKeys::UsizeValue(key.clone());
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    pub fn remove_usize_value(env: &soroban_sdk::Env, key: &usize) {
-        let key = StorageKeys::UsizeValue(key.clone());
-        env.storage().persistent().remove(&key);
-    }
-    pub fn set_or_remove_usize_value(
-        env: &soroban_sdk::Env,
-        key: &usize,
-        value: &Option<u32>,
-    ) {
-        match value.as_ref() {
-            Some(v) => Self::set_usize_value(env, key, v),
-            None => Self::remove_usize_value(env, key),
-        }
-    }
-    pub fn has_usize_value(env: &soroban_sdk::Env, key: &usize) -> bool {
-        let key = StorageKeys::UsizeValue(key.clone());
-        let exists = env.storage().persistent().has(&key);
-        if exists {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        exists
-    }
-    pub fn extend_usize_value_ttl(
-        env: &soroban_sdk::Env,
-        key: &usize,
-        threshold: u32,
-        extend_to: u32,
-    ) {
-        let key = StorageKeys::UsizeValue(key.clone());
-        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-    }
-    pub fn string_value(env: &soroban_sdk::Env, key: &String) -> Option<String> {
-        let key = StorageKeys::StringValue(key.clone());
-        let value = env.storage().persistent().get::<_, String>(&key);
-        if value.is_some() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_string_value(env: &soroban_sdk::Env, key: &String, value: &String) {
-        let key = StorageKeys::StringValue(key.clone());
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    pub fn remove_string_value(env: &soroban_sdk::Env, key: &String) {
-        let key = StorageKeys::StringValue(key.clone());
-        env.storage().persistent().remove(&key);
-    }
-    pub fn set_or_remove_string_value(
-        env: &soroban_sdk::Env,
-        key: &String,
-        value: &Option<String>,
-    ) {
-        match value.as_ref() {
-            Some(v) => Self::set_string_value(env, key, v),
-            None => Self::remove_string_value(env, key),
-        }
-    }
-    pub fn has_string_value(env: &soroban_sdk::Env, key: &String) -> bool {
-        let key = StorageKeys::StringValue(key.clone());
-        let exists = env.storage().persistent().has(&key);
-        if exists {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        exists
-    }
-    pub fn extend_string_value_ttl(
-        env: &soroban_sdk::Env,
-        key: &String,
-        threshold: u32,
-        extend_to: u32,
-    ) {
-        let key = StorageKeys::StringValue(key.clone());
-        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-    }
-    pub fn vec_value(env: &soroban_sdk::Env, key: &Vec<u32>) -> Option<Vec<u32>> {
-        let key = StorageKeys::VecValue(key.clone());
-        let value = env.storage().persistent().get::<_, Vec<u32>>(&key);
-        if value.is_some() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_vec_value(env: &soroban_sdk::Env, key: &Vec<u32>, value: &Vec<u32>) {
-        let key = StorageKeys::VecValue(key.clone());
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    pub fn remove_vec_value(env: &soroban_sdk::Env, key: &Vec<u32>) {
-        let key = StorageKeys::VecValue(key.clone());
-        env.storage().persistent().remove(&key);
-    }
-    pub fn set_or_remove_vec_value(
-        env: &soroban_sdk::Env,
-        key: &Vec<u32>,
-        value: &Option<Vec<u32>>,
-    ) {
-        match value.as_ref() {
-            Some(v) => Self::set_vec_value(env, key, v),
-            None => Self::remove_vec_value(env, key),
-        }
-    }
-    pub fn has_vec_value(env: &soroban_sdk::Env, key: &Vec<u32>) -> bool {
-        let key = StorageKeys::VecValue(key.clone());
-        let exists = env.storage().persistent().has(&key);
-        if exists {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        exists
-    }
-    pub fn extend_vec_value_ttl(
-        env: &soroban_sdk::Env,
-        key: &Vec<u32>,
-        threshold: u32,
-        extend_to: u32,
-    ) {
-        let key = StorageKeys::VecValue(key.clone());
-        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-    }
-    pub fn address_value(env: &soroban_sdk::Env, key: &Address) -> Option<Address> {
-        let key = StorageKeys::AddressValue(key.clone());
-        let value = env.storage().persistent().get::<_, Address>(&key);
-        if value.is_some() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_address_value(env: &soroban_sdk::Env, key: &Address, value: &Address) {
-        let key = StorageKeys::AddressValue(key.clone());
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    pub fn remove_address_value(env: &soroban_sdk::Env, key: &Address) {
-        let key = StorageKeys::AddressValue(key.clone());
-        env.storage().persistent().remove(&key);
-    }
-    pub fn set_or_remove_address_value(
-        env: &soroban_sdk::Env,
-        key: &Address,
-        value: &Option<Address>,
-    ) {
-        match value.as_ref() {
-            Some(v) => Self::set_address_value(env, key, v),
-            None => Self::remove_address_value(env, key),
-        }
-    }
-    pub fn has_address_value(env: &soroban_sdk::Env, key: &Address) -> bool {
-        let key = StorageKeys::AddressValue(key.clone());
-        let exists = env.storage().persistent().has(&key);
-        if exists {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        exists
-    }
-    pub fn extend_address_value_ttl(
-        env: &soroban_sdk::Env,
-        key: &Address,
-        threshold: u32,
-        extend_to: u32,
-    ) {
-        let key = StorageKeys::AddressValue(key.clone());
-        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-    }
-    pub fn unit_variant(env: &soroban_sdk::Env) -> Option<u32> {
-        let key = StorageKeys::UnitVariant;
-        let value = env.storage().persistent().get::<_, u32>(&key);
-        if value.is_some() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        value
-    }
-    pub fn set_unit_variant(env: &soroban_sdk::Env, value: &u32) {
-        let key = StorageKeys::UnitVariant;
-        env.storage().persistent().set(&key, value);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    pub fn remove_unit_variant(env: &soroban_sdk::Env) {
-        let key = StorageKeys::UnitVariant;
-        env.storage().persistent().remove(&key);
-    }
-    pub fn set_or_remove_unit_variant(env: &soroban_sdk::Env, value: &Option<u32>) {
-        match value.as_ref() {
-            Some(v) => Self::set_unit_variant(env, v),
-            None => Self::remove_unit_variant(env),
-        }
-    }
-    pub fn has_unit_variant(env: &soroban_sdk::Env) -> bool {
-        let key = StorageKeys::UnitVariant;
-        let exists = env.storage().persistent().has(&key);
-        if exists {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        exists
-    }
-    pub fn extend_unit_variant_ttl(
-        env: &soroban_sdk::Env,
-        threshold: u32,
-        extend_to: u32,
-    ) {
-        let key = StorageKeys::UnitVariant;
-        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-    }
-    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() {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        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);
-        if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-            env,
-        ) {
-            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-        }
-    }
-    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 {
-            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::persistent(
-                env,
-            ) {
-                env.storage().persistent().extend_ttl(&key, threshold, extend_to);
-            }
-        }
-        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);
-    }
-}