Sui RPC: Where Everything You Own Is an Object

Most "alt-L1" chains still think in accounts and balances — Sui doesn't. On Sui, everything you own is a first-class object with its own ID and owner, and that single design decision changes the entire RPC surface. There's no eth_getBalance, no eth_call, no eth_getLogs. If you're arriving from Ethereum, the tooling is unfamiliar but the mental model is actually simpler once it clicks: you don't ask a contract what it thinks you own — you ask the chain which objects belong to your address. Here's the map. The essentials Sui is a non-EVM Layer 1 from Mysten Labs, mainnet since May 2023: Move language (Sui Move) — resource-oriented, assets are safe by construction. Object-centric model — assets are objects with owners, not entries in a contract's storage mapping. Parallel execution — transactions touching disjoint objects don't contend and run concurrently. Sub-second finality for owned-object transactions; a few seconds via consensus for shared objects. SUI is the gas token, with 9 decimals (the base unit is MIST; 1 SUI = 1e9 MIST). No fixed block time — the chain advances in checkpoints, not numbered blocks. The RPC is JSON-RPC, but the method namespace is sui_* / suix_*, not eth_*. Use the official SDK: import { SuiClient, getFullnodeUrl } from "@mysten/sui/client"; const client = new SuiClient({ url: "https://rpc.swiftnodes.io/rpc/sui?key=YOUR_API_KEY", }); await client.getLatestCheckpointSequenceNumber(); // the chain tip Enter fullscreen mode Exit fullscreen mode The mental shift: query objects, not contract storage On Ethereum, "what NFTs does this wallet hold?" means calling a contract's balanceOf/ownerOf or indexing Transfer events — you're reconstructing ownership from a contract's internal bookkeeping. On Sui, ownership is native to the protocol: every object records its owner, so you query it directly. // Everything an address owns — coins, NFTs, arbitrary Move objects const owned = await client.getOwnedObjects({ owner: address }); // A specific object by ID, with its Move type and fields const obj = await client.getObject({ id: objectId, options: { showType: true, showContent: true, showOwner: true }, }); // All coin balances for an address (SUI + any other coin type) const balances = await client.getAllBalances({ owner: address }); Enter fullscreen mode Exit fullscreen mode That's the core reframe. getOwnedObjects is the query you'll reach for constantly — it's the "what does this address actually have?" primitive that Ethereum never gave you at the protocol level. Owned vs shared objects: the finality fast path Sui's speed comes from a distinction with no EVM equivalent, and it's worth understanding because it affects latency: Owned objects (e.g., your coins, your NFT) have a single owner. A transaction touching only owned objects can skip full consensus and finalize in sub-second time — because nothing else can be mutating your object concurrently. Shared objects (e.g., a DEX pool everyone trades against) can be touched by anyone, so those transactions go through the Mysticeti consensus path — still fast (a few seconds), but not the owned-object fast path. For a developer this means: simple transfers and single-owner updates are extremely fast, while contended DeFi state settles through consensus. Design latency expectations around which kind of object a transaction touches. Reading transactions and events (indexing) There's no eth_getLogs, so the range-cap headaches don't apply — but you index differently: // A transaction by digest, with effects, events, and object changes const tx = await client.getTransactionBlock({ digest, options: { showEffects: true, showEvents: true, showObjectChanges: true }, }); // Query events by type, module, or sender const events = await client.queryEvents({ query: { MoveModule: { package: pkgId, module: "my_module" } }, }); Enter fullscreen mode Exit fullscreen mode The chain tip is a checkpoint sequence number, not a block height — poll getLatestCheckpointSequenceNumber (or subscribe over WebSocket) and read checkpoints to tail the chain. objectChanges on a transaction tells you exactly which objects were created, mutated, or transferred — the object-model equivalent of parsing logs. Standard JSON-RPC conveniences still apply — if you're making many independent reads, batch them to cut round-trips. What's different from the other non-EVM chains If you've built on the Cosmos chains we've covered — Celestia, Osmosis — note that Sui is not CometBFT/Tendermint either; it has its own sui_* API and consensus (Mysticeti). And unlike UTXO chains like Litecoin, Sui's objects are rich, typed, and programmable, not just unspent outputs. Sui is genuinely its own model — the closest intuition is "typed, owned objects" rather than accounts, UTXOs, or Cosmos modules. The short version Sui is a non-EVM Move L1 with an object-centric model: assets are first-class objects with owners, so you query ownership natively (getOwnedObjects, getObject, getAllBalances) instead of reconstructing it from contract storage. The API is sui_*/suix_* via the @mysten/sui SDK, not eth_*. SUI has 9 decimals (base unit MIST), the chain advances in checkpoints (no fixed blocks), and owned-object transactions finalize sub-second by skipping consensus while shared-object transactions settle through Mysticeti in a few seconds. Building consumer-scale apps, on-chain games, or low-latency DeFi on Sui? A flat-rate Sui RPC endpoint gives you a full node's sui_* API alongside 75+ other chains under one key. Grab a free key and point the SDK at: https://rpc.swiftnodes.io/rpc/sui?key=YOUR_API_KEY Enter fullscreen mode Exit fullscreen mode Originally published on the SwiftNodes blog. SwiftNodes provides flat-rate multi-chain RPC endpoints — HTTP + WebSocket, 75+ chains, no per-request metering. Grab a free key.