Vault Staking Contract

// Earned yield = (elapsed time / total time) × total yield
earnedYield = (elapsedTime / totalLockTime) × totalYield

// Penalty = unearned yield (deducted from principal)
penalty = totalYield - earnedYield

// User receives: principal - penalty
amountAfterPenalty = principal - penalty

struct Stake {
  uint256 amount;          // Principal amount staked
  uint256 lockDate;        // Timestamp when stake was created
  uint256 unlockDate;      // Timestamp when stake can be withdrawn
  uint256 lockDuration;    // Duration in seconds
  uint256 apy;             // APY rate (with multiplier applied)
  address token;           // Address of staked token
  bool withdrawn;          // Whether stake has been withdrawn
  uint256 totalYield;      // Total yield to be earned
}

import { parseUnits, formatUnits } from 'viem';
import { VAULT_STAKING_ADDRESS, TOKEN_ADDRESSES } from '@/services/vaultService';

const VAULT_STAKING_ABI = [
  {
    inputs: [
      { internalType: 'address', name: 'token', type: 'address' },
      { internalType: 'uint256', name: 'amount', type: 'uint256' },
      { internalType: 'uint256', name: 'lockDuration', type: 'uint256' },
    ],
    name: 'stakeToken',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
];

// Stake 0.001 BTC for 6 months
const tokenAddress = TOKEN_ADDRESSES.BTC;
const amount = parseUnits('0.001', 8); // BTC has 8 decimals
const lockDuration = 15_552_000; // 180 days in seconds

// Step 1: Approve vault contract
const approveData = `0x095ea7b3${
  VAULT_STAKING_ADDRESS.slice(2).padStart(64, '0')
}${
  amount.toString(16).padStart(64, '0')
}`;

const approveTx = await walletClient.sendTransaction({
  to: tokenAddress,
  data: approveData,
});

await publicClient.waitForTransactionReceipt({ hash: approveTx });

// Step 2: Stake tokens
const stakeData = await walletClient.writeContract({
  address: VAULT_STAKING_ADDRESS,
  abi: VAULT_STAKING_ABI,
  functionName: 'stakeToken',
  args: [tokenAddress, amount, lockDuration],
});

import { getUserStakeIds, getStakeDetails } from '@/services/vaultService';

// Get all stake IDs for user
const stakeIds = await getUserStakeIds(userAddress);
console.log('User has', stakeIds.length, 'stakes');

// Get details for each stake
for (const stakeId of stakeIds) {
  const stake = await getStakeDetails(stakeId);
  
  if (stake) {
    console.log('Stake ID:', stakeId);
    console.log('Amount:', formatUnits(stake.amount, 8));
    console.log('Token:', stake.token);
    console.log('Unlock Date:', new Date(Number(stake.unlockDate) * 1000));
    console.log('Total Yield:', formatUnits(stake.totalYield, 8));
    console.log('Withdrawn:', stake.withdrawn);
  }
}

import { calculateEarlyWithdrawalPenalty } from '@/services/vaultService';

const principal = 1000; // 1000 USDC
const lockDate = Date.now() - 30 * 24 * 60 * 60 * 1000; // 30 days ago
const unlockDate = Date.now() + 150 * 24 * 60 * 60 * 1000; // 150 days from now
const totalYield = 50; // 50 USDC expected yield
const currentTime = Date.now();

const penalty = calculateEarlyWithdrawalPenalty(
  principal,
  lockDate,
  unlockDate,
  totalYield,
  currentTime
);

console.log('Penalty Amount:', penalty.penalty); // Unearned yield
console.log('Earned Yield:', penalty.earnedYield); // Proportional yield
console.log('Penalty %:', penalty.penaltyPercentage.toFixed(2) + '%');
console.log('You will receive:', penalty.amountAfterPenalty);
console.log('Days remaining:', penalty.remainingDays);

// Example output:
// Penalty Amount: 41.67 USDC
// Earned Yield: 8.33 USDC
// Penalty %: 83.33%
// You will receive: 958.33 USDC (1000 - 41.67)
// Days remaining: 150

event Staked(
  address indexed user,
  uint256 indexed stakeId,
  address indexed token,
  uint256 amount,
  uint256 lockDuration,
  uint256 unlockDate
);

event Withdrawn(
  address indexed user,
  uint256 indexed stakeId,
  address indexed token,
  uint256 amount,
  uint256 penalty,
  bool isEarlyWithdrawal
);

event PenaltySentToTreasury(
  address indexed token,
  uint256 amount
);

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

function addSupportedToken(address token) external onlyOwner;
function removeSupportedToken(address token) external onlyOwner;

function setTokenAPY(address token, uint256 apy) external onlyOwner;

function setLiquidityPool(address newPool) external onlyOwner;

function updateTreasuryWallet(address newTreasury) external onlyOwner;

function toggleEmergencyWithdrawal(bool enabled) external onlyOwner;

modifier nonReentrant();

modifier whenNotPaused();

modifier onlyOwner();

using SafeERC20 for IERC20;