DEV Community: Steven

Discover Trending Crypto Tokens with GMGN.AI API: A Complete Developer Guide

Steven — Sat, 24 May 2025 16:21:59 +0000

The cryptocurrency market moves fast, and staying ahead of trends can make all the difference. Whether you're building a trading bot, portfolio tracker, or market analysis tool, having access to real-time token data is crucial. Today, I'll walk you through the GMGN.AI API - a powerful tool for tracking trending tokens across multiple blockchains.

What is GMGN.AI API?

GMGN.AI provides a comprehensive API that allows developers to access trending token data across major blockchains including Ethereum, Solana, Base, BSC, and Tron. What sets it apart is its focus on smart money tracking and safety filters to help identify legitimate opportunities while avoiding honeypots and scams.

Important Implementation Considerations

⚠️ Network Protection Notice: The GMGN.AI API is protected by advanced security measures including Cloudflare protection. For production applications, you'll need to implement appropriate request handling solutions that can work with protected endpoints. Consider using proxy services, rotating user agents, or specialized HTTP clients that can handle modern web security measures.

Key Features

🔍 Multi-chain Support: Ethereum, Solana, Base, BSC, and Tron

📊 Multiple Sorting Criteria: Volume, market cap, holder count, smart money activity, and more

🛡️ Safety Filters: Built-in honeypot detection, verification status, and ownership renouncement

⏱️ Flexible Time Periods: From 1-minute to 24-hour trending data

💡 Smart Money Insights: Track what experienced traders are buying and selling

Getting Started

The GMGN.AI API uses a RESTful endpoint structure that's easy to understand and implement:

https://gmgn.ai/defi/quotation/v1/rank/{chain}/swaps/{time_period}?orderby={criteria}&direction={direction}&filters[]={safety_filters}

Basic Parameters

Supported Chains {chain}:

eth - Ethereum
sol - Solana
base - Base
bsc - Binance Smart Chain
tron - Tron

Time Periods {time_period}:

1m, 5m, 1h, 6h, 24h

Sorting Criteria {criteria}:

volume - 24h trading volume
marketcap - Market capitalization
swaps - Number of transactions
holder_count - Number of holders
smartmoney - Smart money activity
liquidity - Available liquidity
And many more...

Direction {direction}:

asc: Ascending order
desc: Descending order

Practical Examples

Let's dive into some real-world use cases with code examples.

Level 1: Basic Token Discovery

High-Volume Ethereum Token Scanner

async function getHighVolumeTokens() {
    const url = 'https://gmgn.ai/defi/quotation/v1/rank/eth/swaps/6h?orderby=volume&direction=desc&filters[]=not_honeypot&filters[]=verified&filters[]=renounced';

    // Note: For production use, implement appropriate request handling
    // that can work with protected endpoints
    const requestOptions = {
        method: 'GET',
        headers: {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
            'Accept': 'application/json',
            'Referer': 'https://gmgn.ai/',
        }
    };

    try {
        const response = await fetch(url, requestOptions);
        const data = await response.json();

        if (data.code === 0) {
            const topTokens = data.data.rank.slice(0, 10);

            topTokens.forEach((token, index) => {
                console.log(`${index + 1}. ${token.symbol}`);
                console.log(`   Volume: ${token.volume.toLocaleString()}`);
                console.log(`   Price: ${token.price}`);
                console.log(`   Market Cap: ${token.market_cap.toLocaleString()}`);
                console.log(`   Holders: ${token.holder_count}`);
                console.log('---');
            });
        }
    } catch (error) {
        console.error('Error:', error);
        // Consider implementing retry logic with exponential backoff
    }
}

getHighVolumeTokens();

Level 2: Advanced Smart Money Analytics

Intelligent Smart Money Tracker

import requests
import pandas as pd
import time
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def create_session_with_retries():
    """Create a requests session with retry strategy and proper headers"""
    session = requests.Session()

    # Configure retry strategy
    retry_strategy = Retry(
        total=3,
        backoff_factor=1,
        status_forcelist=[429, 500, 502, 503, 504],
    )

    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)

    # Set headers that work better with protected endpoints
    session.headers.update({
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
        'Accept': 'application/json, text/plain, */*',
        'Accept-Language': 'en-US,en;q=0.9',
        'Referer': 'https://gmgn.ai/',
        'Origin': 'https://gmgn.ai'
    })

    return session

def track_smart_money(chain='sol', time_period='24h'):
    url = f"https://gmgn.ai/defi/quotation/v1/rank/{chain}/swaps/{time_period}"
    params = {
        'orderby': 'smartmoney',
        'direction': 'desc',
        'filters[]': ['not_honeypot', 'verified', 'renounced']
    }

    session = create_session_with_retries()

    try:
        response = session.get(url, params=params, timeout=30)
        data = response.json()

        if data['code'] == 0:
            tokens = data['data']['rank']

            # Create DataFrame for analysis
            df = pd.DataFrame([{
                'symbol': token['symbol'],
                'price': token['price'],
                'smart_buys': token['smart_buy_24h'],
                'smart_sells': token['smart_sell_24h'],
                'smart_ratio': token['smart_buy_24h'] / max(token['smart_sell_24h'], 1),
                'volume': token['volume'],
                'holders': token['holder_count']
            } for token in tokens[:20]])

            # Filter for tokens with strong smart money interest
            hot_tokens = df[df['smart_ratio'] > 3]  # More smart buys than sells

            print("🔥 Tokens with Strong Smart Money Interest:")
            print(hot_tokens.to_string(index=False))

            return hot_tokens

    except requests.exceptions.RequestException as e:
        print(f"Request failed: {e}")
        # In production, consider implementing alternative data sources

    return None

# Usage
smart_tokens = track_smart_money('sol', '6h')

Level 3: Enterprise-Grade API Client

Production-Ready GMGN Client

class GMGNApiClient {
    constructor() {
        this.baseUrl = 'https://gmgn.ai/defi/quotation/v1/rank';
        this.defaultHeaders = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
            'Accept': 'application/json',
            'Accept-Language': 'en-US,en;q=0.9',
            'Referer': 'https://gmgn.ai/',
            'Cache-Control': 'no-cache'
        };
        this.requestQueue = [];
        this.isProcessing = false;
    }

    async makeRequest(url, options = {}) {
        return new Promise((resolve, reject) => {
            this.requestQueue.push({ url, options, resolve, reject });
            this.processQueue();
        });
    }

    async processQueue() {
        if (this.isProcessing || this.requestQueue.length === 0) return;

        this.isProcessing = true;

        while (this.requestQueue.length > 0) {
            const { url, options, resolve, reject } = this.requestQueue.shift();

            try {
                // Add delay between requests to avoid rate limiting
                await this.delay(1000);

                const response = await fetch(url, {
                    ...options,
                    headers: { ...this.defaultHeaders, ...options.headers }
                });

                if (!response.ok) {
                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
                }

                const data = await response.json();
                resolve(data);

            } catch (error) {
                console.warn(`Request failed, retrying: ${error.message}`);

                // Implement exponential backoff for retries
                await this.delay(2000);

                try {
                    const retryResponse = await fetch(url, {
                        ...options,
                        headers: { ...this.defaultHeaders, ...options.headers }
                    });

                    if (retryResponse.ok) {
                        const data = await retryResponse.json();
                        resolve(data);
                    } else {
                        reject(new Error(`Retry failed: ${retryResponse.status}`));
                    }
                } catch (retryError) {
                    reject(retryError);
                }
            }
        }

        this.isProcessing = false;
    }

    delay(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    async getTrendingTokens(chain, timePeriod, orderBy = 'volume', filters = ['not_honeypot']) {
        const params = new URLSearchParams({
            orderby: orderBy,
            direction: 'desc'
        });

        filters.forEach(filter => params.append('filters[]', filter));

        const url = `${this.baseUrl}/${chain}/swaps/${timePeriod}?${params}`;

        return this.makeRequest(url);
    }
}

// Usage example
const apiClient = new GMGNApiClient();

async function findNewGems(chain = 'base') {
    try {
        const data = await apiClient.getTrendingTokens(
            chain, 
            '1h', 
            'open_timestamp', 
            ['not_honeypot', 'verified', 'renounced']
        );

        if (data.code === 0) {
            const currentTime = Math.floor(Date.now() / 1000);

            const newTokens = data.data.rank.filter(token => {
                const tokenAge = currentTime - token.open_timestamp;
                return tokenAge <= 3600 && // Less than 1 hour old
                       token.holder_count > 50 && 
                       token.volume > 10000;
            });

            console.log('💎 New Gems Found:', newTokens.length);
            return newTokens;
        }
    } catch (error) {
        console.error('Failed to fetch new gems:', error);
        return [];
    }
}

Best Practices for Production Use

1. Implement Robust Error Handling

class APIErrorHandler {
    static async handleRequest(requestFn, maxRetries = 3) {
        for (let attempt = 1; attempt <= maxRetries; attempt++) {
            try {
                return await requestFn();
            } catch (error) {
                console.log(`Attempt ${attempt} failed:`, error.message);

                if (attempt === maxRetries) {
                    throw new Error(`All ${maxRetries} attempts failed: ${error.message}`);
                }

                // Exponential backoff with jitter
                const delay = Math.min(1000 * Math.pow(2, attempt) + Math.random() * 1000, 30000);
                await new Promise(resolve => setTimeout(resolve, delay));
            }
        }
    }
}

2. Request Rate Limiting

class RateLimiter {
    constructor(requestsPerMinute = 30) {
        this.requests = [];
        this.limit = requestsPerMinute;
    }

    async waitIfNeeded() {
        const now = Date.now();
        this.requests = this.requests.filter(time => now - time < 60000);

        if (this.requests.length >= this.limit) {
            const oldestRequest = Math.min(...this.requests);
            const waitTime = 60000 - (now - oldestRequest) + 1000; // Add 1s buffer
            console.log(`Rate limit reached, waiting ${waitTime}ms`);
            await new Promise(resolve => setTimeout(resolve, waitTime));
        }

        this.requests.push(now);
    }
}

3. Data Caching Strategy

class CacheManager {
    constructor(ttl = 60000) { // 1 minute default TTL
        this.cache = new Map();
        this.ttl = ttl;
    }

    set(key, value) {
        this.cache.set(key, {
            value,
            timestamp: Date.now()
        });
    }

    get(key) {
        const item = this.cache.get(key);

        if (!item) return null;

        if (Date.now() - item.timestamp > this.ttl) {
            this.cache.delete(key);
            return null;
        }

        return item.value;
    }

    clear() {
        this.cache.clear();
    }
}

Conclusion

The GMGN.AI API is a powerful tool for cryptocurrency developers and traders. Its combination of multi-chain support, safety filters, and smart money insights makes it invaluable for building sophisticated trading tools and market analysis applications.

Key takeaways:

✅ Always use safety filters to avoid honeypots
✅ Pay attention to smart money metrics for better insights
✅ Implement proper error handling and rate limiting
✅ Combine multiple sorting criteria for comprehensive analysis
✅ Use liquidity lock information to assess token safety

Whether you're building a trading bot, portfolio tracker, or market analysis tool, the GMGN.AI API provides the real-time data you need to stay ahead in the fast-moving crypto market.

Have you used the GMGN.AI API in your projects? Share your experiences and use cases in the comments below!

Useful Links:

Building a Powerful EVM Token Analysis Telegram Bot

Steven — Tue, 22 Apr 2025 07:46:10 +0000

Introduction

In today's fast-paced crypto world, having real-time insights into token metrics can make the difference between a successful trade and a missed opportunity. While many traders rely on scattered data sources and manual research, what if you could access comprehensive token analytics directly through Telegram?

That's exactly what the EVM Token Analysis Bot provides — a powerful Telegram-based solution that delivers detailed token insights across multiple EVM-compatible blockchains including Ethereum, Binance Smart Chain (BSC), and Base.

In this article, I'll walk you through the architecture, features, and implementation details of this advanced blockchain analytics bot that makes on-chain data analysis accessible to everyone.

Why Token Analysis Matters in DeFi

The decentralized finance landscape is incredibly dynamic, with thousands of tokens launching across multiple chains daily. For traders and investors, understanding token metrics is crucial for:

Identifying early opportunities – Finding promising tokens before they gain mainstream attention
Avoiding scams – Detecting red flags in token contracts and deployer behavior
Understanding market dynamics – Tracking whale movements and profit patterns
Making data-driven decisions – Basing trades on actual on-chain metrics rather than speculation

However, gathering this data traditionally requires:

Navigating multiple block explorers
Using various analytics platforms
Understanding complex blockchain data
Spending hours on manual research

The EVM Token Analysis Bot solves these challenges by bringing comprehensive token analytics directly to Telegram, making powerful insights available with just a few clicks.

Key Features of the EVM Token Analysis Bot

