StellarFusion+

Demo

About

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.

How it's made

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 2. 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 3. 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)