Tutoriel : Déployez Votre Premier Jeton SAVITRI-20

Ce tutoriel vous guide dans le déploiement d'un jeton fongible sur le Savitri Network en utilisant le SDK.

Prérequis

• Un nœud léger Savitri en fonctionnement (voir Démarrage Rapide)
• Chaîne d'outils Rust installée
• Un portefeuille financé (utilisez le faucet du testnet)

1. Configuration du Projet

Créez un nouveau projet Rust :

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

Ajoutez les dépendances à 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<()> {
    // Create or import a wallet
    let wallet = Wallet::new();
    println!("Your address: {}", wallet.address());

    // Connect to local node
    let client = RpcClient::from_url("http://localhost:8545")?;

    // Check if node is running
    let health = client.health().await?;
    println!("Connected to {} ({})", health.service, health.mode);

    Ok(())
}

3. Financer Votre Portefeuille

Réclamez des jetons de test via le faucet :

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

// Wait for confirmation
tokio::time::sleep(std::time::Duration::from_secs(10)).await;

// Verify balance
let account = client.get_account(wallet.address()).await?;
println!("Balance: {} (nonce: {})", account.balance, account.nonce);

4. Déployer le Contrat de Jeton

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

use savitri_sdk::TransactionBuilder;

// Encode token initialization parameters
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
}

// Build deploy transaction
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()
    // No .to() — indicates contract deployment
    .data(deploy_data)
    .value(0)
    .nonce(nonce)
    .fee(5_000_000_000_000_000) // 0.005 SAVT contract fee
    .build_and_sign(&wallet)?;

println!("Deploy TX built. Contract will be created at a derived address.");

5. Interagir avec le Jeton

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

use savitri_sdk::ContractClient;

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

// Transfer tokens
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!("Transfer TX: {}", tx_hash);

6. Vérifier le Solde du Jeton

// Via RPC
let balance = client.call_raw(
    "account_getTokenBalance",
    serde_json::json!([wallet.address(), token_contract_address]),
).await?;
println!("Token balance: {}", 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	NFTs	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 NFT	0,005
Transfert par lot	0,005

Montants et Décimales

Tous les jetons Savitri utilisent 18 décimales :

1 token     = 1_000_000_000_000_000_000  (10^18)
0.001 token = 1_000_000_000_000_000      (10^15)
1M tokens   = 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 les contrats s'exécutent
• Gouvernance -- Proposer des changements de paramètres de jeton