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

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 });

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" } },
});

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