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

Edit this page Report a problem