Stablecoin L1 RPC Guide 2026: Chain IDs, Endpoints, Gas and Finality on Arc, Tempo, Plasma and Stable

Four Layer 1 chains now compete to settle dollars, and each has redefined a JSON-RPC method you have relied on for years. On Arc, eth_getBalance returns USDC. On Tempo it returns a constant placeholder for every account, because there is no native asset to count. On Stable a priority fee is silently discarded, and on Arc a fee below 20 Gwei makes the transaction vanish without a receipt. Only Plasma behaves like the EVM you know, and it charges gas in a token your users may never have held.

Arc's public mainnet went live on 16 September 2026 with Circle, Visa, Mastercard and BlackRock among its validators, and it joins Tempo (Stripe and Paradigm, March 2026), Plasma (Tether-aligned, September 2025) and Stable (Bitfinex-backed, December 2025) as the fourth stablecoin L1, or stablechain, with a public mainnet. If you are integrating stablecoin payments in 2026 you will probably touch more than one of them. This guide puts chain IDs, endpoints, gas models and finality side by side, then sends one USDC or USDT transfer on each and calls out what breaks when you port code from Ethereum.

Every chain ID, gas price and block time below was read from the public RPC endpoints on 21 September 2026, and every contract address was checked with an eth_call.

The Four Stablechains at a Glance

Stable coined "Stablechain" for itself, but the label fits all four: a Layer 1 whose reason to exist is moving dollar stablecoins, with a BFT validator set, sub-second or one-second blocks and full EVM compatibility.

The block times are measured: 1,000 Arc blocks spanned 508 seconds, 100,000 Tempo blocks averaged 0.557 seconds, Plasma blocks averaged 1.0 second and Stable blocks averaged 0.7 seconds.

What Each Chain Is For

The four chains look interchangeable in a feature table and are not. Each was built by a different stablecoin issuer or payments company to pull settlement onto rails it controls.

Arc is Circle's settlement layer for USDC. USDC is the gas token, Circle's StableFX handles foreign exchange across 20 or more local-currency stablecoins, and the launch announcement leads with tokenized funds (BlackRock's BUIDL, Circle's USYC) and agent payments over x402.

The validator set is a permissioned Proof-of-Authority cohort: Circle plus BlackRock, DTCC, Galaxy, Global Payments, ICE, Mastercard, MoneyGram, SBI Group, Standard Chartered, Sumitomo and Visa. Day-one integrations include Uniswap, Aave, Morpho, Binance, Coinbase, Kraken, MetaMask and Fireblocks. If your counterparties are institutions and your unit of account is USDC, Arc is the default.

Tempo is a payments network that happens to be a blockchain. Incubated by Stripe and Paradigm and run as an independent company with Matt Huang as CEO, it ships a token standard (TIP-20) with 32-byte memos and compliance policies, a transaction type (0x76) with fee sponsorship and batching, and the Machine Payments Protocol for agent-to-agent payments. There is no native token.

Validators are permissioned and include Stripe, Visa, Zodia Custody and MoneyGram. Production users include DoorDash, Deel, MoneyGram, Coupang, Kraken and OKX. Choose Tempo for payouts, payroll and invoicing where the memo and the sponsored fee matter more than DeFi composability.

Plasma is the USDT liquidity chain. It launched first, holds the most stablecoin supply of the four ($1.28 billion USD-pegged per DefiLlama, with 771 million USDT0 on-chain) and keeps the most conventional EVM: XPL gas, EIP-1559 with a burned base fee, EIP-7702 live, ERC-4337 EntryPoints deployed, and native Circle USDC alongside USDT0 since late August 2026.

Zero-fee USDT transfers exist but run through an API-keyed relayer that Plasma has not documented publicly. The validator set is still the "trusted validator launch" phase with no timeline for external validators. Choose Plasma when you want deep USDT liquidity and DeFi tooling that works unchanged.

Stable is the USDT-gas chain built for enterprise rails. USDT0 replaced gUSDT as the native gas token in February 2026, so the same asset pays fees and settles payments. Stable runs a CometBFT-derived consensus with 11 validators at equal weight, ships a guaranteed-blockspace lane for enterprise senders (live since v1.8.0 in August 2026) and a governance-registered gas waiver that lets a sponsor wrap a user's transaction at zero gas.

