Connecting to Networks

# Start local network
SUI_RUN_FULLNODE_MODE=1 sui start

sui client active-env

sui client envs

sui client new-env --alias testnet --rpc https://fullnode.testnet.sui.io:443

sui client switch --env testnet

use sui_sdk::SuiClientBuilder;

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    // Localnet
    let local = SuiClientBuilder::default()
        .build_localnet()
        .await?;
    
    // Devnet
    let devnet = SuiClientBuilder::default()
        .build_devnet()
        .await?;
    
    // Testnet
    let testnet = SuiClientBuilder::default()
        .build_testnet()
        .await?;
    
    // Mainnet
    let mainnet = SuiClientBuilder::default()
        .build_mainnet()
        .await?;

    // Custom RPC
    let custom = SuiClientBuilder::default()
        .build("https://your-rpc.com")
        .await?;

    println!("Connected to testnet version: {}", testnet.api_version());
    
    Ok(())
}

import { SuiClient, getFullnodeUrl } from '@mysten/sui/client';

// Localnet
const localClient = new SuiClient({
  url: getFullnodeUrl('localnet'),
});

// Devnet
const devnetClient = new SuiClient({
  url: getFullnodeUrl('devnet'),
});

// Testnet
const testnetClient = new SuiClient({
  url: getFullnodeUrl('testnet'),
});

// Mainnet
const mainnetClient = new SuiClient({
  url: getFullnodeUrl('mainnet'),
});

// Custom RPC
const customClient = new SuiClient({
  url: 'https://your-custom-rpc.com',
});

# Ensure you're on testnet or devnet
sui client switch --env testnet

# Request tokens
sui client faucet

# Check balance
sui client gas

import { requestSuiFromFaucetV0, getFaucetHost } from '@mysten/sui/faucet';

const address = '0x...';

// Request from testnet faucet
await requestSuiFromFaucetV0({
  host: getFaucetHost('testnet'),
  recipient: address,
});

use sui_sdk::SuiClient;
use sui_types::base_types::SuiAddress;

pub async fn request_tokens_from_faucet(
    address: SuiAddress,
    sui_client: &SuiClient,
) -> Result<(), anyhow::Error> {
    let faucet_url = "https://faucet.testnet.sui.io/gas";
    
    let response = reqwest::Client::new()
        .post(faucet_url)
        .json(&serde_json::json!({
            "FixedAmountRequest": {
                "recipient": address.to_string()
            }
        }))
        .send()
        .await?;

    if response.status().is_success() {
        println!("Faucet request successful");
    }

    Ok(())
}

export SUI_NETWORK=testnet
export SUI_RPC_URL=https://fullnode.testnet.sui.io:443

keystore:
  File: /home/user/.sui/sui_config/sui.keystore
envs:
  - alias: localnet
    rpc: "http://127.0.0.1:9000"
  - alias: devnet
    rpc: "https://fullnode.devnet.sui.io:443"
  - alias: testnet  
    rpc: "https://fullnode.testnet.sui.io:443"
  - alias: mainnet
    rpc: "https://fullnode.mainnet.sui.io:443"
active_env: testnet
active_address: "0x..."

# Clone Sui repository
git clone https://github.com/MystenLabs/sui.git
cd sui

# Build and run fullnode
cargo build --release --bin sui-node
./target/release/sui-node --config-path fullnode.yaml

// Example with a custom provider
const client = new SuiClient({
  url: 'https://provider.example.com/sui/mainnet',
});

curl https://fullnode.testnet.sui.io:443 -X POST \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"sui_getLatestCheckpointSequenceNumber"}'

async function checkNodeHealth(client: SuiClient): Promise<boolean> {
  try {
    const checkpoint = await client.getLatestCheckpointSequenceNumber();
    console.log('Latest checkpoint:', checkpoint);
    return true;
  } catch (error) {
    console.error('Node unhealthy:', error);
    return false;
  }
}

async fn check_connection(client: &SuiClient) -> Result<bool> {
    match client.read_api().get_latest_checkpoint_sequence_number().await {
        Ok(seq) => {
            println!("Connected. Latest checkpoint: {}", seq);
            Ok(true)
        }
        Err(e) => {
            eprintln!("Connection failed: {}", e);
            Ok(false)
        }
    }
}

const network = process.env.NODE_ENV === 'production' 
  ? 'mainnet' 
  : 'testnet';

const client = new SuiClient({
  url: getFullnodeUrl(network),
});

const client = new SuiClient({
  url: getFullnodeUrl('testnet'),
  // Add timeout configuration if needed
});

sui client active-env
sui client active-address