DEV Community: fino

I built a cross-chain swap SDK for AI agents (MCP-native, handles cold start gas automatically)

fino — Thu, 26 Mar 2026 08:04:59 +0000

I needed to swap 0.003 ETH (on Base) to MYST tokens (on Polygon) for an AI agent I was building. Simple enough, right?

Two hours later, I had manually:

Found the best DEX route on Paraswap
Realized I had no POL on Polygon for gas — so the bridged USDC was stuck
Manually sent POL from another wallet
Set amountOutMin wrong and got sandwiched
Fumbled the slippage config and the tx reverted

There was no single tool that handled all of this. So I built one.

What is AutoSwap?

AutoSwap is a cross-chain swap SDK built specifically for AI agents. It wraps the entire swap pipeline — DEX routing, bridging, native gas resolution, and slippage protection — into a single function call.

from autoswap import swap

result = swap(
    from_token="ETH",
    from_chain="base",
    to_token="MYST",
    to_chain="polygon",
    amount=0.003,
    slippage_max=2.0,
    dry_run=True,  # simulate first — always
)

print(result.route_taken)
# → "ETH→USDC (base) | bridge USDC base→polygon | USDC→MYST (polygon)"

print(f"~{result.amount_out:.4f} MYST")
# → "~47.3281 MYST"

That's it. One call.

The Problems AutoSwap Solves

1. The Cold Start Gas Problem

This is the most under-discussed problem in cross-chain DeFi.

You bridge USDC from Base to Polygon. It arrives. Now you need to swap it to MYST. But you have zero POL on Polygon. Your USDC is stuck, and you can't do anything without gas.

AutoSwap detects this automatically and resolves it via a gasless relay before executing your swap. You never have to think about it.

