qvtx-developer-kit 1.0.0 → 1.1.0

package/templates/contract/ERC20Token.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+/**
+ * @title QVTX ERC20 Token Template
+ * @dev Standard ERC20 implementation with minting and burning
+ */
+contract ERC20Token {
+    string public name;
+    string public symbol;
+    uint8 public constant decimals = 18;
+    uint256 public totalSupply;
+    address public owner;
+
+    mapping(address => uint256) private _balances;
+    mapping(address => mapping(address => uint256)) private _allowances;
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "ERC20: caller is not the owner");
+        _;
+    }
+
+    constructor(string memory _name, string memory _symbol, uint256 _initialSupply) {
+        name = _name;
+        symbol = _symbol;
+        owner = msg.sender;
+        _mint(msg.sender, _initialSupply * 10 ** decimals);
+    }
+
+    function balanceOf(address account) public view returns (uint256) {
+        return _balances[account];
+    }
+
+    function transfer(address to, uint256 amount) public returns (bool) {
+        _transfer(msg.sender, to, amount);
+        return true;
+    }
+
+    function allowance(address tokenOwner, address spender) public view returns (uint256) {
+        return _allowances[tokenOwner][spender];
+    }
+
+    function approve(address spender, uint256 amount) public returns (bool) {
+        _approve(msg.sender, spender, amount);
+        return true;
+    }
+
+    function transferFrom(address from, address to, uint256 amount) public returns (bool) {
+        uint256 currentAllowance = _allowances[from][msg.sender];
+        require(currentAllowance >= amount, "ERC20: insufficient allowance");
+        unchecked {
+            _approve(from, msg.sender, currentAllowance - amount);
+        }
+        _transfer(from, to, amount);
+        return true;
+    }
+
+    function mint(address to, uint256 amount) public onlyOwner {
+        _mint(to, amount);
+    }
+
+    function burn(uint256 amount) public {
+        _burn(msg.sender, amount);
+    }
+
+    function transferOwnership(address newOwner) public onlyOwner {
+        require(newOwner != address(0), "ERC20: new owner is zero address");
+        emit OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+    }
+
+    function _transfer(address from, address to, uint256 amount) internal {
+        require(from != address(0), "ERC20: transfer from zero address");
+        require(to != address(0), "ERC20: transfer to zero address");
+        require(_balances[from] >= amount, "ERC20: insufficient balance");
+
+        unchecked {
+            _balances[from] -= amount;
+            _balances[to] += amount;
+        }
+
+        emit Transfer(from, to, amount);
+    }
+
+    function _mint(address account, uint256 amount) internal {
+        require(account != address(0), "ERC20: mint to zero address");
+        totalSupply += amount;
+        unchecked {
+            _balances[account] += amount;
+        }
+        emit Transfer(address(0), account, amount);
+    }
+
+    function _burn(address account, uint256 amount) internal {
+        require(account != address(0), "ERC20: burn from zero address");
+        require(_balances[account] >= amount, "ERC20: burn exceeds balance");
+
+        unchecked {
+            _balances[account] -= amount;
+            totalSupply -= amount;
+        }
+
+        emit Transfer(account, address(0), amount);
+    }
+
+    function _approve(address tokenOwner, address spender, uint256 amount) internal {
+        require(tokenOwner != address(0), "ERC20: approve from zero address");
+        require(spender != address(0), "ERC20: approve to zero address");
+        _allowances[tokenOwner][spender] = amount;
+        emit Approval(tokenOwner, spender, amount);
+    }
+}

package/templates/dapp/index.html

