Swifter - Advanced Swap Aggregator for MetaMask Smart Accounts on Monad

📋 Executive Summary

Swifter is a revolutionary swap aggregator platform that leverages MetaMask smart accounts with advanced delegation technology, built on the Monad network. The platform delivers a secure, gas-efficient, and flexible automated trading experience with five main swap modes: direct, scheduled, price-targeted, batch convert, and auto-subscription.

🎯 Core Features

1. Direct Swap

Real-time swap execution at current market prices
Direct integration with Monorail Swap Aggregator
Customizable slippage tolerance
Accurate gas fee estimates

2. Scheduled Swap

Schedule swaps for specific future times
Intuitive date and time picker interface
Countdown timer for upcoming swaps
Automated execution without user intervention

3. Price Target Swap

Automated limit orders with specific price targets
Flexible expiration periods (1 day to 1 year)
Automatic calculation of minimum received amount
Automated execution without user intervention

4. Batch Convert Swap

Multi-token Conversion: Convert multiple ERC20 tokens to a single target token in one transaction
Smart Token Detection: Automatic detection of all ERC20 tokens in smart account with balance filtering
Quote Optimization: Real-time price quotes for all selected tokens with automatic failed quote handling
Gas-Efficient Batching: Single transaction execution for multiple token conversions
Priority Selection: Smart token selection with verified token prioritization

5. Auto Subscription Swap

Recursive Trading: Set up automatic recurring swaps at customizable intervals
Flexible Scheduling: Multiple frequency options (hourly, daily, weekly, monthly, custom intervals)
Duration Control: Configurable subscription periods (1 day to indefinite)
Smart Balance Management: Automatic execution with balance verification
Progress Tracking: Real-time monitoring of subscription executions and remaining swaps

⚡ Core Workflows

1️⃣ Delegation Creation Flow

Purpose: Create a delegation signature to grant authority to the backend for swap execution

┌─────────────────────────────────────────────────────────────┐
│                    DELEGATION CREATION                       │
└─────────────────────────────────────────────────────────────┘

Step 1: Initialization
┌──────────────────────────────────────────────┐
│ • Validate smart account address             │
│ • Check wallet connection                    │
│ • Initialize swap parameters:                │
│   - Source token & amount                    │
│   - Target token                             │
│   - Slippage tolerance                       │
└──────────────────────────────────────────────┘
                    ↓
Step 2: Quote Fetching
┌──────────────────────────────────────────────┐
│ • Call Monorail API for best price           │
│ • Support batch or single quote              │
│ • Calculate expected output amount           │
│ • Get optimal swap route                     │
│ • Display price impact to user               │
└──────────────────────────────────────────────┘
                    ↓
Step 3: Delegation Creation
┌──────────────────────────────────────────────┐
│ • Generate delegation object with:           │
│   - Delegate address (backend executor)      │
│   - Caveats (restrictions):                  │
│     • Token allowances                       │
│     • Execution limits                       │
│     • Time constraints                       │
│   - Nonce & expiry                           │
│ • User signs delegation via wallet           │
└──────────────────────────────────────────────┘
                    ↓
Step 4: Approval Handling
┌──────────────────────────────────────────────┐
│ IF token is NOT native (ETH/MATIC):          │
│ • Create ERC20 approval delegation           │
│ • Set allowance for swap contract            │
│ • Sign approval delegation                   │
│ • Include in delegation package              │
└──────────────────────────────────────────────┘
                    ↓
Step 5: Submission
┌──────────────────────────────────────────────┐
│ • Bundle all delegations                     │
│ • Send to backend API:                       │
│   POST /api/delegations                      │
│   {                                          │
│     swap_delegation,                         │
│     approval_delegation,                     │
│     metadata                                 │
│   }                                          │
│ • Receive confirmation & tracking ID         │
└──────────────────────────────────────────────┘
                    ↓
                ✅ Success

2️⃣ Batch Convert Flow

Purpose: Convert multiple tokens to a single target token in one efficient transaction

┌─────────────────────────────────────────────────────────────┐
│                      BATCH CONVERSION                        │
└─────────────────────────────────────────────────────────────┘

