You launch a bot for MEV or screening new tokens and face a problem: how to reliably detect contracts in real time? We solve this task through several parallel mechanisms — from monitoring factory contracts to analyzing deployment transactions. Our team has 5+ years of experience in blockchain development and has implemented scanners for 15+ projects in DeFi. We guarantee stable operation and low latency, even at peak loads: Ethereum generates up to 15 blocks per minute, each with hundreds of transactions.
One of our clients, a hedge fund, used the scanner for early token detection on Arbitrum and achieved a latency reduction from 15 seconds to 2. This allowed them to be first into liquidity pools, increasing ROI by 30% per quarter.
How We Parse New Token Data
How to Detect a New Token On-Chain?
Method 1: Monitoring Factory Contracts
Most tokens are deployed through factories: Uniswap V2/V3 factory when creating a pool, Token Factory contracts, or direct deployment with an event. Uniswap V2 factory emits PairCreated when a new pool is created — this is the most reliable signal of a new tradable token:
from web3 import Web3
import asyncio
UNISWAP_V2_FACTORY = "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f"
PAIR_CREATED_TOPIC = "0x0d3648bd0f6ba80134a33ba9275ac585d9d315f0ad8355cddefde31afa28d0e9"
FACTORY_ABI = [{
"name": "PairCreated",
"type": "event",
"inputs": [
{"name": "token0", "type": "address", "indexed": True},
{"name": "token1", "type": "address", "indexed": True},
{"name": "pair", "type": "address", "indexed": False},
{"name": "", "type": "uint256", "indexed": False}
]
}]
async def watch_new_pairs(w3: Web3, callback):
factory = w3.eth.contract(address=UNISWAP_V2_FACTORY, abi=FACTORY_ABI)
# Subscribe via WebSocket to new events
event_filter = await w3.eth.filter({
"address": UNISWAP_V2_FACTORY,
"topics": [PAIR_CREATED_TOPIC]
})
while True:
events = await event_filter.get_new_entries()
for event_log in events:
decoded = factory.events.PairCreated().process_log(event_log)
await callback({
"token0": decoded.args.token0,
"token1": decoded.args.token1,
"pair": decoded.args.pair,
"block": event_log.blockNumber,
"tx_hash": event_log.transactionHash.hex()
})
await asyncio.sleep(3)
For Uniswap V3 — similarly, listen for PoolCreated on 0x1F98431c8aD98523631AE4a59f267346ea31F984.
Method 2: Detecting ERC-20 Contract Deployment
Direct ERC-20 deployment does not emit standard events. We detect it by analyzing transaction receipts — if contractAddress is non-empty, it's a contract deployment:
async def scan_block_for_deployments(block_number: int, w3: Web3) -> list[dict]:
block = w3.eth.get_block(block_number, full_transactions=True)
deployments = []
for tx in block.transactions:
if tx.to is None: # tx without to = contract deployment
receipt = w3.eth.get_transaction_receipt(tx.hash)
if receipt.contractAddress:
# Check if it's ERC-20
token_info = await check_if_erc20(receipt.contractAddress, w3)
if token_info:
deployments.append({
"contract": receipt.contractAddress,
"deployer": tx["from"],
"block": block_number,
"tx_hash": tx.hash.hex(),
**token_info
})
return deployments
async def check_if_erc20(address: str, w3: Web3) -> dict | None:
"""Check for mandatory ERC-20 methods"""
minimal_abi = [
{"name": "totalSupply", "type": "function", "inputs": [], "outputs": [{"type": "uint256"}]},
{"name": "decimals", "type": "function", "inputs": [], "outputs": [{"type": "uint8"}]},
{"name": "symbol", "type": "function", "inputs": [], "outputs": [{"type": "string"}]},
{"name": "name", "type": "function", "inputs": [], "outputs": [{"type": "string"}]},
]
try:
contract = w3.eth.contract(address=address, abil=minimal_abi)
return {
"name": contract.functions.name().call(),
"symbol": contract.functions.symbol().call(),
"decimals": contract.functions.decimals().call(),
"total_supply": contract.functions.totalSupply().call()
}
except Exception:
return None # not ERC-20 or reverting contract
Scanning every block is high load on RPC. On Ethereum mainnet ~15 blocks/minute, each may have hundreds of transactions. You need a dedicated Alchemy/QuickNode plan or your own node. Factory monitoring works 10 times faster than full block scanning.
Data Enrichment After Detection
A bare contract address is not very informative. Immediately after detection, we enrich:
async def enrich_new_token(contract_address: str, w3: Web3) -> dict:
tasks = await asyncio.gather(
get_contract_source_code(contract_address), # Etherscan API
get_lp_info(contract_address), # existing pools
get_social_links(contract_address), # from contract or Etherscan
run_honeypot_check(contract_address), # sell tax, tradability
return_exceptions=True
)
source, lp_info, socials, honeypot = tasks
return {
"verified_source": bool(source and not isinstance(source, Exception)),
"has_liquidity": bool(lp_info and not isinstance(lp_info, Exception)),
"honeypot_risk": honeypot if not isinstance(honeypot, Exception) else "unknown",
**socials if not isinstance(socials, Exception) else {}
}
Automatic Token Risk Analysis
For a scanner with alerts — automatic bytecode and behavior analysis:
SCAM_PATTERNS = {
"mint_function": "0x40c10f19", # bytes4 selector for mint(address, uint256)
"ownership_transfer": "0xf2fde38b",
"blacklist_function": "0x44337ea1",
}
def check_bytecode_risks(bytecode: str) -> list[str]:
risks = []
if len(bytecode) < 100:
risks.append("minimal_bytecode") # proxy or placeholder
for name, selector in SCAM_PATTERNS.items():
if selector[2:] in bytecode: # remove 0x
risks.append(name)
return risks
A real honeypot check requires simulating buy and sell transactions via eth_call — this determines buy/sell tax and whether you can sell the token at all. Services: honeypot.is API, GoPlus Security API.
Storage and Indexing
CREATE TABLE new_tokens (
id BIGSERIAL PRIMARY KEY,
chain_id INTEGER NOT NULL,
contract TEXT NOT NULL,
name TEXT,
symbol TEXT,
decimals SMALLINT,
total_supply NUMERIC,
deployer TEXT NOT NULL,
deploy_block INTEGER NOT NULL,
deploy_tx TEXT NOT NULL,
deploy_time TIMESTAMPTZ NOT NULL,
verified BOOLEAN DEFAULT FALSE,
has_liquidity BOOLEAN DEFAULT FALSE,
risk_flags TEXT[] DEFAULT '{}',
enriched_at TIMESTAMPTZ,
UNIQUE(chain_id, contract)
);
CREATE INDEX ON new_tokens(deploy_time DESC);
CREATE INDEX ON new_tokens(chain_id, symbol);
CREATE INDEX ON new_tokens USING gin(risk_flags);
What Risks Does the Scanner Detect?
We categorize risks into three levels: critical (honeypot, reentrancy), high (mint, blacklist), and medium (high fee, low liquidity). For each token, a summary with flags and recommendations is generated. This allows immediate rejection of 90% of scam tokens at the detection stage.
Comparison of Detection Methods
| Method | Latency | Reliability | RPC Load |
|---|---|---|---|
| Factory (Uniswap/PancakeSwap) | 1-2 blocks | High (guaranteed event) | Low (topic filter) |
| Direct ERC-20 deployment | 1 block | Medium (not all contracts are ERC-20) | High (analyze every transaction) |
| Non-EVM (Solana) | ~1 slot | High (InitializeMint) | Medium |
Why Factory Monitoring Is Faster Than Block Scanning
Factory contracts emit an event when a pool is created — this is the only signal that needs to be tracked. Full block scanning requires processing every transaction, increasing RPC load by 10-15 times and slowing detection. Therefore, for production systems, we recommend combining both methods but prioritizing factory events.
Example of detailed bytecode analysis
When a `mint` function with sell restrictions is detected, the token is marked as high-risk. A check via `eth_call` with different amounts reveals hidden fees of up to 99%.What's Included in Scanner Development
| Component | Description |
|---|---|
| Solution architecture | Stack selection, load distribution, DB schema |
| Parsing code | Implementation of factory monitoring, direct deployments, enrichment |
| Risk analysis | Bytecode analysis, honeypot check, API integration |
| REST API | Endpoints for data retrieval, filtering, WebSocket |
| Documentation | README, endpoint descriptions, request examples |
| Support | 3 months post-deployment, bug fixes, consultations |
Our Process
- Analytics — we study your requirements, select networks and methods.
- Design — create architecture and data schema.
- Implementation — write parsing, enrichment, and API code.
- Testing — simulate load, verify on real data.
- Deployment — deploy on your infrastructure or ours.
- Support — train your team, hand over documentation.
Timeline and Cost
Development time for a basic scanner for 3-4 EVM networks: from 3 to 5 weeks. Cost is calculated individually based on complexity. Get a consultation — we will evaluate your project and offer an optimal solution. Order scanner development for early token detection and reduce monitoring costs.