Free Features

The bot offers several powerful features even to free users:

First Buyers & Profits Analysis

View the first 1–50 wallets that bought a token
Detailed statistics including buy & sell amounts
Total trades, PNL, and win rate metrics
Limited to 3 token scans per day for free users

Most Profitable Wallets

Discover which wallets have made the most profit from a specific token
View buy & sell totals and net profit
Identify successful trading patterns
Limited to 3 token scans per day for free users

Market Cap & ATH Analysis

View the all-time high market cap of any token
See ATH date and percentage from ATH
Track market cap evolution
Limited to 3 token scans per day for free users

Premium Features

For power users, the premium tier unlocks advanced capabilities:

Deployer Wallet Scan

Reveal the deployer wallet address
See all tokens deployed by the same wallet
View ATH market cap and x-multipliers for each token
Identify potential connections between projects

Top Holders & Whale Watch

See the top 10 holders of any token
Monitor whale wallets
Get notifications when Dev, whales, or top holders sell
Track significant wallet movements

High Net Worth Holders

Scan for wallets holding over $10,000 worth of a token
View total worth in USD and token amount
See average holding time
Identify potential market movers

Unlimited Access

Premium subscribers get unlimited access to all features
No daily scan limits
Priority data processing

Technical Architecture

The EVM Token Analysis Bot is built with a modular architecture that ensures reliability, scalability, and efficient data processing:

1. Multi-Chain Support

The bot supports multiple EVM-compatible blockchains:

Ethereum Mainnet
Binance Smart Chain
Base Network

Each chain connection is initialized with appropriate middleware and configuration.

def _initialize_web3(self, network: str) -> Web3:
    """Initialize Web3 connection for the specified network."""
    provider_url = NETWORKS[network]["provider_url"]
    logger.info(f"Initializing Web3 for {network} with provider URL: {provider_url}")

    web3 = Web3(Web3.HTTPProvider(provider_url))

    # Add PoA middleware for networks like BSC
    web3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)

    # For BNB Chain (BSC), we need additional configuration
    if network == "BNB":
        # BSC uses a different gas price strategy
        from web3.gas_strategies.rpc import rpc_gas_price_strategy
        web3.eth.set_gas_price_strategy(rpc_gas_price_strategy)

    if not web3.is_connected():
        logger.error(f"Failed to connect to {network} network")
        raise ConnectionError(f"Cannot connect to {network} network")

    logger.info(f"Connected to {network} network: Chain ID {web3.eth.chain_id}")
    return web3

2. Data Models

The bot uses structured data models to ensure consistency and reliability:

class TokenData:
    """Model for cached token data"""
    def __init__(
        self,
        address: str,
        name: Optional[str] = None,
        symbol: Optional[str] = None,
        deployer: Optional[str] = None,
        deployment_date: Optional[datetime] = None,
        current_price: Optional[float] = None,
        current_market_cap: Optional[float] = None,
        ath_market_cap: Optional[float] = None,
        ath_date: Optional[datetime] = None,
        last_updated: Optional[datetime] = None
    ):
        self.address = address
        self.name = name
        self.symbol = symbol
        self.deployer = deployer
        self.deployment_date = deployment_date
        self.current_price = current_price
        self.current_market_cap = current_market_cap
        self.ath_market_cap = ath_market_cap
        self.ath_date = ath_date
        self.last_updated = last_updated or datetime.now()

3. Database Integration

The bot uses MongoDB for efficient data storage and retrieval:

def init_database() -> bool:
    """Initialize the database connection and set up indexes"""
    global _db

    try:
        # Connect to MongoDB
        client = MongoClient(MONGODB_URI) 
        _db = client[DB_NAME]

        # Set up indexes for collections
        # Users collection
        _db.users.create_index([("user_id", ASCENDING)], unique=True)

        # User scans collection
        _db.user_scans.create_index([
            ("user_id", ASCENDING),
            ("scan_type", ASCENDING),
            ("date", ASCENDING)
        ], unique=True)

        # Token data collection
        _db.token_data.create_index([("address", ASCENDING)], unique=True)
        _db.token_data.create_index([("deployer", ASCENDING)])

        # Additional indexes for watchlists
        # ...

        return True
    except Exception as e:
        logging.error(f"Failed to initialize database: {e}")
        return False

4. Subscription Management

The bot implements a subscription system to manage free and premium users:

def check_subscription_payment(self, user_id: int) -> Dict[str, Any]:
    if user_id not in self.subscriptions:
        logger.warning(f"No subscription found for user {user_id}")
        return {
            "success": False,
            "error": {
                "code": "SUBSCRIPTION_NOT_FOUND",
                "message": f"No subscription found for user {user_id}"
            }
        }

    subscription = self.subscriptions[user_id]
    network = subscription["network"]
    address = subscription["wallet_address"]
    required_amount = subscription["amount_required"]

    balance_result = self.check_wallet_balance(address, network)
    if not balance_result["success"]:
        return balance_result

    current_balance = balance_result["data"]["native_balance"]
    formatted_balance = balance_result["data"]["formatted_native_balance"]

    # Process payment logic
    # ...

5. Telegram Bot Interface

The bot provides an intuitive Telegram interface with rich menus and callbacks:

async def handle_start_menu(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    """Handle the main menu display with only token analysis functionality"""

    if "default_network" not in context.user_data:
        context.user_data["default_network"] = "eth"

    selected_network = context.user_data.get("default_network")
    network_display = {
        "eth": "🌐 Ethereum",
        "base": "🛡️ Base",
        "bsc": "🔶 BSC"
    }

    welcome_message = (
        f"🆘 <b>Welcome to EVM Token Analysis Bot, {update.effective_user.first_name}! 🎉</b>\n\n"
        f"📊 <b>Token Analysis Features:</b>\n"
        # Feature list...
    )

    token_analysis_keyboard = [
        [InlineKeyboardButton("🛒 First Buyers & Profits of a token", callback_data="token_first_buyers")],
        [InlineKeyboardButton("💰 Most Profitable Wallets of a token", callback_data="token_most_profitable_wallets")],
        # Additional buttons...
    ]

6. Error Handling

The bot implements robust error handling to ensure reliability:

async def handle_telegram_error(update: Optional[Update], context: ContextTypes.DEFAULT_TYPE) -> None:
    """Handle generic TelegramError errors."""
    if update and update.effective_message:
        error_message = "An error occurred while processing your request. Please try again later."

        try:
            await update.effective_message.reply_text(error_message)
        except Exception as e:
            logger.error(f"Failed to send error message: {e}")

Implementation Highlights

Rate Limiting for Free Users

The bot implements a fair usage policy for free users:

async def handle_period_selection(
    update: Update, 
    context: ContextTypes.DEFAULT_TYPE,
    feature_info:str, 
    scan_type: str,
    callback_prefix: str
) -> None:
    """Generic handler for period selection"""
    query = update.callback_query
    user = await check_callback_user(update)

    # Check if user has reached daily limit
    has_reached_limit, current_count = await check_rate_limit_service(
        user.user_id, scan_type, FREE_WALLET_SCANS_DAILY
    )

    if has_reached_limit and not user.is_premium:
        keyboard = [
            [InlineKeyboardButton("💎 Upgrade to Premium", callback_data="premium_info")],
            [InlineKeyboardButton("🔙 Back", callback_data="wallet_analysis")]
        ]
        reply_markup = InlineKeyboardMarkup(keyboard)

        await query.message.reply_text(
            f"⚠️ <b>Daily Limit Reached</b>\n\n"
            # Limit message...
            f"To unlock unlimited access to powerful wallet analysis features, upgrade to <b>Premium</b> and explore the full potential of on-chain intelligence. 💎\n",
            reply_markup=reply_markup,
            parse_mode=ParseMode.HTML
        )
        return

Premium Feature Access Control

The bot checks user subscription status before allowing access to premium features:

async def handle_high_net_worth_holders(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    """Handle high net worth token holders button callback"""
    query = update.callback_query
    user = await check_callback_user(update)

    # Check if user is premium
    if not user.is_premium:
        keyboard = [
            [InlineKeyboardButton("💎 Upgrade to Premium", callback_data="premium_info")],
            [InlineKeyboardButton("🔙 Back", callback_data="main_menu")]
        ]
        reply_markup = InlineKeyboardMarkup(keyboard)

        await query.message.reply_text(
            "⭐ <b>Premium Feature</b>\n\n"
            "<b>💎 High Net Worth Holders</b> is an exclusive premium feature that identifies:\n"
            # Feature description...
            "💎 <b>Upgrade to Premium</b> for unlimited access to this and other advanced features.",
            reply_markup=reply_markup,
            parse_mode=ParseMode.HTML
        )
        return

    # If premium, proceed with feature
    await handle_token_analysis_token_input(update, context, "high_net_worth_holders")

Admin Management Features

The bot includes administrative capabilities for managing users and subscriptions:

async def handle_admin_add_premium(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    """Admin command to manually add premium to a user"""
    # Check if user is admin
    user_id = update.effective_user.id
    user = get_user(user_id)

    if not user or not hasattr(user, 'is_admin') or not user.is_admin:
        await update.message.reply_text("⛔ This command is only available to administrators.")
        return

    # Command logic for adding premium access
    # ...

Setting Up Your Own EVM Token Analysis Bot

Want to run your own instance of the EVM Token Analysis Bot? Here's how to get started:

Prerequisites

Python 3.8+
Telegram Bot Token (from @BotFather on Telegram)
Dune Analytics API credentials
MongoDB database
API keys for blockchain providers

Installation Steps

1. Clone the repository:

git clone https://github.com/imcrazysteven/EVM-Token-Analysis-Telegram-Bot.git

2. Navigate to the project directory:

cd EVM-Token-Analysis-Telegram-Bot

3. Install dependencies:

pip install -r requirements.txt

4. Create a .env file with your credentials:

# DB Configuration
MONGODB_URI="mongodb://localhost:27017/"
DB_NAME="evm_token_analysis"

# API Keys
DUNE_API_KEY=your_dune_api_key_here
ZENROWS_API_KEY=your_zenrows_api_key_here
MORALIS_API_KEY=your_moralis_api_key_here

# ===== BLOCKCHAIN CONFIGURATION =====
# Ethereum Mainnet
ETH_PROVIDER_URL=https://mainnet.infura.io/v3/your_infura_key_here
ETH_CHAIN_ID=1
ETH_ADMIN_WALLET=your_admin_wallet_address

# Binance Smart Chain Mainnet
BNB_PROVIDER_URL=https://bsc-dataseed.binance.org/
BNB_CHAIN_ID=56
BNB_ADMIN_WALLET=your_admin_wallet_address

# Subscription Check Interval (in seconds)
CHECK_INTERVAL=60

# TELEGRAM BOT SETTING
TELEGRAM_TOKEN=your_telegram_bot_token_here

# Free tier limits
FREE_TOKEN_SCANS_DAILY=3
FREE_WALLET_SCANS_DAILY=3
FREE_PROFITABLE_WALLETS_LIMIT=5

# Premium tier limits
PREMIUM_TOKEN_SCANS_DAILY=100
PREMIUM_WALLET_SCANS_DAILY=100
PREMIUM_PROFITABLE_WALLETS_LIMIT=50

# Additional API keys
WEB3_PROVIDER_URI=https://mainnet.infura.io/v3/your_infura_key_here
ETHERSCAN_API_KEY=your_etherscan_api_key_here

5. Start the bot:

python src/main.py

Advanced Features to Consider

Once you've implemented the core functionality, consider these enhancements to further improve the bot's utility:

Cross-Chain Token Correlation

Identify tokens deployed by the same entity across multiple chains
Track related token performance

Sentiment Analysis Integration

Combine on-chain data with social media sentiment
Provide a more complete picture of token prospects

Predictive Analytics

Use historical data to identify patterns
Provide probability-based insights on token performance

Custom Alert Thresholds

Allow users to set custom thresholds for notifications
Personalize the analysis experience

Integration with Trading Platforms

Connect with DEX aggregators for direct trading
Enable one-click trading based on analysis

Conclusion

The EVM Token Analysis Telegram Bot serves as your personal on-chain intelligence assistant—transforming complex blockchain data into actionable insights and giving you a competitive edge in the fast-moving crypto markets.

This powerful tool converts raw blockchain data into comprehensible analytics, delivering real-time token insights across multiple EVM-compatible networks including Ethereum, BSC, and Base. By combining sophisticated token analysis with convenient Telegram delivery, this bot provides crypto traders, investors, and researchers with the critical information needed to navigate the complex DeFi landscape.

The modular architecture and MongoDB integration ensure both performance and historical data preservation, while the intuitive Telegram interface makes advanced blockchain analytics accessible even to users without technical blockchain knowledge. The ability to analyze tokens across multiple chains in a single interface eliminates the need to juggle various block explorers and analytics platforms.

The bot's tiered access model ensures that essential analytics are available to everyone while providing premium capabilities for serious traders and researchers. Features like first buyer analysis, profit tracking, and deployer wallet scanning provide unprecedented visibility into token metrics that would otherwise require hours of manual research.

As blockchain ecosystems continue to evolve and fragment across multiple chains, tools that provide cross-chain visibility become increasingly valuable. Whether you're researching potential investments, monitoring existing holdings, or tracking market-moving whale wallets, this bot serves as your personal blockchain analyst, working around the clock to deliver the insights you need.

By implementing the EVM Token Analysis Bot, you'll gain a significant advantage in the information-rich but often opaque world of decentralized finance. The detailed token metrics and wallet analysis transform raw blockchain data into the kind of actionable intelligence that can make the difference between capturing opportunities and missing them entirely.

In a market where information asymmetry often determines success, having a dedicated token analysis tool delivering insights directly to your Telegram isn't just convenient—it's a strategic necessity for serious participants in the blockchain economy.

📁 GitHub Repository

🔗 View Source Code on GitHub

You can see the sample video there.
If you want to see the whole code or develop EVM Token Analysis telegram bot on your own, please contact me with the contact information below.
Please don’t forget to leave a star if you like the bot.

Contact Information

GitHub: Steven
Gmail: Steven
Telegram: Steven
Twitter: Steven
Instagram: Steven

How to develop professional EVM Wallet Tracking Telegram Bot

Steven — Mon, 21 Apr 2025 04:27:09 +0000

This article gives you a comprehensive guide to building a professional EVM (Etherum, Polygon, Arbitrum, Base, BSC, etc) wallet monitoring system that monitors transactions, and delivers real-time notifications through Telegram.

🧠 Introduction to EVM Wallet Tracking Bot

This guide will walk you through creating a sophisticated wallet tracking bot that monitors transactions across multiple EVM chains (Ethereum, Polygon, Arbitrum, Base, BSC, etc.) and sends detailed notifications via Telegram. By the end, you'll have a powerful tool that provides instant alerts about token purchases, sales, swaps, transfers, and other on-chain activities.

Unlike basic monitoring tools that only show balance changes, this professional-grade solution breaks down transactions with full context, delivering human-readable alerts directly to your Telegram. With support for multi-wallet and multi-chain tracking, historical data storage via MongoDB, and an intuitive command interface, this bot serves as your personal blockchain analyst, giving you the tactical edge needed to make informed decisions in real-time.

Why Wallet Monitoring Matters in DeFi

In the high-stakes, real-time world of DeFi, staying ahead of market movements and tracking key wallets is no longer a luxury—it's a necessity. With thousands of wallets making transactions every second across multiple chains like Ethereum, BSC, and Polygon, traders and developers need instant visibility into wallet activities.

Imagine this: You're a crypto trader watching a major whale wallet. Suddenly, the wallet dumps a massive amount of tokens. If you see this minutes later, it's already too late. But what if you got notified the second it happened? That’s where the EVM Wallet Tracking Telegram Bot comes into play.

This tool lets you track wallet activities across EVM-compatible blockchains in real time. Whether you’re a DeFi enthusiast, investor, security analyst, or just a curious blockchain explorer, this bot gives you a tactical edge with up-to-the-second notifications.

What Makes This Bot Different?

Most bots just show wallet balance changes, but this one breaks it down with full context:

Detects sells, buys, swaps, and contract interactions
Sends formatted, human-readable alerts to Telegram
Supports multi-wallet and multi-chain tracking
Offers historical data storage via MongoDB
Easy command-line interface through Telegram bot commands

It's not just a tracker—it's your personal blockchain analyst, sliding into your Telegram DMs.

🤖 Setting Up the Telegram Bot

Creating Your Telegram Bot with BotFather

First things first: you need your own Telegram bot. Setting it up is easy:

Open Telegram and search for @BotFather.
Send /newbot.
Give it a name like EVM Wallet Tracker.
Choose a unique username ending in bot, such as evmwallettrackbot.
BotFather will return a Bot Token — save this securely!

Understanding Chat IDs & Bot Tokens

To send messages to yourself or a group, your bot needs to know where to send them. That’s where Chat IDs come in.

There are a few ways to get this:

Send a message to your bot and use a script to log the response
Use Telegram’s API directly
Use bot management tools

Once you have your Bot Token and Chat ID, your bot can send messages directly to your Telegram—nice!

Integrating Telegram Bot with Your Code

The bot uses the Telegram Bot API, which makes sending messages as simple as an HTTP request. But this bot comes fully packaged—commands are already built-in for you:

`/start` - See welcome message  
`/track [chain] [address]` - Start tracking  
`/list` - List tracked wallets  
`/remove` - Remove a wallet  
`/stop [chain] [address]` - Stop tracking temporarily, 
`/resume [chain] [address]` - Resume tracking again, 
`/stopall` - Stop all tracking temporarily, 
`/resumeall` - Control tracking  
`/help` - Get command help

⚙️ Installing and Configuring the Bot

Cloning the Repository and Installing Dependencies

# Clone the repo
git clone https://github.com/imcrazysteven/EVM-Wallet-Tracking-Telegram-Bot.git

# Navigate to the project directory
cd EVM-Wallet-Tracking-Telegram-Bot

# Install dependencies
pip install -r requirements.txt

Setting Up the Environment Variables

Create a .env file in the root directory and paste the following:

# API Keys
MORALIS_API_KEY=Your Moralis API Key : API key from Moralis for accessing EVM blockchain data
TELEGRAM_BOT_TOKEN=Your Telegram Bot Token : Your Telegram bot token from BotFather

# Optional Configuration
POLL_INTERVAL=20 : Optional, controls how often bot checks for updates

# DATABASE CONFIGURATION
MONGODB_URI = mongodb://localhost:27017/db_name : MongoDB connection string for storing transaction history

# BLOCKCHAIN CONFIGURATION: Web3 RPC URLs for each EVM-compatible blockchain (Ethereum, Polygon, BSC, etc.)
ETH_PROVIDER_URI=https://mainnet.infura.io/v3/your-api-key
BSC_PROVIDER_URI=https://bsc-dataseed.binance.org/
BASE_PROVIDER_URI=https://mainnet.base.org
POLYGON_PROVIDER_URI=https://polygon-rpc.com
ARBITRUM_PROVIDER_URI=https://arb1.arbitrum.io/rpc
OPTIMISM_PROVIDER_URI=https://mainnet.optimism.io
AVALANCHE_PROVIDER_URI=https://api.avax.network/ext/bc/C/rpc
FANTOM_PROVIDER_URI=https://rpc.ankr.com/fantom
CRONOS_PROVIDER_URI=https://evm.cronos.org
GNOSIS_PROVIDER_URI=https://rpc.gnosischain.com
CHILIZ_PROVIDER_URI=https://rpc.ankr.com/chiliz
MOONBEAM_PROVIDER_URI=https://rpc.api.moonbeam.network
RONIN_PROVIDER_URI=https://api.roninchain.com/rpc
LISK_PROVIDER_URI=https://rpc.mainnet.lisk.com
PULSECHAIN_PROVIDER_URI=https://rpc.pulsechain.com
LINEA_PROVIDER_URI=https://rpc.linea.build
PALM_PROVIDER_URI=https://rpc.palm.io

⛓️ Blockchain Data Integration

Using Moralis API for Real-Time Blockchain Data

Once integrated:

Your bot connects to live WebSocket streams
It listens for activity on any wallet you specify
It pulls all token details, symbols, amounts, and values in real time

Distinguishing Wallet vs Contract Interactions

The bot uses Web3 providers to:

Determine if an address is a contract
Filter out non-human interactions
Only alert you when something useful happens

🕵️ How the Bot Monitors Transactions

Real-Time Wallet Tracking via Moralis API

The bot periodically calls Moralis API to fetch events for the wallets you're tracking. When a transaction hits:

Instantly receives the data
Parses the transaction
Sends a formatted message to

Extracting Token Swap, Transfer, and Liquidity Events

Details extracted:

Token name & symbol
Token amount
USD value
Transaction type
Explorer links

🧩 Behind the Scenes: How It Works

Transaction Analysis Workflow

Receive transaction
Validate sender
Parse and classify
Enrich with token info
Store in DB
Send Telegram alert

Database Storage with MongoDB

Transaction fields stored:

Wallet address
Token name & symbol
Value
Timestamp
Chain
Txn type
Last checked Block

Optimizing Telegram Notifications for Readability

Example:

🔔 New Wallet Activity
👛 Wallet: 0xfc9928...e535
🔗 Chain: Ethereum
📊 Type: 🔴 SELL
🪙 Token: REALM (REALM)
💲 Price: $0.00002340
📈 Amount: 146.16K
💰 Value: $3.42
🕒 Time: 2025-04-19 18:46:23 UTC

🚀 Advanced Features & Enhancements

Multi-threaded Blockchain Connections

Each chain runs on a separate thread for better performance.

Token Info & Symbol Recognition

Token metadata is enriched using Moralis APIs.

Efficient Resource Management

Caching
DB indexing
Error handling

🔐 FAQs

Does this bot require private keys?
No. Only public addresses.
Can I track more than one wallet?
Yes, unlimited.
Which blockchains are supported?
All major EVM chains, like Ethereum, Polygon, Base, Binance Smart Chain, Arbitrum, Optimism, Avalanche, Fantom, etc.
Will it notify me of all types of transactions?
It focuses on key ones (buy, sell, transfer).
Can I view past transaction history?
Yes, stored in MongoDB.

Key Features Implemented

The wallet tracking system includes several powerful features:

1. Multi-chain Transaction Monitoring

The system captures transactions as they occur across multiple EVM-compatible blockchains (Ethereum, Polygon, Arbitrum, Base, BSC, etc.), with minimal delay between on-chain confirmation and notification delivery. This cross-chain awareness is crucial for comprehensive portfolio management and market intelligence.

2. Transaction Type Classification

The bot intelligently classifies transactions into meaningful categories like buys, sells, swaps, and transfers, providing context that raw blockchain data lacks. This classification makes notifications immediately actionable without requiring manual analysis.

3. Token Information Enrichment

All transactions are enriched with token metadata including names, symbols, and current prices, transforming cryptic contract addresses into human-readable information that's easy to understand at a glance.

4. Formatted Telegram Notifications

Notifications are delivered through Telegram with rich, emoji-enhanced formatting that makes complex transaction data instantly comprehensible. Each notification includes direct links to block explorers for deeper investigation.

5. MongoDB Historical Storage

All monitored transactions are stored in MongoDB, creating a searchable history that can be used for pattern recognition, performance analysis, and tax reporting. This historical record becomes increasingly valuable over time.

6. Command-based Interface

The bot offers an intuitive command system through Telegram, allowing users to add/remove wallets, list tracked addresses, and control notification settings without leaving their messaging app.

7. Multi-threaded Architecture

Each blockchain connection runs on a separate thread, ensuring that monitoring one slow chain doesn't impact performance on others and maximizing the system's ability to capture transactions in real-time.

Advanced Features to Consider

Once you've implemented the core functionality, consider these enhancements:

1. Smart Contract Interaction Analysis

Extend the bot to decode complex smart contract interactions, providing insights into DeFi operations like liquidity provision, staking, and governance participation.

2. Whale Alert Thresholds

Implement customizable thresholds for "whale" transactions, allowing users to receive special notifications when movements exceed certain token amounts or dollar values.

3. Gas Optimization Alerts

Add notifications about optimal gas prices across different chains, helping users time their transactions to minimize fees during network congestion.

4. Portfolio Performance Tracking

Develop functionality to track overall portfolio performance across multiple wallets and chains, providing periodic summaries of value changes and transaction activity.

5. Custom Notification Filters

Allow users to set granular criteria for which transactions trigger notifications, such as minimum value thresholds, specific tokens, or transaction types.

🏁 Conclusion

The EVM Wallet Tracking Telegram Bot is your personal DeFi assistant—analyzing, alerting, and giving you the upper hand in real-time blockchain tracking.

The EVM Wallet Tracking Telegram Bot transforms complex blockchain data into actionable intelligence, delivering real-time insights across multiple EVM-compatible networks. By combining sophisticated transaction analysis with convenient Telegram notifications, this tool provides crypto traders, investors, and developers with the situational awareness needed to navigate the fast-moving DeFi landscape.

The multi-threaded architecture and MongoDB integration ensure both performance and historical data preservation, while the command-based Telegram interface makes the system accessible even to users without technical blockchain knowledge. The ability to track multiple wallets across multiple chains in a single interface eliminates the need to juggle various block explorers and monitoring tools.

As blockchain ecosystems continue to evolve, tools that provide cross-chain visibility become increasingly valuable. Whether you're tracking your own investments, monitoring competitor strategies, or keeping tabs on market-moving whale wallets, this bot serves as your personal blockchain analyst, working around the clock to keep you informed of significant on-chain movements.

By implementing this EVM Wallet Tracking Bot, you'll gain a tactical advantage in the information-rich but often opaque world of decentralized finance. The real-time notifications and detailed transaction breakdowns transform raw blockchain data into the kind of actionable intelligence that can make the difference between capturing opportunities and missing them entirely.

📁 GitHub Repository

🔗 View Source Code on GitHub

You can see the sample video there.
If you want to see the whole code or develop EVM wallet tracking telegram bot on your own, please contact me with the contact information below.
Please don’t forget to leave a star if you like the bot.

Contact Information

GitHub: Steven
Gmail: Steven
Telegram: Steven
Twitter: Steven
Instagram: Steven

Building a Professional Solana Wallet Tracking Telegram Bot

Steven — Thu, 17 Apr 2025 08:10:28 +0000

This article gives you a comprehensive guide to building a professional Solana wallet monitoring system that monitors transactions, calculates PnL and delivers real-time notifications through Telegram.

Introduction

In the dynamic landscape of Crypto trading, especially on Solana Blockchain, staying up to date with wallet activity is very important for traders, investors, and developers looking to make informed decisions. Whether you're tracking your own investments, monitoring whale movements, or keeping an eye on competitor strategies, having real-time insights into on-chain transactions can provide a significant advantage.

This guide will walk you through creating a sophisticated wallet tracking bot that monitors transactions and sends detailed notifications via Telegram. By the end, you'll have a powerful tool that provides instant alerts about token purchases, sales, transfers, and other on-chain activities.

Why Build a Solana Wallet Tracker?

Solana's high-speed, low-cost blockchain has become a hub for DeFi, NFTs, and gaming applications. With thousands of transactions occurring every second, manually monitoring wallet activities is impossible. A dedicated tracking system offers several benefits:

Real-time awareness of trading activities and token movements
Investment insights by tracking successful traders' strategies
Security monitoring to detect unauthorized transactions
Market intelligence by observing whale movements and trends
Portfolio management with automated transaction recording

Step-by-Step Guide for developing Solana Wallet Tracking Telegram Bot

1. Setting Up Your Telegram Bot

Telegram bots provide an excellent interface for receiving notifications and interacting with your tracking system. The process starts with creating and
configuring your bot.

Creating your Telegram Bot

The first step is to create a new bot through Telegram's BotFather:

Open Telegram and search for the @botfather
Send the /newbot command
Follow the prompts to name your bot (e.g., "SolanaWalletTracker")
Choose a username that ends with "bot" (e.g., "SolanaWalletTrackerBot")
BotFather will provide a token - this is your API access key

This token is the authentication credential your application will use to send and receive messages through your bot. Keep it secure and never share it publicly.

Understanding Chat IDs

Telegram uses chat IDs to identify conversations. To send notifications to yourself or specific channels, you'll need to obtain these IDs. When a user interacts with your bot, Telegram assigns a unique chat ID to that conversation.

You can retrieve chat IDs by:

Using Telegram's API directly
Setting up a simple script to log message events
Using third-party tools designed for Telegram bot development

For personal use, you'll want to save your own chat ID in your environment configuration.

Environment Configuration

Proper configuration management is essential for security and flexibility. By using environment variables, you can keep sensitive information out of your codebase and easily adjust settings between development and production environments.

Your configuration should include:

Telegram bot credentials
Solana RPC endpoints
Database connection strings
Default wallet addresses (optional)

This separation of configuration from code follows best practices for application development and security.

2. Implementing the Telegram Bot

The Telegram bot serves as both the notification channel and user interface for your tracking system. It needs to handle commands, process wallet addresses, and deliver formatted transaction alerts.

A well-designed bot should:

Respond to standard commands like /start and /help
Process wallet addresses when users send them
Validate input to ensure addresses are properly formatted
Maintain user preferences for which wallets to track
Format transaction data into readable notifications

The bot becomes the primary way users interact with your system, so investing time in creating a smooth, intuitive experience pays dividends in usability.

3. Integrating Helius RPC

Helius provides specialized Solana RPC services with enhanced capabilities for developers. Unlike standard RPC providers, Helius offers:

Higher rate limits for API calls
WebSocket support for real-time data
Enhanced transaction data with parsed information
Specialized endpoints for token data and NFTs

Setting up a connection to Helius involves:

Creating an account on the Helius platform
Generating API keys for authentication
Configuring both HTTP and WebSocket endpoints
Establishing connection handling with proper error management

The WebSocket connection is particularly important for real-time monitoring, as it allows the blockchain to push notifications to your application rather than requiring constant polling.

4. MongoDB Database Configuration and Connection

MongoDB provides a flexible, document-oriented database that's well-suited for storing blockchain transaction data. Its schema-less design accommodates the varying structure of transaction information, while still allowing for efficient querying and analysis.

When setting up your database:

Create appropriate collections for transactions, wallets, and user preferences
Implement indexes for frequently queried fields like wallet addresses and timestamps
Configure connection pooling for efficient database access
Implement proper error handling and reconnection logic

A well-designed database structure enables powerful features like historical analysis, PNL calculation, and pattern recognition across transactions.

5. WebSocket Handling for Real-time Monitoring

WebSockets provide a persistent connection between your application and the Solana blockchain, enabling real-time notification of new transactions. Properly managing these connections is crucial for reliable operation.

Key considerations include:

Implementing reconnection logic for network interruptions
Sending periodic ping messages to keep connections alive
Properly subscribing to relevant blockchain events
Processing incoming messages efficiently

WebSockets are the foundation of real-time monitoring, allowing your system to react instantly to on-chain activities rather than discovering them through periodic polling.

6. Transaction Analysis and Tracking

The heart of your wallet tracking system is the ability to analyze transactions and extract meaningful information. This involves:

1. Receiving transaction signatures from the WebSocket connection

2. Fetching complete transaction data using the RPC connection

3. Parsing the transaction to identify:

Token transfers and amounts
SOL movements
Transaction type (swap, transfer, etc.)
Involved parties and contracts

4. Calculating financial implications like:

Purchase or sale amounts
Price impact
Profit and loss

5. Formatting the data into human-readable notifications

This analysis requires understanding Solana's transaction structure, account system, and token standards. The complexity comes from needing to interpret the raw blockchain data into meaningful financial information.

For example, identifying a token swap requires:

Recognizing the DEX program being called
Tracking token balance changes before and after the transaction
Calculating the effective exchange rate
Determining if it was a buy or sell operation

The analysis logic forms the intelligence layer of your tracking system, transforming raw blockchain events into actionable insights.

7. Utility Functions and Helpers

A collection of utility functions makes your code more maintainable and readable. These helpers handle common tasks like:

Validating Solana addresses
Formatting wallet addresses for display (e.g., "Ab3X...j9Zk")
Converting between token units (e.g., lamports to SOL)
Generating explorer links for transactions and accounts
Managing timeouts and retries for network operations

These utilities encapsulate common operations and ensure consistency throughout your application.

8. Main Application Entry Point

The entry point coordinates the initialization and operation of all system components. It handles:

Loading configuration from environment variables
Establishing database connections
Initializing the Telegram bot
Setting up error handling and logging
Managing the application lifecycle

Proper initialization ensures all components are ready before the system begins processing transactions.

9. Running and Maintaining the Application

Once built, your tracking system needs proper deployment and maintenance:

Deployment options include cloud services, dedicated servers, or container platforms
Monitoring ensures the system remains operational and responsive
Logging captures important events and errors for troubleshooting
Backup procedures protect user data and transaction history
Update processes allow for adding features and fixing issues

A production-ready system requires attention to these operational concerns to ensure reliability.

Key Features Implemented

The wallet tracking system includes several powerful features:

1. Real-time Transaction Monitoring

The system captures transactions as they occur on the Solana blockchain, with minimal delay between on-chain confirmation and notification delivery. This real-time awareness is crucial for time-sensitive trading decisions and security monitoring.

2. Multi-wallet Support

Users can track multiple wallets simultaneously, allowing them to monitor their entire portfolio or keep tabs on several accounts of interest. The Telegram interface makes adding and removing wallets simple and intuitive.

3. Detailed Transaction Analysis

Beyond simply notifying about transactions, the system analyzes each one to extract meaningful information: Was it a buy or sell? Which token was involved? How much was transferred? This analysis transforms raw blockchain data into actionable intelligence.

4. Instant Telegram Notifications

Notifications are delivered immediately through Telegram, with rich formatting that makes the information easy to understand at a glance. Links to block explorers allow for deeper investigation when needed.

5. Transaction History

All monitored transactions are stored in MongoDB, creating a searchable history that can be used for pattern recognition, performance analysis, and tax reporting. This historical record becomes increasingly valuable over time.

6. Token Information

The system enriches notifications with token details like symbols and names, making it easier to understand transaction context without needing to look up token addresses.

7. PNL Tracking

For trading operations, the system calculates and displays profit and loss information, helping users understand the financial impact of each transaction.

Advanced Features to Consider

Once you've implemented the core functionality, consider these enhancements:

1. Token Price Tracking

Integrate with price APIs to show current token values and calculate USD equivalents for transactions. This provides more meaningful financial context for notifications.

2. Whale Alert

Create specialized notifications for large transactions that might impact market conditions. Users could set thresholds for what constitutes a "whale" movement.

3. Portfolio Dashboard

Develop a web interface that visualizes wallet performance, token holdings, and transaction history. This could complement the Telegram notifications with more detailed analysis.

4. Custom Notification Filters

Allow users to set criteria for which transactions trigger notifications, such as minimum value thresholds or specific token types.

5. Multi-chain Support

Extend the system to monitor other blockchains like Ethereum or Binance Smart Chain, creating a comprehensive cross-chain monitoring solution.

Conclusion

Building a Solana wallet tracking system with Telegram notifications combines blockchain technology, database management, and messaging APIs into a powerful tool for crypto enthusiasts, traders, and developers. The system provides real-time insights into on-chain activities, helping users make informed decisions and stay aware of important transactions.

The modular architecture described in this guide allows for easy maintenance and future enhancements. By separating concerns between blockchain interaction, data storage, and user notifications, you can evolve each component independently as needs change.

Remember that blockchain technology and APIs evolve rapidly. Stay informed about changes to Solana's transaction structure, RPC interfaces, and token standards to ensure your tracking system remains accurate and reliable.

With the foundation provided in this guide, you can build a sophisticated wallet tracking system that delivers valuable insights through convenient Telegram notifications. Whether for personal use, team collaboration, or as a service for others, this system transforms the complex world of blockchain transactions into accessible, actionable information.

Github repository

This project is available on my github repository.
If you want to see the whole code or develop Solana wallet tracking telegram bot, you can contact me with the contact information below.

Contact Information

GitHub: Steven
Gmail: Steven
Telegram: Steven
Twitter: Steven
Instagram: Steven

How to integrate ERC20 token presale smart contract with Frontend

Steven — Sat, 16 Nov 2024 12:23:13 +0000

Introduction

Integrating an ERC20 token presale smart contract with a frontend using Rainbow Kit is a great way to provide a seamless user experience for token buyers. Rainbow Kit simplifies the wallet connection process and user interface, making it easier for developers to build decentralized applications (dApps). This article will guide you through the steps necessary to set up the integration.
We are going to use Next.js for the frontend development, Ethers.js for smart contract integration and RainbowKit with Wagmi for wallet connections.

The image below is what I am going to create for SPX token presale.

You can also refer this article for SPX presale smart contract.

How to implement step by step?

1. Create a Next.js project

We are going to use Next.js with Typescript and Tailwind css for the frontend development.

And install the required dependencies.

2. Configure Web3 Providers

Create a new file src/wagmi.ts and configure the chains and projectId.

import { getDefaultConfig } from "@rainbow-me/rainbowkit";
import { mainnet, sepolia } from "wagmi/chains";

export const config = getDefaultConfig({
  appName: "IRONWILL",
  projectId: "68449b069bf507d7dc50e5c1bcb82c50", // Replace with your actual project ID
  chains: [mainnet, sepolia],
  ssr: true, // Enable server-side rendering support
});

3. Create Provider Utilites and blockchain utilities

Create a new file src/utils/web3Providers.ts and write the following code. This code creates a provider instance, handle provider switching, and manage the RPC connections

import { useMemo } from 'react';
import {
  FallbackProvider,
  JsonRpcProvider,
  BrowserProvider,
  JsonRpcSigner,
} from 'ethers';
import type { Account, Chain, Client, Transport } from 'viem';
import { type Config, useClient, useConnectorClient } from 'wagmi';

export function clientToProvider(client: Client<Transport, Chain>) {
  const { chain, transport } = client;
  const network = {
    chainId: chain.id,
    name: chain.name,
    ensAddress: chain.contracts?.ensRegistry?.address,
  };
  if (transport.type === 'fallback') {
    const providers = (transport.transports as ReturnType<Transport>[]).map(
      ({ value }) => new JsonRpcProvider(value?.url, network)
    );
    if (providers.length === 1) return providers[0];
    return new FallbackProvider(providers);
  }
  return new JsonRpcProvider(transport.url, network);
}

export function useEthersProvider({ chainId }: { chainId?: number } = {}) {
  const client = useClient<Config>({ chainId })!;
  return useMemo(() => clientToProvider(client), [client]);
}

export function clientToSigner(client: Client<Transport, Chain, Account>) {
  const { account, chain, transport } = client;
  const network = {
    chainId: chain.id,
    name: chain.name,
    ensAddress: chain.contracts?.ensRegistry?.address,
  };
  const provider = new BrowserProvider(transport, network);
  const signer = new JsonRpcSigner(provider, account.address);
  return signer;
}

export async function useEthersSigner({ chainId }: { chainId?: number } = {}) {
  const { data: client } = useConnectorClient<Config>({ chainId });
  return useMemo(() => (client ? clientToSigner(client) : undefined), [client]);
}

Then create a new file src/utils/ethUtils.ts and write the following code. This code has the several blockchain utility functions.

import { ethers } from "ethers";
import { toast } from "react-toastify";

const ERC20_ABI = [
  "function balanceOf(address owner) view returns (uint256)",
  "function decimals() view returns (uint8)",
  "function symbol() view returns (string)",
];

export const TOKENS = {
  // sepolia
  USDT: "0xaA8E23Fb1079EA71e0a56F48a2aA51851D8433D0",
  USDC: "0x94a9D9AC8a22534E3FaCa9F4e7F2E2cf85d5E4C8",
  DAI: "0xFF34B3d4Aee8ddCd6F9AFFFB6Fe49bD371b8a357",
  SPX: "0x60081fa3c771BA945Aa3E2112b1f557D80e88575",
};

export async function getBalances(
  address: string
): Promise<{ [key: string]: string }> {
  const provider = new ethers.JsonRpcProvider(
    process.env.NEXT_PUBLIC_INFURA_URL
  );

  const balances: { [key: string]: string } = {};

  try {
    // Get ETH balance
    const ethBalance = await provider.getBalance(address);
    balances.ETH = ethers.formatEther(ethBalance);

    // Get token balances
    for (const [symbol, tokenAddress] of Object.entries(TOKENS)) {
      const contract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
      const balance = await contract.balanceOf(address);
      const decimals = await contract.decimals();
      balances[symbol] = ethers.formatUnits(balance, decimals);
    }

    return balances;
  } catch (error) {
    console.error("Error fetching balances:", error);
    toast.error("Error fetching balances");
    return {};
  }
}

4. Create a context for web3 and custom hooks

Create a new file src/contexts/web3Context.tsx and write the following code. This code creates a context for web3 and provides the web3 context to the entire application.

"use client";

import {createContext, useCallback, useEffect, useMemo, useState} from "react";
import Web3 from "web3";
import { useAccount, useChainId } from "wagmi";
import { Contract, ContractRunner, ethers } from "ethers";

import SPXTokenContractABI from "@/abis/SPXTokenContractABI.json";
import PresaleContractABI from "@/abis/PresaleContractABI.json";
import { useEthersProvider, useEthersSigner } from "@/utils/web3Providers";
import {defaultRPC, SPXTokenContractAddress, PresaleContractAddress } from "@/data/constants";
import { Web3ContextType } from "@/types";

declare let window: any;

let web3: any;

const Web3Context = createContext<Web3ContextType | null>(null);

export const Web3Provider = ({ children }: { children: React.ReactNode }) => {
  const { address, isConnected } = useAccount();
  const chainId = useChainId();
  const signer = useEthersSigner();
  const ethersProvider = useEthersProvider();
  let defaultProvider: any;
  if (chainId === 1) {
    defaultProvider = new ethers.JsonRpcProvider(defaultRPC.mainnet);
  } else if (chainId === 11155111) {
    defaultProvider = new ethers.JsonRpcProvider(defaultRPC.sepolia);
  }

  const [provider, setProvider] = useState<ContractRunner>(defaultProvider);
  const [SPXTokenContract, setSPXTokenContract] = useState<Contract>(
    {} as Contract
  );
  const [presaleContract, setPresaleContract] = useState<Contract>(
    {} as Contract
  );
  const [spxTokenAddress, setSPXTokenAddress] = useState<string>("");

  const init = useCallback(async () => {
    try {
      if (typeof window !== "undefined") {
        web3 = new Web3(window.ethereum);
      }
      if (!isConnected || !ethersProvider) {
        // console.log("Not connected wallet");
      } else {
        setProvider(ethersProvider);
        // console.log("Connected wallet");
      }

      if (chainId === 1) {
        const _spxTokenContractWeb3: any = new web3.eth.Contract(
          SPXTokenContractABI,
          SPXTokenContractAddress.mainnet
        );
        const _presaleContractWeb3: any = new web3.eth.Contract(
          PresaleContractABI,
          PresaleContractAddress.mainnet
        );
        setSPXTokenContract(_spxTokenContractWeb3);
        setPresaleContract(_presaleContractWeb3);
        setSPXTokenAddress(SPXTokenContractAddress.mainnet);
      } else if (chainId === 11155111) {
        const _spxTokenContractWeb3: any = new web3.eth.Contract(
          SPXTokenContractABI,
          SPXTokenContractAddress.sepolia
        );
        const _presaleContractWeb3: any = new web3.eth.Contract(
          PresaleContractABI,
          PresaleContractAddress.sepolia
        );
        setSPXTokenContract(_spxTokenContractWeb3);
        setPresaleContract(_presaleContractWeb3);
        setSPXTokenAddress(SPXTokenContractAddress.sepolia);
      }
    } catch (err) {
      console.log(err);
    }
  }, [isConnected, ethersProvider, chainId]);

  useEffect(() => {
    init();
  }, [init]);

  const value = useMemo(
    () => ({
      account: address,
      chainId,
      isConnected,
      library: provider ?? signer,
      SPXTokenContract,
      presaleContract,
      spxTokenAddress,
      web3,
    }),
    [
      address,
      chainId,
      isConnected,
      provider,
      signer,
      SPXTokenContract,
      presaleContract,
      spxTokenAddress,
    ]
  );

  return <Web3Context.Provider value={value}>{children}</Web3Context.Provider>;
};

export default Web3Context;

Then create a custom hook (src/hooks/useWeb3.ts) to use the web3 context.

import { useContext } from "react";
import Web3Context from "@/contexts/web3Context";

const useWeb3 = () => {
  const context = useContext(Web3Context);
  if (!context) throw new Error("context must be use inside provider");
  return context;
};

export default useWeb3;

5. Combine providers

"use client";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { WagmiProvider } from "wagmi";
import { RainbowKitProvider, darkTheme } from "@rainbow-me/rainbowkit";
import { config } from "@/wagmi";
import "@rainbow-me/rainbowkit/styles.css";
import { Web3Provider } from "@/contexts/web3Context";
const client = new QueryClient();

export default function RootProvider({
  children,
}: Readonly<{
  children: React.ReactNode;
}>) {
  return (
    <WagmiProvider config={config}>
      <QueryClientProvider client={client}>
        <RainbowKitProvider
          coolMode={true}
          theme={darkTheme({
            accentColor: "#824B3D",
            accentColorForeground: "#dbdbcf",
            borderRadius: "small",
          })}
        >
          <Web3Provider>{children}</Web3Provider>
        </RainbowKitProvider>
      </QueryClientProvider>
    </WagmiProvider>
  );
}

6. Web3 Integration

Connect wallet

This is the code for the connect wallet button.

import { ConnectButton } from "@rainbow-me/rainbowkit";

const PreSale: React.FC = () => {

  ....

 const handlePayAmountChange = async (
    e: React.ChangeEvent<HTMLInputElement> | { target: { value: string } }
  ) => {
    if (preSaleStage !== PreSaleStage.Running) return;

    const value = e.target.value;
    const regex = /^\d*\.?\d{0,6}$/;
    if (!regex.test(value)) {
      return;
    }

    if (value === "" || value === "0") {
      setPayAmount(0);
      setTokenAmount(0);
    } else {
      try {
        const newPayAmount = ethers.parseUnits(value, 6);
        setPayAmount(parseFloat(value));
        if (paymentType === "ETH") {
          const ethAmount = ethers.parseEther(value);
          const temp = await presaleContract.methods
            .estimatedTokenAmountAvailableWithETH(ethAmount.toString())
            .call();
          const expectedTokenAmount = ethers.formatUnits(temp, 18);
          setTokenAmount(parseFloat(expectedTokenAmount));
        } else {
          const temp = await presaleContract.methods
            .estimatedTokenAmountAvailableWithCoin(
              newPayAmount.toString(),
              TOKENS[paymentType as keyof typeof TOKENS]
            )
            .call();
          const expectedTokenAmount =
            paymentType === "DAI"
              ? ethers.formatUnits(temp, 6)
              : ethers.formatUnits(temp, 18);
          setTokenAmount(parseFloat(expectedTokenAmount));
        }
      } catch (error) {
        console.error("Error fetching token amount:", error);
        toast.error("Error fetching token amount");
        setTokenAmount(0);
      }
    }
  };

    const handleBuy = async () => {
    setPayAmount(0);
    setTokenAmount(0);
    try {
      switch (paymentType) {
        case "ETH":
          const ethAmount = ethers.parseEther(payAmount.toString());
          const txETH = await presaleContract.methods
            .buyWithETH()
            .send({ from: account, value: ethAmount.toString() });
          break;
        case "USDT":
          const txUSDT = await presaleContract.methods
            .buyWithUSDT(toBigInt(tokenAmount.toString()))
            .send({ from: account });
          break;
        case "USDC":
          const txUSDC = await presaleContract.methods
            .buyWithUSDC(toBigInt(tokenAmount.toString()))
            .send({ from: account });
          break;
        case "DAI":
          const txDAI = await presaleContract.methods
            .buyWithDAI(toBigInt(tokenAmount.toString()))
            .send({ from: account });
          break;
      }

      const balance = await presaleContract.methods
        .getTokenAmountForInvestor(account)
        .call();
      const formattedBalance = ethers.formatUnits(balance, 18);
      const tempFundsRaised = await presaleContract.methods
        .getFundsRaised()
        .call();
      const tempTokensAvailable = await presaleContract.methods
        .tokensAvailable()
        .call();
      const formattedTokensAvailable = parseFloat(
        ethers.formatUnits(tempTokensAvailable, 18)
      );

      fetchBalances();
      setFundsRaised(parseFloat(tempFundsRaised) / 1e6);
      setTokensAvailable(Math.floor(formattedTokensAvailable));
      setClaimableSPXBalance(formattedBalance);
    } catch (error) {
      toast.error("Transaction failed. Please try again.");
    }
  };

  ...

  return {
    <button
      className="max-w-[70%] w-full bg-[#824B3D] p-3 rounded font-bold mb-4 hover:bg-orange-800 truncate"
      onClick={account ? openAccountModal : openConnectModal}
    >
      {account ? account.displayName : "CONNECT WALLET"}
    </button>

    {account && (
    <button
      className="w-full bg-[#824B3D] p-3 rounded font-bold mb-4 hover:bg-orange-800 disabled:bg-[#333] disabled:cursor-not-allowed truncate"
      disabled={
        isLoading ||
        preSaleStage === PreSaleStage.Ready ||
        preSaleStage === PreSaleStage.Ended ||
        (preSaleStage === PreSaleStage.Running &&
          (payAmount < min ||
            payAmount >
              parseFloat(balances[paymentType]))) ||
        (preSaleStage === PreSaleStage.Claimable &&
          parseFloat(claimableSPXBalance) < 1)
      }
      onClick={
        preSaleStage !== PreSaleStage.Claimable
          ? handleBuy
          : handleClaim
      }
    >
      {preSaleStage < PreSaleStage.Ended
        ? "BUY"
        : "CLAIM"}
    </button>
  )}

  ....
}

Conclusion

Building a Web3 presale dApp with Next.js, Ethers.js, Wagmi, and RainbowKit creates a powerful and user-friendly platform for token sales. This implementation demonstrates how modern Web3 tools can create sophisticated yet accessible DeFi applications that bridge the gap between blockchain technology and mainstream users.

How to test smart contract on Sepolia testnet?

Steven — Wed, 13 Nov 2024 05:00:38 +0000

Introduction

Testing smart contracts on a testnet before mainnet deployment is crucial for ensuring functionality and security. The Sepolia testnet provides an ideal environment to test the smart contract with real network conditions without risking real assets.

Real-World Simulation: Testing on a testnet mimics the actual blockchain environment, allowing developers to see how their contracts perform with real transactions and network conditions.

Interaction with Other Contracts: Testnets let developers check how their smart contracts work when interacting with other contracts or dApps, helping to catch potential issues that weren't apparent during unit testing.

We have already done the thorough unit testing using Hardhat and Chai, but we are going to check if this smart contract is working well on Sepolia testnet.

This article will walk you through deploying the SPX ERC20 token presale smart contract on the Sepolia testnet, an Ethereum test network and thorough testing it on sepolia etherscan.

Deployment on Sepolia testnet

Configure Hardhat settings

First, we need to configure the Hardhat settings to deploy our smart contract on the Sepolia testnet.

Create a new file named hardhat.config.ts in the root directory of your project.
Open the file and add the following code:

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import "dotenv/config";

const infuraKey: string = process.env.INFURA_API_KEY as string;
const privateKey: string = process.env.PRIVATE_KEY ? process.env.PRIVATE_KEY as string: "";
const etherscanKey: string = process.env.ETHERSCAN_KEY ? process.env.ETHERSCAN_KEY as string: "";

const config: HardhatUserConfig = {
  solidity: {
    version: "0.8.27",
    settings: {
      optimizer: {
        enabled: true,
        runs: 100,
      },
      viaIR: true,
    },
  },
  networks: {
    sepolia: {
      url: `https://sepolia.infura.io/v3/${infuraKey}`,
      accounts: [`0x${privateKey}`],
    },
    mainnet: {
      url: `https://mainnet.infura.io/v3/${infuraKey}`,
      accounts: [`0x${privateKey}`],
    },
    hardhat: {
      chainId: 31337,
    },
  },
  etherscan: {
    apiKey: {
      eth_mainnet: etherscanKey,
      eth_sepolia: etherscanKey
    },
  },
  gasReporter: {
    enabled: true,
  },
  sourcify: {
    enabled: true,
  },
};

export default config;

Second, we need to create a .env file in the root directory of your project.

INFURA_API_KEY=your_infura_api_key
PRIVATE_KEY=your_wallet_private_key
ETHERSCAN_KEY=your_etherscan_api_key

Writing the deployment script

First we need to deploy SPX ERC20 token smart contract, so let's create a new file named deploy_SPX.ts in the scripts directory of your project.

import { ethers } from 'hardhat'

async function main() {
  const [deployer] = await ethers.getSigners();
  const instanceSPX = await ethers.deployContract("SPX");
  await instanceSPX.waitForDeployment()
  const SPX_Address = await instanceSPX.getAddress();
  console.log(`SPX is deployed. ${SPX_Address}`);
}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error)
    process.exitCode = 1
  })

Then, deploy the SPX ERC20 token smart contract on the Sepolia testnet.

npx hardhat run scripts/deploy_SPX.ts --network sepolia

In the output, you will see the deployed SPX contract address.

SPX is deployed. 0xF4072Ee965121c2857EeBa0D3e3C6B9795403072

Just copy it and paste it into the spxAddress variable in the deploy_Presale.ts script below.

Similarly, create a new file named deploy_Presale.ts in the scripts directory of your project.

import { ethers } from 'hardhat'

async function main() {
  const softcap = ethers.parseUnits("300000", 6);
  const hardcap = ethers.parseUnits("1020000", 6);
  const presaleStartTimeInMilliSeconds = new Date("2024-11-15T00:00:00Z"); //2024-11-15T00:00:00Z 
  const presaleStartTime = Math.floor(presaleStartTimeInMilliSeconds.getTime() / 1000);

  const presaleDuration = 24 * 3600 * 30;  //30 days
  const presaleTokenPercent = 10;
  const spxAddress = "0xF4072Ee965121c2857EeBa0D3e3C6B9795403072";   //Deployed SPX token contract on Sepolia

  const [deployer] = await ethers.getSigners();

  const instancePresale = await ethers.deployContract("Presale", [softcap, hardcap, presaleStartTime, presaleDuration, ficcoAddress, presaleTokenPercent]);
  await instancePresale.waitForDeployment();
  const Presale_Address = await instancePresale.getAddress();
  console.log(`Presale is deployed to ${Presale_Address} and presale start time is ${presaleStartTime}`);       
}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error)
    process.exitCode = 1
  })

