Cadence Protocol
Building the ERC Standard for Onchain Subscriptions

The Onchain Subscription
Infrastructure

An open ERC standard and full automation layer for recurring payments on Ethereum and EVM chains — pull payments, full state management, cross-chain — without intermediaries.

No spam. Early access updates only.

Launching on Ethereum Base Arbitrum OP Optimism Polygon
Accepted tokens
USDC
ETH
DAI
Any ERC-20
$650B+
Annual subscription revenue in the digital economy — none of it onchain. Yet.
ERC
Open standard — no vendor lock-in
5+
EVM chains at launch via CREATE2
0.25%
Protocol fee per collected payment

Recurring payments onchain
don't exist. Yet.

Two previous attempts to standardize onchain subscriptions have failed. Cadence is built to fix that — permanently.

ERC-1337 — Abandoned 2018

Meta-transaction dependency

Required offchain relayers to execute payments, introducing centralization, trust assumptions, and a single point of failure. No test cases were ever written. The proposal stagnated and was never finalized.

ERC-5643 — Too narrow

NFT-only scope

Built exclusively for NFT-based memberships. No pull payment mechanism, no state management (pause, grace period, retry), and no support for commercial SaaS-style subscriptions. A partial solution to a much bigger problem.

Feature ERC-1337 ERC-5643 Cadence
Native pull payments ✗ Requires relay ✗ None ✓ Fully onchain
State management ✗ None △ Basic ✓ Active / Paused / Cancelled / Expired / PastDue
ETH + ERC-20 support △ Partial ✗ None ✓ Currency-agnostic
Cross-chain payments ✗ None ✗ None ✓ ERC-7683 intents
Grace period & dunning ✗ None ✗ None ✓ Configurable per merchant
Automation layer ✗ None ✗ None ✓ Keeper + Gelato fallback
Status Stagnant Final (limited) In development

Three layers. One standard.

Cadence is not just a smart contract. It's a complete stack — an open standard, an automation service, and a developer toolkit.

Layer 1

ERC Standard

An open Solidity interface for onchain subscriptions. Deployable by anyone, auditable by everyone. Becomes the shared standard the ecosystem builds on — like ERC-20 for tokens.

Layer 2

Automation Service

The keeper layer that actually executes payments. Indexer, scheduler, executor, dunning manager, webhooks — all managed so merchants don't have to run their own infrastructure.

Layer 3

SDK & Tooling

TypeScript SDK, React hooks, CLI, subgraph, Foundry snippets. Drop-in integration for any EVM project. Built to match the DX expectations of modern developer tooling.

Built for the long run.

Every layer of Cadence is designed to be composable, permissionless, and production-grade.

ERC Standard

ISubscription

The core interface defines everything a subscription needs: who pays, how much, how often, and what happens when payment fails. Fully compatible with ERC-20, ERC-165, and ERC-7683 for cross-chain intents.

Subscribe, cancel, pause, resume — all from the subscriber's wallet
Pull collectPayment() callable by authorized keepers only
Optional extensions: Trial, Tiered plans, Discovery registry, Custom hooks
Deployed at the same address on all EVM chains via CREATE2
Reference implementation: Foundry, >95% test coverage
interface ISubscription {
struct Terms {
address token;
uint256 amount;
uint48  interval;
uint48  trialPeriod;
}
enum Status {
Active, Paused,
Cancelled, Expired,
PastDue
}
function subscribe(
address merchant,
Terms calldata terms
) external returns (bytes32);
function collectPayment(
bytes32 subId
) external returns (bool);
}
Automation Service

The Keeper Layer

A production-grade service that handles execution so merchants never have to. From indexing onchain events to dunning management — everything runs automatically.

Indexer: The Graph subgraph + Node.js custom indexer for real-time sync
Scheduler: Redis priority queue, polls every 60s, checks subscriber balance before execution
Executor: gas-optimized, batched transactions, Gelato Network as decentralized fallback
Dunning manager: configurable grace period + retry logic per merchant
Webhooks: Stripe-compatible HTTP notifications with HMAC signature verification
Merchant dashboard: MRR, ARR, churn rate, subscriber list, analytics
// Dunning flow (configurable)
Day 0
Payment fails → notify subscriber, status → PastDue
Day 3
Retry attempt 1 → second notification sent
Day 5
Retry attempt 2 → urgent notification
Day 7
Grace period ends → cancelSubscription() onchain
// Webhook payload (Stripe-compatible)
{
"type": "payment.collected",
"data": {
"subId": "0xabc...",
"amount": 49000000,
"token": "USDT"
}
}
SDK & Tooling

Built for developers.