2. amountOutMin=0 (The MEV Sandwich Attacker's Best Friend)

Every tutorial, every StackOverflow answer, every quick script I've seen sets amountOutMin=0 "for simplicity." This is the #1 way to get sandwiched.

AutoSwap never sets amountOutMin=0. Period. Slippage is calculated against real liquidity data from the DEX. The hard maximum is 50% — any route exceeding that is rejected outright.

3. Best Route Selection

AutoSwap queries both Paraswap (50+ DEX aggregation) and Uniswap V3 in parallel, picks the highest expected output, and validates it before building the transaction.

4. Bridge Complexity

Cross-chain routing via Across Protocol with ~2-5 second fills, automatic fallback if the primary route fails, and USDC as the default bridge token (deepest liquidity).

Architecture

autoswap/
├── src/
│   ├── swap.py      ← Orchestrator
│   ├── router.py    ← DEX routing (Paraswap + Uniswap V3)
│   ├── bridge.py    ← Cross-chain bridge (Across Protocol)
│   ├── gas.py       ← Native gas resolver
│   └── safety.py    ← Slippage + sandwich protection
├── autoswap/        ← Python package
├── npm/             ← JavaScript wrapper
└── mcp-tool.json    ← MCP tool descriptor (for AI agents)

MCP Native: Claude/Cursor/Cline Can Call It Directly

This is where it gets interesting for AI agent builders.

AutoSwap ships as an MCP (Model Context Protocol) tool. Add this to your Claude Desktop or Cursor config:

{
  "mcpServers": {
    "autoswap": {
      "command": "python3",
      "args": ["-m", "autoswap.mcp_handler"],
      "env": {
        "ETH_PRIVATE_KEY": "your_key"
      }
    }
  }
}

Now Claude can execute cross-chain swaps directly in conversation:

User: "Swap 0.003 ETH on Base to MYST on Polygon, show me the route first"

Claude: [calls autoswap.swap with dry_run=true]
→ Route: ETH→USDC (base) | bridge USDC base→polygon | USDC→MYST (polygon)
→ Expected output: ~47.3 MYST
→ Bridge fee: 0.08 USDC

"Execute it."

Claude: [calls autoswap.swap with dry_run=false]
→ Received: 47.1 MYST ✅

No manual steps. No fumbling with raw transaction builders. The agent just calls swap() and gets a result.

Dry-Run Mode: Safe by Default

AutoSwap is designed for agents that need to verify before executing. dry_run=True builds the entire transaction pipeline, checks liquidity, calculates fees, and returns the full route — without submitting anything to the blockchain.

# Always dry-run first
result = swap("ETH", "base", "MYST", "polygon", 0.003, dry_run=True)
print(f"Route: {result.route_taken}")
print(f"Expected: {result.amount_out:.4f} MYST")
print(f"Bridge fee: {result.fees.get('bridge_fee', 0):.4f} USDC")

# Only execute if the numbers look right
if result.success and result.amount_out > 40:
    live = swap("ETH", "base", "MYST", "polygon", 0.003, dry_run=False)
    print(f"TX: {live.tx_hashes}")

JavaScript / npm

There's a thin JS wrapper for Node.js environments:

npm install autoswap

const { swap, quote } = require('autoswap');

const result = await swap({
  fromToken: 'ETH',
  fromChain: 'base',
  toToken: 'MYST',
  toChain: 'polygon',
  amount: 0.003,
  dryRun: true,
});

console.log(result.routeTaken);

Supported Networks

Chain	Status
Base	✅ Full support
Polygon	✅ Full support
Arbitrum	✅ Full support
Optimism	✅ Full support
Ethereum	🔜 Coming soon

Comparison

Feature	AutoSwap	Li.Fi	1inch	Relay.link
Single function call	✅	❌	❌	❌
Cold start gas fix	✅ automatic	❌ manual	❌	❌
Sandwich protection	✅ built-in	⚠️	✅	⚠️
amountOutMin=0 guard	✅ always	⚠️	✅	⚠️
MCP / AI agent ready	✅ native	❌	❌	❌
Dry-run simulation	✅	⚠️	❌	❌
No API key needed	✅	❌	❌	❌
Open source (MIT)	✅	✅ GPL	❌	❌

Install

pip install autoswap
# or
npm install autoswap

GitHub: https://github.com/fino-oss/autoswap

Built from real pain. If you've ever manually sent POL to unstick a bridged USDC, this is for you.

Happy to answer questions — especially if you're building AI agents that need DeFi access.

I Built an MCP Tool That Scans Smart Contracts for Security Risks

fino — Mon, 16 Mar 2026 21:21:13 +0000

TL;DR: I deployed a contract security scanner on Base L2, then wrapped it as an MCP server so any AI assistant (Claude, Cursor, Cline) can scan contracts on demand. Free, open, permissionless.

The problem

Before interacting with a smart contract — approving a token, depositing in a DeFi protocol, buying an NFT — you should check if it's safe. But most devs just... don't. It's too slow to manually check Etherscan, read the ABI, look for rug patterns.

I wanted to make this a one-liner inside my AI assistant.

What I built

An MCP (Model Context Protocol) server that exposes a contract scanner as a tool.

Once installed, you just ask:

"Is this token safe to buy? 0x4ed4e862860bed51a9570b96d89af5e1b0efefed"

And your AI assistant calls the tool automatically and returns:

## 🟡 Risk Score: 30/100 — MEDIUM

Contract: 0x4ed4e862...
Name: DEGEN
Age: 412 days
Source verified: ✅ Yes

### 🟠 HIGH (1)
- mint(address,uint256): Selector 0x40c10f19 found in bytecode

### ✅ GOOD (3)
- Source code verified
- ERC20 compliant
- Active contract (100+ recent txs)

How it works

The scanner analyzes a contract address on Base L2:

Fetches bytecode via free RPC (https://mainnet.base.org)
Checks source verification via BaseScan API (free tier)
Scans for risky function selectors in bytecode:
- 🔴 Critical: rescueTokens(), withdrawAll() (backdoors)
- 🟠 High: mint(), blacklist()
- 🟡 Medium: pause(), setFee(), upgradeable proxies
Checks contract age and transaction activity
Returns a risk score 0–100

The MCP layer wraps this as 3 tools:

scan_contract(address) — full scan with findings
batch_scan([addr1, addr2, ...]) — compare up to 5 contracts
interpret_risk(score, findings) — get SAFE / CAUTION / HIGH_RISK / DO_NOT_USE

Install in Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "contract-scanner": {
      "command": "node",
      "args": ["/path/to/p8/mcp/server.js"]
    }
  }
}

Same config works for Cursor (~/.cursor/mcp.json) and Cline.

The architecture

AI Assistant (Claude/Cursor/Cline)
    ↓ MCP protocol (stdio)
server.js  ←  McpServer + StdioTransport
    ↓
scanner.js  ←  ethers.js + BaseScan API
    ↓
Base L2 RPC (free) + BaseScan (free tier)

No server. No API key required for basic scans. No wallet needed — read-only.

What's next

The scanner results can also be posted on-chain via the AgentEscrow.sol contract I deployed on Base:

Client sends 0.5 USDC → AgentEscrow → JobCreated event
Scanner analyzes → posts result hash on-chain
24h dispute window → USDC released to scanner wallet

This makes the scanner a trustless on-chain service: pay-per-scan, verifiable, no middleman.

The code is on Base mainnet. Scanner wallet: 0x804dd2cE4aA3296831c880139040e4326df13c6e

If you find it useful, try it. If you find a bug, open an issue.