2026-10-01

Happy Stellartober

October is the month of Hack Meridian and the Meridian conference, which is exactly why I refused to spend the call talking about either of them (mostly — see the intermission below). This week was about USDT0 on Stellar: Tether's USDT delivered to Stellar over LayerZero's OFT standard. Think of it as a prologue to a USDT0 AMA — if everything goes well, next week I'll have people who were actually involved in issuing USDT0 and wiring Stellar into LayerZero on the stream, and my job this week was to make sure you ask them the right questions.

The agenda: slides (necessary, for once), a short intermission about Hack Meridian, then a live tour of nine demos in one website, including launching an omnichain token on Stellar and driving a vault on Stellar from MetaMask. Everything I showed lives in one public repo, and every address I mentioned is verified on-chain.

What USDT0 Is

USDT0 is Tether's USDT moved over LayerZero's Omnichain Fungible Token (OFT) standard. The canonical USDT stays locked in an adapter contract on Ethereum; every other chain holds USDT0 minted against that locked supply. USDT itself is Tether's asset; USDT0 is built and operated by Everdawn Labs (I said "I should fact check this" on the call — I did, and it's correct). It's live on 23 networks, and as of September 2 Stellar is one of them.

One ground rule: USDT0 is on Stellar mainnet only. Anything called USDT0 on testnet is somebody's mock. The LayerZero endpoint, however, is live on testnet, so your own test tokens work there — which is exactly what the demos use.

Where we stood as of the call — not a sales pitch, just a sense of the potential:

• 23,717 accounts hold a USDT0 trustline, up from about 13,500 roughly 17 days earlier — growth of about three quarters in two and a half weeks.
• About 2.58 million USDT0 sits on Stellar, almost all of it held inside 23 contracts.
• Seven DVN operators are registered on Stellar mainnet; USDT0 requires three of them.
• USDT0 is the biggest LayerZero tenant on Stellar but not the only one: of the last 50 messages leaving Stellar when I built the slide, 38 were USDT0. The rest came from other apps — PayPal's and Ethena's among them.

Each Leg Has Its Own Mechanism

An OFT keeps one total supply across chains by pairing a debit on the source with a credit on the destination, but the mechanism differs per leg. On Stellar it's mint/burn: sending burns your USDT0 through the Stellar Asset Contract; receiving has a contract called the SAC manager mint to you, so supply on Stellar always equals what was bridged in. On Ethereum the OFT is an adapter: sending locks canonical USDT (approve first), receiving unlocks it, nothing is ever minted. That invariant is the whole security story — USDT0 minted everywhere else equals USDT locked in the Ethereum adapter — so never promise "burn and mint on both ends"; always check the leg.

Remember CCTP? Same story with decimals, as we saw in Elliot's CCTP call: Stellar has seven, USDT on Ethereum has six. OFT solves this with a shared precision, six for USDT0, and amounts travel on the wire as a 64-bit integer in those six decimals. Send 12345678 stroops and the wire amount is 1234567; the trailing eight stroops are dust, removed before the message is built, and they stay in your account. The practical rule: always call quote_oft first — it returns the exact amount that will arrive, and skipping it fails your simulation.

A LayerZero message is not a transaction that travels. It's five steps: send, verify, commit, execute, mint. The source OFT calls the endpoint and a packet is emitted with a nonce, endpoint IDs, sender, receiver and payload. Each required DVN — decentralized verifier network — independently attests the packet on the destination chain. Once the required set has attested, the verification is committed on the receive library (anyone can call this). An executor calls lz_receive on the destination OFT — anyone can be the executor. And on Stellar, the OFT asks the SAC manager to mint to the recipient. The DVN set is dynamic and may grow or shrink; for now, know that DVNs exist and why.

Three Contracts and a Classic Asset

On EVM chains one contract is both the token and the LayerZero app. On Stellar it's several pieces — the most confusing part for me when I first learned LayerZero:

1. The classic asset, USDT0. Its issuer account is locked, and the flags allow freezing and clawback, like Tether does on every chain.
2. The Stellar Asset Contract. The SEP-41 view of the asset — balance, transfer, burn, the usual suspects. Its admin is not a key; it is a contract.
3. The SAC manager. The admin contract. It holds the admin role and mints only for holders of the minter role. The OFT holds that role, and the SAC manager itself is owned by a multisig.
4. The OFT contract. The actual LayerZero app: quote_oft, quote_send, send, lz_receive. It stores the peers and the enforced options, and it points at the SAC and the endpoint.

The classic asset, SAC, and OFT addresses are on the USDT0 page in our docs — point your AI at it. The SAC manager is the SAC's admin, so you can read its address from the SAC itself. Everything about USDT0 is readable without a key or a signature: Horizon gives you the classic side, Stellar RPC gives you the contract side through simulation, and LayerZero's deployment registry is the source of truth for every LayerZero address. One lesson from the chain data: the Stellar testnet endpoint was redeployed in August, so always fetch the registry at runtime instead of hardcoding. The Stellar CLI works too — a contract invoke with any account as source is a simulation, no signing involved.

Sending USDT0 From Stellar

Sending is five steps and looks like a normal Soroban invocation: build the send parameters; call quote_oft for the exact amount that arrives and use it as the minimum; call quote_send for the fee, paid in XLM; call send — the OFT burns your USDT0 through the SAC and the endpoint emits a PacketSent with a GUID; then track that GUID on LayerZero Scan until it says delivered.

