Tutoriel : Déployer votre Premier Jeton SAVITRI-20

Ce tutoriel vous guide dans le déploiement d'un jeton fongible sur le réseau Savitri à l'aide du SDK.

Prérequis

• Un lightnode Savitri en cours d'exécution (voir Démarrage Rapide)
• La chaîne d'outils Rust installée
• Un portefeuille approvisionné (utilisez le faucet du réseau de test)

1. Configuration du Projet

Créez un nouveau projet Rust :

cargo new my-savitri-token
cd my-savitri-token

Ajoutez les dépendances au Cargo.toml :

[dependencies]
savitri-sdk = { path = "../savitri-sdk" }
tokio = { version = "1", features = ["full"] }
anyhow = "1"
hex = "0.4"

2. Créer un Portefeuille

use savitri_sdk::{Wallet, RpcClient};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Créer ou importer un portefeuille
    let wallet = Wallet::new();
    println!("Votre adresse : {}", wallet.address());

    // Se connecter au nœud local
    let client = RpcClient::from_url("http://localhost:8545")?;

    // Vérifier que le nœud fonctionne
    let health = client.health().await?;
    println!("Connecté à {} ({})", health.service, health.mode);

    Ok(())
}

3. Approvisionner votre Portefeuille

Réclamez des jetons de réseau de test via le faucet :

let claim = client.faucet_claim(wallet.address()).await?;
println!("Reçu {} SAVT (tx : {})", claim.amount, claim.tx_hash);

// Attendre la confirmation
tokio::time::sleep(std::time::Duration::from_secs(10)).await;

// Vérifier le solde
let account = client.get_account(wallet.address()).await?;
println!("Solde : {} (nonce : {})", account.balance, account.nonce);

4. Déployer le Contrat de Jeton

Le déploiement d'un jeton est une transaction avec to = None et les données d'initialisation dans data :

use savitri_sdk::TransactionBuilder;

// Encoder les paramètres d'initialisation du jeton
fn encode_token_init(name: &str, symbol: &str, initial_supply: u128) -> Vec<u8> {
    let mut data = b"initialize_savitri20".to_vec();
    data.push(0); // separator

    // Name (length-prefixed)
    data.extend_from_slice(&(name.len() as u32).to_le_bytes());
    data.extend_from_slice(name.as_bytes());

    // Symbol (length-prefixed)
    data.extend_from_slice(&(symbol.len() as u32).to_le_bytes());
    data.extend_from_slice(symbol.as_bytes());

    // Initial supply (u128 LE)
    data.extend_from_slice(&initial_supply.to_le_bytes());

    data
}

// Construire la transaction de déploiement
let nonce = client.get_nonce(wallet.address()).await?;

let deploy_data = encode_token_init(
    "My Token",                              // name
    "MTK",                                   // symbol
    1_000_000_000_000_000_000_000_000,       // 1M tokens (18 decimals)
);

let deploy_tx = TransactionBuilder::new()
    // Pas de .to() — indique un déploiement de contrat
    .data(deploy_data)
    .value(0)
    .nonce(nonce)
    .fee(5_000_000_000_000_000) // 0.005 SAVT contract fee
    .build_and_sign(&wallet)?;

println!("TX de déploiement construite. Le contrat sera créé à une adresse dérivée.");

5. Interagir avec le Jeton

Une fois déployé, utilisez le ContractClient pour interagir :

use savitri_sdk::ContractClient;

let contract = ContractClient::from_url_and_wallet(
    "http://localhost:8545",
    wallet.clone(),
)?;

// Transférer des jetons
let tx_hash = contract.call_contract(
    &token_contract_address,
    b"transfer",
    &encode_transfer(&recipient_address, 1000_000_000_000_000_000), // 1000 tokens
    Some(0),
).await?;
println!("TX de transfert : {}", tx_hash);

6. Vérifier le Solde de Jetons

// Via RPC
let balance = client.call_raw(
    "account_getTokenBalance",
    serde_json::json!([wallet.address(), token_contract_address]),
).await?;
println!("Solde de jetons : {}", balance);

Référence Rapide des Standards de Jetons

Standard	Cas d'Usage	Fonctions Clés
SAVITRI-20	Jetons fongibles	transfer, approve, transferFrom
SAVITRI-721	NFT	mint, transferFrom, tokenURI
SAVITRI-1155	Multi-actifs	safeTransferFrom, balanceOfBatch

Référence des Frais

Opération	Frais (SAVT)
Déploiement de jeton	0.005
Transfert de jeton	0.005
Approbation de jeton	0.005
Frappe de NFT	0.005
Transfert par lot	0.005

Montants et Décimales

Tous les jetons Savitri utilisent 18 décimales :

1 jeton      = 1_000_000_000_000_000_000  (10^18)
0.001 jeton  = 1_000_000_000_000_000      (10^15)
1M de jetons = 1_000_000_000_000_000_000_000_000  (10^24)

Étapes Suivantes

• Référence SAVITRI-20 -- API complète des jetons fongibles
• Environnement d'Exécution des Contrats -- Comment s'exécutent les contrats
• Gouvernance -- Proposer des modifications des paramètres des jetons