@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.18

package/sdk/vitest.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        // Global setup runs ONCE before all test files
+        globalSetup: './test/suites/globalSetup.ts',
+        // Run tests sequentially to avoid conflicts with shared blockchain state
+        sequence: {
+            concurrent: false,
+        },
+        // Longer timeouts for blockchain operations
+        testTimeout: 120000,
+        hookTimeout: 240000,
+        // Don't isolate test files - they share the same localnet
+        isolate: false,
+        // Run test files sequentially
+        fileParallelism: false,
+        // Stop on first failure
+        bail: 1,
+    },
+});

package/tools/ts-bindings-gen/src/main.rs

@@ -52,6 +52,7 @@ fn main() -> Result<()> {
         ("simple_message_lib", "sml.ts"),
         ("blocked_message_lib", "bml.ts"),
         ("uln302", "uln302.ts"),
+        ("treasury", "treasury.ts"),
         ("upgrader", "upgrader.ts"),
         // Worker contracts
         ("dvn", "dvn.ts"),

package/turbo.json

@@ -4,6 +4,8 @@
         "build": {
             "outputs": [
                 "sdk/src/generated/**",
+                "sdk/src/wasm/**",
+                "sdk/src/wasm.ts",
                 "target/wasm32v1-none/release/*.wasm",
                 "target/wasm32v1-none/release/*.d"
             ]

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

@@ -1,52 +0,0 @@
-use crate::utils;
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::{parse_quote, ImplItem, ItemImpl, Visibility};
-
-/// Generates a `#[soroban_sdk::contractimpl]` with automatic instance TTL extension.
-pub fn contract_impl(attr: TokenStream, input: TokenStream) -> TokenStream {
-    let mut impl_block: ItemImpl = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse impl block: {}", e));
-
-    let is_trait_impl = impl_block.trait_.is_some();
-
-    for item in &mut impl_block.items {
-        let ImplItem::Fn(method) = item else { continue };
-
-        // For trait impls, process all methods; for inherent impls, only public methods
-        if !is_trait_impl && !matches!(method.vis, Visibility::Public(_)) {
-            continue;
-        }
-
-        // Skip the constructor as TTL config is typically not set during initialization
-        if method.sig.ident == "__constructor" {
-            continue;
-        }
-
-        // Skip methods without Env parameter
-        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;
-
-        // Use fully qualified syntax to call ttl_configs from TtlConfigurable trait
-        let extend_ttl_stmt = parse_quote! {
-            if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(#env_ref) {
-                #env_ident.storage().instance().extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
-            }
-        };
-        method.block.stmts.insert(0, extend_ttl_stmt);
-    }
-
-    if attr.is_empty() {
-        quote! {
-            #[soroban_sdk::contractimpl]
-            #impl_block
-        }
-    } else {
-        quote! {
-            #[soroban_sdk::contractimpl(#attr)]
-            #impl_block
-        }
-    }
-}

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

@@ -1,41 +0,0 @@
-use crate::utils;
-use proc_macro2::TokenStream;
-use quote::{quote, ToTokens};
-use syn::{parse_quote, ItemFn, ItemStruct};
-
-/// Generates the ownable implementation from the `#[ownable]` attribute macro.
-pub fn generate_ownable_impl(input: TokenStream) -> TokenStream {
-    let item_struct: ItemStruct = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
-    let name = &item_struct.ident;
-
-    let ownable_impl = quote! {
-        use utils::ownable::OwnableInitializer as _;
-        use utils::ownable::Ownable;
-
-        // Import OwnableInitializer at module level so user code can call Self::init_owner()
-        impl utils::ownable::OwnableInitializer for #name {}
-
-        /// Implement the Ownable trait for the contract with default implementations.
-        #[common_macros::contract_impl(contracttrait)]
-        impl Ownable for #name {}
-    };
-
-    quote! {
-        #item_struct
-        #ownable_impl
-    }
-}
-
-/// Prepends an owner authentication check to a method.
-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_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();
-
-    // 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_ref);));
-    input_fn.into_token_stream()
-}

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

@@ -1,386 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::quote;
-
-use crate::tests::test_helpers::assert_panics_contains;
-
-// ============================================
-// Snapshot Test: ContractImpl Code Generation
-// ============================================
-
-/// Comprehensive snapshot test covering all contract_impl macro features:
-/// - Inherent impl: public methods with Env (adds TTL), private/pub(crate) methods (skipped)
-/// - Trait impl: all methods with Env get TTL extension
-/// - Qualified Env types (soroban_sdk::Env)
-/// - Env parameter not in first position
-/// - Methods without Env (skipped)
-#[test]
-fn snapshot_generated_contract_impl_code() {
-    // Test inherent impl with empty attr
-    let empty_attr = TokenStream::new();
-    let inherent_input = quote! {
-        impl MyContract {
-            /// Public method with Env - should have TTL extension
-            pub fn public_with_env(env: Env, value: u32) -> u32 {
-                value * 2
-            }
-
-            /// Public method with qualified Env path - should have TTL extension
-            pub fn with_qualified_env(env: soroban_sdk::Env) -> u32 {
-                42
-            }
-
-            /// Public method with Env not as first parameter - should have TTL extension
-            pub fn env_second(value: u32, env: &Env) -> u32 {
-                value * 2
-            }
-
-            /// Public method without Env - should NOT have TTL extension
-            pub fn public_without_env(value: u32) -> u32 {
-                value * 4
-            }
-
-            /// Private method with Env - should NOT have TTL extension (not public)
-            fn private_with_env(env: Env, value: u32) -> u32 {
-                value * 5
-            }
-
-            /// Pub(crate) method with Env - should NOT have TTL extension (not fully public)
-            pub(crate) fn pub_crate_with_env(env: Env, value: u32) -> u32 {
-                value * 7
-            }
-
-            /// Constructor method - should NOT have TTL extension
-            pub fn __constructor(env: &Env, value: u32) {
-                let _ = value * 2;
-            }
-        }
-    };
-
-    let inherent_result = crate::contract_impl::contract_impl(empty_attr.clone(), inherent_input);
-    let inherent_formatted =
-        prettyplease::unparse(&syn::parse2::<syn::File>(inherent_result).expect("failed to parse generated code"));
-
-    // Test trait impl with empty attr
-    let trait_input = quote! {
-        impl SomeTrait for MyContract {
-            /// Trait method with Env - should have TTL extension
-            fn trait_method_with_env(env: Env, value: u32) -> u32 {
-                value * 2
-            }
-
-            /// Trait method without Env - should NOT have TTL extension
-            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
-            }
-        }
-    };
-
-    let trait_result = crate::contract_impl::contract_impl(empty_attr, trait_input);
-    let trait_formatted =
-        prettyplease::unparse(&syn::parse2::<syn::File>(trait_result).expect("failed to parse generated code"));
-
-    // Test trait impl with contracttrait attr
-    let contracttrait_attr = quote! { contracttrait };
-    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 {
-                value * 3
-            }
-        }
-    };
-
-    let contracttrait_result = crate::contract_impl::contract_impl(contracttrait_attr, contracttrait_input);
-    let contracttrait_formatted =
-        prettyplease::unparse(&syn::parse2::<syn::File>(contracttrait_result).expect("failed to parse generated code"));
-
-    // Combine all for single snapshot
-    let combined = format!(
-        "// === Inherent Impl (no attr) ===\n\n{}\n\n// === Trait Impl (no attr) ===\n\n{}\n\n// === Trait Impl (contracttrait attr) ===\n\n{}",
-        inherent_formatted, trait_formatted, contracttrait_formatted
-    );
-
-    insta::assert_snapshot!(combined);
-}
-
-// ============================================
-// Error Cases: Invalid Input
-// ============================================
-
-#[test]
-fn test_non_impl_block_input() {
-    let invalid_inputs = vec![
-        (
-            "struct",
-            quote! {
-                struct MyStruct {
-                    field: u32,
-                }
-            },
-        ),
-        (
-            "enum",
-            quote! {
-                enum MyEnum {
-                    Variant1,
-                    Variant2,
-                }
-            },
-        ),
-        ("function", quote! { fn a_function() {} }),
-        ("const item", quote! { const A_CONST: u32 = 1; }),
-        ("type alias", quote! { type AnAlias = u32; }),
-        (
-            "trait",
-            quote! {
-                trait ATrait {
-                    fn method(&self);
-                }
-            },
-        ),
-    ];
-
-    for (case, input) in invalid_inputs {
-        assert_panics_contains(case, "failed to parse impl block", || {
-            crate::contract_impl::contract_impl(TokenStream::new(), input.clone());
-        });
-    }
-}
-
-// ============================================
-// Unit Tests: Behavior Verification
-// ============================================
-
-/// Verifies that the macro adds #[soroban_sdk::contractimpl] attribute without parentheses when attr is empty
-#[test]
-fn test_adds_soroban_contractimpl_attribute_without_attr() {
-    let input = quote! {
-        impl MyContract {
-            pub fn my_method(env: Env) {}
-        }
-    };
-
-    let result = crate::contract_impl::contract_impl(TokenStream::new(), input);
-    let result_str = result.to_string();
-
-    // Should have contractimpl without parentheses when attr is empty
-    assert!(
-        result_str.contains("# [soroban_sdk :: contractimpl]"),
-        "should add #[soroban_sdk::contractimpl] attribute without parentheses when attr is empty. Got: {}",
-        result_str
-    );
-    // Should NOT have empty parentheses
-    assert!(
-        !result_str.contains("contractimpl ()"),
-        "should NOT have empty parentheses when attr is empty. Got: {}",
-        result_str
-    );
-}
-
-/// Verifies that the macro adds #[soroban_sdk::contractimpl(attr)] when attr is provided
-#[test]
-fn test_adds_soroban_contractimpl_attribute_with_attr() {
-    let input = quote! {
-        impl SomeTrait for MyContract {
-            fn my_method(env: Env) {}
-        }
-    };
-
-    let attr = quote! { contracttrait };
-    let result = crate::contract_impl::contract_impl(attr, input);
-    let result_str = result.to_string();
-
-    // Should have contractimpl with the attr in parentheses
-    assert!(
-        result_str.contains("contractimpl (contracttrait)"),
-        "should add #[soroban_sdk::contractimpl(contracttrait)] attribute. Got: {}",
-        result_str
-    );
-}
-
-/// 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 },
-}
-
-struct TtlTestCase {
-    name: &'static str,
-    input: TokenStream,
-    expectation: TtlExpectation,
-}
-
-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 } }
-    }
-
-    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_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();
-}
-
-#[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/snapshots/common_macros__tests__ownable__snapshot_generated_ownable_code.snap

