Blockchains operate in isolation. Conversely applications span multiple networks, assets circulate across ecosystems, and governance decisions ripple across domains. To coordinate this activity, developers turn to General Message Passing protocols (GMPs) — frameworks for transmitting arbitrary data between chains.

GMPs go beyond token transfers. They can deliver structured instructions such as function calls, state updates, or other payloads defined by the application. In doing so, they provide a flexible mechanism for coordinating logic across networks.

Several patterns exist. The simplest are direct push models, where a contract emits a message for execution on another chain. Others add intermediate layers that verify, relay, and route messages. Hybrid designs mix both approaches. These technical choices vary in security assumptions, message formats, and delivery guarantees. Their goal, however, remains the same: enabling programmable interaction across blockchains.

Still, GMPs impose constraints. But what if those boundaries could be pushed further, extending their current reach?

GMPs & Reactive Smart Contracts

Reactive Smart Contracts (RSCs) may seem redundant when you already have General Message Passing protocols (GMPs). At first glance, both let you send cross-chain messages and call functions on smart contracts. Yet the resemblance ends there: RSCs monitor events on the origin contract, unlocking behaviors beyond the reach of GMPs.

With GMPs, messages have to be pushed out manually from the origin contract. This leads to several constraints:

1. The origin contract must be under your control — you can’t use a third-party contract.
2. Any cross-chain logic must be baked in during contract design — it’s not something you can bolt on after deployment.
3. While cross-chain messaging is supported, there is no built-in automation.

Reactive Smart Contracts work differently. Since they react to events:

1. The origin contract can belong to someone else, as in the case of our Stop Order use case (ReacDEFI dApp, Uniswap V2 Stop Order Demo).
2. You can attach new features to contracts that are already live; RSCs will simply react to the events those contracts emit.
3. Processes can be automated without redesigning the underlying system.

In short: GMPs provide cross-chain communication. RSCs bring not only cross-chain interaction but also automation and modular expansion.

Let’s explore the scenarios that become possible once RSCs enter the picture.

Stop Order

The Uniswap V2 Stop Order demo shows how a reactive contract can work in practice. Its primary purpose is to listen for `Sync` events in a Uniswap V2 liquidity pool. Once a predefined threshold is crossed, it triggers an automated asset sale. In trading terms, this is a stop order,  — a mechanism that helps users lock in profits or limit losses without constant monitoring.

The Stop Order Reactive contract subscribes to two event streams: Uniswap’s `Sync` updates and a custom stop order signal. On each `Sync`, it decodes the reserves, checks if the threshold condition is met, and, if so, sends a callback to the stop order contract to execute the trade. A confirmation event finalizes the process.

Approval Magic

The Approval Magic Demo explores two related scenarios: Magic Approval and Magic Swap. It also shows that subscriptions don’t have to be static and can be created and updated dynamically.

Magic Approval shows how approval events can drive token-for-ETH exchanges. Magic Swap takes it further: when a user grants a token approval, the reactive contract intercepts the event and automatically executes a Uniswap V2 swap, converting the approved tokens into another ERC-20. The entire process unfolds without the user needing to submit additional transactions.

Fee Collector

Fee Collector demonstrates how Reactive Smart Contracts can automate the collection, conversion, and distribution of fees across multiple blockchains. QuickSwap manages a variety of liquidity pools, each generating fees in different tokens. Traditionally, the team had to handle these manually — converting tokens, bridging assets, and allocating rewards — a process that was both labor-intensive and error-prone.

With Reactive Smart Contracts, the entire workflow becomes automatic. RSCs listen for on-chain events in real time, collecting fees from all pools, converting them into USDC, bridging assets across chains, and finally converting and distributing QUICK tokens for staking and incentives.

Liquidation Protection

Another area where Reactive Smart Contracts prove valuable is in lending and borrowing protocols. Most DeFi loans require over-collateralization, meaning users must lock more value than they borrow. The risk is that, during market volatility, collateral can suddenly lose value and trigger liquidations if the position isn’t topped up in time.

With Reactive Smart Contracts, this process can be automated. Contracts can monitor collateral ratios non-stop, provide emergency funding before liquidation thresholds are crossed, and even signal when a position is over-collateralized so excess assets can be withdrawn. These protections can operate across networks, ensuring round-the-clock defense against liquidation and making loan management safer and less dependent on constant manual intervention.

Hyperlane

An alternative to Reactive transport is Hyperlane Mailboxes — a modular interoperability protocol for cross-chain messaging. Each supported chain hosts a Mailbox contract, which serves as the entry and exit point for cross-chain traffic. Contracts can use it to send and receive arbitrary data across networks.

Hyperlane and Reactive are not competitors; they address different needs and complement each other.

More details on pros and cons of each transport → Reactive Docs

For Hyperlane mailbox addresses → Hyperlane Docs

Recap

Reactive smart contracts extend what GMPs started. While General Message Passing enables communication between chains, Reactive adds responsiveness — the ability for contracts to observe, interpret, and act on events without manual input.

Across examples like Stop Order, Approval Magic, Fee Collector, and Liquidation Protection, a clear pattern emerges: automation replaces intervention, and modularity replaces redesign. Developers can augment existing systems, not rebuild them, while ensuring cross-chain workflows run continuously and autonomously.

Rather than competing with existing interoperability layers such as Hyperlane, Reactive complements them — adding the missing layer of reactivity that turns cross-chain communication into cross-chain coordination.

About Reactive Network

Reactive is an EVM-compatible execution layer for dApps built with Reactive contracts. These contracts differ from traditional smart contracts by using inversion-of-control for the transaction lifecycle, triggered by data flows across blockchains rather than by direct user input.

Reactive contracts listen for event logs from multiple chains and execute Solidity logic in response. They can determine autonomously when to transmit data to destination chains, enabling conditional cross-chain state changes. The network delivers fast and cost-effective computation via a proprietary parallelized EVM implementation.

Website | Blog | Twitter | Telegram | Discord | Docs