DRAIN

Decentralized Runtime for AI Networks

An open protocol for trustless, streaming micropayments between AI consumers and providers.

ERC-8190: This protocol is being formalized as an Ethereum standard — Payment Channels with Signed Vouchers. The ERC defines the minimal interface for unidirectional payment channels using EIP-712 signed vouchers, complementary to ERC-8183 (Agentic Commerce).

⚡ Superior to Per-Request-Providers.

╔══════════════════════════════════════════════════════════════════════════════╗
║                           1000 AI REQUESTS                                   ║
╠══════════════════════════════════════════════════════════════════════════════╣
║                                                                              ║
║   DRAIN              │  Per-Request Payments (x402, etc.)                    ║
║   ─────              │  ────────────────────────────────                     ║
║   2 transactions     │  1000 transactions                                    ║
║   ~$0.04 gas         │  ~$20+ gas                                            ║
║   0ms latency        │  2-5 sec per request                                  ║
║   1 wallet popup     │  1000 wallet popups (or API key)                      ║
║                                                                              ║
╚══════════════════════════════════════════════════════════════════════════════╝

Why DRAIN?

Existing decentralized AI protocols require holding volatile tokens, creating speculation dynamics that overwhelm utility. Meanwhile, 78% of the world lacks credit cards, and AI agents can't have bank accounts.

DRAIN fills this gap: stablecoin micropayments without tokens, complexity, or intermediaries.

Overview

DRAIN enables permissionless, pay-per-token AI inference without intermediaries. Users open payment channels with USDC, stream requests to any compatible provider, and settle on-chain only when needed.

Core Principles:

• Minimal – The protocol defines only what's necessary
• Permissionless – Anyone can be a provider or consumer
• Trustless – Cryptography replaces trust
• Immutable – No admin keys, no upgrades, no fees

How It Works

DRAIN is like a prepaid card for AI: deposit USDC, use it across requests, withdraw the remainder.

┌──────────────────────────────────────────────────────────────────┐
│                        Off-Chain (Fast & Free)                   │
│                                                                  │
│    Consumer                                      Provider        │
│        │                                             │           │
│        │───────── Request + Voucher ────────────────►│           │
│        │◄──────── AI Response ───────────────────────│           │
│        │───────── Request + Voucher ────────────────►│           │
│        │◄──────── AI Response ───────────────────────│           │
│        │                    ...                      │           │
│                                                                  │
└────────┼─────────────────────────────────────────────┼───────────┘
         │                                             │
         │              On-Chain (Rare)                │
         ▼                                             ▼
┌──────────────────────────────────────────────────────────────────┐
│                        DRAIN Contract                            │
│                                                                  │
│     open(provider, amount, duration)    →  Lock USDC             │
│     claim(channelId, amount, signature) →  Pay provider          │
│     close(channelId)                    →  Refund remainder      │
└──────────────────────────────────────────────────────────────────┘

The Two Roles

Consumer Flow

1. Open Channel: Deposit USDC for a specific provider and duration (~$0.02 gas, ~5 sec finality)
2. Use Service: Send requests with signed vouchers (free, off-chain, $0.000005 per request)
3. Close Channel: Withdraw unused USDC after expiry (~$0.02 gas, ~5 sec finality)

Provider Flow

1. Receive Request: Validate voucher signature and amount
2. Deliver Service: Return AI response
3. Claim Payment: Submit highest voucher to get paid (~$0.02 gas, ~5 sec finality)

Channel Duration & Provider Protection

The consumer sets the channel duration when opening (e.g., 24h). But providers control their requirements:

Key insight: Even after channel expiry, the provider can claim as long as the consumer hasn't closed. The consumer must actively call close() – it's not automatic.

Vouchers Are Cumulative

Each voucher contains the total amount spent, not the increment:

Request 1: voucher.amount = $0.10  (total spent so far)
Request 2: voucher.amount = $0.25  (total, not $0.15 increment)
Request 3: voucher.amount = $0.40  (total, not $0.15 increment)

Provider only needs to claim the last voucher to receive full payment.

Payment Currency

USDC on Polygon can be bridged from Ethereum, Base, Arbitrum via Circle CCTP.

