StableFlow

StableFlow is an intent-based, cross-chain liquidity coordination protocol designed to safely rebalance stablecoin liquidity across chains without executing complex logic inside AMM hooks.

At its core, StableFlow uses a custom Uniswap v4 hook on Ethereum to observe swap activity and pool balance changes in stablecoin pairs. When an imbalance exceeds a configurable threshold, the hook emits a RebalanceIntent event. Importantly, the hook never performs external calls or cross-chain actions, preserving Uniswap v4 hook safety, determinism, and composability.

These intents are processed off-chain by a permissionless executor that is governed entirely via ENS text records. ENS acts as the protocol’s control plane, defining whether execution is active or paused, the authorized executor address, execution mode, safety thresholds, and target contracts, all without redeployments.

To ensure correctness and prevent duplicate execution, StableFlow introduces an on-chain RebalanceExecutionRegistry on Ethereum. Each intent must be marked as executed before settlement, providing idempotency guarantees and a verifiable audit trail.

Final settlement occurs on Arc, which serves as a USDC-native liquidity hub. A dedicated Arc Vault contract receives settlement calls once execution is validated, demonstrating chain-abstracted liquidity where Ethereum generates intents and Arc finalizes capital movement.

A Next.js frontend provides full observability into the system, visualizing ENS-governed protocol state, Arc vault balances, and a step-by-step intent execution trace across chains.

StableFlow demonstrates a modular architecture for cross-chain DeFi where intent generation, execution safety, and settlement are cleanly separated, enabling safer and more transparent liquidity coordination across ecosystems.

StableFlow is built as an intent-driven, cross-chain liquidity coordination system with a clear separation between on-chain safety, off-chain execution, and cross-chain settlement.

1. UNISWAP V4 CUSTOM HOOK (Intent Emission Layer) At the core of StableFlow is a Uniswap v4 custom hook deployed on Ethereum Sepolia. The hook observes swap activity and pool balance changes and computes an imbalance metric in basis points. When the imbalance exceeds a configurable threshold, the hook emits a RebalanceIntent event. Crucially, the hook never performs external calls or cross-chain actions. It is strictly observational and deterministic, preserving Uniswap v4 hook safety, composability, and gas predictability. This design ensures that all execution logic is deferred off-chain.

2. ENS-GOVERNED CONTROL PLANE Protocol configuration is fully externalized into ENS text records (e.g. stableflow-sepolia.eth). Parameters such as protocol status (active/inactive), execution mode (demo/live), imbalance thresholds, authorized executor address, and target execution contracts are resolved dynamically at runtime. This makes StableFlow governance transparent, human-readable, and instantly upgradable without redeploying contracts or backend services.

3. EXECUTION REGISTRY (IDEMPOTENCY & SAFETY) To guarantee execution correctness, StableFlow introduces a RebalanceExecutionRegistry contract. Before any settlement occurs, the off-chain executor must mark an intent as executed on-chain. This enforces idempotency, prevents duplicate execution, and provides a verifiable audit trail on Ethereum. The registry acts as a coordination and safety layer between intent detection and cross-chain settlement.

4. ARC LIQUIDITY HUB (SETTLEMENT LAYER) Arc Testnet is used as the liquidity hub and settlement layer. A StableFlowArcVault contract holds USDC natively on Arc, taking advantage of Arc’s USDC-native execution environment. Once an intent is validated and marked executed on Ethereum, the executor finalizes settlement by calling the Arc vault. This cleanly demonstrates chain-abstracted liquidity, where Ethereum generates intents and Arc finalizes capital movement.

5. OFF-CHAIN EXECUTOR A Node.js-based executor listens for RebalanceIntent events, resolves protocol configuration via ENS, validates authorization, enforces thresholds, and coordinates execution across chains. The executor is intentionally permissionless, with authorization enforced via ENS rather than hardcoded keys.

6. FRONTEND (VERIFICATION & OBSERVABILITY) The frontend is built with Next.js and serves as a verification dashboard rather than a control surface. It visualizes:

• ENS-governed protocol configuration
• Arc vault USDC balance
• A step-by-step intent execution trace showing intent emission (Ethereum), execution registry confirmation, and settlement on Arc This allows judges and users to independently verify the full cross-chain lifecycle.

TECH STACK:

• Smart Contracts: Solidity (Foundry)
• Hooks: Uniswap v4 Hooks
• Backend: Node.js + ethers.js
• Frontend: Next.js (App Router)
• Naming & Governance: ENS
• Liquidity & Settlement: Arc Testnet (USDC-native)

NOTABLE DESIGN DECISION: The most important design choice was enforcing a strict separation between intent emission and execution. By emitting intents instead of executing logic inside hooks, StableFlow avoids reentrancy risks, cross-chain complexity, and hook constraints. Execution becomes verifiable, pausable via ENS, and independently auditable on-chain.

PARTNER TECHNOLOGIES: ✅ Uniswap v4 Hooks — Intent emission & safe observability
✅ ENS — Protocol governance & control plane
✅ Arc — Chain-abstracted USDC liquidity hub