@layerzerolabs/protocol-stellar-v2 0.2.13 → 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

@@ -31,6 +31,8 @@ export * from '@stellar/stellar-sdk'
 export * as contract from '@stellar/stellar-sdk/contract'
 export * as rpc from '@stellar/stellar-sdk/rpc'
 
+export type MigrationData = void;
+
 
 "#
 }
@@ -45,13 +47,22 @@ fn main() -> Result<()> {
     // Configuration for each contract
     // Format: (wasm_filename, ts_filename)
     let contracts = vec![
+        // Protocol contracts
         ("endpoint_v2", "endpoint.ts"),
         ("simple_message_lib", "sml.ts"),
         ("blocked_message_lib", "bml.ts"),
         ("uln302", "uln302.ts"),
-        ("counter", "counter.ts"),
+        ("treasury", "treasury.ts"),
+        ("upgrader", "upgrader.ts"),
+        // Worker contracts
+        ("dvn", "dvn.ts"),
+        ("dvn_fee_lib", "dvn_fee_lib.ts"),
         ("executor", "executor.ts"),
+        ("executor_fee_lib", "executor_fee_lib.ts"),
         ("executor_helper", "executor_helper.ts"),
+        ("price_feed", "price_feed.ts"),
+        // OApp contracts
+        ("counter", "counter.ts"),
         ("oft_std", "oft_std.ts"),
         // Add more contracts here as needed:
     ];

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,47 +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 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::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,59 +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::Ownable as _;
-        use utils::ownable::OwnableInitializer as _;
-
-        /// Implement the OwnableInitializer trait for the contract.
-        impl utils::ownable::OwnableInitializer for #name {
-            fn init_owner(env: &soroban_sdk::Env, owner: &soroban_sdk::Address) {
-                <utils::ownable::DefaultOwnable as utils::ownable::OwnableInitializer>::init_owner(env, owner)
-            }
-        }
-
-        /// Implement the Ownable trait for the contract.
-        #[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)
-            }
-        }
-    };
-
-    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,381 +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
-            }
-        }
-    };
-
-    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,32 +0,0 @@
----
-source: contracts/common-macros/src/tests/ownable.rs
-assertion_line: 17
-expression: formatted
----
-pub struct MyContract;
-use utils::ownable::Ownable as _;
-use utils::ownable::OwnableInitializer as _;
-/// Implement the OwnableInitializer trait for the contract.
-impl utils::ownable::OwnableInitializer for MyContract {
-    fn init_owner(env: &soroban_sdk::Env, owner: &soroban_sdk::Address) {
-        <utils::ownable::DefaultOwnable as utils::ownable::OwnableInitializer>::init_owner(
-            env,
-            owner,
-        )
-    }
-}
-/// Implement the Ownable trait for the contract.
-#[common_macros::contract_impl]
-impl utils::ownable::Ownable for MyContract {
-    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)
-    }
-}