PRIVStakingV2 (ve-PRIV)

User chooses tier  -->  Stakes PRIV  -->  Effective stake calculated  -->  Rewards accrue
      |                     |                       |                          |
      v                     v                       v                          v
  Lock period set    Tokens locked       amount × multiplier / 10000    rewardRate × time
                                                                       / totalEffectiveStake
                                                    |
                                                    v
                                          Claim, auto-compound, or unstake after lock

rewardPerToken = rewardPerTokenStored +
                 (timeElapsed × rewardRate × PRECISION / totalEffectiveStake)

userReward = (effectiveAmount × (rewardPerToken - userRewardPerTokenPaid) / PRECISION)
             + pendingRewards

estimatedAPY(tierIndex) = (rewardRate × 365 days × multiplierBps × 10000)
                          / (totalEffectiveStake × BPS_DENOMINATOR)

uint256 public constant PRECISION = 1e18;
uint256 public constant BPS_DENOMINATOR = 10_000;
uint256 public constant MIN_STAKE_AMOUNT = 1e18;              // 1 PRIV
uint256 public constant MIN_TOTAL_EFFECTIVE_FOR_REWARDS = 1000e18; // 1,000 PRIV effective
uint256 public constant AUTO_COMPOUND_BONUS_BPS = 1500;       // 15%
uint256 public constant NUM_TIERS = 5;

IERC20 public immutable privToken;       // The PRIV token contract
LockTier[5] public tiers;               // Lock tier configurations (index 0-4)
uint256 public rewardRate;               // Tokens per second (scaled by PRECISION)
uint256 public totalStaked;              // Total actual PRIV staked
uint256 public totalEffectiveStake;      // Total weighted stake (sum of all effective amounts)
uint256 public rewardsPool;              // Total rewards available in the pool
uint256 public rewardPerTokenStored;     // Accumulated reward per effective token
uint256 public lastUpdateTime;           // Last time rewards were updated
uint256 public totalPendingRewards;      // Total pending rewards owed to all stakers

struct LockTier {
    uint256 duration;       // Lock duration in seconds
    uint256 multiplierBps;  // Reward multiplier in BPS (10000 = 1x)
}

struct StakePosition {
    uint256 amount;           // Actual PRIV deposited
    uint256 effectiveAmount;  // amount × multiplierBps / BPS_DENOMINATOR
    uint8 tierIndex;          // Lock tier (0=Flex, 1=Bronze, 2=Silver, 3=Gold, 4=Diamond)
    uint256 stakedAt;         // Timestamp of last stake/upgrade
    uint256 unlockTime;       // When tokens can be withdrawn
}

function stake(uint256 amount, uint8 tierIndex) external nonReentrant whenNotPaused

function unstake() external nonReentrant whenNotPaused

function claimRewards() external nonReentrant whenNotPaused

function autoCompound() external nonReentrant whenNotPaused

function upgradeTier(uint8 newTierIndex) external nonReentrant whenNotPaused

function fundRewardsPool(uint256 amount) external nonReentrant

function earned(address account) public view returns (uint256)

function rewardPerToken() public view returns (uint256)

function getPosition(address account) external view returns (StakePosition memory)

function getTier(uint8 tierIndex) external view returns (LockTier memory)

function isLocked(address account) external view returns (bool)

function timeUntilUnlock(address account) external view returns (uint256)

function estimatedAPY(uint8 tierIndex) external view returns (uint256)

function availableRewardsForWithdrawal() external view returns (uint256)

function setRewardRate(uint256 newRate) external onlyOwner

function setTier(uint8 tierIndex, uint256 duration, uint256 multiplierBps) external onlyOwner

function withdrawRewards(uint256 amount) external onlyOwner

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

/// @notice Emitted when a user stakes tokens
event Staked(address indexed user, uint256 amount, uint8 tierIndex, uint256 effectiveAmount, uint256 unlockTime);

/// @notice Emitted when a user unstakes tokens
event Unstaked(address indexed user, uint256 amount);

