qvtx-developer-kit 1.0.0 → 1.2.0

package/purchase/index.js

@@ -0,0 +1,567 @@
+'use strict';
+
+/**
+ * QVTX Direct Purchase Module
+ * SDK for interacting with QVTXDirectPurchase contract
+ *
+ * Features:
+ * - Buy QVTX with native currency (ETH/BNB/MATIC)
+ * - Buy QVTX with stablecoins (USDT, USDC, DAI)
+ * - Referral system integration
+ * - Vesting schedule management
+ * - Purchase history tracking
+ */
+
+const { ethers } = require('ethers');
+const DirectPurchaseABI = require('../abis/QVTXDirectPurchase.json').abi;
+
+// Deployed contract addresses per network
+const PURCHASE_CONTRACTS = {
+    ethereum: {
+        mainnet: null,  // Deploy and add address
+        goerli: null,
+        sepolia: null
+    },
+    bsc: {
+        mainnet: null,  // Deploy and add address
+        testnet: null
+    },
+    polygon: {
+        mainnet: null,  // Deploy and add address
+        mumbai: null
+    },
+    arbitrum: {
+        mainnet: null,
+        goerli: null
+    },
+    avalanche: {
+        mainnet: null,
+        fuji: null
+    }
+};
+
+// Common stablecoin addresses
+const STABLECOINS = {
+    ethereum: {
+        USDT: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+        USDC: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        DAI: '0x6B175474E89094C44Da98b954EescdeCB5BE3830'
+    },
+    bsc: {
+        USDT: '0x55d398326f99059fF775485246999027B3197955',
+        USDC: '0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d',
+        BUSD: '0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56'
+    },
+    polygon: {
+        USDT: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F',
+        USDC: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
+        DAI: '0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063'
+    }
+};
+
+class QVTXDirectPurchase {
+    /**
+     * Create a new QVTXDirectPurchase instance
+     * @param {Object} options Configuration options
+     * @param {string|ethers.Provider} options.provider - RPC URL or ethers provider
+     * @param {string} options.contractAddress - DirectPurchase contract address
+     * @param {string} [options.privateKey] - Private key for transactions
+     * @param {ethers.Signer} [options.signer] - Ethers signer (alternative to privateKey)
+     */
+    constructor(options = {}) {
+        if (!options.contractAddress && !options.network) {
+            throw new Error('Contract address or network required');
+        }
+
+        // Setup provider
+        if (typeof options.provider === 'string') {
+            this.provider = new ethers.providers.JsonRpcProvider(options.provider);
+        } else if (options.provider) {
+            this.provider = options.provider;
+        } else {
+            throw new Error('Provider required');
+        }
+
+        // Setup signer
+        if (options.signer) {
+            this.signer = options.signer;
+        } else if (options.privateKey) {
+            this.signer = new ethers.Wallet(options.privateKey, this.provider);
+        }
+
+        // Get contract address
+        if (options.contractAddress) {
+            this.contractAddress = options.contractAddress;
+        } else if (options.network) {
+            const [network, env] = options.network.split(':');
+            this.contractAddress = PURCHASE_CONTRACTS[network]?.[env || 'mainnet'];
+            if (!this.contractAddress) {
+                throw new Error(`No contract deployed on ${options.network}`);
+            }
+        }
+
+        // Initialize contract
+        this.contract = new ethers.Contract(
+            this.contractAddress,
+            DirectPurchaseABI,
+            this.signer || this.provider
+        );
+    }
+
+    // ============ READ FUNCTIONS ============
+
+    /**
+     * Get current price in native currency
+     * @returns {Promise<string>} Price in wei
+     */
+    async getPriceInNative() {
+        const price = await this.contract.priceInNative();
+        return ethers.utils.formatEther(price);
+    }
+
+    /**
+     * Get price for a specific payment token
+     * @param {string} tokenAddress Payment token address
+     * @returns {Promise<string>} Price per QVTX in token units
+     */
+    async getPriceInToken(tokenAddress) {
+        const price = await this.contract.priceInToken(tokenAddress);
+        return price.toString();
+    }
+
+    /**
+     * Calculate cost for purchasing QVTX with native currency
+     * @param {string|number} qvtxAmount Amount of QVTX to buy
+     * @param {string} [referrer] Optional referrer address
+     * @returns {Promise<string>} Cost in native currency (ETH/BNB/MATIC)
+     */
+    async calculateNativeCost(qvtxAmount, referrer = ethers.constants.AddressZero) {
+        const amount = ethers.utils.parseEther(qvtxAmount.toString());
+        const cost = await this.contract.calculateNativeCost(amount, referrer);
+        return ethers.utils.formatEther(cost);
+    }
+
+    /**
+     * Calculate cost for purchasing QVTX with ERC20 token
+     * @param {string} tokenAddress Payment token address
+     * @param {string|number} qvtxAmount Amount of QVTX to buy
+     * @param {string} [referrer] Optional referrer address
+     * @returns {Promise<string>} Cost in token units
+     */
+    async calculateTokenCost(tokenAddress, qvtxAmount, referrer = ethers.constants.AddressZero) {
+        const amount = ethers.utils.parseEther(qvtxAmount.toString());
+        const cost = await this.contract.calculateTokenCost(tokenAddress, amount, referrer);
+        return cost.toString();
+    }
+
+    /**
+     * Get QVTX amount for native currency
+     * @param {string|number} nativeAmount Amount of native currency
+     * @returns {Promise<string>} QVTX amount
+     */
+    async getQVTXForNative(nativeAmount) {
+        const amount = ethers.utils.parseEther(nativeAmount.toString());
+        const qvtx = await this.contract.getQVTXForNative(amount);
+        return ethers.utils.formatEther(qvtx);
+    }
+
+    /**
+     * Get QVTX amount for ERC20 token
+     * @param {string} tokenAddress Payment token address
+     * @param {string|number} tokenAmount Amount of tokens
+     * @returns {Promise<string>} QVTX amount
+     */
+    async getQVTXForToken(tokenAddress, tokenAmount) {
+        const qvtx = await this.contract.getQVTXForToken(tokenAddress, tokenAmount);
+        return ethers.utils.formatEther(qvtx);
+    }
+
+    /**
+     * Check if a purchase is valid
+     * @param {string} buyer Buyer address
+     * @param {string|number} amount QVTX amount
+     * @returns {Promise<{valid: boolean, reason: string}>}
+     */
+    async canPurchase(buyer, amount) {
+        const amountWei = ethers.utils.parseEther(amount.toString());
+        const [valid, reason] = await this.contract.canPurchase(buyer, amountWei);
+        return { valid, reason };
+    }
+
+    /**
+     * Get purchase limits
+     * @returns {Promise<Object>} Purchase limits
+     */
+    async getPurchaseLimits() {
+        const [min, max, maxWallet, totalCap, totalSold] = await Promise.all([
+            this.contract.minPurchaseAmount(),
+            this.contract.maxPurchaseAmount(),
+            this.contract.maxWalletPurchase(),
+            this.contract.totalSaleCap(),
+            this.contract.totalSold()
+        ]);
+
+        return {
+            minPurchase: ethers.utils.formatEther(min),
+            maxPurchase: ethers.utils.formatEther(max),
+            maxWalletPurchase: ethers.utils.formatEther(maxWallet),
+            totalSaleCap: ethers.utils.formatEther(totalCap),
+            totalSold: ethers.utils.formatEther(totalSold),
+            remainingSupply: ethers.utils.formatEther(totalCap.sub(totalSold))
+        };
+    }
+
+    /**
+     * Get wallet purchase info
+     * @param {string} wallet Wallet address
+     * @returns {Promise<Object>} Wallet purchase info
+     */
+    async getWalletInfo(wallet) {
+        const [purchased, maxWallet, history] = await Promise.all([
+            this.contract.walletPurchased(wallet),
+            this.contract.maxWalletPurchase(),
+            this.contract.getPurchaseHistory(wallet)
+        ]);
+
+        return {
+            totalPurchased: ethers.utils.formatEther(purchased),
+            remainingAllocation: ethers.utils.formatEther(maxWallet.sub(purchased)),
+            purchaseCount: history.length,
+            purchases: history.map(p => ({
+                amount: ethers.utils.formatEther(p.amount),
+                pricePaid: p.pricePaid.toString(),
+                paymentToken: p.paymentToken,
+                timestamp: new Date(p.timestamp.toNumber() * 1000),
+                referrer: p.referrer
+            }))
+        };
+    }
+
+    /**
+     * Get referral info for a wallet
+     * @param {string} wallet Wallet address
+     * @returns {Promise<Object>} Referral info
+     */
+    async getReferralInfo(wallet) {
+        const [earnings, count, referredBy, rewardPercent, discountPercent] = await Promise.all([
+            this.contract.referralEarnings(wallet),
+            this.contract.referralCount(wallet),
+            this.contract.referredBy(wallet),
+            this.contract.referralRewardPercent(),
+            this.contract.referralDiscountPercent()
+        ]);
+
+        return {
+            totalEarnings: ethers.utils.formatEther(earnings),
+            referralCount: count.toNumber(),
+            referredBy: referredBy === ethers.constants.AddressZero ? null : referredBy,
+            rewardPercent: rewardPercent.toNumber() / 100,
+            discountPercent: discountPercent.toNumber() / 100
+        };
+    }
+
+    /**
+     * Get vesting schedules for a wallet
+     * @param {string} wallet Wallet address
+     * @returns {Promise<Array>} Vesting schedules
+     */
+    async getVestingSchedules(wallet) {
+        const schedules = await this.contract.getVestingSchedules(wallet);
+        return schedules.map((s, index) => ({
+            index,
+            totalAmount: ethers.utils.formatEther(s.totalAmount),
+            released: ethers.utils.formatEther(s.released),
+            remaining: ethers.utils.formatEther(s.totalAmount.sub(s.released)),
+            startTime: new Date(s.startTime.toNumber() * 1000),
+            endTime: new Date((s.startTime.toNumber() + s.duration.toNumber()) * 1000),
+            duration: s.duration.toNumber() / 86400, // days
+            percentVested: s.totalAmount.gt(0)
+                ? (s.released.mul(10000).div(s.totalAmount).toNumber() / 100)
+                : 0
+        }));
+    }
+
+    /**
+     * Get supported payment tokens
+     * @returns {Promise<string[]>} Array of token addresses
+     */
+    async getSupportedTokens() {
+        return await this.contract.getSupportedTokens();
+    }
+
+    /**
+     * Check if sale is paused
+     * @returns {Promise<boolean>}
+     */
+    async isPaused() {
+        return await this.contract.paused();
+    }
+
+    /**
+     * Check if whitelist is enabled
+     * @returns {Promise<boolean>}
+     */
+    async isWhitelistEnabled() {
+        return await this.contract.whitelistEnabled();
+    }
+
+    /**
+     * Check if address is whitelisted
+     * @param {string} address Address to check
+     * @returns {Promise<boolean>}
+     */
+    async isWhitelisted(address) {
+        return await this.contract.isWhitelisted(address);
+    }
+
+    // ============ PURCHASE FUNCTIONS ============
+
+    /**
+     * Purchase QVTX with native currency
+     * @param {string|number} qvtxAmount Amount of QVTX to buy
+     * @param {Object} [options] Purchase options
+     * @param {string} [options.referrer] Referrer address for discount
+     * @param {Object} [options.overrides] Transaction overrides
+     * @returns {Promise<ethers.ContractTransaction>}
+     */
+    async purchaseWithNative(qvtxAmount, options = {}) {
+        if (!this.signer) throw new Error('Signer required for transactions');
+
+        const amount = ethers.utils.parseEther(qvtxAmount.toString());
+        const referrer = options.referrer || ethers.constants.AddressZero;
+
+        // Calculate cost
+        const cost = await this.contract.calculateNativeCost(amount, referrer);
+
+        // Add small buffer for price fluctuation
+        const value = cost.mul(101).div(100);
+
+        const tx = await this.contract.purchaseWithNative(amount, referrer, {
+            value,
+            ...options.overrides
+        });
+
+        return tx;
+    }
+
+    /**
+     * Purchase QVTX with ERC20 token
+     * @param {string} tokenAddress Payment token address
+     * @param {string|number} qvtxAmount Amount of QVTX to buy
+     * @param {Object} [options] Purchase options
+     * @param {string} [options.referrer] Referrer address for discount
+     * @param {boolean} [options.approve] Auto-approve token spending
+     * @param {Object} [options.overrides] Transaction overrides
+     * @returns {Promise<ethers.ContractTransaction>}
+     */
+    async purchaseWithToken(tokenAddress, qvtxAmount, options = {}) {
+        if (!this.signer) throw new Error('Signer required for transactions');
+
+        const amount = ethers.utils.parseEther(qvtxAmount.toString());
+        const referrer = options.referrer || ethers.constants.AddressZero;
+
+        // Calculate cost
+        const cost = await this.contract.calculateTokenCost(tokenAddress, amount, referrer);
+
+        // Auto-approve if requested
+        if (options.approve !== false) {
+            const token = new ethers.Contract(
+                tokenAddress,
+                ['function approve(address,uint256) returns (bool)', 'function allowance(address,address) view returns (uint256)'],
+                this.signer
+            );
+
+            const allowance = await token.allowance(await this.signer.getAddress(), this.contractAddress);
+            if (allowance.lt(cost)) {
+                const approveTx = await token.approve(this.contractAddress, ethers.constants.MaxUint256);
+                await approveTx.wait();
+            }
+        }
+
+        const tx = await this.contract.purchaseWithToken(tokenAddress, amount, referrer, {
+            ...options.overrides
+        });
+
+        return tx;
+    }
+
+    /**
+     * Release vested tokens
+     * @param {number} scheduleIndex Index of vesting schedule
+     * @param {Object} [overrides] Transaction overrides
+     * @returns {Promise<ethers.ContractTransaction>}
+     */
+    async releaseVested(scheduleIndex, overrides = {}) {
+        if (!this.signer) throw new Error('Signer required for transactions');
+        return await this.contract.releaseVested(scheduleIndex, overrides);
+    }
+
+    // ============ ADMIN FUNCTIONS ============
+
+    /**
+     * Set price in native currency (owner only)
+     * @param {string|number} price New price in ETH/BNB/MATIC per QVTX
+     * @returns {Promise<ethers.ContractTransaction>}
+     */
+    async setNativePrice(price) {
+        if (!this.signer) throw new Error('Signer required');
+        const priceWei = ethers.utils.parseEther(price.toString());
+        return await this.contract.setNativePrice(priceWei);
+    }
+
+    /**
+     * Add payment token (owner only)
+     * @param {string} tokenAddress Token address
+     * @param {string|number} price Price per QVTX in token units
+     * @returns {Promise<ethers.ContractTransaction>}
+     */
+    async addPaymentToken(tokenAddress, price) {
+        if (!this.signer) throw new Error('Signer required');
+        return await this.contract.addPaymentToken(tokenAddress, price);
+    }
+
+    /**
+     * Update token price (owner only)
+     * @param {string} tokenAddress Token address
+     * @param {string|number} price New price per QVTX
+     * @returns {Promise<ethers.ContractTransaction>}
+     */
+    async updateTokenPrice(tokenAddress, price) {
+        if (!this.signer) throw new Error('Signer required');
+        return await this.contract.updateTokenPrice(tokenAddress, price);
+    }
+
+    /**
+     * Set purchase limits (owner only)
+     * @param {Object} limits Limit configuration
+     * @returns {Promise<ethers.ContractTransaction>}
+     */
+    async setPurchaseLimits(limits) {
+        if (!this.signer) throw new Error('Signer required');
+        return await this.contract.setPurchaseLimits(
+            ethers.utils.parseEther(limits.min?.toString() || '100'),
+            ethers.utils.parseEther(limits.max?.toString() || '10000000'),
+            ethers.utils.parseEther(limits.maxWallet?.toString() || '100000000'),
+            ethers.utils.parseEther(limits.totalCap?.toString() || '1000000000')
+        );
+    }
+
+    /**
+     * Update whitelist (owner only)
+     * @param {string[]} addresses Addresses to update
+     * @param {boolean} status Whitelist status
+     * @returns {Promise<ethers.ContractTransaction>}
+     */
+    async updateWhitelist(addresses, status) {
+        if (!this.signer) throw new Error('Signer required');
+        return await this.contract.updateWhitelist(addresses, status);
+    }
+
+    /**
+     * Pause sale (owner only)
+     * @returns {Promise<ethers.ContractTransaction>}
+     */
+    async pause() {
+        if (!this.signer) throw new Error('Signer required');
+        return await this.contract.pause();
+    }
+
+    /**
+     * Unpause sale (owner only)
+     * @returns {Promise<ethers.ContractTransaction>}
+     */
+    async unpause() {
+        if (!this.signer) throw new Error('Signer required');
+        return await this.contract.unpause();
+    }
+
+    /**
+     * Withdraw native currency to treasury (owner only)
+     * @returns {Promise<ethers.ContractTransaction>}
+     */
+    async withdrawNative() {
+        if (!this.signer) throw new Error('Signer required');
+        return await this.contract.withdrawNative();
+    }
+
+    /**
+     * Withdraw tokens to treasury (owner only)
+     * @param {string} tokenAddress Token to withdraw
+     * @returns {Promise<ethers.ContractTransaction>}
+     */
+    async withdrawToken(tokenAddress) {
+        if (!this.signer) throw new Error('Signer required');
+        return await this.contract.withdrawToken(tokenAddress);
+    }
+
+    // ============ UTILITY FUNCTIONS ============
+
+    /**
+     * Generate referral link
+     * @param {string} referrerAddress Referrer wallet address
+     * @param {string} baseUrl Base URL for the purchase page
+     * @returns {string} Referral link
+     */
+    generateReferralLink(referrerAddress, baseUrl = 'https://quantvestrix.com/buy') {
+        return `${baseUrl}?ref=${referrerAddress}`;
+    }
+
+    /**
+     * Parse referral code from URL
+     * @param {string} url URL with referral parameter
+     * @returns {string|null} Referrer address or null
+     */
+    parseReferralCode(url) {
+        try {
+            const parsed = new URL(url);
+            const ref = parsed.searchParams.get('ref');
+            if (ref && ethers.utils.isAddress(ref)) {
+                return ref;
+            }
+        } catch {}
+        return null;
+    }
+
+    /**
+     * Format purchase summary
+     * @param {string|number} qvtxAmount QVTX amount to buy
+     * @param {string} [referrer] Optional referrer
+     * @returns {Promise<Object>} Purchase summary
+     */
+    async getPurchaseSummary(qvtxAmount, referrer = null) {
+        const amount = ethers.utils.parseEther(qvtxAmount.toString());
+        const refAddr = referrer || ethers.constants.AddressZero;
+
+        const [nativeCost, limits, discountPercent] = await Promise.all([
+            this.contract.calculateNativeCost(amount, refAddr),
+            this.getPurchaseLimits(),
+            this.contract.referralDiscountPercent()
+        ]);
+
+        const discount = referrer ? discountPercent.toNumber() / 100 : 0;
+
+        return {
+            qvtxAmount: qvtxAmount.toString(),
+            nativeCost: ethers.utils.formatEther(nativeCost),
+            referrer: referrer || 'None',
+            discount: `${discount}%`,
+            remainingSupply: limits.remainingSupply,
+            withinLimits: parseFloat(qvtxAmount) >= parseFloat(limits.minPurchase) &&
+                         parseFloat(qvtxAmount) <= parseFloat(limits.maxPurchase)
+        };
+    }
+}
+
+// Factory functions
+function createDirectPurchase(options) {
+    return new QVTXDirectPurchase(options);
+}
+
+// Export
+module.exports = {
+    QVTXDirectPurchase,
+    createDirectPurchase,
+    PURCHASE_CONTRACTS,
+    STABLECOINS,
+    DirectPurchaseABI
+};