Backers are Bitfinex and Hack VC, with Tether and PayPal as investors and Paolo Ardoino as an advisor. Utilization is low today, roughly one transaction per block. Choose Stable when USDT is your settlement asset and you need reserved capacity.

Gas Models Compared

This is where the four diverge most, and where ported code fails first. The table shows what the public endpoint returned for eth_gasPrice on 21 September 2026 and what a simple transfer costs at that day's base fee.

Three of these need explanation.

Arc's 20 Gwei floor is a silent failure. The mempool drops any transaction whose maxFeePerGas is below 20 Gwei. eth_sendRawTransaction may still return a hash, but no receipt is ever produced and the transaction never appears in a block. Wallet code that reads eth_gasPrice from another chain's defaults, or that applies a 10% discount to a quote, hits this immediately. Clamp to the floor before signing.

Arc also publishes the next block's base fee in the parent header's extraData as an 8-byte big-endian value. eth_feeHistory on Arc shows every block pinned at exactly 20 Gwei right now because utilization is 2% to 8% and the EWMA has settled at the floor.

Tempo's fee comes out of a stablecoin you choose. There is no native balance. The protocol picks the fee token in this order: an explicit fee_token on a type 0x76 Tempo transaction, then the account default set through FeeManager.setUserToken on the precompile at 0xfeec000000000000000000000000000000000000, then the token being transferred if the call is transfer or transferWithMemo on a USD TIP-20, then pathUSD as the fallback. That last rule is what makes a plain EIP-1559 transfer() work with no setup: the fee is deducted from the USDT0 or USDC.e you are sending. A plain call to a non-token contract needs pathUSD in the account or an explicit fee token, or it fails.

Tempo also reprices state. A new account costs 250,000 gas and a new storage slot costs 250,000, so the first transfer to a fresh address is about 300,000 gas, six times a warm one.

Stable ignores tips. The protocol discards maxPriorityFeePerGas and any tip is lost rather than refunded, yet the public node returns 0.125 Gwei from eth_maxPriorityFeePerGas and folds it into eth_gasPrice. Build the fee yourself: read baseFeePerGas from the latest block, set maxFeePerGas to twice that and maxPriorityFeePerGas to zero. The base fee has sat at exactly 1 Gwei on every sampled block.

Plasma keeps Ethereum's fee model unchanged. Its base fee is 8 wei because the chain is lightly loaded, and a sender using a hard-coded 2 Gwei legacy gas price pays about 200 times the quoted price and still spends about $0.000012. Fee estimation code from Ethereum works. It needs XPL in the wallet, nothing more.

Finality Compared

All four use BFT consensus, so none of them has probabilistic finality in the Ethereum or Bitcoin sense. A block is either committed by a supermajority of validators or it does not exist. The practical differences are how long commitment takes and how the RPC reports it.

On Arc, Tempo and Stable a receipt is settlement. You can fire the webhook, credit the ledger and move on. Persist the block number and hash for audit, but there is no rollback path to write. Arc finalizes on inclusion, Tempo tells integrators to treat finalized as irreversible with no extra confirmations, and Stable calls it single-slot finality.

Plasma is the exception. In live samples the finalized block trailed latest by two to three blocks. Ask for the finalized tag rather than counting, or wait three confirmations if your client only counts.

The flip side of sub-second blocks is volume. Arc produces about 170,000 blocks a day and Tempo about 155,000. An indexer that polls eth_blockNumber and fetches blocks one at a time falls behind quickly; subscribe to newHeads over WebSocket instead. Arc and Plasma do not offer a public WebSocket endpoint, so on those two a subscription means a provider.

Chain IDs, Endpoints and Rate Limits

One curl per chain confirms you are talking to the right network. The Dwellir hostnames follow one pattern, so a config that works for one chain works for the others with the slug swapped.

for chain in arc tempo plasma stable; do
  curl -sS -X POST "https://api-${chain}-mainnet.n.dwellir.com/YOUR_API_KEY" \
    -H 'Content-Type: application/json' \
    -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'
  echo
