ONE TRUSTLESS LAYER TO EVERY CHAIN
Connect your protocol to every other chain through one trustless layer. Your contracts, your chains, your features stay exactly as they are — we prove what happens cross-chain, you simply verify it. No bridge, no multisig, no new trust.
Three steps. We do the hard one.
Change nothing
Keep your contracts, your chains, and every feature exactly as they are. We already watch the chains you live on — nothing to migrate, no proofs for you to build.
We prove it, trustlessly
When something happens on one chain — a deposit, a fill, a settlement — we produce a small cryptographic receipt anyone can check. No relayer, no committee, no trusting us.
You verify it anywhere
Read that receipt in a single call — off-chain in your backend or on-chain in your contract — and safely act on another chain's events. Trustless, end to end.
One trustless way to read
any chain.
Every protocol eventually needs to know what happened on a chain it doesn't live on — a deposit, a price, a vote, a balance. Today that means trusting someone. Taifoon removes the someone. It commits the state of 41 chains — EVM, Solana, Bitcoin, Polkadot and more — into one cryptographic root every few seconds, so any fact on any of them becomes a small receipt you can check yourself, off-chain or on-chain. Chain-agnostic, VM-agnostic, trustless.
A bridge or messaging network signs that the event happened. You inherit the trust of its guardians, validators, or oracle set.
Maintain an on-chain light client per source chain. Correct, but heavy to build, costly to run, and impossible for non-EVM chains.
A coprocessor proves the data with zero-knowledge. Trustless — but usually one chain, query-by-query, with heavy proving cost and latency.
Taifoon is the fourth way: one always-on commitment over every covered chain, with proofs small and cheap enough to verify directly in your contract. No committee to trust, no per-chain light client to run, no proof to commission for each query.
Read any chain → build things that couldn't exist before.
Lend against a balance held on another chain — proven, not bridged.
Tally votes and execute decisions across chains from one verifiable record.
Prove holdings across every chain against one root — auditable by anyone.
Read a price, a rate, a supply directly from the source chain, trustlessly.
Release on the destination only when the source event is proven and final.
Trigger on real, final, proven state — never on a relayer’s word.
Where Taifoon fits — honestly.
Move messages between chains, secured by a verifier network, a 13-of-19 guardian set, a PoS validator committee, or a configurable security module. Fast and battle-tested — but you trust their set, not the source chain itself.
Prove historical data with zero-knowledge — genuinely trustless. But typically anchored to one chain (often Ethereum), answered query-by-query, with proving cost and latency that suit batch analytics more than live settlement.
One always-on commitment over 41 heterogeneous chains — any VM, including non-EVM. Proofs are compact keccak Merkle paths: cheap to verify on-chain, instant off-chain. Trustless like a coprocessor, broad like a messaging layer, live like an oracle.
These categories aren't enemies — many protocols will use a messaging layer to move and Taifoon to prove. We verify the fact; they carry the action.
One delivery cycle of safety.
Reading any chain trustlessly is the foundation. On top of it, the same proof primitive powers the rest:
The proof layer: any event on any of 41 chains, provable off-chain and on-chain.
Settle-on-proof: funds and actions release only when inclusion, finality, and anchor all pass.
Hosting: agents run in kernel-isolated machines, on-chain identity, every action a proof-anchored breadcrumb.
Together that's the autonomous blockchain OS: read, act, and run across every chain with one chain of proof from end to end. And if your case needs something bespoke — a custom verifier, a new chain, a tailored settlement flow — the team builds it with you.
Verify a cross-chain proof on-chain — live on selected partner network
1// SPDX-License-Identifier: MIT2pragma solidity ^0.8.20;34// TaifoonV5ProofVerifier — LIVE on Base Sepolia (84532):5// 0x8D4962d8bc69648F57D5cC4d68F073499b1f32936interface ITaifoonVerifier {7 // full 6-layer V5 proof (superroot, chain header, MMR paths,8 // event, finality) — verified entirely on-chain9 function verifyEncoded(bytes calldata blob) external returns (bool);10}1112contract CrossChainSettlement {13 ITaifoonVerifier constant VERIFIER =14 ITaifoonVerifier(0x8D4962d8bc69648F57D5cC4d68F073499b1f3293);1516 function settleFromProof(bytes calldata v5Proof) external {17 require(VERIFIER.verifyEncoded(v5Proof), "Invalid proof");18 // proof verified on-chain — release funds, never trust a relayer19 _processSettlement();20 }21}verifyEncoded(proof) . The verifier is also live on Base Sepolia — the chain you settle on.Subscribe to indexed events over SSE
Every event Taifoon indexes for a wired-in protocol is pushed to this stream the moment it happens. Subscribe once, filtered to the protocol you care about, instead of re-scanning eth_getLogs on a timer across every chain it touches.
1# All indexed protocol events2curl -N https://taifoon.io/api/intel/genomes/stream34# Filter to one protocol (protocol_slug)5curl -N "https://taifoon.io/api/intel/genomes/stream?protocol=<your-protocol-slug>"const es = new EventSource( "https://taifoon.io/api/intel/genomes/stream?protocol=<your-protocol-slug>");es.addEventListener("genome", (msg) => { const g = JSON.parse(msg.data); // g.event_kind: "deposit" (source lock) | "settle" (dest delivery) // g.src_chain_id / g.dst_chain_id, g.src_tx / g.dst_tx // g.amount_raw, g.token, g.route_hash console.log(`${g.event_kind}: ${g.amount_raw} ${g.token}`);});Say you wanted Wormhole on this stream — its Core Bridge already emits a well-known event across 20+ chains. Adding a protocol is exactly this shape: real contract addresses, real chain IDs, one source event and one settlement event.
// Wormhole Core Bridge — LogMessagePublished (source, all EVM chains,// same address): 0x98f3c9e6E3fAce36bAAd05FE09E1BbC5e8B1Ebf8// Ethereum (1), Arbitrum (42161), Base (8453), Polygon (137), ...//// Wormhole Token Bridge — TransferRedeemed (destination settlement):// 0x3ee18B2214AFF97000D974cf647E7C347E8fa585BridgeWatchConfig { protocol_slug: "wormhole".into(), source: BridgeLeg { chain_id: 1, // pick the source chain to watch bridge_address: "0x98f3c9e6E3fAce36bAAd05FE09E1BbC5e8B1Ebf8".into(), rpc_url: "https://rpc.ankr.com/eth".into(), }, dest: BridgeLeg { chain_id: 8453, // and the destination chain to watch bridge_address: "0x3ee18B2214AFF97000D974cf647E7C347E8fa585".into(), rpc_url: "https://mainnet.base.org".into(), },}Not live yet — this is the real config shape, not a claim that Wormhole is already on the stream. GLMR and MOVR (Moonbeam → Base) are the two protocols wired in today.
Run your own protocol and want the same treatment — pushed to subscribers instead of everyone re-scanning blocks? Send us the contract addresses, chain IDs, and event ABI for the source/settlement pair you want indexed, specifying which chain(s) via Telegram, or see the full bridge-operator integration guide.
Who it's for
Generate a proof right now
Pick any chain, pick any block, and watch a trustless proof appear in real time.