LicenseChain Telegram Bot

Official Telegram Bot for LicenseChain - License management and customer support through Telegram.

🚀 Features

🔐 License Management - Validate, create, and manage licenses
👤 User Support - Handle customer inquiries and support tickets
📊 Analytics - View usage statistics and performance metrics
🔔 Notifications - Real-time license events and alerts
🎫 Ticket System - Create and manage support tickets
📈 Reporting - Generate reports and analytics
🛡️ Security - Secure authentication and authorization
🛠️ Easy Setup - Simple configuration and deployment

📦 Installation

Method 1: npm (Recommended)

# Clone the repository
git clone https://github.com/LicenseChain/LicenseChain-TG-Bot.git
cd LicenseChain-TG-Bot

# Install dependencies
npm install

# Start the bot
npm start

Method 2: Docker

# Build the Docker image
docker build -t licensechain-telegram-bot .

# Run the container
docker run -p 3000:3000 licensechain-telegram-bot

Method 3: Manual Installation

Download the latest release from GitHub Releases
Extract to your project directory
Install dependencies: npm install
Configure environment variables
Start the bot: npm start

🚀 Quick Start

Basic Setup

# Clone the repository
git clone https://github.com/LicenseChain/LicenseChain-TG-Bot.git
cd LicenseChain-TG-Bot

# Install dependencies
npm install

# Copy environment file
cp .env.example .env

# Edit environment variables
nano .env

# Start the bot
npm start

Environment Configuration

Create a .env file with the following variables:

# Telegram Configuration
TELEGRAM_TOKEN=your-telegram-bot-token
TELEGRAM_WEBHOOK_URL=your-webhook-url

# LicenseChain API
LICENSECHAIN_API_KEY=your-api-key
LICENSECHAIN_APP_NAME=your-app-name
LICENSECHAIN_APP_VERSION=1.0.0
LICENSECHAIN_BASE_URL=https://api.licensechain.com

# Bot Configuration
BOT_DEBUG=false
BOT_OWNER_ID=your-telegram-user-id

# Database Configuration
DATABASE_URL=your-database-url

# Webhook Configuration
WEBHOOK_URL=your-webhook-url
WEBHOOK_SECRET=your-webhook-secret

📚 Commands

License Commands

# Validate a license
/validate <license-key>

# Get license information
/info <license-key>

# List user's licenses
/m licenses

# Create a new license
/create <user-id> <features> <expires>

# Update a license
/update <license-key> <field> <value>

# Revoke a license
/revoke <license-key>

User Commands

# Get user information
/user <user-id>

# Get user's licenses
/licenses <user-id>

# Get user's analytics
/analytics <user-id>

# Ban a user
/ban <user-id> <reason>

# Unban a user
/unban <user-id>

Support Commands

# Create a support ticket
/ticket <subject> <description>

# List support tickets
/tickets

# Get ticket details
/ticket <ticket-id>

# Update ticket status
/update <ticket-id> <status>

# Close a ticket
/close <ticket-id>

Analytics Commands

# Get usage analytics
/usage [timeframe]

# Get license analytics
/licenses [timeframe]

# Get performance metrics
/performance

# Get error statistics
/errors

Admin Commands

# Get bot status
/status

# Get bot statistics
/stats

# Reload commands
/reload

# Set bot status
/setstatus <status>

# Get bot logs
/logs [lines]

🔧 Configuration

Bot Configuration

Configure the bot through environment variables or a configuration file:

// config/bot.js
module.exports = {
  telegram: {
    token: process.env.TELEGRAM_TOKEN,
    webhookUrl: process.env.TELEGRAM_WEBHOOK_URL
  },
  licensechain: {
    apiKey: process.env.LICENSECHAIN_API_KEY,
    appName: process.env.LICENSECHAIN_APP_NAME,
    version: process.env.LICENSECHAIN_APP_VERSION,
    baseUrl: process.env.LICENSECHAIN_BASE_URL
  },
  bot: {
    debug: process.env.BOT_DEBUG === 'true',
    ownerId: process.env.BOT_OWNER_ID
  }
};

Command Configuration

Configure commands and their permissions:

// config/commands.js
module.exports = {
  'validate': {
    permission: 'user',
    cooldown: 5000,
    description: 'Validate a license key'
  },
  'create': {
    permission: 'admin',
    cooldown: 10000,
    description: 'Create a new license'
  },
  'status': {
    permission: 'owner',
    cooldown: 0,
    description: 'Get bot status'
  }
};

Database Configuration

The bot supports multiple database types:

// PostgreSQL
DATABASE_URL=postgresql://username:password@localhost:5432/licensechain

// MySQL
DATABASE_URL=mysql://username:password@localhost:3306/licensechain

// SQLite
DATABASE_URL=sqlite://./database.sqlite

🛡️ Security Features

Authentication

Telegram user verification
Role-based command permissions
User authentication system
Secure API key management

Authorization

Command-level permissions
User role validation
Admin-only commands
Owner-only functions

Data Protection

Input validation and sanitization
SQL injection prevention
XSS protection
Secure logging

📊 Analytics and Monitoring

Command Analytics

// Track command usage
bot.on('message', async (ctx) => {
  if (ctx.message.text.startsWith('/')) {
    analytics.track('command_used', {
      command: ctx.message.text.split(' ')[0],
      user: ctx.from.id,
      chat: ctx.chat.id,
      timestamp: new Date()
    });
  }
});

Performance Monitoring

// Monitor command execution time
const start = Date.now();
await command.execute(ctx);
const duration = Date.now() - start;
metrics.record('command_execution_time', duration);

Error Tracking

// Track command errors
try {
  await command.execute(ctx);
} catch (error) {
  errorTracker.captureException(error, {
    command: ctx.message.text.split(' ')[0],
    user: ctx.from.id,
    chat: ctx.chat.id
  });
}

🔄 Error Handling

Custom Error Types

// Custom error classes
class CommandError extends Error {
  constructor(message) {
    super(message);
    this.name = 'CommandError';
  }
}

class PermissionError extends Error {
  constructor(message) {
    super(message);
    this.name = 'PermissionError';
  }
}

Error Middleware

// Global error handler
bot.catch((err, ctx) => {
  console.error('Bot error:', err);
  errorTracker.captureException(err);
  
  ctx.reply('An error occurred. Please try again later.');
});

process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
  errorTracker.captureException(reason);
});

🧪 Testing

Unit Tests

# Run tests
npm test

# Run tests with coverage
npm run test:coverage

# Run tests in watch mode
npm run test:watch

Integration Tests

# Test with real Telegram API
npm run test:integration

End-to-End Tests

# Test complete command flows
npm run test:e2e

📝 Examples

See the examples/ directory for complete examples:

basic-setup.js - Basic bot setup
custom-commands.js - Custom command examples
webhook-integration.js - Webhook handling
deployment.js - Deployment configuration

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Development Setup

Clone the repository
Install Node.js 16 or later
Install dependencies: npm install
Set up environment variables
Start development server: npm run dev

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🆘 Support

Documentation: https://docs.licensechain.com/telegram-bot
Issues: GitHub Issues
Discord: LicenseChain Discord
Email: support@licensechain.com

🔗 Related Projects

Made with ❤️ for the Telegram community

Name		Name	Last commit message	Last commit date
Latest commit History 4 Commits
src		src
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
package.json		package.json

License

LicenseChain/LicenseChain-TG-Bot

Folders and files

Latest commit

History

Repository files navigation