Sui tooling

Sui blockchain development tools guide. Use gRPC, GraphQL, the TypeScript SDK, Rust SDK, Python pysui, and Go SDK to build Sui applications with Chainstack.

Get started with a reliable Sui RPC endpoint to use the tools below. Your Chainstack Sui node serves gRPC, and Sui Mainnet Global Nodes also serve GraphQL on the same endpoint.

Sui removes JSON-RPC from the full node in v1.82. Sui Testnet nodes no longer serve JSON-RPC, and Sui Mainnet nodes stop serving it with the v1.82 upgrade — see Migrate Sui from JSON-RPC to gRPC and GraphQL.

Extended history

Sui Global Nodes are Extended. The node holds a window of checkpoints from lowestAvailableCheckpoint to the tip, not the full ledger from genesis. LedgerService/GetServiceInfo reports the current window — see Checkpoint retention for how the window applies to gRPC and GraphQL.

gRPC API

Sui nodes on Chainstack support gRPC for high-performance access. gRPC uses HTTP/2 and Protocol Buffers for binary serialization, which makes payloads smaller and adds server-side streaming — ideal for indexers, backends, and low-latency lookups. gRPC replaces JSON-RPC, which Sui removes from the full node in v1.82.

Endpoint and authentication

Your Sui gRPC endpoint is sui-mainnet.core.chainstack.com:443 (testnet: sui-testnet.core.chainstack.com:443), with TLS. Authenticate by passing your token in the x-token metadata header on every call. To find your endpoint and token on Chainstack, see View node access and credentials.

Explore with grpcurl

Sui gRPC has server reflection enabled, so grpcurl can list services and call methods without compiling proto files:

List services

grpcurl -H "x-token: YOUR_X_TOKEN" \
  sui-mainnet.core.chainstack.com:443 \
  list

The node exposes six sui.rpc.v2 services:

Service	Use it for
LedgerService	Checkpoints, objects, transactions, epochs, and node info
StateService	Balances, coins, owned objects, and dynamic fields
TransactionExecutionService	Executing and simulating transactions
SubscriptionService	Streaming checkpoints
MovePackageService	Move packages, modules, functions, and datatypes
NameService	SuiNS name resolution

gRPC from code

In TypeScript, use the official @mysten/sui SDK. Its default gRPC-Web transport works against Chainstack over HTTPS — including from the browser — so the simplest setup needs only your node URL as baseUrl. For server-side apps that prefer native gRPC over HTTP/2, pass a native transport instead. From other languages, generate typed stubs from Sui’s proto definitions and connect over native gRPC. Authenticate with your node’s x-token — carried in the endpoint URL, or as x-token metadata on native-gRPC calls — and use recent client versions — @mysten/sui 2.16+ and @grpc/grpc-js 1.14+ — since older releases produce intermittent gRPC errors under load.

TypeScript (gRPC-Web)

// npm install @mysten/sui
// Default gRPC-Web transport over HTTPS — works in the browser and in Node.js.
import { SuiGrpcClient } from '@mysten/sui/grpc';

const client = new SuiGrpcClient({
  network: 'mainnet',
  baseUrl: 'YOUR_CHAINSTACK_SUI_HTTPS_ENDPOINT',
});

const gasPrice = await client.core.getReferenceGasPrice();
console.log(gasPrice.referenceGasPrice);

The default gRPC-Web transport works in both the browser and server runtimes, so it is the simplest choice for most apps. The native gRPC transport (HTTP/2) is server-side only — use it when you specifically need native gRPC.

GraphQL API

Sui Mainnet Global Nodes serve Sui’s GraphQL RPC at YOUR_CHAINSTACK_ENDPOINT/graphql, with the same auth token as your HTTPS endpoint. Use GraphQL for filtered, paginated reads — transactions by address, events by type, objects by owner and type — that have no gRPC equivalent. GraphQL is not available on Sui Testnet.

In TypeScript, use SuiGraphQLClient from the official @mysten/sui SDK:

TypeScript

// npm install @mysten/sui
import { SuiGraphQLClient } from '@mysten/sui/graphql';
import { graphql } from '@mysten/sui/graphql/schema';

const client = new SuiGraphQLClient({
  url: 'YOUR_CHAINSTACK_ENDPOINT/graphql',
  network: 'mainnet',
});

const result = await client.query({
  query: graphql(`
    query {
      checkpoint {
        sequenceNumber
        timestamp
      }
    }
  `),
});
console.log(result.data);

Filtered queries and events keep a shorter history window than point lookups. For authentication options, filters, history windows, and query limits, see Sui GraphQL endpoint.

Sui TypeScript SDK