Then, deploy the presale smart contract on the Sepolia testnet.

npx hardhat run scripts/deploy_Presale.ts --network sepolia

In the output, you will see the deployed Presale contract address.
The output should be similar to the following:

Presale is deployed to 0x2Ae586f1EbE743eFDCD371E939757EEb42dC6CA7 and presale start time is 1731542400

Testing the Presale smart contract on Sepolia testnet

Verification of the SPX token contract and Presale smart contract on Sepolia testnet

In order to test the SPX token contract and Presale smart contract on Sepolia testnet, we need to verify them on Sepolia Etherscan.

SPX token contract verification

npx hardhat verify 0xF4072Ee965121c2857EeBa0D3e3C6B9795403072 --network sepolia

The command structure is npx hardhat verify <contract_address> <contract constructor arguments> --network <network_name>

The output should be similar to the following:

The contract 0xF4072Ee965121c2857EeBa0D3e3C6B9795403072 has been successfully verified on the block explorer. 
https://sepolia.etherscan.io/address/0xF4072Ee965121c2857EeBa0D3e3C6B9795403072#code

The contract 0xF4072Ee965121c2857EeBa0D3e3C6B9795403072 has already been verified on Sourcify.
https://repo.sourcify.dev/contracts/full_match/11155111/0xF4072Ee965121c2857EeBa0D3e3C6B9795403072/

