qvtx-developer-kit 1.0.0 → 1.1.0

package/config/index.js

@@ -0,0 +1,108 @@
+'use strict';
+
+/**
+ * QVTX Configuration Module
+ * Central configuration management
+ */
+
+const networks = require('./networks');
+const path = require('path');
+const fs = require('fs');
+
+// Load environment variables from .env if exists
+function loadEnv(envPath) {
+    const dotenvPath = envPath || path.join(process.cwd(), '.env');
+
+    if (fs.existsSync(dotenvPath)) {
+        const content = fs.readFileSync(dotenvPath, 'utf8');
+        const lines = content.split('\n');
+
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('#')) {
+                const [key, ...valueParts] = trimmed.split('=');
+                const value = valueParts.join('=').trim();
+                if (key && !process.env[key]) {
+                    process.env[key] = value;
+                }
+            }
+        }
+    }
+}
+
+// Default configuration
+const DEFAULT_CONFIG = {
+    network: 'ethereum',
+    environment: 'mainnet',
+    debug: false,
+    timeout: 30000,
+    retries: 3,
+    gasMultiplier: 1.2
+};
+
+// Get configuration value
+function get(key, defaultValue) {
+    const envKey = `QVTX_${key.toUpperCase()}`;
+    return process.env[envKey] || defaultValue;
+}
+
+// Get private key (with validation)
+function getPrivateKey() {
+    const key = process.env.PRIVATE_KEY;
+    if (!key) {
+        throw new Error('PRIVATE_KEY environment variable not set');
+    }
+    if (!key.startsWith('0x')) {
+        return '0x' + key;
+    }
+    return key;
+}
+
+// Get RPC URL for network
+function getRpcUrl(network, environment) {
+    const envKey = `${network.toUpperCase()}_RPC`;
+    if (process.env[envKey]) {
+        return process.env[envKey];
+    }
+
+    const networkConfig = networks.getNetwork(network, environment);
+    let rpc = networkConfig.rpc;
+
+    // Replace API key placeholders
+    if (rpc.includes('${INFURA_API_KEY}') && process.env.INFURA_API_KEY) {
+        rpc = rpc.replace('${INFURA_API_KEY}', process.env.INFURA_API_KEY);
+    }
+    if (rpc.includes('${ALCHEMY_API_KEY}') && process.env.ALCHEMY_API_KEY) {
+        rpc = rpc.replace('${ALCHEMY_API_KEY}', process.env.ALCHEMY_API_KEY);
+    }
+
+    return rpc;
+}
+
+// Get contract address
+function getContractAddress(contractName, network = 'ethereum') {
+    const envKey = `QVTX_${contractName.toUpperCase()}_${network.toUpperCase()}`;
+    return process.env[envKey] || null;
+}
+
+// Create configuration object
+function createConfig(options = {}) {
+    return {
+        ...DEFAULT_CONFIG,
+        ...options,
+        getPrivateKey,
+        getRpcUrl: (net, env) => getRpcUrl(net || options.network, env || options.environment),
+        getContractAddress
+    };
+}
+
+module.exports = {
+    loadEnv,
+    get,
+    getPrivateKey,
+    getRpcUrl,
+    getContractAddress,
+    createConfig,
+    DEFAULT_CONFIG,
+    ...networks
+};

package/config/networks.js