/// @notice Emitted when a user claims rewards
event RewardsClaimed(address indexed user, uint256 amount);

/// @notice Emitted when rewards are auto-compounded
event AutoCompounded(address indexed user, uint256 rewardAmount, uint256 bonusAmount, uint256 newEffectiveAmount);

/// @notice Emitted when a user upgrades their lock tier
event TierUpgraded(address indexed user, uint8 oldTier, uint8 newTier, uint256 newEffectiveAmount, uint256 newUnlockTime);

/// @notice Emitted when the rewards pool is funded
event RewardsPoolFunded(address indexed funder, uint256 amount);

/// @notice Emitted when the reward rate is updated
event RewardRateUpdated(uint256 oldRate, uint256 newRate);

/// @notice Emitted when a tier configuration is updated
event TierUpdated(uint8 indexed tierIndex, uint256 duration, uint256 multiplierBps);

/// @notice Emitted when rewards are withdrawn by owner
event RewardsWithdrawn(uint256 amount);

error InvalidAddress();
error InvalidAmount();
error InvalidTier();
error BelowMinimumStake();
error NoStake();
error TokensLocked();
error CannotDowngradeTier();
error InsufficientRewardsPool();
error InvalidRewardRate();
error InsufficientAvailableRewards();
error InvalidTierConfig();
error SameTier();

import { useWriteContract, useReadContract } from 'wagmi'
import { parseEther } from 'viem'

function useStakePriv() {
  const { writeContract } = useWriteContract()

  return async (amount: string, tierIndex: number) => {
    const amountWei = parseEther(amount)

    // 1. Approve staking contract
    await writeContract({
      address: PRIV_TOKEN_ADDRESS,
      abi: privTokenAbi,
      functionName: 'approve',
      args: [STAKING_V2_ADDRESS, amountWei],
    })

    // 2. Stake tokens with tier selection
    // Tier indexes: 0=Flex, 1=Bronze, 2=Silver, 3=Gold, 4=Diamond
    await writeContract({
      address: STAKING_V2_ADDRESS,
      abi: stakingV2Abi,
      functionName: 'stake',
      args: [amountWei, tierIndex],
    })
  }
}

function useStakingPosition(address: string) {
  const { data: position } = useReadContract({
    address: STAKING_V2_ADDRESS,
    abi: stakingV2Abi,
    functionName: 'getPosition',
    args: [address],
  })

  const { data: pendingRewards } = useReadContract({
    address: STAKING_V2_ADDRESS,
    abi: stakingV2Abi,
    functionName: 'earned',
    args: [address],
  })

  return { position, pendingRewards }
}

function useAutoCompound() {
  const { writeContract } = useWriteContract()

  return () => {
    writeContract({
      address: STAKING_V2_ADDRESS,
      abi: stakingV2Abi,
      functionName: 'autoCompound',
    })
  }
}

function useUpgradeTier() {
  const { writeContract } = useWriteContract()

  return (newTierIndex: number) => {
    writeContract({
      address: STAKING_V2_ADDRESS,
      abi: stakingV2Abi,
      functionName: 'upgradeTier',
      args: [newTierIndex],
    })
  }
}

function useEstimatedAPY(tierIndex: number) {
  const { data: apyBps } = useReadContract({
    address: STAKING_V2_ADDRESS,
    abi: stakingV2Abi,
    functionName: 'estimatedAPY',
    args: [tierIndex],
  })

  // Convert basis points to percentage
  const apyPercent = apyBps ? Number(apyBps) / 100 : 0
  return apyPercent
}

// Anyone can fund the rewards pool
async function fundPool(amount: string) {
  const amountWei = parseEther(amount)

  await writeContract({
    address: PRIV_TOKEN_ADDRESS,
    abi: privTokenAbi,
    functionName: 'approve',
    args: [STAKING_V2_ADDRESS, amountWei],
  })

  await writeContract({
    address: STAKING_V2_ADDRESS,
    abi: stakingV2Abi,
    functionName: 'fundRewardsPool',
    args: [amountWei],
  })
}