Ship trustless airdrops with zero-knowledge proofs
No Merkle trees. No backend. Publish your allocation list as a SQL table, deploy a claim contract, and let Proof of SQL verify every payout onchain. Claimants get cryptographic proof that their reward was read from your data. Not spoofable, fully auditable.
How It Works
Traditional airdrops rely on Merkle trees or centralized APIs to validate claims. This approach replaces both with a verifiable SQL query. Your allocation data is the source of truth, and Proof of SQL is the verification layer.
- 1. Publish your allocation table
Upload your allocation CSV and write it to an onchain SXT Chain table. This becomes the canonical, publicly auditable source of who gets what.
- 2. Deploy a claim contract
We generate an airdrop claim contract for you. It works on any chain supported by the SXT Network, with any ERC-20 reward token you configure.
- 3. Users claim with ZK verification
A claimant calls claim() on your contract. It sends the query to SXT, which executes the SQL and returns a zero-knowledge proof.
- 4. Verified payout settles onchain
The callback delivers the proven allocation amount. If valid and funded, the reward token is transferred to the claimant.
Why Proof of SQL?
Most airdrops use Merkle trees: generate a tree off-chain, publish the root, and let users submit proofs. It works, but it has real limitations. Here's how a Proof of SQL airdrop compares.
| Merkle Tree | Proof of SQL | |
|---|---|---|
| Allocation data | Off-chain JSON/CSV, root published onchain | Full table stored on SXT Chain, queryable by anyone |
| Auditability | Requires trusting the tree generator | Fully transparent. SQL table is public |
| Updatable | New root = new contract or migration | Insert rows to the same table, same contract |
| Claim UX | User must obtain proof from an API | User just calls claim(). No proof needed |
| Backend | API server required to serve proofs | No backend. Contract + SXT handle everything |
| Verification | Merkle inclusion proof (hash chain) | Zero-knowledge proof of correct SQL execution |
Connect your wallet to complete this tutorial
Step 1: Publish Your Allocation Table
Paste or upload a CSV with address,amount columns. Data is written to AIRDROP_YOUR_ADDRESS.AIRDROP_LIST on SXT Chain.
| Address | Amount |
|---|---|
| 0x1111111111111111111111111111111111111111 | 250 |
| 0x2222222222222222222222222222222222222222 | 1200.5 |
Step 2: Choose Your Reward Token
Pick the ERC-20 token claimants will receive. Use an existing token for production, or deploy a demo token to test the full flow.
Step 3: Deploy the Claim Contract
Deploy a self-contained claim contract. The proof plan for your SQL query is compiled automatically and embedded in the contract.
Ethereum uses a higher upfront deposit than Base because Ethereum mainnet callback costs are higher and more variable. The deposit is not a flat fee: the Query Router pays the actual query and callback cost, then refunds the remainder to the refund address.
Step 4: Fund and Share
Transfer reward tokens into the contract and share the claim URL. The suggested amount covers your full allocation.
Important Notes
- Each claim uses a 1000 SXT query deposit. The Query Router pays the actual Proof of SQL and callback cost, then refunds the remainder.
- If the shared SXT payment router is deployed on this chain, claimants can swap ETH for that deposit directly on the claim page.
- Permit flow: available on this chain. Claimants sign once instead of approving + claiming.
- The deployed contract is immutable. Double-check your allocation table, reward token, and query plan before deploying.