qvtx-developer-kit 1.0.0 → 1.2.0

package/smart-contracts/QVTXDirectPurchase.sol

@@ -0,0 +1,543 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
+import "@openzeppelin/contracts/security/Pausable.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @title QVTXDirectPurchase
+ * @dev Direct purchase contract for QVTX token ecosystem
+ * Allows users to buy QVTX directly with native currency (ETH/BNB/MATIC) or stablecoins
+ *
+ * Features:
+ * - Multi-currency support (native + ERC20 stablecoins)
+ * - Dynamic pricing with admin controls
+ * - Purchase limits (min/max per transaction, per wallet)
+ * - Whitelist support for private sales
+ * - Vesting options for large purchases
+ * - Referral system with rewards
+ * - Emergency pause functionality
+ */
+contract QVTXDirectPurchase is ReentrancyGuard, Pausable, Ownable {
+    using SafeERC20 for IERC20;
+
+    // QVTX Token
+    IERC20 public immutable qvtxToken;
+
+    // Pricing (in wei per QVTX, 18 decimals)
+    uint256 public priceInNative;           // Price in ETH/BNB/MATIC
+    mapping(address => uint256) public priceInToken;  // Price in specific ERC20 (USDT, USDC, etc.)
+
+    // Supported payment tokens
+    address[] public supportedTokens;
+    mapping(address => bool) public isTokenSupported;
+
+    // Purchase limits
+    uint256 public minPurchaseAmount;       // Minimum QVTX per purchase
+    uint256 public maxPurchaseAmount;       // Maximum QVTX per purchase
+    uint256 public maxWalletPurchase;       // Maximum total QVTX per wallet
+    uint256 public totalSaleCap;            // Total QVTX available for sale
+    uint256 public totalSold;               // Total QVTX sold
+
+    // Wallet tracking
+    mapping(address => uint256) public walletPurchased;
+    mapping(address => PurchaseRecord[]) public purchaseHistory;
+
+    // Whitelist (for private sales)
+    bool public whitelistEnabled;
+    mapping(address => bool) public isWhitelisted;
+
+    // Referral system
+    uint256 public referralRewardPercent;   // Reward for referrer (basis points, 100 = 1%)
+    uint256 public referralDiscountPercent; // Discount for buyer using referral (basis points)
+    mapping(address => address) public referredBy;
+    mapping(address => uint256) public referralEarnings;
+    mapping(address => uint256) public referralCount;
+
+    // Vesting for large purchases
+    uint256 public vestingThreshold;        // Amount above which vesting applies
+    uint256 public vestingDuration;         // Vesting period in seconds
+    mapping(address => VestingSchedule[]) public vestingSchedules;
+
+    // Treasury
+    address public treasury;
+
+    // Structs
+    struct PurchaseRecord {
+        uint256 amount;
+        uint256 pricePaid;
+        address paymentToken;   // address(0) for native currency
+        uint256 timestamp;
+        address referrer;
+    }
+
+    struct VestingSchedule {
+        uint256 totalAmount;
+        uint256 released;
+        uint256 startTime;
+        uint256 duration;
+    }
+
+    // Events
+    event TokensPurchased(
+        address indexed buyer,
+        uint256 qvtxAmount,
+        uint256 pricePaid,
+        address paymentToken,
+        address indexed referrer
+    );
+    event PriceUpdated(address token, uint256 newPrice);
+    event PaymentTokenAdded(address token, uint256 price);
+    event PaymentTokenRemoved(address token);
+    event ReferralReward(address indexed referrer, address indexed buyer, uint256 reward);
+    event VestingCreated(address indexed beneficiary, uint256 amount, uint256 duration);
+    event VestingReleased(address indexed beneficiary, uint256 amount);
+    event WhitelistUpdated(address indexed account, bool status);
+    event TreasuryUpdated(address newTreasury);
+    event FundsWithdrawn(address token, uint256 amount);
+
+    constructor(
+        address _qvtxToken,
+        address _treasury,
+        uint256 _priceInNative,
+        uint256 _totalSaleCap
+    ) {
+        require(_qvtxToken != address(0), "Invalid QVTX token");
+        require(_treasury != address(0), "Invalid treasury");
+
+        qvtxToken = IERC20(_qvtxToken);
+        treasury = _treasury;
+        priceInNative = _priceInNative;
+        totalSaleCap = _totalSaleCap;
+
+        // Default limits
+        minPurchaseAmount = 100 * 10**18;           // 100 QVTX minimum
+        maxPurchaseAmount = 10_000_000 * 10**18;    // 10M QVTX maximum per tx
+        maxWalletPurchase = 100_000_000 * 10**18;   // 100M QVTX max per wallet
+
+        // Default referral settings
+        referralRewardPercent = 500;    // 5% to referrer
+        referralDiscountPercent = 200;  // 2% discount for buyer
+
+        // Default vesting
+        vestingThreshold = 1_000_000 * 10**18;  // 1M QVTX threshold
+        vestingDuration = 180 days;             // 6 months vesting
+    }
+
+    // ============ PURCHASE FUNCTIONS ============
+
+    /**
+     * @dev Purchase QVTX with native currency (ETH/BNB/MATIC)
+     * @param qvtxAmount Amount of QVTX to purchase
+     * @param referrer Optional referrer address
+     */
+    function purchaseWithNative(
+        uint256 qvtxAmount,
+        address referrer
+    ) external payable nonReentrant whenNotPaused {
+        _validatePurchase(msg.sender, qvtxAmount);
+
+        uint256 cost = calculateNativeCost(qvtxAmount, referrer);
+        require(msg.value >= cost, "Insufficient payment");
+
+        _processPurchase(msg.sender, qvtxAmount, cost, address(0), referrer);
+
+        // Refund excess
+        if (msg.value > cost) {
+            (bool refunded, ) = msg.sender.call{value: msg.value - cost}("");
+            require(refunded, "Refund failed");
+        }
+    }
+
+    /**
+     * @dev Purchase QVTX with ERC20 token (USDT, USDC, etc.)
+     * @param paymentToken Address of the payment token
+     * @param qvtxAmount Amount of QVTX to purchase
+     * @param referrer Optional referrer address
+     */
+    function purchaseWithToken(
+        address paymentToken,
+        uint256 qvtxAmount,
+        address referrer
+    ) external nonReentrant whenNotPaused {
+        require(isTokenSupported[paymentToken], "Token not supported");
+        _validatePurchase(msg.sender, qvtxAmount);
+
+        uint256 cost = calculateTokenCost(paymentToken, qvtxAmount, referrer);
+
+        // Transfer payment
+        IERC20(paymentToken).safeTransferFrom(msg.sender, address(this), cost);
+
+        _processPurchase(msg.sender, qvtxAmount, cost, paymentToken, referrer);
+    }
+
+    /**
+     * @dev Internal purchase processing
+     */
+    function _processPurchase(
+        address buyer,
+        uint256 qvtxAmount,
+        uint256 cost,
+        address paymentToken,
+        address referrer
+    ) internal {
+        // Update state
+        totalSold += qvtxAmount;
+        walletPurchased[buyer] += qvtxAmount;
+
+        // Record purchase
+        purchaseHistory[buyer].push(PurchaseRecord({
+            amount: qvtxAmount,
+            pricePaid: cost,
+            paymentToken: paymentToken,
+            timestamp: block.timestamp,
+            referrer: referrer
+        }));
+
+        // Process referral
+        if (referrer != address(0) && referrer != buyer) {
+            _processReferral(buyer, referrer, qvtxAmount);
+        }
+
+        // Check if vesting applies
+        if (qvtxAmount >= vestingThreshold && vestingDuration > 0) {
+            _createVesting(buyer, qvtxAmount);
+        } else {
+            // Direct transfer
+            qvtxToken.safeTransfer(buyer, qvtxAmount);
+        }
+
+        emit TokensPurchased(buyer, qvtxAmount, cost, paymentToken, referrer);
+    }
+
+    /**
+     * @dev Process referral rewards
+     */
+    function _processReferral(
+        address buyer,
+        address referrer,
+        uint256 qvtxAmount
+    ) internal {
+        if (referredBy[buyer] == address(0)) {
+            referredBy[buyer] = referrer;
+            referralCount[referrer]++;
+        }
+
+        uint256 reward = (qvtxAmount * referralRewardPercent) / 10000;
+        if (reward > 0 && qvtxToken.balanceOf(address(this)) >= reward) {
+            referralEarnings[referrer] += reward;
+            qvtxToken.safeTransfer(referrer, reward);
+            emit ReferralReward(referrer, buyer, reward);
+        }
+    }
+
+    /**
+     * @dev Create vesting schedule for large purchases
+     */
+    function _createVesting(address beneficiary, uint256 amount) internal {
+        vestingSchedules[beneficiary].push(VestingSchedule({
+            totalAmount: amount,
+            released: 0,
+            startTime: block.timestamp,
+            duration: vestingDuration
+        }));
+
+        emit VestingCreated(beneficiary, amount, vestingDuration);
+    }
+
+    // ============ VESTING FUNCTIONS ============
+
+    /**
+     * @dev Release vested tokens
+     * @param scheduleIndex Index of the vesting schedule
+     */
+    function releaseVested(uint256 scheduleIndex) external nonReentrant {
+        VestingSchedule storage schedule = vestingSchedules[msg.sender][scheduleIndex];
+        require(schedule.totalAmount > 0, "No vesting schedule");
+
+        uint256 releasable = _vestedAmount(schedule) - schedule.released;
+        require(releasable > 0, "Nothing to release");
+
+        schedule.released += releasable;
+        qvtxToken.safeTransfer(msg.sender, releasable);
+
+        emit VestingReleased(msg.sender, releasable);
+    }
+
+    /**
+     * @dev Calculate vested amount
+     */
+    function _vestedAmount(VestingSchedule memory schedule) internal view returns (uint256) {
+        if (block.timestamp < schedule.startTime) {
+            return 0;
+        } else if (block.timestamp >= schedule.startTime + schedule.duration) {
+            return schedule.totalAmount;
+        } else {
+            return (schedule.totalAmount * (block.timestamp - schedule.startTime)) / schedule.duration;
+        }
+    }
+
+    /**
+     * @dev Get releasable vested amount for a user
+     */
+    function getReleasableAmount(address user, uint256 scheduleIndex) external view returns (uint256) {
+        VestingSchedule memory schedule = vestingSchedules[user][scheduleIndex];
+        return _vestedAmount(schedule) - schedule.released;
+    }
+
+    /**
+     * @dev Get all vesting schedules for a user
+     */
+    function getVestingSchedules(address user) external view returns (VestingSchedule[] memory) {
+        return vestingSchedules[user];
+    }
+
+    // ============ PRICING FUNCTIONS ============
+
+    /**
+     * @dev Calculate cost in native currency
+     */
+    function calculateNativeCost(uint256 qvtxAmount, address referrer) public view returns (uint256) {
+        uint256 cost = (qvtxAmount * priceInNative) / 10**18;
+
+        // Apply referral discount
+        if (referrer != address(0) && referrer != msg.sender && referralDiscountPercent > 0) {
+            cost = cost - (cost * referralDiscountPercent) / 10000;
+        }
+
+        return cost;
+    }
+
+    /**
+     * @dev Calculate cost in ERC20 token
+     */
+    function calculateTokenCost(
+        address paymentToken,
+        uint256 qvtxAmount,
+        address referrer
+    ) public view returns (uint256) {
+        require(isTokenSupported[paymentToken], "Token not supported");
+        uint256 cost = (qvtxAmount * priceInToken[paymentToken]) / 10**18;
+
+        // Apply referral discount
+        if (referrer != address(0) && referrer != msg.sender && referralDiscountPercent > 0) {
+            cost = cost - (cost * referralDiscountPercent) / 10000;
+        }
+
+        return cost;
+    }
+
+    /**
+     * @dev Get QVTX amount for native currency
+     */
+    function getQVTXForNative(uint256 nativeAmount) external view returns (uint256) {
+        return (nativeAmount * 10**18) / priceInNative;
+    }
+
+    /**
+     * @dev Get QVTX amount for ERC20 token
+     */
+    function getQVTXForToken(address paymentToken, uint256 tokenAmount) external view returns (uint256) {
+        require(isTokenSupported[paymentToken], "Token not supported");
+        return (tokenAmount * 10**18) / priceInToken[paymentToken];
+    }
+
+    // ============ VIEW FUNCTIONS ============
+
+    /**
+     * @dev Get purchase history for a wallet
+     */
+    function getPurchaseHistory(address wallet) external view returns (PurchaseRecord[] memory) {
+        return purchaseHistory[wallet];
+    }
+
+    /**
+     * @dev Get remaining allocation for a wallet
+     */
+    function getRemainingAllocation(address wallet) external view returns (uint256) {
+        if (walletPurchased[wallet] >= maxWalletPurchase) return 0;
+        return maxWalletPurchase - walletPurchased[wallet];
+    }
+
+    /**
+     * @dev Get remaining tokens available for sale
+     */
+    function getRemainingSupply() external view returns (uint256) {
+        if (totalSold >= totalSaleCap) return 0;
+        return totalSaleCap - totalSold;
+    }
+
+    /**
+     * @dev Get all supported payment tokens
+     */
+    function getSupportedTokens() external view returns (address[] memory) {
+        return supportedTokens;
+    }
+
+    /**
+     * @dev Check if purchase is valid
+     */
+    function canPurchase(address buyer, uint256 amount) external view returns (bool, string memory) {
+        if (paused()) return (false, "Sale paused");
+        if (whitelistEnabled && !isWhitelisted[buyer]) return (false, "Not whitelisted");
+        if (amount < minPurchaseAmount) return (false, "Below minimum");
+        if (amount > maxPurchaseAmount) return (false, "Above maximum");
+        if (walletPurchased[buyer] + amount > maxWalletPurchase) return (false, "Wallet limit exceeded");
+        if (totalSold + amount > totalSaleCap) return (false, "Sale cap exceeded");
+        if (qvtxToken.balanceOf(address(this)) < amount) return (false, "Insufficient supply");
+        return (true, "");
+    }
+
+    // ============ VALIDATION ============
+
+    function _validatePurchase(address buyer, uint256 amount) internal view {
+        require(!whitelistEnabled || isWhitelisted[buyer], "Not whitelisted");
+        require(amount >= minPurchaseAmount, "Below minimum purchase");
+        require(amount <= maxPurchaseAmount, "Above maximum purchase");
+        require(walletPurchased[buyer] + amount <= maxWalletPurchase, "Wallet limit exceeded");
+        require(totalSold + amount <= totalSaleCap, "Sale cap exceeded");
+        require(qvtxToken.balanceOf(address(this)) >= amount, "Insufficient supply");
+    }
+
+    // ============ ADMIN FUNCTIONS ============
+
+    function setNativePrice(uint256 newPrice) external onlyOwner {
+        priceInNative = newPrice;
+        emit PriceUpdated(address(0), newPrice);
+    }
+
+    function addPaymentToken(address token, uint256 price) external onlyOwner {
+        require(token != address(0), "Invalid token");
+        require(!isTokenSupported[token], "Already supported");
+
+        supportedTokens.push(token);
+        isTokenSupported[token] = true;
+        priceInToken[token] = price;
+
+        emit PaymentTokenAdded(token, price);
+    }
+
+    function updateTokenPrice(address token, uint256 newPrice) external onlyOwner {
+        require(isTokenSupported[token], "Token not supported");
+        priceInToken[token] = newPrice;
+        emit PriceUpdated(token, newPrice);
+    }
+
+    function removePaymentToken(address token) external onlyOwner {
+        require(isTokenSupported[token], "Token not supported");
+
+        isTokenSupported[token] = false;
+        priceInToken[token] = 0;
+
+        // Remove from array
+        for (uint i = 0; i < supportedTokens.length; i++) {
+            if (supportedTokens[i] == token) {
+                supportedTokens[i] = supportedTokens[supportedTokens.length - 1];
+                supportedTokens.pop();
+                break;
+            }
+        }
+
+        emit PaymentTokenRemoved(token);
+    }
+
+    function setPurchaseLimits(
+        uint256 _min,
+        uint256 _max,
+        uint256 _maxWallet,
+        uint256 _totalCap
+    ) external onlyOwner {
+        minPurchaseAmount = _min;
+        maxPurchaseAmount = _max;
+        maxWalletPurchase = _maxWallet;
+        totalSaleCap = _totalCap;
+    }
+
+    function setReferralSettings(uint256 reward, uint256 discount) external onlyOwner {
+        require(reward <= 2000, "Reward too high"); // Max 20%
+        require(discount <= 1000, "Discount too high"); // Max 10%
+        referralRewardPercent = reward;
+        referralDiscountPercent = discount;
+    }
+
+    function setVestingSettings(uint256 threshold, uint256 duration) external onlyOwner {
+        vestingThreshold = threshold;
+        vestingDuration = duration;
+    }
+
+    function setWhitelistEnabled(bool enabled) external onlyOwner {
+        whitelistEnabled = enabled;
+    }
+
+    function updateWhitelist(address[] calldata accounts, bool status) external onlyOwner {
+        for (uint i = 0; i < accounts.length; i++) {
+            isWhitelisted[accounts[i]] = status;
+            emit WhitelistUpdated(accounts[i], status);
+        }
+    }
+
+    function setTreasury(address newTreasury) external onlyOwner {
+        require(newTreasury != address(0), "Invalid treasury");
+        treasury = newTreasury;
+        emit TreasuryUpdated(newTreasury);
+    }
+
+    function pause() external onlyOwner {
+        _pause();
+    }
+
+    function unpause() external onlyOwner {
+        _unpause();
+    }
+
+    // ============ WITHDRAWAL FUNCTIONS ============
+
+    function withdrawNative() external onlyOwner {
+        uint256 balance = address(this).balance;
+        require(balance > 0, "No balance");
+
+        (bool sent, ) = treasury.call{value: balance}("");
+        require(sent, "Transfer failed");
+
+        emit FundsWithdrawn(address(0), balance);
+    }
+
+    function withdrawToken(address token) external onlyOwner {
+        uint256 balance = IERC20(token).balanceOf(address(this));
+        require(balance > 0, "No balance");
+
+        // Don't withdraw QVTX sale supply
+        if (token == address(qvtxToken)) {
+            uint256 reserved = totalSaleCap - totalSold;
+            require(balance > reserved, "Cannot withdraw sale supply");
+            balance = balance - reserved;
+        }
+
+        IERC20(token).safeTransfer(treasury, balance);
+
+        emit FundsWithdrawn(token, balance);
+    }
+
+    function withdrawUnsoldQVTX() external onlyOwner {
+        uint256 balance = qvtxToken.balanceOf(address(this));
+        qvtxToken.safeTransfer(treasury, balance);
+        totalSaleCap = totalSold; // Close sale
+
+        emit FundsWithdrawn(address(qvtxToken), balance);
+    }
+
+    // Emergency function
+    function emergencyWithdraw(address token) external onlyOwner {
+        if (token == address(0)) {
+            (bool sent, ) = treasury.call{value: address(this).balance}("");
+            require(sent, "Transfer failed");
+        } else {
+            IERC20(token).safeTransfer(treasury, IERC20(token).balanceOf(address(this)));
+        }
+    }
+
+    receive() external payable {}
+}