Over the last few weeks, we have rebuilt large parts of the t3rn bridge and execution stack.
Not as a cosmetic upgrade or a single feature release, but as a structural rethink of how cross-chain execution should work once systems start to operate at real scale.

These changes together form t3rn 2.0.

Before diving into individual components, it helps to frame the underlying shift. Historically, most cross-chain systems depend on some form of trusted coordination — whether multisigs, committees, or privileged relayers — to assert that execution happened correctly. t3rn is moving away from that model.

Instead, execution itself becomes verifiable. A trustless proof engine underpins the stack, making every cross-chain action something that can be independently validated and deterministically proven correct. Correctness is enforced by cryptography and protocol logic, not by reputation or assumptions.

At the center of this upgrade is a new bridge architecture called LiquidityWellCompact. It introduces native staking and liquidity provision as first class primitives of cross-chain execution, rather than optional add-ons. Staked liquidity is now directly responsible for filling transactions, earning fees, and securing execution, while the architecture itself improves cost and performance at a fundamental level.

Most of the complexity stays inside the protocol. What users notice is simple: transactions cost less, start faster, and fail less often. Builders get a system that is easier to integrate, easier to reason about, and easier to extend.

Below are the concrete reasons why.

Why t3rn 2.0 Is Cheaper

t3rn 2.0 collapses three-layer bridge architectures into a single, cryptographically verifiable execution primitive. The result: cross-chain transactions that cost less, execute faster, and fail less often.

Not incremental improvements. Fundamental protocol redesigns.

A large portion of bridge gas cost comes from security checks, especially preventing the same transaction from being executed twice. 

LiquidityWellCompact replaces heavy storage based checks with a compact bitmap flagging system that packs many execution states into minimal storage while preserving the same security guarantees. 

Bitmap compression replaces hash-based order tracking, packing 256 execution states into a single storage slot. Security checks drop from 1400 gas to 200 gas—a **86% reduction**—while maintaining the same cryptographic guarantees.

Core security reads are now roughly eighty six percent cheaper. Failed replay attempts cost about ninety five percent less gas. Even successful executions see a reduction.

We also reduced overhead in fee estimation by collapsing multiple network calls into a single operation. Less back and forth with RPC providers means fewer wasted cycles and lower overall cost.

On top of that, fees are now calculated using live network conditions and split into clear components. Gas paid to executors. Rewards paid to liquidity providers. A small buffer to protect against volatility.

Together, these changes directly lower what users pay per cross-chain transaction.

Why t3rn 2.0 Is Faster

Speed is not just about block times. It is about how quickly a transaction can be prepared, validated, and sent for execution.

LiquidityWellCompact unifies order management, escrow logic, and liquidity provision into one gas-optimized contract:

RemoteOrder + EscrowGMP + LiquidityWell → LiquidityWellCompact

3 contracts, ~450k gas               1 contract, ~135k gas

LiquidityWellCompact introduces a leaner execution path that minimizes storage reads and writes, which are among the slowest operations onchain.

Fee estimation and execution now happen in a single step, removing unnecessary reverse Dutch auction bidding by executors. The result is that transactions enter execution sooner and encounter fewer bottlenecks along the way.

For users, this simply feels like a faster bridge.

Why t3rn 2.0 Is More Reliable

Bridges fail in two common ways. Transactions get stuck due to temporary liquidity shortages, or infrastructure components fall out of sync.

Both are now handled automatically.

If an order cannot be executed instantly because liquidity is insufficient, it is placed into a queue and retried every few minutes. As soon as liquidity becomes available, execution happens without the user needing to do anything.

On the infrastructure side, indexers monitor their own progress. If they stop advancing, the system automatically resets itself to a healthy block position.

Reliability also improves when liquidity is deep.

LiquidityWellCompact integrates directly with the protocol’s fee distribution system, which correctly tracks and pays rewards to liquidity providers across networks. Live APY tracking shows providers exactly what they are earning.

Staking is no longer just a yield mechanism. It is a core part of how execution is secured and scaled.

Clear incentives attract more staked liquidity. More liquidity means higher instant execution success rates.

Why t3rn 2.0 Is More Composable

Composable systems are easy to integrate, easy to upgrade, and hard to break.

APIs remain backward compatible while exposing richer data for applications that want deeper control over fees and routing.

Old and new contract versions, including LiquidityWellCompact, can coexist on the same network. Services detect which features are available and adapt automatically instead of failing.

For builders, this means fewer breaking changes, simpler integrations, and more freedom to experiment.

What All of This Means

t3rn 2.0 is not one big feature, but the accumulation of many structural improvements that compound.

Lower costs come from cheaper security checks and leaner execution paths.
Faster execution comes from fewer network round trips and simplified onchain logic.
Reliability comes from automation and stronger liquidity incentives.
Composability comes from backward compatible APIs and modular architecture.

The end result is a cross-chain execution layer that behaves more like infrastructure and less like an experiment.

Fast. Cheap. Predictable. Good place to be in.

t3rn 2.0 moves us closer to the long-term goal: making cross-chain execution a primitive, not a special case.