Client RPC

Le RpcClient est la couche de transport principale pour communiquer avec les nœuds Savitri via JSON-RPC 2.0.

Créer un Client

use savitri_sdk::RpcClient;

// Depuis une URL (HTTP localhost autorisé)
let client = RpcClient::from_url("http://localhost:8545")?;

// Depuis une URL (HTTPS requis pour les connexions distantes)
let client = RpcClient::from_url("https://rpc.savitrinetwork.com")?;

// Avec une configuration personnalisée
use savitri_sdk::client::rpc_client::RpcClientConfig;

let client = RpcClient::new(RpcClientConfig {
    url: "http://localhost:8545".to_string(),
    timeout: Some(60),          // délai de 60 secondes
    allow_insecure: false,      // imposer HTTPS pour les connexions distantes
})?;

Requêtes de Chaîne

// Hauteur de bloc
let height: u64 = client.get_block_number().await?;

// Bloc par hauteur
let block = client.get_block_by_height(42).await?;
println!("Hash du bloc {} : {}", block.height, block.hash);
println!("Proposant : {}", block.proposer);
println!("Nombre de TX : {}", block.transaction_count);

// Hash du bloc
let hash: String = client.get_block_hash(42).await?;

Requêtes de Compte

// Informations complètes du compte
let account = client.get_account("aabbcc...64chars").await?;
println!("Solde : {}", account.balance);  // u128 comme chaîne décimale
println!("Nonce : {}", account.nonce);

// Solde uniquement
let balance: String = client.get_balance("aabbcc...").await?;

// Nonce uniquement
let nonce: u64 = client.get_nonce("aabbcc...").await?;

Opérations sur les Transactions

// Obtenir une transaction par hash
let tx = client.get_transaction("tx_hash_hex").await?;
println!("De : {} Vers : {} Montant : {}", tx.from, tx.to, tx.amount);

// Soumettre une transaction signée
let result = client.send_raw_transaction("signed_tx_hex").await?;
println!("Hash TX : {}", result.tx_hash);

// Réclamer le faucet du réseau de test
let claim = client.faucet_claim("your_address_64hex").await?;
println!("Reçu : {} (tx : {})", claim.amount, claim.tx_hash);

Requêtes de Consensus

// État PoU local
let pou = client.pou_local().await?;
println!("Mon score : {:?}", pou.local_score);
println!("Leader : {:?} (score : {:?})", pou.leader, pou.leader_score);
println!("Suis-je le leader ? {}", pou.local_is_leader);

// Tous les scores des pairs
let peers = client.pou_peers().await?;
for (peer_id, score) in &peers.peers {
    println!("{} : {}", peer_id, score);
}

// Groupes (masternode uniquement)
let groups = client.pou_groups().await?;
for group in &groups.groups {
    println!("Groupe {} : {} membres", group.group_id, group.members.len());
}

// Masternodes (masternode uniquement)
let mns = client.pou_masternodes().await?;
for mn in &mns.masternodes {
    println!("{} : PoU={} Santé={}", mn.node_id, mn.pou_score, mn.health_score);
}

Requêtes par Lot

Envoyez plusieurs appels RPC dans une seule requête HTTP (max 100) :

let responses = client.batch(vec![
    ("savitri_blockNumber", serde_json::json!([])),
    ("savitri_health", serde_json::json!([])),
    ("savitri_getAccount", serde_json::json!(["aabbcc..."])),
]).await?;

for resp in &responses {
    println!("{}", resp);
}

Appels Bruts

Pour les méthodes non couvertes par les assistants typés :

let result: serde_json::Value = client
    .call_raw("custom_method", serde_json::json!(["param1", 42]))
    .await?;

Vérification de l'État

// Vérification typée de l'état
let health = client.health().await?;
assert_eq!(health.status, "ok");

// Ping simple (retourne un booléen)
let is_alive = client.ping().await?;

Gestion des Erreurs

use savitri_sdk::SdkError;

match client.get_account("invalid").await {
    Ok(account) => println!("Solde : {}", account.balance),
    Err(SdkError::RpcError { code, message, .. }) => {
        println!("Erreur RPC {} : {}", code, message);
    }
    Err(SdkError::HttpError(e)) => {
        println!("Erreur réseau : {}", e);
    }
    Err(e) => println!("Autre erreur : {}", e),
}

Types d'erreurs :

Erreur	Description
SdkError::RpcError	Erreur JSON-RPC du serveur (code, message, données)
SdkError::HttpError	Erreur réseau/transport
SdkError::JsonError	Erreur de sérialisation JSON
SdkError::InvalidResponse	Format de réponse inattendu
SdkError::NoRpcClient	Méthode de portefeuille appelée sans connexion RPC