Step 1: Token Detection
┌──────────────────────────────────────────────┐
│ • Scan smart account for all ERC20 balances  │
│ • Filter tokens with balance > 0             │
│ • Fetch token metadata (symbol, decimals)    │
│ • Display total portfolio value              │
└──────────────────────────────────────────────┘
                    ↓
Step 2: Target Selection
┌──────────────────────────────────────────────┐
│ • User selects target conversion token       │
│   (e.g., USDC, ETH, USDT)                    │
│ • System auto-excludes target token from     │
│   source token list                          │
│ • Show available tokens for conversion       │
└──────────────────────────────────────────────┘
                    ↓
Step 3: Quote Aggregation
┌──────────────────────────────────────────────┐
│ • Fetch quotes for ALL selected tokens       │
│   simultaneously via Monorail batch API      │
│ • For each token pair:                       │
│   - Get best swap route                      │
│   - Calculate output amount                  │
│   - Estimate gas cost                        │
│ • Display total expected output              │
└──────────────────────────────────────────────┘
                    ↓
Step 4: Validation
┌──────────────────────────────────────────────┐
│ • Check quote results:                       │
│   ✅ Success: Include in batch               │
│   ❌ Failed: Auto-deselect & notify user     │
│ • Validate total gas estimate                │
│ • Check for price impact warnings            │
│ • Require user confirmation                  │
└──────────────────────────────────────────────┘
                    ↓
Step 5: Batch Execution
┌──────────────────────────────────────────────┐
│ • Create batch delegation with:              │
│   - Multiple swap operations                 │
│   - Shared caveats & restrictions            │
│   - Optimized execution order                │
│ • Generate approval delegations for each     │
│   source token                               │
│ • User signs batch delegation                │
│ • Submit to backend for execution            │
└──────────────────────────────────────────────┘
                    ↓
Step 6: Confirmation
┌──────────────────────────────────────────────┐
│ • Display conversion summary:                │
│   - Total tokens converted: X                │
│   - Total output amount: Y target tokens     │
│   - Transaction hash                         │
│   - Gas cost used                            │
│   - Success/failure per token                │
│ • Update portfolio balance                   │
└──────────────────────────────────────────────┘
                    ↓
                ✅ Complete

3️⃣ Auto Subscription Flow

Purpose: Automatic recurring swap with certain time intervals (DCA strategy)

┌─────────────────────────────────────────────────────────────┐
│                    AUTO SUBSCRIPTION                         │
└─────────────────────────────────────────────────────────────┘

Step 1: Configuration
┌──────────────────────────────────────────────┐
│ User Input:                                   │
│ • Frequency (Daily/Weekly/Monthly)            │
│ • Duration (1 month / 3 months / 1 year)      │
│ • Token pair (e.g., USDC → ETH)               │
│ • Amount per swap                             │
│ • Slippage tolerance                          │
│                                               │
│ System Calculates:                            │
│ • Total executions = duration / frequency     │
│ • Total cost = amount × executions            │
│ • Next execution time                         │
└──────────────────────────────────────────────┘
                    ↓
Step 2: Validation
┌──────────────────────────────────────────────┐
│ • Check for duplicate pair subscriptions      │
│ • Validate sufficient token balance:          │
│   Required = amount × total_executions        │
│ • Verify gas fee coverage                     │
│ • Confirm subscription limit not exceeded     │
└──────────────────────────────────────────────┘
                    ↓
Step 3: Delegation Setup
┌──────────────────────────────────────────────┐
│ • Create time-bound delegation with:          │
│   - Start time: Now                           │
│   - End time: Now + duration                  │
│   - Execution limit: total_executions         │
│   - Amount per execution: specified amount    │
│   - Frequency caveat: time interval           │
│                                               │
│ • Generate recurring approval delegation      │
│ • User signs subscription delegation          │
└──────────────────────────────────────────────┘
                    ↓