Handshake58 Marketplace

The official DRAIN marketplace is Handshake58 - a provider directory where AI agents can discover and pay for AI inference.

For AI Agents

Install the MCP Server and start using AI with crypto payments:

npm install -g drain-mcp

Configure in Claude Desktop or Cursor:

{
  "mcpServers": {
    "drain": {
      "command": "drain-mcp",
      "env": {
        "DRAIN_PRIVATE_KEY": "your-polygon-wallet-key"
      }
    }
  }
}

That's it! The MCP server auto-discovers providers from Handshake58.

Agent-Oriented Endpoints

Protocol Specification (ERC-8190)

DRAIN implements ERC-8190: Payment Channels with Signed Vouchers — an Ethereum standard for streaming micropayments via EIP-712 signed vouchers.

The protocol intentionally excludes provider discovery, reputation systems, dispute resolution, and governance. See ERC-8183 (Agentic Commerce) and ERC-8004 (Trustless Agents) for complementary standards.

Full specification: See contracts/ for the Solidity implementation and the ERC-8190 draft for the formal standard.

Security Model

EIP-712 signatures with chainId and verifyingContract prevent replay attacks. OpenZeppelin ECDSA provides malleability protection.

Voucher Format

// EIP-712 typed data
struct Voucher {
    bytes32 channelId;
    uint256 amount;  // Cumulative total spent
    uint256 nonce;   // Incrementing per voucher
}

Consumer signs vouchers off-chain. Provider submits latest voucher to claim payment.

Economics

Total overhead: <$0.05 per session regardless of usage.

Minimum Deposit Recommendations:

• $0.10: Testing (40% gas overhead, ~100 messages)
• $0.50: Recommended minimum (8% gas overhead, ~500 messages)
• $1.00: Optimal (4% gas overhead, ~1000 messages)
• $5.00: Best value (0.8% gas overhead, ~5000 messages)

See Test Results for verified cost data.

What DRAIN Is NOT

Project Structure

drain/
├── contracts/                  # Solidity smart contracts
│   ├── src/DrainChannel.sol    # Core payment channel contract
│   ├── test/                   # 47 Foundry tests
│   └── script/                 # Deploy scripts
├── sdk/                        # TypeScript SDK
│   ├── src/consumer.ts         # Consumer: open, sign, close
│   └── src/provider.ts         # Provider: verify, claim
├── provider/                   # Reference AI Provider
│   ├── src/index.ts            # Express server (OpenAI-compatible)
│   └── src/drain.ts            # Voucher validation
├── mcp/                        # MCP Server for AI Agents
│   ├── src/index.ts            # MCP server entry point
│   └── src/tools/              # drain_chat, drain_balance, etc.
└── demo/                       # AI-optimized examples
    ├── README.md               # Quick start for AI agents
    └── simple-demo.ts          # Minimal code example

MCP Server (Agent-to-Agent) ✅ VERIFIED

DRAIN includes an MCP (Model Context Protocol) server that enables AI agents to autonomously pay for AI services.

✅ Successfully tested with Claude Desktop - An AI agent autonomously opened a $0.10 channel and made AI inference requests, proving the agent-to-agent payment economy works without human intervention.

Test Results: $0.000005 per request, 20,000 requests possible with $0.10 channel. See Test Results and Comparison with Credit Cards for detailed metrics.

npm install -g drain-mcp

Configure in Cursor or Claude:

{
  "mcpServers": {
    "drain": {
      "command": "npx",
      "args": ["-y", "drain-mcp"],
      "env": {
        "DRAIN_PRIVATE_KEY": "0x..."
      }
    }
  }
}

Available Tools:

See mcp/README.md for full documentation.

SDK Quick Start

npm install @drain-protocol/sdk viem

import { createDrainConsumer, CHAIN_IDS } from '@drain-protocol/sdk';

// Open channel, sign vouchers, close when done
const consumer = createDrainConsumer(walletClient, account, {
  chainId: CHAIN_IDS.POLYGON_MAINNET,
});

await consumer.approveUsdc('10');
const { channelId } = await consumer.openChannel({
  provider: '0x...',
  amount: '10',
  duration: '24h',
});

