zadao.aiTransaction Simulation (Pre-flight / Dry-run)
Transaction Simulation lets you dry-run a proposed transaction before you ever sign it.
In short
Dry-run a transfer, swap or contract call on Stacks, EVM or Solana against live state without signing or broadcasting, to see if it would succeed, what moves, the fee, and whether a token can be sold.
Transaction Simulation lets you dry-run a proposed transaction before you ever sign it. You describe an action — a transfer, a swap, a contract or program call — and Nova runs it against live on-chain state and tells you what would happen, without broadcasting anything and without moving any funds.
You get back: whether the transaction would succeed or revert (and the reason), the asset changes (who gains or loses what), the real fee / gas / compute cost, and — for tokens — a honeypot / sellability verdict.
Supported Chains
| Chain | What it covers |
|---|---|
| Stacks | STX transfers (fee + balance check), Clarity contract calls (real evaluation of read-only functions; ABI validation + fee + static asset-movement scan for state-changing functions), SIP-010 sellability scan |
| EVM (Ethereum, Base, Arbitrum, Optimism, Polygon, BSC, Avalanche) | Native + ERC-20 transfers, arbitrary contract calls (success/revert + gas), ERC-20 honeypot/sellability |
| Solana | Native SOL + SPL transfers, arbitrary program instructions, fully-serialized transactions (e.g. a Jupiter swap), SPL sellability |
What You Can Simulate
| Action | What you provide | What you get |
|---|---|---|
| Transfer | from, to, amount (+ token/mint for a token transfer) | success/revert, asset changes, fee/gas/compute |
| Contract / program call | the contract (or program) + function/calldata + args | success or revert (+ reason), cost, asset movements where derivable |
| Sellability / honeypot | token (+ a holder that owns it) | a verdict: sellable, likely honeypot, or inconclusive |
Honeypot / Sellability Check
The headline check. A honeypot token lets you buy but blocks you from selling. Transaction Simulation tests the sell side directly:
- EVM —
eth_call-executes a transfer of the holder's full balance against live state. If the transfer reverts or returns false (blacklist, pause, trading-disabled), the token is flagged as a likely honeypot. - Solana — simulates moving the SPL token out of the holder. A frozen / non-transferable token fails here.
- Stacks — statically scans the SIP-010
transfersource for pause flags, blacklist maps, and owner-only guards that could block sells. For a full Clarity audit, pair it with the Token Risk Check.
The sell test needs a holder that actually owns the token (for example, an address that just bought it). If the holder's balance is 0, the result is inconclusive rather than a false "honeypot." On the current RPC tier, fee-on-transfer tax % is not measured on EVM.
Example Prompts
"Simulate sending 0.5 ETH from 0xabc… to 0xdef… on Base — will it go through and what's the gas?"
"Dry-run calling
claimon SP….my-contract — would it revert?"
"Is 0x… on Ethereum a honeypot? Can this wallet actually sell it?"
"Preview swapping this Jupiter transaction before I sign it." (pass the serialized transaction)
"What would this STX transfer cost and does my wallet cover it?"
Using It From an Agent (x402 / MCP)
The per-chain tools are exposed on the public Tools Platform as stacks-tx-simulate, evm-tx-simulate, and solana-tx-simulate (REST + MCP). Agents can call them to verify sellability before relying on a token or to pre-flight a transaction before broadcasting it themselves.