@@ -1,12 +0,0 @@
----
-source: contracts/common-macros/src/tests/ownable.rs
-assertion_line: 17
-expression: formatted
----
-pub struct MyContract;
-use utils::ownable::OwnableInitializer as _;
-use utils::ownable::Ownable;
-impl utils::ownable::OwnableInitializer for MyContract {}
-/// Implement the Ownable trait for the contract with default implementations.
-#[common_macros::contract_impl(contracttrait)]
-impl Ownable for MyContract {}

package/contracts/macro-integration-tests/tests/runtime/ttl_configurable/extend_instance_ttl.rs

@@ -1,50 +0,0 @@
-// Runtime tests: `extend_instance_ttl` behavior.
-//
-// Tests covered:
-// - `extend_instance_ttl` exists on `#[ttl_configurable]` contracts and manually extends instance TTL.
-
-use common_macros::{ownable, ttl_configurable};
-use soroban_sdk::{
-    contract, contractimpl,
-    testutils::{storage::Instance as _, Address as _, Ledger as _},
-    Address, Env,
-};
-
-#[contract]
-#[ttl_configurable]
-#[ownable]
-pub struct TestContract;
-
-#[contractimpl]
-impl TestContract {
-    pub fn init(env: Env, owner: Address) {
-        Self::init_owner(&env, &owner);
-    }
-}
-
-#[test]
-fn extend_instance_ttl_extends() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    // Write something to ensure instance storage exists and has a TTL.
-    let owner = Address::generate(&env);
-    client.init(&owner);
-
-    let (ttl_before, seq_before) =
-        env.as_contract(&contract_id, || (env.storage().instance().get_ttl(), env.ledger().sequence()));
-    let live_until = seq_before + ttl_before;
-
-    // Choose a threshold near the current TTL and extend further.
-    let threshold = ttl_before.saturating_sub(1);
-    let extend_to = ttl_before + 50;
-
-    // Set sequence so remaining TTL == threshold (i.e. at the trigger point).
-    env.ledger().set_sequence_number(live_until - threshold);
-
-    client.extend_instance_ttl(&threshold, &extend_to);
-
-    let ttl_after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
-    assert_eq!(ttl_after, extend_to);
-}