Presale smart contract verification

npx hardhat verify 0x2Ae586f1EbE743eFDCD371E939757EEb42dC6CA7 300000000000 1020000000000 1731542400 2592000 0xF4072Ee965121c2857EeBa0D3e3C6B9795403072 10 --network sepolia

Here, we need to pass the constructor arguments of the Presale smart contract one by one with space .

The output should be similar to the following:

The contract 0x2Ae586f1EbE743eFDCD371E939757EEb42dC6CA7 has been successfully verified on the block explorer.
https://sepolia.etherscan.io/address/0x2Ae586f1EbE743eFDCD371E939757EEb42dC6CA7#code

Successfully verified contract Presale on Sourcify.
https://repo.sourcify.dev/contracts/full_match/11155111/0x2Ae586f1EbE743eFDCD371E939757EEb42dC6CA7/

Testing the Presale smart contract on Sepolia testnet

You can test the Presale smart contract on Sepolia testnet with Sepolia Etherscan.

Go to the Sepolia Etherscan website and search for the SPX ERC20 token contract address and Presale smart contract address.
Click on the "Contract" tab.
Click on the "Read Contract" tab.

You can see all the read-only functions of the SPX ERC20 token contract and Presale smart contract.

Click on the "Write Contract" tab.

You can see all the write functions of the SPX ERC20 token contract and Presale smart contract.