Step 4: Monitoring
┌──────────────────────────────────────────────┐
│ Backend System Tracks:                        │
│ • Execution count: X / total                  │
│ • Next run time: timestamp                    │
│ • Remaining balance check                     │
│ • Subscription status: ACTIVE/PAUSED/ENDED    │
│                                               │
│ User Dashboard Shows:                         │
│ • Progress bar                                │
│ • Execution history                           │
│ • Average price achieved                      │
│ • Total tokens accumulated                    │
└──────────────────────────────────────────────┘
                    ↓
Step 5: Automatic Execution
┌──────────────────────────────────────────────┐
│ When Next Run Time Reached:                   │
│ • Validate delegation still valid             │
│ • Check balance sufficient                    │
│ • Fetch current market quote                  │
│ • Execute swap via delegation                 │
│ • Update execution counter                    │
│ • Calculate next execution time               │
│ • Send notification to user                   │
└──────────────────────────────────────────────┘
                    ↓
Step 6: Progress Tracking
┌──────────────────────────────────────────────┐
│ Real-time Updates:                            │
│ • Email/Push notification after each swap     │
│ • In-app execution log                        │
│ • Performance metrics:                        │
│   - Average buy price                         │
│   - Total accumulated                         │
│   - ROI vs lump sum                           │
│                                               │
│ Completion:                                   │
│ • Final summary report                        │
│ • Option to renew subscription                │
└──────────────────────────────────────────────┘
                    ↓
                ✅ Active

4️⃣ Execution Flow (Backend)

Purpose: Backend service that monitors and executes delegations

┌─────────────────────────────────────────────────────────────┐
│                     BACKEND EXECUTION                        │
└─────────────────────────────────────────────────────────────┘

Step 1: Validation
┌──────────────────────────────────────────────┐
│ On Delegation Received:                       │
│ • Verify signature validity                   │
│ • Check delegation not expired                │
│ • Validate all caveats satisfied              │
│ • Confirm nonce not used                      │
│ • Store in execution queue                    │
└──────────────────────────────────────────────┘
                    ↓
Step 2: Monitoring
┌──────────────────────────────────────────────┐
│ Continuous Monitoring For:                    │
│                                               │
│ A. Market Conditions:                         │
│    • Price thresholds met                     │
│    • Liquidity availability                   │
│    • Gas price optimal                        │
│                                               │
│ B. Time-Based:                                │
│    • Scheduled execution time reached         │
│    • Subscription interval completed          │
│                                               │
│ C. Subscription Schedules:                    │
│    • Next run time for each subscription      │
│    • Execution count not exceeded             │
│    • Balance still sufficient                 │
└──────────────────────────────────────────────┘
                    ↓
Step 3: Execution
┌──────────────────────────────────────────────┐
│ When Conditions Met:                          │
│ 1. Fetch latest market quote                  │
│ 2. Validate quote within slippage             │
│ 3. Execute approval if needed                 │
│ 4. Execute swap via delegation:               │
│    • Call smart account with delegation       │
│    • Submit transaction to network            │
│ 5. Wait for confirmation                      │
│ 6. Update execution status                    │
└──────────────────────────────────────────────┘
                    ↓
Step 4: Confirmation
┌──────────────────────────────────────────────┐
│ Post-Execution:                               │
│ • Store transaction hash                      │
│ • Update delegation status: COMPLETED         │
│ • Calculate actual vs expected output         │
│ • Compute gas cost                            │
└──────────────────────────────────────────────┘
                    ↓
                ✅ Completed

🏗️ Technical Architecture

System Components

┌─────────────────────────────────────────────────────────────┐
│                     SYSTEM ARCHITECTURE                      │
└─────────────────────────────────────────────────────────────┘

Frontend (User Interface)
┌──────────────────────────────────────────────┐
│ • Wallet connection (WalletConnect, Metamask)│
│ • Delegation signing interface               │
│ • Portfolio management dashboard             │
│ • Subscription configuration panel           │
│ • Real-time execution tracking               │
└──────────────────────────────────────────────┘
                    ↓ API Calls
Backend Services
┌──────────────────────────────────────────────┐
│ • Delegation validation service              │
│ • Execution scheduler (cron jobs)            │
│ • Market monitoring engine                   │
│ • Notification service                       │
│ • Transaction management                     │
└──────────────────────────────────────────────┘
                    ↓ RPC Calls
