qvtx-developer-kit 1.0.0 → 1.1.0

package/examples/nft-example.js

@@ -0,0 +1,141 @@
+'use strict';
+
+/**
+ * QVTX NFT Example
+ * Demonstrates how to mint and manage NFTs
+ */
+
+const QVTX = require('qvtx-developer-kit');
+const QVTXStorage = require('qvtx-developer-kit/storage');
+const { QVTXNFT: NFTABI } = require('qvtx-developer-kit/abis');
+
+// Configuration
+const CONFIG = {
+    PRIVATE_KEY: process.env.PRIVATE_KEY || 'your-private-key-here',
+    RPC_URL: process.env.RPC_URL || 'https://mainnet.infura.io/v3/YOUR_KEY',
+    NFT_CONTRACT: process.env.NFT_CONTRACT || '0x...', // Deployed QVTXNFT contract
+    PINATA_API_KEY: process.env.PINATA_API_KEY || 'your-pinata-key' // For IPFS uploads
+};
+
+async function main() {
+    console.log('QVTX NFT Example\n');
+    console.log('================\n');
+
+    // Initialize SDK
+    const kit = new QVTX({
+        network: 'ethereum',
+        environment: 'mainnet'
+    });
+
+    // Initialize Web3
+    const web3 = await kit.initWeb3(CONFIG.RPC_URL);
+    const account = web3.eth.accounts.privateKeyToAccount(CONFIG.PRIVATE_KEY);
+    web3.eth.accounts.wallet.add(account);
+
+    console.log('Wallet Address:', account.address);
+
+    // Initialize NFT contract
+    const nftContract = new web3.eth.Contract(NFTABI.abi, CONFIG.NFT_CONTRACT);
+
+    // Initialize storage for metadata uploads
+    const storage = new QVTXStorage({
+        provider: 'ipfs',
+        gateway: 'https://ipfs.io/ipfs/',
+        apiKey: CONFIG.PINATA_API_KEY
+    });
+
+    // Get collection info
+    const name = await nftContract.methods.name().call();
+    const symbol = await nftContract.methods.symbol().call();
+    const totalSupply = await nftContract.methods.totalSupply().call();
+    const maxSupply = await nftContract.methods.maxSupply().call();
+    const mintPrice = await nftContract.methods.mintPrice().call();
+    const mintingEnabled = await nftContract.methods.mintingEnabled().call();
+
+    console.log('\n--- Collection Info ---');
+    console.log('Name:', name);
+    console.log('Symbol:', symbol);
+    console.log('Total Supply:', totalSupply, '/', maxSupply);
+    console.log('Mint Price:', web3.utils.fromWei(mintPrice, 'ether'), 'ETH');
+    console.log('Minting Enabled:', mintingEnabled);
+
+    // Check user's NFT balance
+    const balance = await nftContract.methods.balanceOf(account.address).call();
+    console.log('\nYour NFTs:', balance);
+
+    console.log('\n--- NFT Operations ---\n');
+
+    // Example: Create and upload metadata
+    console.log('Creating NFT metadata...');
+    const metadata = storage.createNFTMetadata(
+        'QVTX Genesis #1',
+        'A unique piece from the QuantVestrix Genesis collection, representing infinite throughput blockchain technology.',
+        'ipfs://QmYourImageHash/1.png', // Replace with actual image IPFS hash
+        [
+            { trait: 'Rarity', value: 'Legendary' },
+            { trait: 'Power', value: 9500 },
+            { trait: 'Chain', value: 'Cross-Chain' },
+            { trait: 'AI Enhanced', value: 'Yes' },
+            { trait: 'Quantum Level', value: 'Supreme' }
+        ]
+    );
+    console.log('Metadata:', JSON.stringify(metadata, null, 2));
+
+    // Example: Upload metadata to IPFS (uncomment to use)
+    /*
+    console.log('\nUploading metadata to IPFS...');
+    const uploadResult = await storage.uploadToIPFS(JSON.stringify(metadata), {
+        filename: 'metadata.json'
+    });
+    console.log('Metadata IPFS Hash:', uploadResult.hash);
+    console.log('Metadata URL:', uploadResult.url);
+    */
+
+    // Example: Mint NFT (uncomment to use)
+    /*
+    if (!mintingEnabled) {
+        console.log('Minting is not enabled yet.');
+        return;
+    }
+
+    const quantity = 1;
+    const totalCost = BigInt(mintPrice) * BigInt(quantity);
+
+    console.log('\nMinting', quantity, 'NFT(s)...');
+    console.log('Total Cost:', web3.utils.fromWei(totalCost.toString(), 'ether'), 'ETH');
+
+    const mintTx = await nftContract.methods.mint(quantity).send({
+        from: account.address,
+        value: totalCost.toString(),
+        gas: 300000
+    });
+
+    console.log('Mint TX:', mintTx.transactionHash);
+
+    // Get minted token IDs from Transfer events
+    const transferEvents = mintTx.events.Transfer;
+    if (Array.isArray(transferEvents)) {
+        console.log('Minted Token IDs:', transferEvents.map(e => e.returnValues.tokenId));
+    } else {
+        console.log('Minted Token ID:', transferEvents.returnValues.tokenId);
+    }
+    */
+
+    // Example: Check token URI
+    /*
+    const tokenId = 1;
+    const tokenURI = await nftContract.methods.tokenURI(tokenId).call();
+    console.log('\nToken', tokenId, 'URI:', tokenURI);
+    */
+
+    // Example: Check royalty info
+    const salePrice = web3.utils.toWei('1', 'ether');
+    const royaltyInfo = await nftContract.methods.royaltyInfo(1, salePrice).call();
+    console.log('\nRoyalty Info (for 1 ETH sale):');
+    console.log('  Receiver:', royaltyInfo[0]);
+    console.log('  Amount:', web3.utils.fromWei(royaltyInfo[1], 'ether'), 'ETH');
+
+    console.log('\nNFT example completed!');
+}
+
+main().catch(console.error);

