Vault Staking

// VaultStaking contract address
const VAULT_STAKING_ADDRESS = '0xB156a66521BCB5A903daA42879A3e562E402Fa41';

// Staking function
function stakeToken(
  address token,      // Token contract address
  uint256 amount,     // Amount to stake (in wei)
  uint256 lockDuration // Duration in days (30/60/90/180/365)
) external {
  // Transfer tokens from user to contract
  IERC20(token).transferFrom(msg.sender, address(this), amount);
  
  // Calculate APY based on duration
  uint256 apy = getAPYForDuration(token, lockDuration);
  
  // Calculate total yield
  uint256 totalYield = (amount * apy * lockDuration) / (365 * 10000);
  
  // Store stake details
  stakes[stakeId] = Stake({
    user: msg.sender,
    token: token,
    amount: amount,
    lockDate: block.timestamp,
    unlockDate: block.timestamp + (lockDuration * 1 days),
    apy: apy,
    totalYield: totalYield,
    withdrawn: false
  });
}

// From VaultPage.tsx
const currentYield = useMemo(() => {
  const now = Date.now();
  const elapsed = now - asset.lockDate;
  const total = asset.unlockDate - asset.lockDate;
  
  // Calculate proportional yield
  const yieldProgress = elapsed / total;
  return asset.totalYield * yieldProgress;
}, [currentTime, asset]);  // Recalculates every second

Stake: 5,000 USDC for 180 days at 6.9% APY
Total Yield: 169.32 USDC

After 90 days (50% complete):
Current Yield: 84.66 USDC
Value: 5,084.66 USDC

// From VaultPage.tsx - Normal unlock
const handleUnlock = async (assetId: string) => {
  // Call withdraw(uint256 stakeId)
  const withdrawData = `0x2e1a7d4d${  // withdraw()
    stakeId.toString(16).padStart(64, '0')  // Stake ID
  }`;
  
  const result = await sendTransaction(
    VAULT_STAKING_ADDRESS,
    '0',
    'ETH',
    withdrawData
  );
  
  // Contract transfers: principal + totalYield
};

// From vaultService.ts
export function calculateEarlyWithdrawalPenalty(
  amount: number,
  lockDate: number,
  unlockDate: number,
  totalYield: number,
  currentTime: number
) {
  const elapsed = currentTime - lockDate;
  const totalDuration = unlockDate - lockDate;
  const remaining = unlockDate - currentTime;
  
  // Penalty = (remaining time / total time) × total yield
  const penaltyPercentage = (remaining / totalDuration) * 100;
  const penalty = (remaining / totalDuration) * totalYield;
  const amountAfterPenalty = amount + totalYield - penalty;
  
  return {
    penalty,
    penaltyPercentage,
    amountAfterPenalty
  };
}

Stake: 5,000 USDC, 180 days, 6.9% APY
Total Yield: 169.32 USDC

After 90 days (50% remaining):
  Penalty: 50% × 169.32 = 84.66 USDC
  Amount After Penalty: 5,000 + 169.32 - 84.66 = 5,084.66 USDC

After 135 days (25% remaining):
  Penalty: 25% × 169.32 = 42.33 USDC
  Amount After Penalty: 5,000 + 169.32 - 42.33 = 5,126.99 USDC

// Call withdrawEarly(uint256 stakeId)
const earlyUnlockData = `0x4f4b48f2${  // withdrawEarly()
  stakeId.toString(16).padStart(64, '0')
}`;

const result = await sendTransaction(
  VAULT_STAKING_ADDRESS,
  '0',
  'ETH',
  earlyUnlockData
);

// Contract calculates penalty on-chain and transfers:
// principal + (totalYield × elapsed / total)

// From VaultPage.tsx
const historyKey = `vaultHistory_${address.toLowerCase()}`;
localStorage.setItem(historyKey, JSON.stringify(history));

// From vaultService.ts
export async function getUserStakeIds(userAddress: string): Promise<number[]> {
  const logs = await publicClient.getLogs({
    address: VAULT_STAKING_ADDRESS,
    event: StakedEvent,
    args: {
      user: userAddress  // Filter to your address
    },
    fromBlock: 'earliest'
  });
  
  return logs.map(log => Number(log.args.stakeId));
}

export async function getStakeDetails(stakeId: number): Promise<Stake> {
  const stake = await publicClient.readContract({
    address: VAULT_STAKING_ADDRESS,
    abi: vaultAbi,
    functionName: 'stakes',
    args: [BigInt(stakeId)]
  });
  
  return {
    user: stake.user,
    token: stake.token,
    amount: stake.amount,
    lockDate: Number(stake.lockDate),
    unlockDate: Number(stake.unlockDate),
    apy: Number(stake.apy),
    totalYield: stake.totalYield,
    withdrawn: stake.withdrawn
  };
}

// From VaultPage.tsx
const stats: VaultStats = useMemo(() => {
  return {
    totalLocked: lockedAssets.reduce(
      (sum, asset) => sum + asset.usdValue, 
      0
    ),
    totalYieldEarned: lockedAssets.reduce((sum, asset) => {
      const elapsed = currentTime - asset.lockDate;
      const total = asset.unlockDate - asset.lockDate;
      const currentYield = (elapsed / total) * asset.totalYield;
      const yieldValue = currentYield * (asset.usdValue / asset.amount);
      return sum + yieldValue;
    }, 0),
    activeVaults: lockedAssets.filter(
      a => a.status === 'locked' || a.status === 'unlocking'
    ).length,
    averageAPY: lockedAssets.reduce(
      (sum, asset) => sum + asset.apy, 0
    ) / (lockedAssets.length || 1)
  };
}, [lockedAssets, currentTime]);

VaultStaking: 0xB156a66521BCB5A903daA42879A3e562E402Fa41