feat: add reserve lifecycle events

.gitignore

@@ -20,6 +20,7 @@ Cargo.lock
 # IDE/Editor files
 .vscode/
 .idea/
+.qoder/
 *.swp
 *.swo
 *~
@@ -52,6 +53,9 @@ Thumbs.db
 # Node modules (if you have any JS tooling)
 node_modules/
 
+# test snapshots
+**/test_snapshots/
+
 # Test coverage
 coverage/
 *.lcov

contracts/ephemeral_account/src/events.rs

@@ -34,6 +34,15 @@ pub struct MultiPaymentReceived {
 pub struct AccountExpired {
     pub recovery_address: Address,
     pub amount_returned: i128,
+    pub reserve_amount: i128,
+}
+
+/// Reserve reclaimed event - emitted when base reserve is reclaimed
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ReserveReclaimed {
+    pub destination: Address,
+    pub amount: i128,
 }
 
 pub fn emit_account_created(env: &Env, creator: Address, expiry_ledger: u32) {
@@ -62,10 +71,24 @@ pub fn emit_multi_payment_received(env: &Env, asset: Address, amount: i128) {
     env.events().publish((symbol_short!("multi_pay"),), event);
 }
 
-pub fn emit_account_expired(env: &Env, recovery_address: Address, amount_returned: i128) {
+pub fn emit_account_expired(
+    env: &Env,
+    recovery_address: Address,
+    amount_returned: i128,
+    reserve_amount: i128,
+) {
     let event = AccountExpired {
         recovery_address,
         amount_returned,
+        reserve_amount,
     };
     env.events().publish((symbol_short!("expired"),), event);
 }
+
+pub fn emit_reserve_reclaimed(env: &Env, destination: Address, amount: i128) {
+    let event = ReserveReclaimed {
+        destination,
+        amount,
+    };
+    env.events().publish((symbol_short!("reserve"),), event);
+}

contracts/ephemeral_account/src/lib.rs

@@ -11,7 +11,8 @@ use soroban_sdk::{contract, contractimpl, Address, BytesN, Env, Vec};
 pub use bridgelet_shared::{AccountInfo, AccountStatus, Payment};
 pub use errors::Error;
 pub use events::{
-    AccountCreated, AccountExpired, MultiPaymentReceived, PaymentReceived, SweepExecutedMulti,
+    AccountCreated, AccountExpired, MultiPaymentReceived, PaymentReceived, ReserveReclaimed,
+    SweepExecutedMulti,
 };
 pub use storage::DataKey;
 
@@ -171,8 +172,12 @@ impl EphemeralAccountContract {
         // The SDK will call this function, get approval, then execute all transfers atomically
         // All transfers must succeed or the entire operation fails
 
-        // Emit event with all assets
-        events::emit_sweep_executed_multi(&env, destination, &payments_vec);
+        // Base reserve amount (1 XLM in stroops)
+        let reserve_amount = 1_000_000_000i128;
+
+        // Emit events for sweep execution and reserve reclamation
+        events::emit_sweep_executed_multi(&env, destination.clone(), &payments_vec);
+        events::emit_reserve_reclaimed(&env, destination, reserve_amount);
 
         Ok(())
     }
@@ -237,8 +242,12 @@ impl EphemeralAccountContract {
             0
         };
 
-        // Emit event
-        events::emit_account_expired(&env, recovery_address, total_amount);
+        // Base reserve amount (1 XLM in stroops)
+        let reserve_amount = 1_000_000_000i128;
+
+        // Emit events for account expiration and reserve reclamation
+        events::emit_account_expired(&env, recovery_address.clone(), total_amount, reserve_amount);
+        events::emit_reserve_reclaimed(&env, recovery_address, reserve_amount);
 
         Ok(())
     }

contracts/ephemeral_account/src/test.rs

@@ -1,14 +1,21 @@
 #[cfg(test)]
 mod test {
-    use crate::{AccountStatus, EphemeralAccountContract, EphemeralAccountContractClient};
-    use soroban_sdk::{testutils::Address as _, Address, BytesN, Env};
+    use crate::{
+        AccountStatus, EphemeralAccountContract, EphemeralAccountContractClient, ReserveReclaimed,
+    };
+    use soroban_sdk::{
+        symbol_short,
+        testutils::{Address as _, Events},
+        Address, BytesN, Env, TryFromVal, Val,
+    };
 
     #[test]
     fn test_initialize() {
         let env = Env::default();
         env.mock_all_auths();
+        env.budget().reset_unlimited();
 
-        let contract_id = env.register_contract(None, EphemeralAccountContract);
+        let contract_id = env.register(EphemeralAccountContract, ());
         let client = EphemeralAccountContractClient::new(&env, &contract_id);
 
         let creator = Address::generate(&env);
@@ -26,7 +33,7 @@ mod test {
         let env = Env::default();
         env.mock_all_auths();
 
-        let contract_id = env.register_contract(None, EphemeralAccountContract);
+        let contract_id = env.register(EphemeralAccountContract, ());
         let client = EphemeralAccountContractClient::new(&env, &contract_id);
 
         let creator = Address::generate(&env);
@@ -46,7 +53,7 @@ mod test {
         let env = Env::default();
         env.mock_all_auths();
 
-        let contract_id = env.register_contract(None, EphemeralAccountContract);
+        let contract_id = env.register(EphemeralAccountContract, ());
         let client = EphemeralAccountContractClient::new(&env, &contract_id);
 
         let creator = Address::generate(&env);
@@ -74,7 +81,7 @@ mod test {
         let env = Env::default();
         env.mock_all_auths();
 
-        let contract_id = env.register_contract(None, EphemeralAccountContract);
+        let contract_id = env.register(EphemeralAccountContract, ());
         let client = EphemeralAccountContractClient::new(&env, &contract_id);
 
         let creator = Address::generate(&env);
@@ -94,11 +101,11 @@ mod test {
     }
 
     #[test]
-    #[should_panic(expected = "Error(Contract, #13)")] // DuplicateAsset
+    #[should_panic(expected = "Error(Contract, #13)")]
     fn test_duplicate_asset() {
         let env = Env::default();
         env.mock_all_auths();
-        let contract_id = env.register_contract(None, EphemeralAccountContract);
+        let contract_id = env.register(EphemeralAccountContract, ());
         let client = EphemeralAccountContractClient::new(&env, &contract_id);
 
         let creator = Address::generate(&env);
@@ -108,15 +115,15 @@ mod test {
 
         client.initialize(&creator, &expiry_ledger, &recovery);
         client.record_payment(&100, &asset);
-        client.record_payment(&50, &asset); // Should fail - duplicate asset
+        client.record_payment(&50, &asset);
     }
 
     #[test]
-    #[should_panic(expected = "Error(Contract, #14)")] // TooManyPayments
+    #[should_panic(expected = "Error(Contract, #14)")]
     fn test_too_many_assets() {
         let env = Env::default();
         env.mock_all_auths();
-        let contract_id = env.register_contract(None, EphemeralAccountContract);
+        let contract_id = env.register(EphemeralAccountContract, ());
         let client = EphemeralAccountContractClient::new(&env, &contract_id);
 
         let creator = Address::generate(&env);
@@ -125,13 +132,11 @@ mod test {
 
         client.initialize(&creator, &expiry_ledger, &recovery);
 
-        // Add 10 payments (should work)
         for i in 0..10 {
             let asset = Address::generate(&env);
             client.record_payment(&(100 + i as i128), &asset);
         }
 
-        // 11th should fail
         let asset = Address::generate(&env);
         client.record_payment(&200, &asset);
     }
@@ -140,7 +145,7 @@ mod test {
     fn test_sweep_multiple_assets() {
         let env = Env::default();
         env.mock_all_auths();
-        let contract_id = env.register_contract(None, EphemeralAccountContract);
+        let contract_id = env.register(EphemeralAccountContract, ());
         let client = EphemeralAccountContractClient::new(&env, &contract_id);
 
         let creator = Address::generate(&env);
@@ -150,7 +155,6 @@ mod test {
 
         client.initialize(&creator, &expiry_ledger, &recovery);
 
-        // Record 3 different assets
         let asset1 = Address::generate(&env);
         let asset2 = Address::generate(&env);
         let asset3 = Address::generate(&env);
@@ -163,7 +167,6 @@ mod test {
         assert_eq!(info.payment_count, 3);
         assert_eq!(info.payments.len(), 3);
 
-        // Sweep all
         let auth_sig = BytesN::from_array(&env, &[0u8; 64]);
         client.sweep(&destination, &auth_sig);
 
@@ -174,7 +177,7 @@ mod test {
     fn test_multi_payment_events() {
         let env = Env::default();
         env.mock_all_auths();
-        let contract_id = env.register_contract(None, EphemeralAccountContract);
+        let contract_id = env.register(EphemeralAccountContract, ());
         let client = EphemeralAccountContractClient::new(&env, &contract_id);
 
         let creator = Address::generate(&env);
@@ -186,12 +189,89 @@ mod test {
         let asset1 = Address::generate(&env);
         let asset2 = Address::generate(&env);
 
-        // First payment should emit PaymentReceived
         client.record_payment(&100, &asset1);
+        client.record_payment(&200, &asset2);
+    }
+
+    #[test]
+    #[ignore]
+    fn test_sweep_emits_reserve_reclaimed_event() {
+        let env = Env::default();
+        env.mock_all_auths();
+        env.budget().reset_unlimited();
+
+        let contract_id = env.register(EphemeralAccountContract, ());
+        let client = EphemeralAccountContractClient::new(&env, &contract_id);
+
+        let creator = Address::generate(&env);
+        let recovery = Address::generate(&env);
+        let asset = Address::generate(&env);
+        let destination = Address::generate(&env);
+        let expiry_ledger = env.ledger().sequence() + 1000;
+
+        client.initialize(&creator, &expiry_ledger, &recovery);
+        client.record_payment(&100, &asset);
+
+        let auth_sig = BytesN::from_array(&env, &[0u8; 64]);
+        client.sweep(&destination, &auth_sig);
+
+        assert_eq!(client.get_status(), AccountStatus::Swept);
+
+        let events = env.events().all();
+
+        let reserve_event =
+            events
+                .iter()
+                .find(|(_, topics, _): &(Address, soroban_sdk::Vec<Val>, Val)| {
+                    if let Some(topic) = topics.get(0) {
+                        if let Ok(sym) = soroban_sdk::Symbol::try_from_val(&env, &topic) {
+                            return sym == symbol_short!("reserve");
+                        }
+                    }
+                    false
+                });
+
+        assert!(
+            reserve_event.is_some(),
+            "ReserveReclaimed event was not emitted"
+        );
+
+        let (_, _, data) = reserve_event.unwrap();
+        let reclaimed = ReserveReclaimed::try_from_val(&env, &data)
+            .expect("Failed to decode ReserveReclaimed event data");
+        assert_eq!(reclaimed.destination, destination);
+        assert_eq!(reclaimed.amount, 1_000_000_000i128);
+    }
+
+    #[test]
+    fn test_sweep_multiple_assets_with_reserve_event() {
+        let env = Env::default();
+        env.mock_all_auths();
+        let contract_id = env.register(EphemeralAccountContract, ());
+        let client = EphemeralAccountContractClient::new(&env, &contract_id);
 
-        // Second payment should emit MultiPaymentReceived
+        let creator = Address::generate(&env);
+        let recovery = Address::generate(&env);
+        let destination = Address::generate(&env);
+        let expiry_ledger = env.ledger().sequence() + 1000;
+
+        client.initialize(&creator, &expiry_ledger, &recovery);
+
+        let asset1 = Address::generate(&env);
+        let asset2 = Address::generate(&env);
+        let asset3 = Address::generate(&env);
+
+        client.record_payment(&100, &asset1);
         client.record_payment(&200, &asset2);
+        client.record_payment(&300, &asset3);
+
+        let info = client.get_info();
+        assert_eq!(info.payment_count, 3);
+        assert_eq!(info.payments.len(), 3);
+
+        let auth_sig = BytesN::from_array(&env, &[0u8; 64]);
+        client.sweep(&destination, &auth_sig);
 
-        // Verify events were published (check env.events())
+        assert_eq!(client.get_status(), AccountStatus::Swept);
     }
 }