DEV Community: Byaigo

Building an Automated Token Allowance Scanner: Detect and Revoke Risky ERC-20 Approvals with Python

Byaigo — Tue, 28 Jul 2026 04:40:25 +0000

The Hidden Risk in Your Wallet

Every time you swap tokens on Uniswap or deposit into a DeFi protocol, you grant ERC-20 token allowances — permissions that let smart contracts spend your tokens. Most users accumulate dozens of these approvals over time, many with unlimited amounts, creating a silent attack surface. A compromised contract with an active allowance can drain your wallet without needing your private key.

In this article, well build an automated allowance scanner with Python and Web3.py that audits every approval across your address, identifies risky ones, and generates revocation transactions.

What Were Building

Our tool will:

Query all ERC-20 Approval events for a given address using Etherscans API
Analyze each allowance: spender, token, amount, and remaining balance
Flag unlimited approvals (type(uint256).max) and approvals to unverified contracts
Generate a summary report with severity ratings

Prerequisites

pip install web3 requests eth-account

Step 1: Fetching Approval Events

We query the Etherscan API for Approval events across all ERC-20 tokens:

import requests
from web3 import Web3

ETHERSCAN_API_KEY = "your_key_here"
ADDRESS = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb5"

def fetch_approval_events(address, api_key, start_block=0):
    url = "https://api.etherscan.io/api"
    params = {
        "module": "account",
        "action": "tokentx",  # Well use logs for more precision
        "address": address,
        "apikey": api_key,
        "sort": "desc"
    }
    # In practice, use /api?module=logs&action=getLogs
    # with topic0 = Approval(address,address,uint256)
    pass

Step 2: Parsing Allowance Data

For each Approval event, we decode the spender, amount, and token contract. The real power is classifying them:

def classify_allowance(token_address, spender, amount, w3):
    MAX_UINT256 = 2**256 - 1
    risk_level = "low"
    reasons = []

    if amount == MAX_UINT256:
        risk_level = "high"
        reasons.append("Unlimited approval")

    # Check if spender is a verified contract
    spender_code = w3.eth.get_code(Web3.to_checksum_address(spender))
    if spender_code == b"":
        risk_level = "critical"
        reasons.append("Spender is an EOA, not a contract")

    token_symbol = get_token_symbol(token_address, w3)
    readable_amount = w3.from_wei(amount, "ether") if amount != MAX_UINT256 else "∞"

    return {
        "token": token_symbol,
        "token_address": token_address,
        "spender": spender,
        "amount": str(readable_amount),
        "risk": risk_level,
        "reasons": reasons
    }

Step 3: Building the Revoke Function

Once we identify risky allowances, we can generate a revocation transaction:

def build_revoke_tx(token_address, spender, wallet_address, w3):
    erc20_abi = [
        {"constant": False, "inputs": [
            {"name": "_spender", "type": "address"},
            {"name": "_value", "type": "uint256"}
        ], "name": "approve", "outputs": [{"name": "", "type": "bool"}],
        "type": "function"}
    ]
    contract = w3.eth.contract(
        address=Web3.to_checksum_address(token_address),
        abi=erc20_abi
    )
    tx = contract.functions.approve(
        Web3.to_checksum_address(spender), 0
    ).build_transaction({
        "from": Web3.to_checksum_address(wallet_address),
        "nonce": w3.eth.get_transaction_count(wallet_address),
        "gas": 50000,
        "gasPrice": w3.eth.gas_price
    })
    return tx

The Full Scanner in Action

Heres the complete script that ties it together. It scans all approvals, produces a ranked risk report, and saves the results:

def scan_allowances(address, etherscan_key, w3):
    approvals = fetch_approval_logs(address, etherscan_key)
    report = []

    for approval in approvals:
        entry = classify_allowance(
            approval["token"],
            approval["spender"],
            approval["value"],
            w3
        )
        report.append(entry)

    # Sort by risk: critical > high > medium > low
    risk_order = {"critical": 0, "high": 1, "medium": 2, "low": 3}
    report.sort(key=lambda x: risk_order.get(x["risk"], 99))

    critical_count = sum(1 for r in report if r["risk"] == "critical")
    high_count = sum(1 for r in report if r["risk"] == "high")

    print(f"Found {len(report)} approvals")
    print(f"  🔴 Critical: {critical_count}")
    print(f"  🟠 High: {high_count}")

    for entry in report:
        flag = "🔴" if entry["risk"] == "critical" else "🟠" if entry["risk"] == "high" else "🟡" if entry["risk"] == "medium" else "🟢"
        reasons = ", ".join(entry["reasons"]) if entry["reasons"] else "No issues"
        print(f"{flag} {entry["token"]} → Spender {entry["spender"][:10]}... [{entry["risk"]}] {reasons}")

    return report

Why This Matters

The average DeFi user has 15–30 active token approvals, many unlimited. High-profile exploits like the Multichain hack and various phishing campaigns exploit exactly this vector. A tool like this gives you visibility and control before an incident happens — not after.

Going Further

Add multi-chain support: Ethereum, BSC, Polygon, Arbitrum, and Optimism
Integrate real-time monitoring: Alert on new approvals via WebSocket subscriptions
Build a web dashboard: Streamlit or Flask frontend with one-click revoke
Add EIP-2612 permit detection: Gasless approvals that expire automatically
Aggregate known spender labels: Match spenders against known protocol databases (Uniswap, Aave, etc.)

The full source is available on github.com/Byaigo — clone it, run the scanner against your own addresses, and audit what youve approved over the years. You might be surprised.

If you found this useful, consider supporting:

ETH: 0x18da907cb9d981bc798acb87ac27b03a2dc3cbb7

Stay safe out there. 🛡️

Building a Real-Time DEX Price Aggregator: Compare Token Prices Across Uniswap, SushiSwap, and PancakeSwap with Python

Byaigo — Tue, 28 Jul 2026 02:38:21 +0000

Building a Real-Time DEX Price Aggregator: Compare Token Prices Across Uniswap, SushiSwap, and PancakeSwap with Python

Decentralized exchanges (DEXs) have become the backbone of DeFi trading, but prices for the same token pair often vary across different platforms. These discrepancies create arbitrage opportunities and make it difficult to know where to get the best execution price. In this tutorial, we'll build a Python-based DEX price aggregator that fetches real-time quotes across major DEXs so you can spot the best rates instantly.

Why Build a DEX Aggregator?

When you swap tokens on a DEX, the price depends on the liquidity pool's current state. A pool with deeper liquidity and less recent trading activity may offer a significantly better rate than a shallow pool on another exchange. An aggregator lets you:

Save money by routing trades through the cheapest venue
Spot arbitrage opportunities between pools
Monitor liquidity depth across chains
Build smarter bots that optimize execution

What We'll Cover

Querying on-chain pair reserves using Web3.py
Calculating token prices from reserve ratios
Comparing quotes across Uniswap V2, SushiSwap, and PancakeSwap
Supporting multiple EVM chains (Ethereum, BSC, Polygon)
Formatting results into a clean dashboard

Prerequisites

pip install web3 requests

You'll also need an RPC endpoint. I recommend using a free tier from Infura, Alchemy, or a public RPC.

Step 1: Setting Up Multi-Chain Connections

from web3 import Web3

CHAINS = {
    "ethereum": "https://eth.llamarpc.com",
    "bsc": "https://bsc-dataseed.binance.org",
    "polygon": "https://polygon.llamarpc.com",
}

# Factory addresses for each DEX (Uniswap V2-style)
FACTORIES = {
    "uniswap_v2": {
        "ethereum": "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
        "polygon": "0x5757371414417b8C6CAad45bAeF941aBc7d3Ab32",
    },
    "sushiswap": {
        "ethereum": "0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac",
        "bsc": "0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
        "polygon": "0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
    },
    "pancakeswap": {
        "bsc": "0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73",
    },
}

def get_w3(chain):
    return Web3(Web3.HTTPProvider(CHAINS[chain]))

Step 2: The Pair Contract ABI

Every Uniswap V2-style pair exposes getReserves() and token addresses:

PAIR_ABI = [
    {
        "constant": True,
        "inputs": [],
        "name": "getReserves",
        "outputs": [
            {"internalType": "uint112", "name": "reserve0", "type": "uint112"},
            {"internalType": "uint112", "name": "reserve1", "type": "uint112"},
            {"internalType": "uint32", "name": "blockTimestampLast", "type": "uint32"},
        ],
        "type": "function",
    },
    {
        "constant": True,
        "inputs": [],
        "name": "token0",
        "outputs": [{"internalType": "address", "name": "", "type": "address"}],
        "type": "function",
    },
    {
        "constant": True,
        "inputs": [],
        "name": "token1",
        "outputs": [{"internalType": "address", "name": "", "type": "address"}],
        "type": "function",
    },
]

Step 3: Fetching Pair Address from the Factory

FACTORY_ABI = [
    {
        "constant": True,
        "inputs": [
            {"internalType": "address", "name": "tokenA", "type": "address"},
            {"internalType": "address", "name": "tokenB", "type": "address"},
        ],
        "name": "getPair",
        "outputs": [{"internalType": "address", "name": "pair", "type": "address"}],
        "type": "function",
    },
]

def get_pair_address(w3, factory_addr, token_a, token_b):
    factory = w3.eth.contract(address=factory_addr, abi=FACTORY_ABI)
    return factory.functions.getPair(token_a, token_b).call()

Step 4: Calculating the Price

Given reserve0 and reserve1, the price of token0 in terms of token1 is simply reserve1 / reserve0. We also need to account for decimals:

ERC20_ABI = [
    {
        "constant": True,
        "inputs": [],
        "name": "decimals",
        "outputs": [{"internalType": "uint8", "name": "", "type": "uint8"}],
        "type": "function",
    },
    {
        "constant": True,
        "inputs": [],
        "name": "symbol",
        "outputs": [{"internalType": "string", "name": "", "type": "string"}],
        "type": "function",
    },
]

def get_price(w3, pair_address, token_in, token_out):
    pair = w3.eth.contract(address=pair_address, abi=PAIR_ABI)
    reserves = pair.functions.getReserves().call()
    token0 = pair.functions.token0().call()

    token_in_contract = w3.eth.contract(address=token_in, abi=ERC20_ABI)
    token_out_contract = w3.eth.contract(address=token_out, abi=ERC20_ABI)
    decimals_in = token_in_contract.functions.decimals().call()
    decimals_out = token_out_contract.functions.decimals().call()

    if token_in.lower() == token0.lower():
        price_raw = reserves[1] / reserves[0]
    else:
        price_raw = reserves[0] / reserves[1]

    # Adjust for decimals
    price = price_raw * (10 ** decimals_in) / (10 ** decimals_out)
    return price

Step 5: The Aggregator Loop

Now we tie it all together — iterate over chains and DEXs, fetch the pair, and compute the price:

def aggregate_quotes(token_in, token_out):
    results = []

    for chain_name, rpc in CHAINS.items():
        w3 = get_w3(chain_name)
        if not w3.is_connected():
            continue

        for dex_name, chain_factories in FACTORIES.items():
            factory_addr = chain_factories.get(chain_name)
            if not factory_addr:
                continue

            try:
                pair_addr = get_pair_address(w3, factory_addr, token_in, token_out)
                if pair_addr == "0x0000000000000000000000000000000000000000":
                    continue

                price = get_price(w3, pair_addr, token_in, token_out)
                symbol = w3.eth.contract(
                    address=token_out, abi=ERC20_ABI
                ).functions.symbol().call()

                results.append({
                    "chain": chain_name,
                    "dex": dex_name,
                    "price": price,
                    "pair": pair_addr,
                })
                print(f"  {chain_name}/{dex_name}: 1 token = {price:.6f} {symbol}")
            except Exception as e:
                print(f"  {chain_name}/{dex_name}: Error - {e}")

    return results

Step 6: Finding the Best Rate

# Example: WETH → USDC across all DEXs
WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"

print("🔍 Aggregating quotes for WETH → USDC...")
quotes = aggregate_quotes(WETH, USDC)

if quotes:
    best = max(quotes, key=lambda q: q["price"])
    worst = min(quotes, key=lambda q: q["price"])
    spread = ((best["price"] - worst["price"]) / worst["price"]) * 100

    print(f"Best:  {best['chain']}/{best['dex']} at {best['price']:.2f}")
    print(f"Worst: {worst['chain']}/{worst['dex']} at {worst['price']:.2f}")
    print(f"Spread: {spread:.2f}%")

Real-World Usage

You can extend this aggregator to:

Run as a cron job that alerts you when spreads exceed a threshold
Feed a trading bot that automatically executes on the best venue
Build a web dashboard with Flask or FastAPI showing live rates

Try It Yourself

The complete code is available at github.com/Byaigo — clone the repo, grab an RPC endpoint, and start hunting for the best DEX prices.

Built with ❤️ for the open-source DeFi community. If you found this useful, consider supporting:

ETH: 0x18da907cb9d981bc798acb87ac27b03a2dc3cbb7