From npm to CLI, Cadence is designed to integrate in minutes, not days. The same experience developers expect from Stripe or Alchemy — but fully onchain.

@cadenceprotocol/sdk — TypeScript SDK with viem/wagmi wrappers and React hooks
@cadenceprotocol/cli — deploy, manage, and inspect subscriptions from the terminal
Public subgraph on The Graph — query any subscription or payment history
OpenZeppelin-style base contract — drop into any Foundry or Hardhat project
Merchant API with key management, rate limiting, and webhook configuration
import { useSubscription }
  from '@cadenceprotocol/sdk';
const { subscribe, status } =
  useSubscription('0xMerchant...');
// Subscribe in one call
await subscribe({
token: USDC,
amount: 49_000_000, // $49
interval: 'monthly',
trial: '14d',
});
// Status is reactive
status; // → "Active"
Open Source · Built in Public

The protocol lives on GitHub.

The reference implementation — interface, contracts, tests — is fully open source and MIT licensed. Read the code, open an issue, propose a change. This is infrastructure for the commons.

Any recurring payment.
Any chain.

Cadence is currency-agnostic and chain-agnostic. If it recurs, it runs on Cadence.

🔧

Onchain SaaS

Monthly API access, RPC nodes, developer tools — billed in USDT or ETH, collected automatically, no invoices.

🏛

DAO Membership

Recurring dues for governance rights, token-gated access, or community benefits. Auto-cancel on non-payment.

✍️

Content Monetization

Newsletters, research, media — subscription-based monetization for creators without a payment processor.

🤖

AI Agent Economy

Agents paying agents — recurring micropayments between autonomous systems, fully onchain and permissionless.

🏪

Onchain Commerce

Box subscriptions, physical goods, recurring orders — managed natively in crypto for merchants on Shopify or custom storefronts.

🌐

Infrastructure Access

Streaming subscriptions for indexers, oracles, bridges — pay-as-you-subscribe for onchain infrastructure providers.

The window is open.
It won't stay open long.

Five converging forces make 2026 the exact moment to standardize onchain subscriptions.

2024–2025

Stripe re-enters crypto

Stripe relaunched crypto payments in 2024 and is actively building onchain payment rails. When Stripe integrates a subscription standard, it will move the entire merchant ecosystem with it.

2025–2026

Base reaches critical mass

Coinbase's Base chain has crossed meaningful TVL and daily active user thresholds. A subscription standard deployed on Base has immediate access to a distribution network of millions of Coinbase users.

2026

AI agents need payment rails

Autonomous AI agents are increasingly executing tasks that require recurring micropayments — to each other and to services. Onchain subscriptions are the native payment primitive for the agentic economy.

Now

Stablecoin infrastructure matures

USDT and USDC liquidity is now deep and reliable across all major EVM chains. Merchants can accept stablecoin subscriptions without meaningful exchange rate or liquidity risk for the first time.

Now

No incumbent standard exists

The two prior attempts (ERC-1337, ERC-5643) have both failed or been abandoned. The standard-setting race is still open. The first well-implemented, well-adopted ERC wins by default.

2026–2027

TradFi moves to crypto rails

Major financial institutions are actively exploring onchain settlement. A subscription standard today becomes the infrastructure they adopt tomorrow — the same way ERC-20 became the default for tokenized assets.

Every payment is a transaction.
Every transaction generates value.

Cadence captures value at the protocol level on every collected payment — while generating compounding stablecoin volume for the tokens it runs on.

Payment flow — from subscriber to merchant
👤
Subscriber
Holds USDT
Cadence Protocol
collectPayment()
🏪
Merchant
Receives USDT
💰
Protocol Fee
0.25% retained
$10M
Monthly volume → $25K/mo protocol revenue
$100M
Monthly volume → $250K/mo protocol revenue
$1B
Monthly volume → $2.5M/mo protocol revenue

Building the rails for the subscription economy.

We're looking for strategic partners who understand the infrastructure opportunity — stablecoin issuers, chain ecosystems, and fintech investors who want early positioning in the onchain subscription standard.

Where we are.
Where we're going.

Now — Q1 2026
Foundation
✓ ERC interface design + rationale
✓ Reference implementation (Foundry, 90+ tests)
Ethereum Magicians discussion open
Testnet deployment (Sepolia + Base Sepolia)
Q2 2026
Standard & Product
ERC submission + number assigned
cadenceprotocol.build site live
Automation Service beta (first merchants)
SDK on NPM + public subgraph
Q3–Q4 2026
Security & Scale
Formal security audit (Sherlock / Code4rena)
Mainnet launch across 5 chains
Immunefi bug bounty program
Ecosystem grants + early adopter integrations