Skip to main content
The Sui Rust SDK provides a type-safe, high-level interface for interacting with the Sui blockchain. It builds on top of the JSON-RPC API and offers idiomatic Rust patterns for working with Sui.

​
Installation

Add the Sui SDK to your project: 
cargo add sui-sdk
Or add to your Cargo.toml: 
[dependencies]
sui-sdk = "1.0"

​
Quick Start

use sui_sdk::SuiClientBuilder;

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    // Connect to Sui network
    let sui = SuiClientBuilder::default()
        .build("https://fullnode.mainnet.sui.io:443")
        .await?;
    
    println!("Sui version: {}", sui.api_version());
    
    Ok(())
}

​
SuiClientBuilder

The SuiClientBuilder provides a fluent interface for configuring and building a SuiClient.

​
Configuration Options

use sui_sdk::SuiClientBuilder;
use std::time::Duration;
use std::collections::HashMap;

let sui = SuiClientBuilder::default()
    .request_timeout(Duration::from_secs(60))
    .max_concurrent_requests(256)
    .ws_url("wss://fullnode.mainnet.sui.io:443")
    .ws_ping_interval(Duration::from_secs(30))
    .basic_auth("username", "password")
    .custom_headers({
        let mut headers = HashMap::new();
        headers.insert("X-Custom-Header".to_string(), "value".to_string());
        headers
    })
    .build("https://fullnode.mainnet.sui.io:443")
    .await?;

​
Network Shortcuts

// Local network (http://127.0.0.1:9000)
let sui_local = SuiClientBuilder::default()
    .build_localnet()
    .await?;

// Devnet (https://fullnode.devnet.sui.io:443)
let sui_devnet = SuiClientBuilder::default()
    .build_devnet()
    .await?;

// Testnet (https://fullnode.testnet.sui.io:443)
let sui_testnet = SuiClientBuilder::default()
    .build_testnet()
    .await?;

// Mainnet (https://fullnode.mainnet.sui.io:443)
let sui_mainnet = SuiClientBuilder::default()
    .build_mainnet()
    .await?;

​
SuiClient APIs

The SuiClient provides access to different API modules:

​
ReadApi

Query objects, transactions, and network state: 
let read_api = sui.read_api();

// Get object
let obj = read_api.get_object_with_options(
    object_id,
    SuiObjectDataOptions::default().with_content()
).await?;

// Get transaction
let tx = read_api.get_transaction_with_options(
    digest,
    SuiTransactionBlockResponseOptions::default()
        .with_input()
        .with_effects()
).await?;

​
CoinReadApi

Query coin balances and metadata: 
let coin_api = sui.coin_read_api();

// Get balance
let balance = coin_api.get_balance(address, None).await?;

// Get all balances
let all_balances = coin_api.get_all_balances(address).await?;

// Get coin metadata
let metadata = coin_api.get_coin_metadata("0x2::sui::SUI".to_string()).await?;

​
EventApi

Query and subscribe to events: 
let event_api = sui.event_api();

// Query events
let events = event_api.query_events(
    EventFilter::MoveEventType("0x2::coin::CoinCreated".to_string()),
    None,
    Some(10),
    false
).await?;

// Subscribe to events (WebSocket required)
let mut event_stream = event_api.subscribe_event(
    EventFilter::All(vec![])
).await?;

​
GovernanceApi

Query staking and validator information: 
let gov_api = sui.governance_api();

// Get system state
let system_state = gov_api.get_latest_sui_system_state().await?;

// Get stakes
let stakes = gov_api.get_stakes(address).await?;

// Get reference gas price
let gas_price = gov_api.get_reference_gas_price().await?;

​
QuorumDriverApi

Execute transactions: 
let quorum_api = sui.quorum_driver_api();

// Execute transaction
let response = quorum_api.execute_transaction_block(
    signed_transaction,
    SuiTransactionBlockResponseOptions::default()
        .with_effects()
        .with_events(),
    None
).await?;

​
TransactionBuilder

Build transactions programmatically: 
let tx_builder = sui.transaction_builder();

// Transfer object
let tx_data = tx_builder.transfer_object(
    sender,
    object_id,
    Some(gas),
    gas_budget,
    recipient
).await?;

​
Common Patterns

​
Query Owned Objects

use sui_sdk::SuiClientBuilder;
use sui_types::base_types::SuiAddress;
use std::str::FromStr;

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    let sui = SuiClientBuilder::default().build_mainnet().await?;
    let address = SuiAddress::from_str("0x...")?;
    
    let owned_objects = sui.read_api()
        .get_owned_objects(address, None, None, None)
        .await?;
    
    println!("Found {} objects", owned_objects.data.len());
    
    Ok(())
}

​
Execute a Transaction

use sui_sdk::SuiClientBuilder;
use sui_types::transaction::Transaction;

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    let sui = SuiClientBuilder::default().build_mainnet().await?;
    
    // Build and sign transaction
    let tx: Transaction = /* ... */;
    
    // Execute
    let response = sui.quorum_driver_api()
        .execute_transaction_block(
            tx,
            SuiTransactionBlockResponseOptions::default()
                .with_effects()
                .with_events(),
            None
        )
        .await?;
    
    println!("Transaction digest: {}", response.digest);
    
    Ok(())
}

​
Stream Events

use sui_sdk::SuiClientBuilder;
use sui_json_rpc_types::EventFilter;
use futures::StreamExt;

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    let sui = SuiClientBuilder::default()
        .ws_url("wss://fullnode.mainnet.sui.io:443")
        .build("https://fullnode.mainnet.sui.io:443")
        .await?;
    
    let mut events = sui.event_api()
        .subscribe_event(EventFilter::All(vec![]))
        .await?;
    
    while let Some(event) = events.next().await {
        match event {
            Ok(e) => println!("Event: {:?}", e),
            Err(err) => eprintln!("Error: {}", err),
        }
    }
    
    Ok(())
}

​
Error Handling

The SDK uses the SuiRpcResult<T> type, which is an alias for Result<T, Error>: 
use sui_sdk::error::Error;

match sui.read_api().get_object_with_options(object_id, options).await {
    Ok(object) => println!("Object: {:?}", object),
    Err(Error::DataError(msg)) => eprintln!("Data error: {}", msg),
    Err(Error::RpcError(err)) => eprintln!("RPC error: {}", err),
    Err(err) => eprintln!("Other error: {}", err),
}

​
Type Definitions

The SDK re-exports important types: 
use sui_sdk::{
    types::base_types::{ObjectID, SuiAddress, TransactionDigest},
    rpc_types::{SuiObjectData, SuiTransactionBlockResponse},
    json::SuiJsonValue,
};

​
Next Steps

Build docs developers (and LLMs) love

Get started for freeTalk to us