qvtx-developer-kit 1.0.0 → 1.1.0

package/languages/solana_sdk.js

@@ -0,0 +1,383 @@
+'use strict';
+
+/**
+ * QuantVestrix QVTX Solana SDK
+ *
+ * Solana blockchain integration for QVTX ecosystem
+ * Supports SPL tokens, NFTs, and cross-chain operations
+ *
+ * @author QuantVestrix Tech Team (07-Tech)
+ * @version 1.0.0
+ */
+
+const {
+    Connection,
+    PublicKey,
+    Keypair,
+    Transaction,
+    SystemProgram,
+    LAMPORTS_PER_SOL,
+    sendAndConfirmTransaction
+} = require('@solana/web3.js');
+
+const {
+    createMint,
+    getMint,
+    getOrCreateAssociatedTokenAccount,
+    mintTo,
+    transfer,
+    getAccount,
+    TOKEN_PROGRAM_ID
+} = require('@solana/spl-token');
+
+class QVTXSolana {
+    constructor(config = {}) {
+        this.network = config.network || 'devnet';
+        this.rpcUrl = config.rpcUrl || this._getDefaultRpcUrl();
+        this.connection = null;
+        this.commitment = config.commitment || 'confirmed';
+
+        console.log('🌊 QVTX Solana SDK Initialized');
+        console.log('📡 Network:', this.network);
+    }
+
+    _getDefaultRpcUrl() {
+        const urls = {
+            'mainnet-beta': 'https://api.mainnet-beta.solana.com',
+            'devnet': 'https://api.devnet.solana.com',
+            'testnet': 'https://api.testnet.solana.com'
+        };
+        return urls[this.network] || urls['devnet'];
+    }
+
+    // Connect to Solana network
+    async connect() {
+        this.connection = new Connection(this.rpcUrl, this.commitment);
+        const version = await this.connection.getVersion();
+        console.log('✅ Connected to Solana');
+        console.log('   Version:', version['solana-core']);
+        return this.connection;
+    }
+
+    // Get connection (auto-connect if needed)
+    async getConnection() {
+        if (!this.connection) {
+            await this.connect();
+        }
+        return this.connection;
+    }
+
+    // Generate new keypair
+    generateKeypair() {
+        const keypair = Keypair.generate();
+        return {
+            publicKey: keypair.publicKey.toString(),
+            secretKey: Buffer.from(keypair.secretKey).toString('hex'),
+            keypair
+        };
+    }
+
+    // Load keypair from secret key
+    loadKeypair(secretKey) {
+        const secretKeyArray = typeof secretKey === 'string'
+            ? Uint8Array.from(Buffer.from(secretKey, 'hex'))
+            : secretKey;
+        return Keypair.fromSecretKey(secretKeyArray);
+    }
+
+    // Get SOL balance
+    async getBalance(publicKey) {
+        const connection = await this.getConnection();
+        const pubKey = typeof publicKey === 'string' ? new PublicKey(publicKey) : publicKey;
+        const balance = await connection.getBalance(pubKey);
+        return balance / LAMPORTS_PER_SOL;
+    }
+
+    // Request airdrop (devnet/testnet only)
+    async requestAirdrop(publicKey, amount = 1) {
+        if (this.network === 'mainnet-beta') {
+            throw new Error('Airdrop not available on mainnet');
+        }
+
+        const connection = await this.getConnection();
+        const pubKey = typeof publicKey === 'string' ? new PublicKey(publicKey) : publicKey;
+
+        console.log(`💰 Requesting ${amount} SOL airdrop...`);
+        const signature = await connection.requestAirdrop(
+            pubKey,
+            amount * LAMPORTS_PER_SOL
+        );
+
+        await connection.confirmTransaction(signature);
+        console.log('✅ Airdrop received!');
+        return signature;
+    }
+
+    // Transfer SOL
+    async transfer(fromKeypair, toPublicKey, amount) {
+        const connection = await this.getConnection();
+        const toPubKey = typeof toPublicKey === 'string' ? new PublicKey(toPublicKey) : toPublicKey;
+
+        console.log(`📤 Transferring ${amount} SOL...`);
+
+        const transaction = new Transaction().add(
+            SystemProgram.transfer({
+                fromPubkey: fromKeypair.publicKey,
+                toPubkey: toPubKey,
+                lamports: amount * LAMPORTS_PER_SOL
+            })
+        );
+
+        const signature = await sendAndConfirmTransaction(
+            connection,
+            transaction,
+            [fromKeypair]
+        );
+
+        console.log('✅ Transfer complete!');
+        console.log('   Signature:', signature);
+        return signature;
+    }
+
+    // Create SPL Token (QVTX on Solana)
+    async createToken(authority, decimals = 9) {
+        const connection = await this.getConnection();
+
+        console.log('🪙 Creating SPL Token...');
+
+        const mint = await createMint(
+            connection,
+            authority,
+            authority.publicKey,
+            authority.publicKey,
+            decimals
+        );
+
+        console.log('✅ Token created!');
+        console.log('   Mint Address:', mint.toString());
+        return mint.toString();
+    }
+
+    // Get token info
+    async getTokenInfo(mintAddress) {
+        const connection = await this.getConnection();
+        const mintPubKey = new PublicKey(mintAddress);
+
+        const mintInfo = await getMint(connection, mintPubKey);
+
+        return {
+            address: mintAddress,
+            decimals: mintInfo.decimals,
+            supply: Number(mintInfo.supply) / Math.pow(10, mintInfo.decimals),
+            mintAuthority: mintInfo.mintAuthority?.toString(),
+            freezeAuthority: mintInfo.freezeAuthority?.toString(),
+            isInitialized: mintInfo.isInitialized
+        };
+    }
+
+    // Create token account
+    async createTokenAccount(mint, owner, payer) {
+        const connection = await this.getConnection();
+        const mintPubKey = new PublicKey(mint);
+        const ownerPubKey = typeof owner === 'string' ? new PublicKey(owner) : owner.publicKey || owner;
+
+        console.log('📦 Creating token account...');
+
+        const tokenAccount = await getOrCreateAssociatedTokenAccount(
+            connection,
+            payer,
+            mintPubKey,
+            ownerPubKey
+        );
+
+        console.log('✅ Token account created!');
+        console.log('   Address:', tokenAccount.address.toString());
+        return tokenAccount.address.toString();
+    }
+
+    // Mint tokens
+    async mintTokens(mint, destination, authority, amount) {
+        const connection = await this.getConnection();
+        const mintPubKey = new PublicKey(mint);
+        const destPubKey = new PublicKey(destination);
+
+        console.log(`🔨 Minting ${amount} tokens...`);
+
+        const mintInfo = await getMint(connection, mintPubKey);
+        const adjustedAmount = amount * Math.pow(10, mintInfo.decimals);
+
+        const signature = await mintTo(
+            connection,
+            authority,
+            mintPubKey,
+            destPubKey,
+            authority,
+            adjustedAmount
+        );
+
+        console.log('✅ Tokens minted!');
+        console.log('   Signature:', signature);
+        return signature;
+    }
+
+    // Transfer tokens
+    async transferTokens(mint, from, to, owner, amount) {
+        const connection = await this.getConnection();
+        const mintPubKey = new PublicKey(mint);
+        const fromPubKey = new PublicKey(from);
+        const toPubKey = new PublicKey(to);
+
+        console.log(`📤 Transferring ${amount} tokens...`);
+
+        const mintInfo = await getMint(connection, mintPubKey);
+        const adjustedAmount = amount * Math.pow(10, mintInfo.decimals);
+
+        const signature = await transfer(
+            connection,
+            owner,
+            fromPubKey,
+            toPubKey,
+            owner,
+            adjustedAmount
+        );
+
+        console.log('✅ Tokens transferred!');
+        console.log('   Signature:', signature);
+        return signature;
+    }
+
+    // Get token balance
+    async getTokenBalance(tokenAccount) {
+        const connection = await this.getConnection();
+        const accountPubKey = new PublicKey(tokenAccount);
+
+        const accountInfo = await getAccount(connection, accountPubKey);
+
+        // Get decimals from mint
+        const mintInfo = await getMint(connection, accountInfo.mint);
+
+        return Number(accountInfo.amount) / Math.pow(10, mintInfo.decimals);
+    }
+
+    // Get recent blockhash
+    async getRecentBlockhash() {
+        const connection = await this.getConnection();
+        const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+        return { blockhash, lastValidBlockHeight };
+    }
+
+    // Get transaction
+    async getTransaction(signature) {
+        const connection = await this.getConnection();
+        return await connection.getTransaction(signature, {
+            maxSupportedTransactionVersion: 0
+        });
+    }
+
+    // Get account info
+    async getAccountInfo(publicKey) {
+        const connection = await this.getConnection();
+        const pubKey = typeof publicKey === 'string' ? new PublicKey(publicKey) : publicKey;
+        return await connection.getAccountInfo(pubKey);
+    }
+
+    // Monitor transaction
+    async waitForConfirmation(signature, timeout = 60000) {
+        const connection = await this.getConnection();
+        const startTime = Date.now();
+
+        while (Date.now() - startTime < timeout) {
+            const status = await connection.getSignatureStatus(signature);
+
+            if (status.value?.confirmationStatus === 'confirmed' ||
+                status.value?.confirmationStatus === 'finalized') {
+                return status.value;
+            }
+
+            if (status.value?.err) {
+                throw new Error(`Transaction failed: ${JSON.stringify(status.value.err)}`);
+            }
+
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+
+        throw new Error('Transaction confirmation timeout');
+    }
+
+    // Get network status
+    async getStatus() {
+        const connection = await this.getConnection();
+
+        const [slot, blockHeight, epochInfo, supply] = await Promise.all([
+            connection.getSlot(),
+            connection.getBlockHeight(),
+            connection.getEpochInfo(),
+            connection.getSupply()
+        ]);
+
+        return {
+            network: this.network,
+            rpcUrl: this.rpcUrl,
+            slot,
+            blockHeight,
+            epoch: epochInfo.epoch,
+            slotIndex: epochInfo.slotIndex,
+            slotsInEpoch: epochInfo.slotsInEpoch,
+            totalSupply: supply.value.total / LAMPORTS_PER_SOL,
+            circulatingSupply: supply.value.circulating / LAMPORTS_PER_SOL
+        };
+    }
+}
+
+// QVTX-specific Solana utilities
+class QVTXSolanaBridge {
+    constructor(solanaSDK, config = {}) {
+        this.solana = solanaSDK;
+        this.qvtxMint = config.qvtxMint || null;
+        this.bridgeProgram = config.bridgeProgram || null;
+    }
+
+    // Set QVTX token mint address
+    setQVTXMint(mintAddress) {
+        this.qvtxMint = mintAddress;
+    }
+
+    // Get QVTX balance
+    async getQVTXBalance(owner) {
+        if (!this.qvtxMint) {
+            throw new Error('QVTX mint address not set');
+        }
+        // Implementation would get associated token account and balance
+        return 0;
+    }
+
+    // Bridge QVTX from Solana to EVM chain
+    async bridgeToEVM(amount, evmAddress, evmChainId, signer) {
+        console.log(`🌉 Bridging ${amount} QVTX to EVM chain ${evmChainId}...`);
+        // Implementation would interact with bridge program
+        return { signature: 'mock-signature', bridgeId: 'mock-bridge-id' };
+    }
+
+    // Receive QVTX from EVM chain
+    async receiveFromEVM(bridgeId, amount, proof, signer) {
+        console.log(`📥 Receiving ${amount} QVTX from EVM bridge...`);
+        // Implementation would verify proof and mint tokens
+        return { signature: 'mock-signature' };
+    }
+}
+
+module.exports = QVTXSolana;
+module.exports.QVTXSolana = QVTXSolana;
+module.exports.QVTXSolanaBridge = QVTXSolanaBridge;
+
+// CLI Usage
+if (require.main === module) {
+    const solana = new QVTXSolana({ network: 'devnet' });
+
+    (async () => {
+        await solana.connect();
+        const status = await solana.getStatus();
+        console.log('\nSolana Network Status:');
+        console.log(JSON.stringify(status, null, 2));
+    })().catch(console.error);
+}

package/package.json

@@ -1,13 +1,27 @@
 {
     "name": "qvtx-developer-kit",
-    "version": "1.0.0",
+    "version": "1.1.0",
     "description": "Complete QuantVestrix QVTX Developer Package - Build infinite throughput blockchain applications with cross-chain rewards and neural storage",
     "main": "index.js",
+    "types": "types/index.d.ts",
     "bin": {
         "qvtx-developer": "./bin/qvtx-developer-cli.js",
         "qvtx": "./bin/qvtx-developer-cli.js"
     },
+    "exports": {
+        ".": "./index.js",
+        "./abis": "./abis/index.js",
+        "./abis/*": "./abis/*.json",
+        "./rewards": "./rewards/index.js",
+        "./storage": "./storage/index.js",
+        "./config": "./config/index.js",
+        "./test": "./test/index.js",
+        "./solana": "./languages/solana_sdk.js",
+        "./blockchain-ai": "./languages/blockchain_ai_sdk.js",
+        "./node-sdk": "./languages/node_sdk.js"
+    },
     "files": [
+        "index.js",
         "languages/",
         "templates/",
         "docs/",
@@ -17,6 +31,11 @@
         "rewards/",
         "storage/",
         "bin/",
+        "abis/",
+        "types/",
+        "config/",
+        "test/",
+        ".env.example",
         "README.md",
         "CONTRIBUTING.md",
         "LICENSE"
@@ -50,7 +69,12 @@
         "smart-contracts",
         "dapp",
         "defi",
-        "cryptocurrency"
+        "cryptocurrency",
+        "nft",
+        "governance",
+        "bridge",
+        "staking",
+        "vesting"
     ],
     "author": "QuantVestrix Tech Team (07-Tech)",
     "license": "MIT",
@@ -62,6 +86,7 @@
         "ethers": "^5.7.0",
         "axios": "^1.4.0",
         "@solana/web3.js": "^1.75.0",
+        "@solana/spl-token": "^0.3.8",
         "fs-extra": "^11.1.1",
         "chalk": "^5.2.0",
         "inquirer": "^9.2.11",
@@ -106,4 +131,4 @@
         "x64",
         "arm64"
     ]
-}
+}

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;