Prove anything

What this is

The layer folds every chain it includes into one superroot about every 10 seconds. Each protocol set it decodes (its contracts, events and order machine) adds a history root and a state root, and those are committed under the same superroot. One API answers five kinds of proof:

GET /v1/protocols/proven lists every protocol set inside the root: its transitions, orders and roots, and how current each source is.

Before you start

• No key is needed inside the free rate. With a key, proofs run at 90 a minute (900 with a balance). A key limited by scopes needs proofs.
• Past the free rate a proof costs 0.2 GRID (0.002 USDC). GET /v1/access has the price list.

export TAIFOON=https://coord.taifoon.dev/v1
tf() { curl -sS -m 90 -H "X-Taifoon-Client: taifoon-skill-prove-anything" -H "content-type: application/json" ${TAIFOON_API_KEY:+-H "X-API-Key: $TAIFOON_API_KEY"} "$@"; }

Pitfalls

1. Reading ok: true as proven. On a transaction proof read proof_state and every entry of checks. not_final means the block is not final yet: ask again.
2. Guessing a log index. log_index is the log's index in its block, as eth_getLogs reports it (logIndex), not its position in the transaction.
3. Guessing an order key. It is <protocol>:<chain>:<id> as the protocol set names it (for example erc8183:8453:81401). An order that is not there proves absent (state.present: false), which is an answer, not an error.
4. Asking for more than 256 sequence numbers or blocks in one call. Page it.
5. Comparing a proof's root with a later root. The root changes about every 10 seconds, and a proof is under its own batchId. Keep the blob.
6. Expecting a transaction proof on every committed chain. GET /v1/protocols/decoders (chains) says which chains are read per transaction.

Steps

1. The protocol sets inside the root

SETS=$(tf "$TAIFOON/protocols/proven")
echo "$SETS" | jq -e '(.protocols | length) > 0 and (.protocols[0].historyRoot | test("^0x[0-9a-f]{64}$"))' >/dev/null
P=$(echo "$SETS" | jq -r '[.protocols[] | select(.transitions > 2)][0].protocol')

2. Transitions of a protocol set, in order

tf "$TAIFOON/proof/transition/$P?seqs=0,1,2" | jq -e '(.anchor.historyRoot | test("^0x[0-9a-f]{64}$")) and (.anchor.batchId > 0)' >/dev/null

3. An order's lifecycle (or its absence)

tf "$TAIFOON/proof/order/erc8183/erc8183:8453:81401" | jq -e 'has("anchor") and has("state")' >/dev/null

4. A transaction, and one of its logs

A USDC burn on Base. Its logs are read from the gateway, so the index is the block's own.

TX=0x81464f5e6a8b6322e4bec8f609a08e8ec1f1ef11d39e5f5d51e3fa676c5f042a
tf "$TAIFOON/proof/tx/8453/$TX" | jq -e '.ok and .checks.receipt_found and .checks.tx_succeeded and .checks.block_hash_matches' >/dev/null
BN=$(tf "$TAIFOON/proof/tx/8453/$TX" | jq -r '.block_number')
LI=$(curl -sS -m 60 -X POST https://coord.taifoon.dev/gw/rpc/8453 -H 'content-type: application/json' -H "X-Taifoon-Client: taifoon-skill-prove-anything" ${TAIFOON_API_KEY:+-H "X-API-Key: $TAIFOON_API_KEY"} \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$(printf '0x%x' $BN)\",\"toBlock\":\"$(printf '0x%x' $BN)\",\"address\":\"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913\"}]}" \
  | jq -r --arg tx "$TX" '[.result[] | select(.transactionHash == $tx)][0].logIndex')
tf "$TAIFOON/proof/log/8453/$TX?log_index=$(( LI ))" | jq -e '(.calldata | test("^0x[0-9a-f]+$")) and has("anchor") and has("receipt")' >/dev/null

5. Blocks of a chain

V=$(tf "$TAIFOON/proof/verifiable/8453" | jq -r '.chainHeaders[0].blockNumber')
tf "$TAIFOON/proof/blocks/8453?blocks=$(( V - 10 )),$(( V - 11 ))" | jq -e 'type == "object"' >/dev/null

Verify it works

tf "$TAIFOON/root" | jq -e '(.chains_included | index(8453) != null) and .leaf_count > 0' >/dev/null
echo "prove-anything: transitions of $P, an order, a transaction, its log and two blocks, all under the root"

What it costs

Inside the free rate, nothing. Past it, 0.2 GRID (0.002 USDC) a proof from the key's balance. The root, its chains and the list of proven protocols are never charged.

Next

• The log proof's calldata goes to verifyLogAt on the V5 verifier on Base, 0x2D475a53eAA8F9AC78B69bD2429275a622C644f8.
• The independent check of one transaction against your own RPC: prove-a-transaction.
• Add your own protocol set: onboard-a-protocol.
• The same as one MCP tool: taifoon_prove (wrap-in-an-agent).