Merge pull request #248 from oraimoitel/main

feat: add migrate_escrow for atomic fund migration on upgrade

Author: Kingsman-99

contracts/split/src/lib.rs

@@ -40,6 +40,9 @@ fn admin_key() -> Symbol {
 fn admins_key() -> Symbol {
     symbol_short!("admins")
 }
+fn pending_admin_key() -> Symbol {
+    symbol_short!("pd_adm")
+}
 fn paused_key() -> Symbol {
     symbol_short!("paused")
 }
@@ -539,6 +542,16 @@ fn require_not_paused(env: &Env) {
     assert!(!is_paused(env), "contract is paused");
 }
 
+fn require_admin(env: &Env) -> Address {
+    let admin: Address = env
+        .storage()
+        .instance()
+        .get(&admin_key())
+        .expect("admin not set");
+    admin.require_auth();
+    admin
+}
+
 fn require_role(env: &Env, admin: &Address, min_role: AdminRole) {
     admin.require_auth();
     let admins: Map<Address, AdminRole> = env
@@ -1517,6 +1530,61 @@ impl SplitContract {
         save_invoice(&env, invoice_id, &invoice);
     }
 
+    /// Migrate all escrowed funds to a new contract address atomically.
+    ///
+    /// Iterates all active invoice IDs, sums their funded amounts, verifies
+    /// the total matches the actual token balance held by this contract, and
+    /// transfers everything to `new_contract`. Requires admin auth.
+    /// Panics if the calculated total does not match the actual token balance.
+    pub fn migrate_escrow(env: Env, admin: Address, new_contract: Address) {
+        let admin_addr = require_admin(&env);
+        let _ = admin;
+
+        let counter: u64 = env
+            .storage()
+            .persistent()
+            .get(&counter_key())
+            .unwrap_or(0u64);
+
+        // Group funded amounts by token
+        let mut token_totals: Map<Address, i128> = Map::new(&env);
+        for id in 1u64..=counter {
+            if env.storage().persistent().has(&invoice_key(id))
+                || env.storage().instance().has(&invoice_key(id))
+            {
+                let invoice = load_invoice(&env, id);
+                if invoice.status == InvoiceStatus::Pending && invoice.funded > 0 {
+                    let token = invoice.tokens.get(0).expect("no token");
+                    let prev = token_totals.get(token.clone()).unwrap_or(0);
+                    token_totals.set(token, prev + invoice.funded);
+                }
+            }
+        }
+
+        // Verify and transfer for each token
+        let mut grand_total: i128 = 0;
+        for (token, total) in token_totals.iter() {
+            let token_client = token::Client::new(&env, &token);
+            let actual_balance: i128 =
+                token_client.balance(&env.current_contract_address());
+            assert!(
+                total == actual_balance,
+                "escrow balance mismatch for token"
+            );
+            if total > 0 {
+                token_client.transfer(
+                    &env.current_contract_address(),
+                    &new_contract,
+                    &total,
+                );
+            }
+            grand_total += total;
+        }
+
+        events::escrow_migrated(&env, grand_total, &new_contract);
+        append_audit_entry(&env, 0, symbol_short!("migrate"), &admin_addr);
+    }
+
     // -----------------------------------------------------------------------
     // Invoice creation
     // -----------------------------------------------------------------------

contracts/split/src/test.rs

@@ -5038,3 +5038,63 @@ fn test_all_or_nothing_group_still_requires_all_funded() {
     c.pay(&payer, &id1, &100_i128, &0_u64, &false, &false);
     c.release(&id1); // should panic
 }
+
+// ---------------------------------------------------------------------------
+// Escrow migration
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_migrate_escrow_transfers_balance() {
+    let (env, contract_id, token_id) = setup();
+    let c = client(&env, &contract_id);
+    let tk = token_client(&env, &token_id);
+
+    let admin = Address::generate(&env);
+    let creator = Address::generate(&env);
+    let payer = Address::generate(&env);
+    let recipient = Address::generate(&env);
+    let new_contract = Address::generate(&env);
+
+    StellarAssetClient::new(&env, &token_id).mint(&payer, &500);
+    env.ledger().set_timestamp(1_000);
+
+    // Initialize with admin
+    let treasury = Address::generate(&env);
+    c.initialize(&admin, &0_i128, &treasury, &token_id, &0_u32, &None, &0_u32, &0_u32, &0_u64);
+
+    // Create a pending invoice with partial funds
+    let id = make_invoice(&env, &c, &creator, &recipient, 200, &token_id, 9_999);
+    c.pay(&payer, &id, &100_i128, &0_u64, &false, &false);
+    assert_eq!(c.get_invoice(&id).status, InvoiceStatus::Pending);
+    assert_eq!(c.get_invoice(&id).funded, 100);
+
+    // Check contract token balance before migration
+    let contract_balance_before = tk.balance(&contract_id);
+    assert_eq!(contract_balance_before, 100);
+
+    // Migrate escrow
+    c.migrate_escrow(&admin, &new_contract);
+
+    // Verify new contract received the funds
+    assert_eq!(tk.balance(&new_contract), 100);
+    assert_eq!(tk.balance(&contract_id), 0);
+}
+
+#[test]
+fn test_migrate_escrow_zero_balance() {
+    let (env, contract_id, token_id) = setup();
+    let c = client(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let new_contract = Address::generate(&env);
+
+    // Initialize with admin
+    let treasury = Address::generate(&env);
+    c.initialize(&admin, &0_i128, &treasury, &token_id, &0_u32, &None, &0_u32, &0_u32, &0_u64);
+
+    // No invoices with funds - migration should succeed with zero transfer
+    c.migrate_escrow(&admin, &new_contract);
+
+    let tk = token_client(&env, &token_id);
+    assert_eq!(tk.balance(&new_contract), 0);
+}