Merge pull request #85 from OpadijoIdris/feat/stellar-benji-connector

feat: integrate BENJI strategy connector for YieldVault

Author: Junirezz

contracts/vault/src/benji_strategy.rs

@@ -0,0 +1,74 @@
+use soroban_sdk::{contract, contractimpl, contracttype, token, Address, Env};
+use crate::strategy::StrategyTrait;
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum StrategyDataKey {
+    Vault,
+    Asset,
+    BenjiToken,
+}
+
+#[contract]
+pub struct BenjiStrategy;
+
+#[contractimpl]
+impl BenjiStrategy {
+    pub fn initialize(env: Env, vault: Address, asset: Address, benji_token: Address) {
+        if env.storage().instance().has(&StrategyDataKey::Vault) {
+            panic!("already initialized");
+        }
+        env.storage().instance().set(&StrategyDataKey::Vault, &vault);
+        env.storage().instance().set(&StrategyDataKey::Asset, &asset);
+        env.storage().instance().set(&StrategyDataKey::BenjiToken, &benji_token);
+    }
+}
+
+#[contractimpl]
+impl StrategyTrait for BenjiStrategy {
+    fn deposit(env: Env, amount: i128) {
+        let vault: Address = env.storage().instance().get(&StrategyDataKey::Vault).unwrap();
+        vault.require_auth();
+
+        let asset_addr: Address = env.storage().instance().get(&StrategyDataKey::Asset).unwrap();
+        let benji_addr: Address = env.storage().instance().get(&StrategyDataKey::BenjiToken).unwrap();
+        
+        let asset_client = token::Client::new(&env, &asset_addr);
+        let benji_client = token::Client::new(&env, &benji_addr);
+
+        // Transfer USDC from Vault to Strategy
+        asset_client.transfer(&vault, &env.current_contract_address(), &amount);
+
+        // In a real BENJI integration, we would swap USDC for BENJI or call a specific mint function.
+        // For this connector, we assume BENJI tokens are issued 1:1 for the underlying asset.
+        // BENJI is a "Fund Token" on Stellar.
+        
+        // Simulating the purchase of BENJI tokens
+        // logic: benji_client.mint(&env.current_contract_address(), &amount); 
+        // Note: Real BENJI has a patent-pending daily accrual mechanism.
+    }
+
+    fn withdraw(env: Env, amount: i128) {
+        let vault: Address = env.storage().instance().get(&StrategyDataKey::Vault).unwrap();
+        vault.require_auth();
+
+        let asset_addr: Address = env.storage().instance().get(&StrategyDataKey::Asset).unwrap();
+        let asset_client = token::Client::new(&env, &asset_addr);
+
+        // Transfer USDC from Strategy back to Vault
+        asset_client.transfer(&env.current_contract_address(), &vault, &amount);
+    }
+
+    fn total_value(env: Env) -> i128 {
+        let benji_addr: Address = env.storage().instance().get(&StrategyDataKey::BenjiToken).unwrap();
+        let benji_client = token::Client::new(&env, &benji_addr);
+        
+        // The value is the balance of BENJI tokens held by this contract.
+        // Assumes 1 BENJI = 1 USD/USDC.
+        benji_client.balance(&env.current_contract_address())
+    }
+
+    fn asset(env: Env) -> Address {
+        env.storage().instance().get(&StrategyDataKey::Asset).unwrap()
+    }
+}

contracts/vault/src/lib.rs

@@ -1,11 +1,14 @@
 #![no_std]
 
 mod test;
+pub mod strategy;
+pub mod benji_strategy;
 
 use soroban_sdk::{
     contract, contractclient, contracterror, contractimpl, contracttype, symbol_short, token,
     Address, Env, Vec,
 };
+use crate::strategy::StrategyClient;
 
 const MAX_PAGE_SIZE: u32 = 50;
 
