Implement YieldFarm logic with staking, rewards, boosts and remove TODO prefixes.

Author: syntaxsurge

challenge-2-yield-farm/contracts/yeild.sol

@@ -57,7 +57,7 @@ contract YieldFarm is ReentrancyGuard, Ownable {
     event RewardsClaimed(address indexed user, uint256 amount);
     event EmergencyWithdrawn(address indexed user, uint256 amount);
 
-    // TODO: Implement the following functions
+    // Implement the following functions
 
     /**
      * @notice Initialize the contract with the LP token and reward token addresses
@@ -70,9 +70,17 @@ contract YieldFarm is ReentrancyGuard, Ownable {
         address _rewardToken,
         uint256 _rewardRate
     ) Ownable(msg.sender) {
-        // TODO: Initialize contract state
+        // Initialize contract state
+        require(_lpToken != address(0) && _rewardToken != address(0), "Zero address");
+        lpToken = IERC20(_lpToken);
+        rewardToken = IERC20(_rewardToken);
+        rewardRate = _rewardRate;
+        lastUpdateTime = block.timestamp;
     }
 
+    /**
+     * @dev Internal function to update global and user-specific reward accounting
+     */
     function updateReward(address _user) internal {
         rewardPerTokenStored = rewardPerToken();
         lastUpdateTime = block.timestamp;
@@ -85,68 +93,132 @@ contract YieldFarm is ReentrancyGuard, Ownable {
     }
 
     function rewardPerToken() public view returns (uint256) {
-        // TODO: Implement pending rewards calculation
+        // Implement pending rewards calculation
         // Requirements:
         // 1. Calculate rewards since last update
         // 2. Apply boost multiplier
         // 3. Return total pending rewards
+        if (totalStaked == 0) {
+            return rewardPerTokenStored;
+        }
+        uint256 timeElapsed = block.timestamp - lastUpdateTime;
+        uint256 newRewards = (timeElapsed * rewardRate * 1e18) / totalStaked;
+        return rewardPerTokenStored + newRewards;
     }
 
     function earned(address _user) public view returns (uint256) {
-        // TODO: Implement pending rewards calculation
+        // Implement pending rewards calculation
         // Requirements:
         // 1. Calculate rewards since last update
         // 2. Apply boost multiplier
         // 3. Return total pending rewards
+        UserInfo storage user = userInfo[_user];
+        uint256 accumulated = (user.amount * rewardPerToken()) / 1e18;
+        uint256 pending = accumulated - user.rewardDebt + user.pendingRewards;
+        uint256 boost = calculateBoostMultiplier(_user);
+        return (pending * boost) / 100;
     }
 
     /**
      * @notice Stake LP tokens into the farm
      * @param _amount Amount of LP tokens to stake
      */
     function stake(uint256 _amount) external nonReentrant {
-        // TODO: Implement staking logic
+        // Implement staking logic
         // Requirements:
         // 1. Update rewards
         // 2. Transfer LP tokens from user
         // 3. Update user info and total staked amount
         // 4. Emit Staked event
+        require(_amount > 0, "Cannot stake 0");
+        updateReward(msg.sender);
+
+        lpToken.transferFrom(msg.sender, address(this), _amount);
+
+        UserInfo storage user = userInfo[msg.sender];
+        user.amount += _amount;
+        totalStaked += _amount;
+
+        if (user.startTime == 0) {
+            user.startTime = block.timestamp;
+        }
+
+        emit Staked(msg.sender, _amount);
     }
 
     /**
      * @notice Withdraw staked LP tokens
      * @param _amount Amount of LP tokens to withdraw
      */
     function withdraw(uint256 _amount) external nonReentrant {
-        // TODO: Implement withdrawal logic
+        // Implement withdrawal logic
         // Requirements:
         // 1. Update rewards
         // 2. Transfer LP tokens to user
         // 3. Update user info and total staked amount
         // 4. Emit Withdrawn event
+        require(_amount > 0, "Cannot withdraw 0");
+        UserInfo storage user = userInfo[msg.sender];
+        require(user.amount >= _amount, "Insufficient balance");
+
+        updateReward(msg.sender);
+
+        user.amount -= _amount;
+        totalStaked -= _amount;
+        lpToken.transfer(msg.sender, _amount);
+
+        if (user.amount == 0) {
+            user.startTime = 0;
+        }
+
+        emit Withdrawn(msg.sender, _amount);
     }
 
     /**
      * @notice Claim pending rewards
      */
     function claimRewards() external nonReentrant {
-        // TODO: Implement reward claiming logic
+        // Implement reward claiming logic
         // Requirements:
         // 1. Calculate pending rewards with boost multiplier
         // 2. Transfer rewards to user
         // 3. Update user reward debt
         // 4. Emit RewardsClaimed event
+        updateReward(msg.sender);
+
+        UserInfo storage user = userInfo[msg.sender];
+        uint256 reward = user.pendingRewards;
+        require(reward > 0, "No rewards");
+
+        user.pendingRewards = 0;
+        rewardToken.transfer(msg.sender, reward);
+
+        emit RewardsClaimed(msg.sender, reward);
     }
 
     /**
      * @notice Emergency withdraw without caring about rewards
      */
     function emergencyWithdraw() external nonReentrant {
-        // TODO: Implement emergency withdrawal
+        // Implement emergency withdrawal
         // Requirements:
         // 1. Transfer all LP tokens back to user
         // 2. Reset user info
         // 3. Emit EmergencyWithdrawn event
+        UserInfo storage user = userInfo[msg.sender];
+        uint256 amount = user.amount;
+        require(amount > 0, "Nothing to withdraw");
+
+        totalStaked -= amount;
+
+        user.amount = 0;
+        user.rewardDebt = 0;
+        user.pendingRewards = 0;
+        user.startTime = 0;
+
+        lpToken.transfer(msg.sender, amount);
+
+        emit EmergencyWithdrawn(msg.sender, amount);
     }
 
     /**
@@ -157,21 +229,38 @@ contract YieldFarm is ReentrancyGuard, Ownable {
     function calculateBoostMultiplier(
         address _user
     ) public view returns (uint256) {
-        // TODO: Implement boost multiplier calculation
+        // Implement boost multiplier calculation
         // Requirements:
         // 1. Calculate staking duration
         // 2. Return appropriate multiplier based on duration thresholds
+        UserInfo storage user = userInfo[_user];
+        if (user.startTime == 0) {
+            return 100;
+        }
+
+        uint256 duration = block.timestamp - user.startTime;
+
+        if (duration >= BOOST_THRESHOLD_3) {
+            return 200;
+        } else if (duration >= BOOST_THRESHOLD_2) {
+            return 150;
+        } else if (duration >= BOOST_THRESHOLD_1) {
+            return 125;
+        }
+        return 100;
     }
 
     /**
      * @notice Update reward rate
      * @param _newRate New reward rate per second
      */
     function updateRewardRate(uint256 _newRate) external onlyOwner {
-        // TODO: Implement reward rate update logic
+        // Implement reward rate update logic
         // Requirements:
         // 1. Update rewards before changing rate
         // 2. Set new reward rate
+        updateReward(address(0));
+        rewardRate = _newRate;
     }
 
     /**
@@ -182,4 +271,4 @@ contract YieldFarm is ReentrancyGuard, Ownable {
     function pendingRewards(address _user) external view returns (uint256) {
         return earned(_user);
     }
-}
+}