Costruzione e Invio di Transazioni

Il TransactionBuilder fornisce un'API fluente per costruire, firmare e inviare transazioni alla Savitri Network.

Trasferimento Semplice

use savitri_sdk::{Wallet, TransactionBuilder, RpcClient};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = RpcClient::from_url("http://localhost:8545")?;
    let wallet = Wallet::from_private_key_hex("your_private_key_hex")?;

    // Get current nonce
    let nonce = client.get_nonce(wallet.address()).await?;

    // Build and sign
    let signed_tx = TransactionBuilder::new()
        .to("recipient_address_64hex")
        .value(1_000_000_000_000_000_000)  // 1 SAVT (18 decimals)
        .nonce(nonce)
        .fee(1_000_000_000_000_000)        // 0.001 SAVT fee
        .build_and_sign(&wallet)?;

    // Submit
    let result = client.send_raw_transaction(&serialize_tx(&signed_tx)).await?;
    println!("TX hash: {}", result.tx_hash);

    Ok(())
}

API del Builder

Campi Obbligatori

Metodo	Tipo	Descrizione
.from(address)	String	Indirizzo del mittente (compilato automaticamente dal wallet se omesso)
.to(address)	String	Indirizzo del destinatario
.value(amount)	u128	Importo del trasferimento nell'unità minima

Campi Opzionali

Metodo	Tipo	Predefinito	Descrizione
.nonce(n)	u64	0	Nonce della transazione (ottieni con get_nonce())
.fee(f)	u128	Nessuno	Commissione della transazione
.data(bytes)	Vec<u8>	Nessuno	Payload per le chiamate ai contratti

Costruisci Senza Firma

let unsigned = TransactionBuilder::new()
    .from("sender_address")
    .to("recipient_address")
    .value(1000)
    .nonce(5)
    .build()?;

// unsigned.from, unsigned.to, unsigned.value, unsigned.nonce, unsigned.fee, unsigned.data

Costruisci e Firma

let signed = TransactionBuilder::new()
    .to("recipient_address")
    .value(1000)
    .nonce(5)
    .fee(100)
    .build_and_sign(&wallet)?;

// signed.transaction -- the UnsignedTransaction
// signed.public_key  -- 32-byte ed25519 public key
// signed.signature   -- 64-byte ed25519 signature

Se .from() non viene chiamato, l'indirizzo del wallet viene usato automaticamente.

Chiamate Oracle

let signed = TransactionBuilder::new()
    .oracle_call(
        "oracle_contract_address",
        "request_data",
        b"temperature_sensor_01",
    )
    .value(0)
    .nonce(nonce)
    .build_and_sign(&wallet)?;

Chiamate di Governance

Vota su una Proposta

use savitri_sdk::GovernanceAction;

let signed = TransactionBuilder::new()
    .governance_call(
        "governance_contract_address",
        proposal_id,              // u64
        GovernanceAction::Vote(true),  // true = support, false = oppose
    )
    .nonce(nonce)
    .build_and_sign(&wallet)?;

Esegui una Proposta Approvata

let signed = TransactionBuilder::new()
    .governance_call(
        "governance_contract_address",
        proposal_id,
        GovernanceAction::Execute,
    )
    .nonce(nonce)
    .build_and_sign(&wallet)?;

Crea una Proposta FL

let signed = TransactionBuilder::new()
    .create_fl_proposal(
        "governance_contract_address",
        "Upgrade model v2",        // title
        "Replace BERT with GPT-4", // description
        604800,                    // voting period in seconds (7 days)
    )
    .nonce(nonce)
    .build_and_sign(&wallet)?;

Formato di Firma delle Transazioni

Il messaggio di firma viene costruito come:

from_hex_bytes || to_hex_bytes || amount_le_u64 || nonce_le_u64 || fee_le_u128

Viene quindi sottoposto a hash SHA-256, e l'hash viene firmato con Ed25519.

Questo formato corrisponde alla verifica lato server in savitri-rpc.

Importi e Decimali

Tutti gli importi usano 18 decimali:

Importo Leggibile	Valore Grezzo
1 SAVT	1_000_000_000_000_000_000
0.1 SAVT	100_000_000_000_000_000
0.001 SAVT	1_000_000_000_000_000
0.00001 SAVT	10_000_000_000_000

Riferimento alle Commissioni

Tipo di Transazione	Commissione (SAVT)	Valore Grezzo
Trasferimento normale	0.001	1_000_000_000_000_000
Chiamata a contratto	0.005	5_000_000_000_000_000
Dati IoT	0.00005	50_000_000_000_000