Connect your MetaMask wallet to Sepolia testnet.

Make sure you have enough Sepolia ETH and USDT, USDC and DAI faucet in your MetaMask wallet.

We can test all the functionalities of the SPX ERC20 token contract and Presale smart contract here.

Before Presale:

Transfer tokens to presale contract.
Verify token balance
Check the buy functions not working before presale starts

During Presale:

Test buying tokens with different payment methods
Verify investment amounts
Check token allocation

After Presale:

Set claim time
Test claim function
Verify token distribution
Test withdrawal or refund based on softcap achievement
Check the buy functions not working after presale ends

Make sure all the require statements are working properly and functions are working correctly with the correct input and output and within correct timespan.

Conclusion

Testing on Sepolia Testnet provides a realistic environment to validate:

Contract functionality
Security measures
Gas optimization
User interaction flows
Integration with other contracts

Always verify all functions thoroughly before proceeding to mainnet deployment. The systematic testing approach on Sepolia ensures a smooth and secure launch on the mainnet.

Thorough Testing for ERC20 Token Presale Smart Contract using Hardhat and Chai

Steven — Sat, 09 Nov 2024 18:43:39 +0000

Introduction

This article shows how to thoroughly test a SPX ERC20 token presale smart contract using Hardhat and Chai on Ethereum Sepolia testnet. We'll cover testing all key functionalities including token purchases with multiple currencies, claiming, refunds and withdraw functions.

Prerequisites

Hardhat development environment
Chai assertion library
Ethereum-waffle for blockchain testing
Basic understanding of TypeScript testing

Testing Presale smart contract step by step

Test Structure

describe('Presale Contract', async function () {
    // Before testing, deploy SPX ERC20 token smart contract and Presale smart contract 
    before(async function () {
        // Deploy SPX, Presale, USDT, USDC, DAI token contract to Sepolia testnet and gets contract instance.
        // Approve presale contract to spend USDT, USDC, and DAI from investors
    })

    describe("Presale setup", function () {
        //Checks if sufficient tokens are available in presale contract
    })

    // Test token purchase functions
    describe("Buying SPX with USDT", function () {
        // It should not allow investors spending USDT more thatn allowance
        // It should allow investors buying SPX tokens with USDT
        // It should not allow investors buying SPX tokens before presale starts
        // It should now allow investors buying SPX tokens after presale ends 
    })
    describe("Buying SPX with USDC", function () {
        // It should not allow investors spending USDC more thatn allowance
        // It should allow investors buying SPX tokens with USDC
        // It should not allow investors buying SPX tokens before presale starts
        // It should now allow investors buying SPX tokens after presale ends 
    })
    describe("Buying SPX with DAI", function () {
        // It should not allow investors spending DAI more thatn allowance
        // It should allow investors buying SPX tokens with DAI
        // It should not allow investors buying SPX tokens before presale starts
        // It should now allow investors buying SPX tokens after presale ends 
    })
    describe("Buying SPX with ETH", function () {
        // It should allow investors buying SPX tokens with ETH
        // It should not allow investors buying SPX tokens before presale starts
        // It should now allow investors buying SPX tokens after presale ends 
    })

    // Test admin functions
    describe("Claim functionality", function () {
        before(async function () {
            // Set the claim time before each test
        })
        // It should revert if trying to claim tokens before claim time is set
        // It should correctly distribute bonus tokens among multiple early investors
        // It should allow investors to claim their tokens
        // It should revert if a non-owner tries to set the claim time
    })

    describe("Withdraw functionality", function () {
        before(async function () {
            // Set the predefined multisig wallet before each test       
        })
        // It should allow the owner to withdraw balance of contract to wallet after presale ends
        // It should revert if non-owner tries to withdraw
        // It should revert if a non-owner tries to set the wallet
        // It should revert if trying to withdraw before the presale ends
    })

    describe("Refund Functionality", function () {
        // It should allow the owner to refund to investors if softcap is not reached
        // It should revert if non-owner tries to refund
        // It should revert if trying to refund before the presale ends
    })
})

Important Key Test Cases

Presale setup

describe("Presale setup", function () {
    it("should set up presale correctly", async function () {
        expect(await presale.getFundsRaised()).to.equal(0);
        expect(await presale.tokensAvailable()).to.equal(presaleSupply);
    });
});

Token purchase function test