Some details cost real money if you get them wrong: the recipient is raw bytes, either a G or a C address; a G recipient needs a trustline before the message lands; and the seventh decimal never leaves your account, which is why you call quote_oft. Tracking uses the LayerZero Scan API, no key needed — by transaction hash, by GUID, or the latest messages for Stellar. One testnet quirk: Scan indexes Stellar messages by GUID first, so the transaction link can lag a few minutes. Delivery is permissionless: once the required DVNs have attested, anyone can finish the message. Remember CCTP? It sort of works like that.

The first question I get from Stellar developers is how this differs from CCTP, so I put together an honest side-by-side (slides coming to X). The short version: not identical, but if you dabble in CCTP, USDT0 over OFT will not be a problem for you.

Intermission: Hack Meridian

My intermission guest was Feems from Guava, the production studio helping produce Hack Meridian, who you met on last week's stream. The facts: Hack Meridian is a two-day hackathon on October 25–26 in Lisbon, with two tracks — Genesis, for people with great ideas who want to build (with Raven, the Stellar MCP, at hand), and Scale, for existing teams already on Stellar looking to grow. Expect workshops, mentors, office hours and prizes, then a day to chill before the Meridian conference on October 28–29.

Leading up to it, partners are running a plethora of events across Europe — Barcelona on October 3, Paris on October 6, an online AMA with me on October 8, plus Berlin, Paris and Porto, with more announced each week. Go to one to get a taste of Hack Meridian. My proposal, only half joking: she should do this intermission every week until the hackathon. Thank you for staying up late for it.

The Demos: Fork This Repo

Everything lives at kaankacar/stellar-layerzero-demos. Please fork it and do a bunch of weird stuff with it — every time I play with LayerZero, another use case opens up. Highlights of the tour:

• Explainer — an interactive version of the slides, with the DVNs live on testnet and the "Stellar twist" of multiple contracts. I'm an academic boy, so there are multiple-choice quizzes too.
• Inspector — mainnet, read-only, refreshed every 30 seconds: USDT0 supply and holders, plus the wired peers — the 21 networks your app on Stellar can connect to: Arbitrum, Berachain, Tempo, Optimism, Monad and more. I don't know half of these chains, but each one is a user base you might want to reach. (HyperCore shows up in LayerZero's testnet API but has no registry ID, so it's unusable for now.) A simulate view shows how many DVNs a route requires: three.
• Bridge tracker — paste a transaction hash and follow it, or browse the latest USDT0 messages touching Stellar; the last four were from Polygon and Ethereum, each attested by three DVNs. Timing varies: my first Ethereum testnet transfer took 20 minutes because of Ethereum's block times; Arbitrum takes about two seconds.
• Quotes and a playground — mock only, because real USDT0 is mainnet only.

Launching an Omnichain Token, Live

The launchpad generates an issuer keypair in your browser and keeps it in local storage — testing only, not how you'd launch a real token, but it walks the exact steps. I'd already launched a KAAN token (please don't buy it if anyone offers it to you; I'm not selling, and I don't even have any). For the live run I named the asset after the last person in chat — ELLIOT — in lock/unlock mode (the alternative is mint/burn, like USDT0), one million supply.

The Stellar side, one Freighter popup per step at a thousandth of an XLM each: fund a throwaway issuer via Friendbot, deploy the SAC, deploy the SAC manager (USDT0 has one, why shouldn't ELLIOT), open a trustline (always — OFT or not, a SAC means a trustline), mint a million ELLIOT, hand the SAC admin to the SAC manager, deploy the OFT, and lock the issuer — simulating USDT0's trust model with clawback and master weight.

Then the part that makes it omnichain: deploy the OFT on Arbitrum Sepolia via MetaMask, enforce options, and wire the two OFTs as peers — three wallet-signed transactions. Result: ELLIOT live on two chains, one OFT owned through Freighter and one through MetaMask, on a pathway using the active testnet DVN. Recipients need an ELLIOT trustline; open one and I'll send you some. Want more chains? Repeat the last three steps per chain: deploy the OFT, enforce options, wire the peers.

A Vault on Stellar, Driven From MetaMask

The last demo: a vault on Stellar testnet that you operate with MetaMask on Arbitrum Sepolia. To be clear, I am not saying MetaMask has integrated Stellar. I'm saying that, right now, MetaMask on an EVM L2 can interact with a contract that lives on Stellar. I minted some mock USDT0 on Arbitrum, hit deposit via LayerZero, signed the MetaMask popup, and watched the tracker: one DVN verification required.

Then the demo stalled — I hate it when my demos don't work — so I nudged it with my Freighter: committed the verification and called the endpoint's lz_receive myself. "You were the executor." Exactly the logic from Elliot's CCTP demo: instead of waiting for execution, you finish the message. A moment later the vault on Stellar held 500 more mock USDT0, deposited from MetaMask.

Now imagine the rest. Five years ago people talked about omnichain tokens with no good use cases; the industry is in a more established place now. Omnichain DEXes, omnichain lending and borrowing, omnichain wallets — anything. Every user of Ethereum, Arbitrum, Berachain or Monad is now a potential user of your financial application on Stellar. Fork the repo, ask Raven what else is possible, and build it.

Closing

Around 250 people were still watching when I closed, and I hate ending a stream with a quarter of a thousand viewers on. I'll be at Hack Meridian helping every one of you — if you're around, ask me about LayerZero. Thanks for watching, enjoy the outro music, and I'll see you next week — hopefully with something as interesting as this week's topic.