migration: core: Reward Engine & Treasury Vault

PiRC-204/contracts/reward_engine_enhanced.rs

@@ -0,0 +1,9 @@
+pub struct RewardEngineEnhanced;
+
+impl RewardEngineEnhanced {
+    pub fn allocate_rewards(total_vault: u64, active_ratio: f64) -> u64 {
+        let base = total_vault.saturating_mul(314) / 10_000;
+        let boosted = (base as f64 * (1.0 + active_ratio.clamp(0.0, 1.0))) as u64;
+        boosted
+    }
+}

bootstrap.rs

@@ -0,0 +1,14 @@
+#![no_std]
+use soroban_sdk::{contractimpl, Env};
+
+pub struct Bootstrapper;
+
+#[contractimpl]
+impl Bootstrapper {
+    pub fn run(env: Env) {
+        let liquidity_amount = env.invoke_contract::<u128>(&Symbol::short("LiquidityController"), &Symbol::short("execute_liquidity"), &());
+        env.invoke_contract::<u128>(&Symbol::short("FreeFaultDex"), &Symbol::short("add_liquidity"), &(liquidity_amount, liquidity_amount));
+        // distribute rewards proportional
+        env.invoke_contract::<()>("RewardEngine", &Symbol::short("distribute"), &(env.invoker(), liquidity_amount / 10));
+    }
+}

contracts/reward/advanced_reward_engine.rs

@@ -0,0 +1,90 @@
+use std::collections::HashMap;
+
+pub struct RewardEngine {
+
+    pub treasury_balance: u128,
+    pub reward_multiplier: f64,
+
+    pub activity_scores: HashMap<String, u128>,
+    pub liquidity_scores: HashMap<String, u128>,
+    pub reward_balances: HashMap<String, u128>,
+
+}
+
+impl RewardEngine {
+
+    pub fn new(initial_treasury: u128) -> Self {
+
+        Self {
+            treasury_balance: initial_treasury,
+            reward_multiplier: 1.0,
+            activity_scores: HashMap::new(),
+            liquidity_scores: HashMap::new(),
+            reward_balances: HashMap::new(),
+        }
+
+    }
+
+    pub fn record_activity(&mut self, user: String, score: u128) {
+
+        let entry = self.activity_scores.entry(user).or_insert(0);
+        *entry += score;
+
+    }
+
+    pub fn record_liquidity(&mut self, user: String, amount: u128) {
+
+        let entry = self.liquidity_scores.entry(user).or_insert(0);
+        *entry += amount;
+
+    }
+
+    fn anti_sybil_filter(activity: u128) -> u128 {
+
+        if activity < 10 {
+            0
+        } else {
+            activity
+        }
+
+    }
+
+    pub fn calculate_reward(&self, user: &String) -> u128 {
+
+        let activity = self.activity_scores.get(user).unwrap_or(&0);
+        let liquidity = self.liquidity_scores.get(user).unwrap_or(&0);
+
+        let filtered_activity = Self::anti_sybil_filter(*activity);
+
+        let base_reward =
+            filtered_activity * 10 +
+            liquidity * 5;
+
+        (base_reward as f64 * self.reward_multiplier) as u128
+
+    }
+
+    pub fn distribute_reward(&mut self, user: String) {
+
+        let reward = self.calculate_reward(&user);
+
+        if self.treasury_balance >= reward {
+
+            self.treasury_balance -= reward;
+
+            let entry = self.reward_balances.entry(user).or_insert(0);
+            *entry += reward;
+
+        }
+
+    }
+
+    pub fn set_multiplier(&mut self, value: f64) {
+
+        if value >= 0.5 && value <= 3.0 {
+            self.reward_multiplier = value;
+        }
+
+    }
+
+}

contracts/reward/reward_engine.rs

@@ -0,0 +1,12 @@
+pub struct RewardEngine;
+
+impl RewardEngine {
+
+    pub fn calculate_reward(activity_score: u128, liquidity_score: u128) -> u128 {
+
+        let base_reward = 10;
+
+        activity_score * base_reward + liquidity_score * 5
+    }
+
+}

contracts/reward_engine_enhanced.rs

@@ -0,0 +1,9 @@
+pub struct RewardEngineEnhanced;
+
+impl RewardEngineEnhanced {
+    pub fn allocate_rewards(total_vault: u64, active_ratio: f64) -> u64 {
+        let base = total_vault.saturating_mul(314) / 10_000;
+        let boosted = (base as f64 * (1.0 + active_ratio.clamp(0.0, 1.0))) as u64;
+        boosted
+    }
+}

reward_engine.rs

@@ -0,0 +1,25 @@
+#![no_std]
+use soroban_sdk::{contractimpl, Env, Address, Map};
+
+pub struct RewardEngine;
+
+#[contractimpl]
+impl RewardEngine {
+    pub fn claim_reward(env: Env, user: Address, amount: u64) {
+        let key = (b"claimed", user.clone());
+        let mut claimed: u64 = env.storage().get(&key).unwrap_or(0);
+        claimed += amount;
+        env.storage().set(&key, &claimed);
+
+        // mint ke user
+        env.invoke_contract::<()>(
+            &env.current_contract_address(),
+            &soroban_sdk::Symbol::new(&env, "mint"),
+            &(user, amount),
+        );
+    }
+
+    pub fn total_claimed(env: Env, user: Address) -> u64 {
+        env.storage().get(&(b"claimed", user)).unwrap_or(0)
+    }
+}

treasury_vault.rs

@@ -0,0 +1,23 @@
+#![no_std]
+use soroban_sdk::{contractimpl, Env, Address};
+
+pub struct TreasuryVault;
+
+#[contractimpl]
+impl TreasuryVault {
+    pub fn deposit(env: Env, user: Address, amount: u64) {
+        let key = (b"vault", user.clone());
+        let mut bal: u64 = env.storage().get(&key).unwrap_or(0);
+        bal += amount;
+        env.storage().set(&key, &bal);
+    }
+
+    pub fn withdraw(env: Env, user: Address, amount: u64) -> bool {
+        let key = (b"vault", user.clone());
+        let mut bal: u64 = env.storage().get(&key).unwrap_or(0);
+        if bal < amount { return false; }
+        bal -= amount;
+        env.storage().set(&key, &bal);
+        true
+    }
+}