StellarFusion+

StellaSwap

What is StellaSwap?

StellaSwap is a revolutionary cross-chain protocol that enables trustless atomic swaps between Stellar and Ethereum blockchains. It allows users to directly exchange assets (like XLM for ETH or ETH for XLM) without relying on centralized exchanges, wrapped tokens, or vulnerable bridge protocols that have lost billions to hacks.

The Core Problem We Solve

Today's cross-chain trading is fundamentally broken:

Centralized exchanges require you to deposit funds and trust the platform (remember FTX?)

Traditional bridges create wrapped tokens with counterparty risk and have lost over $2.5 billion to exploits

Direct swaps between different blockchains have been technically impossible... until now

Our Solution: Hash Time-Locked Contracts (HTLCs)

StellaSwap implements atomic swaps using Hash Time-Locked Contracts — a cryptographic mechanism that ensures either both parties get what they want, or both get their original funds back. No one can be scammed.

How It Works (Simple Version)

Alice wants to trade 1000 XLM for 0.5 ETH with Bob (or Bob wants to trade 0.5 ETH for 1000 XLM with Alice)

Alice (or Bob) creates a secret and locks her (or his) asset in a Stellar or Ethereum smart contract using a hash of that secret

The counterparty locks their asset in the corresponding smart contract on the other chain using the same hash

When the initiator reveals the secret to claim the counterparty's asset, the counterparty automatically gets access to the initiator's locked asset

If something goes wrong, both can recover their funds after a timeout period

Technical Architecture

Five Key Components

Make: Creates swap orders (wants to exchange Asset A for Asset B)

Relayer: Broadcasts orders and coordinates the swap process

Resolver: Takes the other side of trades (provides liquidity)

Stellar Contract: Handles XLM/Stellar asset escrow with HTLC logic

Ethereum Contract: Handles ETH/ERC-20 escrow with HTLC logic

The Complete Flow

Phase 1: Order Creation

Maker creates a StellaSwap order specifying: "I want to swap 1000 XLM for 0.5 ETH" (or "I want to swap 0.5 ETH for 1000 XLM")

Order includes a secret hash and timelock parameters

Relayer broadcasts this intent to potential resolvers

Phase 2: Escrow Setup

Resolver agrees to take the trade

Maker locks 1000 XLM (or 0.5 ETH) in the corresponding contract with secret hash + 24-hour timelock

Resolver locks 0.5 ETH (or 1000 XLM) in the contract on the other chain with same hash + 12-hour timelock

Both escrows must be confirmed before proceeding

Phase 3: Atomic Execution

Maker reveals the secret to claim the counterparty’s asset from the Ethereum or Stellar contract

The same secret automatically allows resolver to claim the original asset from the opposite contract

Both transfers happen atomically — if one fails, both fail

Phase 4: Safety Recovery

If maker doesn't reveal the secret within timelock, both parties can recover original funds

Shorter timelock on second-mover chain protects counterparty from griefing attacks

Why This is Revolutionary

Security Advantages

No custodial risk: You never give up control of your assets to a third party

No wrapped tokens: Direct native asset transfers

No bridge vulnerabilities: No validators or multisig that can be compromised

Mathematical guarantees: Cryptographic proof that swaps are fair

Efficiency Benefits

Lower fees: ~$0.50 total vs 0.1-1% on traditional bridges

Faster settlement: 2-3 minutes vs hours on some bridges

No KYC required: Fully decentralized and permissionless

Cross-chain composability: Enables new DeFi strategies across ecosystems

Live Demo Capabilities

Our working prototype demonstrates:

Real testnet transactions on both Stellar and Ethereum

Smart contract deployment with verified source code

Cross-chain coordination via our relayer system

Block explorer verification showing actual fund transfers

Recovery mechanisms if swaps need to be cancelled

Market Opportunity

Cross-chain bridge market: $58 billion in locked value

Stellar daily volume: $3+ billion

Ethereum DeFi TVL: $100+ billion

Current bridge fees: 0.1–1% (we can do 0.01%)

Bridge hack losses: $2.5+ billion (we eliminate this risk)

Technical Innovation

Building on Proven Technology

Extends 1inch Fusion+ protocol to work across different blockchain architectures

Stellar's native smart contracts for efficient asset handling

Ethereum's EVM for complex HTLC logic

Cross-chain event monitoring for seamless coordination

Key Differentiators

First implementation of atomic swaps between Stellar and Ethereum

Leverages battle-tested 1inch infrastructure ($50B+ processed)

No new consensus mechanisms or validator sets required

Compatible with existing DeFi protocols on both chains

Business Model

Revenue Streams

Transaction fees: 0.01% per successful swap

Resolver incentives: Market-making rewards for liquidity providers

API licensing: White-label solutions for other protocols

Conservative Projections

Year 1: $1M daily volume = $36K annual revenue

Year 3: $100M daily volume = $3.6M annual revenue

Why Judges Should Care

For DeFi Enthusiasts: We're solving the biggest problem in crypto — isolated blockchain ecosystems

For Security-Minded: We eliminate the single biggest attack vector in DeFi (bridge hacks)

For Builders: We provide infrastructure that other protocols can build on top of

For Investors: We're addressing a $58B market with proven technology and clear revenue model

What Makes This Demo-Ready

Unlike many hackathon projects that show mockups, StellaSwap is fully functional:

Working smart contracts on both Stellar and Ethereum testnets

End-to-end atomic swap completion in under 3 minutes

