Composing execution
over multiple blockchains.

Smart contracts are immutable within their chain. When you need a contract on Ethereum to coordinate with one on Arbitrum, you hit a wall — there's no shared state, no rollback if one side fails, no standard for what "success" even means across two independent ledgers.

Every bridge built before t3rn solved asset transfers and stopped there. Tokens move; logic doesn't. The result: fragmented liquidity, duplicated contracts per chain, and cross-chain failures that leave funds stranded with no recourse.

t3rn was built to solve this at the protocol level — not at the application layer.

The core insight: separate the execution logic from the chains it runs on. t3rn's Circuit acts as a decentralised coordination layer. It doesn't replace any chain — it orchestrates execution across them.

Gateways are adapters deployed on each connected chain. They escrow funds and execution state locally. The Circuit validates that each step completed correctly before releasing any escrow — making the entire cross-chain sequence atomic.

Every interoperable transaction moves through three phases: Execute (run the steps), Revert (rollback if anything fails), Commit (release escrow once everything is proven). Until Commit fires, nothing is final. This is how t3rn makes cross-chain execution truly fail-safe.

In 2020 we called them Execution Agents. In 2026 they're solvers — same role, sharper tooling. Solvers watch the intent stream, race to fill orders, and post cryptographic proofs back to the Circuit. They bond 2× the value of any transaction they volunteer to fill.

Relayers observe foreign chains and deliver inclusion proofs. Fishermen monitor for misbehaviour and collect 10% of any slashed bond they report. Together these actors form a self-policing economy: solvers compete on price and speed; cheating is economically irrational.

The Genome stream — live at taifoon.io/genomes — is the real-time intent feed. Every intent that hits t3rn lands in the stream within ~120ms. Solvers subscribed to the stream are the heartbeat of the network.

The original whitepaper described Polkadot Parachains and Substrate gateways. The 2026 network runs across 56 EVM-compatible chains — Ethereum, Arbitrum, Base, Optimism, Polygon, Linea, Scroll, Mantle, Monad, HyperEVM, and growing.

The execution model is the same. The substrate changed. EVM gateways replaced Substrate pallets. RainbowKit replaced Polkadot.js. The three-phase execution model — Execute, Revert, Commit — ships verbatim from the whitepaper into every LiquidityWellCompact contract deployed today.

The Composable Execution Schedule from §III of the original paper is now an on-chain intent. The Circuit is now the solver network. The escrow accounts are now the LiquidityWell contracts. The names changed; the guarantees didn't.

The fee model from the original paper held: solvers collect execution fees from requesters, protocol takes a small ecosystem cut, liquidity providers earn yield from the pools they fund. No block rewards — the economy runs on throughput.

The 2026 addition: protocol buybacks. A portion of ecosystem fees is used to buy $TRN on the open market via the Kelly Buyback executor, visible in real time on the DAO page. Staking TRN earns yield proportional to bridge volume — the protocol's success and the token's utility are directly coupled.

Governance is on-chain. TRN holders vote on fee parameters, gateway whitelisting, solver bond requirements, and treasury allocation. The DAO is the mechanism through which the solver community sets the rules they operate under.

2026 roadmap: remove every centralised operational dependency. Solvers discover tasks on-chain without relying on centralised coordinators. Cryptographic proofs replace trusted attestations. The Trail of Bits audit (round 2, this quarter) covers the new LiquidityWellCompact and the intent verification path.

Monad and HyperEVM integrations land this month — both high-throughput EVM chains where intent latency matters most. The solver leaderboard goes live with the explorer, making solver performance fully transparent.

The full protocol specification — the formal successor to this whitepaper — lives at docs.t3rn.io. The original 2020 paper is preserved below for reference.

The 2020 paper assumed Circuit would be the trust anchor — a decentralised coordinator that validators run and agree on. The direction we're heading: the coordination layer becomes a cryptographic root. Every event on every chain, anchored under a single on-chain proof that any contract on any chain can verify — no committee, no bridge, just math. That's the cornerstone taifoon.io is building toward, and where t3rn's execution layer is heading.