@layerzerolabs/protocol-stellar-v2 0.2.9 → 0.2.11

package/Cargo.lock

@@ -613,6 +613,7 @@ dependencies = [
  "common-macros",
  "message-lib-common",
  "soroban-sdk",
+ "utils",
  "worker",
 ]
 
@@ -1176,18 +1177,14 @@ dependencies = [
 ]
 
 [[package]]
-name = "oft-mint-burn"
+name = "oft-std"
 version = "0.0.1"
 dependencies = [
- "assert_unordered",
  "common-macros",
  "endpoint-v2",
- "executor",
- "message-lib-common",
  "oapp",
  "oapp-macros",
  "oft",
- "simple-message-lib",
  "soroban-sdk",
  "utils",
 ]
@@ -1257,6 +1254,17 @@ dependencies = [
  "syn 2.0.108",
 ]
 
+[[package]]
+name = "price-feed"
+version = "0.0.1"
+dependencies = [
+ "common-macros",
+ "endpoint-v2",
+ "soroban-sdk",
+ "utils",
+ "worker",
+]
+
 [[package]]
 name = "primeorder"
 version = "0.13.6"

package/contracts/common-macros/src/contract_impl.rs

@@ -18,12 +18,15 @@ pub fn contract_impl(attr: TokenStream, input: TokenStream) -> TokenStream {
         }
 
         // Skip methods without Env parameter
-        let Some(env_ident) = utils::find_env_ident(&method.sig.inputs) else { continue };
+        let Some(env_param) = utils::find_env_param(&method.sig.inputs) else { continue };
+
+        // Get a reference to env (handles both `Env` and `&Env` parameter types)
+        let env_ref = env_param.as_ref_tokens();
+        let env_ident = env_param.ident;
 