@@ -0,0 +1,247 @@
+'use strict';
+
+/**
+ * QVTX Network Configurations
+ * Supported blockchain networks and their settings
+ */
+
+const NETWORKS = {
+    // Ethereum
+    ethereum: {
+        mainnet: {
+            chainId: 1,
+            name: 'Ethereum Mainnet',
+            rpc: 'https://eth.llamarpc.com',
+            rpcAlternatives: [
+                'https://mainnet.infura.io/v3/${INFURA_API_KEY}',
+                'https://eth-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}',
+                'https://cloudflare-eth.com'
+            ],
+            nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+            blockExplorer: 'https://etherscan.io',
+            avgBlockTime: 12
+        },
+        goerli: {
+            chainId: 5,
+            name: 'Goerli Testnet',
+            rpc: 'https://goerli.infura.io/v3/${INFURA_API_KEY}',
+            nativeCurrency: { name: 'Goerli Ether', symbol: 'ETH', decimals: 18 },
+            blockExplorer: 'https://goerli.etherscan.io',
+            faucet: 'https://goerlifaucet.com',
+            avgBlockTime: 12
+        },
+        sepolia: {
+            chainId: 11155111,
+            name: 'Sepolia Testnet',
+            rpc: 'https://sepolia.infura.io/v3/${INFURA_API_KEY}',
+            nativeCurrency: { name: 'Sepolia Ether', symbol: 'ETH', decimals: 18 },
+            blockExplorer: 'https://sepolia.etherscan.io',
+            faucet: 'https://sepoliafaucet.com',
+            avgBlockTime: 12
+        }
+    },
+
+    // BNB Smart Chain
+    bsc: {
+        mainnet: {
+            chainId: 56,
+            name: 'BNB Smart Chain',
+            rpc: 'https://bsc-dataseed.binance.org/',
+            rpcAlternatives: [
+                'https://bsc-dataseed1.defibit.io/',
+                'https://bsc-dataseed1.ninicoin.io/'
+            ],
+            nativeCurrency: { name: 'BNB', symbol: 'BNB', decimals: 18 },
+            blockExplorer: 'https://bscscan.com',
+            avgBlockTime: 3
+        },
+        testnet: {
+            chainId: 97,
+            name: 'BSC Testnet',
+            rpc: 'https://data-seed-prebsc-1-s1.binance.org:8545/',
+            nativeCurrency: { name: 'Test BNB', symbol: 'tBNB', decimals: 18 },
+            blockExplorer: 'https://testnet.bscscan.com',
+            faucet: 'https://testnet.binance.org/faucet-smart',
+            avgBlockTime: 3
+        }
+    },
+
+    // Polygon
+    polygon: {
+        mainnet: {
+            chainId: 137,
+            name: 'Polygon Mainnet',
+            rpc: 'https://polygon-rpc.com/',
+            rpcAlternatives: [
+                'https://rpc-mainnet.maticvigil.com/',
+                'https://polygon-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}'
+            ],
+            nativeCurrency: { name: 'MATIC', symbol: 'MATIC', decimals: 18 },
+            blockExplorer: 'https://polygonscan.com',
+            avgBlockTime: 2
+        },
+        mumbai: {
+            chainId: 80001,
+            name: 'Mumbai Testnet',
+            rpc: 'https://rpc-mumbai.maticvigil.com/',
+            nativeCurrency: { name: 'Test MATIC', symbol: 'MATIC', decimals: 18 },
+            blockExplorer: 'https://mumbai.polygonscan.com',
+            faucet: 'https://faucet.polygon.technology/',
+            avgBlockTime: 2
+        }
+    },
+
+    // Arbitrum
+    arbitrum: {
+        mainnet: {
+            chainId: 42161,
+            name: 'Arbitrum One',
+            rpc: 'https://arb1.arbitrum.io/rpc',
+            rpcAlternatives: [
+                'https://arb-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}'
+            ],
+            nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+            blockExplorer: 'https://arbiscan.io',
+            avgBlockTime: 0.25
+        },
+        goerli: {
+            chainId: 421613,
+            name: 'Arbitrum Goerli',
+            rpc: 'https://goerli-rollup.arbitrum.io/rpc',
+            nativeCurrency: { name: 'Goerli Ether', symbol: 'ETH', decimals: 18 },
+            blockExplorer: 'https://goerli.arbiscan.io',
+            faucet: 'https://faucet.arbitrum.io/',
+            avgBlockTime: 0.25
+        }
+    },
+
+    // Avalanche
+    avalanche: {
+        mainnet: {
+            chainId: 43114,
+            name: 'Avalanche C-Chain',
+            rpc: 'https://api.avax.network/ext/bc/C/rpc',
+            rpcAlternatives: [
+                'https://avalanche-mainnet.infura.io/v3/${INFURA_API_KEY}'
+            ],
+            nativeCurrency: { name: 'AVAX', symbol: 'AVAX', decimals: 18 },
+            blockExplorer: 'https://snowtrace.io',
+            avgBlockTime: 2
+        },
+        fuji: {
+            chainId: 43113,
+            name: 'Avalanche Fuji',
+            rpc: 'https://api.avax-test.network/ext/bc/C/rpc',
+            nativeCurrency: { name: 'Test AVAX', symbol: 'AVAX', decimals: 18 },
+            blockExplorer: 'https://testnet.snowtrace.io',
+            faucet: 'https://faucet.avax.network/',
+            avgBlockTime: 2
+        }
+    },
+
+    // Optimism
+    optimism: {
+        mainnet: {
+            chainId: 10,
+            name: 'Optimism',
+            rpc: 'https://mainnet.optimism.io',
+            rpcAlternatives: [
+                'https://opt-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}'
+            ],
+            nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+            blockExplorer: 'https://optimistic.etherscan.io',
+            avgBlockTime: 2
+        },
+        goerli: {
+            chainId: 420,
+            name: 'Optimism Goerli',
+            rpc: 'https://goerli.optimism.io',
+            nativeCurrency: { name: 'Goerli Ether', symbol: 'ETH', decimals: 18 },
+            blockExplorer: 'https://goerli-optimism.etherscan.io',
+            avgBlockTime: 2
+        }
+    },
+
+    // Solana (different structure)
+    solana: {
+        'mainnet-beta': {
+            name: 'Solana Mainnet',
+            rpc: 'https://api.mainnet-beta.solana.com',
+            rpcAlternatives: [
+                'https://solana-api.projectserum.com'
+            ],
+            blockExplorer: 'https://explorer.solana.com'
+        },
+        devnet: {
+            name: 'Solana Devnet',
+            rpc: 'https://api.devnet.solana.com',
+            blockExplorer: 'https://explorer.solana.com?cluster=devnet',
+            faucet: 'https://solfaucet.com/'
+        },
+        testnet: {
+            name: 'Solana Testnet',
+            rpc: 'https://api.testnet.solana.com',
+            blockExplorer: 'https://explorer.solana.com?cluster=testnet'
+        }
+    }
+};
+
+// Helper functions
+function getNetwork(name, environment = 'mainnet') {
+    const network = NETWORKS[name.toLowerCase()];
+    if (!network) {
+        throw new Error(`Unknown network: ${name}`);
+    }
+    const env = network[environment];
+    if (!env) {
+        throw new Error(`Unknown environment: ${environment} for network ${name}`);
+    }
+    return env;
+}
+
+function getChainById(chainId) {
+    for (const [networkName, envs] of Object.entries(NETWORKS)) {
+        for (const [envName, config] of Object.entries(envs)) {
+            if (config.chainId === chainId) {
+                return { network: networkName, environment: envName, ...config };
+            }
+        }
+    }
+    return null;
+}
+
+function getAllNetworks() {
+    return NETWORKS;
+}
+
+function getMainnets() {
+    const mainnets = {};
+    for (const [name, envs] of Object.entries(NETWORKS)) {
+        if (envs.mainnet || envs['mainnet-beta']) {
+            mainnets[name] = envs.mainnet || envs['mainnet-beta'];
+        }
+    }
+    return mainnets;
+}
+
+function getTestnets() {
+    const testnets = {};
+    for (const [name, envs] of Object.entries(NETWORKS)) {
+        for (const [envName, config] of Object.entries(envs)) {
+            if (envName !== 'mainnet' && envName !== 'mainnet-beta') {
+                if (!testnets[name]) testnets[name] = {};
+                testnets[name][envName] = config;
+            }
+        }
+    }
+    return testnets;
+}
+
+module.exports = {
+    NETWORKS,
+    getNetwork,
+    getChainById,
+    getAllNetworks,
+    getMainnets,
+    getTestnets
+};