done
# {"jsonrpc":"2.0","id":1,"result":"0x13b2"}   Arc    5042
# {"jsonrpc":"2.0","id":1,"result":"0x1079"}   Tempo  4217
# {"jsonrpc":"2.0","id":1,"result":"0x2611"}   Plasma 9745
# {"jsonrpc":"2.0","id":1,"result":"0x3dc"}    Stable 988

The public endpoints are fine for development and each has a catch in production.

• Arc https://rpc.mainnet.arc.io publishes no rate limit. A 300-item JSON-RPC batch returned -32005 rate limit exceeded on some items inside an HTTP 200 with no rate-limit headers, and the testnet returns -32011 request limit reached on a per-connection concurrency cap (x-ratelimit-limit: 1;w=1) that breaks viem's receipt polling unless you use a fallback transport. There is no public WebSocket from Circle; dRPC, QuickNode and Blockdaemon host partner endpoints under *.mainnet.arc.io.
• Arc on ChainList. Ignore the "ARC Mainnet" entry at chain ID 1243, an unrelated older network that outranks Circle's docs for "arc chain id". Circle's Arc is 5042. Dwellir's Arc endpoint follows Circle's full-provider profile: eth_*, net_*, web3_* and arc_getCertificate over HTTPS and WebSocket, with blocks, receipts and logs back to genesis.
• Tempo https://rpc.tempo.xyz and wss://rpc.tempo.xyz publish no rate limit for the RPC itself, though the separate Tempo API caps anonymous callers at 20 requests per minute. The public node exposes txpool_, trace_ and debug_ as well as eth_. Dwellir's Tempo endpoint runs an archive backend with trace, debug and txpool.
• Plasma https://rpc.plasma.to is labelled "rate limited and not for production systems" with no number given, and there is no public WebSocket at all; a WebSocket upgrade returns HTTP 400. Dwellir serves Plasma over HTTPS and WebSocket on full nodes with debug_ and txpool_.
• Stable https://rpc.stable.xyz documents 1,000 requests per 10 seconds per IP with HTTP 429 above that. The bigger catch is history: the public node is pruned to roughly the last 1.8 million blocks, about two weeks. A balance query at a block from February returned height 12151355 is not available, lowest height is 38429001. Anything older needs an archive provider. Stable also does not implement eth_getBlockReceipts, eth_createAccessList or debug_traceCall.

For the free public endpoint table across every chain Dwellir supports, see the public RPC endpoints page. For throughput on paid plans, the RPC provider rate limits comparison has the per-provider numbers.

One Transfer on Each Chain

Four transfers, four different shapes. Two are plain value sends, one is an ERC-20 call, and one is a token-standard call with a memo. Each snippet points at the Dwellir endpoint; swap in the public RPC to try it without a key.

Arc: send USDC as native value

USDC is the native asset, so a transfer is eth_sendRawTransaction with value set and no calldata. The trap is decimals. The native interface is 18 decimals, so 1 USDC is parseEther("1"), not parseUnits("1", 6). Circle's own docs contain a snippet that gets this wrong and sends a trillionth of a dollar.

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider(
  "https://api-arc-mainnet.n.dwellir.com/YOUR_API_KEY"
);
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY!, provider);

const FLOOR = ethers.parseUnits("20", "gwei"); // Arc's protocol floor. Below it the tx is dropped silently.
const block = await provider.getBlock("latest");
const doubled = block!.baseFeePerGas! * 2n;
const maxFeePerGas = doubled > FLOOR ? doubled : FLOOR; // Headroom above the floor if the EWMA rises.

const tx = await wallet.sendTransaction({
  to: "0xRecipient",
  value: ethers.parseEther("1"), // 1 USDC. Native USDC is 18 decimals.
  maxFeePerGas,
  maxPriorityFeePerGas: 0n,
});

const receipt = await tx.wait(1); // Final on inclusion. One confirmation is settlement.
console.log(receipt?.blockNumber, receipt?.gasUsed); // gasUsed 21000

The same balance is also an ERC-20 at 0x3600000000000000000000000000000000000000 with 6 decimals, for approve, transferFrom and Permit2 flows.