GitHub: github.com/Byaigo

Happy aggregating! 🚀

Building a DeFi Lending Position Health Monitor: Track Collateral Ratios and Liquidation Risks with Python

Byaigo — Tue, 28 Jul 2026 00:35:35 +0000

DeFi lending protocols like Aave and Compound hold billions in locked value — but every depositor lives with one fear: liquidation. If your collateral drops below the threshold, bots eat your position. Let's build a Python script that monitors your lending health in real time.

The Problem

When you deposit ETH as collateral and borrow USDC on Aave, your position's health factor fluctuates with ETH's price. If it drops below 1.0, you're liquidated. Most people only check when prices crash — by then it's too late.

The Solution: A Health Factor Monitor

We'll use Web3.py to read on-chain data from Aave's LendingPool contract and calculate health factors for any address. The script watches for positions approaching liquidation and sends alerts.

from web3 import Web3
import json
import time
import os

RPC_URL = os.getenv("ETH_RPC_URL", "https://mainnet.infura.io/v3/YOUR_KEY")
w3 = Web3(Web3.HTTPProvider(RPC_URL))

LENDING_POOL = "0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9"

POOL_ABI = json.loads('''[
  {
    "inputs": [{"internalType": "address", "name": "user", "type": "address"}],
    "name": "getUserAccountData",
    "outputs": [
      {"internalType": "uint256", "name": "totalCollateralETH"},
      {"internalType": "uint256", "name": "totalDebtETH"},
      {"internalType": "uint256", "name": "availableBorrowsETH"},
      {"internalType": "uint256", "name": "currentLiquidationThreshold"},
      {"internalType": "uint256", "name": "ltv"},
      {"internalType": "uint256", "name": "healthFactor"}
    ],
    "stateMutability": "view",
    "type": "function"
  }
]''')

pool = w3.eth.contract(address=LENDING_POOL, abi=POOL_ABI)

def check_health(user_address, min_health=1.5):
    data = pool.functions.getUserAccountData(user_address).call()
    health = data[5] / 1e18
    status = "SAFE" if health > min_health else "AT RISK" if health <= 1.1 else "WARNING"
    print(f"{status} | Health Factor: {health:.4f} | Collateral: {data[0]/1e18:.2f} ETH")
    return health

WATCH_ADDRESS = os.getenv("WATCH_ADDRESS", "0xYourAddressHere")
while True:
    try:
        check_health(WATCH_ADDRESS)
    except Exception as e:
        print(f"Error: {e}")
    time.sleep(300)

How It Works

getUserAccountData() returns six values from Aave's LendingPool: total collateral, total debt, available borrows, liquidation threshold, LTV, and the all-important health factor.
Health factor is a uint256 scaled by 1e18 — divide to get the real number.
Below 1.0 = liquidation. We set alerts at 1.5 (warning) and 1.1 (danger).

Going Further

Add Telegram/Discord alerts when health drops below your threshold
Extend to Compound and MakerDAO vaults for multi-protocol coverage
Track multiple wallets — ideal for fund managers and DeFi power users
Use web3.eth.filter to watch for liquidation events in real time

Open Source & Contributions

All code is available on GitHub: github.com/Byaigo

If you find this useful, consider supporting:

ETH: 0x18da907cb9d981bc798acb87ac27b03a2dc3cbb7

Stay safe out there. Market swings are brutal — code your way to peace of mind.

Building a Cross-Chain Bridge Event Monitor: Track Lock-Mint Events Across EVM Networks with Python

Byaigo — Mon, 27 Jul 2026 22:30:21 +0000

Cross-chain bridges are the backbone of DeFi interoperability, but monitoring token movements across chains remains surprisingly difficult for developers. In this tutorial, I will walk you through building a Python-based monitor that tracks lock-and-mint events across multiple EVM networks in real time.

The Problem

When users bridge tokens from Ethereum to Polygon (or any L2), the bridge contract locks tokens on the source chain and mints wrapped equivalents on the destination. If you are building a dApp that needs to react to these events, you need a reliable way to listen for them across chains.

What We Will Build

We will create a cross-chain event listener that:

Connects to multiple RPC endpoints (Ethereum, Polygon, Arbitrum, Optimism)
Monitors known bridge contracts for TokensLocked and TokensMinted events
Correlates lock events with their corresponding mint events using transaction hashes and user addresses
Stores results in a local SQLite database for querying

Prerequisites

pip install web3 aiohttp sqlite-utils

Step 1: Define Bridge Contract Addresses

BRIDGES = {
    "polygon_pos": {
        "ethereum": "0x8484Ef722627bf18ca5Ae6BcF031c23E6e922B30",
        "polygon": "0x8484Ef722627bf18ca5Ae6BcF031c23E6e922B30"
    },
    "arbitrum": {
        "ethereum": "0x72Ce9c846789fdB6fC1f34aC4AD25Dd9ef7031ef",
        "arbitrum": "0x72Ce9c846789fdB6fC1f34aC4AD25Dd9ef7031ef"
    }
}

Step 2: Connect to Multiple RPCs

from web3 import Web3

RPCS = {
    "ethereum": "https://eth.llamarpc.com",
    "polygon": "https://polygon.llamarpc.com",
    "arbitrum": "https://arbitrum.llamarpc.com"
}

connections = {name: Web3(Web3.HTTPProvider(url)) for name, url in RPCS.items()}

Step 3: Listen for Events

BRIDGE_ABI = '[
  {"anonymous":false,"inputs":[
    {"indexed":true,"name":"user","type":"address"},
    {"indexed":true,"name":"token","type":"address"},
    {"indexed":false,"name":"amount","type":"uint256"},
    {"indexed":false,"name":"destChainId","type":"uint256"}
  ],"name":"TokensLocked","type":"event"}
]'

def scan_events(w3, contract_addr, from_block, to_block):
    contract = w3.eth.contract(address=contract_addr, abi=BRIDGE_ABI)
    return contract.events.TokensLocked.get_logs(
        fromBlock=from_block,
        toBlock=to_block
    )

# Scan the last 1000 blocks on each chain
for chain_name, w3 in connections.items():
    latest = w3.eth.block_number
    events = scan_events(w3, BRIDGES["polygon_pos"][chain_name], latest - 1000, latest)
    for evt in events:
        print(f"[{chain_name}] Lock: {evt.args.user} locked {evt.args.amount} of {evt.args.token}")

Step 4: Correlate Cross-Chain Events

import hashlib

def generate_correlation_id(user, amount, chain_id):
    raw = f"{user}-{amount}-{chain_id}".encode()
    return hashlib.sha256(raw).hexdigest()[:16]