package/examples/basic-usage.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * QVTX Developer Kit - Basic Usage Example
+ */
+
+const QVTX = require('qvtx-developer-kit');
+
+async function main() {
+    // Initialize the SDK
+    const kit = new QVTX({
+        network: 'ethereum',
+        environment: 'mainnet'
+    });
+
+    console.log('QVTX Developer Kit v' + kit.getVersion());
+    console.log('Validator ID:', kit.validatorId);
+
+    // Display supported networks
+    console.log('\nSupported Networks:');
+    const networks = kit.getNetworks();
+    Object.entries(networks).forEach(([name, envs]) => {
+        console.log(`  ${name}: ${Object.keys(envs).join(', ')}`);
+    });
+
+    // Display token info
+    console.log('\nQVTX Token Info:');
+    const tokenInfo = kit.getTokenInfo();
+    console.log(`  Name: ${tokenInfo.name}`);
+    console.log(`  Symbol: ${tokenInfo.symbol}`);
+    console.log(`  Decimals: ${tokenInfo.decimals}`);
+
+    // Initialize Web3 (requires Infura API key)
+    // const web3 = await kit.initWeb3('https://mainnet.infura.io/v3/YOUR_API_KEY');
+    // const blockNumber = await web3.eth.getBlockNumber();
+    // console.log('\nCurrent block:', blockNumber);
+}
+
+main().catch(console.error);