describe("Buying SPX with USDT", function () {
    it("should not allow investors spending usdt more than allowance", async function () {
        const tokenAmount = ethers.parseUnits("20000000", 18); 
        await expect(presale.connect(investor1).buyWithUSDT(tokenAmount))
            .to.be.revertedWith("Insufficient allowance set for the contract.");
    });

    it("should allow investors buying SPX tokens with USDT.", async function () {
        const tokenAmount = ethers.parseUnits("1500000", 18); 
        const usdtAmount = await presale.estimatedCoinAmountForTokenAmount(tokenAmount, usdtMockInterface);

        const investmentsforUserBeforeTx1 = await presale.getInvestments(investor1.address, SEPOLIA_USDT);
        const investmentsforUserBeforeTx2 = await presale.getInvestments(investor2.address, SEPOLIA_USDT);
        const fundsRaisedBeforeTx = await presale.getFundsRaised();
        const investorTokenBalanceBeforeTx1 = await presale.getTokenAmountForInvestor(investor1.address);
        const investorTokenBalanceBeforeTx2 = await presale.getTokenAmountForInvestor(investor2.address);
        const tokensAvailableBeforeTx = await presale.tokensAvailable();

        const tx1 = await presale.connect(investor1).buyWithUSDT(tokenAmount);
        await tx1.wait();
        const tx2 = await presale.connect(investor2).buyWithUSDT(tokenAmount);
        await tx2.wait();

        const investmentsforUserAfterTx1 = await presale.getInvestments(investor1.address, SEPOLIA_USDT);
        const investmentsforUserAfterTx2 = await presale.getInvestments(investor2.address, SEPOLIA_USDT);
        const fundsRaisedAfterTx = await presale.getFundsRaised();
        const investorTokenBalanceAfterTx1 = await presale.getTokenAmountForInvestor(investor1.address);
        const investorTokenBalanceAfterTx2 = await presale.getTokenAmountForInvestor(investor2.address);
        const tokensAvailableAfterTx = await presale.tokensAvailable();

        expect(investorTokenBalanceAfterTx1).to.equal(investorTokenBalanceBeforeTx1 + tokenAmount);
        expect(investorTokenBalanceAfterTx2).to.equal(investorTokenBalanceBeforeTx2 + tokenAmount);
        expect(tokensAvailableAfterTx).to.equal(tokensAvailableBeforeTx - BigInt(2) * tokenAmount);
        expect(investmentsforUserAfterTx1).to.equal(investmentsforUserBeforeTx1 + usdtAmount);
        expect(investmentsforUserAfterTx2).to.equal(investmentsforUserBeforeTx2 + usdtAmount);
        expect(fundsRaisedAfterTx).to.equal(fundsRaisedBeforeTx + usdtAmount * BigInt(2) / BigInt(1000000));
    });

    //Before presale starts
    it("should not allow investors buying SPX tokens before presale starts", async function () {
        const tokenAmount = ethers.parseUnits("1500000", 18);
        await expect(presale.connect(investor1).buyWithUSDT(tokenAmount))
            .to.be.revertedWith("Invalid time for buying the token.");
    });

    //After presale ends
    it("should not allow investors buying SPX tokens after presale ends", async function () {
        const tokenAmount = ethers.parseUnits("1500000", 18);
        await expect(presale.connect(investor1).buyWithUSDT(tokenAmount))
            .to.be.revertedWith("Invalid time for buying the token.");
    });
});

This test suite "Buying SPX with USDT" contains four test cases that verify different scenarios:

Testing insufficient allowance:

Tests buying 20,000,000 SPX tokens (worth 1600 USDT) Investors have 1000 USDT allowance
Expects transaction to fail with "Insufficient allowance" error
Verifies allowance checks are working properly

Testing successful token purchase:

Tests buying 1,500,000 SPX tokens (worth 120 USDT)
Records state before transactions:
- USDT investments for both investors
- Total funds raised
- Token balances
- Available tokens
Executes purchases for two investors
Verifies after transaction:
- Token balances increased correctly
- Available tokens decreased properly
- Investment amounts recorded accurately
- Funds raised updated correctly

Testing presale timing restrictions (before start):

Attempts purchase before presale start time
Expects revert with "Invalid time" message
Verifies timing restrictions work

Testing presale timing restrictions (after end):

Attempts purchase after presale end time
Expects revert with "Invalid time" message
Verifies presale end time enforcement

This test suite ensures the USDT purchase functionality works correctly under all expected conditions.
Similarly, we can write test suite for USDC, DAI, ETH purchase functionality.

Claim function test

describe("Claim functionality", function () {
    before(async function () {
        // Set the claim time before each test
        const setClaimTimeTx = await presale.connect(owner).setClaimTime(claimTime);
        await setClaimTimeTx.wait();
    });

    //Before presale ends
    it("should revert if trying to claim tokens before claim time is set", async function () {
        await presale.connect(investor1).buyWithUSDT(ethers.parseUnits("1500000", 18));
        await expect(presale.connect(investor1).claim(investor1.address)).to.be.revertedWith("It's not claiming time yet.");
    });

    it("should correctly distribute bonus tokens among multiple early investors", async function () {
        expect(await presale.isEarlyInvestors(investor1.address)).to.be.true;
        expect(await presale.isEarlyInvestors(investor2.address)).to.be.true;
    });

    it("should allow investors to claim their tokens", async function () {
        const initialBalance = await spx.balanceOf(investor2.address);
        const tokenAmount = await presale.getTokenAmountForInvestor(investor2.address);
        const bonusTokenAmount = await presale.getBonusTokenAmount();

        const claimTx = await presale.connect(investor2).claim(investor2.address);
        await claimTx.wait();
        const finalBalance = await spx.balanceOf(investor2.address);

        expect(finalBalance - initialBalance).to.equal(tokenAmount + bonusTokenAmount);
        expect(await presale.getTokenAmountForInvestor(investor2.address)).to.equal(0);
        //Second claim
        await expect(presale.connect(investor2).claim(investor2.address))
            .to.be.revertedWith("No tokens claim.");
    });

    it("should revert if a non-owner tries to set the claim time", async function () {
        await expect(presale.connect(investor1).setClaimTime(claimTime)).to.be.revertedWithCustomError(presale, "NotOwner");
    });
});

This Claim test suite verifies the token claiming process with five key test cases:

Initial setup:

Sets up claim time before running tests
Uses owner account to set claim time

Early Claim Prevention:

Tests claiming before proper time
Buys tokens with USDT first
Verifies claim attempt fails with timing error

Early Investor Bonus Verification:

Checks early investor status for two investors
Verifies both are marked as early investors
Ensures bonus distribution eligibility

Token Claiming Process:

Records initial token balance
Gets expected token amount and bonus
Executes claim transaction
Verifies:
- Final balance matches expected amount
- Token balance reset to zero
- Second claim attempt fails

Token Claiming Process:

Tests unauthorized claim time setting
Verifies only owner can set claim time
Checks custom error handling

This test suite ensures the claiming mechanism works correctly and securely under various conditions.

Withdraw function test

describe("Withdraw functionality", function () {
    before(async function () {
        const setWalletTx = await presale.connect(owner).setWallet(wallet.address);
        await setWalletTx.wait();
    })

    it("should allow the owner to withdraw balance of contract to wallet after presale ends", async function () {
        const initialUSDTBalance = await usdtMockInterface.balanceOf(wallet.address);
        const initialUSDCBalance = await usdcMockInterface.balanceOf(wallet.address);
        const initialDAIBalance = await daiMockInterface.balanceOf(wallet.address);

        const usdtAmount = await usdtMockInterface.balanceOf(presaleAddress);
        const usdcAmount = await usdcMockInterface.balanceOf(presaleAddress);
        const daiAmount = await daiMockInterface.balanceOf(presaleAddress);

        const withdrawTx = await presale.connect(owner).withdraw();
        await withdrawTx.wait();

        const finalUSDTBalance = await usdtMockInterface.balanceOf(wallet.address);
        const finalUSDCBalance = await usdcMockInterface.balanceOf(wallet.address);
        const finalDAIBalance = await daiMockInterface.balanceOf(wallet.address);

        expect(finalUSDTBalance).to.equal(initialUSDTBalance + usdtAmount);
        expect(finalUSDCBalance).to.equal(initialUSDCBalance + usdcAmount);
        expect(finalDAIBalance).to.equal(initialDAIBalance + daiAmount);
    });

    it("should revert if non-owner tries to withdraw", async function () {
        await expect(presale.connect(investor1).withdraw()).to.be.revertedWithCustomError(presale, "NotOwner");
    });

    it("should revert if a non-owner tries to set the wallet", async function () {
        await expect(presale.connect(investor1).setWallet(wallet)).to.be.revertedWithCustomError(presale, "NotOwner");
    });

    //Before presale ends
    it("should revert if trying to withdraw before the presale ends", async function () {
        await expect(presale.connect(owner).withdraw())
            .to.be.revertedWith("Cannot withdraw because presale is still in progress.");
    })
})

This Withdraw test suite verifies the token claiming process with five key test cases:

Initial setup:

Sets withdraw wallet address before tests
Uses owner account to configure wallet

Owner Withdraw Testing:

Records initial balances of USDT, USDC, DAI in wallet
Gets contract balances for all tokens
Executes withdraw
Verifies final balances match expected amounts:
- USDT balance increased correctly
- USDC balance increased correctly
- DAI balance increased correctly

Unauthorized Withdraw Prevention:

Tests withdraw with non-owner account
Verifies custom error "NotOwner" is thrown

Wallet Setting Access Control:

Tests unauthorized wallet address setting
Verifies only owner can set wallet address
Checks custom error handling

Early Withdraw Prevention:

Tests withdraw before presale end time
Verifies timing restriction message
Ensures funds are locked during presale

This test suite ensures the withdrawl mechanism works correctly and securely under various conditions.

Refund function test

describe("Refund Functionality", function () {
    it("should allow the owner to refund to investors if softcap is not reached", async function () {
        const investor1USDTInitialBalance = await usdtMockInterface.balanceOf(investor1.address);
        const investor2USDTInitialBalance = await usdtMockInterface.balanceOf(investor2.address);
        const investor1USDCInitialBalance = await usdcMockInterface.balanceOf(investor1.address);
        const investor2USDCInitialBalance = await usdcMockInterface.balanceOf(investor2.address);
        const investor1DAIInitialBalance = await daiMockInterface.balanceOf(investor1.address);
        const investor2DAIInitialBalance = await daiMockInterface.balanceOf(investor2.address);

        const investor1USDTAmount = await presale.getInvestments(investor1.address, usdtMockInterface);
        const investor2USDTAmount = await presale.getInvestments(investor2.address, usdtMockInterface);
        const investor1USDCAmount = await presale.getInvestments(investor1.address, usdcMockInterface);
        const investor2USDCAmount = await presale.getInvestments(investor2.address, usdcMockInterface);
        const investor1DAIAmount = await presale.getInvestments(investor1.address, daiMockInterface);
        const investor2DAIAmount = await presale.getInvestments(investor2.address, daiMockInterface);

        await usdtMockInterface.connect(investor1).approve(presaleAddress, investor1USDTAmount);
        await usdtMockInterface.connect(investor2).approve(presaleAddress, investor2USDTAmount);
        await usdcMockInterface.connect(investor1).approve(presaleAddress, investor1USDCAmount);
        await usdcMockInterface.connect(investor2).approve(presaleAddress, investor2USDCAmount);
        await daiMockInterface.connect(investor1).approve(presaleAddress, investor1DAIAmount);
        await daiMockInterface.connect(investor2).approve(presaleAddress, investor2DAIAmount);

        const tx = await presale.connect(owner).refund();
        await tx.wait();

        const investor1USDTFinalBalance = await usdtMockInterface.balanceOf(investor1.address);
        const investor2USDTFinalBalance = await usdtMockInterface.balanceOf(investor2.address);
        const investor1USDCFinalBalance = await usdcMockInterface.balanceOf(investor1.address);
        const investor2USDCFinalBalance = await usdcMockInterface.balanceOf(investor2.address);
        const investor1DAIFinalBalance = await daiMockInterface.balanceOf(investor1.address);
        const investor2DAIFinalBalance = await daiMockInterface.balanceOf(investor2.address);

        expect(investor1USDTFinalBalance).to.equal(investor1USDTInitialBalance + investor1USDTAmount);
        expect(investor2USDTFinalBalance).to.equal(investor2USDTInitialBalance + investor2USDTAmount);
        expect(investor1USDCFinalBalance).to.equal(investor1USDCInitialBalance + investor1USDCAmount);
        expect(investor2USDCFinalBalance).to.equal(investor2USDCInitialBalance + investor2USDCAmount);
        expect(investor1DAIFinalBalance).to.equal(investor1DAIInitialBalance + investor1DAIAmount);
        expect(investor2DAIFinalBalance).to.equal(investor2DAIInitialBalance + investor2DAIAmount);
    });

    it("should revert if non-owner tries to refund", async function () {
        await expect(presale.connect(investor1).refund())
            .to.be.revertedWithCustomError(presale, "NotOwner");
    });

    //After presale ends
    it("should revert if trying to refund before the presale ends", async function () {
        await expect(presale.connect(owner).refund())
            .to.be.revertedWith("Cannot refund because presale is still in progress.");
    })
});

This Refund test suite verifies the token refunding process with three key test cases:

Owner Refund Testing:

Records initial balances for all investors in USDT, USDC, DAI
Gets investment amounts for each investor and token
Sets up approvals for all tokens and investors
Executes refund transaction
Verifies final balances:
- USDT balances returned correctly
- USDC balances returned correctly
- DAI balances returned correctly
Ensures each investor receives their exact investment back

Unauthorized Refund Prevention:

Tests refund with non-owner account
Verifies custom error "NotOwner" is thrown
Ensures only owner can initiate refunds

Early Refund Prevention:

Tests refund before presale end time
Verifies timing restriction message
Ensures refunds can't happen during active presale

This ensures the refund mechanism works correctly and securely for all investors and tokens under various conditions.

Best Practices

Use before hooks for test setup
Test both success and failure cases
Verify events and state changes
Test access control
Use helper functions for common operations
Maintain test isolation

Conclusion

Thorough testing is crucial for presale contracts handling significant value. This testing approach ensures the contract behaves correctly under all conditions while maintaining security and fairness for all participants.

Comprehensive guide to write ERC20 token presale smart contract on Ethereum blockchain using Solidity