Real blockchain transactions you can verify on explorers

Recovery mechanisms tested and functional

Clean, professional UI for creating and monitoring swaps

This isn't just a concept — it's a working protocol ready for mainnet deployment.

StellaSwap represents the future of cross-chain trading: secure, efficient, and truly decentralized. We're not just building another bridge — we're creating the infrastructure for a connected multi-chain future.

Project Name: StellaSwap Tagline: Trustless atomic swaps for XLM↔ETH between Stellar & Ethereum with zero counterparty risk.

What We Built We’ve created a trustless, cross-chain atomic swap protocol that enables seamless token exchanges between Ethereum and Stellar networks — without relying on bridges or centralized custody.

Inspired by 1inch Fusion+, our protocol implements Hash Time-Locked Contracts (HTLCs) to ensure atomic execution: either both sides of the trade succeed, or both parties are fully refunded. Think of it as a decentralized escrow system that works across two entirely different blockchain architectures. Users can swap ETH/ERC-20 tokens for XLM/Soroban assets, with mathematical guarantees of security.

The Problem We Solved Traditional cross-chain swaps depend on:

Bridges — vulnerable to exploits (>$2.5B lost from 2022–2024)

Centralized exchanges — custodial risk, KYC friction

Wrapped tokens — added complexity and trust assumptions

Our solution eliminates all of the above using atomic swap technology. Inspired by 1inch Fusion+, we provide:

Built-in MEV protection

Intent-based Dutch auction fills

Trustless, non-custodial infrastructure

How It Works — Protocol Flow Phase 1: Order Creation & Broadcasting Maker creates a swap order with a secret hash (keeps secret private)

Relayer broadcasts the order to potential Resolvers (liquidity providers)

Orders are filled using a Dutch auction mechanism (similar to 1inch Fusion+)

Phase 2: Dual Escrow Setup Resolver locks ETH/tokens on Ethereum via our EthHTLC.sol contract

Resolver also locks XLM/assets on Stellar via Soroban HTLC contract

Both contracts use the same secret hash with different timelocks (Stellar expires first)

Phase 3: Atomic Execution Resolver reveals the secret to claim funds on one chain

Relayer detects the secret and propagates it

Maker uses revealed secret to claim funds on the other chain

Swap completes atomically — both parties get what they expected

Phase 4: Safety Mechanism If something fails, timelocks allow fund recovery

Neither side can lose funds or get locked in a failed trade

Technical Architecture Smart Contracts Ethereum Side (EthHTLC.sol)

EVM-compatible HTLC with events

Supports ETH and ERC-20 tokens

Gas-optimized using custom errors

Stellar Side (Rust/Soroban)

Full HTLC for XLM and Soroban tokens

Event-rich for relayer sync

Panic-safe with robust state handling

Off-Chain Infrastructure Relayer (Node.js / TypeScript)

Monitors Ethereum and Stellar in parallel

Detects HTLC events + secret reveals

Propagates secrets cross-chain

Coordinates Dutch auction filling

Resolver / Market Maker

Provides cross-chain liquidity

Competes in auction fills

Manages exposure and risk

Frontend (Next.js) Integrated with MetaMask and Freighter

Real-time swap status and explorer links

Smooth UX for cross-chain transactions

Key Technical Innovations

1. Dual-Chain HTLC Synchronization Deterministic swap IDs based on hash and order params

Event-driven architecture with normalized schemas

Differential timelocks (Stellar expires first) prevent griefing

1. Soroban–Ethereum Bridge Logic Soroban HTLC mirrors EVM semantics with:

Native XLM + Soroban token support

Custom error and panic-safe state

Gas-efficient storage structures

1. Secure Secret Management 32-byte SHA-256 hashlock

Enforced replay protection via state enums

Strict timed execution windows

What Makes This Special Security-First Design No custodial risk — funds stay with users until swap completion

Mathematical guarantees — all-or-nothing execution

MEV-resistance — Dutch auction removes front-running

Audit-ready — well-tested contracts with formal logic structure

Production-Ready Features Bidirectional swaps: ETH→XLM and XLM→ETH

Multi-asset support: ERC-20 + Soroban tokens

Live on testnets: Sepolia (ETH) + Stellar testnet

Block explorer verification: All contracts and txs are traceable

1inch Fusion+ Compatibility StellaSwap adheres to 1inch Fusion+ architecture:

Intent-based swaps

Dutch auction pricing

Gas-adaptive execution

This allows seamless integration with 1inch aggregation infrastructure and any DEX that supports intent-based routing.

The “Hacky” Parts Worth Highlighting Cross-Chain Event Sync Built a custom indexer that maps EVM logs and Stellar ledger entries into a unified schema. This bridges two radically different event models with consistency.

Timelock Differentiation Strategy Implemented asymmetric timeouts:

Stellar HTLC expires at T

Ethereum HTLC expires at T + Δ

This guarantees fair recovery and protects against late-claim exploits.

Soroban Memory Optimization Soroban contracts are memory-constrained. We:

Used bit-packed enums

Designed compact state machines

Retained full audit trails despite footprint limitations

Demo & Verification StellaSwap is fully functional on public testnets:

✅ Verified smart contracts on Sepolia and Stellar testnet

✅ Live swap executions with test assets

✅ On-chain block confirmations via explorers

✅ 24/7 relayer uptime during demo

Future Extensibility The architecture supports:

Partial fills for large orders

Multi-resolver auctions

Expansion to additional chains

Support for advanced order types (e.g., limit, DCA)