Rust SDK API Reference

Complete API documentation for Selendra Rust SDK.

SelendraSDK

Main SDK struct providing access to all Selendra functionality.

Constructors & Core Methods

Method	Signature	Returns	Description
`new()`	`pub fn new(network: Network, ws_endpoint: &str) -> Result<Self>`	SDK instance	Create SDK with network and endpoint
`with_options()`	`pub fn with_options(options: SelendraSDKOptions) -> Result<Self>`	SDK instance	Create SDK with full configuration
`connect()`	`pub async fn connect(&mut self) -> Result<()>`	Connection status	Establish network connection
`disconnect()`	`pub async fn disconnect(&mut self) -> Result<()>`	Disconnection status	Close network connection
`is_connected()`	`pub fn is_connected(&self) -> bool`	Connection state	Check connection status
`get_chain_info()`	`pub async fn get_chain_info(&self) -> Result<ChainInfo>`	Chain metadata	Get chain information

Example

use selendra_sdk::{SelendraSDK, Network};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut sdk = SelendraSDK::new(Network::Mainnet, "wss://rpc.selendra.org")?;
    sdk.connect().await?;
    let info = sdk.get_chain_info().await?;
    println!("Connected to {}", info.chain_name);
    Ok(())
}

Configuration Types

SelendraSDKOptions

Configuration options for the SDK.

pub struct SelendraSDKOptions {
    pub network: Network,
    pub ws_endpoint: String,
    pub http_endpoint: Option<String>,
    pub default_account: Option<String>,
    pub auto_connect: bool,
    pub connection_timeout: Option<Duration>,
    pub retry_attempts: u32,
    pub retry_delay: Duration,
}

Network

Network configuration.

pub enum Network {
    Mainnet,
    Testnet,
    Custom {
        chain_id: u64,
        ws_endpoint: String,
        http_endpoint: Option<String>,
    },
}

NetworkConfig

Network-specific configuration.

pub struct NetworkConfig {
    pub name: String,
    pub chain_id: u64,
    pub ws_endpoint: String,
    pub http_endpoint: Option<String>,
    pub block_time: Duration,
    pub decimals: u8,
    pub token_symbol: String,
}

impl Network {
    pub fn config(&self) -> NetworkConfig;
}

Account Management

Methods

Method	Signature	Returns	Description
`create_account()`	`pub async fn create_account(&mut self, options: Option<CreateAccountOptions>) -> Result<CreatedAccount>`	New account with mnemonic	Create account with random mnemonic
`import_account_from_mnemonic()`	`pub async fn import_account_from_mnemonic(&mut self, mnemonic: &str, options: Option<ImportAccountOptions>) -> Result<Account>`	Imported account	Import from mnemonic phrase
`import_account_from_private_key()`	`pub async fn import_account_from_private_key(&mut self, private_key: &str, options: Option<ImportAccountOptions>) -> Result<Account>`	Imported account	Import from private key
`get_accounts()`	`pub async fn get_accounts(&self) -> Result<Vec<Account>>`	Account list	Get all available accounts
`get_balance()`	`pub async fn get_balance(&self, address: &str) -> Result<Balance>`	Account balance	Get balance for address

Types

pub struct CreateAccountOptions {
    pub account_type: AccountType,
    pub name: Option<String>,
    pub password: Option<String>,
    pub derivation_path: Option<String>,
}

pub enum AccountType { Substrate, Evm, Both }

pub struct CreatedAccount {
    pub mnemonic: String,
    pub account: Account,
}

pub struct Balance {
    pub free: u128,
    pub reserved: u128,
    pub frozen: u128,
    pub total: u128,
    pub token_symbol: String,
    pub decimals: u8,
}

Example

let created = sdk.create_account(Some(CreateAccountOptions {
    account_type: AccountType::Both,
    name: Some("My Wallet".to_string()),
    password: None,
    derivation_path: Some("//m/44'/354'/0'/0'/0'".to_string()),
})).await?;

println!("Mnemonic: {}", created.mnemonic);
println!("Address: {}", created.account.address);

let balance = sdk.get_balance(&created.account.address).await?;
println!("Balance: {} {}", balance.free, balance.token_symbol);

Transactions

Methods

Method	Signature	Returns	Description
`transfer()`	`pub async fn transfer(&self, options: TransferOptions) -> Result<Transaction>`	Transaction details	Transfer tokens to address
`send_transaction()`	`pub async fn send_transaction(&self, options: SendTransactionOptions) -> Result<Transaction>`	Transaction details	Send custom transaction
`estimate_gas()`	`pub async fn estimate_gas(&self, options: SendTransactionOptions) -> Result<u64>`	Gas estimate	Estimate gas for transaction
`get_transaction()`	`pub async fn get_transaction(&self, hash: &str) -> Result<Option<Transaction>>`	Transaction details	Get transaction by hash
`get_transaction_receipt()`	`pub async fn get_transaction_receipt(&self, hash: &str) -> Result<Option<TransactionReceipt>>`	Receipt details	Get transaction receipt