An ERC-20 transfer() costs about 49,000 gas and emits two Transfer logs for one movement: a 6-decimal one from the token contract and an 18-decimal one from the EIP-7708 system emitter at 0xffffFFFfFFffffffffffffffFfFFFfffFFFfFFfE. A native send emits only the system log. Indexers must filter on the emitter address, not topic0, or they double count.

Tempo: transfer a TIP-20 with a memo

Tempo has no native asset, so a stablecoin transfer is a contract call on a TIP-20 token. TIP-20 is a precompile-backed superset of ERC-20 with 6 decimals always, and it adds transferWithMemo(address,uint256,bytes32). A standard EIP-1559 transaction works, and the fee is taken from the token you are transferring, so the wallet needs nothing but USDT0.

import { createWalletClient, http, parseUnits, pad, stringToHex, defineChain } from "viem";
import { privateKeyToAccount } from "viem/accounts";

const tempo = defineChain({
  id: 4217,
  name: "Tempo",
  nativeCurrency: { name: "USD", symbol: "USD", decimals: 18 }, // No native asset. Fees are stablecoin-denominated.
  rpcUrls: { default: { http: ["https://api-tempo-mainnet.n.dwellir.com/YOUR_API_KEY"] } },
});

const client = createWalletClient({
  chain: tempo,
  transport: http(),
  account: privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`),
});

const USDT0 = "0x20c00000000000000000000014f22ca97301eb73";

const hash = await client.writeContract({
  address: USDT0,
  abi: [
    {
      name: "transferWithMemo",
      type: "function",
      stateMutability: "nonpayable",
      inputs: [
        { name: "to", type: "address" },
        { name: "amount", type: "uint256" },
        { name: "memo", type: "bytes32" },
      ],
      outputs: [{ type: "bool" }],
    },
  ],
  functionName: "transferWithMemo",
  args: ["0xRecipient", parseUnits("100", 6), pad(stringToHex("INV-12345"), { size: 32 })],
  maxPriorityFeePerGas: 0n,
});

Tempo's official viem/tempo client wraps this as client.token.transferSync and adds a feeToken option, which needs the type 0x76 Tempo transaction that ethers and Hardhat cannot produce.

Two rules survive whichever client you use. First, read balances with balanceOf, never eth_getBalance, which returns the same placeholder value for every account. Second, check the Transfer log's recipient before marking a payment delivered: since the T6 upgrade a transfer blocked by the receiver's policy still succeeds but credits the ReceivePolicyGuard contract instead.

Other USD tokens on mainnet include bridged USDC.e at 0x20c000000000000000000000b9537d11c60e8b50 and pathUSD at 0x20c0000000000000000000000000000000000000; there is no native Circle USDC on Tempo yet.

Plasma: a standard ERC-20 transfer of USDT0

Plasma is the one chain where Ethereum code runs unmodified. USDT is USDT0, an upgradeable ERC-20 at 0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb with 6 decimals, bridged in through LayerZero. Gas is XPL.

import { createWalletClient, createPublicClient, http, parseUnits, erc20Abi, defineChain } from "viem";
import { privateKeyToAccount } from "viem/accounts";

const plasma = defineChain({
  id: 9745,
  name: "Plasma",
  nativeCurrency: { name: "Plasma", symbol: "XPL", decimals: 18 },
  rpcUrls: { default: { http: ["https://api-plasma-mainnet.n.dwellir.com/YOUR_API_KEY"] } },
});

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const wallet = createWalletClient({ chain: plasma, transport: http(), account });
const client = createPublicClient({ chain: plasma, transport: http() });

const hash = await wallet.writeContract({
  address: "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb", // USDT0
  abi: erc20Abi,
  functionName: "transfer",
  args: ["0xRecipient", parseUnits("1", 6)],
});

// finalized trails latest by 2 to 3 blocks on Plasma
const receipt = await client.waitForTransactionReceipt({ hash, confirmations: 3 });
console.log(receipt.gasUsed); // about 61,000

Native Circle USDC is at 0x2d661C89D812261039AF9764eceaAee884f5F67F, also 6 decimals, with CCTP v2 support. The zero-fee USDT path is not something you broadcast: it is a signed authorization submitted to Plasma's relayer at api.relayer.plasma.to, which requires an API key and has no public documentation. Keep the paid-XPL path as the fallback.

Stable: send USDT0 as native value

Stable mirrors Arc's model with USDT0. The native interface is 18 decimals and the ERC-20 view at 0x779Ded0c9e1022225f8E0630b35a9b54bE713736 is 6 decimals, one balance behind two interfaces. The fee rule is the opposite of Arc's: there is no floor to clamp to, but the tip must be zero.

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider(
  "https://api-stable-mainnet.n.dwellir.com/YOUR_API_KEY"
);
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY!, provider);

const block = await provider.getBlock("latest");
const baseFee = block!.baseFeePerGas!; // 1 Gwei on every block sampled

const tx = await wallet.sendTransaction({
  to: "0xRecipient",
  value: ethers.parseUnits("1", 18), // 1 USDT0. Native units are 18 decimals.
  maxFeePerGas: baseFee * 2n,
  maxPriorityFeePerGas: 0n, // Tips are ignored and lost on Stable.
});

const receipt = await tx.wait(1); // Single-slot finality.
console.log(receipt?.gasUsed); // 21000, fee 0.000021 USDT0

Two indexing notes. The two views of a balance can differ by up to 0.000001 USDT0 because of fractional reconciliation, and that reconciliation emits Transfer events involving the reserve address 0x5113954bbC0eD721F1C68671EBa3d91e9e9bF7b5, which you should filter out. And the zero-gas transfers Stable advertises are not a protocol default: they require a governance-registered gas waiver that wraps the user's signed transaction and submits it to a marker address, with the mainnet waiver server URL still listed as TBD.

What Breaks When You Port From Ethereum

Most of the failures are in RPC handling rather than in Solidity. This table is the checklist to run before pointing an existing integration at any of the four.

The one that catches experienced teams is Arc's value-transfer rules. A send can revert even with a funded sender: to the zero address, to or from a blocklisted address (the transaction is still included and still consumes gas), to a precompile, or to an account that has already self-destructed. A forwarding pattern that assumes native value always lands does not hold. Simulate with eth_call before signing, and read the status field on every receipt.

Arc's docs also recommend testing with arc-anvil --network arc rather than stock Anvil, because a vanilla fork cannot reproduce the floor, the dual-decimal balance or the transfer rules.

Choosing Between Them

The gas model decides most of it.

• Your users hold USDC and your counterparties are institutions: Arc. Gas and settlement are the same asset, finality is under a second, and the validator list doubles as a compliance reference. Budget for eth_getLogs volume, because the dual-emitter model produces two Transfer logs for every ERC-20 movement.
• You are paying out to many people and need memos, sponsorship or agent payments: Tempo. The memo field, fee sponsorship and the Machine Payments Protocol are built in. Plan for the 0x76 transaction type and a viem-based stack, and fund pathUSD or set a fee token before calling non-token contracts.
• You need USDT liquidity and unmodified DeFi tooling: Plasma. The largest stablecoin balance of the four and the most standard EVM. Hold XPL for gas, use the finalized tag, and do not build on the zero-fee relayer until it is documented.
• USDT is your settlement asset and you want reserved capacity: Stable. Native USDT0 gas, single-slot finality and a guaranteed-blockspace lane. Set tips to zero and use an archive endpoint for anything older than two weeks.

Whichever you pick, the RPC layer is where the chain-specific behaviour shows up, and a provider that treats eth_getLogs or debug_traceTransaction as a 10x to 60x compute-unit multiplier will bill you for it. Dwellir runs all four mainnets and bills one request per response regardless of method. The Arc, Tempo and Stable provider comparisons have the per-provider pricing, and the network pages for Arc, Tempo, Plasma and Stable have the endpoints and FAQs.

FAQ

What is a stablechain?

A stablechain is a Layer 1 built around stablecoin settlement rather than a volatile native asset. Stable coined the term for itself, and it fits Arc, Tempo and Plasma too. All four are EVM chains with BFT consensus and sub-second or one-second blocks. The differences are what pays for gas and how the stablecoin is represented: Arc and Stable make USDC and USDT0 the native asset, Tempo has no native token and takes fees in any USD stablecoin, and Plasma keeps a conventional XPL gas token.

What are the chain IDs for Arc, Tempo, Plasma and Stable?

Arc mainnet is 5042 (0x13b2), Tempo mainnet is 4217 (0x1079), Plasma Mainnet Beta is 9745 (0x2611) and Stable mainnet is 988 (0x3dc). The testnets are Arc 5042002, Tempo Moderato 42431, Plasma 9746 and Stable 2201. All four values were confirmed with eth_chainId against the public endpoints on 21 September 2026.

Is chain ID 1243 Circle's Arc?

No. ChainList's entry for chain ID 1243, labelled ARC Mainnet, is an unrelated older network that happens to share the name and ranks near the top of Google for arc chain id. Circle's Arc mainnet is chain ID 5042 (0x13b2) and its testnet is 5042002. Verify with eth_chainId against rpc.mainnet.arc.io before adding the network to a wallet or config.

Do I need a native token to pay gas on these chains?

Only on Plasma, where gas is XPL. On Arc the gas is USDC and on Stable it is USDT0, so the stablecoin you are moving also pays the fee. Tempo has no native token at all: the fee comes out of any USD TIP-20 stablecoin with Fee AMM liquidity, defaulting to the token you are transferring or to pathUSD.

How many confirmations do I need on a stablechain?

One, on Arc, Tempo and Stable. All three use BFT consensus that finalizes a block when it commits, so a receipt is irreversible and there is no reorg path. Plasma also uses BFT finality but the finalized tag trails the head by two to three blocks, so wait for finalized or three confirmations before treating a payment as settled.

Why does eth_getBalance behave differently on each stablechain?

Because each chain represents its stablecoin differently. On Arc it returns the account's USDC in 18 decimals, and the same balance is an ERC-20 with 6 decimals. Stable works the same way with USDT0. On Tempo there is no native asset, so eth_getBalance returns a constant placeholder for every account and you must read balanceOf on the TIP-20 token. On Plasma it returns XPL, the gas token, not your stablecoins.

Which USDC or USDT is native on each chain?

On Arc, USDC is the native asset itself, with an ERC-20 view at 0x3600000000000000000000000000000000000000. On Stable, USDT0 is the native asset with an ERC-20 view at 0x779Ded0c9e1022225f8E0630b35a9b54bE713736. On Plasma, USDT0 is an ERC-20 at 0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb and native Circle USDC is at 0x2d661C89D812261039AF9764eceaAee884f5F67F. On Tempo, USDT0 is a TIP-20 at 0x20c00000000000000000000014f22ca97301eb73 and USDC exists only as bridged USDC.e at 0x20c000000000000000000000b9537d11c60e8b50; there is no native Circle USDC on Tempo yet.

Does Dwellir support Arc, Tempo, Plasma and Stable?

Yes. Dwellir runs mainnet HTTPS and WebSocket endpoints for all four at api-arc-mainnet, api-tempo-mainnet, api-plasma-mainnet and api-stable-mainnet under n.dwellir.com. Tempo adds trace, debug and txpool namespaces on an archive backend, Plasma adds debug and txpool, and Arc follows Circle's full-provider profile. Every plan bills one request per response with no compute-unit multipliers.

Next Steps

Point a key at all four endpoints and run the eth_chainId loop above; it takes a minute and rules out the most common misconfiguration. Then send one transfer on the chain you are evaluating using the matching snippet, and watch which of the table rows above bites first.

Get a free API key for 100,000 requests a day across every chain, or talk to the Dwellir team about dedicated capacity for a settlement workload.

Sources

All RPC readings taken on 21 September 2026 from the public endpoints. Docs and announcements as linked.

• Arc: RPC endpoints, gas and fees, EVM differences, USDC system events, stablecoin-native model, deterministic finality, Circle mainnet launch, founding validator cohort
• Tempo: connection details, EVM compatibility, fee spec, TIP-20 spec, consensus and finality, send a payment, mainnet token list, mainnet announcement
• Plasma: mainnet details, network fees, consensus, differences from Ethereum, USDT0 deployments, Circle USDC contract addresses, mainnet beta announcement
• Stable: mainnet information, connect, USDT0 as gas, gas pricing, gas waiver, finality, send your first USDT0, network upgrades
• Stablecoin supply and TVL: DefiLlama stablecoin chains, DefiLlama chains