hotfix for user claim

Author: wphan

api/src/main.rs

@@ -170,10 +170,23 @@ async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
                     max_total_claim: single_tree.max_total_claim,
                 });
                 for node in single_tree.tree_nodes.iter() {
-                    tree_clone
+                    let tree_has = tree_clone
                         .lock()
                         .await
-                        .insert(node.claimant, (distributor_pubkey, node.clone()));
+                        .contains_key(&node.claimant);
+                    if tree_has && node.claimant == Pubkey::from_str("FJWKx31QCW7yCwsVBihqx9QH5FzexbkpHgaaGrj8cbi5").unwrap() {
+                        let placeholder = Pubkey::from_str("BUZn6J1R6FEKNMptvKVmYiyn4U4cvxBRswBfeKBMKMm1").unwrap();
+                        println!("user was in tree already, insert the second claim in tree {}, amt: {}, ph: {}", single_tree.airdrop_version, node.amount, placeholder);
+                        tree_clone
+                            .lock()
+                            .await
+                            .insert(placeholder, (distributor_pubkey, node.clone()));
+                    } else {
+                        tree_clone
+                            .lock()
+                            .await
+                            .insert(node.claimant, (distributor_pubkey, node.clone()));
+                    }
                 }
                 let duration_single_tree = start_single_tree.elapsed();
                 println!(

api/src/router.rs

@@ -288,6 +288,7 @@ async fn get_eligibility(
 ) -> Result<impl IntoResponse> {
     let merkle_tree = &state.tree;
     let proof = get_user_proof(merkle_tree, user_pubkey.clone())?;
+
     let distributor = state.cache.get_distributor(&proof.merkle_tree);
     let curr_ts = SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -361,22 +362,119 @@ async fn get_eligibility(
             err
         })?;
 
-    Ok(Json(EligibilityResp {
-        claimant: user_pubkey.clone(),
-        merkle_tree: proof.merkle_tree,
-        start_ts,
-        end_ts,
-        mint,
-        proof: proof.proof,
-        start_amount,
-        end_amount: proof.amount as u128,
-        locked_amount: proof.locked_amount as u128,
-        claimable_amount: claimable_amount as u128,
-        unvested_amount: state.cache.get_unvested_amount(user_pubkey),
-        claimed_amount: (unlocked_amount_claimed + locked_amount_withdrawn) as u128,
-        unlocked_amount_claimed: unlocked_amount_claimed as u128,
-        locked_amount_withdrawn: locked_amount_withdrawn as u128,
-    }))
+    let now = SystemTime::now().duration_since(UNIX_EPOCH).expect("epoch time").as_secs() as i64;
+    if user_pubkey.as_str() == "FJWKx31QCW7yCwsVBihqx9QH5FzexbkpHgaaGrj8cbi5" && now % 10 == 0 /*unlocked_amount_claimed == proof.amount*/ {
+        let proof = get_user_proof(merkle_tree, "BUZn6J1R6FEKNMptvKVmYiyn4U4cvxBRswBfeKBMKMm1".to_string())?;
+
+        println!("user FJWKx31QCW7yCwsVBihqx9QH5FzexbkpHgaaGrj8cbi5 had full claim, loading second proof: {:?}", proof.amount);
+
+        let distributor = state.cache.get_distributor(&proof.merkle_tree);
+        let curr_ts = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("epoch time")
+            .as_secs() as i64;
+
+        let (start_ts, end_ts, mint) = match distributor {
+            Some(distributor) => (
+                distributor.start_ts,
+                distributor.end_ts,
+                distributor.mint.to_string(),
+            ),
+            None => (
+                state.cache.default_start_ts,
+                state.cache.default_end_ts,
+                state.cache.default_mint.clone(),
+            ),
+        };
+        let (unlocked_amount_claimed, locked_amount_withdrawn, claimable_amount) = state
+            .cache
+            .get_claim_status(&user_pubkey)
+            .map(|r| {
+                (
+                    r.data.unlocked_amount_claimed,
+                    r.data.locked_amount_withdrawn,
+                    r.data
+                        .amount_withdrawable(curr_ts, start_ts, end_ts)
+                        .unwrap_or(0),
+                )
+            })
+            .unwrap_or_else(|| {
+                // No ClaimStatus exists - calculate what would be claimable
+                // For unlocked amounts (proof.amount), use vesting with 50% start
+                let unlocked_claimable = calculate_claimable_amount_for_new_user(
+                    proof.amount as u64,
+                    curr_ts,
+                    start_ts,
+                    end_ts,
+                    state.start_amount_pct,
+                );
+
+                // For locked amounts, calculate linear vesting (no 50% start)
+                let locked_claimable = calculate_locked_amount_claimable(
+                    proof.locked_amount as u64,
+                    curr_ts,
+                    start_ts,
+                    end_ts,
+                );
+
+                (0, 0, unlocked_claimable + locked_claimable)
+            });
+
+        let start_amount_pct_num = state.start_amount_pct * START_AMOUNT_PCT_PRECISION;
+        let start_amount = (proof.amount as u128)
+            .checked_mul(start_amount_pct_num)
+            .ok_or_else(|| {
+                let err = ApiError::MathError();
+                error!(
+                    "Math error occurred (1), amount: {}, START_AMOUNT_PCT_NUM: {}, START_AMOUNT_PCT_DENOM: {}",
+                    proof.amount, start_amount_pct_num, START_AMOUNT_PCT_DENOM
+                );
+                err
+            })?
+            .checked_div(START_AMOUNT_PCT_DENOM)
+            .ok_or_else(|| {
+                let err = ApiError::MathError();
+                error!(
+                    "Math error occurred (2), amount: {}, START_AMOUNT_PCT_NUM: {}, START_AMOUNT_PCT_DENOM: {}",
+                    proof.amount, start_amount_pct_num, START_AMOUNT_PCT_DENOM
+                );
+                err
+            })?;
+        Ok(Json(EligibilityResp {
+            claimant: user_pubkey.clone(),
+            merkle_tree: proof.merkle_tree,
+            start_ts,
+            end_ts,
+            mint,
+            proof: proof.proof,
+            start_amount,
+            end_amount: proof.amount as u128,
+            locked_amount: proof.locked_amount as u128,
+            claimable_amount: claimable_amount as u128,
+            unvested_amount: state.cache.get_unvested_amount(user_pubkey),
+            claimed_amount: (unlocked_amount_claimed + locked_amount_withdrawn) as u128,
+            unlocked_amount_claimed: unlocked_amount_claimed as u128,
+            locked_amount_withdrawn: locked_amount_withdrawn as u128,
+        }))
+    } else {
+        Ok(Json(EligibilityResp {
+            claimant: user_pubkey.clone(),
+            merkle_tree: proof.merkle_tree,
+            start_ts,
+            end_ts,
+            mint,
+            proof: proof.proof,
+            start_amount,
+            end_amount: proof.amount as u128,
+            locked_amount: proof.locked_amount as u128,
+            claimable_amount: claimable_amount as u128,
+            unvested_amount: state.cache.get_unvested_amount(user_pubkey),
+            claimed_amount: (unlocked_amount_claimed + locked_amount_withdrawn) as u128,
+            unlocked_amount_claimed: unlocked_amount_claimed as u128,
+            locked_amount_withdrawn: locked_amount_withdrawn as u128,
+        }))
+    }
+
 }
 
 #[derive(Serialize, Deserialize, Clone)]