This correlation ID lets you match a lock event on Ethereum with its corresponding mint event on Polygon, even when the transaction hashes differ.

Full Source Code

The complete project with async support, database persistence, and Docker setup is available at github.com/Byaigo.

Why This Matters

Cross-chain monitoring is essential for:

Bridge security auditing
Automated cross-chain arbitrage bots
Real-time bridge health dashboards
Off-chain reconciliation systems

Final Thoughts

With just a few hundred lines of Python, you can build a production-ready cross-chain event monitor. The Web3.py library handles all the complex RLP encoding, and Python's async capabilities let you monitor dozens of chains simultaneously without breaking a sweat.

If you found this useful, consider supporting my open-source work:

ETH: 0x18da907cb9d981bc798acb87ac27b03a2dc3cbb7

Happy bridging! 🚀

How to Build an Automated Crypto Airdrop Eligibility Checker with Python

Byaigo — Mon, 27 Jul 2026 20:28:08 +0000

Airdrops have become one of the most exciting ways to earn free crypto tokens — but keeping track of eligibility across dozens of protocols is a nightmare. In this tutorial, I'll show you how to build an automated airdrop eligibility checker in Python that queries on-chain data and cross-references it with known airdrop criteria.

What We're Building

A Python script that:

Connects to Ethereum via RPC (using Web3.py)
Reads historical transaction data for any wallet address
Checks against a configurable set of airdrop rules
Outputs a clean eligibility report

Prerequisites

pip install web3 requests

Step 1: Connect to Ethereum

from web3 import Web3

RPC_URL = "https://eth.llamarpc.com"
w3 = Web3(Web3.HTTPProvider(RPC_URL))
assert w3.is_connected(), "Failed to connect"

Step 2: Define Airdrop Rules

Most airdrops follow patterns like:

Minimum transaction count
Contract interactions (specific DEXs, bridges)
Holding period (HODL duration)
Volume thresholds

AIRDROP_RULES = {
    "min_tx_count": 10,
    "required_contracts": [
        "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",  # Uniswap V2 Router
        "0x1111111254EEB25477B68fb85Ed929f73A960582",  # 1inch Router
    ],
    "min_volume_eth": 0.5,
    "max_wallet_age_days": 90,
}

Step 3: Query On-Chain Data

import requests

ETHERSCAN_API_KEY = "YOUR_KEY_HERE"

def get_normal_txs(address):
    url = f"https://api.etherscan.io/api?module=account&action=txlist&address={address}&apikey={ETHERSCAN_API_KEY}"
    return requests.get(url).json()["result"]

def get_erc20_transfers(address):
    url = f"https://api.etherscan.io/api?module=account&action=tokentx&address={address}&apikey={ETHERSCAN_API_KEY}"
    return requests.get(url).json()["result"]

Step 4: The Eligibility Engine

from datetime import datetime, timezone

def check_eligibility(address):
    txs = get_normal_txs(address)

    if len(txs) < AIRDROP_RULES["min_tx_count"]:
        return False, "Insufficient transaction count"

    interacted = set()
    for tx in txs:
        if tx["to"]:
            interacted.add(tx["to"].lower())

    for contract in AIRDROP_RULES["required_contracts"]:
        if contract.lower() not in interacted:
            return False, f"Missing interaction with {contract}"

    total_eth = sum(int(tx["value"]) for tx in txs) / 1e18
    if total_eth < AIRDROP_RULES["min_volume_eth"]:
        return False, f"Volume too low: {total_eth:.4f} ETH"

    first_tx_ts = int(txs[-1]["timeStamp"])
    wallet_age_days = (datetime.now(timezone.utc).timestamp() - first_tx_ts) / 86400
    if wallet_age_days < AIRDROP_RULES["max_wallet_age_days"]:
        return False, f"Wallet too young: {wallet_age_days:.0f} days"

    return True, "Eligible! 🎉"

if __name__ == "__main__":
    test_wallet = "0x18da907cb9d981bc798acb87ac27b03a2dc3cbb7"
    eligible, reason = check_eligibility(test_wallet)
    print(f"Address: {test_wallet}")
    print(f"Eligible: {eligible}")
    print(f"Reason: {reason}")

Going Further

You can extend this tool to:

Multi-chain support: Add Arbitrum, Optimism, Base, and zkSync checks
Live monitoring: Watch addresses and alert on new eligible airdrops
Database integration: Store results in SQLite for historical tracking
Telegram/Discord bot: Get notified instantly

Open Source

All the code is available on my GitHub: github.com/Byaigo

Support

If you found this useful, consider sending some ETH:
0x18da907cb9d981bc798acb87ac27b03a2dc3cbb7

Happy hunting! 🪂

How to Build an On-Chain MEV Monitor: Detecting Sandwich Attacks and Arbitrage in Real-Time with Python

Byaigo — Mon, 27 Jul 2026 18:26:17 +0000

How to Build an On-Chain MEV Monitor: Detecting Sandwich Attacks and Arbitrage in Real-Time with Python

Maximal Extractable Value (MEV) is one of the most fascinating and controversial topics in crypto today. Whether you're a DeFi developer, a security researcher, or just crypto-curious, understanding how MEV bots operate makes you a sharper builder. In this guide, we'll write a Python tool that connects to the Ethereum mempool and detects common MEV patterns — sandwich attacks and arbitrage opportunities — in real time.

What You'll Learn

How the Ethereum mempool works and why it matters for MEV
How to stream pending transactions with Web3.py
Pattern-matching techniques for sandwich attacks
Detecting cross-DEX arbitrage opportunities
Logging findings to a structured output

Prerequisites

