DRAIN

Decentralized Runtime for AI Networks

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

⚡ 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)                      ║
║                                                                              ║
╚══════════════════════════════════════════════════════════════════════════════╝

🏦 2 On-Chain TXs	⚡ Zero Latency	💸 ~$0.04 Total Gas	🔐 No API Keys
Open + Close only	Off-chain vouchers	500x cheaper at scale	Cryptographic auth

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.

Problem	DRAIN Solution
Token volatility	USDC-only, predictable pricing
High fees	~$0.02 per tx on Polygon (varies: $0.015-0.025)
AI agents can't pay	First-class programmatic support
Credit card barriers	Permissionless crypto access

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

Role	What They Do	On-Chain Actions
Consumer	Pays for AI services	`open` (deposit), `close` (refund)
Provider	Delivers AI responses	`claim` (withdraw earnings)

Consumer Flow

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

Provider Flow

Receive Request: Validate voucher signature and amount
Deliver Service: Return AI response
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:

Provider Can...	How
Require minimum duration	Reject vouchers from channels < X hours
Recommend duration	Document in API: "We recommend 24h channels"
Claim anytime	No deadline until consumer calls `close()`

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

Asset	Network	Why
USDC	Polygon	Stable ($1), liquid ($500M+), low fees (~$0.02/tx, varies: $0.015-0.025)

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

🏪 DRAIN Marketplace

🚀 Launch Marketplace

The DRAIN Marketplace is the gateway to the agent-to-agent economy:

Feature	Description
Provider Directory	Browse all registered AI providers with real-time status
One-Click Payments	Open channels, chat with AI, pay in USDC
Model Selection	Choose from multiple models per provider
Search & Filter	Find providers by name, model, or capability
No Account Required	Just connect your wallet and start

🔗 Links:

Live App: believable-inspiration-production-b1c6.up.railway.app
Provider Directory: /directory
Marketing Page: github.com/kimbo128/DRAIN-marketplace-landing

For Providers: Register your AI service and get discovered by autonomous agents worldwide.

📖 Become a Provider Guide - Complete integration documentation

For Users: Pay for AI with crypto - no credit card, no subscription, no minimums.

Protocol Specification

DRAIN defines three components:

Component	Description
Smart Contract	Immutable escrow and settlement logic
Voucher Format	EIP-712 typed signatures for off-chain payments
API Standard	OpenAI-compatible interface with payment headers

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

Party	Protected Against	How
Consumer	Overcharging	Only signs amounts they agree to
Consumer	Non-delivery	Stops signing, refunds after expiry
Provider	Overspending	`amount ≤ deposit` enforced on-chain
Provider	Double-spend	USDC locked in contract, not wallet

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

Role	Cost
Consumer	~$0.02 open + provider rate + ~$0.02 close
Provider	~$0.02 claim gas, keeps 100% of fees
Protocol	Zero fees

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

❌	Why
Token	No speculation, no governance drama
Marketplace	Discovery is separate, built on top
Reputation system	Out of scope, can be layered
Upgradeable	Immutable contracts, no admin keys

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:

Tool	Description
`drain_providers`	Discover AI providers
`drain_balance`	Check wallet balance
`drain_open_channel`	Open payment channel
`drain_chat`	AI chat with payment
`drain_close_channel`	Close channel, get refund

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

Model	Input/1K Tokens	Output/1K Tokens	~Cost/Message
gpt-4o-mini	$0.000225	$0.0009	~$0.001 ✨
gpt-4o	$0.00375	$0.015	~$0.01
gpt-4-turbo	$0.015	$0.045	~$0.03
gpt-3.5-turbo	$0.00075	$0.00225	~$0.002

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:

Method	Best For	Link
DRAIN Marketplace	Humans browsing providers	Launch App
MCP Server	AI agents (auto-discovery)	npm package
Direct Address	Known provider integration	Use provider wallet address

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://believable-inspiration-production-b1c6.up.railway.app

Try DRAIN without writing code:

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

Development Status

Component	Status	Link
Smart Contract	✅ Complete	polygonscan
Test Suite (47 tests)	✅ Complete	`contracts/test/`
TypeScript SDK	✅ Available	`sdk/`
Reference Provider	✅ Online	Railway
MCP Server	✅ Published	npm
🏪 Marketplace	✅ LIVE	Launch App

Deployed Contracts

Network	Contract	Address
Polygon Mainnet	DrainChannel	`0x1C1918C99b6DcE977392E4131C91654d8aB71e64`
Polygon Amoy (Testnet)	DrainChannel	`0x61f1C1E04d6Da1C92D0aF1a3d7Dc0fEFc8794d7C`

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

Chain	Tx Cost	Finality	USDC Liquidity
Polygon	~$0.02 (varies: $0.015-0.025)	5 sec	$500M+ native

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

What if the provider doesn't deliver?

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.

What if the consumer stops paying?

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

Can I use ETH/MATIC instead of USDC?

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

Can I close a channel early?

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

When should providers claim?

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

What happens to unclaimed vouchers after 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:

Consumer opens channel at 10:00 AM
Consumer uses service, signs vouchers worth $5
Channel expires at 10:00 AM next day
Consumer might close at 2:00 PM (4 hours later)
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.

Can I top up a channel?

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

Related Projects

Project	Description	Link
🏪 DRAIN Marketplace	Live app for provider discovery & payments	Launch
Marketplace Info	Public marketing & documentation	GitHub
MCP Server	AI agent integration (Claude, Cursor)	npm
Reference Provider	Live DRAIN-compatible AI provider	API

Contributing

See CONTRIBUTING.md for guidelines.

License

MIT License – Attribution required.

Permissionless AI infrastructure for an open economy.

Name		Name	Last commit message	Last commit date
Latest commit History 88 Commits
contracts		contracts
demo		demo
docs		docs
mcp		mcp
provider		provider
sdk		sdk
.gitignore		.gitignore
.gitmodules		.gitmodules
CONTRIBUTING.md		CONTRIBUTING.md
Gemini_Generated_Image_r40rogr40rogr40r.png		Gemini_Generated_Image_r40rogr40rogr40r.png
LICENSE		LICENSE
README.md		README.md

License

kimbo128/DRAIN

Folders and files

Latest commit

History

Repository files navigation

DRAIN

⚡ Superior to Per-Request-Providers.

Why DRAIN?

Overview

How It Works

The Two Roles

Consumer Flow

Provider Flow

Channel Duration & Provider Protection

Vouchers Are Cumulative

Payment Currency

🏪 DRAIN Marketplace

Protocol Specification

Security Model

Voucher Format

Economics

What DRAIN Is NOT

Project Structure

MCP Server (Agent-to-Agent) ✅ VERIFIED

SDK Quick Start

Reference Provider

Available Models & Pricing

Provider Discovery

Demo & Examples

Development Status

Deployed Contracts

Getting Started

Test Coverage

Target Chain

FAQ

Related Projects

Contributing

License

About

Topics

Resources

License

Contributing

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Languages

Packages