The Sui TypeScript SDK is the official SDK for building Sui applications. Use its gRPC client, SuiGrpcClient, for reads and transactions, and SuiGraphQLClient for filtered queries — see GraphQL API.

Installation

npm install @mysten/sui

The SDK’s JSON-RPC client, SuiJsonRpcClient from @mysten/sui/jsonRpc, stops working when JSON-RPC is removed. SuiGrpcClient covers the same reads and transactions through methods such as getObject, listOwnedObjects, getBalance, and signAndExecuteTransaction. See the SDK 2.0 migration guide.

Basic usage

Connection

import { SuiGrpcClient } from '@mysten/sui/grpc';

// Connect to your Chainstack node
const client = new SuiGrpcClient({
  network: 'mainnet',
  baseUrl: 'YOUR_CHAINSTACK_SUI_HTTPS_ENDPOINT',
});

// Get the reference gas price for the current epoch
const { referenceGasPrice } = await client.getReferenceGasPrice();
console.log('Reference gas price:', referenceGasPrice);

Sui Rust SDK

The sui-rpc crate from Mysten Labs’ Sui Rust SDK is a gRPC client for Sui, published on crates.io.

Installation

Add to your Cargo.toml:

sui-rpc = "0.4"
tokio = { version = "1", features = ["full"] }
anyhow = "1"

Basic usage

use sui_rpc::client::{Client, HeadersInterceptor};
use sui_rpc::proto::sui::rpc::v2::GetServiceInfoRequest;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let mut headers = HeadersInterceptor::new();
    headers.headers_mut().insert("x-token", "YOUR_X_TOKEN".parse()?);

    let mut client = Client::new("https://sui-mainnet.core.chainstack.com")?.with_headers(headers);

    let info = client
        .ledger_client()
        .get_service_info(GetServiceInfoRequest::default())
        .await?
        .into_inner();
    println!("Chain: {:?}, checkpoint: {:?}", info.chain, info.checkpoint_height);

    Ok(())
}

Python SDK (pysui)

pysui is a community-maintained Python SDK for Sui. pysui 1.x connects over gRPC and GraphQL, and its gRPC client is async. pysui reads its connection settings from a configuration folder, so the example creates one with a Chainstack profile on the first run and passes your x-token as a header on every call.

Installation

pip install pysui

Basic usage

import asyncio
from pathlib import Path

from pysui import PysuiConfiguration
from pysui.sui.sui_common.config.confgroup import NetworkType
from pysui.sui.sui_grpc.pgrpc_clients import GrpcProtocolClient
import pysui.sui.sui_grpc.pgrpc_requests as rn

CONFIG_DIR = Path("~/.pysui-chainstack").expanduser()

# Create a pysui configuration with a Chainstack profile on first run
try:
    cfg = PysuiConfiguration(from_cfg_path=str(CONFIG_DIR), group_name="chainstack")
except ValueError:
    cfg = PysuiConfiguration.initialize_config(
        in_folder=CONFIG_DIR,
        init_groups=[{"name": "chainstack", "make_active": True}],
    )
    cfg.new_profile(
        profile_name="mainnet",
        url="https://sui-mainnet.core.chainstack.com:443",
        network_type=NetworkType.PRODUCTION,
        make_active=True,
        in_group="chainstack",
    )


async def main():
    client = GrpcProtocolClient(pysui_config=cfg, default_header={"x-token": "YOUR_X_TOKEN"})
    result = await client.execute_grpc_request(request=rn.GetServiceInfo())
    if result.is_ok():
        print(f"Latest checkpoint: {result.result_data.checkpoint_height}")
    else:
        print(result.result_string)
    await client.close()


asyncio.run(main())

For a complete pysui program, see Sui: On-chain validator analytics with pysui.

Go SDK

The Sui Go SDK from BlockVision provides Go language bindings for Sui, including a gRPC client. The client dials without TLS by default, so pass TLS credentials for your Chainstack endpoint.

Installation

go get github.com/block-vision/sui-go-sdk

Basic usage

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/block-vision/sui-go-sdk/common/grpcconn"
    v2 "github.com/block-vision/sui-go-sdk/pb/sui/rpc/v2"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
)

func main() {
    client := grpcconn.NewSuiGrpcClientWithAuth(
        "sui-mainnet.core.chainstack.com:443",
        "YOUR_X_TOKEN",
        grpcconn.WithDialOptions(grpc.WithTransportCredentials(credentials.NewTLS(nil))),
    )
    defer client.Close()

    ctx := context.Background()

    ledger, err := client.LedgerService(ctx)
    if err != nil {
        log.Fatal(err)
    }

    info, err := ledger.GetServiceInfo(ctx, &v2.GetServiceInfoRequest{})
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Chain: %s, checkpoint: %d\n", info.GetChain(), info.GetCheckpointHeight())
}