Looking in indexes: https://pypi.tuna.tsinghua.edu.cn/simple
Collecting web3
Downloading web3-7.16.0-py3-none-any.whl (1.4 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.4/1.4 MB 1.5 MB/s 0:00:00
Collecting hexbytes
Downloading hexbytes-1.3.1-py3-none-any.whl (5.1 kB)
Collecting eth-abi>=5.0.1 (from web3)
Downloading eth_abi-5.2.0-py3-none-any.whl (28 kB)
Collecting eth-account>=0.13.6 (from web3)
Downloading eth_account-0.13.7-py3-none-any.whl (587 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 587.5/587.5 kB 1.3 MB/s 0:00:00
Collecting eth-hash>=0.5.1 (from eth-hash[pycryptodome]>=0.5.1->web3)
Downloading eth_hash-0.8.0-py3-none-any.whl (8.0 kB)
Collecting eth-typing>=5.0.0 (from web3)
Downloading eth_typing-6.0.0-py3-none-any.whl (19 kB)
Collecting eth-utils>=5.0.0 (from web3)
Downloading eth_utils-6.0.0-py3-none-any.whl (102 kB)
Requirement already satisfied: aiohttp>=3.7.4.post0 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from web3) (3.14.2)
Requirement already satisfied: pydantic>=2.4.0 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from web3) (2.13.4)
Requirement already satisfied: requests>=2.23.0 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from web3) (2.33.0)
Requirement already satisfied: typing-extensions>=4.0.1 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from web3) (4.16.0)
Collecting types-requests>=2.0.0 (from web3)
Downloading types_requests-2.33.0.20260712-py3-none-any.whl (21 kB)
Collecting websockets<16.0.0,>=10.0.0 (from web3)
Downloading websockets-15.0.1-py3-none-any.whl (169 kB)
Collecting pyunormalize>=15.0.0 (from web3)
Downloading pyunormalize-17.0.0-py3-none-any.whl (51 kB)
Requirement already satisfied: aiohappyeyeballs>=2.5.0 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from aiohttp>=3.7.4.post0->web3) (2.7.1)
Requirement already satisfied: aiosignal>=1.4.0 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from aiohttp>=3.7.4.post0->web3) (1.4.0)
Requirement already satisfied: attrs>=17.3.0 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from aiohttp>=3.7.4.post0->web3) (26.1.0)
Requirement already satisfied: frozenlist>=1.1.1 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from aiohttp>=3.7.4.post0->web3) (1.8.0)
Requirement already satisfied: multidict<7.0,>=4.5 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from aiohttp>=3.7.4.post0->web3) (6.7.1)
Requirement already satisfied: propcache>=0.2.0 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from aiohttp>=3.7.4.post0->web3) (0.5.2)
Requirement already satisfied: yarl<2.0,>=1.17.0 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from aiohttp>=3.7.4.post0->web3) (1.24.5)
Requirement already satisfied: idna>=2.0 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from yarl<2.0,>=1.17.0->aiohttp>=3.7.4.post0->web3) (3.18)
Collecting parsimonious<0.11.0,>=0.10.0 (from eth-abi>=5.0.1->web3)
Using cached parsimonious-0.10.0-py3-none-any.whl (48 kB)
Collecting regex>=2022.3.15 (from parsimonious<0.11.0,>=0.10.0->eth-abi>=5.0.1->web3)
Downloading regex-2026.7.19.tar.gz (416 kB)
Installing build dependencies: started
Installing build dependencies: finished with status 'done'
Getting requirements to build wheel: started
Getting requirements to build wheel: finished with status 'done'
Preparing metadata (pyproject.toml): started
Preparing metadata (pyproject.toml): finished with status 'done'
Collecting bitarray>=2.4.0 (from eth-account>=0.13.6->web3)
Downloading bitarray-3.9.2.tar.gz (160 kB)
Installing build dependencies: started
Installing build dependencies: finished with status 'done'
Getting requirements to build wheel: started
Getting requirements to build wheel: finished with status 'done'
Preparing metadata (pyproject.toml): started
Preparing metadata (pyproject.toml): finished with status 'done'
Collecting eth-abi>=5.0.1 (from web3)
Downloading eth_abi-6.0.0b1-py3-none-any.whl (28 kB)
Collecting eth-keyfile<0.9.0,>=0.7.0 (from eth-account>=0.13.6->web3)
Using cached eth_keyfile-0.8.1-py3-none-any.whl (7.5 kB)
Collecting eth-keys>=0.4.0 (from eth-account>=0.13.6->web3)
Downloading eth_keys-0.7.0-py3-none-any.whl (20 kB)
Collecting eth-rlp>=2.1.0 (from eth-account>=0.13.6->web3)
Downloading eth_rlp-2.2.0-py3-none-any.whl (4.4 kB)
Collecting rlp>=1.0.0 (from eth-account>=0.13.6->web3)
Downloading rlp-4.1.0-py3-none-any.whl (19 kB)
Collecting ckzg>=2.0.0 (from eth-account>=0.13.6->web3)
Downloading ckzg-2.1.8.tar.gz (1.1 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.1/1.1 MB 1.1 MB/s 0:00:00
Installing build dependencies: started
Installing build dependencies: finished with status 'done'
Getting requirements to build wheel: started
Getting requirements to build wheel: finished with status 'done'
Preparing metadata (pyproject.toml): started
Preparing metadata (pyproject.toml): finished with status 'done'
Collecting pycryptodome<4,>=3.6.6 (from eth-keyfile<0.9.0,>=0.7.0->eth-account>=0.13.6->web3)
Downloading pycryptodome-3.23.0.tar.gz (4.9 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.9/4.9 MB 1.7 MB/s 0:00:02
Installing build dependencies: started
Installing build dependencies: finished with status 'done'
Getting requirements to build wheel: started
Getting requirements to build wheel: finished with status 'done'
Preparing metadata (pyproject.toml): started
Preparing metadata (pyproject.toml): finished with status 'done'
Collecting cytoolz>=0.10.1 (from eth-utils>=5.0.0->web3)
Downloading cytoolz-1.1.0.tar.gz (642 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 642.5/642.5 kB 1.5 MB/s 0:00:00
Installing build dependencies: started
Installing build dependencies: finished with status 'done'
Getting requirements to build wheel: started
Getting requirements to build wheel: finished with status 'done'
Preparing metadata (pyproject.toml): started
Preparing metadata (pyproject.toml): finished with status 'done'
Requirement already satisfied: annotated-types>=0.6.0 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from pydantic>=2.4.0->web3) (0.7.0)
Requirement already satisfied: pydantic-core==2.46.4 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from pydantic>=2.4.0->web3) (2.46.4)
Requirement already satisfied: typing-inspection>=0.4.2 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from pydantic>=2.4.0->web3) (0.4.2)
Collecting toolz>=0.8.0 (from cytoolz>=0.10.1->eth-utils>=5.0.0->web3)
Downloading toolz-1.1.0-py3-none-any.whl (58 kB)
Requirement already satisfied: charset_normalizer<4,>=2 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from requests>=2.23.0->web3) (3.4.9)
Requirement already satisfied: urllib3<3,>=1.26 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from requests>=2.23.0->web3) (2.7.0)
Requirement already satisfied: certifi>=2023.5.7 in /data/data/com.termux/files/home/.hermes/hermes-agent/venv/lib/python3.14/site-packages (from requests>=2.23.0->web3) (2026.5.20)
Building wheels for collected packages: pycryptodome, bitarray, ckzg, cytoolz, regex
Building wheel for pycryptodome (pyproject.toml): started
Building wheel for pycryptodome (pyproject.toml): finished with status 'done'
Created wheel for pycryptodome: filename=pycryptodome-3.23.0-cp37-abi3-android_24_arm64_v8a.whl size=1987435 sha256=1455f4764c3f8b2f7af703df3fafdca3c7bb9ede30a5d2fa49614660a97be4f9
Stored in directory: /data/data/com.termux/files/home/.cache/pip/wheels/3c/f9/be/e50ed8bfe5e8d0a6c994cf85138b1122021ffab04eeb7097f3
Building wheel for bitarray (pyproject.toml): started
Building wheel for bitarray (pyproject.toml): finished with status 'done'
Created wheel for bitarray: filename=bitarray-3.9.2-cp314-cp314-android_24_arm64_v8a.whl size=262292 sha256=e965d4d79b85aa20a227ef36285e03bc0bd3a16627888a36e385833576bfc30b
Stored in directory: /data/data/com.termux/files/home/.cache/pip/wheels/46/a7/de/cb4da8faba0eddb791924885c1c3504487965f35540c8b248c
Building wheel for ckzg (pyproject.toml): started
Building wheel for ckzg (pyproject.toml): finished with status 'done'
Created wheel for ckzg: filename=ckzg-2.1.8-cp314-cp314-android_24_arm64_v8a.whl size=162777 sha256=5397935f743343503b1dc9a8e9c7c852fd1aefe6e8920e9ee5d7592a0b9e744c
Stored in directory: /data/data/com.termux/files/home/.cache/pip/wheels/29/ff/76/a9fe38fd665e7bbe8b3818262ec61bff5e61eedd767118831b
Building wheel for cytoolz (pyproject.toml): started
Building wheel for cytoolz (pyproject.toml): finished with status 'done'
Created wheel for cytoolz: filename=cytoolz-1.1.0-cp314-cp314-android_24_arm64_v8a.whl size=2014357 sha256=ac4131f38af38ac5a55ff4b3153b2786b7783bf868347409f24403db56c220df
Stored in directory: /data/data/com.termux/files/home/.cache/pip/wheels/b0/f3/81/da0c46db35e802be926fe4888f7fb61d78bd7c713b88c8a0f4
Building wheel for regex (pyproject.toml): started
Building wheel for regex (pyproject.toml): finished with status 'done'
Created wheel for regex: filename=regex-2026.7.19-cp314-cp314-android_24_arm64_v8a.whl size=554942 sha256=8d88b88d4e6e6451f65494373b3541210fcb92b26ca00be999ffb716c66b9328
Stored in directory: /data/data/com.termux/files/home/.cache/pip/wheels/1b/7f/df/ddd8a2f642277e4547636b229cd3077ffe0d4c9a86c3c2b4fd
Successfully built pycryptodome bitarray ckzg cytoolz regex
Installing collected packages: ckzg, websockets, types-requests, toolz, regex, pyunormalize, pycryptodome, hexbytes, eth-typing, eth-hash, bitarray, parsimonious, cytoolz, eth-utils, rlp, eth-keys, eth-abi, eth-rlp, eth-keyfile, eth-account, web3

