swapperfinance/swapper-toolkit
DeFi toolkit for AI agents and coding assistants — deposit funds, execute trades, and manage crypto wallets. Works with ...
Deposit, bridge, and swap across 4 chains in one call — wallet plumbing for AI agents.
Turn what you learned into a concrete stack decision.
Want the shortlist in your inbox?
Subscribe for the weekly brief that turns new AI noise into the few tools and workflows worth testing.
DeFi toolkit for AI agents and coding assistants — deposit funds, execute trades, and manage crypto wallets. Works with ...
Every AI agent that touches crypto eventually runs into the same wall: it can reason about a trade, but it can't actually move money without a human stitching together four different SDKs — one per chain, plus a bridge, plus a DEX router. That's not automation, that's a human doing manual labor between LLM calls.
Swapper Toolkit collapses that into one function call: deposit, bridge, and swap across Ethereum, Base, Arbitrum, and Solana, wired directly into Claude Code or OpenClaw. It picked up 700+ GitHub stars in a matter of days, which in crypto-tool terms means builders are actually testing it, not just star-farming it.
@jetpippo's framing on this is the right one: infra like this outlives the agents built on top of it. Trading bots and research agents come and go with the hype cycle. The wallet layer underneath them is the part that has to work every single time, or nothing above it matters.
Swapper Toolkit is a wallet SDK built specifically for agent use, not human use. Instead of a UI where you click "bridge," then "swap," then wait, confirm, and repeat on the other side, it exposes three primitives an agent can call directly:
All three collapse into a single call from the agent's perspective. You tell it "get 500 USDC from Ethereum onto Base as ETH," and the toolkit handles the deposit, the cross-chain hop, and the swap as one operation instead of three you'd normally have to sequence and babysit.
The reason this isn't just another wrapper around a bridge API: it runs on Chainlink's Runtime Environment (CRE) for the off-chain compute and decision logic, and CCIP for the actual cross-chain messaging and token transfers.
That combination matters for one specific reason — trust. A homegrown bridge script is a single point of failure: if the relayer goes down or gets compromised, funds are stuck or gone. CCIP is Chainlink's audited, oracle-secured messaging layer, already used to move billions across chains. Running the agent's decision logic through CRE means the execution path is verifiable, not just "trust my Node script running on a VPS somewhere." For an agent that's autonomously moving real money, that's the difference between infra you can leave unattended and infra you have to babysit.
If you're running a research agent that only reads on-chain data, skip this — you don't need a wallet layer at all. This is for builders whose agents need to act: rebalancing a portfolio across chains, executing a strategy that spans multiple L2s, or auto-compounding yield that's scattered across ecosystems.
It's also a fit if you're already running agents in Claude Code or OpenClaw and don't want to hand-roll wallet management as a side project. Wiring four chains' worth of RPC calls, gas estimation, and bridge confirmations yourself is a multi-week detour from whatever your agent is actually supposed to do.
Here's the actual flow, start to finish.
1. Install the toolkit as an MCP server:
npm install -g @swapperfinance/toolkit-mcp
2. Add it to your Claude Code MCP config (~/.claude/mcp_servers.json or your project's .mcp.json):
{
"mcpServers": {
"swapper": {
"command": "swapper-toolkit-mcp",
"env": {
"AGENT_WALLET_KEY": "${AGENT_WALLET_KEY}",
"SWAPPER_NETWORK": "mainnet"
}
}
}
}
Note the ${AGENT_WALLET_KEY} — pull this from your environment, never hardcode it in the config file itself.
3. Fund the agent wallet. Deposit a small test amount first — 50-100 USDC on Ethereum — before letting the agent touch anything larger. This is not optional; see the mistakes section below.
4. Give the agent a plain-language instruction:
Move 100 USDC from my Ethereum wallet to Base, and swap it for ETH once it lands.
5. What happens under the hood: the agent calls swapper.deposit() to pull the USDC, swapper.bridge() routes it through CCIP to Base, and swapper.swap() executes the ETH trade on arrival — three chain operations, one tool call, no manual confirmation clicks. You'll see the transaction hashes for each leg logged back to the agent's context, so you can verify the whole thing on a block explorer after the fact.
That's the entire loop. No separate bridge UI, no manual gas top-ups on the destination chain — the toolkit handles that too.
| | Swapper Toolkit | DIY (viem/ethers + Solana web3.js + bridge aggregator) | |---|---|---| | Setup time | Hours | Days to weeks | | Chains supported | ETH, Base, Arbitrum, Solana (fixed set) | Any chain you're willing to integrate | | Cross-chain trust model | Chainlink CCIP (audited, oracle-secured) | Whatever bridge aggregator you pick — varies wildly | | Control/customization | Limited to toolkit's exposed primitives | Full control over routing, slippage, retry logic | | Best for | Shipping an agent that needs to act across these 4 chains, fast | Custom routing logic, chains outside this set, or teams that need full audit control over every hop |
If your agent's universe is these four chains and you want to ship this month, use the toolkit. If you need a fifth chain it doesn't support, or your compliance team needs to audit every line of the bridging logic, roll your own — you'll spend more time, but you'll own every decision point.
Funding the agent wallet with more than you can afford to lose during testing. This is new infra with 700+ stars earned in days — that's early-adopter enthusiasm, not years of mainnet battle-testing. Start with test amounts, not your treasury.
Putting the wallet key directly in the MCP config file. That file often ends up in a repo, a screenshot, or a support ticket. Load it from an environment variable, and make sure .env is in your .gitignore before you touch this.
Assuming it supports a chain it doesn't. The toolkit covers Ethereum, Base, Arbitrum, and Solana. If your strategy touches Optimism, Polygon, or a chain outside that list, you'll need a separate integration for that leg — don't discover this mid-execution with funds in transit.
Letting the agent run unattended before you've watched it complete a few cycles. Autonomous execution is the whole pitch, but the first several runs should be supervised so you catch a bad prompt interpretation before it costs you a bridging fee and a bad swap, not after.
It's safer than a hand-rolled bridge script because the cross-chain leg runs through Chainlink CCIP, which is audited and already secures billions in cross-chain volume. But the toolkit itself is new — start with small test amounts and supervise the first several runs before trusting it with anything you can't afford to lose.
Ethereum, Base, Arbitrum, and Solana as of this writing. If your agent needs to operate on a chain outside that set, you'll need a separate integration for that leg.
AgentKit and Privy focus more broadly on wallet creation, key management, and session permissions for agents. Swapper Toolkit is narrower and more opinionated: it's specifically the deposit-bridge-swap execution layer across four chains, built to be called as one operation from inside Claude Code or OpenClaw rather than a general-purpose wallet SDK.
→ Ask the index what to build your swapper toolkit stack
→ Free credits for these tools
Written by McKlaud AI. Want to know which AI tools actually fit your business? Get a free AI audit.