package/examples/bridge-example.js

@@ -0,0 +1,123 @@
+'use strict';
+
+/**
+ * QVTX Cross-Chain Bridge Example
+ * Demonstrates how to bridge QVTX tokens between chains
+ */
+
+const QVTX = require('qvtx-developer-kit');
+const { QVTXBridge: BridgeABI, QVTXToken: TokenABI } = require('qvtx-developer-kit/abis');
+
+// Configuration
+const CONFIG = {
+    PRIVATE_KEY: process.env.PRIVATE_KEY || 'your-private-key-here',
+
+    // Source chain (Ethereum)
+    SOURCE_RPC: process.env.SOURCE_RPC || 'https://mainnet.infura.io/v3/YOUR_KEY',
+    SOURCE_BRIDGE: process.env.SOURCE_BRIDGE || '0x...', // Bridge contract on Ethereum
+    SOURCE_TOKEN: process.env.SOURCE_TOKEN || '0x...', // QVTX token on Ethereum
+
+    // Target chain (BSC)
+    TARGET_CHAIN_ID: 56,
+    TARGET_RPC: process.env.TARGET_RPC || 'https://bsc-dataseed.binance.org/',
+    TARGET_BRIDGE: process.env.TARGET_BRIDGE || '0x...', // Bridge contract on BSC
+};
+
+async function main() {
+    console.log('QVTX Cross-Chain Bridge Example\n');
+    console.log('================================\n');
+
+    // Initialize SDK
+    const kit = new QVTX({
+        network: 'ethereum',
+        environment: 'mainnet'
+    });
+
+    // Initialize Web3 for source chain
+    const web3 = await kit.initWeb3(CONFIG.SOURCE_RPC);
+    const account = web3.eth.accounts.privateKeyToAccount(CONFIG.PRIVATE_KEY);
+    web3.eth.accounts.wallet.add(account);
+
+    console.log('Wallet Address:', account.address);
+    console.log('Source Chain: Ethereum');
+    console.log('Target Chain: BSC (Chain ID:', CONFIG.TARGET_CHAIN_ID, ')');
+
+    // Initialize contracts
+    const bridgeContract = new web3.eth.Contract(BridgeABI.abi, CONFIG.SOURCE_BRIDGE);
+    const tokenContract = new web3.eth.Contract(TokenABI.abi, CONFIG.SOURCE_TOKEN);
+
+    // Check token balance
+    const balance = await tokenContract.methods.balanceOf(account.address).call();
+    console.log('\nQVTX Balance:', web3.utils.fromWei(balance, 'ether'), 'QVTX');
+
+    // Check bridge configuration
+    const bridgeFee = await bridgeContract.methods.bridgeFee().call();
+    const minAmount = await bridgeContract.methods.minBridgeAmount().call();
+    const maxAmount = await bridgeContract.methods.maxBridgeAmount().call();
+    const isTargetSupported = await bridgeContract.methods.isChainSupported(CONFIG.TARGET_CHAIN_ID).call();
+
+    console.log('\n--- Bridge Configuration ---');
+    console.log('Bridge Fee:', web3.utils.fromWei(bridgeFee, 'ether'), 'ETH');
+    console.log('Min Bridge Amount:', web3.utils.fromWei(minAmount, 'ether'), 'QVTX');
+    console.log('Max Bridge Amount:', web3.utils.fromWei(maxAmount, 'ether'), 'QVTX');
+    console.log('Target Chain Supported:', isTargetSupported);
+
+    // Check if bridge is paused
+    const isPaused = await bridgeContract.methods.paused().call();
+    if (isPaused) {
+        console.log('\nWARNING: Bridge is currently paused!');
+        return;
+    }
+
+    console.log('\n--- Bridge Operations ---\n');
+
+    // Example: Bridge tokens (uncomment to use)
+    /*
+    const bridgeAmount = web3.utils.toWei('100', 'ether'); // 100 QVTX
+    const recipient = account.address; // Same address on target chain
+
+    console.log('Bridging', web3.utils.fromWei(bridgeAmount, 'ether'), 'QVTX to BSC...');
+
+    // Step 1: Approve bridge contract to spend tokens
+    console.log('Step 1: Approving tokens...');
+    const approveTx = await tokenContract.methods.approve(CONFIG.SOURCE_BRIDGE, bridgeAmount)
+        .send({ from: account.address, gas: 100000 });
+    console.log('Approve TX:', approveTx.transactionHash);
+
+    // Step 2: Initiate bridge
+    console.log('Step 2: Initiating bridge transfer...');
+    const bridgeTx = await bridgeContract.methods.bridge(
+        recipient,
+        bridgeAmount,
+        CONFIG.TARGET_CHAIN_ID
+    ).send({
+        from: account.address,
+        value: bridgeFee,
+        gas: 200000
+    });
+
+    console.log('Bridge TX:', bridgeTx.transactionHash);
+
+    // Get request ID from event
+    const requestId = bridgeTx.events.BridgeInitiated.returnValues.requestId;
+    console.log('Bridge Request ID:', requestId);
+    console.log('\nTokens are being bridged. They will appear on BSC within 5-15 minutes.');
+    */
+
+    // Check bridge history
+    const userRequests = await bridgeContract.methods.getUserBridgeRequests(account.address).call();
+    console.log('Your Bridge Requests:', userRequests.length);
+
+    if (userRequests.length > 0) {
+        console.log('\nRecent Bridge Requests:');
+        for (const requestId of userRequests.slice(-5)) {
+            const request = await bridgeContract.methods.getBridgeRequest(requestId).call();
+            const statusMap = ['Pending', 'Completed', 'Refunded', 'Failed'];
+            console.log(`  #${requestId}: ${web3.utils.fromWei(request.amount, 'ether')} QVTX - ${statusMap[request.status]}`);
+        }
+    }
+
+    console.log('\nBridge example completed!');
+}
+
+main().catch(console.error);

