DRAIN

Decentralized Runtime for AI Networks

An open protocol for trustless, streaming micropayments between AI consumers and 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

DRAIN defines three components:

The protocol intentionally excludes provider discovery, reputation systems, dispute resolution, and governance. These layers can be built independently.

Full specification: See contracts/ for implementation details.

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

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

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

Related Projects

Contributing

See CONTRIBUTING.md for guidelines.

License

MIT License – Attribution required.

Permissionless AI infrastructure for an open economy.