@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/common-macros/src/snapshots/common_macros__tests__tests__snapshot_generated_storage_code.snap

@@ -0,0 +1,310 @@
+---
+source: contracts/common-macros/src/tests.rs
+assertion_line: 285
+expression: formatted
+---
+use utils::ttl::TtlConfigProvider as _;
+#[soroban_sdk::contracttype]
+pub enum StorageKeys {
+    Counter,
+    Message(Address),
+    Flag(String),
+    Data(u64, String),
+    Owner,
+    OptionalData(BytesN<32>),
+}
+impl StorageKeys {
+    pub fn counter(env: &soroban_sdk::Env) -> u32 {
+        let key = StorageKeys::Counter;
+        let value = env.storage().instance().get::<_, u32>(&key);
+        if value.is_some() {
+            let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::instance::<
+                TtlProvider,
+            >(env);
+            env.storage().instance().extend_ttl(threshold, extend_to);
+        }
+        value.unwrap_or(0)
+    }
+    pub fn set_counter(env: &soroban_sdk::Env, value: &u32) {
+        let key = StorageKeys::Counter;
+        env.storage().instance().set(&key, value);
+        let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::instance::<
+            TtlProvider,
+        >(env);
+        env.storage().instance().extend_ttl(threshold, extend_to);
+    }
+    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;
+        let exists = env.storage().instance().has(&key);
+        if exists {
+            let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::instance::<
+                TtlProvider,
+            >(env);
+            env.storage().instance().extend_ttl(threshold, extend_to);
+        }
+        exists
+    }
+    pub fn extend_ttl_counter(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() {
+            let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::persistent::<
+                TtlProvider,
+            >(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);
+        let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::persistent::<
+            TtlProvider,
+        >(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 {
+            let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::persistent::<
+                TtlProvider,
+            >(env);
+            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+        }
+        exists
+    }
+    pub fn extend_ttl_message(
+        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());
+        env.storage().temporary().get::<_, bool>(&key)
+    }
+    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());
+        let exists = env.storage().temporary().has(&key);
+        if exists {}
+        exists
+    }
+    pub fn extend_ttl_flag(
+        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() {
+            let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::persistent::<
+                TtlProvider,
+            >(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);
+        let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::persistent::<
+            TtlProvider,
+        >(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 {
+            let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::persistent::<
+                TtlProvider,
+            >(env);
+            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+        }
+        exists
+    }
+    pub fn extend_ttl_data(
+        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() {
+            let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::persistent::<
+                TtlProvider,
+            >(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);
+        let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::persistent::<
+            TtlProvider,
+        >(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 {
+            let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::persistent::<
+                TtlProvider,
+            >(env);
+            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+        }
+        exists
+    }
+    pub fn extend_ttl_owner(env: &soroban_sdk::Env, threshold: u32, extend_to: u32) {
+        let key = StorageKeys::Owner;
+        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+    }
+    pub fn optional_data(
+        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() {
+            let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::persistent::<
+                TtlProvider,
+            >(env);
+            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+        }
+        value
+    }
+    pub fn set_optional_data(
+        env: &soroban_sdk::Env,
+        key: &BytesN<32>,
+        value: &Option<Address>,
+    ) {
+        let key = StorageKeys::OptionalData(key.clone());
+        env.storage().persistent().set(&key, value);
+        let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::persistent::<
+            TtlProvider,
+        >(env);
+        env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+    }
+    pub fn remove_optional_data(env: &soroban_sdk::Env, key: &BytesN<32>) {
+        let key = StorageKeys::OptionalData(key.clone());
+        env.storage().persistent().remove(&key);
+    }
+    pub fn set_or_remove_optional_data(
+        env: &soroban_sdk::Env,
+        key: &BytesN<32>,
+        value: &Option<Option<Address>>,
+    ) {
+        match value.as_ref() {
+            Some(v) => Self::set_optional_data(env, key, v),
+            None => Self::remove_optional_data(env, key),
+        }
+    }
+    pub fn has_optional_data(env: &soroban_sdk::Env, key: &BytesN<32>) -> bool {
+        let key = StorageKeys::OptionalData(key.clone());
+        let exists = env.storage().persistent().has(&key);
+        if exists {
+            let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::persistent::<
+                TtlProvider,
+            >(env);
+            env.storage().persistent().extend_ttl(&key, threshold, extend_to);
+        }
+        exists
+    }
+    pub fn extend_ttl_optional_data(
+        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);
+    }
+}