@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

package/sdk/turbo.json

@@ -0,0 +1,8 @@
+{
+    "extends": ["//"],
+    "tasks": {
+        "build": {
+            "dependsOn": ["@layerzerolabs/protocol-stellar-v2#build", "^build"]
+        }
+    }
+}

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/Cargo.toml

@@ -11,4 +11,6 @@ path = "src/main.rs"
 [dependencies]
 anyhow = "1.0"
 soroban-spec-typescript = "23.0.3"
+sha2 = "0.10"
+base64 = "0.22"
 

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

@@ -1,4 +1,6 @@
 use anyhow::Result;
+use base64::{engine::general_purpose::STANDARD as BASE64, Engine};
+use sha2::{Digest, Sha256};
 use soroban_spec_typescript::generate_from_file;
 use std::{fs, path::Path};
 
@@ -37,6 +39,44 @@ export type MigrationData = void;
 "#
 }
 
+/// Generate embedded WASM code section
+fn generate_wasm_embed(wasm_bytes: &[u8]) -> String {
+    // Compute SHA-256 hash (this is what Stellar uses for wasmHash)
+    let wasm_hash = Sha256::digest(wasm_bytes);
+    let wasm_hash_hex = format!("{:x}", wasm_hash);
+
+    // Base64 encode the WASM bytes
+    let wasm_base64 = BASE64.encode(wasm_bytes);
+
+    format!(
+        r#"/**
+ * Embedded WASM bytecode (base64-encoded)
+ * Size: {} bytes ({:.2} KB)
+ */
+export const WASM_BASE64 = "{}";
+
+/**
+ * Pre-computed WASM hash (SHA-256)
+ * Use this when the WASM is already uploaded on-chain
+ */
+export const WASM_HASH = "{}";
+
+/**
+ * Get the WASM bytecode as a Buffer
+ * Use this to upload the WASM to the network
+ */
+export function getWasmBuffer(): Buffer {{
+  return Buffer.from(WASM_BASE64, 'base64');
+}}
+
+"#,
+        wasm_bytes.len(),
+        wasm_bytes.len() as f64 / 1024.0,
+        wasm_base64,
+        wasm_hash_hex
+    )
+}
+
 fn main() -> Result<()> {
     println!("🚀 Generating TypeScript bindings for Stellar contracts...\n");
 
@@ -52,6 +92,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"),
@@ -62,7 +103,7 @@ fn main() -> Result<()> {
         ("price_feed", "price_feed.ts"),
         // OApp contracts
         ("counter", "counter.ts"),
-        ("oft_std", "oft_std.ts"),
+        ("oft", "oft.ts"),
         // Add more contracts here as needed:
     ];
 
@@ -88,6 +129,13 @@ fn main() -> Result<()> {
             continue;
         }
 
+        // Read WASM bytes for embedding
+        let wasm_bytes = fs::read(&wasm_path)?;
+        println!("   WASM size: {} bytes ({:.2} KB)", wasm_bytes.len(), wasm_bytes.len() as f64 / 1024.0);
+
+        // Generate the embedded WASM section
+        let wasm_embed = generate_wasm_embed(&wasm_bytes);
+
         // Generate TypeScript bindings
         println!("   Generating bindings...");
         let wasm_path_str =
@@ -131,8 +179,8 @@ fn main() -> Result<()> {
   }"#,
         );
 
-        // Combine imports header with generated code
-        let complete_code = format!("{}{}", generate_imports_header(), ts_code);
+        // Combine imports header + embedded WASM + generated code
+        let complete_code = format!("{}{}{}", generate_imports_header(), wasm_embed, ts_code);
 
         // Write to contract-specific TypeScript file
         fs::write(&output_file, &complete_code)?;
@@ -144,7 +192,7 @@ fn main() -> Result<()> {
     }
 
     println!("\n✅ TypeScript binding generation complete!");
-    println!("   Generated {} contract(s)", generated_contracts.len());
+    println!("   Generated {} contract(s) with embedded WASM", generated_contracts.len());
 
     if generated_contracts.is_empty() {
         println!("\n💡 Tip: Build your contracts first before generating bindings:");

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);
-}