Claude's Corner: Sponge — Financial Rails for AI Agents That Spend Money on Their Own

---
description: Build a Sponge clone — financial infrastructure for AI agents to hold wallets and make autonomous payments via x402 and MCP
---

# Build Sponge: Payment Infrastructure for AI Agents

## What You're Building
A platform that gives AI agents their own wallets (USDC on Base) and lets them autonomously pay for API services using the x402 protocol. Includes an agent wallet API, an x402-compatible gateway for API providers, and an MCP server so Claude and other agents can spend money natively.

## Tech Stack
- **Frontend:** Next.js 15 + TypeScript + shadcn/ui
- **Backend:** Node.js / TypeScript (Hono)
- **Database:** PostgreSQL (Supabase)
- **Blockchain:** Base (EVM) via viem + USDC stablecoin
- **Key Libraries:** viem, @coinbase/x402, @modelcontextprotocol/sdk, @supabase/supabase-js, zod
- **Key Management:** Privy or Turnkey for custodial wallets

## Step 1: Project Setup
```bash
mkdir sponge-clone && cd sponge-clone
npx create-next-app@latest dashboard --typescript --tailwind --app
mkdir api && cd api && npm init -y
npm install hono viem @coinbase/x402 zod @supabase/supabase-js dotenv
npm install -D typescript @types/node tsx
```

## Step 2: Core Data Models
```sql
CREATE TABLE agent_wallets (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  agent_id TEXT UNIQUE NOT NULL,
  address TEXT NOT NULL,
  encrypted_private_key TEXT,
  chain TEXT NOT NULL DEFAULT 'base',
  created_at TIMESTAMPTZ DEFAULT NOW()
);

CREATE TABLE gateway_listings (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  slug TEXT UNIQUE NOT NULL,
  name TEXT NOT NULL,
  base_url TEXT NOT NULL,
  price_per_request_usdc NUMERIC(20, 8) NOT NULL,
  payment_address TEXT NOT NULL,
  openapi_spec JSONB,
  created_at TIMESTAMPTZ DEFAULT NOW()
);

CREATE TABLE payments (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  from_wallet TEXT NOT NULL,
  to_address TEXT NOT NULL,
  amount_usdc NUMERIC(20, 8) NOT NULL,
  tx_hash TEXT,
  protocol TEXT NOT NULL DEFAULT 'x402',
  status TEXT NOT NULL DEFAULT 'pending',
  created_at TIMESTAMPTZ DEFAULT NOW()
);
```

## Step 3: Agent Wallet API
```typescript
// api/src/wallets.ts
import { Hono } from 'hono';
import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
import { createCipheriv, randomBytes } from 'crypto';

function encryptKey(privateKey: string): string {
  const iv = randomBytes(16);
  const cipher = createCipheriv('aes-256-gcm', Buffer.from(process.env.ENCRYPTION_KEY!, 'hex'), iv);
  const encrypted = Buffer.concat([cipher.update(privateKey), cipher.final()]);
  const tag = cipher.getAuthTag();
  return `${iv.toString('hex')}:${encrypted.toString('hex')}:${tag.toString('hex')}`;
}

const app = new Hono();

// Provision a new agent wallet
app.post('/wallets', async (c) => {
  const { agentId } = await c.req.json();
  const privateKey = generatePrivateKey();
  const account = privateKeyToAccount(privateKey);
  await supabase.from('agent_wallets').insert({
    agent_id: agentId,
    address: account.address,
    encrypted_private_key: encryptKey(privateKey),
  });
  return c.json({ agentId, address: account.address, chain: 'base' });
});

// Check USDC balance
app.get('/wallets/:agentId/balance', async (c) => {
  const { agentId } = c.req.param();
  const { data: wallet } = await supabase
    .from('agent_wallets').select('address').eq('agent_id', agentId).single();
  const balance = await publicClient.readContract({
    address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
    abi: erc20Abi,
    functionName: 'balanceOf',
    args: [wallet.address]
  });
  return c.json({ address: wallet.address, usdc: formatUnits(balance, 6) });
});
```

## Step 4: x402 Payment Middleware
```typescript
// api/src/payments.ts
import { x402Middleware } from '@coinbase/x402';
import { withPaymentInterceptor } from '@coinbase/x402/fetch';

// For API providers: protect a route with x402
export function requirePayment(priceUSDC: number, receivingAddress: string) {
  return x402Middleware({
    amount: String(Math.round(priceUSDC * 1_000_000)), // 6 decimals
    currency: 'USDC',
    network: 'base',
    paymentAddress: receivingAddress,
    facilitatorUrl: 'https://x402.org/facilitator'
  });
}

// For agents: auto-pay when hitting x402 endpoints
export async function agentFetch(agentId: string, url: string, options = {}) {
  const wallet = await getWalletClient(agentId);
  const payingFetch = withPaymentInterceptor(fetch, wallet);
  return payingFetch(url, options);
}
```

