@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.123

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

@@ -1,412 +0,0 @@
----
-source: contracts/common-macros/src/tests/storage/generate_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_else(|| 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_else(|| 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);
-    }
-}

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

@@ -1,39 +0,0 @@
-//! Unit tests for the `StorageKind` enum methods via wrapper functions.
-
-use crate::storage::test::{
-    storage_kind_instance_accessor, storage_kind_instance_name, storage_kind_persistent_accessor,
-    storage_kind_persistent_name, storage_kind_temporary_accessor, storage_kind_temporary_name,
-};
-
-#[test]
-fn test_instance_name() {
-    assert_eq!(storage_kind_instance_name(), "instance");
-}
-
-#[test]
-fn test_persistent_name() {
-    assert_eq!(storage_kind_persistent_name(), "persistent");
-}
-
-#[test]
-fn test_temporary_name() {
-    assert_eq!(storage_kind_temporary_name(), "temporary");
-}
-
-#[test]
-fn test_instance_accessor() {
-    let accessor = storage_kind_instance_accessor();
-    assert_eq!(accessor.to_string(), "env . storage () . instance ()");
-}
-
-#[test]
-fn test_persistent_accessor() {
-    let accessor = storage_kind_persistent_accessor();
-    assert_eq!(accessor.to_string(), "env . storage () . persistent ()");
-}
-
-#[test]
-fn test_temporary_accessor() {
-    let accessor = storage_kind_temporary_accessor();
-    assert_eq!(accessor.to_string(), "env . storage () . temporary ()");
-}

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

@@ -1,25 +0,0 @@
-//! Shared helpers for storage macro unit tests.
-//!
-//! Keep these helpers scoped to the storage test module to avoid leaking
-//! test-only utilities across the crate.
-/// Parse the first `syn::Variant` from a single-variant `enum` token stream.
-pub(in crate::tests::storage) fn parse_variant(input: proc_macro2::TokenStream) -> syn::Variant {
-    let item_enum: syn::ItemEnum = syn::parse2(input).expect("failed to parse enum");
-    item_enum.variants.into_iter().next().expect("no variant found")
-}
-
-/// Parse the attributes from the first variant in a single-variant `enum` token stream.
-pub(in crate::tests::storage) fn parse_attrs(input: proc_macro2::TokenStream) -> Vec<syn::Attribute> {
-    let item_enum: syn::ItemEnum = syn::parse2(input).expect("failed to parse enum");
-    item_enum.variants.into_iter().next().expect("no variant found").attrs
-}
-
-/// Normalize whitespace in a `TokenStream` for stable string comparisons.
-pub(in crate::tests::storage) fn normalize(ts: proc_macro2::TokenStream) -> String {
-    ts.to_string().split_whitespace().collect::<Vec<_>>().join(" ")
-}
-
-/// Convenience for tests building input via `format!(...)`.
-pub(in crate::tests::storage) fn parse_variant_str(input: &str) -> syn::Variant {
-    parse_variant(input.parse().expect("failed to parse token stream"))
-}

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

@@ -1,138 +0,0 @@
-//! Unit tests for the `validate_attrs` function.
-
-use crate::storage::test::{known_attrs_for_test, validate_attrs_for_test};
-use quote::{format_ident, quote};
-
-use super::test_setup::parse_attrs;
-
-#[test]
-fn test_accepts_known_attributes() {
-    let known_attrs = known_attrs_for_test();
-
-    for attr_name in known_attrs {
-        if *attr_name == "doc" {
-            // doc attribute uses /// syntax
-            let attrs = parse_attrs(quote! {
-                enum Test {
-                    /// This is a doc comment
-                    #[persistent(u32)]
-                    Variant,
-                }
-            });
-            let variant_ident = format_ident!("Variant");
-            assert!(validate_attrs_for_test(&attrs, &variant_ident).is_ok(), "doc attribute should be accepted");
-        } else {
-            // Other attributes use #[attr] or #[attr(...)] syntax
-            let input = match *attr_name {
-                "instance" => quote! {
-                    enum Test {
-                        #[instance(u32)]
-                        Variant,
-                    }
-                },
-                "persistent" => quote! {
-                    enum Test {
-                        #[persistent(u32)]
-                        Variant,
-                    }
-                },
-                "temporary" => quote! {
-                    enum Test {
-                        #[temporary(u32)]
-                        Variant,
-                    }
-                },
-                "default" => quote! {
-                    enum Test {
-                        #[persistent(u32)]
-                        #[default(0)]
-                        Variant,
-                    }
-                },
-                "name" => quote! {
-                    enum Test {
-                        #[persistent(u32)]
-                        #[name("custom")]
-                        Variant,
-                    }
-                },
-                "no_ttl_extension" => quote! {
-                    enum Test {
-                        #[persistent(u32)]
-                        #[no_ttl_extension]
-                        Variant,
-                    }
-                },
-                _ => continue,
-            };
-
-            let attrs = parse_attrs(input);
-            let variant_ident = format_ident!("Variant");
-            assert!(
-                validate_attrs_for_test(&attrs, &variant_ident).is_ok(),
-                "attribute '{}' should be accepted",
-                attr_name
-            );
-        }
-    }
-}
-
-#[test]
-fn test_rejects_unknown_attribute() {
-    let attrs = parse_attrs(quote! {
-        enum Test {
-            #[persistent(u32)]
-            #[unknown_attr]
-            Variant,
-        }
-    });
-    let variant_ident = format_ident!("Variant");
-
-    let result = validate_attrs_for_test(&attrs, &variant_ident);
-    assert!(result.is_err(), "unknown attribute should be rejected");
-    let err = result.unwrap_err();
-    assert!(
-        err.contains("unknown attribute 'unknown_attr' on variant 'Variant'"),
-        "error should mention unknown attribute"
-    );
-}
-
-#[test]
-fn test_accepts_multiple_valid_attributes() {
-    let attrs = parse_attrs(quote! {
-        enum Test {
-            /// Doc comment
-            #[persistent(u32)]
-            #[default(0)]
-            #[name("custom")]
-            Variant,
-        }
-    });
-    let variant_ident = format_ident!("Variant");
-
-    assert!(validate_attrs_for_test(&attrs, &variant_ident).is_ok(), "multiple valid attributes should be accepted");
-}
-
-#[test]
-fn test_empty_attrs_is_valid() {
-    let attrs: Vec<syn::Attribute> = vec![];
-    let variant_ident = format_ident!("Variant");
-
-    // Empty attrs is valid for validate_attrs (storage type check is separate)
-    assert!(validate_attrs_for_test(&attrs, &variant_ident).is_ok());
-}
-
-#[test]
-fn test_rejects_path_attribute() {
-    let attrs = parse_attrs(quote! {
-        enum Test {
-            #[persistent(u32)]
-            #[some::path::attr]
-            Variant,
-        }
-    });
-    let variant_ident = format_ident!("Variant");
-
-    let result = validate_attrs_for_test(&attrs, &variant_ident);
-    assert!(result.is_err(), "path attributes should be rejected");
-}