perf(grant): O(1) claim_milestone recipient lookup + increase get_winners cap

Author: Shadow-MMN

contracts/events/src/event_ops.rs

@@ -155,6 +155,7 @@ pub fn create_event(env: &Env, params: CreateEventParams, op_id: BytesN<32>) ->
                 reputation_bump: None,
             },
         );
+        storage::set_grant_recipient_idx(env, id, &params.owner, 0);
     }
 
     evt::EventCreated {
@@ -670,7 +671,8 @@ pub fn select_winners(
             }
         }
         ReleaseKind::Multi(_) => {
-            for spec in winners.iter() {
+            for (i, spec) in winners.iter().enumerate() {
+                let anchor_idx = existing_count + (i as u32);
                 storage::append_winner(
                     env,
                     event_id,
@@ -683,6 +685,7 @@ pub fn select_winners(
                         reputation_bump: Some(spec.reputation_bump),
                     },
                 );
+                storage::set_grant_recipient_idx(env, event_id, &spec.recipient, anchor_idx);
             }
         }
     }
@@ -849,7 +852,7 @@ pub fn get_winners(env: &Env, event_id: u64) -> Result<Vec<Winner>, Error> {
     Ok(storage::winners_snapshot(
         env,
         event_id,
-        MAX_WINNERS_PER_SELECT,
+        MAX_WINNERS_PER_SELECT.saturating_mul(20),
     ))
 }
 

contracts/events/src/grant.rs

@@ -54,33 +54,24 @@ pub fn claim_milestone(
         return Err(Error::MilestoneAlreadyClaimed);
     }
 
-    let count = storage::winner_count(env, event_id);
-    let mut winner_position: Option<u32> = None;
-    let mut reputation_bump: u32 = 0;
-    let mut already_claimed_for_recipient: u32 = 0;
-    let mut already_paid_to_recipient: i128 = 0;
-    for idx in 0..count {
-        let w = match storage::winner_at(env, event_id, idx) {
-            Some(w) => w,
-            None => continue,
-        };
-        if w.recipient != recipient {
-            continue;
-        }
-        match w.milestone {
-            None => {
-                winner_position = Some(w.position);
-                reputation_bump = w.reputation_bump.unwrap_or(0);
-            }
-            Some(_) => {
-                already_claimed_for_recipient = already_claimed_for_recipient.saturating_add(1);
-                already_paid_to_recipient = already_paid_to_recipient.saturating_add(w.amount);
-            }
-        }
-    }
-    let position = winner_position.ok_or(Error::NoSubmissions)?;
-
     let is_crowdfunding = matches!(event.pillar, Pillar::Crowdfunding);
+
+    let anchor_idx =
+        storage::get_grant_recipient_idx(env, event_id, &recipient).ok_or(Error::NoSubmissions)?;
+    let anchor = storage::winner_at(env, event_id, anchor_idx).ok_or(Error::NoSubmissions)?;
+    let position = anchor.position;
+    let reputation_bump = anchor.reputation_bump.unwrap_or(0);
+    let already_claimed_for_recipient =
+        storage::get_grant_recipient_claim_count(env, event_id, &recipient);
+    let already_paid_to_recipient = if is_crowdfunding {
+        0
+    } else {
+        let percent = event.winner_distribution.get(position).unwrap_or(0) as i128;
+        let total_share = event.total_budget.saturating_mul(percent) / 100_i128;
+        let per_milestone_floored = total_share / (total_milestones as i128);
+        (already_claimed_for_recipient as i128).saturating_mul(per_milestone_floored)
+    };
+
     let amount: i128 = if is_crowdfunding {
         let claimed_count = storage::get_crowdfunding_milestones_claimed(env, event_id);
         let remaining_milestones = total_milestones.saturating_sub(claimed_count);
@@ -124,6 +115,7 @@ pub fn claim_milestone(
     }
     event.remaining_escrow = event.remaining_escrow.saturating_sub(amount);
     storage::mark_milestone_claimed(env, event_id, &recipient, milestone);
+    storage::increment_grant_recipient_claim_count(env, event_id, &recipient);
     if is_crowdfunding {
         let claimed = storage::get_crowdfunding_milestones_claimed(env, event_id);
         storage::set_crowdfunding_milestones_claimed(env, event_id, claimed.saturating_add(1));

contracts/events/src/storage.rs

@@ -466,6 +466,39 @@ pub fn get_winner_index(env: &Env, id: u64, recipient: &Address, position: u32)
     idx
 }
 
+pub fn get_grant_recipient_idx(env: &Env, id: u64, recipient: &Address) -> Option<u32> {
+    let key = DataKey::GrantRecipientIdx(id, recipient.clone());
+    let idx: Option<u32> = env.storage().persistent().get(&key);
+    if idx.is_some() {
+        touch_event_persistent(env, &key);
+    }
+    idx
+}
+
+pub fn set_grant_recipient_idx(env: &Env, id: u64, recipient: &Address, idx: u32) {
+    let key = DataKey::GrantRecipientIdx(id, recipient.clone());
+    env.storage().persistent().set(&key, &idx);
+    touch_event_persistent(env, &key);
+}
+
+pub fn get_grant_recipient_claim_count(env: &Env, id: u64, recipient: &Address) -> u32 {
+    let key = DataKey::GrantRecipientClaimCount(id, recipient.clone());
+    let count: Option<u32> = env.storage().persistent().get(&key);
+    if count.is_some() {
+        touch_event_persistent(env, &key);
+    }
+    count.unwrap_or(0)
+}
+
+pub fn increment_grant_recipient_claim_count(env: &Env, id: u64, recipient: &Address) {
+    let key = DataKey::GrantRecipientClaimCount(id, recipient.clone());
+    let count: u32 = env.storage().persistent().get(&key).unwrap_or(0);
+    env.storage()
+        .persistent()
+        .set(&key, &count.saturating_add(1));
+    touch_event_persistent(env, &key);
+}
+
 pub fn winners_snapshot(env: &Env, id: u64, max: u32) -> Vec<Winner> {
     let count = winner_count(env, id);
     let upper = if count < max { count } else { max };

contracts/events/src/types.rs

@@ -202,6 +202,12 @@ pub enum DataKey {
 
     // Winner anchor index for O(1) claim_prize lookup (added 2026-07).
     WinnerIndex(u64, Address, u32),
+
+    // Grant anchor index for O(1) claim_milestone recipient lookup.
+    GrantRecipientIdx(u64, Address),
+
+    // Per-recipient milestone claim counter for claim_milestone.
+    GrantRecipientClaimCount(u64, Address),
 }
 
 // ============================================================