Rebased-Contracts

Rebased Protocol enables rebasing tokens like stETH to work across chains with real-time rewards. Uses L1SLOAD, EIP-4788 & LayerZero.

Comment

About MigrationAgent

Inspiration

The blockchain ecosystem is fragmented. Ethereum hosts the largest DeFi ecosystem with over $50B in TVL, but developers and users face crippling gas fees—sometimes paying \$50+ for a simple token transfer. Meanwhile, Solana offers transactions at a fraction of a cent (\$0.00025 average), but migrating existing smart contracts requires expertise in two completely different paradigms:

  • Ethereum: Account-based model, Solidity, EVM bytecode
  • Solana: Account-based with explicit data accounts, Rust/Anchor, BPF bytecode

We saw developers spending weeks to months manually translating contracts, often introducing bugs in the process. We asked: What if AI could bridge this gap?

The rise of powerful LLMs like Claude gave us the answer. MigrationAgent was born from the belief that cross-chain migration should be as easy as copy-paste.

What it does

MigrationAgent is an AI-powered web application that automatically converts Ethereum smart contracts to Solana Anchor programs.

Core Features:

  1. One-Click Contract Fetching: Enter any Ethereum contract address → we fetch the verified source code via Etherscan API v2
  2. AI-Powered Migration: Claude analyzes the Solidity code and generates equivalent Anchor (Rust) code with inline comments explaining each translation
  3. Side-by-Side Comparison: Monaco Editor split view showing original Solidity alongside generated Rust
  4. Deep Analysis Dashboard:
    • Contract type detection (ERC20, ERC721, Staking, Governance, etc.)
    • Complexity scoring
    • Migration effort estimation
    • Detailed differences table (e.g., mapping → PDA, msg.sender → Signer)
  5. Cost Comparison Chart: Visual breakdown showing potential savings—Ethereum vs Solana fees
  6. Project Export: Download a complete Anchor project structure as a ZIP file, ready for anchor build

How we built it

Tech Stack:

  • Frontend: Next.js 14 (App Router), TypeScript, Tailwind CSS
  • UI Components: Custom Shadcn/ui components (Button, Card, Tabs, etc.)
  • Code Editor: Monaco Editor (same engine as VS Code)
  • AI Engine: Anthropic Claude API (Claude Sonnet 4)
  • Blockchain Data: Etherscan API v2 for fetching verified contracts
  • Visualization: Recharts for cost comparison charts
  • Export: JSZip + FileSaver for ZIP generation

Architecture:

┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
│   User Input    │────▶│  Next.js API     │────▶│  Etherscan V2   │
│  (Address/Code) │     │  /api/fetch      │     │  (Source Code)  │
└─────────────────┘     └──────────────────┘     └─────────────────┘
                                │
                                ▼
                        ┌──────────────────┐
                        │  Claude API      │
                        │  /api/migrate    │
                        │  (AI Analysis)   │
                        └──────────────────┘
                                │
                                ▼
                        ┌──────────────────┐
                        │  Analysis UI     │
                        │  Code + Tabs +   │
                        │  Export ZIP      │
                        └──────────────────┘

Prompt Engineering:

We crafted a detailed system prompt that instructs Claude to:

  • Identify contract patterns (ERC20, ERC721, etc.)
  • Generate structured JSON output with code, analysis, and migration checklist
  • Explain Solana-specific concepts like PDAs, CPIs, and account constraints
  • Highlight unsupported patterns and suggest alternatives

Challenges we ran into

1. API Versioning Issues

Etherscan deprecated their V1 API mid-development! We had to quickly migrate to the new V2 unified API with chainid parameters.

2. Claude Model Availability

We encountered 404 not_found_error for various Claude model versions. Solution: implemented a fallback chain that tries multiple models (claude-sonnet-4-20250514 → claude-3-7-sonnet → claude-3-haiku) until one succeeds.

3. Complex Solidity Patterns

Some Solidity patterns have no direct Solana equivalent:

  • Reentrancy guards → Solana's single-threaded runtime handles this differently
  • mapping(address => mapping(...)) nesting → Requires multiple PDA derivations
  • Inheritance → Anchor doesn't support inheritance; requires flattening

We solved this by having Claude explain alternatives rather than generating broken code.

4. JSON Parsing from LLM Output

Claude sometimes wraps JSON in markdown code blocks. We implemented regex extraction (/\{[\s\S]*\}/) with graceful fallbacks.

5. Vercel Deployment

SSL handshake errors during deployment required retries. Environment variables needed manual configuration post-deploy.

Accomplishments that we're proud of

✅ End-to-end automation: From contract address to downloadable Anchor project in one click

✅ Production-ready UI: Clean, responsive interface with dark mode, loading states, and error handling

✅ Intelligent analysis: Not just code generation—we provide context, explanations, and a migration roadmap

✅ Real cost savings visualization: Developers can see exactly how much they'll save on Solana

✅ Deployed and live: https://migration-agent.vercel.app

What we learned

  1. Solana vs EVM Mental Models: The biggest migration challenge isn't syntax—it's understanding that Solana separates code (programs) from data (accounts). This requires rethinking state management entirely.

  2. LLM Prompt Engineering: Structured output (JSON) from LLMs requires explicit formatting instructions and robust parsing with fallbacks.

  3. API Resilience: External APIs (Etherscan, Anthropic) can change or fail. Building with multiple fallbacks and clear error messages is essential.

  4. The Power of AI-Assisted Development: We built a complex full-stack application in hours, not weeks—demonstrating the potential of AI pair programming.

What's next for MigrationAgent

Short Term:

  • Multi-chain support: Add Base, Polygon, Arbitrum → Solana migrations
  • Test generation: Automatically generate Anchor tests based on Solidity tests
  • Gas estimation: More accurate cost comparisons using real-time gas prices

Medium Term:

  • Interactive migration: Let users modify the generated code in-browser with live validation
  • Deployment pipeline: One-click deploy to Solana devnet directly from the app
  • Migration history: Save and track previous migrations

Long Term:

  • Bi-directional migration: Solana → EVM for projects wanting to expand
  • Audit integration: Partner with security firms to auto-audit generated code
  • Enterprise tier: Support for complex multi-contract protocols with cross-contract calls

--

Built With

Share this project:

Updates