DogWithCapStaking Contract

Contract: DogWithCapStaking
Version: V8 (Simplified Final)
License: MIT
Solidity: ^0.8.19

DogWithCapStaking is ReentrancyGuard, Pausable, Ownable

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

struct StakePosition {
    uint256 amount;                // Fixed stake amount
    uint256 claimedInterest;       // Total interest claimed
    uint64 startTime;              // Position creation time
    uint64 lastClaimTime;          // Last claim timestamp
    bool isActive;                 // Always true (permanent)
}

struct UserInfo {
    uint256 totalStaked;           // Sum of all positions
    uint256 unclaimedRewards;      // Referral rewards
    uint64 firstStakeTime;         // First stake timestamp
    address referrer;              // Who referred user
    MilestoneLevel milestone;      // Current level
    bool hasEverStaked;            // Has user staked
}

struct ContractStats {
    uint256 totalStaked;           // Total across all users
    uint256 totalUsers;            // Unique user count
    uint256 rewardPool;            // Available rewards
    uint256 totalPositions;        // Total positions created
    uint256 totalInterestPaid;     // Interest distributed
    uint256 totalReferralsPaid;    // Referral rewards paid
}

struct MilestoneVesting {
    uint256 totalAmount;           // Total bonus amount
    uint256 claimedAmount;         // Amount already claimed
    uint64 vestingStart;           // Start timestamp
    uint64 vestingEnd;             // End timestamp
    uint64 lastClaimTime;          // Last claim time
    bool isActive;                 // Vesting active
}

// Rate precision
uint256 public constant RATE_PRECISION = 100000;
 
// Referral rate (5%)
uint256 public constant REFERRAL_RATE = 5000;
 
// Minimum stake amount (100 WICC)
uint256 public constant MIN_STAKE_AMOUNT = 100 * 10**18;
 
// Cooldown between actions (60 seconds)
uint256 public constant CLAIM_COOLDOWN = 60;
 
// Interest rate bounds
uint256 public constant MIN_DAILY_INTEREST_RATE = 50;   // 0.05%
uint256 public constant MAX_DAILY_INTEREST_RATE = 1000; // 1%

IERC20 public immutable stakingToken;

uint256 public dailyInterestRate = 200; // 0.2% default
InterestRateChange[] public interestRateHistory;

uint256 public nextCashOutRequestId = 1;
uint256 public minCashOutAmount = 10 * 10**18;
uint256 public maxCashOutAmount = 1000000 * 10**18;
uint256 public cashOutFeeRate = 100; // 0.1%
bool public cashOutEnabled = true;
uint256 public totalCashOutTokensInContract = 0;

// User data
mapping(address => UserInfo) public users;
mapping(address => UserReferralData) private userReferralData;
mapping(address => mapping(uint256 => StakePosition)) public userPositions;
 
// Position tracking
mapping(address => uint256[]) public userPositionIds;
mapping(uint256 => address) public positionOwner;
 
// Milestone vesting
mapping(address => mapping(uint8 => MilestoneVesting)) public milestoneVesting;
mapping(address => mapping(uint8 => bool)) public milestoneAchieved;
 
// Rate limiting
mapping(address => uint256) public lastActionTime;
 
// Referrals
mapping(address => address[]) public userReferees;

function stake(
    uint256 amount,
    address referrer
) external nonReentrant whenNotPaused rateLimited 
  returns (uint256 positionId)

function claimPositionInterest(uint256 positionId) 
    external 
    nonReentrant 
    whenNotPaused 
    rateLimited 
    validPosition(positionId)
    returns (uint256 claimedAmount)

function claimAllPositions() 
    external 
    nonReentrant 
    whenNotPaused 
    rateLimited

function claimReferralRewards() 
    external 
    nonReentrant 
    whenNotPaused 
    rateLimited

function claimMilestoneVesting(uint8[] calldata milestoneLevels) 
    external 
    nonReentrant 
    whenNotPaused 
    rateLimited

function getUserInfo(address userAddr)
    external
    view
    returns (
        uint256 totalStaked,
        uint256 unclaimedReferralRewards,
        uint256 totalPendingInterest,
        uint256 totalVestingAmount,
        uint256 totalClaimableVesting,
        address referrer,
        MilestoneLevel milestone,
        uint256 totalPositions
    )

function getPosition(address user, uint256 positionId)
    external
    view
    returns (
        uint256 amount,
        uint256 claimedInterest,
        uint256 pendingInterest,
        uint256 startTime,
        uint256 lastClaimTime,
        uint256 stakingDays,
        bool isActive
    )

function getContractStats()
    external
    view
    returns (
        uint256 totalStaked,
        uint256 totalUsers,
        uint256 rewardPool,
        uint256 totalPositions,
        uint256 contractBalance,
        uint256 totalInterestPaid,
        uint256 totalReferralsPaid,
        uint256 pendingCashOutAmount,
        uint256 currentDailyRate
    )

function setDailyInterestRate(uint256 newRate, string calldata reason) 
    external 
    onlyOwner

function depositRewards(uint256 amount) 
    external 
    onlyOwner

function pause() external onlyOwner
function unpause() external onlyOwner

modifier nonReentrant() 

modifier rateLimited() {
    require(
        block.timestamp >= lastActionTime[msg.sender] + CLAIM_COOLDOWN,
        "Cooldown active"
    );
    _;
    lastActionTime[msg.sender] = block.timestamp;
}

modifier onlyOwner()

describe("DogWithCapStaking", () => {
  it("Should stake tokens successfully", async () => {
    await token.approve(staking.address, amount);
    await staking.stake(amount, referrer);
    // Assert position created
  });
 
  it("Should enforce minimum stake", async () => {
    await expect(
      staking.stake(99, ADDRESS_ZERO)
    ).to.be.revertedWith("AmountTooLow");
  });
 
  it("Should prevent self-referral", async () => {
    await expect(
      staking.stake(amount, user.address)
    ).to.be.revertedWith("SelfReferral");
  });
 
  it("Should calculate interest correctly", async () => {
    // Stake
    // Wait 1 day
    // Claim
    // Assert correct amount
  });
});