> ## Documentation Index > Fetch the complete documentation index at: https://developers.stellar.org/llms.txt > Use this file to discover all available pages before exploring further. # USDT0 on mainnet > Work with USDT0 on Stellar mainnet from the CLI. Addresses, trustlines, the clawback flags, and how to acquire it safely. Get USDT0 into a mainnet account, hold it, and move some of it. > [!WARNING] > > Every command on this page moves real value on mainnet, and a confirmed transaction cannot be reversed. Before you let an agent run them, bound what it can reach: give it a [capped allowance](#give-an-agent-a-capped-allowance) or a small balance of its own, never the key to the account that holds your funds. ## Ask your agent ```text theme={"theme":{"light":"github-light","dark":"github-dark"}} Check the USDT0 balance of GATISXX6BZ6NC7IKQBY37CJD4SOZL3CYZJWXEDG6JVIY4WBS6KXJHN6Q on mainnet, then tell me what the current XLM to USDT0 rate is. ``` > [!TIP] > > Read [Acquire USDT0](#acquire-usdt0) before you buy any. It covers which route to use and how to bound a trade. ## Addresses USDT0 is a classic Stellar asset with a Stellar Asset Contract. Its supply is unified with USDT on other chains, minted and burned on Stellar by a LayerZero OFT contract. It is live on mainnet only. [USDT0 on Stellar](https://developers.stellar.org/launch/usdt0) is the source of truth for these values. | Thing | Value | | - | - | | Classic asset | `USDT0:GATISXX6BZ6NC7IKQBY37CJD4SOZL3CYZJWXEDG6JVIY4WBS6KXJHN6Q` | | Token contract (SAC) | `CBSJZEIO5C7KC2SF3MKSNXXJSW5G3VTNBX4ATMKUI3B2MR4JKM4R26YF` | | OFT contract | `CBOWOLFSDM5PZXNFIVDMP5NZ7U2GSIHED6H6R446QOHF266XINKUMMF6` | | LayerZero endpoint ID | `30600` | | Decimals on Stellar | 7 | Do not trust a pasted contract address. Derive the SAC from the asset and compare. This is a free read with no source account: ```bash theme={"theme":{"light":"github-light","dark":"github-dark"}} stellar contract id asset --asset USDT0:GATISXX6BZ6NC7IKQBY37CJD4SOZL3CYZJWXEDG6JVIY4WBS6KXJHN6Q \ --network mainnet ``` ## Set up mainnet first The built-in `mainnet` entry has no RPC URL, so mainnet commands fail with `Invalid URL Bring Your Own` until you add one. Pick an endpoint from Stellar's [RPC providers page](https://developers.stellar.org/docs/data/apis/rpc/providers.md). Once you pass `--rpc-url`, you must also pass `--network-passphrase`: ```bash theme={"theme":{"light":"github-light","dark":"github-dark"}} stellar network add mainnet \ --rpc-url \ --network-passphrase "Public Global Stellar Network ; September 2015" stellar network health --network mainnet ``` `network health` only proves the endpoint answers. In testing, one endpoint reported healthy and landed classic transactions while every Soroban submission timed out. Validate a new endpoint with one small Soroban write, such as a `stellar token approve`, before you rely on it. There is no friendbot on mainnet, so fund a new account from an existing one. An account needs 1 XLM to exist plus 0.5 XLM per trustline, so an account holding only USDT0 needs at least 1.5 XLM plus fees: ```bash theme={"theme":{"light":"github-light","dark":"github-dark"}} stellar tx new create-account --source --destination \ --starting-balance 15000000 --network mainnet ``` ## Steps 1. Read the asset. No key or signing needed: ```bash theme={"theme":{"light":"github-light","dark":"github-dark"}} stellar token symbol --id USDT0:GATISXX6… --network mainnet stellar token decimals --id USDT0:GATISXX6… --network mainnet ``` 2. Add the trustline. USDT0 cannot arrive without one: ```bash theme={"theme":{"light":"github-light","dark":"github-dark"}} stellar tx new change-trust --source \ --line USDT0:GATISXX6BZ6NC7IKQBY37CJD4SOZL3CYZJWXEDG6JVIY4WBS6KXJHN6Q --network mainnet ``` 3. Confirm it. Any number, even `0`, means the trustline exists. Without one this fails with `"trustline entry is missing for account"`: ```bash theme={"theme":{"light":"github-light","dark":"github-dark"}} stellar token balance --id USDT0:GATISXX6… --account --network mainnet ``` 4. Send it with a classic payment. At 7 decimals, 1 USDT0 is `10000000`, and the destination needs its own trustline: ```bash theme={"theme":{"light":"github-light","dark":"github-dark"}} stellar tx new payment --source --destination \ --asset USDT0:GATISXX6BZ6NC7IKQBY37CJD4SOZL3CYZJWXEDG6JVIY4WBS6KXJHN6Q \ --amount 10000000 --network mainnet ``` Prefer this over `stellar token transfer` for USDT0. The classic payment costs 100 stroops, while `token transfer` pays Soroban resource fees of about 14,000 stroops for the same transfer. ## Acquire USDT0 Transfer USDT0 to Stellar from another network at [usdt0.to/transfer](https://usdt0.to/transfer), or buy it on a venue that supports Stellar, such as Kraken or SushiSwap. [USDT0 on Stellar](https://developers.stellar.org/launch/usdt0) lists the integrated exchanges, ramps, and custodians. A cross-chain transfer costs the source network's gas plus the LayerZero message, and some routes enforce a minimum amount. To swap from the CLI, use a path payment and always set `--dest-min`, so a bad rate fails instead of executing. The CLI has no price command, so quote the trade against Horizon's path endpoint first and set the bound below the quote: ```bash theme={"theme":{"light":"github-light","dark":"github-dark"}} stellar tx new path-payment-strict-send --source --network mainnet \ --send-asset native --send-amount 50000000 --destination \ --dest-asset USDT0:GATISXX6… --dest-min 8000000 ``` To price a sale of USDT0, quote with `strict-receive`. A `strict-send` quote with USDT0 as the source asset returns no paths, even though a route exists. ## Give an agent a capped allowance The network enforces a capped, expiring allowance over your USDT0, which makes it the strongest control for letting an agent spend it. The owner needs a USDT0 trustline, but no balance, so you can set it up before funding: ```bash theme={"theme":{"light":"github-light","dark":"github-dark"}} LEDGER=$(stellar ledger latest --network mainnet --output json | python3 -c 'import sys,json;print(json.load(sys.stdin)["sequence"])') stellar token approve --id USDT0:GATISXX6… --from --spender \ --amount 20000000 --expiration-ledger $((LEDGER + 17280)) --network mainnet stellar token allowance --id USDT0:GATISXX6… --from --spender \ --network mainnet --decimal ``` That grants 2 USDT0 for about a day (17,280 ledgers at 5 seconds each). Revoke with `--amount 0 --expiration-ledger 0`. The agent spends it with `stellar token transfer-from`, signing as the spender: ```bash theme={"theme":{"light":"github-light","dark":"github-dark"}} stellar token transfer-from --id USDT0:GATISXX6… --spender --from \ --to --amount --network mainnet ``` See [Delegate spending](https://developers.stellar.org/docs/tools/cli/agent-cli/guides/delegate-spending.md). ## Revocation and clawback The asset sets `auth_revocable` and `auth_clawback_enabled`, so a trustline can be revoked or a balance clawed back. `auth_required` is not set, so anyone can hold it. The admin is a contract, `CA3GUWLOS3QKN6WNRAELSUDSKLDTVTWEDJ3KLGAJG3SIWGA5L3KZYWGJ`, not a keypair. To limit how much USDT0 an account will accept, set a trustline limit. This caps it at 1 USDT0: ```bash theme={"theme":{"light":"github-light","dark":"github-dark"}} stellar tx new change-trust --source \ --line USDT0:GATISXX6BZ6NC7IKQBY37CJD4SOZL3CYZJWXEDG6JVIY4WBS6KXJHN6Q \ --limit 10000000 --network mainnet ``` Without `--limit`, the trustline is effectively uncapped. `--limit 0` removes the trustline and returns its 0.5 XLM reserve, but only at a zero balance. ## Common pitfalls * **No trustline.** A payment to an account without one fails with `op_no_trust`. * **Smallest units.** `--amount 1` sends 0.0000001 USDT0. * **Cross-chain rounding.** Bridged transfers use six decimals. Send 1.2345678 and 1.234567 moves; the 0.0000008 remainder is refunded. * **Parsing a submit.** `tx send` writes its info line to stderr and JSON to stdout, so `2>&1` breaks the parse. * **Timed-out submits.** A `transaction submission timeout` means the outcome is unknown. Check `stellar tx fetch result --hash --network mainnet` first. Resubmitting the same signed envelope with `stellar tx send` is safe: it is byte-identical and can land at most once. Rerunning `tx new payment` or `token transfer` builds a new transaction with a new sequence number, and if the first one landed you pay twice. Never retry on a timer. * **Duplicate network entries.** Running `stellar network add mainnet` twice leaves two entries, and only `--very-verbose` shows which URL is in use. * **Protocol gap.** Testnet upgrades to each new protocol before mainnet, so the two networks can differ for a few weeks. Check both with `stellar doctor` before assuming a testnet rehearsal covers mainnet. ## Related pages * [Send tokens](https://developers.stellar.org/docs/tools/cli/agent-cli/guides/send-tokens.md) * [Build and submit transactions](https://developers.stellar.org/docs/tools/cli/agent-cli/guides/build-and-submit-transactions.md) * [Authority model](https://developers.stellar.org/docs/tools/cli/agent-cli/reference/authority-model.md)