Successfully installed bitarray-3.9.2 ckzg-2.1.8 cytoolz-1.1.0 eth-abi-5.2.0 eth-account-0.13.7 eth-hash-0.8.0 eth-keyfile-0.8.1 eth-keys-0.7.0 eth-rlp-2.2.0 eth-typing-6.0.0 eth-utils-6.0.0 hexbytes-1.3.1 parsimonious-0.10.0 pycryptodome-3.23.0 pyunormalize-17.0.0 regex-2026.7.19 rlp-4.1.0 toolz-1.1.0 types-requests-2.33.0.20260712 web3-7.16.0 websockets-15.0.1

You'll also need a WebSocket endpoint. Services like Alchemy, Infura, or a self-hosted node work great.

Step 1: Connect to the Mempool

The mempool is the waiting room for unconfirmed transactions. We subscribe via WebSocket to see them as they arrive:

Step 2: Detect Sandwich Attacks

A sandwich attack has three legs: a front-run buy, the victim's trade, and a back-run sell. In the mempool we typically spot the front-run and victim close together:

Step 3: Track Arbitrage Patterns

Arbitrage transactions often call multiple DEXs in a single bundle. We detect them by looking for transactions that interact with multiple well-known router contracts in rapid succession:

Step 4: Structured Logging

Save findings to a JSONL file for later analysis or alerting:

Putting It All Together

The complete script continuously monitors the mempool and logs suspicious activity. Run it with and let it collect data over hours or days — you'll be surprised how much MEV activity you uncover.

Ethical Considerations

Monitoring MEV is a powerful educational tool. However, using this knowledge to front-run other users is unethical and in some jurisdictions illegal. Use this code responsibly — for research, security auditing, and building better DeFi protocols.

Resources

Full source code and more blockchain tools: github.com/Byaigo
Support my open-source work — ETH donations welcome:

Happy building, and stay curious! 🚀

Crafting a Custom Ethereum Transaction Decoder: From Raw Hex to Human-Readable Data with Python

Byaigo — Mon, 27 Jul 2026 16:22:41 +0000

Crafting a Custom Ethereum Transaction Decoder: From Raw Hex to Human-Readable Data with Python

Ever looked at a raw Ethereum transaction and wondered what all that hex gibberish actually means? Let's build a decoder that turns opaque calldata into something you can actually read.

Why Decode Transactions?

Every time someone interacts with a smart contract, they send calldata — hex-encoded function signatures and parameters. Understanding this data is crucial for:

Auditing contract interactions
Building block explorers
Monitoring whale wallets
Debugging failed transactions

The Building Blocks

We'll use just two Python libraries: web3.py for chain interaction and eth-abi for decoding. Here's the core approach:

from web3 import Web3
from eth_abi import decode
import requests

# Connect to Ethereum
w3 = Web3(Web3.HTTPProvider('https://eth.llamarpc.com'))

# Get a transaction
tx_hash = '0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060'
tx = w3.eth.get_transaction(tx_hash)

# Extract function selector (first 4 bytes of input)
input_data = tx['input']
function_selector = '0x' + input_data.hex()[:8]
print(f"Function Selector: {function_selector}")

The Magic: ABI-Based Decoding

Function selectors alone aren't enough — we need the contract's ABI. Here's a smart trick: query the Etherscan API for verified contract ABIs, cache them, then decode on the fly.

import json
from eth_abi import decode

