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

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.

Top comments (0)