Rust SDK

The official Rust SDK for Tenzro Platform provides type-safe, async-first access to all services with zero-copy deserialization and comprehensive error handling.

Installation

[dependencies]
tenzro-platform = "0.1"

# With all features
tenzro-platform = { version = "0.1", features = ["full"] }

# Minimal (no TLS, bring your own)
tenzro-platform = { version = "0.1", default-features = false }

Requirements

• Rust 1.70 or later
• Tokio runtime (async)

Basic Usage

use tenzro_platform::TenzroPlatform;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let platform = TenzroPlatform::builder()
        .api_key(std::env::var("TENZRO_API_KEY")?)
        .tenant_id(std::env::var("TENZRO_TENANT_ID")?)
        .build()?;

    // List wallets
    let wallets = platform.wallet().list().await?;
    for wallet in wallets {
        println!("Wallet: {} ({})", wallet.name, wallet.address);
    }

    Ok(())
}

Available Services

Wallet Service

use tenzro_platform::wallet::{CreateWalletRequest, WalletType, Chain};

// Create a wallet
let wallet = platform.wallet().create(CreateWalletRequest {
    name: "Treasury".to_string(),
    wallet_type: WalletType::MultiSig,
    chain: Chain::Ethereum,
    signers: Some(vec!["user_1".into(), "user_2".into(), "user_3".into()]),
    threshold: Some(2),
}).await?;

println!("Created wallet: {}", wallet.address);

// List wallets with filters
let wallets = platform.wallet()
    .list()
    .chain(Chain::Ethereum)
    .wallet_type(WalletType::MultiSig)
    .limit(10)
    .send()
    .await?;

// Get balance
let balance = platform.wallet().get_balance(&wallet.id).await?;
println!("Balance: {} ETH", balance.native);

// Get transactions
let txs = platform.wallet()
    .get_transactions(&wallet.id)
    .limit(50)
    .status(TxStatus::Confirmed)
    .send()
    .await?;

Token Service

use tenzro_platform::token::{TransferRequest, TokenAmount};

// Transfer tokens
let transfer = platform.token().transfer(TransferRequest {
    from: wallet_id.clone(),
    to: "0x...".to_string(),
    token: "USDC".to_string(),
    amount: TokenAmount::from_human("1000.0", 6), // 1000 USDC
    chain: Chain::Ethereum,
}).await?;

println!("Transfer tx: {}", transfer.tx_hash);

// Get token info
let token_info = platform.token()
    .get_info("USDC", Chain::Ethereum)
    .await?;

// Get token balance
let balance = platform.token()
    .get_balance(&wallet_id, "USDC")
    .await?;

Bridge Service

use tenzro_platform::bridge::{BridgeRequest, RouteQuery};

// Get available routes
let routes = platform.bridge().get_routes(RouteQuery {
    from_chain: Chain::Ethereum,
    to_chain: Chain::Polygon,
    token: "USDC".to_string(),
    amount: TokenAmount::from_human("1000.0", 6),
}).await?;

// Execute bridge transfer
let bridge_tx = platform.bridge().transfer(BridgeRequest {
    from_chain: Chain::Ethereum,
    to_chain: Chain::Polygon,
    from_wallet: wallet_id.clone(),
    to_address: "0x...".to_string(),
    token: "USDC".to_string(),
    amount: TokenAmount::from_human("1000.0", 6),
    route_id: routes[0].id.clone(),
}).await?;

// Check status
let status = platform.bridge().get_status(&bridge_tx.id).await?;
println!("Bridge status: {:?}", status.state);

AI Service

use tenzro_platform::ai::{InferenceRequest, Message, Role};

// Run inference in TEE
let response = platform.ai().inference(InferenceRequest {
    model: "gpt-4".to_string(),
    messages: vec![
        Message {
            role: Role::System,
            content: "You are a financial analyst.".to_string(),
        },
        Message {
            role: Role::User,
            content: "Analyze this transaction for risk.".to_string(),
        },
    ],
    attestation: true,
    ..Default::default()
}).await?;

println!("Response: {}", response.content);
if let Some(attestation) = response.attestation {
    println!("TEE Attestation: {}", attestation.quote);
}

// Generate embeddings
let embeddings = platform.ai().embed(EmbedRequest {
    model: "text-embedding-3-small".to_string(),
    input: vec![
        "Transaction 1 data".to_string(),
        "Transaction 2 data".to_string(),
    ],
}).await?;

Ledger Service

use tenzro_platform::ledger::{CreateEntryRequest, LedgerEntry};
use rust_decimal::Decimal;

// Create journal entry
let entry = platform.ledger().create_entry(CreateEntryRequest {
    description: "Token transfer".to_string(),
    entries: vec![
        LedgerEntry {
            account: "assets:wallet:treasury".to_string(),
            debit: Some(Decimal::new(100000, 2)), // 1000.00
            credit: None,
        },
        LedgerEntry {
            account: "assets:wallet:operations".to_string(),
            debit: None,
            credit: Some(Decimal::new(100000, 2)),
        },
    ],
    metadata: Some(serde_json::json!({ "tx_hash": "0x..." })),
}).await?;

// Get account balance
let balance = platform.ledger()
    .get_balance("assets:wallet:treasury")
    .await?;

// Query transactions
let transactions = platform.ledger()
    .query()
    .account("assets:*")
    .start_date("2024-01-01")
    .end_date("2024-12-31")
    .send()
    .await?;

Anchor Service

use tenzro_platform::anchor::{AnchorRequest, AnchorData};

// Anchor data to blockchain
let anchor = platform.anchor().create(AnchorRequest {
    data: AnchorData {
        document_id: "doc_123".to_string(),
        hash: "sha256:...".to_string(),
    },
    chain: Chain::Ethereum,
}).await?;

println!("Anchor ID: {}", anchor.id);

// Verify anchor
let verification = platform.anchor().verify(&anchor.id).await?;
assert!(verification.verified);
println!("On-chain tx: {}", verification.tx_hash);

Events Service

use tenzro_platform::events::{EventSubscription, EventHandler};
use futures::StreamExt;

// Subscribe to events
let mut subscription = platform.events()
    .subscribe(&["wallet:*", "bridge:completed"])
    .await?;

// Process events
while let Some(event) = subscription.next().await {
    match event {
        Ok(evt) => println!("Event: {:?}", evt),
        Err(e) => eprintln!("Error: {}", e),
    }
}

// Or use callback style
platform.events()
    .subscribe_with_handler(
        &["wallet:*"],
        |event| async move {
            println!("Received: {:?}", event);
            Ok(())
        },
    )
    .await?;

Feature Flags