package/rewards/index.js

@@ -0,0 +1,71 @@
+'use strict';
+
+/**
+ * QVTX Rewards Module
+ * Cross-chain rewards distribution utilities
+ */
+
+class QVTXRewards {
+    constructor(web3, contractAddress, abi) {
+        this.web3 = web3;
+        this.contractAddress = contractAddress;
+        this.abi = abi || require('./QVTXRewardsABI.json');
+        this.contract = null;
+    }
+
+    async init() {
+        if (!this.web3) throw new Error('Web3 instance required');
+        this.contract = new this.web3.eth.Contract(this.abi, this.contractAddress);
+        return this;
+    }
+
+    async getStake(address) {
+        return await this.contract.methods.stakes(address).call();
+    }
+
+    async getEarned(address) {
+        return await this.contract.methods.earned(address).call();
+    }
+
+    async getTotalStaked() {
+        return await this.contract.methods.totalStaked().call();
+    }
+
+    async getRewardRate() {
+        return await this.contract.methods.rewardRate().call();
+    }
+
+    async stake(amount, fromAddress, privateKey) {
+        const tx = this.contract.methods.stake(amount);
+        return await this._sendTransaction(tx, fromAddress, privateKey);
+    }
+
+    async withdraw(amount, fromAddress, privateKey) {
+        const tx = this.contract.methods.withdraw(amount);
+        return await this._sendTransaction(tx, fromAddress, privateKey);
+    }
+
+    async claimReward(fromAddress, privateKey) {
+        const tx = this.contract.methods.claimReward();
+        return await this._sendTransaction(tx, fromAddress, privateKey);
+    }
+
+    async _sendTransaction(tx, fromAddress, privateKey) {
+        const gas = await tx.estimateGas({ from: fromAddress });
+        const data = tx.encodeABI();
+        const nonce = await this.web3.eth.getTransactionCount(fromAddress);
+        const gasPrice = await this.web3.eth.getGasPrice();
+
+        const signedTx = await this.web3.eth.accounts.signTransaction({
+            to: this.contractAddress,
+            data,
+            gas: Math.ceil(gas * 1.2),
+            gasPrice,
+            nonce
+        }, privateKey);
+
+        return await this.web3.eth.sendSignedTransaction(signedTx.rawTransaction);
+    }
+}
+
+module.exports = QVTXRewards;