Types

pub struct TransferOptions {
    pub to: String,
    pub amount: u128,
    pub from: Option<String>,
    pub memo: Option<String>,
    pub gas_limit: Option<u64>,
    pub max_fee_per_gas: Option<u128>,
    pub max_priority_fee_per_gas: Option<u128>,
}

Returns

pub struct Transaction {
    pub hash: String,
    pub from: String,
    pub to: String,
    pub amount: Option<u128>,
    pub data: Option<Vec<u8>>,
    pub gas_limit: Option<u64>,
    pub max_fee_per_gas: Option<u128>,
    pub max_priority_fee_per_gas: Option<u128>,
    pub nonce: Option<u64>,
    pub block_number: Option<u64>,
    pub gas_limit: Option<u64>,
    pub max_fee_per_gas: Option<u128>,
    pub max_priority_fee_per_gas: Option<u128>,
}

pub struct SendTransactionOptions {
    pub from: Option<String>,
    pub to: Option<String>,
    pub data: Option<Vec<u8>>,
    pub value: Option<u128>,
    pub gas_limit: Option<u64>,
    pub max_fee_per_gas: Option<u128>,
    pub max_priority_fee_per_gas: Option<u128>,
    pub nonce: Option<u64>,
}

pub struct Transaction {
    pub hash: String,
    pub from: String,
    pub to: String,
    pub amount: Option<u128>,
    pub data: Option<Vec<u8>>,
    pub nonce: Option<u64>,
    pub block_number: Option<u64>,
    pub block_hash: Option<String>,
    pub status: TransactionStatus,
    pub events: Vec<TransactionEvent>,
}

pub enum TransactionStatus { Pending, Included, Finalized, Failed { error: String } }

Example

let tx = sdk.transfer(TransferOptions {
    to: "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY".to_string(),
    amount: 1_000_000_000_000,
    from: None,
    memo: Some("Payment".to_string()),
    gas_limit: None,
    max_fee_per_gas: None,
    max_priority_fee_per_gas: None,
}).await?;

println!("Transaction: {} - Status: {:?}", tx.hash, tx.status);

Smart Contracts

Contract Struct

Method	Signature	Returns	Description
`new()`	`pub fn new(address: &str, abi: &[u8], sdk: &SelendraSDK) -> Result<Self>`	Contract instance	Create contract interface
`call()`	`pub async fn call(&self, function: &str, args: &[Token]) -> Result<Token>`	Function output	Call view function
`send()`	`pub async fn send(&self, function: &str, args: &[Token], options: SendOptions) -> Result<Transaction>`	Transaction	Execute contract function

SDK Methods

Method	Signature	Returns	Description
`deploy_contract()`	`pub async fn deploy_contract(&self, options: DeployOptions) -> Result<DeployedContract>`	Contract address	Deploy new contract

Types

pub struct Contract<'a> {
    pub address: String,
    pub abi: EthAbi,
    sdk: &'a SelendraSDK,
}

pub struct SendOptions {
    pub from: Option<String>,
    pub value: Option<u128>,
    pub gas_limit: Option<u64>,
}

pub struct DeployOptions {
    pub bytecode: Vec<u8>,
    pub abi: Vec<u8>,
    pub constructor_args: Vec<ethabi::Token>,
    pub from: Option<String>,
    pub gas_limit: Option<u64>,
}

pub struct DeployedContract {
    pub address: String,
    pub transaction_hash: String,
    pub block_number: Option<u64>,
}

Example

// Deploy contract
let deployed = sdk.deploy_contract(DeployOptions {
    bytecode: contract_bytecode,
    abi: abi_bytes,
    constructor_args: vec![Token::String("My Token".to_string()), Token::String("MTK".to_string())],
    from: Some(my_address),
    gas_limit: None,
}).await?;

// Interact with contract
let contract = Contract::new(&deployed.address, &abi_bytes, &sdk)?;
let balance = contract.call("balanceOf", &[Token::Address(addr.parse()?)]).await?;

EVM Compatibility

Methods

Method	Signature	Returns	Description
`get_evm_account()`	`pub async fn get_evm_account(&self, address: &str) -> Result<EvmAccount>`	Account info	Get EVM account details
`get_evm_transaction_count()`	`pub async fn get_evm_transaction_count(&self, address: &str) -> Result<u64>`	Nonce	Get transaction count
`get_evm_block()`	`pub async fn get_evm_block(&self, block: BlockId) -> Result<EvmBlock>`	Block data	Get block information
`send_evm_transaction()`	`pub async fn send_evm_transaction(&self, tx: EvmTransactionRequest) -> Result<EvmTransaction>`	Transaction	Send EVM transaction

Types

pub struct EvmAccount {
    pub address: String,
    pub nonce: u64,
    pub balance: u128,
    pub code_hash: String,
}

pub enum BlockId { Number(u64), Hash(String), Latest, Earliest, Pending }