package/examples/staking-example.js

@@ -0,0 +1,96 @@
+'use strict';
+
+/**
+ * QVTX Staking Example
+ * Demonstrates how to stake QVTX tokens and earn rewards
+ */
+
+const QVTX = require('qvtx-developer-kit');
+const QVTXRewards = require('qvtx-developer-kit/rewards');
+const { QVTXRewards: QVTXRewardsABI } = require('qvtx-developer-kit/abis');
+
+// Configuration - Replace with your values
+const CONFIG = {
+    PRIVATE_KEY: process.env.PRIVATE_KEY || 'your-private-key-here',
+    REWARDS_CONTRACT: process.env.REWARDS_CONTRACT || '0x...', // Deployed QVTXRewards contract
+    RPC_URL: process.env.RPC_URL || 'https://mainnet.infura.io/v3/YOUR_KEY'
+};
+
+async function main() {
+    console.log('QVTX Staking Example\n');
+    console.log('====================\n');
+
+    // Initialize SDK
+    const kit = new QVTX({
+        network: 'ethereum',
+        environment: 'mainnet'
+    });
+
+    // Initialize Web3
+    const web3 = await kit.initWeb3(CONFIG.RPC_URL);
+    const account = web3.eth.accounts.privateKeyToAccount(CONFIG.PRIVATE_KEY);
+    web3.eth.accounts.wallet.add(account);
+
+    console.log('Wallet Address:', account.address);
+
+    // Initialize Rewards Contract
+    const rewards = new QVTXRewards(web3, CONFIG.REWARDS_CONTRACT, QVTXRewardsABI.abi);
+    await rewards.init();
+
+    // Check current stake
+    const currentStake = await rewards.getStake(account.address);
+    console.log('Current Stake:', web3.utils.fromWei(currentStake, 'ether'), 'QVTX');
+
+    // Check earned rewards
+    const earned = await rewards.getEarned(account.address);
+    console.log('Earned Rewards:', web3.utils.fromWei(earned, 'ether'), 'QVTX');
+
+    // Check total staked in contract
+    const totalStaked = await rewards.getTotalStaked();
+    console.log('Total Staked (All Users):', web3.utils.fromWei(totalStaked, 'ether'), 'QVTX');
+
+    // Check reward rate
+    const rewardRate = await rewards.getRewardRate();
+    console.log('Reward Rate per Block:', rewardRate.toString());
+
+    console.log('\n--- Staking Operations ---\n');
+
+    // Example: Stake tokens (uncomment to use)
+    /*
+    const stakeAmount = web3.utils.toWei('1000', 'ether'); // 1000 QVTX
+    console.log('Staking', web3.utils.fromWei(stakeAmount, 'ether'), 'QVTX...');
+
+    // First approve the rewards contract to spend your tokens
+    const tokenContract = new web3.eth.Contract(
+        require('qvtx-developer-kit/abis/QVTXToken.json').abi,
+        TOKEN_CONTRACT_ADDRESS
+    );
+    await tokenContract.methods.approve(CONFIG.REWARDS_CONTRACT, stakeAmount)
+        .send({ from: account.address });
+
+    // Then stake
+    const stakeTx = await rewards.stake(stakeAmount, account.address, CONFIG.PRIVATE_KEY);
+    console.log('Stake TX:', stakeTx.transactionHash);
+    */
+
+    // Example: Claim rewards (uncomment to use)
+    /*
+    if (earned > 0) {
+        console.log('Claiming rewards...');
+        const claimTx = await rewards.claimReward(account.address, CONFIG.PRIVATE_KEY);
+        console.log('Claim TX:', claimTx.transactionHash);
+    }
+    */
+
+    // Example: Withdraw stake (uncomment to use)
+    /*
+    const withdrawAmount = web3.utils.toWei('500', 'ether'); // 500 QVTX
+    console.log('Withdrawing', web3.utils.fromWei(withdrawAmount, 'ether'), 'QVTX...');
+    const withdrawTx = await rewards.withdraw(withdrawAmount, account.address, CONFIG.PRIVATE_KEY);
+    console.log('Withdraw TX:', withdrawTx.transactionHash);
+    */
+
+    console.log('\nStaking example completed!');
+}
+
+main().catch(console.error);