def get_contract_abi(contract_address):
    """Fetch verified ABI from Etherscan with caching."""
    url = f"https://api.etherscan.io/api"
    params = {
        'module': 'contract',
        'action': 'getabi',
        'address': contract_address,
        'apikey': 'YOUR_API_KEY'
    }
    response = requests.get(url, params=params)
    if response.status_code == 200:
        data = response.json()
        if data['status'] == '1':
            return json.loads(data['result'])
    return None

def decode_transaction_input(tx_input, abi):
    """Decode calldata using contract ABI."""
    selector = tx_input[:4]

    for item in abi:
        if item.get('type') != 'function':
            continue

        # Compute function selector
        signature = f"{item['name']}({','.join(i['type'] for i in item['inputs'])})"
        computed_selector = w3.keccak(text=signature)[:4]

        if selector == computed_selector:
            # Decode parameters
            param_types = [i['type'] for i in item['inputs']]
            param_names = [i['name'] for i in item['inputs']]
            decoded = decode(param_types, tx_input[4:])

            return {
                'function': item['name'],
                'params': dict(zip(param_names, decoded))
            }

    return {'function': 'unknown', 'params': {}}

Putting It All Together

Here's a complete script that decodes any transaction to a verified contract:

def decode_any_transaction(tx_hash):
    tx = w3.eth.get_transaction(tx_hash)

    if tx['input'] == b'' or tx['input'] == '0x':
        return {
            'type': 'ETH transfer',
            'value': w3.from_wei(tx['value'], 'ether'),
            'to': tx['to']
        }

    abi = get_contract_abi(tx['to'])
    if not abi:
        return {'type': 'contract call (unverified)', 'raw_input': tx['input'].hex()}

    decoded = decode_transaction_input(tx['input'], abi)
    return {
        'type': 'contract interaction',
        'contract': tx['to'],
        **decoded
    }

# Example usage
result = decode_any_transaction('0x1234...')
print(json.dumps(result, indent=2, default=str))

Going Further

This approach scales well. You can extend it with:

Event log decoding — parse emitted events the same way
Proxy contract resolution — follow EIP-1967 to find implementation ABIs
Multi-chain support — works on any EVM chain with a compatible explorer API

The Code Is Open Source

All the code from this tutorial is available on GitHub: github.com/Byaigo

Support open-source development:

ETH: 0x18da907cb9d981bc798acb87ac27b03a2dc3cbb7

Happy decoding! 🚀

Building a Multi-Chain Crypto Portfolio Tracker with Python and Web3.py

Byaigo — Mon, 27 Jul 2026 14:20:55 +0000

Managing crypto across multiple chains is a hassle — different explorers, different UIs, scattered balances. In this tutorial, we will build a command-line multi-chain portfolio tracker that aggregates your ETH, ERC-20 token, and native coin balances across Ethereum, Polygon, and Arbitrum in one unified view.

🧰 What You Will Learn

Querying native balances and ERC-20 token balances with web3.py
Working with multiple RPC providers (Infura, Alchemy, public endpoints)
Aggregating data from multiple chains into a single CLI dashboard
Handling rate limits and fallback providers gracefully

📦 Prerequisites

pip install web3 rich tabulate python-dotenv

web3 — Ethereum interaction
rich — Beautiful CLI tables
python-dotenv — Manage RPC URLs securely

🔧 Step 1: Configure RPC Endpoints

Create a .env file:

ETH_RPC=https://mainnet.infura.io/v3/YOUR_KEY
POLYGON_RPC=https://polygon-rpc.com
ARBITRUM_RPC=https://arb1.arbitrum.io/rpc

🐍 Step 2: The Core Tracker Script

from web3 import Web3
from rich.console import Console
from rich.table import Table
import json, os
from dotenv import load_dotenv

load_dotenv()
console = Console()

CHAINS = {
    "Ethereum": Web3(Web3.HTTPProvider(os.getenv("ETH_RPC"))),
    "Polygon": Web3(Web3.HTTPProvider(os.getenv("POLYGON_RPC"))),
    "Arbitrum": Web3(Web3.HTTPProvider(os.getenv("ARBITRUM_RPC"))),
}

ERC20_ABI = json.loads('[{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"type":"function"}]')

TOKENS = {
    "USDC": {
        "ethereum": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "polygon": "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
        "arbitrum": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
    },
    "USDT": {
        "ethereum": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
        "polygon": "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
    }
}

def get_native_balance(w3, address):
    balance_wei = w3.eth.get_balance(address)
    return w3.from_wei(balance_wei, "ether")

def get_token_balance(w3, token_address, address):
    contract = w3.eth.contract(address=token_address, abi=ERC20_ABI)
    symbol = contract.functions.symbol().call()
    decimals = contract.functions.decimals().call()
    balance = contract.functions.balanceOf(address).call()
    return symbol, balance / (10 ** decimals)

def track_portfolio(addresses):
    table = Table(title="Multi-Chain Portfolio")
    table.add_column("Chain", style="cyan")
    table.add_column("Address", style="magenta")
    table.add_column("Asset", style="green")
    table.add_column("Balance", justify="right")

    for chain_name, w3 in CHAINS.items():
        for addr in addresses:
            try:
                native = get_native_balance(w3, addr)
                table.add_row(chain_name, addr[:10] + "...", "Native", f"{native:.4f}")

                for token_name, chain_tokens in TOKENS.items():
                    if chain_name.lower() in chain_tokens:
                        symbol, bal = get_token_balance(w3, chain_tokens[chain_name.lower()], addr)
                        table.add_row("", "", symbol, f"{bal:.2f}")
            except Exception as e:
                table.add_row(chain_name, addr[:10] + "...", "ERROR", str(e)[:30])

    console.print(table)

if __name__ == "__main__":
    WALLETS = [
        "0x18da907cb9d981bc798acb87ac27b03a2dc3cbb7",
    ]
    track_portfolio(WALLETS)

🚀 Step 3: Run It

python portfolio_tracker.py

You will see a formatted table showing native coin and token balances across all configured chains.

🔐 Security Notes

Never commit your .env file
Use read-only RPC keys
For production, consider using The Graph or Dune Analytics for heavy queries

🧩 Extending the Tracker

Add NFT detection using OpenSea API
Integrate price feeds from CoinGecko for USD values
Export to CSV for spreadsheet analysis
Add Telegram bot alerts for balance changes

📂 Source Code

Full project on GitHub: github.com/Byaigo

Like this article? Drop a ❤️ and follow for more Python + Web3 content!

ETH Tip Jar: 0x18da907cb9d981bc798acb87ac27b03a2dc3cbb7

