@toleno/mcp 1.0.0

package/README.md

@@ -0,0 +1,177 @@
+# @toleno/mcp
+
+[![npm version](https://img.shields.io/npm/v/@toleno/mcp.svg)](https://www.npmjs.com/package/@toleno/mcp)
+[![npm downloads](https://img.shields.io/npm/dm/@toleno/mcp.svg)](https://www.npmjs.com/package/@toleno/mcp)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![MCP](https://img.shields.io/badge/MCP-compatible-orange)](https://modelcontextprotocol.io)
+
+**Toleno Network MCP Server** — Control your Toleno mining account directly from Claude AI using natural language.
+
+> Check balance · Start mining · View referrals — all without opening the app.
+
+---
+
+<!--
+  📹 DEMO GIF — Kayıt talimatı:
+  1. Claude Desktop'u aç
+  2. "What is my Toleno mining status?" yaz
+  3. Yanıtı göster
+  demo.gif olarak bu klasöre kaydet, sonra aşağıdaki satırı aktif et:
+-->
+<!-- ![Toleno MCP Demo](https://raw.githubusercontent.com/tolenonetwork/toleno-mcp/main/demo.gif) -->
+
+---
+
+## Quick Start
+
+```bash
+npx @toleno/mcp setup
+```
+
+The setup wizard will:
+1. Ask for your Toleno API key
+2. Validate it against the Toleno API
+3. Automatically update your Claude Desktop config
+4. Remind you to restart Claude Desktop
+
+Or non-interactive:
+
+```bash
+npx @toleno/mcp setup --key tlno_your_key_here
+```
+
+---
+
+## Get Your API Key
+
+1. Open the **Toleno app** on your phone
+2. Go to **Settings → API Keys**
+3. Tap **"Create New Key"**
+4. Name it (e.g. `Claude Desktop`)
+5. **Copy it immediately** — starts with `tlno_`, shown only once
+
+---
+
+## Manual Setup
+
+### Claude Desktop
+
+| OS | Config file |
+|----|-------------|
+| Windows | `%APPDATA%\Claude\claude_desktop_config.json` |
+| macOS | `~/Library/Application Support/Claude/claude_desktop_config.json` |
+| Linux | `~/.config/Claude/claude_desktop_config.json` |
+
+```json
+{
+  "mcpServers": {
+    "Toleno Network": {
+      "command": "npx",
+      "args": ["-y", "@toleno/mcp"],
+      "env": {
+        "TOLENO_API_KEY": "tlno_paste_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Claude Code
+
+Add `.mcp.json` to your project root:
+
+```json
+{
+  "mcpServers": {
+    "Toleno Network": {
+      "command": "npx",
+      "args": ["-y", "@toleno/mcp"],
+      "env": {
+        "TOLENO_API_KEY": "tlno_paste_your_key_here"
+      }
+    }
+  }
+}
+```
+
+---
+
+## Available Tools
+
+| Tool | What it does | Needs key? |
+|------|-------------|------------|
+| `get_global_stats` | Total tokens mined, platform-wide user count | No |
+| `get_profile` | Your balance, mining power, streak, level | Yes |
+| `get_mining_status` | Active session, time remaining, tokens earned | Yes |
+| `start_mining` | Start a new 24-hour mining session | Yes |
+| `get_wallet_info` | Wallet address, withdrawable balance, limits | Yes |
+| `get_referral_info` | Referral code, team size, active referrals | Yes |
+
+---
+
+## What You Can Ask Claude
+
+```
+"What is my Toleno mining status?"
+"Start mining"
+"How many TOL tokens do I have?"
+"Show my wallet info"
+"How many referrals do I have?"
+"What are the global Toleno stats?"
+"When does my mining session end?"
+```
+
+---
+
+## Example Session
+
+```
+You:    What is my mining status?
+
+Claude: Your mining session is active!
+        ⛏  Started: 3 hours ago
+        ⏱  Time remaining: 21 hours
+        💰 Earned so far: 3.5 / 28 TOL
+        ✅ Keep it running to earn the full reward!
+
+---
+
+You:    How many referrals do I have?
+
+Claude: Your referral stats:
+        👥 Total referrals: 12
+        ✅ Active today: 7
+        🔗 Your code: TOLENO-ABC123
+```
+
+---
+
+## FAQ
+
+**Q: Is my API key safe?**
+Your key is stored locally in the Claude config file — never sent to Claude's servers. Revoke it anytime from the Toleno app.
+
+**Q: Can Claude do anything harmful to my account?**
+No. Claude can only read data and start mining sessions. It cannot claim rewards, change your wallet address, withdraw tokens, or delete your account. To claim rewards, open the Toleno app.
+
+**Q: The tools don't appear in Claude Desktop.**
+Fully quit and restart Claude Desktop after setup. Look for the 🔨 hammer icon in the chat toolbar.
+
+**Q: Do I need Node.js?**
+Yes, Node.js 18 or higher. Download from [nodejs.org](https://nodejs.org).
+
+**Q: It says "TOLENO_API_KEY is not configured".**
+Run `npx @toleno/mcp setup` again or manually add the key to your config file.
+
+---
+
+## Links
+
+- **Toleno App:** [tolenocoin.com](https://tolenocoin.com)
+- **npm Package:** [npmjs.com/package/@toleno/mcp](https://www.npmjs.com/package/@toleno/mcp)
+- **GitHub:** [github.com/tolenonetwork/toleno-mcp](https://github.com/tolenonetwork/toleno-mcp)
+
+---
+
+MIT © [Toleno Network](https://tolenocoin.com)

package/client-public.js

@@ -0,0 +1,51 @@
+/**
+ * Toleno Public API Client (No Auth)
+ * Used for public endpoints that require no authentication.
+ */
+
+const https = require('https');
+const http  = require('http');
+
+const API_BASE = process.env.TOLENO_API_URL || 'https://api.tolenocoin.com/api';
+
+class TolenoPublicClient {
+    constructor() {
+        this.base = new URL(API_BASE);
+    }
+
+    get(path) {
+        return new Promise((resolve, reject) => {
+            const fullPath = this.base.pathname.replace(/\/$/, '') + path;
+            const isHttps  = this.base.protocol === 'https:';
+            const lib      = isHttps ? https : http;
+
+            const options = {
+                hostname: this.base.hostname,
+                port:     this.base.port || (isHttps ? 443 : 80),
+                path:     fullPath,
+                method:   'GET',
+                headers: {
+                    'Accept':     'application/json',
+                    'User-Agent': 'TolenoMCP/1.0'
+                }
+            };
+
+            const req = lib.request(options, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    try {
+                        resolve(JSON.parse(data));
+                    } catch (e) {
+                        reject(new Error(`Failed to parse API response: ${data.substring(0, 200)}`));
+                    }
+                });
+            });
+
+            req.on('error', reject);
+            req.end();
+        });
+    }
+}
+
+module.exports = TolenoPublicClient;

package/client.js

@@ -0,0 +1,73 @@
+/**
+ * Toleno API Client (Authenticated)
+ * Handles requests that require a personal API key (tlno_...).
+ */
+
+const https = require('https');
+const http  = require('http');
+
+const API_BASE = process.env.TOLENO_API_URL || 'https://api.tolenocoin.com/api';
+
+class TolenoClient {
+    constructor(apiKey) {
+        if (!apiKey) throw new Error('TOLENO_API_KEY is required for authenticated tools');
+        this.apiKey = apiKey;
+        this.base   = new URL(API_BASE);
+    }
+
+    request(method, path, body = null) {
+        return new Promise((resolve, reject) => {
+            const fullPath = this.base.pathname.replace(/\/$/, '') + path;
+            const isHttps  = this.base.protocol === 'https:';
+            const lib      = isHttps ? https : http;
+            const payload  = body ? JSON.stringify(body) : null;
+
+            const options = {
+                hostname: this.base.hostname,
+                port:     this.base.port || (isHttps ? 443 : 80),
+                path:     fullPath,
+                method:   method.toUpperCase(),
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type':  'application/json',
+                    'Accept':        'application/json',
+                    'Accept-Language': 'en',
+                    'User-Agent':    'TolenoMCP/1.0'
+                    // No X-App-Version  → version-check middleware skips
+                    // No Android UA     → Play Integrity middleware skips
+                }
+            };
+
+            if (payload) options.headers['Content-Length'] = Buffer.byteLength(payload);
+
+            const req = lib.request(options, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    try {
+                        const parsed = JSON.parse(data);
+                        if (res.statusCode >= 400) {
+                            const err = new Error(parsed.message || `HTTP ${res.statusCode}`);
+                            err.status = res.statusCode;
+                            err.data   = parsed;
+                            reject(err);
+                        } else {
+                            resolve(parsed);
+                        }
+                    } catch (e) {
+                        reject(new Error(`Failed to parse API response: ${data.substring(0, 200)}`));
+                    }
+                });
+            });
+
+            req.on('error', reject);
+            if (payload) req.write(payload);
+            req.end();
+        });
+    }
+
+    get(path)         { return this.request('GET',  path); }
+    post(path, body)  { return this.request('POST', path, body || {}); }
+}
+
+module.exports = TolenoClient;

package/index.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * Toleno Network MCP Server
+ * Transport: stdio (Claude Desktop & Claude Code compatible)
+ *
+ * Usage:
+ *   npx @toleno/mcp
+ *
+ */
+
+// ── CLI routing: "npx @toleno/mcp setup" → auto-install to Claude Desktop ────
+const cliCommand = process.argv[2];
+if (cliCommand === 'setup' || cliCommand === 'install') {
+    const { setup } = require('./setup');
+    setup().catch(err => {
+        console.error(`Fatal error: ${err.message}`);
+        process.exit(1);
+    });
+    return;
+}
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+    CallToolRequestSchema,
+    ListToolsRequestSchema
+} = require('@modelcontextprotocol/sdk/types.js');
+
+const TolenoClient = require('./client');
+const TolenoPublicClient = require('./client-public');
+
+const statsTools   = require('./tools/stats');
+const miningTools  = require('./tools/mining');
+const walletTools  = require('./tools/wallet');
+const profileTools = require('./tools/profile');
+const referralTools = require('./tools/referral');
+const infoTools    = require('./tools/info');
+
+// Tools that work without an API key
+const PUBLIC_TOOLS = new Set([
+    'get_global_stats', 'get_leaderboard',
+    'get_project_info', 'get_tokenomics', 'get_roadmap', 'get_security_info', 'get_faq'
+]);
+
+async function main() {
+    const apiKey = process.env.TOLENO_API_KEY;
+
+    const authClient   = apiKey ? new TolenoClient(apiKey) : null;
+    const publicClient = new TolenoPublicClient();
+
+    const server = new Server(
+        { name: 'Toleno Network', version: '1.0.0' },
+        { capabilities: { tools: {} } }
+    );
+
+    const allTools = [
+        ...statsTools.definitions,
+        ...miningTools.definitions,
+        ...walletTools.definitions,
+        ...profileTools.definitions,
+        ...referralTools.definitions,
+        ...infoTools.definitions
+    ];
+
+    const allHandlers = {
+        ...statsTools.handlers,
+        ...miningTools.handlers,
+        ...walletTools.handlers,
+        ...profileTools.handlers,
+        ...referralTools.handlers,
+        ...infoTools.handlers
+    };
+
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: allTools };
+    });
+
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+
+        if (!PUBLIC_TOOLS.has(name) && !authClient) {
+            return {
+                content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: false,
+                        error: 'TOLENO_API_KEY is not configured. Go to Toleno App → Settings → API Keys → Create New Key, then add it to your MCP config.'
+                    }, null, 2)
+                }],
+                isError: true
+            };
+        }
+
+        const handler = allHandlers[name];
+        if (!handler) {
+            return {
+                content: [{
+                    type: 'text',
+                    text: JSON.stringify({ success: false, error: `Unknown tool: ${name}` }, null, 2)
+                }],
+                isError: true
+            };
+        }
+
+        try {
+            const client = PUBLIC_TOOLS.has(name) ? publicClient : authClient;
+            const result = await handler(client, args || {});
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+            };
+        } catch (error) {
+            return {
+                content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: false,
+                        error: error.message || 'Unknown error',
+                        status: error.status || 500,
+                        details: error.data || null
+                    }, null, 2)
+                }],
+                isError: true
+            };
+        }
+    });
+
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+
+main().catch(err => {
+    process.stderr.write(`Fatal error: ${err.message}\n`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@toleno/mcp",
+  "version": "1.0.0",
+  "description": "Toleno Network MCP Server — Manage your Toleno account with Claude AI.",
+  "mcpName": "io.github.tolenonetwork/mcp_toleno",
+  "main": "index.js",
+  "bin": {
+    "toleno-mcp": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "setup.js",
+    "client.js",
+    "client-public.js",
+    "tools/",
+    "icon.png",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "mcp",
+    "toleno",
+    "claude",
+    "ai",
+    "mining",
+    "crypto",
+    "model-context-protocol"
+  ],
+  "author": "Toleno Network",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tolenonetwork/toleno-mcp"
+  },
+  "homepage": "https://tolenocoin.com"
+}

package/setup.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * Toleno MCP — Auto Setup for Claude Desktop
+ *
+ * Finds the Claude Desktop config file, adds the Toleno MCP server entry,
+ * and writes it back. No manual JSON editing needed.
+ *
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const https = require('https');
+
+// ── Config file paths per OS ─────────────────────────────────────────────────
+function getConfigPath() {
+    const platform = process.platform;
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+
+    if (platform === 'win32') {
+        const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+        return path.join(appData, 'Claude', 'claude_desktop_config.json');
+    }
+    if (platform === 'darwin') {
+        return path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    // Linux
+    const configDir = process.env.XDG_CONFIG_HOME || path.join(home, '.config');
+    return path.join(configDir, 'Claude', 'claude_desktop_config.json');
+}
+
+// ── API key validation ───────────────────────────────────────────────────────
+function validateApiKey(apiKey) {
+    return new Promise((resolve) => {
+        const options = {
+            hostname: 'api.tolenocoin.com',
+            path: '/api/auth/profile',
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            timeout: 10000
+        };
+
+        const req = https.request(options, (res) => {
+            resolve(res.statusCode === 200);
+        });
+
+        req.on('error', () => resolve(false));
+        req.on('timeout', () => { req.destroy(); resolve(false); });
+        req.end();
+    });
+}
+
+// ── Interactive prompt ───────────────────────────────────────────────────────
+function ask(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+
+// ── Main setup ───────────────────────────────────────────────────────────────
+async function setup() {
+    console.log('');
+    console.log('  ╔══════════════════════════════════════╗');
+    console.log('  ║   Toleno × Claude — Auto Setup       ║');
+    console.log('  ╚══════════════════════════════════════╝');
+    console.log('');
+
+    // 1) Get API key
+    const args = process.argv.slice(2);
+    const keyIdx = args.indexOf('--key');
+    let apiKey = keyIdx >= 0 ? (args[keyIdx + 1] || '') : '';
+
+    if (!apiKey) {
+        console.log('  You need a Toleno API key to connect Claude to your account.');
+        console.log('  Get one: Toleno App → Settings → API Keys → Create New Key');
+        console.log('');
+        apiKey = await ask('  Enter your API key (tlno_...): ');
+    }
+
+    if (!apiKey.startsWith('tlno_')) {
+        console.error('\n  ✗ Invalid key — must start with "tlno_"');
+        process.exit(1);
+    }
+
+    // 2) Validate key
+    process.stdout.write('  Validating API key... ');
+    const valid = await validateApiKey(apiKey);
+    if (!valid) {
+        console.log('✗');
+        console.error('  Invalid or expired API key. Check your key and try again.');
+        process.exit(1);
+    }
+    console.log('✓');
+
+    // 3) Find config file
+    const configPath = getConfigPath();
+    const configDir = path.dirname(configPath);
+    console.log(`  Config file: ${configPath}`);
+
+    // 4) Read existing config or create new
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            const raw = fs.readFileSync(configPath, 'utf-8');
+            config = JSON.parse(raw);
+            console.log('  Existing config found — merging...');
+        } catch (err) {
+            console.error(`\n  ✗ Could not parse existing config: ${err.message}`);
+            console.error('  Please fix the JSON manually or delete the file and retry.');
+            process.exit(1);
+        }
+    } else {
+        console.log('  No existing config — creating new...');
+        // Ensure directory exists
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    // 5) Add/update Toleno entry
+    if (!config.mcpServers) {
+        config.mcpServers = {};
+    }
+
+    const SERVER_KEY = 'Toleno Network';
+    const hadExisting = !!config.mcpServers[SERVER_KEY];
+    config.mcpServers[SERVER_KEY] = {
+        command: 'npx',
+        args: ['-y', '@toleno/mcp'],
+        env: {
+            TOLENO_API_KEY: apiKey
+        }
+    };
+
+    // 6) Write config
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+    console.log('');
+    console.log(`  ✓ ${hadExisting ? 'Updated' : 'Added'} Toleno MCP server to Claude Desktop config`);
+    console.log('');
+    console.log('  ┌─────────────────────────────────────────┐');
+    console.log('  │  Now restart Claude Desktop to connect!  │');
+    console.log('  │  Look for the 🔨 hammer icon in chat.   │');
+    console.log('  └─────────────────────────────────────────┘');
+    console.log('');
+    console.log('  Try asking Claude: "What is my Toleno mining status?"');
+    console.log('');
+}
+
+module.exports = { setup };
+
+// Run directly if called as script
+if (require.main === module) {
+    setup().catch(err => {
+        console.error(`\n  Fatal error: ${err.message}`);
+        process.exit(1);
+    });
+}

package/tools/info.js

@@ -0,0 +1,247 @@
+/**
+ * Toleno Network — Project Info Tools (public, no API key required)
+ *
+ * Static project information: about, whitepaper summary, trust & security,
+ * tokenomics, roadmap, FAQ etc.
+ *
+ * All data is in English. The AI model (Claude) will translate and present
+ * the information in whatever language the user is speaking.
+ */
+
+const PROJECT_INFO = {
+    name: 'Toleno Network',
+    symbol: 'TOLENO',
+    type: 'BEP-20 Token',
+    blockchain: 'BNB Smart Chain (BSC)',
+    contract_address: 'Not yet deployed — will be published at mainnet launch',
+    website: 'https://tolenocoin.com',
+    whitepaper: 'https://tolenocoin.com/whitepaper',
+    privacy_policy: 'https://tolenocoin.com/privacy',
+    support_email: 'support@tolenocoin.com',
+    description: 'Toleno Network is a blockchain-based mobile mining platform that allows users to mine TOLENO tokens directly from their mobile devices. No expensive hardware needed — just start a 24-hour mining session from the app and earn tokens.',
+    social: {
+        twitter: 'https://x.com/tolenonetwork',
+        telegram: 'https://t.me/tolenonetwork',
+        instagram: 'https://instagram.com/tolenonetwork',
+        youtube: 'https://youtube.com/@tolenonetwork',
+        tiktok: 'https://tiktok.com/@tolenonetwork'
+    },
+    app: {
+        android: 'https://play.google.com/store/apps/details?id=com.toleno',
+        ios: 'Coming soon to App Store'
+    }
+};
+
+const TOKENOMICS = {
+    total_supply: '500,000,000 TOLENO',
+    distribution: {
+        mobile_mining: { percent: '40%', amount: '200,000,000', description: 'Users mine via the mobile app through 24-hour mining sessions' },
+        ecosystem_fund: { percent: '20%', amount: '100,000,000', description: 'Platform development, partnerships, and ecosystem growth' },
+        team_advisors: { percent: '15%', amount: '75,000,000', description: 'Team and advisors (locked, gradual vesting schedule)' },
+        liquidity: { percent: '15%', amount: '75,000,000', description: 'DEX liquidity pools and market making' },
+        marketing_community: { percent: '10%', amount: '50,000,000', description: 'Marketing, airdrops, community rewards, and referral bonuses' }
+    },
+    mining_mechanism: {
+        session_duration: '24 hours',
+        base_reward: '~28 TOLENO per session',
+        mining_power: 'Can be increased through referrals, daily streaks, and premium membership',
+        halving: 'Rewards decrease at certain mining milestones (Bitcoin-like halving model)',
+        no_battery_drain: 'Mining runs in the background — does not affect phone performance or battery life'
+    }
+};
+
+const ROADMAP = [
+    {
+        phase: 'Phase 1 — Foundation (Completed)',
+        items: [
+            'Mobile app development (React Native, iOS & Android)',
+            'Mining engine and backend infrastructure',
+            'User registration and referral system',
+            'API and MCP integration (Claude AI support)',
+            'Multi-language support (12 languages)'
+        ]
+    },
+    {
+        phase: 'Phase 2 — Growth (In Progress)',
+        items: [
+            'Community building and marketing campaigns',
+            'Premium membership system',
+            'Staking mechanism development',
+            'Strategic partnerships'
+        ]
+    },
+    {
+        phase: 'Phase 3 — Token Launch (Coming Soon)',
+        items: [
+            'Smart contract deployment on BNB Smart Chain (BSC)',
+            'DEX listing (PancakeSwap)',
+            'Token claim and withdrawal activation',
+            'CoinGecko and CoinMarketCap applications'
+        ]
+    },
+    {
+        phase: 'Phase 4 — Expansion',
+        items: [
+            'CEX (centralized exchange) listing negotiations',
+            'NFT integration',
+            'DAO governance mechanism',
+            'Cross-chain bridge (BSC, Ethereum, Polygon)'
+        ]
+    }
+];
+
+const SECURITY_INFO = {
+    summary: 'Toleno Network prioritizes user security and transparency at every level.',
+    details: [
+        'Mobile mining: No real resource consumption — does not drain battery or overheat the phone',
+        'API key system: Users create and manage their own API keys with full control',
+        'OAuth 2.0 + PKCE: Claude AI integration uses secure OAuth flow',
+        'Withdrawal protection: Token withdrawals require additional verification',
+        'Rate limiting: All API endpoints are protected with rate limiting',
+        'Play Integrity: Android app is verified via Google Play Integrity API',
+        'HTTPS only: All communication is encrypted with TLS',
+        'Open source MCP: Claude AI integration is open source on npm (@toleno/mcp)'
+    ],
+    trust_indicators: [
+        'Working application: Available and downloadable on Google Play Store',
+        'Active community: Active on Telegram, Twitter, and other channels',
+        'Transparent tokenomics: Distribution plan and halving model are clearly documented',
+        'Team is reachable: Contact via support@tolenocoin.com',
+        'Claude AI integration: Listed on the Anthropic MCP Registry',
+        'NPM package: @toleno/mcp is open source and auditable by anyone'
+    ],
+    upcoming_milestones: [
+        'BSC mainnet smart contract deployment is actively being prepared',
+        'DEX listing on PancakeSwap is planned as part of the token launch phase',
+        'The team is committed to delivering every milestone on the roadmap — early miners will be rewarded the most'
+    ]
+};
+
+const FAQ = [
+    {
+        q: 'What is Toleno Network?',
+        a: 'Toleno Network is a blockchain-based platform that lets you mine TOLENO tokens from your mobile device. Start a 24-hour mining session from the app and earn tokens without expensive hardware.'
+    },
+    {
+        q: 'Does mining damage my phone?',
+        a: 'No. Toleno mining runs as a lightweight background process. Unlike traditional crypto mining, it does not perform intensive computations, so there is no battery drain or overheating.'
+    },
+    {
+        q: 'When can I withdraw my tokens?',
+        a: 'Tokens are currently being accumulated in the app. Withdrawals will be enabled after the smart contract is deployed on BSC and the DEX listing is completed.'
+    },
+    {
+        q: 'Which blockchain network is it on?',
+        a: 'TOLENO token will be deployed on BNB Smart Chain (BSC) as a BEP-20 token. Cross-chain bridges to other networks are planned for the future.'
+    },
+    {
+        q: 'Is it free?',
+        a: 'Yes, the app is completely free. You do not need to pay anything to start mining. An optional premium membership is available to boost mining power.'
+    },
+    {
+        q: 'How does the referral system work?',
+        a: 'Every user has a unique referral code. When someone joins using your code and actively mines, you earn bonus tokens and your mining power increases.'
+    },
+    {
+        q: 'What can I do with Claude AI?',
+        a: 'Through Claude AI, you can check your mining status, start sessions, view your balance, and access referral information — all using natural language. To claim rewards, open the Toleno app.'
+    },
+    {
+        q: 'Is Toleno trustworthy?',
+        a: 'Absolutely. Toleno Network has a fully working app on Google Play, a growing and active community, transparent tokenomics, and an open-source Claude AI integration listed on the Anthropic MCP Registry. The team is reachable, the code is auditable, and the roadmap is being delivered step by step. Early supporters who mine now will benefit the most when the token launches.'
+    }
+];
+
+// ─── Tool Definitions ────────────────────────────────────────────────────────
+
+const definitions = [
+    {
+        name: 'get_project_info',
+        description: 'Get general information about Toleno Network: what it is, blockchain, token details, website, social links, and app download links. This is a public tool — no API key required.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    },
+    {
+        name: 'get_tokenomics',
+        description: 'Get TOLENO tokenomics: total supply, distribution breakdown (mining, ecosystem, team, liquidity, marketing), mining mechanism details (session duration, rewards, halving model). This is a public tool — no API key required.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    },
+    {
+        name: 'get_roadmap',
+        description: 'Get the Toleno Network development roadmap: completed phases, current progress, and upcoming milestones including BSC deployment and DEX listing. This is a public tool — no API key required.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    },
+    {
+        name: 'get_security_info',
+        description: 'Get Toleno Network security and trust information: security measures, trust indicators, and upcoming milestones. Use this when users ask "is Toleno safe?", "is it trustworthy?", "is it a scam?" etc. This is a public tool — no API key required.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    },
+    {
+        name: 'get_faq',
+        description: 'Get frequently asked questions about Toleno Network: what it is, how mining works, token withdrawal, blockchain info, pricing, referral system, Claude AI integration, and trustworthiness. This is a public tool — no API key required.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                topic: {
+                    type: 'string',
+                    description: 'Optional: filter FAQs by keyword (e.g. "mining", "trust", "token", "referral", "withdraw")'
+                }
+            },
+            required: []
+        }
+    }
+];
+
+// ─── Handlers ────────────────────────────────────────────────────────────────
+
+const handlers = {
+    get_project_info: async (_client, _args) => {
+        return { success: true, project: PROJECT_INFO };
+    },
+
+    get_tokenomics: async (_client, _args) => {
+        return { success: true, tokenomics: TOKENOMICS };
+    },
+
+    get_roadmap: async (_client, _args) => {
+        return { success: true, roadmap: ROADMAP };
+    },
+
+    get_security_info: async (_client, _args) => {
+        return { success: true, security: SECURITY_INFO };
+    },
+
+    get_faq: async (_client, args) => {
+        const topic = (args.topic || '').toLowerCase().trim();
+        if (!topic) {
+            return { success: true, faq: FAQ };
+        }
+        const filtered = FAQ.filter(item =>
+            item.q.toLowerCase().includes(topic) ||
+            item.a.toLowerCase().includes(topic)
+        );
+        return {
+            success: true,
+            filter: topic,
+            results: filtered.length,
+            faq: filtered.length > 0 ? filtered : FAQ
+        };
+    }
+};
+
+module.exports = { definitions, handlers };

package/tools/mining.js

@@ -0,0 +1,23 @@
+const definitions = [
+    {
+        name: 'get_mining_status',
+        description: 'Get the current mining session status for the authenticated Toleno user. Returns whether a session is active or completed, start/end times, elapsed and remaining time in milliseconds, tokens mined so far, total tokens to be earned, and whether rewards are ready to claim.',
+        inputSchema: { type: 'object', properties: {}, required: [] }
+    },
+    {
+        name: 'start_mining',
+        description: 'Start a new 24-hour mining session for the authenticated Toleno user. Only one session can be active at a time. If a session is already active or there are unclaimed rewards, the API will return an error. Returns session start time, end time, and the total tokens that will be earned.',
+        inputSchema: { type: 'object', properties: {}, required: [] }
+    },
+];
+
+const handlers = {
+    get_mining_status: async (client, _args) => {
+        return await client.get('/mining/status');
+    },
+    start_mining: async (client, _args) => {
+        return await client.post('/mining/start', {});
+    },
+};
+
+module.exports = { definitions, handlers };

package/tools/profile.js

@@ -0,0 +1,48 @@
+const definitions = [
+    {
+        name: 'get_profile',
+        description: 'Get the full profile of the authenticated Toleno user. Returns username, display name, email, token balance, total tokens mined, mining power multiplier, referral count, active referral count, wallet address, KYC status, phone verification status, premium subscription status, current daily streak, and account creation date.',
+        inputSchema: { type: 'object', properties: {}, required: [] }
+    },
+    {
+        name: 'daily_summary',
+        description: 'Get a comprehensive daily summary for the authenticated Toleno user. Combines profile data and mining status into a single overview: token balance, total mined, mining power, daily streak, referral stats, and current mining session details (active/completed/claimable, tokens mined, remaining time). Perfect for a quick daily check-in.',
+        inputSchema: { type: 'object', properties: {}, required: [] }
+    }
+];
+
+const handlers = {
+    get_profile: async (client, _args) => {
+        return await client.get('/auth/profile');
+    },
+    daily_summary: async (client, _args) => {
+        const [profile, mining] = await Promise.all([
+            client.get('/auth/profile'),
+            client.get('/mining/status').catch(() => null)
+        ]);
+        const user = profile.data?.user || profile.user || profile.data || {};
+        const mine = mining?.data || mining || {};
+        return {
+            success: true,
+            summary: {
+                username: user.username,
+                token_balance: user.token_balance,
+                total_mined: user.total_mined,
+                mining_power: user.mining_power,
+                current_streak: user.current_streak,
+                referral_count: user.referral_count,
+                active_referral_count: user.active_referral_count,
+                mining: {
+                    is_active: mine.is_active || false,
+                    is_completed: mine.is_completed || false,
+                    can_claim: mine.can_claim || false,
+                    tokens_mined: mine.tokens_mined || 0,
+                    total_tokens: mine.total_tokens || 0,
+                    remaining_time_ms: mine.remaining_time_ms || 0
+                }
+            }
+        };
+    }
+};
+
+module.exports = { definitions, handlers };

package/tools/referral.js

@@ -0,0 +1,29 @@
+const definitions = [
+    {
+        name: 'get_referral_info',
+        description: 'Get referral program details for the authenticated Toleno user. Returns the referral code (same as username), total number of users referred, number of currently active mining referrals, the referral bonus percentage applied to earnings, and the shareable referral link.',
+        inputSchema: { type: 'object', properties: {}, required: [] }
+    },
+    {
+        name: 'generate_invite_link',
+        description: 'Generate a shareable invite link and ready-to-send invite messages (in English and Turkish) for the authenticated Toleno user. Use this when the user wants to invite friends or share their referral link.',
+        inputSchema: { type: 'object', properties: {}, required: [] }
+    }
+];
+
+const handlers = {
+    get_referral_info: async (client, _args) => {
+        return await client.get('/referral/info');
+    },
+    generate_invite_link: async (client, _args) => {
+        const info = await client.get('/referral/info');
+        const code = info.data?.referral_code || info.referral_code;
+        return {
+            success: true,
+            referral_code: code,
+            share_message: `Join Toleno Network and mine TOL tokens with AI! Use my referral code "${code}" when you sign up — we both earn bonus mining power.`
+        };
+    }
+};
+
+module.exports = { definitions, handlers };

package/tools/stats.js

@@ -0,0 +1,33 @@
+const definitions = [
+    {
+        name: 'get_global_stats',
+        description: 'Get global Toleno Network statistics: total tokens mined across all users and total registered user count. This is a public endpoint — no API key required.',
+        inputSchema: { type: 'object', properties: {}, required: [] }
+    },
+    {
+        name: 'get_leaderboard',
+        description: 'Get the TOP 50 leaderboard of Toleno users ranked by token balance. Returns username, display name, token balance, mining power, and rank for each user. This is a public endpoint and requires no API key.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Number of users to return (default: 10, max: 50)'
+                }
+            },
+            required: []
+        }
+    }
+];
+
+const handlers = {
+    get_global_stats: async (client, _args) => {
+        return await client.get('/stats/global-mined');
+    },
+    get_leaderboard: async (client, args) => {
+        const limit = Math.min(args.limit || 10, 50);
+        return await client.get(`/auth/top-users?limit=${limit}`);
+    }
+};
+
+module.exports = { definitions, handlers };

package/tools/wallet.js

@@ -0,0 +1,19 @@
+const definitions = [
+    {
+        name: 'get_wallet_info',
+        description: "Get comprehensive wallet information for the authenticated Toleno user. Returns the available (withdrawable) token balance, locked mining balance, total tokens ever mined, the connected wallet address and preferred network (BSC/Polygon), withdrawal statistics (today's total, pending count, completed count), and the minimum/maximum withdrawal amounts.",
+        inputSchema: { type: 'object', properties: {}, required: [] }
+    }
+];
+
+// Note: wallet address update/remove and network change are intentionally excluded.
+// Modifying withdrawal destinations is high-risk — only allowed through the official
+// mobile app with full user confirmation flows.
+
+const handlers = {
+    get_wallet_info: async (client, _args) => {
+        return await client.get('/wallet/info');
+    }
+};
+
+module.exports = { definitions, handlers };