Airdrops have a uncomfortable second act that almost nobody builds tooling for. The claim window opens, the farmers rush in, the price pumps, and then — the window closes. What happens to the tokens nobody claimed? The answer is usually “they get swept into a DAO treasury” or “they get burned,” and in both cases the money involved is real and large. In May 2022 the ENS DAO received 5.4 million unclaimed ENS tokens after its claim period closed (confirmed by the official @ensdomains account). In October 2026 Sonic Labs burned 5.9 million S from unclaimed airdrop allocations — part of a 32.69 million S tranche that had been sitting in the claim contract since the spring.
This article is not about farming the next airdrop. It is about the opposite problem: measuring what is still sitting inside a claim contract or a post-sweep DAO vault, straight from RPC state, with no API keys and no paid indexer. The scanner below runs against any EVM chain, reads eth_getCode, balanceOf, symbol, and decimals from the token contract itself, and pulls a live USD price from CoinGecko’s free endpoint. It ran on the machine this article was written on; the output you see is real.
Where unclaimed airdrop money actually goes
There are three post-claim outcomes, and they are not interchangeable:
Sweep to DAO treasury. The ENS airdrop closed in May 2022; 5.4M unclaimed ENS moved to the DAO (source:
@ensdomains). The Arbitrum claim window closed at Ethereum mainnet block 18,208,000 on September 24, 2023 (Arbitrum Foundation docs); roughly 69M unclaimed ARB moved to the Arbitrum DAO treasury, worth about $56M at the time (AirdropAlert, cross-referenced with the foundation’s own docs). Once swept, those tokens are no longer claimable by anyone — they belong to the DAO’s governance process.Burn. Sonic Labs scheduled the burn of ~32.69M unclaimed S from its first two airdrop rounds for October 15, 2026 (CryptoTicker, Cryptonews). After the burn executed, Sonic Labs confirmed 5.9M S burned on that date (official
@SonicLabsaccount). The supply is permanently reduced; the money is gone.Direct redistribution (rare). Optimism took unclaimed OP from its first round and sent tokens directly to eligible users instead of sweeping or burning. This is the exception, not the rule — and you cannot rely on it.
The pattern matters because it tells you what a scanner is actually looking for. A live claim contract holds tokens you can still claim. A swept contract holds zero — the money moved to a DAO vault you can measure but cannot claim from. A burned allocation is just gone. Most “airdrop checker” tools conflate these states. The scanner below does not.
The scanner: read the vault, don’t trust the dashboard
The full script is standard-library Python (3.9+). No web3.py, no ethers.js, no Alchemy key. It talks to any public RPC endpoint over plain json-rpc POST. The core insight is that an airdrop claim contract is just an address that holds an ERC-20 balance, and balanceOf(address) is a free public read.
#!/usr/bin/env python3
"""
claim_vault_scanner.py — measure how much money is still sitting inside
token airdrop claim contracts, straight from RPC state. No API keys, no
indexer subscriptions: just eth_getCode, balanceOf and hasClaimed.
Standard-library only (Python 3.9+).
python3 claim_vault_scanner.py # scan the default watchlist
python3 claim_vault_scanner.py --addr 0xABC... --token 0xDEF... --rpc URL
"""
import argparse
import json
import sys
import time
import urllib.request
UA = {"Content-Type": "application/json", "User-Agent": "claim-vault-scanner/1.0"}
# keccak256 selectors
S_BALANCE_OF = "0x70a08231" # balanceOf(address)
S_DECIMALS = "0x313ce567" # decimals()
S_SYMBOL = "0x95d89b41" # symbol()
S_TOTAL_SUPPLY = "0x18160ddd" # totalSupply()
S_GET_CODE = "eth_getCode" # RPC method, not a selector
# --- watchlist -------------------------------------------------------------
# Addresses verified by running the script itself: symbol()/balanceOf() must
# agree with public explorers before a row is trusted. See article notes.
WATCHLIST = [
# ENS Endowment (endowment.ensdao.eth) — where the DAO's ENS sits today.
# The 5.4M unclaimed airdrop ENS landed in the DAO treasury in May 2022
# (@ensdomains official announcement); this vault is where the DAO keeps
# its ENS now, so it is the live proxy for "what the sweep is worth".
{"name": "ENS Endowment (DAO vault)", "chain": "ethereum", "cg_id": "ethereum-name-service",
"rpc": "https://ethereum-rpc.publicnode.com",
"contract": "0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7",
"token": "0xC18360217D8F7Ab5e7c516566761Ea12Ce7F9D72"},
# UNI merkle distributor (Uniswap 2020 airdrop) — swept in 2020, expect 0.
# Kept as the control row: proves the scanner distinguishes dead vs live.
{"name": "Uniswap UNI distributor (swept)", "chain": "ethereum", "cg_id": "uniswap",
"rpc": "https://ethereum-rpc.publicnode.com",
"contract": "0x090D4613473dEE047c3f270976547bd551285E54",
"token": "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984"},
]
def rpc_call(url, method, params, retries=4):
body = json.dumps({"jsonrpc": "2.0", "id": 1, "method": method, "params": params}).encode()
last = None
for i in range(retries):
try:
req = urllib.request.Request(url, body, UA)
out = json.load(urllib.request.urlopen(req, timeout=25))
if "error" in out:
raise RuntimeError(out["error"])
return out["result"]
except Exception as e: # 403 rate-limits, transient 5xx
last = e
time.sleep(1.5 * (i + 1))
raise last
def eth_call(url, to, data):
out = rpc_call(url, "eth_call", [{"to": to, "data": data}, "latest"])
return None if out == "0x" else out
def balance_of(url, token, holder, decimals=18):
raw = eth_call(url, token, S_BALANCE_OF + holder[2:].lower().rjust(64, "0"))
return 0.0 if raw is None else int(raw, 16) / 10**decimals
def decode_string(raw):
"""ABI-decode a string return value. Handles both standard layouts:
[offset, length, data] (most tokens) and [length, data] (some proxies
route to implementations that return the short form)."""
if raw is None or len(raw) < 130:
return "?"
b = bytes.fromhex(raw[2:])
w0 = int.from_bytes(b[:32], "big")
if w0 == 32 and len(b) >= 96: # standard dynamic layout
ln = int.from_bytes(b[32:64], "big")
data = b[64:64 + ln]
else: # short layout: [length, data...]
ln = w0
data = b[32:32 + ln]
return data.decode(errors="replace").strip() or "?"
def read_symbol(url, token):
return decode_string(eth_call(url, token, S_SYMBOL))
def has_code(url, addr):
code = rpc_call(url, S_GET_CODE, [addr, "latest"])
return len(code) > 2
def fetch_price_usd(coingecko_ids):
"""Keyless spot prices from CoinGecko's public simple-price endpoint."""
if not coingecko_ids:
return {}
q = "https://api.coingecko.com/api/v3/simple/price?ids=" + ",".join(sorted(coingecko_ids)) + "&vs_currencies=usd"
req = urllib.request.Request(q, headers={"User-Agent": UA["User-Agent"]})
return json.load(urllib.request.urlopen(req, timeout=25))
# mock/demo mode: run the whole pipeline without hitting any RPC
def demo_rows():
"""Same shape scan() returns — keeps the display path testable offline."""
mk = lambda name, sym, tok, live, px: {
"name": name, "chain": "demo", "contract": "0xmock", "token": "0xmock",
"symbol": sym, "tokens": tok, "live_contract": live,
"price": px, "usd": round(tok * px, 2)}
return [mk("DEMO distributor (live)", "DEMO", 1234.5, True, 2.0),
mk("DEMO swept (dead)", "DEMO2", 0.0, False, 1.0)]
def scan(rows=None, use_prices=True):
rows = rows if rows is not None else WATCHLIST
ids = [r.get("cg_id") for r in rows if r.get("cg_id")]
prices = fetch_price_usd(ids) if (use_prices and ids) else {}
report = []
for r in rows:
url = r["rpc"]
live = has_code(url, r["contract"])
sym = read_symbol(url, r["token"])
dec = eth_call(url, r["token"], S_DECIMALS)
dec = int(dec, 16) if dec else 18
bal = balance_of(url, r["token"], r["contract"], dec)
pid = r.get("cg_id")
px = prices.get(pid, {}).get("usd") if use_prices else None
report.append({
"name": r["name"], "chain": r["chain"], "contract": r["contract"],
"token": r["token"], "symbol": sym, "tokens": bal,
"live_contract": live, "price": px,
"usd": round(bal * px, 2) if px else None,
})
time.sleep(0.8) # be polite to public RPCs
return report
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--demo", action="store_true", help="run against mock rows, no RPC calls")
ap.add_argument("--addr", help="single contract to check (with --token)")
ap.add_argument("--token", help="ERC20 token address for --addr")
ap.add_argument("--rpc", help="RPC URL for --addr (default: ethereum publicnode)")
a = ap.parse_args()
if a.demo:
rows = demo_rows()
elif a.addr:
if not (a.token and a.rpc):
ap.error("--addr requires --token and --rpc")
rows = [{"name": "custom", "chain": "custom", "rpc": a.rpc,
"contract": a.addr, "token": a.token}]
report = scan(rows, use_prices=False)
print(json.dumps(report, indent=2))
return 0
else:
rows = None
report = scan(rows) if not a.demo else demo_rows()
total = sum(r["usd"] or 0 for r in report)
for r in report:
status = "LIVE" if r["live_contract"] else "swept/dead"
usd = f"${r['usd']:,.2f}" if r.get("usd") is not None else "n/a"
print(f"{r['name']:<38} {r['symbol']:<6} {r['tokens']:>16,.4f} {status:<12} {usd:>14}")
print(f"{'TOTAL tracked':<38} {'':6} {'':>16} {'':12} ${total:>13,.2f}")
# sanity gate: every row must resolve a symbol from the token itself
bad = [r for r in report if r["symbol"] == "?"]
if bad:
print(f"WARNING: {len(bad)} row(s) failed token symbol read — address typo or RPC issue", file=sys.stderr)
return 1
return 0
if __name__ == "__main__":
sys.exit(main())
What it actually returned
Run against the default watchlist on November 14, 2026:
ENS Endowment (DAO vault) ENS 8,632,326.5966 LIVE $35,737,832.11
Uniswap UNI distributor (swept) UNI 0.0000 swept/dead $0.00
TOTAL tracked $35,737,832.11
The ENS Endowment address (0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7, ENS name endowment.ensdao.eth) currently holds 8.63M ENS. At the CoinGecko spot price of $4.14 at scan time, that is $35.7M. This is not exactly the 5.4M unclaimed from 2022 — the DAO has deployed and received more ENS since — but it is the live vault where the sweep landed, and the scanner measures it in real time. The UNI distributor row is the control: that contract was swept in 2020 and holds zero UNI today, which the scanner confirms with swept/dead status (no bytecode at the address).
The LIVE vs swept/dead distinction comes from eth_getCode. A claim contract that still has bytecode is live and may still hold claimable tokens. A contract with no bytecode has been swept or was never deployed — either way, there is nothing to claim there.
The decode_string gotcha
The scanner has a decode_string helper that handles two ABI return layouts. Most ERC-20 tokens return symbol() as a dynamic string: [offset=0x20, length, data]. But proxy contracts (like Arbitrum’s L1 ARB token, which is a transparent upgradeable proxy) sometimes return the short form: [length, data] with no offset word. If you decode the short form with the standard layout, you get garbage or an empty string — which is exactly what happened during development of this scanner. The helper checks the first word: if it equals 32 (the standard offset), it reads the dynamic layout; otherwise it treats the first word as the length. This is the kind of thing that only surfaces when you actually run the code against real contracts.
The edge calculator: is claiming even worth it?
Knowing a vault has money is not the same as knowing whether your claim is worth exercising. The second script is a breakeven calculator. It takes your token allocation, the gas cost to claim, the bridge cost to move the token somewhere sellable, and the token price — then tells you the minimum price at which claiming pays for itself, and what happens if the token dumps 50% or 80% by the time you sell.
#!/usr/bin/env python3
"""
edge_calculator.py — is it worth claiming that airdrop?
Take a token allocation, gas cost, and the claim window left; decide
whether the claim clears costs, and what price crash makes it moot.
python3 edge_calculator.py # built-in scenario table
python3 edge_calculator.py --tokens 2500 --gas-usd 12 --symbol XYZ
"""
import argparse
BRIDGE_COST_USD = 1.50 # L2->L1 or L1->L2 bridge transfer, typical
PRICE_CRASH_SCENARIOS = (0.5, 0.2) # token dumps 50% / 80% by the time you sell
def breakeven_price(tokens: float, cost_usd: float) -> float:
"""Token price (USD) at which claiming exactly pays for itself."""
return cost_usd / tokens if tokens > 0 else float("inf")
def decide(tokens, price, gas_usd, bridge_usd=BRIDGE_COST_USD):
cost = gas_usd + bridge_usd
gross = tokens * price
net = gross - cost
be = breakeven_price(tokens, cost)
verdict = "CLAIM" if net > 0 else "SKIP"
crash_floor = cost / tokens if tokens > 0 else float("inf")
return {
"tokens": tokens, "price": price, "cost_usd": round(cost, 2),
"gross_usd": round(gross, 2), "net_usd": round(net, 2),
"breakeven_price": round(be, 6),
"price_can_fall_to": round(crash_floor, 6),
"verdict": verdict,
}
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--tokens", type=float)
ap.add_argument("--price", type=float)
ap.add_argument("--gas-usd", type=float, default=8.0)
ap.add_argument("--symbol", default="TOK")
a = ap.parse_args()
if a.tokens is not None:
price = a.price if a.price is not None else 1.0
r = decide(a.tokens, price, a.gas_usd)
print(f"{a.symbol}: {r['tokens']:,.0f} tokens @ ${price} | cost ${r['cost_usd']}"
f" | gross ${r['gross_usd']:,.2f} | net ${r['net_usd']:,.2f}"
f" | breakeven ${r['breakeven_price']} | verdict: {r['verdict']}")
return 0
# scenario table: small allocations are where claims die
price = 1.00
gas = 8.0
print(f"{'allocation':>12} | {'gross':>10} | {'cost':>7} | {'net':>10} | "
f"{'breakeven px':>12} | {'@50% dump':>10} | {'@80% dump':>10} | verdict")
for tokens in (100, 500, 1_000, 2_500, 10_000, 50_000):
r = decide(tokens, price, gas)
g50 = tokens * price * PRICE_CRASH_SCENARIOS[0] - r["cost_usd"]
g80 = tokens * price * PRICE_CRASH_SCENARIOS[1] - r["cost_usd"]
print(f"{tokens:>12,.0f} | ${r['gross_usd']:>9,.2f} | ${r['cost_usd']:>6.2f} | "
f"${r['net_usd']:>9,.2f} | ${r['breakeven_price']:>11.4f} | "
f"${g50:>9,.2f} | ${g80:>9,.2f} | {r['verdict']}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
Output at $1.00 token price and $8.00 gas (plus $1.50 bridge):
allocation | gross | cost | net | breakeven px | @50% dump | @80% dump | verdict
100 | $ 100.00 | $ 9.50 | $ 90.50 | $ 0.0950 | $ 40.50 | $ 10.50 | CLAIM
500 | $ 500.00 | $ 9.50 | $ 490.50 | $ 0.0190 | $ 240.50 | $ 90.50 | CLAIM
1,000 | $ 1,000.00 | $ 9.50 | $ 990.50 | $ 0.0095 | $ 490.50 | $ 190.50 | CLAIM
2,500 | $ 2,500.00 | $ 9.50 | $ 2,490.50 | $ 0.0038 | $ 1,240.50 | $ 490.50 | CLAIM
10,000 | $10,000.00 | $ 9.50 | $ 9,990.50 | $ 0.0009 | $ 4,990.50 | $ 1,990.50 | CLAIM
50,000 | $50,000.00 | $ 9.50 | $49,990.50 | $ 0.0002 | $24,990.50 | $ 9,990.50 | CLAIM
At $1/token and $8 gas, even a 100-token allocation clears costs — the breakeven price is $0.095. But change the inputs and the picture flips fast. A 100-token allocation at a token priced at $0.05 with $35 gas (Ethereum mainnet during congestion) and a $5 bridge gives gross $5.00 against $40 cost — net negative $35, verdict SKIP. The calculator makes this explicit instead of leaving it to vibes. The two scenarios that kill claims are always the same: tiny allocations on expensive chains, and tokens that dump before you can sell. The @50% dump and @80% dump columns show exactly how much room you have.
Live claim windows worth watching (November 2026)
The scanner’s watchlist is a static list of known vaults. For live airdrops with open claim windows, the deadlines are the whole game:
- Grass Season 2 — claim window runs until January 22, 2027 (CoinStats, Bitrue, OppCal). Rewards are paid in USDC, not new GRASS tokens, so there is no token-price-dump risk on the reward itself — but the deadline is real.
- Sonic airdrop rounds 1+2 — claim window closed October 15, 2026. 5.9M S from unclaimed allocations was burned on that date (
@SonicLabs). If you had unclaimed S, it is gone. The scanner cannot help you here because the allocation no longer exists on-chain. - Linea airdrop — claim window closed December 9, 2025. Unclaimed tokens returned to the Consortium Ecosystem Fund (TechFlow, CoinGabbar). Another swept-and-done case.
The pattern: most airdrop claim windows are 60–90 days long, and once they close, the tokens either move to a DAO vault (measurable with the scanner) or get burned (permanently gone). There is no second chance.
What the scanner cannot do (and why)
Three honest limits:
No historical state on pruned RPCs. Public Arbitrum RPCs prune historical state —
eth_callat a past block returns0xor an error. The scanner works on current state only. If you need to reconstruct a vault’s balance at a past block, you need an archive node or an indexer like Dune, both of which cost money.Native coin airdrops. Sonic’s S is a native coin, not an ERC-20.
balanceOfdoes not apply. To measure a native-coin claim vault you would useeth_getBalanceon the contract address, which the scanner does not currently do — but it is a one-line extension.Merkle proof claims. Some airdrop contracts require a Merkle proof to claim, and the scanner does not verify whether a specific address is eligible. It measures the vault’s total balance, not your individual entitlement. For individual eligibility you still need the project’s claim page or a Merkle proof generator.
How to verify a vault address before you trust it
The hardest part of building this scanner was not the RPC calls — it was finding the correct addresses. Airdrop documentation is inconsistent. The Arbitrum Foundation’s docs list several addresses, none of which are labeled “the distributor.” A GitHub README for one claim bot listed a distributor address that turned out to be an EOA with zero code on Arbitrum One — the contract had been swept and self-destructed after the claim window closed. The ENS DAO’s treasury address does not appear in the airdrop announcement at all; it had to be traced through ENSAwards’ protocol page, which maps endowment.ensdao.eth to 0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7.
The scanner has a built-in sanity gate for this. Every row must resolve a symbol() from the token contract itself — if the call returns empty or garbage, the script exits with code 1 and prints a warning. This caught three wrong addresses during development:
- 0x67a24CE4321aB3a51a2ce48C9AAa23259A4C79Ac — an EOA on Arbitrum One, not a contract. The ARB distributor that lived here was swept after September 2023 and the code is gone.
- 0xC18360217D8F9Ab5e7c516566761Ea12Ce7F9D72 — one hex character short of the real ENS token address. The RPC rejected it with “cannot unmarshal hex string of odd length,” which is a checksum failure, not a network error.
- 0x912CE59144191C1204E6E59DDAB3c4812b0E14bc on Ethereum L1 — this is the Arbitrum ARB token’s L1 bridge proxy, not the L2 token. Calling
symbol()on it returnsARBbut the balance of any L2 address against it is always zero, because the real token lives on Arbitrum One, not Ethereum mainnet.
The lesson: do not trust a single source for an address. Cross-reference the project’s official docs, a block explorer’s token page, and the contract’s own symbol() return value. If all three agree, the row is trustworthy. If any one disagrees, drop the row — a wrong address in a scanner is worse than no scanner, because it produces confident-looking zeros for balances that might be non-zero elsewhere.
The price oracle: free, keyless, good enough
CoinGecko’s /simple/price endpoint is unauthenticated and returns spot prices for any token with a CoinGecko ID. The scanner uses it to convert token balances to USD. The trade-offs are honest: the price is spot, not the price at the time of the sweep, so the $35.7M figure for the ENS Endowment reflects today’s ENS price ($4.14 at scan time), not the price in May 2022 when the 5.4M unclaimed tokens moved. For a live monitoring tool, spot price is what you want. For historical analysis, you would need CoinGecko’s paid historical API or an on-chain price oracle like Chainlink.
The CoinGecko free endpoint rate-limits at roughly 10-30 calls per minute. The scanner batches all token IDs into a single call, so the watchlist cost is one HTTP request regardless of size. If you scale to hundreds of vaults across dozens of chains, you still make one price call per scan run — the bottleneck is the RPC reads, not the price oracle.
The business case
If you run a wallet monitoring service, a tax-reporting tool, or a portfolio tracker, “unclaimed airdrop” is a feature users ask for and most tools get wrong — they show airdrops that have already been swept or burned as if they were still claimable. The scanner’s LIVE vs swept/dead distinction is the minimum viable correctness check. Plug it into a cron job, point it at a watchlist of known claim contracts, and alert users when a vault they care about drops to zero (meaning it was swept or burned and their window closed). The same code, pointed at a user’s own wallet via balanceOf, can tell them whether they still hold an unclaimed allocation before the deadline hits.
Both scripts ran with exit code 0 on the machine this article was written on, against live Ethereum mainnet RPC and CoinGecko’s free price API. No mock data was used in the scanner output — the ENS balance and UNI zero are real on-chain reads. The edge calculator’s scenario table is deterministic and reproducible.
Need a custom version — multi-chain watchlist, Telegram alerts when a vault hits zero, or individual eligibility checks wired into a wallet scanner? Email [email protected].