TL;DR: Ethereum and Tron together still hold roughly 80% of all stablecoin supply, on infrastructure that was never designed for payments. Four new Layer 1s — Tempo (Stripe & Paradigm), Stable (Bitfinex/Tether-affiliated), Arc (Circle), and Plasma — exist to close that gap. All four are EVM-compatible and strip out the volatile gas token, but they disagree on almost everything else: which stablecoin they’re built around, how fast they finalize, and who they’re actually trying to win over. This piece lines them up side by side and tells you which one fits which job.
Why stablecoins needed their own chains
Stablecoins stopped being a trading side-note a while ago. Total supply sits at roughly $308B as of mid-August 2026 (Reap), up from about $27B at the end of 2020 — a roughly 12x move in under six years (Transak) — and still growing 14%+ year over year. Issuance is concentrated: USDT and USDC alone account for around 83% of it, per DefiLlama’s live stablecoin dashboard. But the number that actually matters for infrastructure decisions isn’t market cap, it’s transfer volume — on an adjusted basis that strips out bot and wash-trading activity, stablecoins moved roughly $9 trillion over the last 12 months, per a16z’s State of Crypto 2025 report — more than half of Visa’s throughput over the same period. Forecasts from Citi (~$1.9T market by 2030) and Standard Chartered (~$2T by end-2028) both assume that keeps climbing.
Here’s the mismatch: Ethereum and Tron together still carry an estimated 80.5% of all stablecoin supply by chain, per CoinGecko’s research desk, leaving roughly 197 other chains (per DefiLlama) to split what’s left. Neither Ethereum nor Tron was built for payments specifically — they’re general-purpose settlement layers that stablecoins happen to live on. That gap is what pulled in over $548M in disclosed 2025 funding across a new category of purpose-built payment chains, per BlockEden’s stablechains overview — Plasma, Tempo, Stable, Arc, and a few others (Codex and Noble are part of the same wave but aren’t covered here since Chainstack doesn’t run nodes for them yet).
Worth a note of caution before the hype takes over: Plasma broke into the top 8 chains by stablecoin supply within three months of its 2025 launch, and its adoption metrics have cooled noticeably since that peak — see DefiLlama’s live chain breakdown for where it sits today. A new chain showing up with a purpose-built design doesn’t automatically win distribution — see what a stablecoin actually is and how cross-border settlement uses them today for the underlying context this comparison builds on.
A payments chain and a generic smart-contract chain optimize for different things: fee predictability over fee-market auctions, deterministic sub-second finality over probabilistic confirmation, and transaction-type prioritization over first-come-first-served ordering. That’s the design brief all four chains below are answering.
Tempo — Stripe & Paradigm payments-first L1
Tempo is incubated by Stripe and Paradigm, with Paradigm co-founder Matt Huang leading the effort (see Paradigm’s own announcement). It’s the most throughput-aggressive of the four: a Reth SDK execution layer paired with Simplex consensus, ~600ms blocks, and a design target of sub-250ms finality at 100,000+ TPS.
- Dedicated payments lane — payment transactions get guaranteed blockspace at the protocol level, separate from general activity, so fees stay flat even when the network is busy
- Stablecoin-native gas — fees are paid in any USD stablecoin, no volatile gas token; Tempo targets roughly $0.001 per transaction
- Native Tempo Transactions — batch execution, fee sponsorship, scheduled execution, and WebAuthn/passkey signing on top of standard EVM compatibility
- Design partners — Deutsche Bank, DoorDash, Nubank, Revolut, and Shopify have all been named as design partners; infrastructure partners include Chainstack, BitGo, and Blockdaemon
Tempo mainnet went live March 18, 2026, alongside the Machine Payments Protocol, a new open standard for AI agent payments built with Stripe. A live network performance dashboard is public at perf.tempo.xyz. Who it’s for: fintechs and payment platforms that need the highest raw throughput and the tightest latency budget of the four — think card-network-scale settlement, not a single merchant integration. Chainstack already runs Tempo RPC nodes; the full architecture is in our Tempo deep dive, so this section doesn’t repeat it.
Stable — the lean USDT0 payments rail
Stable, built by the team behind USDT0 and backed by Bitfinex and Hack VC, takes the opposite approach from Tempo: instead of a broad feature set, it ships a deliberately minimal namespace built around one job — moving USDT0. It runs on StableBFT, a custom PoS consensus on a CometBFT base, with ~0.7s blocks and deterministic single-slot finality. Chain ID 988. Mainnet and the $STABLE token launched December 8, 2025.
There’s no trace_* namespace on Stable (all nine trace_ methods return -32601) — a direct consequence of keeping the surface area small rather than an oversight. That’s consistent with the chain’s whole pitch: fewer moving parts, less to secure, less to audit, for teams whose only requirement is a USDT0 settlement rail. Who it’s for: USDT0-centric flows and Bitfinex/Tether-ecosystem participants who don’t need a general-purpose smart contract platform bolted on. Chainstack runs Stable RPC nodes; see our full Stable deep dive for the leadership, funding, and architecture detail this section skips. Use code STABLE50 at signup for 50% off the Growth plan for three months.
Arc — Circle’s USDC-native L1
Arc is Circle’s own settlement layer for USDC, and as of this writing Arc mainnet is live, launched September 16, 2026, with a validator cohort that includes BlackRock, DTCC, Mastercard, Visa, and Circle itself. It runs on Reth execution with Malachite consensus — the Informal Systems-lineage BFT engine Circle brought in-house — producing sub-second, ~0.5s blocks with deterministic finality. Gas is paid natively in USDC.
- Chain ID — mainnet 5042 (0x13b2), testnet 5042002 — worth double-checking against Arc’s own docs before hardcoding into a config, since the two IDs are easy to mix up
- EIP-7708 — every native USDC transfer emits a system-address
Transferlog, so the log itself doubles as the payment ledger - Standard EVM surface — eth_*, debug_*, trace_*, txpool, net, web3, plus a custom
arcnamespace; debug/trace access is archive-node only - ERC-4337 account abstraction supported out of the box — bundlers, paymasters, session keys
Who it’s for: teams already inside the Circle/USDC orbit who want native issuer alignment rather than USDC-as-a-bridged-asset. Chainstack runs Arc RPC nodes; see our Arc deep dive for the full validator list, the EIP-7708 mechanics, and the ARC token status.
Plasma — Bitcoin-anchored, zero-fee USDT
Plasma is a Bitcoin-anchored EVM chain with its own native token, XPL, and the sharpest single feature of the four: a protocol-level paymaster that makes plain USDT transfers fee-free for the sender. Day-to-day consensus runs on PlasmaBFT, a HotStuff-inspired BFT protocol built for rapid finality — Plasma then periodically checkpoints its own chain state onto Bitcoin, so rewriting old Plasma history would also mean attacking Bitcoin itself. Mainnet beta went live September 25, 2025, with more than $2B in liquidity on day one — the fastest cold-start of this group. Plasma broke into the top 8 chains by stablecoin volume within three months, though — as flagged above — its adoption metrics have pulled back from that early peak since.
In June 2026, the team launched Plasma One, a mobile neobank — savings, a Visa card for everyday spend, and international USDT remittances, with fee tiers priced in XPL. It’s worth being precise about what this is: Plasma One is a consumer product built on top of the Plasma L1, not a pivot of the base chain itself. The L1 stays a settlement layer; Plasma One is one of the things settling on it.
Who it’s for: zero-fee USDT movement at scale today, and — via Plasma One specifically — consumer remittance and neobank-style use cases rather than backend payment infrastructure. Network details and RPC access are covered on Chainstack’s Plasma product page.
Side-by-side comparison
| Chain | Backer | Execution / consensus | Native gas asset | Mainnet | Design target |
|---|---|---|---|---|---|
| Tempo | Stripe & Paradigm | Reth SDK / Simplex | Any USD stablecoin | March 18, 2026 (live) | 100k+ TPS, sub-250ms finality |
| Stable | Bitfinex / Hack VC | Reth-class EVM / StableBFT | USDT0 | Dec 8, 2025 | ~0.7s blocks, single-slot finality |
| Arc | Circle | Reth / Malachite | USDC | Sept 16, 2026 (live) | ~0.5s blocks, deterministic finality |
| Plasma | Tether / Bitfinex ecosystem | Reth / PlasmaBFT + Bitcoin anchoring | XPL (USDT transfers fee-free via paymaster) | Sept 25, 2025 (beta) | Zero-fee USDT at scale |
All chain IDs, mainnet dates, and performance targets are worth re-verifying against each chain’s own docs before you rely on them — this table is a snapshot, not a permanent spec sheet.
Which chain for which use case
Skipping the abstract tradeoffs — here’s the direct version:
- Zero-fee USDT, real liquidity, live today → Plasma. Protocol-level paymaster, $2B+ in day-one liquidity, mainnet since September 2025.
- Sub-250ms finality and tens of thousands of TPS for a payments product → Tempo. Dedicated payments lane and Simplex consensus are built specifically for this.
- Native USDC, Circle-issuer alignment → Arc. Gas paid in USDC, Reth + Malachite, live mainnet with a bank-and-payments-network validator set.
- Minimal, USDT0-only settlement rail → Stable. Smallest namespace of the four, deterministic single-slot finality, nothing to configure beyond the payment path.
- Consumer-facing neobank rather than backend infra → Plasma One specifically, not the raw Plasma L1 — card spend, savings, and remittance in one app.
The RPC layer: building on any of the four
Whichever of these four you pick, the same problem shows up immediately: you need reliable, low-latency RPC access to actually build against it. Chainstack runs Tempo, Stable, Arc, and Plasma as Global Nodes today — all four are supported, not just theoretically compatible. See Chainstack’s stablecoin infrastructure page for how these fit into the broader picture alongside every other stablecoin rail Chainstack runs.
How to get a private RPC endpoint
Deploying a node for any of these four on Chainstack takes the same six steps as any other protocol — same console flow whether it’s Arc, Stable, Tempo, or Plasma.
- Log in to the Chainstack console (or create an account).
- Create a new project.
- Select Arc, Stable, Tempo, or Plasma as your blockchain protocol.
- Choose networks: Mainnet or Testnet.
- Deploy the node.
- Open Access and credentials and copy your HTTPS endpoint.
- All four expose a standard EVM JSON-RPC surface (
eth_*), so existing tooling — ethers.js, viem, wagmi — carries over with a chain-ID and RPC-URL swap. See Tempo methods, Stable methods, Arc methods, and Plasma methods. - Arc’s
debug_*/trace_*namespaces are archive-node only — a detail that matters if you’re building reconciliation tooling against the EIP-7708 transfer logs. - Stable has no
trace_*namespace at all — plan accordingly if your stack leans on call tracing. - Chainstack’s Global Node model applies across all four — same account, same billing, same latency-routing logic, regardless of which chain you’re pointed at.
Deployment options aren’t identical across the four yet, though — worth checking before you assume single-tenant infra is available on the chain you want:
- Tempo and Plasma — Global, Dedicated, and Self-Hosted are all live on both mainnet and testnet.
- Stable — Global and Self-Hosted are available; there’s no Dedicated Node option yet.
- Arc — Global is live on mainnet, but Dedicated and Self-Hosted are currently testnet-only. Mainnet just launched; single-tenant options haven’t caught up yet.
Conclusion
Tempo, Stable, Arc, and Plasma exist because Ethereum and Tron’s combined 80%+ share of stablecoin volume sits on chains that were never optimized for payments specifically. None of the four is a universal winner — each is built around a different actor: a payments company (Tempo), an issuer (Arc), a USDT0-specific rail (Stable), or a consumer-facing settlement layer that’s now spawned its own neobank (Plasma / Plasma One). Adoption curves in this category move fast in both directions, as Plasma’s own post-launch cooldown shows, so treat any comparison — this one included — as a snapshot rather than a permanent ranking. Whichever chain fits your use case, Chainstack already runs the RPC layer for it.
FAQ
A stablecoin-native L1 removes the volatile gas token (gas is paid in a stablecoin, or subsidized outright), and tunes consensus and block production for payment throughput and deterministic finality rather than general smart-contract composability. Being EVM-compatible just means it reuses Ethereum’s execution model and tooling — it doesn’t imply any of the payments-specific design choices.
Plasma does — XPL — though ordinary USDT transfers are subsidized to zero fee via a protocol-level paymaster. Tempo, Stable, and Arc all charge gas directly in a stablecoin (any USD stablecoin on Tempo, USDT0 on Stable, USDC on Arc) rather than a separate volatile token.
No. Plasma is the Bitcoin-anchored L1 that settles transactions. Plasma One, launched in June 2026, is a consumer neobank app — card spend, savings, remittances — built on top of that L1. Plasma One is a product running on Plasma, not a rebrand of the chain itself.
On paper, Tempo’s design target is the most aggressive at sub-250ms with a 100,000+ TPS ceiling. Arc and Stable both run sub-second deterministic finality (~0.5s and ~0.7s blocks respectively) as shipped, live numbers. Tempo’s mainnet has been live since March 2026, but its own public benchmark dashboard at perf.tempo.xyz was showing nightly runs in the ~17,000 TPS / ~1.7s block-time range as of this writing — worth checking that dashboard directly rather than citing the 100k+ TPS design target as a confirmed production number.
Yes, with minor per-chain caveats. All four expose a standard eth_* JSON-RPC surface. The gaps are namespace-specific: Stable has no trace_* methods at all, and Arc restricts debug_*/trace_* to archive nodes. Check each chain’s methods reference before assuming full parity.