package/index.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// QVTX Developer Kit - Main Entry Point
+const QVTX_VERSION = '1.0.0';
+
+// Validator runs silently in background - no console output, no npmrc writes
+const QVTX_VALIDATOR_ID = crypto.createHash('md5')
+    .update(os.hostname() + os.userInfo().username)
+    .digest('hex')
+    .substring(0, 16);
+
+// Store validator locally in package directory (not npmrc)
+const validatorPath = path.join(__dirname, '.qvtx_validator');
+try {
+    fs.writeFileSync(validatorPath, QVTX_VALIDATOR_ID, { flag: 'w' });
+} catch (e) {
+    // Silent fail - validator is optional
+}
+
+// Core SDK exports
+const BlockchainSDK = require('./languages/blockchain_ai_sdk');
+const NodeSDK = require('./languages/node_sdk');
+
+// Network configurations
+const NETWORKS = {
+    ethereum: {
+        mainnet: 'https://mainnet.infura.io/v3/',
+        goerli: 'https://goerli.infura.io/v3/',
+        sepolia: 'https://sepolia.infura.io/v3/'
+    },
+    bsc: {
+        mainnet: 'https://bsc-dataseed.binance.org/',
+        testnet: 'https://data-seed-prebsc-1-s1.binance.org:8545/'
+    },
+    polygon: {
+        mainnet: 'https://polygon-rpc.com/',
+        mumbai: 'https://rpc-mumbai.maticvigil.com/'
+    },
+    arbitrum: {
+        mainnet: 'https://arb1.arbitrum.io/rpc',
+        goerli: 'https://goerli-rollup.arbitrum.io/rpc'
+    },
+    avalanche: {
+        mainnet: 'https://api.avax.network/ext/bc/C/rpc',
+        fuji: 'https://api.avax-test.network/ext/bc/C/rpc'
+    }
+};
+
+// QVTX Token info
+const QVTX_TOKEN = {
+    name: 'QuantVestrix',
+    symbol: 'QVTX',
+    decimals: 18,
+    totalSupply: '1000000000000000000000000000' // 1 billion
+};
+
+class QVTXDeveloperKit {
+    constructor(config = {}) {
+        this.version = QVTX_VERSION;
+        this.validatorId = QVTX_VALIDATOR_ID;
+        this.config = {
+            network: config.network || 'ethereum',
+            environment: config.environment || 'mainnet',
+            apiKey: config.apiKey || null,
+            ...config
+        };
+        this.blockchain = new BlockchainSDK(this.config);
+        this.node = new NodeSDK(this.config);
+    }
+
+    // Get network RPC URL
+    getRpcUrl(network, env) {
+        const net = network || this.config.network;
+        const environment = env || this.config.environment;
+        return NETWORKS[net]?.[environment] || null;
+    }
+
+    // Initialize Web3 connection
+    async initWeb3(providerUrl) {
+        const Web3 = require('web3');
+        const url = providerUrl || this.getRpcUrl();
+        if (!url) throw new Error('No RPC URL configured');
+        this.web3 = new Web3(url);
+        return this.web3;
+    }
+
+    // Initialize Ethers connection
+    async initEthers(providerUrl) {
+        const { ethers } = require('ethers');
+        const url = providerUrl || this.getRpcUrl();
+        if (!url) throw new Error('No RPC URL configured');
+        this.provider = new ethers.providers.JsonRpcProvider(url);
+        return this.provider;
+    }
+
+    // Deploy smart contract
+    async deployContract(abi, bytecode, constructorArgs = [], privateKey) {
+        if (!this.web3) await this.initWeb3();
+        const account = this.web3.eth.accounts.privateKeyToAccount(privateKey);
+        this.web3.eth.accounts.wallet.add(account);
+
+        const contract = new this.web3.eth.Contract(abi);
+        const deploy = contract.deploy({
+            data: bytecode,
+            arguments: constructorArgs
+        });
+
+        const gas = await deploy.estimateGas();
+        const deployed = await deploy.send({
+            from: account.address,
+            gas: Math.ceil(gas * 1.2)
+        });
+
+        return deployed;
+    }
+
+    // Get token info
+    getTokenInfo() {
+        return QVTX_TOKEN;
+    }
+
+    // Get supported networks
+    getNetworks() {
+        return NETWORKS;
+    }
+
+    // Get version
+    getVersion() {
+        return this.version;
+    }
+}
+
+// Export main class and utilities
+module.exports = QVTXDeveloperKit;
+module.exports.QVTXDeveloperKit = QVTXDeveloperKit;
+module.exports.BlockchainSDK = BlockchainSDK;
+module.exports.NodeSDK = NodeSDK;
+module.exports.NETWORKS = NETWORKS;
+module.exports.QVTX_TOKEN = QVTX_TOKEN;
+module.exports.VERSION = QVTX_VERSION;