PRIVStaking

User stakes PRIV  -->  Rewards accrue over time  -->  Claim or unstake
       |                       |                           |
       v                       v                           v
  Lock period starts    rewardRate * time         Tokens + rewards
                        / totalStaked             returned to user

rewardPerToken = rewardPerTokenStored + (timeElapsed * rewardRate * PRECISION / totalStaked)

userReward = (userStake * (rewardPerToken - userRewardPerTokenPaid) / PRECISION) + pendingRewards

estimatedAPY = (rewardRate * 365 days * 10000) / totalStaked

/// @notice Precision factor for reward calculations
uint256 public constant PRECISION = 1e18;

/// @notice Minimum stake amount (1 PRIV)
uint256 public constant MIN_STAKE_AMOUNT = 1e18;

/// @notice Minimum total staked before rewards start accruing
uint256 public constant MIN_TOTAL_STAKED_FOR_REWARDS = 1000e18;

/// @notice The PRIV token contract
IERC20 public immutable privToken;

/// @notice Reward rate in tokens per second (scaled by PRECISION)
uint256 public rewardRate;

/// @notice Time lock duration for unstaking (in seconds)
uint256 public lockDuration;

/// @notice Total amount of PRIV tokens staked
uint256 public totalStaked;

/// @notice Total rewards available in the pool
uint256 public rewardsPool;

struct StakeInfo {
    uint256 amount;      // Amount staked
    uint256 stakedAt;    // Timestamp of stake
    uint256 unlockTime;  // Timestamp when tokens can be unstaked
}

function stake(uint256 amount) external nonReentrant whenNotPaused

function unstake() external nonReentrant whenNotPaused

function unstakePartial(uint256 amount) external nonReentrant whenNotPaused

function claimRewards() external nonReentrant whenNotPaused

function fundRewardsPool(uint256 amount) external nonReentrant

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

function rewardPerToken() public view returns (uint256)

function getStakeInfo(address account) external view returns (StakeInfo memory)

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

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

function estimatedAPY() external view returns (uint256)

function availableRewardsForWithdrawal() external view returns (uint256)

function setRewardRate(uint256 newRate) external onlyOwner

function setLockDuration(uint256 newDuration) 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, 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 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 the lock duration is updated
event LockDurationUpdated(uint256 oldDuration, uint256 newDuration);

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

error InvalidAddress();
error InvalidAmount();
error BelowMinimumStake();
error NoStake();
error TokensLocked();
error InsufficientRewardsPool();
error InvalidRewardRate();
error TransferFailed();
error InsufficientAvailableRewards();

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

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

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

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

    // 2. Stake tokens
    await writeContract({
      address: STAKING_ADDRESS,
      abi: stakingAbi,
      functionName: 'stake',
      args: [amountWei],
    })
  }
}

function usePendingRewards(address: string) {
  return useReadContract({
    address: STAKING_ADDRESS,
    abi: stakingAbi,
    functionName: 'earned',
    args: [address],
  })
}

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

  return () => {
    writeContract({
      address: STAKING_ADDRESS,
      abi: stakingAbi,
      functionName: 'claimRewards',
    })
  }
}

function useEstimatedAPY() {
  const { data: apyBps } = useReadContract({
    address: STAKING_ADDRESS,
    abi: stakingAbi,
    functionName: 'estimatedAPY',
  })

  // 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_ADDRESS, amountWei],
  })

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