Blockchain Layer
┌──────────────────────────────────────────────┐
│ • Smart Account contracts                    │
│ • ERC20 tokens                               │
│ • Swap router contracts (Monorail)           │
│ • Event logs & transaction tracking          │
└──────────────────────────────────────────────┘

Data Flow

User Action → Frontend → Backend → Blockchain
    ↓           ↓          ↓           ↓
  Sign      Validate   Execute    Confirm
    ↓           ↓          ↓           ↓
  Store    Monitor    Update    Notify User

Smart Account System

// Hybrid implementation with MetaMask Delegation Toolkitconst smartAccount = await toMetaMaskSmartAccount({
    implementation: Implementation.Hybrid,
    deployParams: [ownerAddress, [], [], []],
    deploySalt: salt,
    signer: { walletClient }
});

Delegation Framework

Utilizes @metamask/delegation-toolkit to create limited permissions:

Restricted Scope: Only the MONORAIL_AGREGATE function is allowed
Smart Caveats: Time, amount, and balance change restrictions
Multi-layer Security: Signature verification for each delegation
Subscription Support: Recurring execution permissions with frequency limits

Batch Operations Engine

Multi-call Aggregation: Combine multiple token approvals and swaps into single transactions
Gas Optimization: Reduced gas costs through batch processing
Quote Validation: Pre-execution quote verification and fallback handling
Token Whitelisting: Verified token prioritization for enhanced security

Gas Optimization

Integration with Pimlico for gas sponsorship
Bundler client for user operation handling
Paymaster integration for gasless transactions
Batch gas savings for multiple operations

🔒 Security Analysis

Security Features

Delegation Caveats:

limitedCalls: Limits the number of executions (crucial for subscriptions)
allowedTargets: Only the Monorail contract is allowed
timestamp: Time-based execution restrictions
balanceChange: Verification of balance changes

Smart Account Protection:

Fund isolation through separate smart accounts
Salt-based account generation
Deployment verification
Subscription limit enforcement (max 5 per account)

Batch Convert Security:

Token verification and whitelisting
Maximum value limits per batch
Quote validation before execution
Automatic failed token deselection

Transaction Safety:

Slippage protection
Minimum output guarantee
Deadline enforcement
Duplicate subscription prevention

Risk Mitigation

// Enhanced caveats for subscription securityconst caveats = [
    {
        type: "erc20BalanceChange",
        tokenAddress: toToken.address,
        recipient: smartAccount.address,
        balance: BigInt(quote.min_output),
        changeType: BalanceChangeType.Increase,
    },
    {
        type: "limitedCalls",
        limit: subscriptionData.totalExecutions, // Fixed execution count
    }
];

⚠️ Error Handling

Common Error Scenarios

1. Insufficient Balance

Detection: Before delegation creation
Action: Show error, suggest amount adjustment
Recovery: User can reduce amount or cancel

2. Quote Failure

Detection: During quote fetching
Action: Retry 3x with exponential backoff
Recovery: Show error, allow manual retry

3. Signature Rejection

Detection: During wallet signingAction: Clear pending stateRecovery: User can retry signing

4. Execution Failure

Detection: During on-chain execution
Action: Mark delegation as FAILED
Recovery: Refund gas, notify user, allow retry

5. Slippage Exceeded

Detection: Before execution
Action: Skip execution, mark as SKIPPED
Recovery: Notify user, wait for next interval

6. Network Congestion

Detection: High gas prices
Action: Queue for later execution
Recovery: Execute when gas drops below threshold

📊 Status & Tracking

Delegation States

Subscription States

CONFIGURING → ACTIVE → PAUSED → ENDED
                ↓         ↓        ↓
              EXECUTING  RESUMED  COMPLETED

🎨 User Experience & Interface

Interface Components

SwapBox: Main swap interface with intuitive token selection
SmartWallet: Smart account management with deposit/withdraw
Task Management: Monitoring and control for all active swaps and subscriptions
Batch Convert: Unified view for multi-token conversions
Subscription Manager: Comprehensive control panel for recurring swaps
Popup System: Elegant confirmation, success, and error handling

User Experience Features

