chores

Cargo.toml

@@ -1,28 +1,16 @@
 [workspace]
-resolver = "2"
 members = [
-  "contracts/course-registry",
-  "contracts/reward-pool",
-  "contracts/quest-engine",
-  "contracts/governance",
-  "contracts/stake-vault",
-  "contracts/badge-nft"
+    "course-registry",
+    "quest-engine",
+    "reward-pool",
+    "badge-nft",
+    "governance",
+    "stake-vault",
 ]
+resolver = "2"
 
 [workspace.dependencies]
 soroban-sdk = "23"
 
 [profile.release]
-opt-level = "z"
 overflow-checks = true
-debug = 0
-strip = "symbols"
-debug-assertions = false
-panic = "abort"
-codegen-units = 1
-lto = true
-
-# For more information about this profile see https://soroban.stellar.org/docs/basic-tutorials/logging#cargotoml-profile
-[profile.release-with-logs]
-inherits = "release"
-debug-assertions = true

contracts/Cargo.toml

@@ -1,5 +1,12 @@
 [workspace]
-members = ["course-registry", "quest-engine", "reward-pool", "badge-nft", "governance"]
+members = [
+    "course-registry",
+    "quest-engine",
+    "reward-pool",
+    "badge-nft",
+    "governance",
+    "stake-vault",
+]
 resolver = "2"
 
 [workspace.dependencies]

contracts/stake-vault/Cargo.toml

@@ -2,6 +2,14 @@
 name = "stake-vault"
 version = "0.1.0"
 edition = "2021"
+authors = ["Learnault Team"]
+description = "Stake vault contract for the Learnault platform"
+license = "MIT"
+repository = "https://github.com/learnault/learnault-contracts"
+
+[lib]
+crate-type = ["lib", "cdylib"]
+doctest = false
 
 [dependencies]
 soroban-sdk = { workspace = true }

contracts/stake-vault/src/lib.rs

@@ -1,48 +1,149 @@
 #![no_std]
-use soroban_sdk::{contract, contractevent, contractimpl, contracttype, Address, BytesN, Env};
+use soroban_sdk::{contract, contractevent, contractimpl, token, Address, BytesN, Env};
 
-#[contracttype]
-pub enum DataKey {
-    UserStake(Address),
-    Admin,
+pub mod types;
+use types::{DataKey, StakeInfo};
+
+#[contract]
+pub struct StakeVault;
+
+#[contractevent]
+pub struct StakeVaultInitialized {
+    #[topic]
+    pub admin: Address,
+    #[topic]
+    pub token: Address,
 }
 
-#[contracttype]
-pub struct StakeInfo {
+#[contractevent]
+pub struct Staked {
+    #[topic]
+    pub user: Address,
     pub amount: i128,
+    pub total_staked: i128,
     pub lock_timestamp: u64,
 }
 
+#[contractevent]
+pub struct Unstaked {
+    #[topic]
+    pub user: Address,
+    pub amount: i128,
+}
+
 #[contractevent]
 pub struct ContractUpgraded {
     #[topic]
     pub admin: Address,
     pub new_wasm_hash: BytesN<32>,
 }
 
-#[contract]
-pub struct StakeVault;
-
 #[contractimpl]
 impl StakeVault {
-    /// Initializes the StakeVault contract with the protocol admin.
-    pub fn initialize(env: Env, admin: Address) {
+    pub fn initialize(env: Env, admin: Address, token: Address) {
         if env.storage().instance().has(&DataKey::Admin) {
             panic!("Already initialized");
         }
+
         admin.require_auth();
+
         env.storage().instance().set(&DataKey::Admin, &admin);
+        env.storage().instance().set(&DataKey::Token, &token);
+
+        StakeVaultInitialized { admin, token }.publish(&env);
+    }
+
+    pub fn stake(env: Env, user: Address, amount: i128) {
+        user.require_auth();
+
+        if amount <= 0 {
+            panic!("Amount must be positive");
+        }
+
+        let token_id: Address = env
+            .storage()
+            .instance()
+            .get(&DataKey::Token)
+            .expect("Not initialized");
+        let token_client = token::Client::new(&env, &token_id);
+
+        token_client.transfer(&user, env.current_contract_address(), &amount);
+
+        let now = env.ledger().timestamp();
+
+        let mut stake_info: StakeInfo = env
+            .storage()
+            .persistent()
+            .get(&DataKey::UserStake(user.clone()))
+            .unwrap_or(StakeInfo {
+                amount: 0,
+                lock_timestamp: now,
+            });
+
+        stake_info.amount += amount;
+        stake_info.lock_timestamp = now;
+
+        env.storage()
+            .persistent()
+            .set(&DataKey::UserStake(user.clone()), &stake_info);
+
+        Staked {
+            user,
+            amount,
+            total_staked: stake_info.amount,
+            lock_timestamp: stake_info.lock_timestamp,
+        }
+        .publish(&env);
+    }
+
+    pub fn unstake(env: Env, user: Address) {
+        user.require_auth();
+
+        let stake_info: StakeInfo = env
+            .storage()
+            .persistent()
+            .get(&DataKey::UserStake(user.clone()))
+            .expect("No stake found");
+
+        let lock_period: u64 = 604800;
+        if env.ledger().timestamp() < stake_info.lock_timestamp + lock_period {
+            panic!("Lock period active");
+        }
+
+        let token_id: Address = env
+            .storage()
+            .instance()
+            .get(&DataKey::Token)
+            .expect("Not initialized");
+        let token_client = token::Client::new(&env, &token_id);
+
+        token_client.transfer(
+            &env.current_contract_address(),
+            user.clone(),
+            &stake_info.amount,
+        );
+
+        env.storage()
+            .persistent()
+            .remove(&DataKey::UserStake(user.clone()));
+
+        Unstaked {
+            user,
+            amount: stake_info.amount,
+        }
+        .publish(&env);
     }
 
     pub fn get_multiplier(env: Env, user: Address) -> u32 {
-        let stake_info = env
+        let stake_info: StakeInfo = env
             .storage()
             .persistent()
             .get(&DataKey::UserStake(user))
             .unwrap_or(StakeInfo {
                 amount: 0,
                 lock_timestamp: 0,
             });
+
         if stake_info.amount >= 500 {
             200
         } else if stake_info.amount >= 100 {
@@ -52,7 +153,6 @@ impl StakeVault {
         }
     }
 
-    /// Upgrades the contract WASM. Only callable by the Protocol Admin.
     pub fn upgrade_contract(env: Env, admin: Address, new_wasm_hash: BytesN<32>) {
         admin.require_auth();
 
@@ -61,7 +161,9 @@ impl StakeVault {
             .instance()
             .get(&DataKey::Admin)
             .expect("Not initialized");
-        assert!(admin == stored_admin, "Unauthorized");
+        if admin != stored_admin {
+            panic!("Unauthorized");
+        }
 
         env.deployer()
             .update_current_contract_wasm(new_wasm_hash.clone());