Squashed 'vendor/ruvector/' content from commit b64c2172

git-subtree-dir: vendor/ruvector
git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900

npm/packages/agentic-synth/examples/crypto/blockchain-data.js

@@ -0,0 +1,632 @@
+"use strict";
+/**
+ * Blockchain and On-Chain Data Generation
+ *
+ * Examples for generating realistic blockchain data including:
+ * - Transaction patterns and behaviors
+ * - Wallet activity simulation
+ * - Token transfer events
+ * - NFT trading activity
+ * - MEV (Maximal Extractable Value) scenarios
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBlockchainDataExamples = runBlockchainDataExamples;
+exports.generateTransactionPatterns = generateTransactionPatterns;
+exports.generateWalletBehavior = generateWalletBehavior;
+exports.generateTokenTransfers = generateTokenTransfers;
+exports.generateNFTActivity = generateNFTActivity;
+exports.generateMEVPatterns = generateMEVPatterns;
+exports.generateBlockData = generateBlockData;
+exports.generateContractDeployments = generateContractDeployments;
+exports.generateBridgeActivity = generateBridgeActivity;
+const index_js_1 = require("../../src/index.js");
+/**
+ * Example 1: Generate realistic transaction patterns
+ * Simulates various transaction types across different networks
+ */
+async function generateTransactionPatterns() {
+    const synth = (0, index_js_1.createSynth)({
+        provider: 'gemini',
+        apiKey: process.env.GEMINI_API_KEY
+    });
+    const networks = ['ethereum', 'polygon', 'arbitrum', 'optimism', 'base'];
+    const results = [];
+    for (const network of networks) {
+        const result = await synth.generateEvents({
+            count: 10000,
+            eventTypes: [
+                'transfer',
+                'contract_call',
+                'contract_creation',
+                'erc20_transfer',
+                'erc721_transfer',
+                'erc1155_transfer'
+            ],
+            distribution: 'poisson',
+            timeRange: {
+                start: new Date(Date.now() - 24 * 60 * 60 * 1000),
+                end: new Date()
+            },
+            userCount: 5000,
+            schema: {
+                txHash: { type: 'string', format: 'transaction_hash' },
+                blockNumber: { type: 'integer', min: 1000000 },
+                blockTimestamp: { type: 'datetime', format: 'iso8601' },
+                network: { type: 'string', default: network },
+                from: { type: 'string', format: 'ethereum_address' },
+                to: { type: 'string', format: 'ethereum_address' },
+                value: { type: 'number', min: 0 },
+                gasLimit: { type: 'integer', min: 21000, max: 30000000 },
+                gasUsed: { type: 'integer', min: 21000 },
+                gasPrice: { type: 'number', min: 1 },
+                maxFeePerGas: { type: 'number' },
+                maxPriorityFeePerGas: { type: 'number' },
+                nonce: { type: 'integer', min: 0 },
+                transactionIndex: { type: 'integer', min: 0, max: 300 },
+                status: { type: 'string', enum: ['success', 'failed'] },
+                type: { type: 'integer', enum: [0, 1, 2] }, // Legacy, EIP-2930, EIP-1559
+                input: { type: 'string' },
+                methodId: { type: 'string' },
+                internalTransactions: { type: 'integer', min: 0, max: 100 }
+            }
+        });
+        results.push({ network, data: result.data });
+        console.log(`Generated ${network} transactions: ${result.data.length}`);
+    }
+    return results;
+}
+/**
+ * Example 2: Simulate wallet behavior patterns
+ * Includes HODLers, traders, bots, and contract wallets
+ */
+async function generateWalletBehavior() {
+    const synth = (0, index_js_1.createSynth)({
+        provider: 'gemini'
+    });
+    const walletTypes = ['hodler', 'trader', 'bot', 'whale', 'retail', 'contract'];
+    const result = await synth.generateStructured({
+        count: 5000,
+        schema: {
+            walletAddress: { type: 'string', format: 'ethereum_address', required: true },
+            walletType: { type: 'string', enum: walletTypes },
+            createdAt: { type: 'datetime', required: true },
+            lastActive: { type: 'datetime' },
+            balance: {
+                type: 'object',
+                properties: {
+                    ETH: { type: 'number', min: 0 },
+                    USDC: { type: 'number', min: 0 },
+                    USDT: { type: 'number', min: 0 },
+                    totalValueUSD: { type: 'number', min: 0 }
+                }
+            },
+            activity: {
+                type: 'object',
+                properties: {
+                    totalTxs: { type: 'integer', min: 0 },
+                    txsLast24h: { type: 'integer', min: 0 },
+                    txsLast7d: { type: 'integer', min: 0 },
+                    txsLast30d: { type: 'integer', min: 0 },
+                    avgTxValue: { type: 'number', min: 0 },
+                    avgTxFrequency: { type: 'number', min: 0 } // per day
+                }
+            },
+            holdings: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        token: { type: 'string' },
+                        symbol: { type: 'string' },
+                        balance: { type: 'number' },
+                        valueUSD: { type: 'number' },
+                        allocation: { type: 'number', min: 0, max: 100 }
+                    }
+                }
+            },
+            defi: {
+                type: 'object',
+                properties: {
+                    totalValueLocked: { type: 'number', min: 0 },
+                    activePools: { type: 'integer', min: 0 },
+                    lendingPositions: { type: 'integer', min: 0 },
+                    borrowingPositions: { type: 'integer', min: 0 },
+                    nftCount: { type: 'integer', min: 0 }
+                }
+            },
+            behaviorMetrics: {
+                type: 'object',
+                properties: {
+                    riskProfile: { type: 'string', enum: ['conservative', 'moderate', 'aggressive', 'degen'] },
+                    avgHoldingPeriod: { type: 'number', min: 0 }, // days
+                    tradingFrequency: { type: 'string', enum: ['daily', 'weekly', 'monthly', 'rarely'] },
+                    gasTotalSpent: { type: 'number', min: 0 },
+                    profitLoss: { type: 'number' },
+                    winRate: { type: 'number', min: 0, max: 100 }
+                }
+            },
+            labels: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: ['whale', 'early_adopter', 'nft_collector', 'yield_farmer', 'mev_bot', 'exchange', 'bridge']
+                }
+            }
+        }
+    });
+    console.log('Generated wallet behavior data:', result.data.length);
+    // Analyze by wallet type
+    const typeDistribution = {};
+    result.data.forEach((wallet) => {
+        typeDistribution[wallet.walletType] = (typeDistribution[wallet.walletType] || 0) + 1;
+    });
+    console.log('Wallet type distribution:', typeDistribution);
+    return result;
+}
+/**
+ * Example 3: Generate token transfer events
+ * Simulates ERC-20, ERC-721, and ERC-1155 transfers
+ */
+async function generateTokenTransfers() {
+    const synth = (0, index_js_1.createSynth)({
+        provider: 'gemini'
+    });
+    const result = await synth.generateEvents({
+        count: 50000,
+        eventTypes: ['erc20', 'erc721', 'erc1155'],
+        distribution: 'poisson',
+        timeRange: {
+            start: new Date(Date.now() - 24 * 60 * 60 * 1000),
+            end: new Date()
+        },
+        userCount: 10000,
+        schema: {
+            txHash: { type: 'string', format: 'transaction_hash' },
+            blockNumber: { type: 'integer', min: 18000000 },
+            timestamp: { type: 'datetime', format: 'iso8601' },
+            tokenStandard: { type: 'string', enum: ['erc20', 'erc721', 'erc1155'] },
+            contractAddress: { type: 'string', format: 'ethereum_address' },
+            tokenName: { type: 'string', required: true },
+            tokenSymbol: { type: 'string', required: true },
+            from: { type: 'string', format: 'ethereum_address' },
+            to: { type: 'string', format: 'ethereum_address' },
+            value: { type: 'string' }, // Large numbers as string
+            valueDecimal: { type: 'number' },
+            valueUSD: { type: 'number', min: 0 },
+            tokenId: { type: 'string' }, // For NFTs
+            amount: { type: 'integer' }, // For ERC-1155
+            logIndex: { type: 'integer', min: 0 },
+            metadata: {
+                type: 'object',
+                properties: {
+                    decimals: { type: 'integer', default: 18 },
+                    totalSupply: { type: 'string' },
+                    holderCount: { type: 'integer' },
+                    marketCap: { type: 'number' }
+                }
+            }
+        }
+    });
+    console.log('Generated token transfers:', result.data.length);
+    // Analyze by token standard
+    const standards = {};
+    result.data.forEach((transfer) => {
+        standards[transfer.tokenStandard] = (standards[transfer.tokenStandard] || 0) + 1;
+    });
+    console.log('Transfers by standard:', standards);
+    return result;
+}
+/**
+ * Example 4: Generate NFT trading activity
+ * Includes mints, sales, and marketplace activity
+ */
+async function generateNFTActivity() {
+    const synth = (0, index_js_1.createSynth)({
+        provider: 'gemini'
+    });
+    const result = await synth.generateEvents({
+        count: 5000,
+        eventTypes: ['mint', 'sale', 'transfer', 'listing', 'bid', 'offer_accepted'],
+        distribution: 'poisson',
+        timeRange: {
+            start: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+            end: new Date()
+        },
+        userCount: 3000,
+        schema: {
+            txHash: { type: 'string', format: 'transaction_hash' },
+            timestamp: { type: 'datetime', format: 'iso8601' },
+            eventType: {
+                type: 'string',
+                enum: ['mint', 'sale', 'transfer', 'listing', 'bid', 'offer_accepted']
+            },
+            marketplace: {
+                type: 'string',
+                enum: ['opensea', 'blur', 'looksrare', 'x2y2', 'rarible', 'foundation']
+            },
+            collection: {
+                type: 'object',
+                properties: {
+                    address: { type: 'string', format: 'ethereum_address' },
+                    name: { type: 'string' },
+                    symbol: { type: 'string' },
+                    floorPrice: { type: 'number', min: 0 },
+                    totalVolume: { type: 'number', min: 0 },
+                    itemCount: { type: 'integer', min: 1 }
+                }
+            },
+            nft: {
+                type: 'object',
+                properties: {
+                    tokenId: { type: 'string' },
+                    name: { type: 'string' },
+                    rarity: { type: 'string', enum: ['common', 'uncommon', 'rare', 'epic', 'legendary'] },
+                    rarityRank: { type: 'integer', min: 1 },
+                    traits: { type: 'array' }
+                }
+            },
+            price: {
+                type: 'object',
+                properties: {
+                    amount: { type: 'number', min: 0 },
+                    currency: { type: 'string', enum: ['ETH', 'WETH', 'USDC', 'APE'] },
+                    usdValue: { type: 'number', min: 0 }
+                }
+            },
+            from: { type: 'string', format: 'ethereum_address' },
+            to: { type: 'string', format: 'ethereum_address' },
+            royalty: {
+                type: 'object',
+                properties: {
+                    recipient: { type: 'string', format: 'ethereum_address' },
+                    amount: { type: 'number', min: 0 },
+                    percentage: { type: 'number', min: 0, max: 10 }
+                }
+            },
+            marketplaceFee: { type: 'number', min: 0 }
+        }
+    });
+    console.log('Generated NFT activity:', result.data.length);
+    // Analyze by event type
+    const events = {};
+    result.data.forEach((activity) => {
+        events[activity.eventType] = (events[activity.eventType] || 0) + 1;
+    });
+    console.log('Activity by type:', events);
+    // Top marketplaces by volume
+    const marketplaces = {};
+    result.data.forEach((activity) => {
+        if (activity.price) {
+            marketplaces[activity.marketplace] =
+                (marketplaces[activity.marketplace] || 0) + activity.price.usdValue;
+        }
+    });
+    console.log('Volume by marketplace:', marketplaces);
+    return result;
+}
+/**
+ * Example 5: Generate MEV transaction patterns
+ * Advanced MEV extraction and sandwich attack simulations
+ */
+async function generateMEVPatterns() {
+    const synth = (0, index_js_1.createSynth)({
+        provider: 'gemini'
+    });
+    const result = await synth.generateStructured({
+        count: 1000,
+        schema: {
+            bundleId: { type: 'string', format: 'uuid' },
+            blockNumber: { type: 'integer', min: 18000000 },
+            timestamp: { type: 'datetime', required: true },
+            mevType: {
+                type: 'string',
+                enum: ['sandwich', 'arbitrage', 'liquidation', 'jit', 'backrun', 'frontrun']
+            },
+            bundleTransactions: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 10,
+                items: {
+                    type: 'object',
+                    properties: {
+                        txHash: { type: 'string' },
+                        position: { type: 'integer' },
+                        type: { type: 'string', enum: ['frontrun', 'victim', 'backrun'] },
+                        from: { type: 'string' },
+                        to: { type: 'string' },
+                        value: { type: 'number' },
+                        gasPrice: { type: 'number' }
+                    }
+                }
+            },
+            targetProtocol: {
+                type: 'string',
+                enum: ['uniswap_v2', 'uniswap_v3', 'sushiswap', 'curve', 'balancer', 'aave', 'compound']
+            },
+            profit: {
+                type: 'object',
+                properties: {
+                    gross: { type: 'number' },
+                    gasCost: { type: 'number' },
+                    net: { type: 'number' },
+                    roi: { type: 'number' }
+                }
+            },
+            victimTx: {
+                type: 'object',
+                properties: {
+                    hash: { type: 'string' },
+                    expectedSlippage: { type: 'number' },
+                    actualSlippage: { type: 'number' },
+                    lossUSD: { type: 'number' }
+                }
+            },
+            mevBot: {
+                type: 'object',
+                properties: {
+                    address: { type: 'string', format: 'ethereum_address' },
+                    operator: { type: 'string' },
+                    flashbotRelay: { type: 'boolean' },
+                    privateTx: { type: 'boolean' }
+                }
+            },
+            complexity: { type: 'integer', min: 1, max: 10 },
+            executionTimeMs: { type: 'number', min: 10, max: 5000 }
+        }
+    });
+    console.log('Generated MEV patterns:', result.data.length);
+    // Analyze MEV types
+    const types = {};
+    result.data.forEach((mev) => {
+        types[mev.mevType] = (types[mev.mevType] || 0) + 1;
+    });
+    console.log('MEV by type:', types);
+    // Total profit extracted
+    const totalProfit = result.data.reduce((sum, mev) => sum + mev.profit.net, 0);
+    console.log(`Total MEV extracted: $${totalProfit.toFixed(2)}`);
+    return result;
+}
+/**
+ * Example 6: Generate block production data
+ * Includes validator performance and block building
+ */
+async function generateBlockData() {
+    const synth = (0, index_js_1.createSynth)({
+        provider: 'gemini'
+    });
+    const result = await synth.generateTimeSeries({
+        count: 7200, // ~24 hours of blocks (12s block time)
+        interval: '12s',
+        startDate: new Date(Date.now() - 24 * 60 * 60 * 1000),
+        metrics: ['gasUsed', 'baseFee', 'mevReward', 'transactionCount'],
+        trend: 'stable',
+        seasonality: true,
+        noise: 0.15,
+        schema: {
+            blockNumber: { type: 'integer', min: 18000000, required: true },
+            timestamp: { type: 'datetime', format: 'iso8601' },
+            hash: { type: 'string', format: 'block_hash' },
+            parentHash: { type: 'string', format: 'block_hash' },
+            proposer: { type: 'string', format: 'ethereum_address' },
+            validator: {
+                type: 'object',
+                properties: {
+                    index: { type: 'integer' },
+                    balance: { type: 'number' },
+                    effectiveBalance: { type: 'number', default: 32 },
+                    slashed: { type: 'boolean', default: false }
+                }
+            },
+            transactions: {
+                type: 'object',
+                properties: {
+                    count: { type: 'integer', min: 0, max: 300 },
+                    totalValue: { type: 'number' },
+                    totalFees: { type: 'number' },
+                    internalTxs: { type: 'integer' }
+                }
+            },
+            gas: {
+                type: 'object',
+                properties: {
+                    used: { type: 'integer', min: 0, max: 30000000 },
+                    limit: { type: 'integer', default: 30000000 },
+                    utilization: { type: 'number', min: 0, max: 100 },
+                    baseFee: { type: 'number', min: 1 },
+                    avgPriorityFee: { type: 'number' }
+                }
+            },
+            mev: {
+                type: 'object',
+                properties: {
+                    bundles: { type: 'integer', min: 0 },
+                    reward: { type: 'number', min: 0 },
+                    flashbotsTx: { type: 'integer', min: 0 }
+                }
+            },
+            size: { type: 'integer', min: 1000 },
+            difficulty: { type: 'string' },
+            extraData: { type: 'string' },
+            blockReward: { type: 'number', min: 0 }
+        }
+    });
+    console.log('Generated block data:', result.data.length);
+    // Calculate average block stats
+    const avgGasUsed = result.data.reduce((sum, block) => sum + block.gas.used, 0) / result.data.length;
+    const avgTxCount = result.data.reduce((sum, block) => sum + block.transactions.count, 0) / result.data.length;
+    console.log('Average block statistics:');
+    console.log(`  Gas used: ${avgGasUsed.toFixed(0)}`);
+    console.log(`  Transactions: ${avgTxCount.toFixed(0)}`);
+    return result;
+}
+/**
+ * Example 7: Generate smart contract deployment patterns
+ * Tracks contract creation and verification
+ */
+async function generateContractDeployments() {
+    const synth = (0, index_js_1.createSynth)({
+        provider: 'gemini'
+    });
+    const result = await synth.generateEvents({
+        count: 1000,
+        eventTypes: ['erc20', 'erc721', 'erc1155', 'proxy', 'defi', 'custom'],
+        distribution: 'uniform',
+        timeRange: {
+            start: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000),
+            end: new Date()
+        },
+        userCount: 500,
+        schema: {
+            txHash: { type: 'string', format: 'transaction_hash' },
+            blockNumber: { type: 'integer', min: 18000000 },
+            timestamp: { type: 'datetime', format: 'iso8601' },
+            deployer: { type: 'string', format: 'ethereum_address' },
+            contractAddress: { type: 'string', format: 'ethereum_address' },
+            contractType: {
+                type: 'string',
+                enum: ['token', 'nft', 'defi', 'dao', 'bridge', 'oracle', 'gaming', 'other']
+            },
+            standard: { type: 'string', enum: ['erc20', 'erc721', 'erc1155', 'erc4626', 'custom'] },
+            bytecode: { type: 'string' },
+            bytecodeSize: { type: 'integer', min: 100, max: 24576 },
+            constructorArgs: { type: 'array' },
+            verified: { type: 'boolean' },
+            verificationDate: { type: 'datetime' },
+            compiler: {
+                type: 'object',
+                properties: {
+                    version: { type: 'string' },
+                    optimization: { type: 'boolean' },
+                    runs: { type: 'integer', default: 200 }
+                }
+            },
+            proxy: {
+                type: 'object',
+                properties: {
+                    isProxy: { type: 'boolean' },
+                    implementation: { type: 'string' },
+                    proxyType: { type: 'string', enum: ['transparent', 'uups', 'beacon', 'none'] }
+                }
+            },
+            gasUsed: { type: 'integer', min: 100000 },
+            deploymentCost: { type: 'number', min: 0 },
+            activity: {
+                type: 'object',
+                properties: {
+                    uniqueUsers: { type: 'integer', min: 0 },
+                    totalTxs: { type: 'integer', min: 0 },
+                    totalVolume: { type: 'number', min: 0 }
+                }
+            }
+        }
+    });
+    console.log('Generated contract deployments:', result.data.length);
+    // Analyze by type
+    const types = {};
+    result.data.forEach((contract) => {
+        types[contract.contractType] = (types[contract.contractType] || 0) + 1;
+    });
+    console.log('Deployments by type:', types);
+    const verified = result.data.filter((c) => c.verified).length;
+    console.log(`Verification rate: ${(verified / result.data.length * 100).toFixed(1)}%`);
+    return result;
+}
+/**
+ * Example 8: Generate cross-chain bridge activity
+ * Simulates asset transfers between blockchains
+ */
+async function generateBridgeActivity() {
+    const synth = (0, index_js_1.createSynth)({
+        provider: 'gemini'
+    });
+    const result = await synth.generateEvents({
+        count: 2000,
+        eventTypes: ['deposit', 'withdraw', 'relay'],
+        distribution: 'poisson',
+        timeRange: {
+            start: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+            end: new Date()
+        },
+        userCount: 1000,
+        schema: {
+            bridgeTxId: { type: 'string', format: 'uuid' },
+            timestamp: { type: 'datetime', format: 'iso8601' },
+            bridge: {
+                type: 'string',
+                enum: ['stargate', 'hop', 'across', 'synapse', 'multichain', 'wormhole', 'layerzero']
+            },
+            sourceChain: {
+                type: 'string',
+                enum: ['ethereum', 'polygon', 'arbitrum', 'optimism', 'avalanche', 'bsc']
+            },
+            destinationChain: {
+                type: 'string',
+                enum: ['ethereum', 'polygon', 'arbitrum', 'optimism', 'avalanche', 'bsc']
+            },
+            user: { type: 'string', format: 'ethereum_address' },
+            asset: { type: 'string', enum: ['ETH', 'USDC', 'USDT', 'DAI', 'WBTC'] },
+            amount: { type: 'number', min: 1 },
+            amountUSD: { type: 'number', min: 1 },
+            fees: {
+                type: 'object',
+                properties: {
+                    sourceGas: { type: 'number' },
+                    bridgeFee: { type: 'number' },
+                    destinationGas: { type: 'number' },
+                    totalFee: { type: 'number' }
+                }
+            },
+            status: {
+                type: 'string',
+                enum: ['pending', 'relaying', 'completed', 'failed', 'refunded']
+            },
+            sourceTxHash: { type: 'string', format: 'transaction_hash' },
+            destinationTxHash: { type: 'string', format: 'transaction_hash' },
+            completionTime: { type: 'number', min: 60, max: 3600 }, // seconds
+            securityDelay: { type: 'number', min: 0, max: 86400 }
+        }
+    });
+    console.log('Generated bridge activity:', result.data.length);
+    // Analyze bridge usage
+    const bridges = {};
+    result.data.forEach((tx) => {
+        bridges[tx.bridge] = (bridges[tx.bridge] || 0) + 1;
+    });
+    console.log('Usage by bridge:', bridges);
+    // Calculate success rate
+    const completed = result.data.filter((tx) => tx.status === 'completed').length;
+    console.log(`Success rate: ${(completed / result.data.length * 100).toFixed(1)}%`);
+    return result;
+}
+/**
+ * Run all blockchain data examples
+ */
+async function runBlockchainDataExamples() {
+    console.log('=== Blockchain and On-Chain Data Generation Examples ===\n');
+    console.log('Example 1: Transaction Patterns');
+    await generateTransactionPatterns();
+    console.log('\n---\n');
+    console.log('Example 2: Wallet Behavior');
+    await generateWalletBehavior();
+    console.log('\n---\n');
+    console.log('Example 3: Token Transfers');
+    await generateTokenTransfers();
+    console.log('\n---\n');
+    console.log('Example 4: NFT Activity');
+    await generateNFTActivity();
+    console.log('\n---\n');
+    console.log('Example 5: MEV Patterns');
+    await generateMEVPatterns();
+    console.log('\n---\n');
+    console.log('Example 6: Block Production Data');
+    await generateBlockData();
+    console.log('\n---\n');
+    console.log('Example 7: Contract Deployments');
+    await generateContractDeployments();
+    console.log('\n---\n');
+    console.log('Example 8: Bridge Activity');
+    await generateBridgeActivity();
+}
+// Uncomment to run
+// runBlockchainDataExamples().catch(console.error);
+//# sourceMappingURL=blockchain-data.js.map