Balance Tracking: Real-time balance updates across all features
Token Search: Filtering and token verification with batch selection
Percentage Quick-select: 25%, 50%, 75%, 100% amount selection
Responsive Design: Mobile-friendly interface
Progress Indicators: Real-time status for batch and subscription operations
Smart Defaults: Auto-selection of optimal parameters

💡 Innovations & Advantages

Technical Innovations

MetaMask Delegation Integration: First in the Monad ecosystem
Hybrid Smart Accounts: Combines EOA and smart contract benefits
Gasless Operations: Seamless user experience without gas fees
Batch Processing Engine: Multi-token operations in single transactions
Recursive Delegation System: Time-based automatic execution permissions

Competitive Advantages

Multi-mode Swaps: One platform for all trading needs
Time-based Automation: Scheduled swaps without manual intervention
Price Automation: More flexible limit orders
Portfolio Consolidation: Batch convert scattered tokens into preferred assets
DCA Strategy Support: Automated dollar-cost averaging through subscriptions
Smart Account Management: Multiple wallet support with guaranteed security

📊 Performance Optimization

Efficiency Features

Quote Caching: Reduces unnecessary API calls
Batch Operations: Multi-account and multi-token management
Gas Price Optimization: Dynamic gas pricing via Pimlico
Error Recovery: Robust error handling and retry mechanisms
Parallel Processing: Simultaneous quote fetching for batch operations

Monitoring & Analytics

Real-time task tracking for all swap types
Subscription execution history and progress
Batch conversion success rates and gas savings
Transaction history with explorer links
Comprehensive status updates
Error reporting and resolution guidance

🔄 Integration Ecosystem

Third-party Integrations

Monorail: Swap aggregation engine
Pimlico: Account abstraction services
Monad Testnet: Blockchain infrastructure
MetaMask: Wallet provider and delegation framework

Contract Architecture

// Core contract addresses
MONORAIL_CONTRACT = "0x525b929fcd6a64aff834f4eecc6e860486ced700";      // Swap aggregationDELEGATOR_ADDRESS = "0x22f4b7Bca137cF91AE3d08B393167FADdA220eee";      // Scheduled swap ExecutorDELEGATOR_ADDRESS_PRICE = "0x82eC492530cAef73fec8512054b070a0a35E0000"; // Price-based swap ExecutorDELEGATOR_ADDRESS_AUTOBUY = "0xc14e57e4ba2a86652f362c459c0dc048331f4444"; // Auto-subscription Executor

🚀 Roadmap & Scalability

Immediate Enhancements

Multi-chain deployment preparation
Advanced order types (TWAP, VWAP)
Portfolio management features
Mobile app development
Enhanced batch conversion strategies

Long-term Vision

DeFi protocol integrations
Cross-chain swap capabilities
Institutional features
DAO governance model
Advanced subscription analytics

🏆 Hackathon Relevance

Why Swifter Stands Out

Technical Depth: Implements delegation technology not widely adopted
User-Centric Design: Complex functionality with a simple interface
Monad Ecosystem Contribution: Building on a new network with specific optimizations
Production Ready: Mature code quality and security considerations

Innovation Points

✨ First MetaMask delegation implementation on Monad
⚡ Gasless scheduled and limit orders
🔄 Multi-mode swap in a single interface
🛡️ Enhanced security through smart account isolation
📦 Batch token conversion for portfolio management
🔄 Auto-subscription for recurring investment strategies

📈 Metrics & Success Indicators

Key Performance Indicators

Reduced gas costs by up to 80% through sponsorship and batching
100% automation rate for scheduled swaps and subscriptions
Sub-5 second execution for price target swaps
99.9% success rate on delegation executions
70% gas savings on batch conversions vs individual swaps
5x user efficiency improvement through automated recurring swaps

User Benefits

Time Savings: Automated execution eliminates manual monitoring
Cost Efficiency: Batch operations reduce overall gas costs
Portfolio Optimization: Easy consolidation of scattered tokens
Strategy Implementation: Support for DCA and recurring investment strategies
Risk Reduction: Automated execution at optimal conditions

Swifter

Videos

Description