Every payments-focused blockchain runs into the same design tension eventually: charge transaction fees in a volatile native token, and you’ve built settlement rails that are only as predictable as that token’s price chart. Stable starts from a different premise — built by the team behind USDT0, it makes the stablecoin itself the gas token, not just the thing people transact in.
Mainnet launched on December 8, 2025, alongside a token generation event for $STABLE, and the chain has spent the months since positioning itself as infrastructure purpose-built for USD₮ settlement — payroll, invoicing, remittances, sponsored transactions — rather than a general-purpose smart contract platform that happens to support stablecoins. This piece looks at what that actually means architecturally, who’s backing the chain, and what changes for anyone building or running infrastructure against it.
What is Stable?
Stable is an EVM-compatible Layer 1 (chain ID 988) that uses USDT0 as its native gas token instead of a separate volatile asset. Consensus runs on StableBFT, a proof-of-stake protocol built on CometBFT (Tendermint’s successor), currently producing blocks roughly every 0.7 seconds with deterministic, single-slot finality — a block is final the moment it’s included, with no reorg window to wait out.
Everything above the consensus layer is standard EVM: Solidity, Vyper, Foundry, Hardhat, ethers.js, and viem all work unchanged, and ERC-20/721/1155 contracts deploy without modification. Stable’s own documentation frames the chain around three builder profiles — payment teams, smart contract developers, and infrastructure operators — with use cases centered on peer-to-peer transfers, payroll runs, invoicing, sponsored (gasless) transactions, and confidential transfers still on the roadmap.
⏭ Skip ahead: If you’re mainly here for the RPC and infrastructure angle, jump to Getting RPC access to Stable.
The USDT0 decimal trap
USDT0 plays two roles on Stable, and the two roles don’t use the same number of decimals. As the native gas token, USDT0 follows the 18-decimal convention every EVM chain uses for its native asset — the same as ETH or wei on Ethereum. As a standard ERC-20 token, deployed at 0x779Ded0c9e1022225f8E0630b35a9b54bE713736 (the same address USDT0 uses on Mantle and Berachain via LayerZero’s cross-chain OFT design — not every LayerZero-connected chain shares it, so verify per chain before hardcoding it), it follows USDT’s usual 6-decimal convention.
That’s a factor of 1012 between the two representations of what a user experiences as “the same” balance — and it’s the single most common integration bug on Stable. A contract that reads a native balance and treats it as if it were reading the 6-decimal ERC-20 balance will be off by twelve orders of magnitude. Stable’s own porting guidance is specific about the failure modes: don’t mirror native balance in internal contract variables, avoid sending native USDT0 to address(0), and don’t rely on EXTCODEHASH for address-reuse detection — because ERC-20 allowance operations like transferFrom and permit can change a contract’s native balance without that contract’s code ever executing.
Concretely, this is the bug that ships if nobody catches it:
// Wrong: assumes the native balance and the ERC-20 form share decimals
uint256 nativeBalance = address(this).balance; // 18 decimals
uint256 erc20Balance = usdt0.balanceOf(address(this)); // 6 decimals
require(nativeBalance == erc20Balance, "balances should match");
// fails every time — off by a factor of 10^12, not a rounding error
Anyone porting a contract that was written for a chain where the native token and its ERC-20 wrapper share the same decimals — which is most chains — needs to re-audit any logic that assumed the two would line up.
Consensus: StableBFT, and the DAG-based roadmap
StableBFT is described in Stable’s documentation as a customized proof-of-stake consensus protocol built on CometBFT, tolerating up to one-third of validators failing or acting maliciously (standard BFT territory) while giving deterministic finality on inclusion — no forks, no probabilistic settlement the way Ethereum’s fork-choice rule works. In its current form, that’s what produces the ~0.7 second block times.
The documentation also lays out a planned successor architecture based on Autobahn’s PBFT-on-DAG design — decoupling transaction gossip from consensus gossip and routing transactions directly from broadcaster to proposer, which the docs describe as capable of a further 5x speed improvement over the current design. Internal testing cited there reports over 200,000 TPS for consensus alone in controlled environments. That number needs a caveat: it’s a lab result for the consensus layer in isolation, not a live mainnet throughput figure — the chain’s current stated target is 10,000+ TPS end to end, and the DAG migration itself is a roadmap item, not something running in production today.
What’s actually different from Ethereum
Stable’s docs are upfront that EVM compatibility doesn’t mean zero behavioral differences. The ones that matter most for anyone running infrastructure or writing integrations:
- No priority fees.
maxPriorityFeePerGasis accepted but ignored — always treated as 0. There’s no fee-based transaction ordering to design around. - No public mempool. Pending-transaction subscriptions and pending filters don’t return results, and the
txpool_*namespace responds but always reports an empty pool. Any payment-detection or invoicing system that watches for inbound pending transfers has to be rebuilt around confirmed-log watching viaeth_subscribeinstead — a real integration-pattern change, not a cosmetic one. - No Parity-style trace methods. All nine
trace_*methods return-32601. The supported replacement is thedebug_*namespace —debug_traceCall,debug_traceTransaction, anddebug_traceBlockByNumberwith a callTracer cover most of whattrace_*was used for. - Different proof format.
eth_getProofreturns Cosmos IAVL-style proofs rather than Ethereum’s Merkle-Patricia proofs — a reminder that Stable’s consensus stack descends from the Cosmos/Tendermint lineage even though its execution layer is EVM. - Bounded log queries.
eth_getLogsis capped at 10,000 blocks per query, and filters created against one backend on a load-balanced endpoint aren’t guaranteed to resolve against another — use explicit block ranges rather than relying on filter state persisting.
The mempool and trace differences are the two that break silently if you don’t test for them directly. Polling the pending pool always comes back empty:
const options = {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({jsonrpc: '2.0', method: 'txpool_content', id: 1})
};
fetch('https://stable-mainnet.core.chainstack.com/<KEY>', options)
.then(res => res.json())
.then(res => console.log(res)) // always { pending: {}, queued: {} }
.catch(err => console.error(err));
And the trace_*-to-debug_* swap in practice — this is the direct replacement for trace_transaction:
const options = {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({
jsonrpc: '2.0',
method: 'debug_traceTransaction',
id: 1,
params: ['0xTRANSACTION_HASH', {tracer: 'callTracer'}]
})
};
fetch('https://stable-mainnet.core.chainstack.com/<KEY>', options)
.then(res => res.json())
.then(res => console.log(res))
.catch(err => console.error(err));
| Property | Ethereum | Stable |
|---|---|---|
| Block time | ~12s | ~0.7s |
| Finality | Multiple confirmations, probabilistic | Single-slot, deterministic on inclusion |
| Gas token | ETH (18 decimals) | USDT0 (18 decimals native / 6 decimals as ERC-20) |
| Priority fees | maxPriorityFeePerGas active | Accepted, ignored — always 0 |
| Public mempool | Yes | No — txpool_* always reports empty |
trace_* methods | Supported on trace-enabled nodes | Unsupported — all nine return -32601 |
eth_getProof format | Merkle-Patricia | Cosmos IAVL-style |
🚀 None of this is a dealbreaker, but it does mean your indexer and payment-detection logic need chain-specific handling before they touch production — not after. Start building on Stable with 50% off the Growth plan for 3 months — use
STABLE50at signup.
Who’s behind Stable
Stable raised a $28 million seed round in mid-2025, co-led by Bitfinex and Hack VC, with participation from Franklin Templeton, eGirl Capital, Mirana, Castle Island Ventures, Susquehanna International Group, Nascent, Blue Pool Capital, BTSE, and KuCoin Ventures. PayPal Ventures joined as a strategic investor in September 2025. Leadership includes CEO Matthew Tabbiner, a former Partner at Introsight Advisors who has worked with institutions including Ontario Teachers’ Pension Plan and Galaxy Digital; CTO Sam Kazemian, known for founding the Frax stablecoin protocol; CFO Brian Mehler, who previously helped manage a roughly $1 billion blockchain fund as VP of Venture Investments at Block.one; and COO Thibault Reichelt, a former venture investor in Compound, dYdX, and Circle.
Mainnet went live on December 8, 2025 at 13:00 UTC, alongside the token generation event for $STABLE — a separate governance and validator-security token that coordinates staking and protocol decisions, distinct from USDT0, which stays purely the fee and settlement asset. The launch followed a two-phase pre-deposit campaign that reportedly drew more than $2 billion in deposits across over 24,000 wallets, and network governance runs through the nonprofit Stable Foundation, unveiled at the same time as the token.
Stable’s homepage also carries a “Trusted by industry leaders” strip naming Franklin Templeton, BTSE, Bitfinex, Tether, Susquehanna, PayPal Ventures, Mirana, KuCoin, and Bybit. Most of those names are already accounted for above as actual seed investors (BTSE and KuCoin via KuCoin Ventures included) — Tether and Bybit are the two on this strip without a disclosed investment, so treat only those two as a partnership/relationship of unspecified kind rather than a confirmed backer.
The ecosystem, so far
Stable’s mainnet is still under a year old. Total value locked sits at roughly $34 million as of this writing per DefiLlama’s Stable chain page — check that figure fresh rather than trusting this snapshot, since it moves fast on a chain this new. On the partnership side, reporting has covered a PayPal USD (PYUSD) integration onto Stable, along with reported ties to Anchorage and Standard Chartered around custody and payments. Stable has also shipped a StablePay payments product and an institutional USDT0 yield offering since mainnet launched.
The honest framing: the funding and the launch numbers are real, but eight months in, ecosystem maturity — indexers, monitoring tooling, third-party integrations — still lags the marketing on any new L1, and Stable is no exception.
Stable also isn’t the only bet placed on stablecoin-native settlement in this window. Plasma (XPL) — also Tether- and Bitfinex-backed — launched its own USDT-focused L1 mainnet beta on September 25, 2025, roughly three months ahead of Stable, with a zero-fee USDT transfer mode. Tempo, a Stripe and Paradigm collaboration that lets users pay gas in any of several supported stablecoins, followed with its own mainnet on March 18, 2026. Circle’s Arc, built around USDC rather than USDT, rounds out the field. The Plasma overlap is the more interesting data point: the same backers funding two chains chasing an overlapping thesis says more about how much capital is chasing USDT-native settlement specifically than either chain’s marketing does on its own.
| Chain | Gas token | Consensus base | Mainnet | Notable backers |
|---|---|---|---|---|
| Stable | USDT0 | StableBFT (CometBFT) | Dec 2025 | Bitfinex, Hack VC, Franklin Templeton, PayPal Ventures |
| Plasma (XPL) | USDT0 (zero-fee mode) | Bitcoin-anchored, EVM | Sep 2025 (beta) | Tether, Bitfinex |
| Tempo | Multiple stablecoins | Simplex (Commonware) + Reth | Mar 2026 | Stripe, Paradigm |
| Arc | USDC | Reth + Malachite | 2026 | Circle |
🚀 A chain this early in its life is exactly where infrastructure cost and reliability compound — a small team burning time on a flaky RPC endpoint is time not spent shipping. Code
STABLE50gets you 3 months at half price on the Growth plan — claim it here.
Getting RPC access to Stable
Stable‘s public RPC (rpc.stable.xyz) is rate-limited to 1,000 requests per 10 seconds per IP with no SLA — workable for testing, not something to build a production payment flow on.
Chainstack delivers Stable Mainnet RPC, but doesn’t run independent Stable node infrastructure itself. In practice, that means: Global Nodes are available self-serve for Stable Mainnet, with the debug, eth, net, rpc, txpool, and web3 namespaces enabled (no trace, consistent with the rest of this piece). Archive access is available at a basic level; Dedicated Nodes aren’t currently offered for this protocol. Testnet isn’t part of the managed offering at all — it’s reachable only through Chainstack Self-Hosted, running the stabled client, where both mainnet and testnet snapshots temporarily need about double their steady-state storage while the initial archive downloads and extracts.
How to get a Stable RPC endpoint on Chainstack
- Log in to the Chainstack console (or create an account).
- Create a new project.
- Select Stable as your blockchain protocol.
- Choose Mainnet.
- Deploy the node.
- Open Access and credentials and copy your HTTPS and WebSocket endpoints.
📖 Related read: for a side-by-side of RPC providers for Stable, see Top 6 Stable RPC providers for stablecoin infrastructure in 2026.
For the full method-level detail — which namespaces are enabled, exact error codes, and the trace_*-to-debug_* migration mapping — the reference docs are the source of truth: Stable tooling and Stable methods.
Conclusion
Stable is closer to the start of its production life than the middle of it — real capital, a working payments thesis, and the kind of USDT0-specific integration bugs (decimal mismatches, a missing mempool, unsupported trace calls) that only surface once you’re actually building against mainnet rather than reading the whitepaper. None of that looks like Ethereum tooling superficially breaking. It looks like Ethereum tooling working right up until, on one specific and well-documented set of edge cases, it doesn’t.
🚀 Ready to build on Stable?
STABLE50takes 50% off Growth for your first 3 months at signup.
FAQs
What is Stable’s chain ID?
Mainnet is chain ID 988 (0x3dc). Testnet uses a separate chain ID and is only reachable through Self-Hosted deployment, not as a managed Global Node.
Is USDT0 the same token as USDT?
Not exactly. USDT0 is Tether’s cross-chain OFT version of USDT, deployed at the same contract address across several chains via LayerZero. On Stable it plays two roles at once: 18 decimals as the native gas token, and 6 decimals through its ERC-20 form — the mismatch that causes most Stable integration bugs.
Does Stable have a public mempool?
No. Pending-transaction subscriptions and filters don’t return results, and the txpool_* namespace responds but always reports an empty pool. Payment-detection systems need to watch confirmed logs via eth_subscribe instead of watching for pending inbound transfers.
Can I use trace_call and other Parity-style trace methods on Stable?
No. All nine trace_* methods return -32601. Use the debug_* namespace instead — debug_traceCall, debug_traceTransaction, and debug_traceBlockByNumber with a callTracer cover most of the same ground. See Stable methods for the full mapping.
What consensus mechanism does Stable use?
StableBFT, a proof-of-stake protocol built on CometBFT, currently producing blocks roughly every 0.7 seconds with deterministic, single-slot finality. A planned DAG-based successor is on the roadmap but not yet running in production.
Who backs Stable?
A $28 million seed round co-led by Bitfinex and Hack VC, with Franklin Templeton, eGirl Capital, Mirana, Castle Island Ventures, Susquehanna International Group, Nascent, Blue Pool Capital, BTSE, and KuCoin Ventures participating. PayPal Ventures joined later as a strategic investor. Mainnet and the $STABLE token launched together on December 8, 2025.
Additional resources
- Chainstack introduces Stable Mainnet support
- Top 6 Stable RPC providers for stablecoin infrastructure in 2026
- Migrate your Stable RPC to Chainstack
- Stable tooling documentation
- Stable methods reference
- Stable mainnet information (official docs)
- Stablescan — Stable block explorer
- $STABLE tokenomics (official docs)