Steven — Sat, 09 Nov 2024 07:52:29 +0000

Introduction

This article will give you a comprehensive guide to build a presale contract that accepts ETH and major stablecoins step by step.

Key Features

Multiple payment options(ETH, USDT, USDC, DAI)
Early Investor bonus system
Staged token buying campaign

Prerequisites

Hardhat development environment
Openzeppelin contracts
Ethereum development experience
Basic understanding of ERC20 tokens

Token features

Type: ERC20
Name: Silver Phoenix
Symbol: SPX
Decimal: 18
Total Supply: 100 billion

Presale Features

Presale Supply: 10 billion (10%)
Presale Period: 30 days
Presale Stage: 4
Softcap: 500000 USDT
Hardcap: 1020000 USDT
Price and token amounts for each stage:

Stage	Price	Token Amount
1	0.00008 USDT	3 billion
2	0.00010 USDT	4 billion
3	0.00012 USDT	2 billion
4	0.00014 USDT	1 billion

Options for buying tokens: ETH, USDT, USDC, DAI
Claim time: After second public sale ends
Minimum amount for buying tokens: 100 USDT

Investors who bought tokens before softcap reached are listed on early investors and can get bonus tokens after presale ends if unsold tokens exist.

How to implement step by step

Key functions:

buyWithETH
buyWithStableCoin
Helper functions for calculating token amounts available with ETH or Stable coin and vice versa
Claim
Withdraw
Refund
Several helper functions like set and get functions

Buy SPX token with ETH

function buyWithETH() external payable whenNotPaused nonReentrant {
    require(
        block.timestamp >= startTime && block.timestamp <= endTime,
        "Invalid time for buying the token"
    );

    uint256 _estimatedTokenAmount = estimatedTokenAmountAvailableWithETH(
        msg.value
    );
    uint256 _tokensAvailable = tokensAvailable();

    require(
        _estimatedTokenAmount <= _tokensAvailable &&
            _estimatedTokenAmount > 0,
        "Invalid token amount to buy"
    );

    uint256 minUSDTOutput = (_estimatedTokenAmount * 90) / 100;
    // Swap ETH for USDT
    address[] memory path = new address[](2);
    path[0] = router.WETH();
    path[1] = USDT;

    uint256[] memory amounts = router.swapExactETHForTokens{
        value: msg.value
    }(minUSDTOutput, path, address(this), block.timestamp + 15 minutes);

    // Ensure the swap was successful
    require(amounts.length > 1, "Swap failed, no USDT received");
    uint256 _usdtAmount = amounts[1];

    // Calculate final token amount
    uint256 _tokenAmount = estimatedTokenAmountAvailableWithCoin(
        _usdtAmount,
        USDTInterface
    );

    //Update investor records
    _updateInvestorRecords(
        msg.sender,
        _tokenAmount,
        USDTInterface,
        _usdtAmount
    );

    //Update presale stats
    _updatePresaleStats(_tokenAmount, _usdtAmount, 6);

    emit TokensBought(
        msg.sender,
        _tokenAmount,
        _usdtAmount,
        block.timestamp
    );
}

First, this function checks if presale is ongoing or not.
Next, it estimates how much tokens investor can buy with specific ETH amount and checks if this amount is availbale for purchase.
Next, it swaps ETH to USDT using Uniswap V2 Router for buying SPX tokens and returns USDT amount equivalent.
Next, it calculates how much tokens investor can buy with swapped USDT equivalent.
Next, it updates investor and investment status.

function _updateInvestorRecords(
    address investor_,
    uint256 tokenAmount_,
    IERC20 coin_,
    uint256 coinAmount_
) private {
    if (investorTokenBalance[investor_] == 0) {
        investors.push(investor_);
        if (fundsRaised < softcap && !earlyInvestorsMapping[investor_]) {
            earlyInvestorsMapping[investor_] = true;
            earlyInvestors.push(investor_);
        }
    }

    investorTokenBalance[investor_] += tokenAmount_;
    investments[investor_][address(coin_)] += coinAmount_;
}

Next, it updates presale status.

function _updatePresaleStats(
    uint256 tokenAmount_,
    uint256 coinAmount_,
    uint8 coinDecimals_
) private {
    totalTokensSold += tokenAmount_;
    fundsRaised += coinAmount_ / (10 ** (coinDecimals_ - 6));
}

Last, it emits TokensBought event.

Buy SPX token with Stable Coins

function _buyWithCoin(
    IERC20 coin_,
    uint256 tokenAmount_
) internal checkSaleState(tokenAmount_) whenNotPaused nonReentrant {
    uint256 _coinAmount = estimatedCoinAmountForTokenAmount(
        tokenAmount_,
        coin_
    );
    uint8 _coinDecimals = getCoinDecimals(coin_);

    //Check allowances and balances
    require(
        _coinAmount <= coin_.allowance(msg.sender, address(this)),
        "Insufficient allowance"
    );
    require(
        _coinAmount <= coin_.balanceOf(msg.sender),
        "Insufficient balance."
    );

    //Send the coin to the contract
    SafeERC20.safeTransferFrom(
        coin_,
        msg.sender,
        address(this),
        _coinAmount
    );

    //Update the investor status
    _updateInvestorRecords(msg.sender, tokenAmount_, coin_, _coinAmount);

    // Update presale stats
    _updatePresaleStats(tokenAmount_, _coinAmount, _coinDecimals);

    emit TokensBought(
        msg.sender,
        tokenAmount_,
        _coinAmount,
        block.timestamp
    );
}

First, this function checks if presale is ongoing, tokenAmount that investor wants to buy is available, and so on.(modifiers)
Next, it calculates how much coins are needed to buy those amount of tokens and checks if investor has sufficient balance and allowance.
Next, it transfers Stable coins to presale contract.
Then, it updates investor & investment status and presale status, finally, emits TokensBought event.

Each functions for buying token with specific stable coins can be written as follows:

function buyWithUSDT(uint256 tokenAmount_) external whenNotPaused {
    _buyWithCoin(USDTInterface, tokenAmount_);
}

Helper function to calculate SPX token amount with ETH and vice versa

function estimatedTokenAmountAvailableWithETH(
    uint256 ethAmount_
) public view returns (uint256) {
    // Swap ETH for USDT
    address[] memory path = new address[](2);
    path[0] = router.WETH();
    path[1] = USDT;
    uint256[] memory amounts = router.getAmountsOut(ethAmount_, path);
    require(amounts.length > 1, "Invalid path");
    uint256 _usdtAmount = amounts[1];

    // Calculate token amount
    return
        estimatedTokenAmountAvailableWithCoin(_usdtAmount, USDTInterface);
}

This function calculates how much tokens user can buy with specific eth amount using Uniswap V2 Router and estimatedTokenAmountAvailableWithCoin function.

Helper function to calculate SPX token amount with Stable Coin and vice versa

    function estimatedTokenAmountAvailableWithCoin(
        uint256 coinAmount_,
        IERC20 coin_
    ) public view returns (uint256) {
        uint256 tokenAmount = 0;
        uint256 remainingCoinAmount = coinAmount_;
        uint8 _coinDecimals = getCoinDecimals(coin_);

        for (uint8 i = 0; i < thresholds.length; i++) {
            // Get the current token price at the index
            uint256 _priceAtCurrentTier = getCurrentTokenPriceForIndex(i);
            uint256 _currentThreshold = thresholds[i];

            // Determine the number of tokens available at this tier
            uint256 numTokensAvailableAtTier = _currentThreshold >
                totalTokensSold
                ? _currentThreshold - totalTokensSold
                : 0;

            // Calculate the maximum number of tokens that can be bought with the remaining coin amount
            uint256 maxTokensAffordable = (remainingCoinAmount *
                (10 ** (18 - _coinDecimals + 6))) / _priceAtCurrentTier;

            // Determine how many tokens can actually be bought at this tier
            uint256 tokensToBuyAtTier = numTokensAvailableAtTier <
                maxTokensAffordable
                ? numTokensAvailableAtTier
                : maxTokensAffordable;

            // Update amounts
            tokenAmount += tokensToBuyAtTier;
            remainingCoinAmount -=
                (tokensToBuyAtTier * _priceAtCurrentTier) /
                (10 ** (18 - _coinDecimals + 6));

            // If there is no remaining coin amount, break out of the loop
            if (remainingCoinAmount == 0) {
                break;
            }
        }

        return tokenAmount;
    }

This function ensures:

Accurate token calculations across different price tiers
Proper decimal handling for different stablecoins
Maximum token availability limits per tier
Efficient use of remaining purchase amount

The implementation supports the presale's tiered pricing structure while maintaining precision in token calculations.

Claim function

function claim(address investor_) external nonReentrant {
    require(
        block.timestamp > claimTime && claimTime > 0,
        "It's not claiming time yet."
    );

    require(
        fundsRaised >= softcap,
        "Can not claim as softcap not reached. Instead you can be refunded."
    );

    uint256 _tokenAmountforUser = getTokenAmountForInvestor(investor_);
    uint256 _bonusTokenAmount = getBonusTokenAmount();

    if (isEarlyInvestors(investor_))
        _tokenAmountforUser += _bonusTokenAmount;
    require(_tokenAmountforUser > 0, "No tokens claim.");
    investorTokenBalance[investor_] = 0;
    earlyInvestorsMapping[investor_] = false;

    SafeERC20.safeTransfer(token, investor_, _tokenAmountforUser);
    emit TokensClaimed(investor_, _tokenAmountforUser);
}

This function

checks claim time and softcap requirements
calculates total tokens including bonuses
resets investor balances and early investor status
uses SafeERC20 for token transfers
emits TokensClaimed event

Withdraw function

function withdraw() external onlyOwner nonReentrant {
    require(
        block.timestamp > endTime,
        "Cannot withdraw because presale is still in progress."
    );

    require(wallet != address(0), "Wallet not set");

    require(
        fundsRaised > softcap,
        "Can not withdraw as softcap not reached."
    );

    uint256 _usdtBalance = USDTInterface.balanceOf(address(this));
    uint256 _usdcBalance = USDCInterface.balanceOf(address(this));
    uint256 _daiBalance = DAIInterface.balanceOf(address(this));

    require(
        _usdtBalance > 0 && _usdcBalance > 0 && _daiBalance > 0,
        "No funds to withdraw"
    );

    if (_usdtBalance > 0)
        SafeERC20.safeTransfer(USDTInterface, wallet, _usdtBalance);
    if (_usdcBalance > 0)
        SafeERC20.safeTransfer(USDCInterface, wallet, _usdcBalance);
    if (_daiBalance > 0)
        SafeERC20.safeTransfer(DAIInterface, wallet, _daiBalance);
}

This function

validates if predefined multisig wallet address is set
ensures presale is already ended
verifies sufficient funds exist
uses SafeERC20 for transfers

Refund function

function refund() external onlyOwner nonReentrant {
    require(
        block.timestamp > endTime,
        "Cannot refund because presale is still in progress."
    );
    require(fundsRaised < softcap, "Softcap reached, refund not available");

    // refund all funds to investors
    for (uint256 i = 0; i < investors.length; i++) {
        address investor = investors[i];

        //Refund USDT
        uint256 _usdtAmount = investments[investor][address(USDTInterface)];
        if (_usdtAmount > 0) {
            investments[investor][address(USDTInterface)] = 0;
            SafeERC20.safeTransfer(USDTInterface, investor, _usdtAmount);
            emit FundsRefunded(investor, _usdtAmount, block.timestamp);
        }

        //Refund USDC
        uint256 _usdcAmount = investments[investor][address(USDCInterface)];
        if (_usdcAmount > 0) {
            investments[investor][address(USDCInterface)] = 0;
            SafeERC20.safeTransfer(USDCInterface, investor, _usdcAmount);
            emit FundsRefunded(investor, _usdcAmount, block.timestamp);
        }

        //Refund DAI
        uint256 _daiAmount = investments[investor][address(DAIInterface)];
        if (_daiAmount > 0) {
            investments[investor][address(DAIInterface)] = 0;
            SafeERC20.safeTransfer(DAIInterface, investor, _daiAmount);
            emit FundsRefunded(investor, _daiAmount, block.timestamp);
        }
    }

    fundsRaised = 0;
    delete investors;
}

This function

loops through all investors
checks and refunds each stable coin separately
Resets investment records to zero
Emits FundsRefunded events
Clears global state(fundsRaised and investors array)

Conclusion

This SPX token presale smart contract demonstrates a robust and versatile implementation that effectively handles multiple payment methods including ETH, USDT, USDC, and DAI.
This implementation serves as an excellent template for future presale contracts, offering a balance of security, functionality, and user accessibility.
It's architecture ensures fair distribution while protecting both investor and project owner interests through its well-structured validation and distribution mechanisms.