pub struct EvmTransactionRequest {
    pub from: String,
    pub to: Option<String>,
    pub data: Option<Vec<u8>>,
    pub value: Option<u128>,
    pub gas: Option<u64>,
    pub nonce: Option<u64>,
}

Substrate Integration

Methods

Method	Signature	Returns	Description
`query()`	`pub async fn query(&self, pallet: &str, storage: &str, args: &[String]) -> Result<Value>`	Storage value	Query Substrate storage
`tx()`	`pub fn tx(&self, pallet: &str, method: &str, args: &[Value]) -> SubmittableExtrinsic`	Extrinsic	Create Substrate transaction
`get_runtime_version()`	`pub async fn get_runtime_version(&self) -> Result<RuntimeVersion>`	Runtime info	Get runtime version
`subscribe_to_heads()`	`pub async fn subscribe_to_heads(&self, callback: F) -> Result<Unsubscribe>`	Unsubscribe handle	Subscribe to new blocks

Example

// Query storage
let account_info = sdk.query("System", "Account", &["5GrwvaEF..."]).await?;

// Create and send transaction
let tx = sdk.tx("Balances", "transfer", &[
    Value::String("5GrwvaEF...".to_string()),
    Value::Number(1_000_000_000_000.into()),
]);
let hash = tx.sign_and_send(&keypair).await?;

// Subscribe to blocks
let unsub = sdk.subscribe_to_heads(|header| {
    println!("New block: {}", header.number);
}).await?;

Utilities

Methods

Method	Signature	Returns	Description
`format_balance()`	`pub fn format_balance(balance: u128, decimals: u8) -> String`	Formatted string	Format balance for display
`parse_balance()`	`pub fn parse_balance(balance: &str, decimals: u8) -> Result<u128>`	Parsed amount	Parse balance string
`address_to_evm()`	`pub fn address_to_evm(substrate_address: &str) -> Result<String>`	EVM address	Convert Substrate to EVM address
`evm_to_address()`	`pub fn evm_to_address(evm_address: &str) -> Result<String>`	Substrate address	Convert EVM to Substrate address
`validate_address()`	`pub fn validate_address(address: &str) -> AddressType`	Address type	Validate address format
`get_fee_estimate()`	`pub async fn get_fee_estimate(&self) -> Result<FeeEstimate>`	Fee info	Get current fee estimates

Types

pub enum AddressType { Substrate, Evm, Invalid }

pub struct FeeEstimate {
    pub slow: FeeTier,
    pub average: FeeTier,
    pub fast: FeeTier,
}

pub struct FeeTier {
    pub max_fee_per_gas: u128,
    pub max_priority_fee_per_gas: u128,
    pub estimated_time: u64,
}

Core Types

Account

pub struct Account {
    pub address: String,
    pub name: Option<String>,
    pub account_type: AccountType,
    pub public_key: String,
}

ChainInfo

pub struct ChainInfo {
    pub chain_name: String,
    pub chain_id: u64,
    pub version: String,
    pub spec_version: u32,
    pub impl_version: u32,
    pub token_decimals: u8,
    pub token_symbol: String,
}

RuntimeVersion

pub struct RuntimeVersion {
    pub spec_name: String,
    pub impl_name: String,
    pub authoring_version: u32,
    pub spec_version: u32,
    pub impl_version: u32,
}

Error Handling

SelendraError

pub enum SelendraError {
    ConnectionError(String),
    InvalidAddress(String),
    InsufficientBalance { required: u128, available: u128 },
    TransactionFailed(String),
    ContractError(String),
    Timeout,
    SerializationError(String),
    DeserializationError(String),
    Other(String),
}

impl std::fmt::Display for SelendraError { /* ... */ }
impl std::error::Error for SelendraError { /* ... */ }

Example

match sdk.transfer(options).await {
    Ok(tx) => println!("Transfer successful: {}", tx.hash),
    Err(SelendraError::InsufficientBalance { required, available }) => {
        eprintln!("Insufficient balance: need {}, have {}", required, available);
    },
    Err(SelendraError::InvalidAddress(addr)) => {
        eprintln!("Invalid address: {}", addr);
    },
    Err(e) => eprintln!("Transfer failed: {}", e),
}

Async Patterns

All async operations use Rust's async/await syntax and require a Tokio runtime.

Example

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut sdk = SelendraSDK::new(Network::Mainnet, "wss://rpc.selendra.org")?;
    sdk.connect().await?;

    let balance = sdk.get_balance("5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY").await?;
    println!("Balance: {}", balance.free);

    // Timeout example
    use tokio::time::timeout;
    let result = timeout(Duration::from_secs(30), sdk.get_balance(address)).await??;

    Ok(())
}

This API reference covers all major functionality of the Selendra Rust SDK. For more examples, check out our examples directory and tutorials.

React

Status

Contribute

Found an issue or want to contribute?

Help us improve this documentation by editing this page on GitHub.

Edit this page on GitHub

← Back to Documentation