StableRoute is a stablecoin liquidity routing protocol built on the Stellar network that automatically finds the most efficient path for cross-currency payments.

It acts as a payment routing layer for Stellar assets, optimizing how stablecoins and fiat tokens move across the network.

StableRoute enables applications, wallets, and payment providers to perform cheapest-path asset swaps and cross-border payments with minimal slippage and optimal liquidity.

The protocol functions similarly to DEX aggregators like 1inch or Jupiter, but specialized for Stellar payments and stablecoin routing.

The Stellar ecosystem contains a growing number of stablecoins and fiat-backed tokens:

• USDC
• EURC
• regional fiat tokens
• anchor-issued tokens
• tokenized banking assets

However, liquidity is fragmented across multiple markets.

A user wants to send money from India to Europe. INR Token → USDC → EURC → EUR Anchor

Without routing optimization:

• users receive poor exchange rates
• liquidity pools may be insufficient
• routes are inefficient
• transactions experience higher slippage

This limits the scalability of Stellar as a global settlement network.

StableRoute provides a routing engine for Stellar assets that automatically determines the optimal path for asset conversion.

The router analyzes:

• liquidity across anchors
• orderbooks
• exchange rates
• available multi-hop paths

It then executes the lowest-cost route automatically.

User sends: ₹50,000

StableRoute computes the optimal path:

INR Token → USDC → EURC → EUR Anchor

The payment reaches the recipient with the best available exchange rate.

Automatically finds the best conversion path between assets.

Scans available anchors and orderbooks to determine liquidity depth.

Minimizes price impact for large payments.

Applications can send payments without worrying about route selection.

Provides insights into liquidity distribution and market efficiency.

StableRoute leverages Stellar's built-in financial infrastructure.

Stellar's path payment functionality makes it ideal for routing.

flowchart LR
  User[User Wallet]
  API[StableRoute API]
  Router[Routing Engine]
  Liquidity[Liquidity Indexer]
  Orderbooks[Stellar Orderbooks]
  Stellar[Stellar Network]
  Receiver[Recipient Wallet]

  User --> API
  API --> Router
  Router --> Liquidity
  Liquidity --> Orderbooks
  Router --> Stellar
  Stellar --> Receiver

flowchart TB
  Frontend[Wallet / Payment App]
  Gateway[API Gateway]
  Router[Routing Engine]
  Pathfinder[Pathfinding Algorithm]
  LiquidityIndexer[Liquidity Indexer]
  QuoteService[Pricing Service]
  DB[(PostgreSQL)]
  Cache[(Redis)]
  StellarNode[Stellar Horizon Node]

  Frontend --> Gateway
  Gateway --> Router
  Gateway --> QuoteService
  Router --> Pathfinder
  Router --> LiquidityIndexer
  LiquidityIndexer --> DB
  QuoteService --> Cache
  Router --> StellarNode

sequenceDiagram
  participant User
  participant API
  participant Router
  participant Stellar
  participant Receiver

  User->>API: Send Payment Request
  API->>Router: Compute Best Route
  Router->>Router: Analyze Liquidity
  Router->>Stellar: Execute Path Payment
  Stellar->>Receiver: Deliver Destination Asset

StableRoute implements an optimized pathfinding algorithm similar to shortest-path routing in networks.

The algorithm evaluates:

• exchange rate
• liquidity depth
• slippage risk
• transaction fees
• number of hops

The best route is selected based on minimum effective cost.

Example candidate routes:

• Route A: INR → USDC → EURC → EUR
• Route B: INR → USDC → EUR
• Route C: INR → XLM → EURC → EUR

The router selects the optimal route dynamically.

erDiagram
  ASSET {
    string asset_code
    string issuer
    string type
  }
  MARKET {
    string base_asset
    string quote_asset
    float liquidity
  }
  ROUTE {
    string source_asset
    string destination_asset
    float estimated_cost
  }
  TRADE {
    string route_id
    float amount
    float price
  }
  ASSET ||--o{ MARKET : traded_in
  MARKET ||--o{ ROUTE : part_of
  ROUTE ||--o{ TRADE : executed_by

StableRoute includes multiple security protections.

• Phase 1: basic routing engine, Stellar path payment integration, liquidity monitoring
• Phase 2: advanced routing optimization, developer SDK, analytics dashboard
• Phase 3: institutional payment routing, cross-chain routing, automated liquidity markets

StableRoute enables efficient cross-border payments and stablecoin transfers.

Benefits include:

• better exchange rates
• reduced slippage
• automated payment routing
• improved liquidity utilization

This positions StableRoute as a core infrastructure layer for the Stellar payment ecosystem.

• stableroute-frontend — Next.js wallet / payment app
• stableroute-backend — API gateway, routing engine, pricing service
• stableroute-contracts — Soroban smart contracts (Stellar)

MIT