const voucher = await consumer.signVoucher(channelId, '0.50');
// Send voucher to provider...

See sdk/README.md for full documentation.

Reference Provider

OpenAI-compatible API server that accepts DRAIN payments.

🟢 Live Provider: https://drain-production-a9d4.up.railway.app/v1/pricing

Available Models & Pricing

Prices include 50% margin over OpenAI base rates

Run your own:

cd provider
cp env.example .env  # Configure OPENAI_API_KEY, PROVIDER_PRIVATE_KEY
npm install
npm run dev

Endpoints:

GET  /v1/pricing          → View pricing per model
GET  /v1/models           → List available models  
POST /v1/chat/completions → Chat (with X-DRAIN-Voucher header)

DRAIN Headers:

# Request
X-DRAIN-Voucher: {"channelId":"0x...","amount":"1000000","nonce":"1","signature":"0x..."}

# Response
X-DRAIN-Cost: 8250
X-DRAIN-Total: 158250
X-DRAIN-Remaining: 9841750

See provider/README.md for full documentation.

Provider Discovery

DRAIN is a permissionless protocol - anyone can be a provider. Multiple discovery options:

The marketplace is optional - DRAIN protocol works standalone with any provider address.

Demo & Examples

Quick Start for AI Agents: See demo/README.md for machine-readable examples.

Live Demo: https://www.handshake58.com

Try DRAIN without writing code:

1. Connect Wallet – MetaMask on Polygon Mainnet
2. Choose Provider & Model – Select from available AI models
3. Open Channel – Deposit USDC ($0.10 minimum recommended)
4. Chat – Each message signs a voucher and calls the real AI ($0.000005 per request)
5. Close Channel – Get unused USDC refunded

Development Status

Deployed Contracts

DrainChannelV2 is the production contract used by Handshake58 and the ERC-8190 reference implementation. It adds cooperative close and optional platform fees over V1.

Getting Started

git clone https://github.com/kimbo128/DRAIN.git
cd DRAIN/contracts

# Install Foundry if needed: https://book.getfoundry.sh
forge build
forge test -vvv

Test Coverage

forge test --gas-report  # Gas optimization
forge coverage           # Line coverage

Target Chain

Why Polygon?

• Native USDC with Circle CCTP bridging
• 5-second finality enables 10-minute challenge periods (300 blocks)
• Proven infrastructure, no reorgs
• Low gas costs (~$0.02 per transaction)

Future chains via CREATE2 for identical addresses.

FAQ

Stop signing vouchers. Your USDC stays locked until expiry, then you can close the channel and get a full refund. The provider can only claim what you've signed.

Provider stops delivering service and claims the last valid voucher. The consumer's deposit covers all signed vouchers.

No. DRAIN v1 supports only USDC on Polygon. This keeps the protocol simple and prices predictable.

No. Channels have a fixed duration (e.g., 24h) to protect providers. After expiry, unused funds are refundable.

Recommended: when accumulated earnings exceed ~$10 (to amortize ~$0.02 gas). Providers can claim at any time – before, during, or after channel expiry.

Providers are protected by the channel duration. Here's the timeline:

Channel Open → Provider can claim (anytime) → Channel Expiry → Consumer can close
     │                    │                        │                  │
     └────────────────────┴────────────────────────┴──────────────────┘
                    Provider can claim throughout this entire period

• Provider can claim: From channel open until consumer calls close()
• Consumer can close: Only AFTER channel expiry
• The gap is your protection: Even after expiry, if the consumer doesn't immediately close, you can still claim

Example with 24h channel:

1. Consumer opens channel at 10:00 AM
2. Consumer uses service, signs vouchers worth $5
3. Channel expires at 10:00 AM next day
4. Consumer might close at 2:00 PM (4 hours later)
5. Provider can claim anytime from 10:00 AM Day 1 until 2:00 PM Day 2 (28 hours!)

Best practice: Set up monitoring to claim before expiry, but know you have a buffer.

No. Open a new channel instead. This keeps the protocol simple and avoids edge cases.

Related Projects

Contributing

See CONTRIBUTING.md for guidelines.

License

MIT License – Attribution required.