airdrop.py

import json
import os
import time
import logging
from web3 import Web3
from eth_account import Account
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format='%(message)s',
)
logger = logging.getLogger(__name__)

# Constants from .env file
TOKEN_MAX = float(os.getenv('TOKEN_MAX', 0.5))  # Maximum token balance to maintain
SLEEP_BETWEEN_TXS = 2  # Seconds to wait between transactions

# Chain configuration from .env file
RPC_URL = os.getenv('RPC_URL')
if not RPC_URL:
    raise ValueError("🔴 RPC_URL is not set in the environment variables")

CHAIN_ID = os.getenv('CHAIN_ID')
if not CHAIN_ID:
    raise ValueError("🔴 CHAIN_ID is not set in the environment variables")
CHAIN_ID = int(CHAIN_ID)

# Get private keys from .env file
MASTER_PRIVATE_KEY = os.getenv('MASTER_PRIVATE_KEY')
if not MASTER_PRIVATE_KEY:
    raise ValueError("🔴 MASTER_PRIVATE_KEY is not set in the environment variables")

# Get wallet private keys from .env file (comma-separated)
WALLET_PRIVATE_KEYS = os.getenv('WALLET_PRIVATE_KEYS', '').split(',')
if not WALLET_PRIVATE_KEYS or not WALLET_PRIVATE_KEYS[0]:
    raise ValueError("🔴 WALLET_PRIVATE_KEYS is not set in the environment variables")

def derive_address_from_private_key(private_key):
    """Derive Ethereum address from a private key"""
    if isinstance(private_key, str) and private_key.startswith('0x'):
        private_key = private_key[2:]
    account = Account.from_key(private_key)
    return account.address

def create_accounts_json():
    """Create accounts.json with wallet details"""
    wallets = []

    for i, private_key in enumerate(WALLET_PRIVATE_KEYS):
        if not private_key.strip():  # Skip empty entries
            continue

        address = derive_address_from_private_key(private_key)
        wallets.append({
            "id": i,
            "address": address,
            "private_key": private_key
        })

    accounts_data = {
        "master": MASTER_PRIVATE_KEY,
        "wallets": wallets
    }

    with open('accounts.json', 'w') as f:
        json.dump(accounts_data, f, indent=2)

    logger.info(f"✅ Created accounts.json with {len(wallets)} wallets")
    return accounts_data

def get_balance(w3, address):
    """Get balance in ETH for an address"""
    wei_balance = w3.eth.get_balance(address)
    eth_balance = w3.from_wei(wei_balance, 'ether')
    return eth_balance

def send_transaction(w3, from_private_key, to_address, amount_in_eth):
    """Send ETH from one account to another"""
    # Make sure we have the right private key format (with or without 0x prefix)
    if isinstance(from_private_key, str) and from_private_key.startswith('0x'):
        from_private_key_hex = from_private_key[2:]
    else:
        from_private_key_hex = from_private_key

    # Create account from private key
    from_account = Account.from_key(from_private_key_hex)
    from_address = from_account.address

    # Get the nonce for the sender address
    nonce = w3.eth.get_transaction_count(from_address)

    # Convert ETH amount to Wei
    amount_in_wei = w3.to_wei(amount_in_eth, 'ether')

    # Get gas price and estimate gas
    gas_price = w3.eth.gas_price

    # Build the transaction
    tx = {
        'nonce': nonce,
        'to': to_address,
        'value': amount_in_wei,
        'gas': 21000,  # Standard gas for ETH transfer
        'gasPrice': gas_price,
        'chainId': CHAIN_ID
    }

    # Sign the transaction
    signed_tx = Account.sign_transaction(tx, from_private_key_hex)

    # Send the transaction and wait for receipt
    tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction)
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash)

    return {
        'tx_hash': tx_hash.hex(),
        'from': from_address,
        'to': to_address,
        'amount_eth': amount_in_eth,
        'status': receipt['status']
    }

def main():
    # Connect to the Ethereum network
    w3 = Web3(Web3.HTTPProvider(RPC_URL))

    if not w3.is_connected():
        logger.error(f"🔴 Failed to connect to {RPC_URL}")
        return

    logger.info(f"🌐 Connected to network: {w3.net.version}")

    # Create or load accounts.json
    if os.path.exists('accounts.json'):
        with open('accounts.json', 'r') as f:
            accounts_data = json.load(f)
        logger.info(f"📄 Loaded accounts.json with {len(accounts_data['wallets'])} wallets")
    else:
        accounts_data = create_accounts_json()

    # Get master wallet info
    master_private_key = accounts_data['master']
    master_address = derive_address_from_private_key(master_private_key)
    master_balance = get_balance(w3, master_address)

    logger.info(f"💼 Master wallet: {master_address}")
    logger.info(f"💰 Master balance: {master_balance} ETH")

    # Check if master has enough funds
    if master_balance < 1:
        logger.warning(f"⚠️  Warning: Master wallet has less than 1 ETH ({master_balance})")

    # Check each wallet balance and fund if needed
    for wallet in accounts_data['wallets']:
        wallet_address = wallet['address']

        # Skip the master wallet if it's in the list
        if wallet_address.lower() == master_address.lower():
            logger.info(f"⏩ Skipping master wallet {wallet['id']} ({wallet_address}): {get_balance(w3, wallet_address)} ETH")
            continue

        wallet_balance = get_balance(w3, wallet_address)
        logger.info(f"👛 Wallet {wallet['id']} ({wallet_address}): {wallet_balance} ETH")

        # If balance is below TOKEN_MAX, send funds
        if wallet_balance < TOKEN_MAX:
            amount_to_send = float(TOKEN_MAX - wallet_balance)

            # Check if master has enough funds to send
            if master_balance < amount_to_send:
                logger.error(f"🔴 Master wallet doesn't have enough funds to send {amount_to_send} ETH")
                continue

            logger.info(f"📤 Sending {amount_to_send} ETH to {wallet_address}...")

            try:
                result = send_transaction(
                    w3,
                    master_private_key,
                    wallet_address,
                    amount_to_send
                )

                if result['status'] == 1:
                    logger.info(f"✅ Transaction successful: {result['tx_hash']}")
                    master_balance = float(master_balance) - amount_to_send
                else:
                    logger.error(f"❌ Transaction failed: {result['tx_hash']}")

            except Exception as e:
                logger.error(f"❌ Error sending transaction: {str(e)}")

            # Wait between transactions
            time.sleep(SLEEP_BETWEEN_TXS)

if __name__ == "__main__":
    main()