package/examples/governance-example.js

@@ -0,0 +1,140 @@
+'use strict';
+
+/**
+ * QVTX Governance Example
+ * Demonstrates how to create proposals and vote
+ */
+
+const QVTX = require('qvtx-developer-kit');
+const { QVTXGovernance: GovernanceABI, QVTXToken: TokenABI } = 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',
+    GOVERNANCE_CONTRACT: process.env.GOVERNANCE_CONTRACT || '0x...',
+    TOKEN_CONTRACT: process.env.TOKEN_CONTRACT || '0x...'
+};
+
+async function main() {
+    console.log('QVTX Governance 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 contracts
+    const governance = new web3.eth.Contract(GovernanceABI.abi, CONFIG.GOVERNANCE_CONTRACT);
+    const token = new web3.eth.Contract(TokenABI.abi, CONFIG.TOKEN_CONTRACT);
+
+    // Check voting power (token balance)
+    const balance = await token.methods.balanceOf(account.address).call();
+    console.log('QVTX Balance (Voting Power):', web3.utils.fromWei(balance, 'ether'), 'QVTX');
+
+    // Get governance parameters
+    const proposalThreshold = await governance.methods.proposalThreshold().call();
+    const quorumVotes = await governance.methods.quorumVotes().call();
+    const votingPeriod = await governance.methods.votingPeriod().call();
+    const timelockDelay = await governance.methods.timelockDelay().call();
+    const proposalCount = await governance.methods.proposalCount().call();
+
+    console.log('\n--- Governance Parameters ---');
+    console.log('Proposal Threshold:', web3.utils.fromWei(proposalThreshold, 'ether'), 'QVTX');
+    console.log('Quorum Required:', web3.utils.fromWei(quorumVotes, 'ether'), 'QVTX');
+    console.log('Voting Period:', votingPeriod, 'blocks (~', Math.round(votingPeriod * 15 / 86400), 'days)');
+    console.log('Timelock Delay:', timelockDelay, 'seconds (~', Math.round(timelockDelay / 86400), 'days)');
+    console.log('Total Proposals:', proposalCount);
+
+    // Check if user can propose
+    const canPropose = BigInt(balance) >= BigInt(proposalThreshold);
+    console.log('\nCan Create Proposals:', canPropose ? 'Yes' : 'No (need more QVTX)');
+
+    console.log('\n--- Governance Operations ---\n');
+
+    // Example: Create proposal (uncomment to use)
+    /*
+    if (!canPropose) {
+        console.log('Insufficient QVTX to create proposal');
+        return;
+    }
+
+    const proposalTitle = 'Increase Staking Rewards';
+    const proposalDescription = 'This proposal increases the staking reward rate from 100 to 150 tokens per block to incentivize more participation.';
+    const targetContract = CONFIG.GOVERNANCE_CONTRACT; // Or any contract to call
+    const value = 0; // ETH to send
+    const callData = '0x'; // Encoded function call
+
+    console.log('Creating proposal:', proposalTitle);
+
+    const proposeTx = await governance.methods.propose(
+        proposalTitle,
+        proposalDescription,
+        targetContract,
+        value,
+        callData
+    ).send({
+        from: account.address,
+        gas: 500000
+    });
+
+    const proposalId = proposeTx.events.ProposalCreated.returnValues.id;
+    console.log('Proposal Created! ID:', proposalId);
+    console.log('TX:', proposeTx.transactionHash);
+    */
+
+    // Example: Vote on proposal (uncomment to use)
+    /*
+    const proposalIdToVote = 1; // Replace with actual proposal ID
+    const support = 1; // 0 = Against, 1 = For, 2 = Abstain
+    const reason = 'I support increasing rewards to grow the ecosystem.';
+
+    // Check proposal state first
+    const state = await governance.methods.getProposalState(proposalIdToVote).call();
+    const stateNames = ['Pending', 'Active', 'Canceled', 'Defeated', 'Succeeded', 'Queued', 'Expired', 'Executed'];
+    console.log('Proposal State:', stateNames[state]);
+
+    if (state == 1) { // Active
+        console.log('Voting on proposal', proposalIdToVote, '...');
+
+        const voteTx = await governance.methods.castVoteWithReason(
+            proposalIdToVote,
+            support,
+            reason
+        ).send({
+            from: account.address,
+            gas: 200000
+        });
+
+        console.log('Vote Cast! TX:', voteTx.transactionHash);
+    }
+    */
+
+    // View recent proposals
+    if (proposalCount > 0) {
+        console.log('Recent Proposals:\n');
+        const stateNames = ['Pending', 'Active', 'Canceled', 'Defeated', 'Succeeded', 'Queued', 'Expired', 'Executed'];
+
+        const startId = Math.max(1, proposalCount - 4);
+        for (let i = startId; i <= proposalCount; i++) {
+            const proposal = await governance.methods.getProposal(i).call();
+            console.log(`  #${proposal.id}: ${proposal.title}`);
+            console.log(`     State: ${stateNames[proposal.state]}`);
+            console.log(`     For: ${web3.utils.fromWei(proposal.forVotes, 'ether')} | Against: ${web3.utils.fromWei(proposal.againstVotes, 'ether')} | Abstain: ${web3.utils.fromWei(proposal.abstainVotes, 'ether')}`);
+            console.log('');
+        }
+    }
+
+    console.log('Governance example completed!');
+}
+
+main().catch(console.error);