-        // TODO: should support Env instead of &Env?
         // Use fully qualified syntax to call ttl_configs from TtlConfigurable trait
         let extend_ttl_stmt = parse_quote! {
-            if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(#env_ident) {
+            if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(#env_ref) {
                 #env_ident.storage().instance().extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
             }
         };

package/contracts/common-macros/src/error.rs

@@ -1,17 +1,15 @@
-use proc_macro::TokenStream;
+use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{parse_macro_input, parse_quote, spanned::Spanned, ExprLit, Fields, ItemEnum, Lit, Token};
-
-/// The default starting value for error enum discriminants when no explicit value is provided.
-/// This ensures error codes start from 1 instead of 0.
-const DEFAULT_OFFSET: u32 = 1;
+use syn::{parse_quote, spanned::Spanned, ExprLit, Fields, ItemEnum, Lit, Token};
 
 pub fn generate_error(attr: TokenStream, item: TokenStream) -> TokenStream {
     assert!(attr.is_empty(), "contract_error attribute is not supported");
 
-    let mut data_enum = parse_macro_input!(item as ItemEnum);
+    let mut data_enum: ItemEnum = syn::parse2(item).unwrap_or_else(|e| panic!("failed to parse enum: {}", e));
 
-    let mut current_value = DEFAULT_OFFSET;
+    // For variants without an explicit discriminant, assign sequential error codes starting at 1
+    // (by initializing the counter to 0 and incrementing before assignment).
+    let mut current_value = 0;
     for variant in &mut data_enum.variants {
         assert!(matches!(variant.fields, Fields::Unit), "Error enum variants must be unit variants");
 
@@ -19,15 +17,12 @@ pub fn generate_error(attr: TokenStream, item: TokenStream) -> TokenStream {
         if let Some((_, disc)) = &variant.discriminant {
             // Explicit discriminant - validate it's greater than previous and update counter
             let val = parse_discriminant_value(disc);
-            assert!(
-                val >= current_value,
-                "Error enum discriminant must be greater than or equal to the previous discriminant"
-            );
-            current_value = val + 1;
+            assert!(val > current_value, "Error enum discriminant must be greater than the previous discriminant");
+            current_value = val;
         } else {
             // No discriminant - assign the next sequential value
-            variant.discriminant = Some((Token![=](variant.span()), parse_quote!(#current_value)));
             current_value += 1;
+            variant.discriminant = Some((Token![=](variant.span()), parse_quote!(#current_value)));
         }
     }
 
@@ -37,7 +32,6 @@ pub fn generate_error(attr: TokenStream, item: TokenStream) -> TokenStream {
         #[repr(u32)]
         #data_enum
     }
-    .into()
 }
 
 /// Parses a discriminant value from a variant, returning the u32 value if valid.
@@ -49,5 +43,3 @@ fn parse_discriminant_value(disc: &syn::Expr) -> u32 {
         panic!("Error enum discriminant must be an integer literal")
     }
 }
-
-// TODO: add test for this

package/contracts/common-macros/src/event.rs

@@ -1,9 +1,9 @@
-use proc_macro::TokenStream;
+use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{parse_macro_input, DeriveInput};
+use syn::DeriveInput;
 
 pub fn generate_event(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(item as DeriveInput);
+    let input: DeriveInput = syn::parse2(item).unwrap_or_else(|e| panic!("failed to parse input: {}", e));
     let struct_name = input.ident.to_string();
 
     let expanded = quote! {
@@ -12,5 +12,5 @@ pub fn generate_event(_attr: TokenStream, item: TokenStream) -> TokenStream {
         #input
     };
 
-    TokenStream::from(expanded)
+    expanded
 }

package/contracts/common-macros/src/lib.rs

@@ -115,7 +115,7 @@ pub fn storage(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_attribute]
 pub fn event(attr: TokenStream, item: TokenStream) -> TokenStream {
-    event::generate_event(attr, item)
+    event::generate_event(attr.into(), item.into()).into()
 }
 
 // ============================================================================
@@ -149,7 +149,7 @@ pub fn event(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_attribute]
 pub fn contract_error(attr: TokenStream, item: TokenStream) -> TokenStream {
-    error::generate_error(attr, item)
+    error::generate_error(attr.into(), item.into()).into()
 }
 
 // ============================================================================

package/contracts/common-macros/src/ownable.rs

@@ -1,4 +1,4 @@
-use crate::utils::expect_env_ident;
+use crate::utils;
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
 use syn::{parse_quote, ItemFn, ItemStruct};
@@ -20,16 +20,18 @@ pub fn generate_ownable_impl(input: TokenStream) -> TokenStream {
         }
 
         /// Implement the Ownable trait for the contract.
-        #[soroban_sdk::contractimpl]
+        #[common_macros::contract_impl]
         impl utils::ownable::Ownable for #name {
             fn owner(env: &soroban_sdk::Env) -> Option<soroban_sdk::Address> {
                 utils::ownable::DefaultOwnable::owner(env)
             }
 
+            #[common_macros::only_owner]
             fn transfer_ownership(env: &soroban_sdk::Env, new_owner: &soroban_sdk::Address) {
                 utils::ownable::DefaultOwnable::transfer_ownership(env, new_owner)
             }
 
+            #[common_macros::only_owner]
             fn renounce_ownership(env: &soroban_sdk::Env) {
                 utils::ownable::DefaultOwnable::renounce_ownership(env)
             }
@@ -46,10 +48,12 @@ pub fn generate_ownable_impl(input: TokenStream) -> TokenStream {
 pub fn prepend_only_owner_check(input: TokenStream) -> TokenStream {
     let mut input_fn: ItemFn = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse function: {}", e));
 
-    let env_ident = expect_env_ident(&input_fn.sig.inputs);
+    let env_param = utils::expect_env_param(&input_fn.sig.inputs);
+
+    // Get a reference to env (handles both `Env` and `&Env` parameter types)
+    let env_ref = env_param.as_ref_tokens();
 
-    // TODO: should support Env instead of &Env?
     // Insert the owner authentication check at the beginning of the function body
-    input_fn.block.stmts.insert(0, parse_quote!(utils::ownable::require_owner_auth::<Self>(#env_ident);));
+    input_fn.block.stmts.insert(0, parse_quote!(utils::ownable::require_owner_auth::<Self>(#env_ref);));
     input_fn.into_token_stream()
 }

package/contracts/common-macros/src/tests/contract_impl.rs

@@ -30,7 +30,7 @@ fn snapshot_generated_contract_impl_code() {
             }
 
             /// Public method with Env not as first parameter - should have TTL extension
-            pub fn env_second(value: u32, env: Env) -> u32 {
+            pub fn env_second(value: u32, env: &Env) -> u32 {
                 value * 2
             }
 
@@ -67,6 +67,12 @@ fn snapshot_generated_contract_impl_code() {
             fn trait_method_without_env(value: u32) -> u32 {
                 value * 4
             }
+
+            /// Trait method with macro attribute - should have TTL extension
+            #[common_macros::only_owner]
+            fn trait_method_with_only_owner_attribute(env: Env, value: u32) -> u32 {
+                value * 5
+            }
         }
     };
 
@@ -79,7 +85,7 @@ fn snapshot_generated_contract_impl_code() {
     let contracttrait_input = quote! {
         impl AnotherTrait for MyContract {
             /// Trait method with contracttrait attr - should have TTL extension
-            fn contracttrait_method(env: Env, value: u32) -> u32 {
+            fn contracttrait_method(env: &Env, value: u32) -> u32 {
                 value * 3
             }
         }
@@ -193,97 +199,183 @@ fn test_adds_soroban_contractimpl_attribute_with_attr() {
     );
 }
 
-/// Helper to assert TTL extension behavior in generated code
-fn assert_ttl_extension(input: TokenStream, expected: bool, env_ident: Option<&str>, case: &str) {
-    let result = crate::contract_impl::contract_impl(TokenStream::new(), input);
-    let result_str = result.to_string();
+/// Expected TTL extension behavior for a test case
+#[derive(Clone)]
+enum TtlExpectation {
+    /// TTL extension should NOT be inserted
+    None,
+    /// TTL extension should be inserted with the given env patterns
+    /// - `instance_arg`: pattern in `TtlConfigStorage::instance(...)` (e.g., "& env" for owned, "env" for ref)
+    /// - `storage_ident`: identifier for `.storage()` call
+    Present { instance_arg: &'static str, storage_ident: &'static str },
+}
 
-    let has_ttl = result_str.contains("TtlConfigStorage :: instance");
+struct TtlTestCase {
+    name: &'static str,
+    input: TokenStream,
+    expectation: TtlExpectation,
+}
 
-    assert_eq!(
-        has_ttl,
-        expected,
-        "{}: TTL extension {} but {}",
-        case,
-        if expected { "expected" } else { "not expected" },
-        if has_ttl { "was found" } else { "was not found" }
-    );
+impl TtlTestCase {
+    fn expect_ttl(
+        name: &'static str,
+        input: TokenStream,
+        instance_arg: &'static str,
+        storage_ident: &'static str,
+    ) -> Self {
+        Self { name, input, expectation: TtlExpectation::Present { instance_arg, storage_ident } }
+    }
 
-    if expected {
-        assert!(result_str.contains("extend_ttl"), "{}: should insert extend_ttl call", case);
-
-        // Verify correct env identifier is used in TTL extension code
-        if let Some(env) = env_ident {
-            let instance_pattern = format!("TtlConfigStorage :: instance ({})", env);
-            let storage_pattern = format!("{} . storage ()", env);
-            assert!(
-                result_str.contains(&instance_pattern),
-                "{}: should use '{}' in TtlConfigStorage::instance call",
-                case,
-                env
-            );
-            assert!(result_str.contains(&storage_pattern), "{}: should use '{}' for storage access", case, env);
+    fn expect_no_ttl(name: &'static str, input: TokenStream) -> Self {
+        Self { name, input, expectation: TtlExpectation::None }
+    }
+
+    fn run(&self) {
+        let result = crate::contract_impl::contract_impl(TokenStream::new(), self.input.clone());
+        let result_str = result.to_string();
+        let has_ttl = result_str.contains("TtlConfigStorage :: instance");
+
+        match &self.expectation {
+            TtlExpectation::None => {
+                assert!(!has_ttl, "{}: TTL extension should NOT be present, but was found", self.name);
+            }
+            TtlExpectation::Present { instance_arg, storage_ident } => {
+                assert!(has_ttl, "{}: TTL extension should be present, but was not found", self.name);
+                assert!(result_str.contains("extend_ttl"), "{}: should insert extend_ttl call", self.name);
+
+                let instance_pattern = format!("TtlConfigStorage :: instance ({})", instance_arg);
+                assert!(
+                    result_str.contains(&instance_pattern),
+                    "{}: expected '{}' in TtlConfigStorage::instance call. Got: {}",
+                    self.name,
+                    instance_arg,
+                    result_str
+                );
+
+                let storage_pattern = format!("{} . storage ()", storage_ident);
+                assert!(
+                    result_str.contains(&storage_pattern),
+                    "{}: expected '{}.storage()' call",
+                    self.name,
+                    storage_ident
+                );
+            }
         }
     }
 }
 
 #[test]
-fn test_ttl_extension_insertion() {
-    let cases: Vec<(&str, TokenStream, bool, Option<&str>)> = vec![
-        // (case name, input, should have TTL extension, optional env ident to verify)
-        (
-            "public method with Env",
-            quote! {
-                impl MyContract {
-                    pub fn my_method(env: Env) { let x = 1; }
-                }
-            },
-            true,
-            Some("env"),
-        ),
-        (
-            "private method with Env",
-            quote! {
-                impl MyContract {
-                    fn private_method(env: Env) { let x = 1; }
-                }
-            },
-            false,
-            None,
-        ),
-        (
-            "public method without Env",
-            quote! {
-                impl MyContract {
-                    pub fn no_env_method(value: u32) -> u32 { value }
-                }
-            },
-            false,
-            None,
-        ),
-        (
-            "custom Env identifier",
-            quote! {
-                impl MyContract {
-                    pub fn my_method(my_custom_env: Env) { let x = 1; }
-                }
-            },
-            true,
-            Some("my_custom_env"),
-        ),
-        (
-            "trait impl method with Env",
-            quote! {
-                impl SomeTrait for MyContract {
-                    fn trait_method(env: Env) { let x = 1; }
-                }
-            },
-            true,
-            Some("env"),
-        ),
-    ];
+fn test_ttl_extension_with_owned_env() {
+    TtlTestCase::expect_ttl(
+        "public method with owned Env",
+        quote! {
+            impl MyContract {
+                pub fn my_method(env: Env) { let x = 1; }
+            }
+        },
+        "& env", // instance takes reference
+        "env",   // storage called on ident
+    )
+    .run();
+}
 
-    for (case, input, expected, env_ident) in cases {
-        assert_ttl_extension(input, expected, env_ident, case);
-    }
+#[test]
+fn test_ttl_extension_with_ref_env() {
+    TtlTestCase::expect_ttl(
+        "public method with ref Env",
+        quote! {
+            impl MyContract {
+                pub fn my_method(env: &Env) { let x = 1; }
+            }
+        },
+        "env", // instance takes ident directly (already a ref)
+        "env",
+    )
+    .run();
+}
+
+#[test]
+fn test_ttl_extension_with_custom_env_ident_owned() {
+    TtlTestCase::expect_ttl(
+        "custom Env identifier (owned)",
+        quote! {
+            impl MyContract {
+                pub fn my_method(my_custom_env: Env) { let x = 1; }
+            }
+        },
+        "& my_custom_env",
+        "my_custom_env",
+    )
+    .run();
+}
+
+#[test]
+fn test_ttl_extension_with_custom_env_ident_ref() {
+    TtlTestCase::expect_ttl(
+        "custom Env identifier (ref)",
+        quote! {
+            impl MyContract {
+                pub fn my_method(my_custom_env: &Env) { let x = 1; }
+            }
+        },
+        "my_custom_env",
+        "my_custom_env",
+    )
+    .run();
+}
+
+#[test]
+fn test_ttl_extension_for_trait_impl_owned_env() {
+    TtlTestCase::expect_ttl(
+        "trait impl method with owned Env",
+        quote! {
+            impl SomeTrait for MyContract {
+                fn trait_method(env: Env) { let x = 1; }
+            }
+        },
+        "& env",
+        "env",
+    )
+    .run();
+}
+
+#[test]
+fn test_ttl_extension_for_trait_impl_ref_env() {
+    TtlTestCase::expect_ttl(
+        "trait impl method with ref Env",
+        quote! {
+            impl SomeTrait for MyContract {
+                fn trait_method(env: &Env) { let x = 1; }
+            }
+        },
+        "env",
+        "env",
+    )
+    .run();
+}
+
+#[test]
+fn test_no_ttl_extension_for_private_method() {
+    TtlTestCase::expect_no_ttl(
+        "private method with Env",
+        quote! {
+            impl MyContract {
+                fn private_method(env: Env) { let x = 1; }
+            }
+        },
+    )
+    .run();
+}
+
+#[test]
+fn test_no_ttl_extension_without_env_param() {
+    TtlTestCase::expect_no_ttl(
+        "public method without Env",
+        quote! {
+            impl MyContract {
+                pub fn no_env_method(value: u32) -> u32 { value }
+            }
+        },
+    )
+    .run();
 }

package/contracts/common-macros/src/tests/error.rs

@@ -0,0 +1,168 @@
+use quote::quote;
+
+use crate::tests::test_helpers::{assert_panics_contains, non_enum_item_inputs};
+
+// ============================================
+// Error Cases: Invalid Inputs
+// ============================================
+
+#[test]
+fn test_contract_error_rejects_non_enum_inputs() {
+    for (case, input) in non_enum_item_inputs() {
+        assert_panics_contains(case, "failed to parse enum", || {
+            crate::error::generate_error(quote! {}, input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_contract_error_rejects_attr_arguments() {
+    let input = quote! {
+        pub enum MyError {
+            A,
+        }
+    };
+    assert_panics_contains("attr not empty", "contract_error attribute is not supported", || {
+        crate::error::generate_error(quote! { some_attr }, input);
+    });
+}
+
+#[test]
+fn test_contract_error_requires_unit_variants() {
+    let cases = vec![("tuple variant", quote! { A(u32) }), ("struct variant", quote! { A { x: u32 } })];
+
+    for (case, variant) in cases {
+        let input = quote! {
+            pub enum MyError {
+                #variant,
+            }
+        };
+        assert_panics_contains(case, "Error enum variants must be unit variants", || {
+            crate::error::generate_error(quote! {}, input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_contract_error_discriminant_must_be_integer_literal() {
+    let cases = vec![
+        ("binary expr", quote! { 1 + 1 }),
+        ("path expr", quote! { SOME_CONST }),
+        ("negative integer (unary expr)", quote! { -1 }),
+        ("paren expr", quote! { (1) }),
+        ("bool literal", quote! { true }),
+        ("string literal", quote! { "1" }),
+        ("float literal", quote! { 1.0 }),
+        ("char literal", quote! { 'a' }),
+    ];
+
+    for (case, expr) in cases {
+        let input = quote! {
+            pub enum MyError {
+                A = #expr,
+            }
+        };
+        assert_panics_contains(case, "Error enum discriminant must be an integer literal", || {
+            crate::error::generate_error(quote! {}, input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_contract_error_discriminant_must_fit_u32() {
+    let input = quote! {
+        pub enum MyError {
+            A = 4294967296,
+        }
+    };
+
+    assert_panics_contains("u32::MAX + 1", "Error enum discriminant must be a valid u32 integer", || {
+        crate::error::generate_error(quote! {}, input);
+    });
+}
+
+#[test]
+fn test_contract_error_discriminants_ordering_rejections_table_driven() {
+    let cases = vec![
+        (
+            "explicit value is less than previous",
+            quote! {
+                // A is assigned 1 by default; B cannot go backwards.
+                A,
+                B = 1,
+            },
+        ),
+        (
+            "explicit zero",
+            quote! {
+                A = 0,
+            },
+        ),
+        (
+            "explicit equal to previous explicit",
+            quote! {
+                A = 1,
+                B = 1,
+            },
+        ),
+        (
+            "explicit decreases after explicit",
+            quote! {
+                A = 5,
+                B = 4,
+            },
+        ),
+    ];
+
+    for (case, variants) in cases {
+        let input = quote! {
+            pub enum MyError {
+                #variants
+            }
+        };
+        assert_panics_contains(case, "Error enum discriminant must be greater than the previous discriminant", || {
+            crate::error::generate_error(quote! {}, input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_contract_error_max_not_last_panics_overflow() {
+    let input = quote! {
+        pub enum MyError {
+            A = 4294967295,
+            B,
+        }
+    };
+    assert_panics_contains("max not last overflows", "attempt to add with overflow", || {
+        crate::error::generate_error(quote! {}, input);
+    });
+}
+
+// ============================================
+// Valid Cases: Snapshot Tests for Generated Code
+// ============================================
+
+#[test]
+fn snapshot_generated_contract_error_code() {
+    let input = quote! {
+        /// Example error enum
+        pub enum MyError {
+            /// Implicit (should start at 1)
+            A,
+            /// Implicit (should be 2)
+            B,
+            /// Explicit (must be >= previous + 1)
+            C = 10,
+            /// Implicit (should be 11)
+            D,
+            /// Explicit max boundary (u32::MAX)
+            E = 4294967295,
+        }
+    };
+
+    let result = crate::error::generate_error(quote! {}, input);
+    let formatted = prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
+
+    insta::assert_snapshot!(formatted);
+}

package/contracts/common-macros/src/tests/mod.rs

@@ -1,9 +1,7 @@
 mod contract_impl;
+mod error;
 mod ownable;
 mod storage;
 mod test_helpers;
 mod ttl_configurable;
-
-// Note: error.rs and event.rs use proc_macro::TokenStream which cannot be tested
-// outside of a procedural macro context. These macros are tested via integration
-// tests in the contracts that use them (e.g., utils crate).
+mod utils;