Extra commands added

Author: UdaykiranReddy-1

package-lock.json

@@ -4,7 +4,7 @@
   "description": "",
   "main": "dist/index.js",
   "scripts": {
-    "dev": "ts-node index.ts",
+    "dev": "nodemon index.ts",
     "build": "tsc",
     "start": "node dist/index.js",
     "test": "echo \"No tests specified\" && exit 0"
@@ -15,7 +15,9 @@
   "dependencies": {
     "@google/genai": "^0.9.0",
     "axios": "^1.8.4",
-    "bubble-telegram": "file:",
+    "chart.js": "^4.4.9",
+    "chartjs-node-canvas": "^5.0.0",
+    "chartjs-plugin-datalabels": "^2.2.0",
     "dotenv": "^16.5.0",
     "express": "^5.1.0",
     "mime": "^4.0.7",

package.json

@@ -27,7 +27,7 @@ export async function analyzeToken(tokenAddress: string, topHolders: { address?:
   Top 5 Holders Information:
   ${holdersInfo}
   
-  Based solely on this token address and holder distribution information, provide a concise 2-3 line verdict on whether this appears to be a good token investment. Consider holder concentration, distribution patterns, and potential red flags. Format your response as a direct recommendation.Use a single emoji at the start to indicate the emotion of the response like danger signals or green signals etc...
+  Based solely on this token address and holder distribution information, provide a concise 2-3 line verdict on whether this appears to be a good token investment. Consider holder concentration, distribution patterns, and potential red flags. Format your response as a direct recommendation. Use a single emoji at the start to indicate the emotion of the response (e.g., 🟢 for bullish, ⚠️ for caution, 🛑 for bearish, etc)
   `;
 
     try {
@@ -42,4 +42,38 @@ export async function analyzeToken(tokenAddress: string, topHolders: { address?:
       console.error("Error analyzing token:", error);
       return "Analysis failed. Unable to provide recommendation due to technical error.";
     }
-  }
+}
+
+export async function analyzeTokenPriceVolume(tokenAddress: string, priceVolumeHistory: { time: number, close: number, volumeUsd: number }[]): Promise<string> {
+    if (!tokenAddress || !Array.isArray(priceVolumeHistory) || priceVolumeHistory.length === 0) {
+        return "ERROR: Missing required token address or price/volume history.";
+    }
+
+    const ai = new GoogleGenAI({
+        apiKey: process.env.GEMINI_API_KEY,
+    });
+
+    // Format data for the prompt
+    const historyInfo = priceVolumeHistory.map((item, idx) =>
+        `Period ${idx + 1}: Time: ${new Date(item.time * 1000).toISOString()}, Close: ${item.close}, VolumeUSD: ${item.volumeUsd}`
+    ).join('\n');
+
+    const prompt = `
+Token Address: ${tokenAddress}
+
+Recent Price and Volume History:
+${historyInfo}
+
+Based solely on this price and volume history, provide a concise 2-3 line verdict on the token's recent trend and trading activity. Consider price movement, volume spikes, and any notable patterns. Format your response as a direct recommendation. Use a single emoji at the start to indicate the emotion of the response (e.g., 🚀 for bullish, ⚠️ for caution, 🛑 for bearish, etc).`;
+
+    try {
+        const response = await ai.models.generateContent({
+            model: "gemini-2.0-flash",
+            contents: prompt,
+        });
+        return response.text || "Analysis failed. Gemini did not return a response.";
+    } catch (error) {
+        console.error("Error analyzing token price/volume:", error);
+        return "Analysis failed. Unable to provide recommendation due to technical error.";
+    }
+}

services/bot.ts

@@ -0,0 +1,114 @@
+import { ChartJSNodeCanvas } from 'chartjs-node-canvas';
+import { ChartConfiguration } from 'chart.js';
+
+const width = 800;
+const height = 400;
+
+const chartJSNodeCanvas = new ChartJSNodeCanvas({ width, height });
+
+export async function generateLineChart(
+    labels: string[],
+    priceData: number[],
+    volumeData: number[],
+    title: string
+): Promise<Buffer> {
+    // Helper to calculate min/max with padding
+    function getAxisLimits(data: number[]): { min: number, max: number } {
+        const filtered = data.filter((v) => !isNaN(v));
+        if (filtered.length === 0) return { min: 0, max: 1 };
+        const min = Math.min(...filtered);
+        const max = Math.max(...filtered);
+        if (min === max) {
+            // Flat line: add small padding
+            const pad = min === 0 ? 1 : Math.abs(min) * 0.05;
+            return { min: min - pad, max: max + pad };
+        }
+        const range = max - min;
+        return { min: min - range * 0.1, max: max + range * 0.1 };
+    }
+    const priceLimits = getAxisLimits(priceData);
+    const volumeLimits = getAxisLimits(volumeData);
+    const configuration: ChartConfiguration = {
+        type: 'line',
+        data: {
+            labels,
+            datasets: [
+                {
+                    label: 'Price',
+                    data: priceData,
+                    borderColor: 'rgb(75, 192, 192)',
+                    tension: 0.0001,
+                    yAxisID: 'y',
+                },
+                {
+                    label: 'Volume',
+                    data: volumeData,
+                    borderColor: 'rgb(153, 102, 255)',
+                    tension: 0.0001,
+                    yAxisID: 'y1',
+                },
+            ],
+        },
+        options: {
+            responsive: true,
+            interaction: {
+                mode: 'index',
+                intersect: false,
+            },
+            plugins: {
+                title: {
+                    display: true,
+                    text: title,
+                },
+                legend: {
+                    display: true,
+                },
+                tooltip: {
+                    callbacks: {
+                        label: function(context: any) {
+                            // Show up to 8 decimals for small values
+                            return `${context.dataset.label}: ${context.parsed.y.toFixed(8)}`;
+                        }
+                    }
+                }
+            },
+            scales: {
+                y: {
+                    type: 'linear',
+                    display: true,
+                    position: 'left',
+                    title: {
+                        display: true,
+                        text: 'Price',
+                    },
+                    min: priceLimits.min,
+                    max: priceLimits.max,
+                },
+                y1: {
+                    type: 'linear',
+                    display: true,
+                    position: 'right',
+                    title: {
+                        display: true,
+                        text: 'Volume',
+                    },
+                    min: volumeLimits.min,
+                    max: volumeLimits.max,
+                    grid: {
+                        drawOnChartArea: false,
+                    },
+                },
+            },
+        },
+    };
+
+    // If all values are zero or nearly constant, optionally overlay a message
+    const allZeroOrFlat = (arr: number[]) => arr.every((v) => Math.abs(v - arr[0]) < 1e-12);
+    if (allZeroOrFlat(priceData) && allZeroOrFlat(volumeData)) {
+        // Overlay text if the chart would be blank
+        const buffer = await chartJSNodeCanvas.renderToBuffer(configuration);
+        // Optionally: add text overlay here if needed (requires more canvas manipulation)
+        return buffer;
+    }
+    return await chartJSNodeCanvas.renderToBuffer(configuration);
+}

services/geminiService.ts

@@ -0,0 +1,87 @@
+import { ChartJSNodeCanvas } from 'chartjs-node-canvas';
+import { ChartConfiguration } from 'chart.js';
+import ChartDataLabels from 'chartjs-plugin-datalabels';
+import fs from 'fs';
+import path from 'path';
+
+// Helper function to generate pie chart
+export async function generatePieChart(tokens: any[]) {
+    const width = 800;
+    const height = 600;
+    const chartJSNodeCanvas = new ChartJSNodeCanvas({
+        width,
+        height,
+        chartCallback: (ChartJS) => {
+            ChartJS.register(ChartDataLabels); // 👈 Important for showing labels
+        }
+    });
+
+    const labels = tokens.map(token => token.symbol);
+    const data = tokens.map(token => Number(token.valueUsd));
+
+    const total = data.reduce((sum, value) => sum + value, 0); // Total value for percentage calculation
+
+    const backgroundColors = [
+        '#4e79a7', '#f28e2c', '#e15759', '#76b7b2',
+        '#59a14f', '#edc949', '#af7aa1', '#ff9da7',
+        '#9c755f', '#bab0ab'
+    ];
+
+    const configuration: ChartConfiguration<'pie', number[], unknown> = {
+        type: 'pie',
+        data: {
+            labels,
+            datasets: [{
+                data,
+                backgroundColor: backgroundColors,
+                borderWidth: 1,
+                borderColor: '#ffffff',
+            }]
+        },
+        options: {
+            responsive: true,
+            plugins: {
+                legend: {
+                    position: 'bottom',
+                },
+                title: {
+                    display: true,
+                    text: 'Token Balance Distribution',
+                    font: {
+                        size: 24,
+                    }
+                },
+                datalabels: {
+                    color: '#000000', // black for better visibility
+                    align: 'center',  // center the label inside the pie slice
+                    anchor: 'center', // anchor the label in the center of the slice
+                    formatter: (value: number, context: any) => {
+                        const label = context.chart.data.labels?.[context.dataIndex] || '';
+                        const percentage = (value / total) * 100;
+
+                        // Show label only if percentage is >= 10%
+                        if (percentage >= 10) {
+                            return `${label}: $${value.toFixed(2)}\n(${percentage.toFixed(2)}%)`;
+                        }
+                        return ''; // Hide label for smaller segments
+                    },
+                    font: {
+                        weight: 'bold',
+                        size: 12,
+                    },
+                    clamp: true,
+                    textAlign:'center'
+                },
+            },
+            layout: {
+                padding: 20,
+            }
+        }
+    };
+
+    const image = await chartJSNodeCanvas.renderToBuffer(configuration);
+
+    const filePath = path.join(__dirname, `token_balance_chart_${Date.now()}.png`);
+    fs.writeFileSync(filePath, image);
+    return filePath;
+}

types/index.ts

@@ -0,0 +1,23 @@
+const TELEGRAM_MESSAGE_LIMIT = 4096; // Telegram's official limit
+
+export async function sendLargeMessage(bot: any, chatId: number, message: string, options: any) {
+    const chunks: string[] = [];
+    let currentChunk = '';
+
+    const tokens = message.split('\n\n'); // Split at end of each token block
+
+    for (const token of tokens) {
+        if ((currentChunk + token + '\n\n').length > TELEGRAM_MESSAGE_LIMIT) {
+            chunks.push(currentChunk);
+            currentChunk = '';
+        }
+        currentChunk += token + '\n\n';
+    }
+
+    if (currentChunk) chunks.push(currentChunk);
+
+    for (let i = 0; i < chunks.length; i++) {
+        const chunkMessage = i === 0 ? chunks[i] : `...continued\n\n${chunks[i]}`;
+        await bot.sendMessage(chatId, chunkMessage.trim(), options);
+    }
+}