Tensora Rust SDK

Official Rust SDK for the Tensora L2 AI Network

A production-ready SDK for building on Tensora — an OP Stack Layer-2 blockchain with BSC settlement

📖 Documentation • 🚀 Quick Start • 🏗️ Architecture • 💬 Discord

🚀 Features

• ✅ Typed Contract Bindings — Auto-generated bindings for TORA token, staking, subnets, bridge, and paymaster
• 🔐 Wallet Abstraction — Secure keystore and signer management
• 🌉 Bridge Helpers — L1↔L2 token bridging (WTORA deposits/withdrawals)
• 📊 API Clients — REST clients for indexer, explorer, and coordinator services
• ⛽ Paymaster Support — ERC-4337 gasless transactions
• 🏗️ Subnet Management — Create and manage subnets, validators, and miners
• 🔄 Async-first — Built on tokio and ethers-rs
• 🛡️ BSC Reorg Handling — Safe bridge operations with confirmation tracking

📦 Installation

Add to your Cargo.toml:

[dependencies]
tensora = "0.1"
ethers = "2"
tokio = { version = "1", features = ["full"] }

Or use cargo add:

cargo add tensora ethers
cargo add tokio --features full

⚡ Quick Start

1. Set Up Environment

Create a .env file:

TENSORA_RPC=https://rpc.tensora.sh
TENSORA_CHAIN_ID=44444444
BSC_RPC=https://bsc-dataseed.binance.org
PRIVATE_KEY=0x...  # Optional, for signing transactions

2. Connect to Tensora L2

use tensora::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load configuration from environment
    let config = TensoraConfig::from_env()?;
    
    // Create client
    let client = TensoraClient::new(&config).await?;
    
    // Get current block number
    let block = client.get_block_number().await?;
    println!("Current block: {}", block);
    
    Ok(())
}

3. Check Balance

use tensora::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = TensoraClient::default().await?;
    
    let address: Address = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb".parse()?;
    let balance = client.get_balance(address).await?;
    
    println!("Balance: {} BNB", ethers::utils::format_ether(balance));
    
    Ok(())
}

4. Work with TORA Token

use tensora::prelude::*;
use tensora::contracts::ToraToken;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = TensoraClient::default().await?;
    
    // WTORA token address on Tensora L2
    let wtora_addr: Address = "0x...".parse()?;
    let wtora = ToraToken::new(wtora_addr, &client);
    
    // Get token info
    let symbol = wtora.symbol().await?;
    let decimals = wtora.decimals().await?;
    let total_supply = wtora.total_supply().await?;
    
    println!("Token: {}", symbol);
    println!("Decimals: {}", decimals);
    println!("Total Supply: {}", ethers::utils::format_units(total_supply, decimals)?);
    
    // Check balance
    let my_addr: Address = "0x...".parse()?;
    let balance = wtora.balance_of(my_addr).await?;
    println!("My balance: {} {}", ethers::utils::format_units(balance, decimals)?, symbol);
    
    Ok(())
}

5. Query Subnet Information

use tensora::api::IndexerClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let indexer = IndexerClient::new("https://indexer.tensora.sh")?;
    
    // List all subnets
    let subnets = indexer.list_subnets().await?;
    for subnet in subnets {
        println!("Subnet #{}: {} ({} validators, {} miners)",
            subnet.id,
            subnet.name,
            subnet.validator_count,
            subnet.miner_count
        );
    }
    
    Ok(())
}

📖 Examples

Run the included examples:

# Check balance
cargo run --example get_balance

# Monitor bridge deposits
cargo run --example bridge_deposit

# Check staking info
cargo run --example stake

🔧 Configuration

Environment Variables

Programmatic Configuration

use tensora::config::{TensoraConfig, AddressConfig};

let config = TensoraConfig::new(
    "https://rpc.tensora.sh".to_string(),
    "https://bsc-dataseed.binance.org".to_string(),
)
.with_private_key("0x...".to_string())
.with_addresses(AddressConfig {
    l2_wtora: Some("0x...".to_string()),
    staking_hub: Some("0x...".to_string()),
    ..Default::default()
});

🏗️ Architecture

Core Modules

• client — RPC client for L2 (Tensora) and L1 (BSC)
• config — Configuration management and validation
• wallet — Wallet and signer abstraction
• types — Shared types (SubnetInfo, ValidatorInfo, etc.)
• errors — Error handling with thiserror
• contracts — Smart contract bindings
  • tora_token — TORA/WTORA ERC-20 token
  • staking_hub — Staking and rewards
  • subnet_factory — Subnet creation and management
  • bridge — OP Stack L1/L2 Standard Bridge
  • paymaster — ERC-4337 Paymaster
• api — Off-chain API clients
  • indexer — Subnet, validator, and miner data
  • explorer — Transaction and block data
  • coordinator — Epoch and VRF data

🌉 Bridge Operations

L1 → L2 Deposit (BSC → Tensora)

// Note: This requires a signer and actual bridge implementation
// Placeholder for reference:

// 1. Approve WTORA on L1
// 2. Call depositERC20() on L1 Bridge
// 3. Wait for L1 confirmation
// 4. Wait for L2 relay (2-5 minutes)
// 5. Verify balance on L2

⚠️ Important: BSC can experience reorgs. Wait for at least 15 confirmations on L1 before considering a deposit finalized.

L2 → L1 Withdrawal (Tensora → BSC)

// Note: This requires a signer and actual bridge implementation
// Withdrawal process:

// 1. Call withdrawERC20() on L2 Bridge
// 2. Wait for state root submission (~1 hour)
// 3. Wait for challenge period (~7 days on mainnet, faster on testnet)
// 4. Call finalizeWithdrawal() on L1
// 5. Verify balance on L1

🔒 Staking

use tensora::contracts::StakingHub;

// Get staking info
let staking_hub = StakingHub::new(staking_addr, &client);
let total_staked = staking_hub.get_total_staked().await?;
let my_stake = staking_hub.get_stake(my_addr).await?;
let rewards = staking_hub.get_rewards(my_addr).await?;

// Note: stake(), unstake(), and claim() require SignerMiddleware

🧪 Testing

cargo test

📚 Documentation

Generate and view documentation:

cargo doc --open

Or visit docs.rs/tensora-rs

🔗 Network Information

Tensora L2 Mainnet

BSC L1

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

📄 License

Licensed under the Apache License, Version 2.0. See LICENSE for details.

🔗 Links

• Homepage: https://tensora.sh
• Documentation: https://docs.tensora.sh
• Explorer: https://explorer.tensora.sh
• GitHub: https://github.com/TensoraL2/tensora-rs
• Discord: https://discord.gg/tensora

⚠️ Disclaimer

This SDK is provided "as is" without warranty of any kind. Use at your own risk. Always test on testnet before using on mainnet.

Built with ❤️ by the Tensora Labs team