How to Programmatically Verify Smart Contracts on Etherscan with Python

Byaigo — Mon, 27 Jul 2026 12:18:42 +0000

Why Verify Smart Contracts?

When you deploy a smart contract to Ethereum, the bytecode on-chain is opaque. Users and other developers can't easily audit what the contract does without the original source code. Verifying your contract on Etherscan bridges that gap — it links your human-readable Solidity (or Vyper) source to the bytecode on-chain, so anyone can read and trust the logic.

But doing this manually through Etherscan's web UI for every deployment is tedious. Let's automate it.

The Etherscan API

Etherscan provides a Contract Verification API endpoint. You POST the source code, compiler version, optimization settings, and constructor arguments, and Etherscan does the hard work of checking that the compiled bytecode matches what's on-chain.

Here's the endpoint:

POST https://api.etherscan.io/api
  ?module=contract
  &action=verifysourcecode
  &apikey=YOUR_API_KEY

Python Implementation

Let's build a reusable verify_contract() function using requests:

import requests

def verify_contract(
    api_key: str,
    contract_address: str,
    source_code: str,
    contract_name: str,
    compiler_version: str,
    optimization_used: int = 0,
    runs: int = 200,
    constructor_args: str = "",
    license_type: int = 3,  # MIT
) -> dict:
    """
    Submit a smart contract for verification on Etherscan.

    Args:
        api_key: Your Etherscan API key
        contract_address: Deployed contract address (0x...)
        source_code: Full Solidity source code as a string
        contract_name: Name of the main contract to verify
        compiler_version: Solidity compiler version, e.g. v0.8.24+commit.e11b9ed9
        optimization_used: 1 if optimizer was enabled, else 0
        runs: Number of optimizer runs (default 200)
        constructor_args: ABI-encoded constructor arguments (hex, without 0x)
        license_type: SPDX license type code (1=None, 2=Unlicense, 3=MIT, ...)

    Returns:
        API response as a dict with verification GUID
    """
    url = "https://api.etherscan.io/api"

    payload = {
        "apikey": api_key,
        "module": "contract",
        "action": "verifysourcecode",
        "contractaddress": contract_address,
        "sourceCode": source_code,
        "codeformat": "solidity-single-file",
        "contractname": contract_name,
        "compilerversion": compiler_version,
        "optimizationUsed": optimization_used,
        "runs": runs,
        "constructorArguements": constructor_args,
        "licenseType": license_type,
    }

    resp = requests.post(url, data=payload, timeout=30)
    resp.raise_for_status()
    return resp.json()

Checking Verification Status

Etherscan verification is asynchronous — you get a GUID back and need to poll for the result:

import time

def check_verification_status(api_key: str, guid: str) -> dict:
    """Poll until verification completes or fails."""
    url = "https://api.etherscan.io/api"
    params = {
        "apikey": api_key,
        "module": "contract",
        "action": "checkverifystatus",
        "guid": guid,
    }

    for attempt in range(20):
        resp = requests.get(url, params=params, timeout=10)
        data = resp.json()
        status = data.get("result", "")

        if status == "Pass - Verified":
            print(f"✅ Contract verified: {data}")
            return data
        elif status.startswith("Fail"):
            print(f"❌ Verification failed: {data}")
            return data

        print(f"⏳ Attempt {attempt+1}/20 — still pending...")
        time.sleep(5)

    return {"result": "Timeout — check manually"}

Usage Example

def main():
    API_KEY = "your-etherscan-api-key"
    contract_addr = "0xYourDeployedContractAddress"

    # Read your Solidity source
    with open("MyToken.sol", "r") as f:
        source = f.read()

    result = verify_contract(
        api_key=API_KEY,
        contract_address=contract_addr,
        source_code=source,
        contract_name="MyToken",
        compiler_version="v0.8.24+commit.e11b9ed9",
        optimization_used=1,
        runs=200,
    )

    guid = result.get("result")
    if guid and guid != "Max rate limit reached":
        check_verification_status(API_KEY, guid)
    else:
        print(f"Submission failed: {result}")

if __name__ == "__main__":
    main()

Multi-Chain Support

Etherscan's API also works across other EVM chains. Swap the base URL for:

Chain	API URL
Ethereum Mainnet	`api.etherscan.io`
Polygon	`api.polygonscan.com`
BSC	`api.bscscan.com`
Arbitrum	`api.arbiscan.io`
Optimism	`api-optimistic.etherscan.io`
Base	`api.basescan.org`

Why It Matters

Verified contracts build trust. Users can inspect the code before interacting. Tools like Dune Analytics and The Graph can index verified contracts more reliably. And it's a professional standard — serious projects don't skip verification.

Automation ensures every deployment — whether from CI, Hardhat, or Foundry — gets verified without manual steps. That's one less thing to forget after a late-night deploy.

Useful Resources:

🔗 GitHub: github.com/Byaigo
💰 Support: 0x18da907cb9d981bc798acb87ac27b03a2dc3cbb7

Happy building! 🚀

Best Free Blockchain Developer Tools - No API Keys Required

Byaigo — Mon, 27 Jul 2026 08:43:02 +0000

Free open source crypto tools. All available at https://byaigo.github.io — one command install: curl -sSL https://raw.githubusercontent.com/Byaigo/install/main/install.sh | bash. Includes portfolio tracker, gas monitor, wallet generator, token scanner. All free. Donate: 0x18da907cb9d981bc798acb87ac27b03a2dc3cbb7

Free Crypto Portfolio Tracker 2026 - Track BTC ETH BSC All Chains

Byaigo — Mon, 27 Jul 2026 08:42:59 +0000

Earn Crypto Passively: BSC Auto-Dividend Tokens Explained

Byaigo — Mon, 27 Jul 2026 08:35:30 +0000

Tokens that pay you just for holding

Some BSC tokens automatically distribute rewards to all holders. No staking, no claiming, no gas fees to receive.

How It Works

Every transaction charges a small tax (2-10%). That tax is redistributed to all holders automatically.

Real Example: TCF Token

Contract 0x0c8fE3269Dd812e5B38D6C3D65907c60c214d7b6 sends ~1000 tokens/day to holders via automatic transfers.

How to Find These Tokens

I wrote a scanner that checks BSC for auto-distribution patterns:

git clone https://github.com/Byaigo/dividend-token
python3 scan_wallet.py

The Catch

Most dividend tokens have low liquidity. The real opportunity: find new ones early.

Tools: github.com/Byaigo

Found this useful? 0x18da907cb9d981bc798acb87ac27b03a2dc3cbb7