Implemented the native XLM transfer logic

Author: soundsng

contracts/ephemeral_account/Cargo.toml

@@ -9,11 +9,13 @@ crate-type = ["cdylib", "rlib"]
 [dependencies]
 soroban-sdk = "22.0.0"
 bridgelet-shared = { path = "../shared", version = "0.1.0" }
+native-transfer = { path = "../native_transfer" }
 
 
 [dev-dependencies]
 soroban-sdk = { version = "22.0.0", features = ["testutils"] }
 bridgelet-shared = { path = "../shared", features = ["testutils"] }
+native-transfer = { path = "../native_transfer", features = ["testutils"] } 
 
 [profile.release]
 opt-level = "z"

contracts/ephemeral_account/src/lib.rs

@@ -7,6 +7,7 @@ mod storage;
 mod test;
 
 use soroban_sdk::{contract, contractimpl, Address, BytesN, Env, Vec};
+use native_transfer::NativeTransferContractClient as NativeTransferClient;
 
 pub use bridgelet_shared::{AccountInfo, AccountStatus, Payment};
 pub use errors::Error;
@@ -37,6 +38,7 @@ impl EphemeralAccountContract {
         creator: Address,
         expiry_ledger: u32,
         recovery_address: Address,
+        native_transfer_address: Address, 
     ) -> Result<(), Error> {
         // Check if already initialized
         if storage::is_initialized(&env) {
@@ -58,6 +60,7 @@ impl EphemeralAccountContract {
         storage::set_expiry_ledger(&env, expiry_ledger);
         storage::set_recovery_address(&env, &recovery_address);
         storage::set_status(&env, AccountStatus::Active);
+        storage::set_native_transfer_address(&env, &native_transfer_address);
         storage::init_reserve_tracking(&env, BASE_RESERVE_STROOPS);
 
         // Emit event
@@ -416,6 +419,18 @@ impl EphemeralAccountContract {
         Ok(reclaim_amount)
     }
 
+      // Execute actual native XLM transfer to destination
+     if reclaim_amount > 0 {
+        let native_transfer_address = storage::get_native_transfer_address(env)
+            .ok_or(Error::NotInitialized)?;
+        let native_client = NativeTransferClient::new(env, &native_transfer_address);
+        native_client.transfer(
+            &env.current_contract_address(),
+            destination,
+            &reclaim_amount,
+        );
+    }
+
     fn emit_and_store_reserve_event(env: &Env, event: ReserveReclaimed) -> Result<(), Error> {
         events::emit_reserve_reclaimed(
             env,

contracts/ephemeral_account/src/storage.rs

@@ -17,6 +17,7 @@ pub enum DataKey {
     LastSweepId,
     ReserveEventCount,
     LastReserveEvent,
+    NativeTransferAddress,
 }
 
 // Initialization
@@ -204,3 +205,15 @@ pub fn set_last_reserve_event(env: &Env, event: &ReserveReclaimed) {
 pub fn get_last_reserve_event(env: &Env) -> Option<ReserveReclaimed> {
     env.storage().instance().get(&DataKey::LastReserveEvent)
 }
+
+pub fn set_native_transfer_address(env: &Env, address: &Address) {
+    env.storage()
+        .instance()
+        .set(&DataKey::NativeTransferAddress, address);
+}
+
+pub fn get_native_transfer_address(env: &Env) -> Option<Address> {
+    env.storage()
+        .instance()
+        .get(&DataKey::NativeTransferAddress)
+}

contracts/native_transfer/src/errors.rs

@@ -5,4 +5,6 @@ use soroban_sdk::contracterror;
 pub enum Error {
     InvalidAmount = 1,
     TransferFailed = 2,
+    AlreadyInitialized = 3,
+    NotInitialized = 4,
 }

contracts/native_transfer/src/lib.rs

@@ -3,7 +3,7 @@
 mod errors;
 mod events;
 
-use soroban_sdk::{contract, contractimpl, Env};
+use soroban_sdk::{contract, contractimpl, Address, Env};
 
 pub use errors::Error;
 pub use events::NativeTransferExecuted;
@@ -13,5 +13,58 @@ pub struct NativeTransferContract;
 
 #[contractimpl]
 impl NativeTransferContract {
-    // Implementation coming in a future issue
+    /// Initialize with the native asset contract address
+    ///
+    /// # Arguments
+    /// * `native_token_address` - The Stellar native XLM token contract address
+    ///
+    /// # Errors
+    /// * `Error::AlreadyInitialized` - called more than once
+    pub fn initialize(env: Env, native_token_address: Address) -> Result<(), Error> {
+        if env.storage().instance().has(&"native_token") {
+            return Err(Error::AlreadyInitialized);
+        }
+
+        env.storage()
+            .instance()
+            .set(&"native_token", &native_token_address);
+
+        Ok(())
+    }
+
+    /// Execute a native XLM transfer
+    ///
+    /// # Arguments
+    /// * `from` - Address sending XLM
+    /// * `to` - Address receiving XLM
+    /// * `amount` - Amount in stroops (must be positive)
+    ///
+    /// # Errors
+    /// * `Error::NotInitialized` - contract not initialized
+    /// * `Error::InvalidAmount` - amount is zero or negative
+    pub fn transfer(env: Env, from: Address, to: Address, amount: i128) -> Result<(), Error> {
+        // Check initialized
+        let native_token_address: Address = env
+            .storage()
+            .instance()
+            .get(&"native_token")
+            .ok_or(Error::NotInitialized)?;
+
+        // Validate amount
+        if amount <= 0 {
+            return Err(Error::InvalidAmount);
+        }
+
+        // Require authorization from sender
+        from.require_auth();
+
+        // Execute transfer via native token client
+        let native_token = soroban_sdk::token::Client::new(&env, &native_token_address);
+        native_token.transfer(&from, &to, &amount);
+
+        // Emit event
+        events::emit_native_transfer_executed(&env, from, to, amount);
+
+        Ok(())
+    }
 }