Merge branch 'main' into feat/issue-215-214-212-204

Author: Kingsman-99

contracts/split/src/lib.rs

@@ -41,6 +41,22 @@ fn paused_key() -> Symbol {
 fn paused_fns_key() -> Symbol {
     symbol_short!("ps_fns")
 }
+
+fn pause_exempt_key(address: &Address) -> (Symbol, Address) {
+    (symbol_short!("p_exempt"), address.clone())
+}
+
+fn global_payer_limit_key() -> Symbol {
+    symbol_short!("g_vel_lim")
+}
+
+fn global_payer_window_key() -> Symbol {
+    symbol_short!("g_vel_win")
+}
+
+fn global_vel_key(payer: &Address) -> (Symbol, Address) {
+    (symbol_short!("g_vel"), payer.clone())
+}
 fn creation_fee_key() -> Symbol {
     symbol_short!("crt_fee")
 }
@@ -708,6 +724,25 @@ impl SplitContract {
         env.storage().persistent().set(&paused_fns_key(), &new_list);
     }
 
+    /// Set an address as exempt from the global pause for invoice creation.
+    /// Requires admin auth.
+    pub fn set_pause_exempt(env: Env, admin: Address, address: Address, exempt: bool) {
+        require_role(&env, &admin, AdminRole::Operator);
+        if exempt {
+            env.storage().persistent().set(&pause_exempt_key(&address), &true);
+        } else {
+            env.storage().persistent().remove(&pause_exempt_key(&address));
+        }
+    }
+
+    /// Set the global payer aggregate limit and window. Requires admin auth.
+    pub fn set_global_payer_limit(env: Env, admin: Address, limit: i128, window_secs: u64) {
+        require_role(&env, &admin, AdminRole::Operator);
+        assert!(limit >= 0, "limit must be non-negative");
+        env.storage().persistent().set(&global_payer_limit_key(), &limit);
+        env.storage().persistent().set(&global_payer_window_key(), &window_secs);
+    }
+
     /// Update the creation fee. Requires admin auth.
     pub fn set_creation_fee(env: Env, admin: Address, creation_fee: i128) {
         require_role(&env, &admin, AdminRole::Operator);
@@ -1331,7 +1366,12 @@ impl SplitContract {
         deadline: u64,
         options: InvoiceOptions,
     ) -> u64 {
-        require_not_paused(&env);
+        // Check if contract is paused, but allow exempt creators
+        let is_paused = is_paused(&env);
+        let is_exempt = env.storage().persistent().get::<_, bool>(&pause_exempt_key(&creator)).unwrap_or(false);
+        if is_paused && !is_exempt {
+            panic!("contract is paused");
+        }
         creator.require_auth();
         Self::_apply_rate_limit(&env, &creator);
 
@@ -1400,6 +1440,7 @@ impl SplitContract {
             options.refund_grace_secs,
             options.priorities,
             options.require_kyc,
+            options.scheduled_release_at,
         )
     }
 
@@ -1449,6 +1490,7 @@ impl SplitContract {
         refund_grace_secs: Option<u64>,
         priorities: Vec<u32>,
         require_kyc: bool,
+        scheduled_release_at: Option<u64>,
     ) -> u64 {
         assert!(
             recipients.len() == amounts.len(),
@@ -1742,6 +1784,7 @@ impl SplitContract {
             payment_cooldown_secs,
             max_payments_per_window,
             payment_window_secs,
+            scheduled_release_at,
             refund_grace_secs,
             cross_chain_ref,
             require_kyc,
@@ -2176,7 +2219,7 @@ impl SplitContract {
         let mut new_payments: Vec<Payment> = Vec::new(&env);
         for (payer, amount) in payer_amounts.iter() {
             let tip = payer_tips.get(payer.clone()).unwrap_or(0);
-            new_payments.push_back(Payment { payer, amount, tip, donate_on_failure: false });
+            new_payments.push_back(Payment { payer, amount, tip, attestation_hash: None });
         }
 
         // Verify total funded is unchanged (optional assertion, as asked by Acceptance Criteria)
@@ -2259,7 +2302,7 @@ impl SplitContract {
                 .persistent()
                 .get::<(Symbol, u64, u64), Vec<Payment>>(&pay_shard_key(invoice_id, shard_id))
                 .unwrap_or_else(|| Vec::new(&env));
-            shard_payments.push_back(Payment { payer: payer.clone(), amount: net_paid, tip: 0, donate_on_failure: false });
+            shard_payments.push_back(Payment { payer: payer.clone(), amount: net_paid, tip: 0, attestation_hash: None });
             env.storage().persistent().set(&pay_shard_key(invoice_id, shard_id), &shard_payments);
 
             invoice.funded += net_paid;
@@ -2300,10 +2343,22 @@ impl SplitContract {
     pub fn pay(env: Env, payer: Address, invoice_id: u64, amount: i128, nonce: u64, _auto_convert: bool, donate_on_failure: bool) {
         require_fn_not_paused(&env, &symbol_short!("pay"));
         payer.require_auth();
-        Self::_pay(&env, &payer, invoice_id, amount, nonce, _auto_convert, donate_on_failure);
+        Self::_pay(&env, &payer, invoice_id, amount, nonce, _auto_convert, None);
     }
 
-    fn _pay(env: &Env, payer: &Address, invoice_id: u64, amount: i128, nonce: u64, _auto_convert: bool, donate_on_failure: bool) {
+    /// Pay with a signed attestation binding the payment to an off-chain identity
+    pub fn pay_with_attestation(env: Env, payer: Address, invoice_id: u64, amount: i128, nonce: u64, attestation_hash: BytesN<32>, signature: BytesN<64>, signer_pubkey: BytesN<32>, _auto_convert: bool) {
+        require_fn_not_paused(&env, &symbol_short!("pay"));
+        payer.require_auth();
+
+        // Verify ed25519 signature over attestation_hash
+        env.crypto().ed25519_verify(&signer_pubkey, &attestation_hash, &signature);
+
+        // Proceed with payment, storing the attestation hash
+        Self::_pay(&env, &payer, invoice_id, amount, nonce, _auto_convert, Some(attestation_hash));
+    }
+
+    fn _pay(env: &Env, payer: &Address, invoice_id: u64, amount: i128, nonce: u64, _auto_convert: bool, attestation_hash: Option<BytesN<32>>) {
         let mut invoice = load_invoice(env, invoice_id);
 
         assert!(
@@ -2418,6 +2473,26 @@ impl SplitContract {
             env.storage().persistent().set(&vel_key(invoice_id, payer), &window);
         }
 
+        // Global cross-invoice velocity limiting per payer
+        let global_limit: i128 = env.storage().persistent().get(&global_payer_limit_key()).unwrap_or(0i128);
+        if global_limit > 0 {
+            let global_window_secs: u64 = env.storage().persistent().get(&global_payer_window_key()).unwrap_or(0u64);
+            let now = env.ledger().timestamp();
+            let mut global_window: (u64, i128) = env
+                .storage()
+                .persistent()
+                .get(&global_vel_key(payer))
+                .unwrap_or((0u64, 0i128));
+            if now > global_window.0 + global_window_secs {
+                // reset global window
+                global_window.0 = now;
+                global_window.1 = 0;
+            }
+            assert!(global_window.1 + amount <= global_limit, "global payer limit exceeded");
+            global_window.1 += amount;
+            env.storage().persistent().set(&global_vel_key(payer), &global_window);
+        }
+
         let token_client = token::Client::new(env, &invoice.tokens.get(0).expect("no token"));
 
         let credited_amount = match invoice.overflow_behavior {
@@ -2493,7 +2568,7 @@ impl SplitContract {
             .persistent()
             .get::<(Symbol, u64, u64), Vec<Payment>>(&pay_shard_key(invoice_id, shard_id))
             .unwrap_or_else(|| Vec::new(env));
-        shard_payments.push_back(Payment { payer: payer.clone(), amount: credited_amount, tip: 0, donate_on_failure });
+        shard_payments.push_back(Payment { payer: payer.clone(), amount: credited_amount, tip: 0, attestation_hash });
         env.storage().persistent().set(&pay_shard_key(invoice_id, shard_id), &shard_payments);
 
         invoice.funded += credited_amount;
@@ -2652,7 +2727,7 @@ impl SplitContract {
             .persistent()
             .get::<(Symbol, u64, u64), Vec<Payment>>(&pay_shard_key(invoice_id, shard_id))
             .unwrap_or_else(|| Vec::new(&env));
-        shard_payments.push_back(Payment { payer: payer.clone(), amount: credited_amount, tip: 0, donate_on_failure: false });
+        shard_payments.push_back(Payment { payer: payer.clone(), amount: credited_amount, tip: 0, attestation_hash });
         env.storage().persistent().set(&pay_shard_key(invoice_id, shard_id), &shard_payments);
 
         invoice.funded += credited_amount;
@@ -2724,7 +2799,7 @@ impl SplitContract {
             .persistent()
             .get::<(Symbol, u64, u64), Vec<Payment>>(&pay_shard_key(invoice_id, shard_id))
             .unwrap_or_else(|| Vec::new(&env));
-        shard_payments.push_back(Payment { payer: payer.clone(), amount: converted, tip: 0, donate_on_failure: false });
+        shard_payments.push_back(Payment { payer: payer.clone(), amount: converted, tip: 0, attestation_hash: None });
         env.storage().persistent().set(&pay_shard_key(invoice_id, shard_id), &shard_payments);
 
         invoice.funded += converted;
@@ -2811,7 +2886,7 @@ impl SplitContract {
                 .persistent()
                 .get::<(Symbol, u64, u64), Vec<Payment>>(&pay_shard_key(p.invoice_id, shard_id))
                 .unwrap_or_else(|| Vec::new(&env));
-            shard_payments.push_back(Payment { payer: payer.clone(), amount: p.amount, tip: 0, donate_on_failure: false });
+            shard_payments.push_back(Payment { payer: payer.clone(), amount: p.amount, tip: 0, attestation_hash: None });
             env.storage().persistent().set(&pay_shard_key(p.invoice_id, shard_id), &shard_payments);
 
             inv.funded += p.amount;
@@ -2952,6 +3027,48 @@ impl SplitContract {
         Self::_release(&env, invoice_id, &mut invoice, &caller);
     }
 
+    /// Trigger a scheduled release at the configured timestamp, respecting min_funding_bps
+    pub fn trigger_scheduled_release(env: Env, invoice_id: u64) {
+        require_not_paused(&env);
+        let mut invoice = load_invoice(&env, invoice_id);
+
+        assert!(!invoice.frozen, "invoice is frozen");
+        assert!(!invoice.admin_frozen, "invoice frozen by admin");
+        assert!(invoice.status == InvoiceStatus::Pending, "invoice is not pending");
+
+        let scheduled_at = invoice.scheduled_release_at.expect("no scheduled release time");
+        assert!(env.ledger().timestamp() >= scheduled_at, "scheduled release time not reached");
+
+        // Check min funding requirement if set
+        if invoice.min_funding_bps > 0 {
+            let total: i128 = invoice.amounts.iter().sum();
+            let min_required = (total as u128 * invoice.min_funding_bps as u128 / 10_000u128) as i128;
+            assert!(invoice.funded >= min_required, "minimum funding not reached");
+        }
+
+        // Approval check (issue #25)
+        if invoice.approver.is_some() && !invoice.approved {
+            panic!("awaiting approval");
+        }
+
+        // Prerequisite check (issue #22)
+        if let Some(prereq_id) = invoice.prerequisite_id {
+            let prereq = load_invoice(&env, prereq_id);
+            assert!(prereq.status == InvoiceStatus::Released, "prerequisite not released");
+        }
+
+        // Co-signer approval check
+        if !invoice.co_signers.is_empty() {
+            assert!(
+                invoice.signatures.len() >= invoice.required_signatures,
+                "not enough co-signer approvals"
+            );
+        }
+
+        let caller = env.current_contract_address();
+        Self::_release(&env, invoice_id, &mut invoice, &caller);
+    }
+
     fn _release(env: &Env, invoice_id: u64, invoice: &mut Invoice, actor: &Address) {
         if invoice.tranches.is_empty() {
             Self::_release_full(env, invoice_id, invoice, actor);
@@ -3979,7 +4096,7 @@ impl SplitContract {
                     .persistent()
                     .get::<(Symbol, u64, u64), Vec<Payment>>(&pay_shard_key(target_id, shard_id))
                     .unwrap_or_else(|| Vec::new(env));
-                shard_payments.push_back(Payment { payer: env.current_contract_address(), amount: leftover, tip: 0, donate_on_failure: false });
+                shard_payments.push_back(Payment { payer: env.current_contract_address(), amount: leftover, tip: 0, attestation_hash: None });
                 env.storage().persistent().set(&pay_shard_key(target_id, shard_id), &shard_payments);
 
                 target.funded += leftover;

contracts/split/src/types.rs

@@ -84,9 +84,7 @@ pub struct Payment {
     pub payer: Address,
     pub amount: i128,
     pub tip: i128,
-    /// Issue #204: when true, this payer's contribution is donated to the
-    /// creator on failure instead of being refunded.
-    pub donate_on_failure: bool,
+    pub attestation_hash: Option<BytesN<32>>,
 }
 
 #[contracttype]
@@ -232,6 +230,8 @@ pub struct InvoiceOptions {
     pub priorities: Vec<u32>,
     /// Issue #199: grace period in seconds after deadline before refund is allowed.
     pub refund_grace_secs: Option<u64>,
+    /// Scheduled release timestamp (issue #207).
+    pub scheduled_release_at: Option<u64>,
 }
 
 /// Legacy invoice layout used by stored invoices created before the `version`
@@ -335,6 +335,7 @@ pub struct InvoiceExt {
     pub payment_cooldown_secs: Option<u64>,
     pub max_payments_per_window: Option<u32>,
     pub payment_window_secs: Option<u64>,
+    pub scheduled_release_at: Option<u64>,
 }
 
 #[contracttype]
@@ -432,6 +433,8 @@ pub struct Invoice {
     pub payment_cooldown_secs: Option<u64>,
     pub max_payments_per_window: Option<u32>,
     pub payment_window_secs: Option<u64>,
+    /// Scheduled release timestamp (issue #207).
+    pub scheduled_release_at: Option<u64>,
     /// Issue #199: grace period in seconds after deadline before refund is allowed.
     pub refund_grace_secs: Option<u64>,
     pub notification_contract: Option<Address>,
@@ -511,6 +514,7 @@ impl Invoice {
                 payment_cooldown_secs: self.payment_cooldown_secs,
                 max_payments_per_window: self.max_payments_per_window,
                 payment_window_secs: self.payment_window_secs,
+                scheduled_release_at: self.scheduled_release_at,
             },
             InvoiceExt2 {
                 notification_contract: self.notification_contract,
@@ -587,6 +591,7 @@ impl Invoice {
             payment_cooldown_secs: ext.payment_cooldown_secs,
             max_payments_per_window: ext.max_payments_per_window,
             payment_window_secs: ext.payment_window_secs,
+            scheduled_release_at: ext.scheduled_release_at,
             notification_contract: ext2.notification_contract,
             overflow_behavior: ext2.overflow_behavior,
             cross_chain_ref: ext2.cross_chain_ref,
@@ -795,6 +800,7 @@ impl Invoice {
             payment_cooldown_secs: None,
             max_payments_per_window: None,
             payment_window_secs: None,
+            scheduled_release_at: None,
             refund_grace_secs: None,
             forward_to: None,
             forward_invoice_id: None,