@@ -40,6 +43,7 @@ pub enum DataKey {
     TotalShares,
     TotalAssets,
     Admin,
+    Strategy,
     State,
     DaoThreshold,
     ProposalNonce,
@@ -97,6 +101,21 @@ impl YieldVault {
 
         env.storage().instance().set(&DataKey::Admin, &admin);
         env.storage().instance().set(&DataKey::TokenAsset, &token);
+        env.storage().instance().set(&DataKey::TotalAssets, &0i128);
+        env.storage().instance().set(&DataKey::DaoThreshold, &1i128);
+        env.storage().instance().set(&DataKey::ProposalNonce, &0u32);
+    }
+
+    /// Set or update the active strategy connector.
+    pub fn set_strategy(env: Env, strategy: Address) {
+        let admin: Address = env.storage().instance().get(&DataKey::Admin).unwrap();
+        admin.require_auth();
+        env.storage().instance().set(&DataKey::Strategy, &strategy);
+    }
+
+    /// Read the active strategy address.
+    pub fn strategy(env: Env) -> Option<Address> {
+        env.storage().instance().get(&DataKey::Strategy)
 
         // Initialize the unified state
         let state = VaultState {
@@ -144,6 +163,18 @@ impl YieldVault {
         Self::get_state(&env).total_shares
     }
 
+    /// Read the total underlying assets (idle in vault + invested in strategy).
+    pub fn total_assets(env: Env) -> i128 {
+        let idle_assets = env.storage().instance().get::<_, i128>(&DataKey::TotalAssets).unwrap_or(0);
+        
+        let strategy_assets = if let Some(strategy_addr) = Self::strategy(env.clone()) {
+            let strategy_client = StrategyClient::new(&env, &strategy_addr);
+            strategy_client.total_value()
+        } else {
+            0
+        };
+
+        idle_assets + strategy_assets
     pub fn total_assets(env: Env) -> i128 {
         Self::get_state(&env).total_assets
     }
@@ -483,6 +514,12 @@ impl YieldVault {
 
         token_client.transfer(&user, &env.current_contract_address(), &amount);
 
+        // Update idle state
+        let ta = env.storage().instance().get::<_, i128>(&DataKey::TotalAssets).unwrap_or(0);
+        env.storage().instance().set(&DataKey::TotalAssets, &(ta + amount));
+        
+        let ts = Self::total_shares(env.clone());
+        env.storage().instance().set(&DataKey::TotalShares, &(ts + shares_to_mint));
         state.total_assets += amount;
         state.total_shares += shares_to_mint;
         env.storage().instance().set(&DataKey::State, &state);
@@ -532,6 +569,26 @@ impl YieldVault {
 
         let token_addr = Self::token(env.clone());
         let token_client = token::Client::new(&env, &token_addr);
+
+        // Check if vault has enough idle assets, otherwise divest from strategy
+        let mut idle_ta = env.storage().instance().get::<_, i128>(&DataKey::TotalAssets).unwrap_or(0);
+        if idle_ta < assets_to_return {
+            let needed = assets_to_return - idle_ta;
+            Self::divest(env.clone(), needed);
+            idle_ta = env.storage().instance().get::<_, i128>(&DataKey::TotalAssets).unwrap_or(0);
+        }
+
+        // Transfer assets from vault to user
+        token_client.transfer(&env.current_contract_address(), &user, &assets_to_return);
+
+        // Update state
+        env.storage().instance().set(&DataKey::TotalAssets, &(idle_ta - assets_to_return));
+        
+        let ts = Self::total_shares(env.clone());
+        env.storage().instance().set(&DataKey::TotalShares, &(ts - shares));
+
+        let vault_balance = Self::balance(env.clone(), user.clone());
+        env.storage().instance().set(&DataKey::ShareBalance(user.clone()), &(vault_balance - shares));
         token_client.transfer(&env.current_contract_address(), &user, &assets_to_return);
 
         state.total_assets -= assets_to_return;
@@ -549,12 +606,53 @@ impl YieldVault {
         Ok(assets_to_return)
     }
 
+    /// Move idle funds to the strategy.
+    pub fn invest(env: Env, amount: i128) {
+        let admin: Address = env.storage().instance().get(&DataKey::Admin).unwrap();
+        admin.require_auth();
+
+        let strategy_addr = Self::strategy(env.clone()).expect("no strategy set");
+        let strategy_client = StrategyClient::new(&env, &strategy_addr);
+
+        let mut idle_ta = env.storage().instance().get::<_, i128>(&DataKey::TotalAssets).unwrap_or(0);
+        if idle_ta < amount { panic!("insufficient idle assets"); }
+
+        // Approve and deposit to strategy
+        let token_addr = Self::token(env.clone());
+        let token_client = token::Client::new(&env, &token_addr);
+        token_client.approve(&env.current_contract_address(), &strategy_addr, &amount, &env.ledger().sequence());
+        
+        strategy_client.deposit(&amount);
+
+        // Update idle assets
+        env.storage().instance().set(&DataKey::TotalAssets, &(idle_ta - amount));
+    }
+
+    /// Recall funds from the strategy.
+    pub fn divest(env: Env, amount: i128) {
+        // Can be called by admin or internally by withdraw
+        let strategy_addr = Self::strategy(env.clone()).expect("no strategy set");
+        let strategy_client = StrategyClient::new(&env, &strategy_addr);
+
+        strategy_client.withdraw(&amount);
+
+        // The strategy contract should have transferred funds back to the vault
+        let idle_ta = env.storage().instance().get::<_, i128>(&DataKey::TotalAssets).unwrap_or(0);
+        env.storage().instance().set(&DataKey::TotalAssets, &(idle_ta + amount));
+    }
+
+    /// Admin function to artificially accrue yield (legacy, but updated for strategy).
     pub fn accrue_yield(env: Env, amount: i128) {
         let admin: Address = env.storage().instance().get(&DataKey::Admin).unwrap();
         admin.require_auth();
 
         let token_addr = Self::token(env.clone());
         let token_client = token::Client::new(&env, &token_addr);
+
+        token_client.transfer(&admin, &env.current_contract_address(), &amount);
+
+        let ta = env.storage().instance().get::<_, i128>(&DataKey::TotalAssets).unwrap_or(0);
+        env.storage().instance().set(&DataKey::TotalAssets, &(ta + amount));
         token_client.transfer(&admin, &env.current_contract_address(), &amount);
 
         let mut state = Self::get_state(&env);

contracts/vault/src/strategy.rs

@@ -0,0 +1,16 @@
+use soroban_sdk::{contractclient, Address, Env};
+
+#[contractclient(name = "StrategyClient")]
+pub trait StrategyTrait {
+    /// Deposits an amount of the underlying asset into the strategy.
+    fn deposit(env: Env, amount: i128);
+
+    /// Withdraws an amount of the underlying asset from the strategy.
+    fn withdraw(env: Env, amount: i128);
+
+    /// Returns the total value of assets held by the strategy (including accrued yield).
+    fn total_value(env: Env) -> i128;
+
+    /// Returns the address of the underlying asset (e.g., USDC).
+    fn asset(env: Env) -> Address;
+}

contracts/vault/src/test.rs

@@ -24,6 +24,9 @@
 #![cfg(test)]
 
 use super::*;
+use soroban_sdk::testutils::{Address as _};
+use soroban_sdk::{token, Address, Env};
+use crate::benji_strategy::{BenjiStrategy, BenjiStrategyClient};
 use soroban_sdk::testutils::Address as _;
 use soroban_sdk::{token, Address, Env, Vec};
 
@@ -60,6 +63,69 @@ fn setup_vault(
 // ─── 1. initialize ───────────────────────────────────────────────────────────
 
 #[test]
+fn test_vault_with_benji_strategy() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let admin = Address::generate(&env);
+    let user = Address::generate(&env);
+
+    // Setup USDC (Underlying Asset)
+    let token_admin = Address::generate(&env);
+    let usdc = create_token_contract(&env, &token_admin);
+    let usdc_admin_client = token::StellarAssetClient::new(&env, &usdc.address);
+    usdc_admin_client.mint(&user, &1000);
+
+    // Setup BENJI Token (Strategy Asset)
+    let benji_token = create_token_contract(&env, &token_admin);
+    let benji_admin_client = token::StellarAssetClient::new(&env, &benji_token.address);
+
+    // Register Contracts
+    let vault_id = env.register(YieldVault, ());
+    let vault = YieldVaultClient::new(&env, &vault_id);
+    
+    let strategy_id = env.register(BenjiStrategy, ());
+    let strategy = BenjiStrategyClient::new(&env, &strategy_id);
+
+    // 1. Initialize
+    vault.initialize(&admin, &usdc.address);
+    strategy.initialize(&vault_id, &usdc.address, &benji_token.address);
+    vault.set_strategy(&strategy_id);
+
+    // 2. User Deposits 100 USDC
+    vault.deposit(&user, &100);
+    assert_eq!(vault.total_assets(), 100);
+    assert_eq!(usdc.balance(&vault_id), 100);
+    assert_eq!(strategy.total_value(), 0);
+
+    // 3. Invest 60 USDC into BENJI Strategy
+    vault.invest(&60);
+    assert_eq!(usdc.balance(&vault_id), 40);
+    assert_eq!(usdc.balance(&strategy_id), 60);
+    
+    // In our mock, strategy value depends on BENJI tokens held by contract
+    // Let's simulate the strategy contract "buying" BENJI tokens
+    benji_admin_client.mint(&strategy_id, &60);
+    assert_eq!(strategy.total_value(), 60);
+    assert_eq!(vault.total_assets(), 100); // 40 idle + 60 in strategy
+
+    // 4. Yield Accrues in BENJI (Daily return)
+    benji_admin_client.mint(&strategy_id, &6); // 10% yield
+    assert_eq!(strategy.total_value(), 66);
+    assert_eq!(vault.total_assets(), 106); // 40 idle + 66 in strategy
+
+    // 5. User Withdraws some shares. 
+    // Vault has 40 idle assets, but user wants to withdraw 50 shares (value ~53 USDC)
+    // This should trigger an internal divestment
+    let withdrawn = vault.withdraw(&user, &50);
+    assert_eq!(withdrawn, 53); // 50 shares * 106 assets / 100 shares = 53
+    
+    assert_eq!(vault.total_shares(), 50);
+    assert_eq!(vault.total_assets(), 53);
+}
+
+#[test]
+fn test_vault_flow_legacy() {
 fn test_initialize_sets_state() {
     let env = Env::default();
     env.mock_all_auths();
@@ -130,6 +196,7 @@ fn test_deposit_second_user_proportional_shares() {
 }
 
 #[test]
+fn test_governance_sets_benji_strategy() {
 fn test_deposit_zero_returns_invalid_amount_error() {
     let env = Env::default();
     env.mock_all_auths();
@@ -178,12 +245,14 @@ fn test_deposit_tiny_amount_after_large_yield_mints_zero_shares() {
 // ─── 3. withdraw ─────────────────────────────────────────────────────────────
 
 #[test]
+fn test_benji_connector_reports_yield() {
 fn test_withdraw_happy_path_receives_correct_assets() {
     let env = Env::default();
     env.mock_all_auths();
 
     let (vault, usdc, usdc_sa, admin) = setup_vault(&env);
     let user = Address::generate(&env);
+    let benji_strategy = Address::generate(&env);
     usdc_sa.mint(&user, &200);
     usdc_sa.mint(&admin, &100);
 
@@ -208,6 +277,8 @@ fn test_withdraw_zero_shares_returns_error() {
     usdc_sa.mint(&user, &100);
     vault.deposit(&user, &100);
 
+    vault.report_benji_yield(&benji_strategy, &40);
+    assert_eq!(vault.total_assets(), 540);
     let result = vault.try_withdraw(&user, &0);
     assert!(result.is_err());
 }