package/contracts/oapps/oapp-macros/src/oapp_core.rs

@@ -1,41 +0,0 @@
-use heck::ToSnakeCase;
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::{Ident, ItemStruct};
-
-/// Generates the `OAppCore` trait implementation and adds `#[contract]` + `#[ownable]` to the struct.
-///
-/// When `manual_impl_core` is false, generates an empty `impl OAppCore`
-/// that uses the trait's default implementations for peer management and endpoint access.
-pub fn generate_impl(name: &Ident, item_struct: ItemStruct, manual_impl_core: bool) -> TokenStream {
-    // Create a unique module name to avoid import conflicts when multiple structs
-    // use oapp macros in the same module. The import must be `OAppCore`
-    // (not an alias) because Soroban SDK's #[contractimpl(contracttrait)] generates
-    // a macro call `OAppCore!(...)` that needs to resolve to the macro
-    // exported by #[contracttrait].
-    let impl_mod = syn::Ident::new(&format!("__oapp_impl_{}", name.to_string().to_snake_case()), name.span());
-
-    let manual_impl = (!manual_impl_core).then(|| {
-        quote! {
-            #[doc(hidden)]
-            mod #impl_mod {
-                use super::*;
-                // Import types used by OAppCore trait's default implementations
-                use soroban_sdk::{Address, BytesN, Env};
-                use oapp::oapp_core::OAppCore;
-
-                #[soroban_sdk::contractimpl(contracttrait)]
-                impl OAppCore for #name {}
-            }
-        }
-    });
-
-    quote! {
-        #[soroban_sdk::contract]
-        #[common_macros::ttl_configurable]
-        #[common_macros::ownable]
-        #item_struct
-
-        #manual_impl
-    }
-}

