PrivPresale

Buyer sends ETH/USDC  -->  USD amount calculated  -->  Tokens allocated  -->  Stage auto-advances
       |                          |                         |                        |
       v                          v                         v                        v
  buyWithETH()             Chainlink oracle          Per-wallet cap           Next stage activates
  buyWithUSDC()            (1hr staleness)           enforced                 when sold out
  recordCardPurchase()

function buyWithETH(uint256 stageIndex) external payable nonReentrant whenNotPaused

function buyWithUSDC(uint256 usdcAmount, uint256 stageIndex) external nonReentrant whenNotPaused

function recordCardPurchase(
    address buyer,
    uint256 tokenAmount,
    uint256 usdPaid,
    uint256 stageIndex
) external onlyOwner nonReentrant whenNotPaused

tgeAmount = totalTokens * 20 / 100
vestedFromSchedule = (totalTokens - tgeAmount) * elapsed / VESTING_DURATION
totalClaimable = tgeAmount + vestedFromSchedule - alreadyClaimed

uint256 public constant TOTAL_PRESALE_TOKENS = 15_000_000 * 10 ** 18;
uint256 public constant NUM_STAGES = 10;
uint256 public constant TGE_BPS = 2000;                  // 20%
uint256 public constant BPS_DENOMINATOR = 10_000;
uint256 public constant VESTING_DURATION = 180 days;
uint256 public constant MIN_PURCHASE_USD = 10 * 10 ** 6;  // $10
uint256 public constant MAX_PURCHASE_USD = 50_000 * 10 ** 6; // $50,000
uint256 public constant PRICE_FEED_STALENESS = 1 hours;

IERC20 public immutable privToken;          // PRIV token contract
IERC20 public immutable usdc;               // USDC token contract
AggregatorV3Interface public immutable ethPriceFeed; // Chainlink ETH/USD

Stage[10] public stages;                     // 10 presale stages
mapping(address => VestingSchedule) public vestingSchedules;
mapping(address => mapping(uint256 => uint256)) public walletStagePurchases;

uint256 public tgeTimestamp;                 // 0 until triggerTGE() called
uint256 public totalTokensSold;
uint256 public totalUsdRaised;               // 6 decimals
uint256 public currentStageIndex;
uint256 public totalBuyers;
bool public initialized;

struct Stage {
    uint256 priceUsd;           // Price per token in USD (6 decimals)
    uint256 tokenAllocation;    // Total tokens in this stage (18 decimals)
    uint256 tokensSold;         // Tokens sold so far (18 decimals)
    uint256 maxPerWallet;       // Per-wallet cap (18 decimals)
    bool active;                // Currently active stage
}

struct VestingSchedule {
    uint256 totalTokens;    // Total tokens purchased
    uint256 claimedTokens;  // Tokens already claimed
}

function buyWithETH(uint256 stageIndex) external payable nonReentrant whenNotPaused

function buyWithUSDC(uint256 usdcAmount, uint256 stageIndex) external nonReentrant whenNotPaused

function claim() external nonReentrant

function getCurrentStage() external view returns (
    uint256 stageIndex,
    uint256 priceUsd,
    uint256 tokenAllocation,
    uint256 tokensSold,
    uint256 maxPerWallet,
    bool isActive
)

function getStageInfo(uint256 stageIndex) external view returns (
    uint256 priceUsd,
    uint256 tokenAllocation,
    uint256 tokensSold,
    uint256 maxPerWallet,
    bool active
)

function getAllStages() external view returns (Stage[10] memory)

function getUserAllocation(address user) external view returns (
    uint256 totalTokens,
    uint256 claimedTokens,
    uint256 claimableTokens,
    uint256 vestingStart,
    uint256 vestingEnd
)

function getClaimable(address user) external view returns (uint256)

function getEthPrice() external view returns (uint256)

function calculateTokensForUsd(uint256 usdAmount) external view returns (uint256)

function initialize() external onlyOwner

function triggerTGE() external onlyOwner

function withdrawETH(address to) external onlyOwner

function withdrawTokens(address token, address to) external onlyOwner

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

event PresaleInitialized(uint256 timestamp);

event TokensPurchased(
    address indexed buyer,
    uint256 indexed stageIndex,
    uint256 tokenAmount,
    uint256 usdAmount,
    string paymentMethod       // "eth", "usdc", or "card"
);

event StageCompleted(uint256 indexed stageIndex, uint256 tokensSold);
event StageActivated(uint256 indexed stageIndex, uint256 priceUsd);
event TGETriggered(uint256 timestamp);
event TokensClaimed(address indexed buyer, uint256 amount);
event FundsWithdrawn(address indexed token, address indexed to, uint256 amount);
event ETHWithdrawn(address indexed to, uint256 amount);

error InvalidAddress();
error AlreadyInitialized();
error NotInitialized();
error StageNotActive();
error InvalidStageIndex();
error StageSoldOut();
error BelowMinPurchase();          // Below $10
error AboveMaxPurchase();          // Above $50,000
error WalletLimitExceeded();
error InsufficientPayment();
error TGEAlreadyTriggered();
error TGENotTriggered();
error NothingToClaim();
error StalePriceFeed();            // Chainlink data > 1 hour old
error InvalidPriceFeed();          // Chainlink returned <= 0
error PresaleComplete();
error InsufficientTokenBalance();  // Contract does not hold 15M PRIV
error ZeroAmount();
error RefundFailed();              // ETH refund transfer failed

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

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

  return (ethAmount: string, stageIndex: number) => {
    writeContract({
      address: PRESALE_ADDRESS,
      abi: presaleAbi,
      functionName: 'buyWithETH',
      args: [BigInt(stageIndex)],
      value: parseEther(ethAmount),
    })
  }
}

import { useWriteContract } from 'wagmi'

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

  return async (usdcAmount: bigint, stageIndex: number) => {
    // 1. Approve USDC spending
    await writeContract({
      address: USDC_ADDRESS,
      abi: erc20Abi,
      functionName: 'approve',
      args: [PRESALE_ADDRESS, usdcAmount],
    })

    // 2. Execute purchase
    await writeContract({
      address: PRESALE_ADDRESS,
      abi: presaleAbi,
      functionName: 'buyWithUSDC',
      args: [usdcAmount, BigInt(stageIndex)],
    })
  }
}

import { useReadContract, useWriteContract } from 'wagmi'

function usePresaleAllocation(address: string) {
  const { data: allocation } = useReadContract({
    address: PRESALE_ADDRESS,
    abi: presaleAbi,
    functionName: 'getUserAllocation',
    args: [address],
  })

  const { writeContract } = useWriteContract()

  const claim = () => {
    writeContract({
      address: PRESALE_ADDRESS,
      abi: presaleAbi,
      functionName: 'claim',
    })
  }

  return { allocation, claim }
}

function useCurrentStage() {
  const { data: stage } = useReadContract({
    address: PRESALE_ADDRESS,
    abi: presaleAbi,
    functionName: 'getCurrentStage',
  })

  // stage = [stageIndex, priceUsd, tokenAllocation, tokensSold, maxPerWallet, isActive]
  return stage
}