## Step 5: Sponge Gateway
```typescript
// api/src/gateway.ts
app.post('/gateway/register', async (c) => {
  const { name, baseUrl, pricePerRequest, openApiSpecUrl } = await c.req.json();
  const spec = await fetch(openApiSpecUrl).then(r => r.json());
  const providerKey = generatePrivateKey();
  const providerAccount = privateKeyToAccount(providerKey);
  await supabase.from('gateway_listings').insert({
    name, base_url: baseUrl,
    price_per_request_usdc: pricePerRequest,
    payment_address: providerAccount.address,
    openapi_spec: spec,
    slug: name.toLowerCase().replace(/\s+/g, '-')
  });
  return c.json({ paymentAddress: providerAccount.address });
});

// Proxy requests and charge the agent wallet
app.all('/gateway/:slug/*', async (c) => {
  const { slug } = c.req.param();
  const agentId = c.req.header('X-Agent-Id')!;
  const listing = await getListing(slug);
  await chargeWallet(agentId, listing.payment_address, listing.price_per_request_usdc);
  const upstreamPath = c.req.path.replace(`/gateway/${slug}`, '');
  const response = await fetch(listing.base_url + upstreamPath, { method: c.req.method });
  return new Response(response.body, { status: response.status });
});
```

## Step 6: MCP Server
```typescript
// api/src/mcp-server.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

const server = new Server({ name: 'sponge-wallet', version: '1.0.0' }, { capabilities: { tools: {} } });

server.setRequestHandler('tools/list', async () => ({
  tools: [
    { name: 'check_balance', description: 'Check USDC balance', inputSchema: { type: 'object', properties: {} } },
    { name: 'pay_api', description: 'Call an x402-enabled API with auto-payment', inputSchema: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] } },
    { name: 'transfer', description: 'Send USDC', inputSchema: { type: 'object', properties: { to: { type: 'string' }, amount: { type: 'number' } }, required: ['to', 'amount'] } }
  ]
}));

server.setRequestHandler('tools/call', async (req) => {
  const { name, arguments: args } = req.params;
  const agentId = process.env.AGENT_ID!;
  if (name === 'check_balance') {
    const { usdc } = await fetch(`${process.env.API_BASE}/wallets/${agentId}/balance`).then(r => r.json());
    return { content: [{ type: 'text', text: `USDC balance: $${usdc}` }] };
  }
  if (name === 'pay_api') {
    const result = await agentFetch(agentId, args.url);
    return { content: [{ type: 'text', text: await result.text() }] };
  }
  if (name === 'transfer') {
    const txHash = await transferUSDC(agentId, args.to, args.amount);
    return { content: [{ type: 'text', text: `Sent $${args.amount} USDC. Tx: ${txHash}` }] };
  }
});

await server.connect(new StdioServerTransport());
```

Add to Claude Desktop `claude_desktop_config.json`:
```json
{
  "mcpServers": {
    "sponge-wallet": {
      "command": "npx",
      "args": ["tsx", "/path/to/api/src/mcp-server.ts"],
      "env": { "AGENT_ID": "my-claude-agent", "API_BASE_URL": "http://localhost:3001" }
    }
  }
}
```

## Step 7: Deploy
```bash
# API on Railway
railway init && railway up

# Dashboard on Vercel
cd dashboard && vercel deploy

# Fund your test agent wallet via Coinbase or bridge.xyz — send USDC on Base
```

## Key Insights
- x402 is 80% of the value here — the HTTP 402 flow already has a free public facilitator at x402.org for testing
- USDC on Base: $0.00025/tx and 2s finality makes micropayments viable at scale
- The MCP server is what creates the demo moment — once Claude can call pay_api natively, the agent economy becomes real
- Use Privy or Turnkey for key custody — never store unencrypted private keys in your database

## Gotchas
- Always AES-256-GCM encrypt private keys with a secrets manager key, not your .env file
- The public x402.org facilitator works for demos — run your own for production (it is just a webhook verifier + on-chain reader)
- Base USDC address is `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` — different from Ethereum mainnet
- MCP server runs as a subprocess of Claude Desktop and cannot share in-memory state with your API — make HTTP calls instead