package/contracts/oapps/oapp-macros/src/oapp_full.rs

@@ -1,21 +0,0 @@
-use crate::{oapp_core, oapp_options_type3, oapp_receiver, oapp_sender, util::ManualImplConfig};
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::{Ident, ItemStruct};
-
-/// Generates the full OApp implementation: Core + Sender + Receiver + OptionsType3.
-///
-/// Combines all OApp components. Use `manual_impl_config` to skip generating
-/// specific trait implementations when custom implementations are needed.
-pub fn generate_impl(name: &Ident, item: ItemStruct, manual_impl_config: ManualImplConfig) -> TokenStream {
-    let core_impl = oapp_core::generate_impl(name, item, manual_impl_config.core);
-    let sender_impl = oapp_sender::generate_impl(name, manual_impl_config.sender);
-    let receiver_impl = oapp_receiver::generate_impl(name, manual_impl_config.receiver);
-    let options_type3_impl = oapp_options_type3::generate_impl(name, manual_impl_config.options_type3);
-    quote! {
-        #core_impl
-        #sender_impl
-        #receiver_impl
-        #options_type3_impl
-    }
-}

package/contracts/oapps/oapp-macros/src/oapp_options_type3.rs

@@ -1,31 +0,0 @@
-use heck::ToSnakeCase;
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::Ident;
-
-/// Generates the `OAppOptionsType3` trait implementation.
-///
-/// When `manual_impl_options_type3` is false, generates an empty `impl OAppOptionsType3`
-/// that uses the trait's default implementations for enforced options management.
-pub fn generate_impl(name: &Ident, manual_impl_options_type3: bool) -> TokenStream {
-    let impl_mod =
-        syn::Ident::new(&format!("__oapp_options_type3_impl_{}", name.to_string().to_snake_case()), name.span());
-
-    let options_type3_impl = (!manual_impl_options_type3).then(|| {
-        quote! {
-            #[doc(hidden)]
-            mod #impl_mod {
-                use super::*;
-                use soroban_sdk::{Env, Bytes, Vec};
-                use oapp::oapp_options_type3::{OAppOptionsType3, EnforcedOptionParam};
-
-                #[soroban_sdk::contractimpl(contracttrait)]
-                impl OAppOptionsType3 for #name {}
-            }
-        }
-    });
-
-    quote! {
-        #options_type3_impl
-    }
-}