@@ -0,0 +1,93 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>QVTX DApp Template</title>
+    <script src="https://cdn.jsdelivr.net/npm/web3@1.8.2/dist/web3.min.js"></script>
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0a0a0a; color: #fff; min-height: 100vh; }
+        .container { max-width: 800px; margin: 0 auto; padding: 40px 20px; }
+        h1 { font-size: 2.5rem; margin-bottom: 10px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
+        .subtitle { color: #888; margin-bottom: 40px; }
+        .card { background: #111; border-radius: 12px; padding: 24px; margin-bottom: 20px; border: 1px solid #222; }
+        .card h2 { font-size: 1.2rem; margin-bottom: 16px; color: #667eea; }
+        button { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: #fff; border: none; padding: 12px 24px; border-radius: 8px; cursor: pointer; font-size: 1rem; transition: transform 0.2s; }
+        button:hover { transform: scale(1.02); }
+        button:disabled { opacity: 0.5; cursor: not-allowed; }
+        .account { font-family: monospace; font-size: 0.9rem; color: #888; word-break: break-all; }
+        .balance { font-size: 2rem; font-weight: bold; margin: 10px 0; }
+        .network { display: inline-block; padding: 4px 12px; background: #222; border-radius: 20px; font-size: 0.8rem; color: #667eea; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>QVTX DApp</h1>
+        <p class="subtitle">Built with QuantVestrix Developer Kit</p>
+
+        <div class="card">
+            <h2>Wallet Connection</h2>
+            <button id="connectBtn" onclick="connectWallet()">Connect Wallet</button>
+            <div id="walletInfo" style="display:none; margin-top: 20px;">
+                <p class="account" id="account"></p>
+                <p class="balance" id="balance">0.00 ETH</p>
+                <span class="network" id="network"></span>
+            </div>
+        </div>
+
+        <div class="card">
+            <h2>QVTX Token</h2>
+            <p>Name: QuantVestrix</p>
+            <p>Symbol: QVTX</p>
+            <p>Total Supply: 1,000,000,000</p>
+        </div>
+    </div>
+
+    <script>
+        let web3;
+        let account;
+
+        async function connectWallet() {
+            if (typeof window.ethereum === 'undefined') {
+                alert('Please install MetaMask!');
+                return;
+            }
+
+            try {
+                document.getElementById('connectBtn').disabled = true;
+                document.getElementById('connectBtn').textContent = 'Connecting...';
+
+                const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' });
+                account = accounts[0];
+                web3 = new Web3(window.ethereum);
+
+                document.getElementById('account').textContent = account;
+                document.getElementById('walletInfo').style.display = 'block';
+                document.getElementById('connectBtn').textContent = 'Connected';
+
+                // Get balance
+                const balance = await web3.eth.getBalance(account);
+                const ethBalance = web3.utils.fromWei(balance, 'ether');
+                document.getElementById('balance').textContent = parseFloat(ethBalance).toFixed(4) + ' ETH';
+
+                // Get network
+                const chainId = await web3.eth.getChainId();
+                const networks = { 1: 'Ethereum', 56: 'BSC', 137: 'Polygon', 42161: 'Arbitrum', 43114: 'Avalanche' };
+                document.getElementById('network').textContent = networks[chainId] || 'Chain ' + chainId;
+
+                // Listen for account changes
+                window.ethereum.on('accountsChanged', (accounts) => {
+                    if (accounts.length === 0) location.reload();
+                    else location.reload();
+                });
+
+            } catch (error) {
+                console.error(error);
+                document.getElementById('connectBtn').disabled = false;
+                document.getElementById('connectBtn').textContent = 'Connect Wallet';
+            }
+        }
+    </script>
+</body>
+</html>

package/test/index.js

@@ -0,0 +1,182 @@
+'use strict';
+
+/**
+ * QVTX Testing Utilities
+ * Helpers for testing QVTX applications
+ */
+
+const { ethers } = require('ethers');
+const Web3 = require('web3');
+
+class QVTXTestUtils {
+    constructor(config = {}) {
+        this.rpcUrl = config.rpcUrl || 'http://127.0.0.1:8545';
+        this.web3 = new Web3(this.rpcUrl);
+        this.provider = new ethers.providers.JsonRpcProvider(this.rpcUrl);
+    }
+
+    // Generate random test wallet
+    generateWallet() {
+        const wallet = ethers.Wallet.createRandom();
+        return {
+            address: wallet.address,
+            privateKey: wallet.privateKey,
+            mnemonic: wallet.mnemonic.phrase
+        };
+    }
+
+    // Generate multiple test wallets
+    generateWallets(count) {
+        return Array(count).fill(null).map(() => this.generateWallet());
+    }
+
+    // Fund test account (for local networks)
+    async fundAccount(address, amount = '10') {
+        const accounts = await this.web3.eth.getAccounts();
+        const funder = accounts[0];
+
+        await this.web3.eth.sendTransaction({
+            from: funder,
+            to: address,
+            value: this.web3.utils.toWei(amount, 'ether')
+        });
+
+        return await this.web3.eth.getBalance(address);
+    }
+
+    // Mine blocks (Hardhat/Ganache)
+    async mineBlocks(count) {
+        for (let i = 0; i < count; i++) {
+            await this.provider.send('evm_mine', []);
+        }
+    }
+
+    // Increase time (Hardhat/Ganache)
+    async increaseTime(seconds) {
+        await this.provider.send('evm_increaseTime', [seconds]);
+        await this.provider.send('evm_mine', []);
+    }
+
+    // Snapshot blockchain state
+    async snapshot() {
+        return await this.provider.send('evm_snapshot', []);
+    }
+
+    // Revert to snapshot
+    async revert(snapshotId) {
+        await this.provider.send('evm_revert', [snapshotId]);
+    }
+
+    // Deploy contract helper
+    async deployContract(abi, bytecode, args = [], signer) {
+        const factory = new ethers.ContractFactory(abi, bytecode, signer);
+        const contract = await factory.deploy(...args);
+        await contract.deployed();
+        return contract;
+    }
+
+    // Parse wei to ether string
+    toEther(wei) {
+        return ethers.utils.formatEther(wei);
+    }
+
+    // Parse ether to wei
+    toWei(ether) {
+        return ethers.utils.parseEther(ether.toString());
+    }
+
+    // Wait for transaction
+    async waitForTx(txPromise) {
+        const tx = await txPromise;
+        return await tx.wait();
+    }
+
+    // Get event from receipt
+    getEvent(receipt, eventName) {
+        const event = receipt.events?.find(e => e.event === eventName);
+        return event ? event.args : null;
+    }
+
+    // Assert transaction reverts
+    async expectRevert(txPromise, message) {
+        try {
+            await txPromise;
+            throw new Error('Expected transaction to revert');
+        } catch (error) {
+            if (message && !error.message.includes(message)) {
+                throw new Error(`Expected revert with "${message}" but got "${error.message}"`);
+            }
+            return true;
+        }
+    }
+
+    // Assert approximate equality (for BigNumbers)
+    assertApproxEqual(actual, expected, tolerance = '0.01') {
+        const actualBN = ethers.BigNumber.from(actual);
+        const expectedBN = ethers.BigNumber.from(expected);
+        const toleranceBN = expectedBN.mul(ethers.utils.parseEther(tolerance)).div(ethers.utils.parseEther('1'));
+
+        const diff = actualBN.sub(expectedBN).abs();
+        if (diff.gt(toleranceBN)) {
+            throw new Error(`Values not approximately equal: ${actualBN.toString()} vs ${expectedBN.toString()}`);
+        }
+        return true;
+    }
+
+    // Get gas used from receipt
+    getGasUsed(receipt) {
+        return receipt.gasUsed.toString();
+    }
+
+    // Calculate gas cost in ETH
+    getGasCost(receipt) {
+        const gasUsed = receipt.gasUsed;
+        const gasPrice = receipt.effectiveGasPrice;
+        return ethers.utils.formatEther(gasUsed.mul(gasPrice));
+    }
+}
+
+// Test fixtures
+const fixtures = {
+    // Sample addresses
+    ZERO_ADDRESS: '0x0000000000000000000000000000000000000000',
+    DEAD_ADDRESS: '0x000000000000000000000000000000000000dEaD',
+
+    // Sample amounts
+    ONE_ETHER: ethers.utils.parseEther('1'),
+    TEN_ETHER: ethers.utils.parseEther('10'),
+    HUNDRED_ETHER: ethers.utils.parseEther('100'),
+    THOUSAND_ETHER: ethers.utils.parseEther('1000'),
+    MILLION_ETHER: ethers.utils.parseEther('1000000'),
+
+    // Time constants
+    ONE_MINUTE: 60,
+    ONE_HOUR: 3600,
+    ONE_DAY: 86400,
+    ONE_WEEK: 604800,
+    ONE_MONTH: 2592000,
+    ONE_YEAR: 31536000
+};
+
+// Mock contract responses for testing
+class MockContract {
+    constructor(methods = {}) {
+        this.methods = {};
+        this.events = {};
+
+        for (const [name, returnValue] of Object.entries(methods)) {
+            this.methods[name] = (...args) => ({
+                call: async () => returnValue,
+                send: async () => ({ transactionHash: '0x' + '1'.repeat(64), events: {} }),
+                estimateGas: async () => 100000,
+                encodeABI: () => '0x'
+            });
+        }
+    }
+}
+
+module.exports = {
+    QVTXTestUtils,
+    fixtures,
+    MockContract
+};

package/tools/build-tool.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs-extra');
+
+async function run(options) {
+    console.log('\nQVTX Build Tool\n');
+
+    const production = options.production || false;
+    console.log(`Mode: ${production ? 'production' : 'development'}\n`);
+
+    // Check for hardhat - compile contracts
+    const hardhatConfig = path.join(process.cwd(), 'hardhat.config.js');
+    if (await fs.pathExists(hardhatConfig)) {
+        console.log('Compiling smart contracts...\n');
+
+        const child = spawn('npx', ['hardhat', 'compile'], {
+            stdio: 'inherit',
+            cwd: process.cwd(),
+            shell: true
+        });
+
+        child.on('close', async (code) => {
+            if (code === 0) {
+                console.log('\nContracts compiled successfully!');
+
+                // Copy artifacts
+                const artifactsDir = path.join(process.cwd(), 'artifacts');
+                const buildDir = path.join(process.cwd(), 'build');
+
+                if (await fs.pathExists(artifactsDir)) {
+                    await fs.ensureDir(buildDir);
+                    await fs.copy(artifactsDir, path.join(buildDir, 'artifacts'));
+                    console.log('Artifacts copied to build/\n');
+                }
+            } else {
+                console.log(`\nBuild failed with code ${code}\n`);
+            }
+        });
+        return;
+    }
+
+    // Check for package.json build script
+    const packagePath = path.join(process.cwd(), 'package.json');
+    if (await fs.pathExists(packagePath)) {
+        const pkg = await fs.readJson(packagePath);
+        if (pkg.scripts?.build) {
+            console.log('Running npm build script...\n');
+            const child = spawn('npm', ['run', 'build'], {
+                stdio: 'inherit',
+                cwd: process.cwd(),
+                shell: true
+            });
+            return;
+        }
+    }
+
+    console.log('No build configuration found');
+    console.log('Add a hardhat.config.js or build script to package.json\n');
+}
+
+module.exports = { run };

package/tools/create-template.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+
+async function run(type, name) {
+    const componentName = name || `qvtx-${type}`;
+
+    console.log(`\nCreating ${type}: ${componentName}\n`);
+
+    if (type === 'dapp') {
+        await createDapp(componentName);
+    } else if (type === 'contract') {
+        await createContract(componentName);
+    } else {
+        console.error(`Unknown type: ${type}. Use 'dapp' or 'contract'`);
+        process.exit(1);
+    }
+}
+
+async function createDapp(name) {
+    const targetDir = path.join(process.cwd(), name);
+    await fs.ensureDir(targetDir);
+    await fs.ensureDir(path.join(targetDir, 'src'));
+    await fs.ensureDir(path.join(targetDir, 'public'));
+
+    const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${name} - QVTX DApp</title>
+    <script src="https://cdn.jsdelivr.net/npm/web3@1.8.2/dist/web3.min.js"></script>
+</head>
+<body>
+    <div id="app">
+        <h1>${name}</h1>
+        <p>Built with QVTX Developer Kit</p>
+        <button id="connectBtn">Connect Wallet</button>
+        <div id="account"></div>
+    </div>
+    <script src="src/app.js"></script>
+</body>
+</html>
+`;
+    await fs.writeFile(path.join(targetDir, 'public/index.html'), indexHtml);
+
+    const appJs = `// QVTX DApp
+let web3;
+let account;
+
+document.getElementById('connectBtn').addEventListener('click', connectWallet);
+
+async function connectWallet() {
+    if (typeof window.ethereum !== 'undefined') {
+        try {
+            const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' });
+            account = accounts[0];
+            web3 = new Web3(window.ethereum);
+            document.getElementById('account').textContent = 'Connected: ' + account;
+            console.log('Connected:', account);
+        } catch (error) {
+            console.error('Connection failed:', error);
+        }
+    } else {
+        alert('Please install MetaMask!');
+    }
+}
+`;
+    await fs.writeFile(path.join(targetDir, 'src/app.js'), appJs);
+
+    console.log(`DApp created: ${targetDir}`);
+    console.log('\nTo run: open public/index.html in a browser\n');
+}
+
+async function createContract(name) {
+    const contractsDir = path.join(process.cwd(), 'contracts');
+    await fs.ensureDir(contractsDir);
+
+    const contractName = name.charAt(0).toUpperCase() + name.slice(1);
+    const contract = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+/**
+ * @title ${contractName}
+ * @dev QVTX Smart Contract
+ */
+contract ${contractName} {
+    address public owner;
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+
+    constructor() {
+        owner = msg.sender;
+        emit OwnershipTransferred(address(0), msg.sender);
+    }
+
+    function transferOwnership(address newOwner) public onlyOwner {
+        require(newOwner != address(0), "Invalid address");
+        emit OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+    }
+}
+`;
+    const filePath = path.join(contractsDir, `${contractName}.sol`);
+    await fs.writeFile(filePath, contract);
+
+    console.log(`Contract created: ${filePath}\n`);
+}
+
+module.exports = { run };

package/tools/deploy-tool.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+
+async function run(contract, options) {
+    const network = options.network || 'ethereum';
+    const env = options.env || 'testnet';
+
+    console.log(`\nQVTX Deploy Tool`);
+    console.log(`================`);
+    console.log(`Network: ${network}`);
+    console.log(`Environment: ${env}`);
+    console.log(`Contract: ${contract || 'all'}\n`);
+
+    // Check for hardhat
+    const hardhatConfigPath = path.join(process.cwd(), 'hardhat.config.js');
+    if (!await fs.pathExists(hardhatConfigPath)) {
+        console.error('Error: hardhat.config.js not found');
+        console.log('Run "qvtx init" first or create a hardhat config\n');
+        process.exit(1);
+    }
+
+    // Check for contracts
+    const contractsDir = path.join(process.cwd(), 'contracts');
+    if (!await fs.pathExists(contractsDir)) {
+        console.error('Error: contracts/ directory not found\n');
+        process.exit(1);
+    }
+
+    const contracts = await fs.readdir(contractsDir);
+    const solFiles = contracts.filter(f => f.endsWith('.sol'));
+
+    if (solFiles.length === 0) {
+        console.error('Error: No Solidity contracts found\n');
+        process.exit(1);
+    }
+
+    console.log('Found contracts:');
+    solFiles.forEach(f => console.log(`  - ${f}`));
+    console.log('');
+
+    // Check for private key
+    if (!process.env.PRIVATE_KEY) {
+        console.log('Warning: PRIVATE_KEY environment variable not set');
+        console.log('Set it with: export PRIVATE_KEY=your_private_key\n');
+        console.log('Deployment aborted - no private key\n');
+        return;
+    }
+
+    console.log('To deploy, run:');
+    console.log(`  npx hardhat run scripts/deploy.js --network ${network}\n`);
+}
+
+module.exports = { run };