The Sui ecosystem playbook — why Move teams need multichain from day one

Sui has the best developer ergonomics of any new L1 in the last five years. The Move language is safer than Solidity. The object-centric model is a genuinely better primitive than accounts for most real-world applications. Parallel execution is not a marketing slide, it's a real property of the VM. All of this is true.

And yet, every team I've watched go live on Sui loses roughly one engineering month on non-differentiated data-layer work before they ship a single user-facing feature. Let's talk about why — and what to do about it.

The Move object model is not optional to understand

On Ethereum, a “token balance” is a row in a mapping inside a contract. On Sui, a token balance is one or more Coin<T> objects you own, which can be split, merged, and moved independently. Events are attached to these objects. The indexer contract — whether yours or a SaaS — has to understand object mutations, not just log lines.

Most generic indexers were built for account-model chains. They index blocks and emit “transfer events” as if the world were EVM-shaped. On Sui that's a lie — and the lie gets expensive the moment you try to do anything non-trivial:

• Dynamic fields (child objects referenced at runtime) — miss these and your state is wrong
• Object wrapping (an object that now lives inside another) — miss these and you “lose” assets
• Shared-object contention — important for UX but invisible to naive indexers
• Checkpoint-based querying — Sui's native pagination primitive, not block-based

What Sui teams actually rebuild, over and over

Pick any five Sui teams that shipped in the last six months. You will find five independent implementations of the same four things:

1. A Sui RPC client with retries, failover, and sane error handling
2. A checkpoint-based indexer with reorg awareness (yes, Sui has reorgs during epoch changes)
3. A Move event decoder that understands object mutations and dynamic fields
4. Glue to push that data into whatever their frontend or analytics stack needs

None of this is Sui's competitive advantage. None of it is what their users pay them for. And every one of those four problems is solved once in chainrpc and chainindex — for Sui plus six other architectures.

The 20-line migration

A team that has already integrated ChainFoundry for Ethereum and Solana can add Sui support like this:

use chainrpc::ChainClient;
use chainindex::Indexer;

class="tok-c">// Before: eth + solana only
let indexer = Indexer::sqlite(class="tok-s">"./data.db")
    .chain(ChainClient::evm(eth_rpc))
    .chain(ChainClient::solana(sol_rpc))
    .build()?;

class="tok-c">// After: add Sui — one line, same shape
let indexer = Indexer::sqlite(class="tok-s">"./data.db")
    .chain(ChainClient::evm(eth_rpc))
    .chain(ChainClient::solana(sol_rpc))
    .chain(ChainClient::sui(sui_rpc))       class="tok-c">// <— this
    .build()?;

class="tok-c">// Canonical event stream — the agent, the UI, the analytics
class="tok-c">// pipeline all read the same shape whether the event came from
class="tok-c">// Ethereum, Solana, or Sui
for evt in indexer.events().await? {
    process(evt);
}

That is the full story. One line. The Move-specific decoding, the checkpoint handling, the object-type awareness — all of that is inside the crate, maintained once, tested across every release.

What Sui Foundation gets from this

Developer relations at a blockchain foundation is, at the end of the day, a time-to-integration problem. If an existing multichain team needs 2–4 months to add Sui, most of them will push Sui to Q3, then Q4, then “next year.” If they need 20 minutes, Sui ships with the product.

ChainFoundry is free distribution into every multichain app that already uses us for other chains. Every time a team running ChainFoundry on Ethereum + Solana decides to add one more chain, Sui is already in the menu — no per-chain integration contract, no new vendor, no new engineer to hire. That's worth more than any grant program.

What's shipped vs. what's next

Today on Sui we ship:

• chainrpc — production RPC transport for Sui, including failover, rate limiting, and caching
• chainindex — reorg-safe checkpoint-native indexer for Sui, pluggable storage

On the roadmap — and where we're actively looking for ecosystem collaboration:

• chaincodec — full Sui Move event decoder with object-type awareness, dynamic field tracking, and checkpoint-based querying
• chaincorrelate — Bitcoin ↔ Sui correlation for BTCFi use cases (more on this in the next post)

If you work on Sui DevRel or ecosystem funding and any of this sounds useful, get in touch. A small grant buys a lot of engineering here, and the output compounds across every team building on Sui.