Rust SDK

[dependencies]
nexus-sdk = "0.1"
tokio = { version = "1", features = ["full"] }

use nexus_sdk::{NexusClient, ClientConfig};

let config = ClientConfig {
    rpc_url: "http://localhost:8545".to_string(),
    rpc_urls: vec!["http://backup:8545".to_string()], // fallbacks
    network: "regtest".to_string(),
    default_gas_limit: 2_000_000,
    timeout_ms: 30000,
    max_requests_per_second: 100,
};

let client = NexusClient::new(config);

pub struct ClientConfig {
    /// Primary RPC endpoint
    pub rpc_url: String,
    
    /// Fallback RPC endpoints for failover
    pub rpc_urls: Vec<String>,
    
    /// Network (mainnet, testnet, regtest)
    pub network: String,
    
    /// Default gas limit
    pub default_gas_limit: u64,
    
    /// Request timeout in milliseconds
    pub timeout_ms: u64,
    
    /// Max requests per second (rate limiting)
    pub max_requests_per_second: u32,
}

impl Default for ClientConfig {
    fn default() -> Self {
        Self {
            rpc_url: "http://localhost:8545".to_string(),
            rpc_urls: Vec::new(),
            network: "regtest".to_string(),
            default_gas_limit: 2_000_000,
            timeout_ms: 30000,
            max_requests_per_second: 100,
        }
    }
}

let height = client.get_block_height().await?;
// Returns: u64

let balance = client.get_balance("bcrt1p...").await?;
// Returns: u128

let nonce = client.get_transaction_count(&address_bytes).await?;
// Returns: u64

use nexus_sdk::ContractBuilder;

let contract = ContractBuilder::new("my_contract")
    .wasm_file("./contract.wasm")
    .init_args_raw(init_args)
    .build()?;

let contract_id = client.deploy_contract(
    contract,
    &deployer_pubkey,
    Some(&secret_key),
    0  // value in sats
).await?;
// Returns: Vec<u8> (32-byte contract ID)

let result: u64 = client.call_contract(
    &contract_id,
    "get_balance",
    &args,
    &caller,
    0
).await?;

let result_bytes = client.call_contract_raw(
    &contract_id,
    "get_data",
    &args,
    &caller,
    0
).await?;
// Returns: Vec<u8>

let tx_id = client.send_contract_call_raw(
    &contract_id,
    "transfer",
    &args,
    &sender,
    Some(&secret_key),
    0
).await?;
// Returns: Vec<u8> (32-byte tx ID)

let value = client.get_state(&contract_id, b"my_key").await?;
// Returns: Option<Vec<u8>>

let events = client.query_events(
    Some(&contract_id),
    Some("Transfer"),
    Some(100),
    Some(200)
).await?;
// Returns: Vec<ContractEvent>

let receipt = client.wait_for_receipt("0x1234...").await?;
// Returns: serde_json::Value

let info = client.get_node_info().await?;
// Returns: serde_json::Value

let balance = client.get_token_balance(&token_contract, "bcrt1p...").await?;
// Returns: TokenBalance { balance: String, balance_decimal: u64 }

use nexus_sdk::ContractBuilder;

let contract = ContractBuilder::new("my_contract")
    .wasm_file("./contract.wasm")
    .init_args_raw(vec![1, 2, 3])
    .build()?;

// Or with typed init args
let contract = ContractBuilder::new("token")
    .wasm_file("./token.wasm")
    .init_args(&("MyToken", "MTK", 18u32, 1000000u64))?
    .build()?;

let builder = ContractBuilder::new("contract_name");

builder.wasm_file("./contract.wasm")

builder.wasm_bytes(wasm_bytes)

builder.init_args(&("arg1", 100u64))?

builder.init_args_raw(vec![1, 2, 3])

let contract = builder.build()?;

use nexus_sdk::NexusClient;
use secp256k1::SecretKey;

let secret_key = SecretKey::from_slice(&key_bytes)?;

// Sign is handled internally by deploy_contract and send_contract_call_raw
// when you provide a signer key

// For manual signing:
let mut tx = Transaction { /* ... */ };
client.sign_transaction(&mut tx, &secret_key)?;

let games = client.list_challenge_games().await?;
// Returns: Vec<BisectionGameInfo>

let game = client.get_challenge_game(&game_id).await?;
// Returns: Option<BisectionGameInfo>

let game_id = client.initiate_challenge(&bond_txid, &claimed_hash).await?;
// Returns: [u8; 32]

client.submit_bisection_midpoint(&game_id, &midpoint_hash).await?;

let resolved = client.select_bisection_half(&game_id, true, &our_hash).await?;
// Returns: bool

let prover_wins = client.verify_and_resolve(&game_id).await?;
// Returns: bool

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContractEvent {
    pub contract_id: Vec<u8>,
    pub event_name: String,
    pub data: Vec<u8>,
    pub block_height: u64,
    pub timestamp: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TokenBalance {
    pub balance: String,
    pub balance_decimal: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BisectionGameInfo {
    pub game_id: [u8; 32],
    pub total_steps: u64,
    pub range_low: u64,
    pub range_high: u64,
    pub prover_hash_low: [u8; 32],
    pub prover_hash_high: [u8; 32],
    pub round: u32,
    pub max_rounds: u32,
    pub state: BisectionStateInfo,
    pub created_at: u64,
    pub deadline: u64,
}

pub enum SdkError {
    NetworkError(String),
    SerializationError(String),
    ExecutionFailed(String),
    InvalidInput(String),
    ContractNotFound,
    InsufficientBalance,
    InvalidNonce,
}

use nexus_sdk::SdkError;

match client.deploy_contract(contract, &deployer, Some(&signer), 0).await {
    Ok(contract_id) => {
        println!("Deployed: {}", hex::encode(&contract_id));
    }
    Err(SdkError::NetworkError(msg)) => {
        eprintln!("Network error: {}", msg);
    }
    Err(SdkError::ExecutionFailed(msg)) => {
        eprintln!("Execution failed: {}", msg);
    }
    Err(e) => {
        eprintln!("Error: {:?}", e);
    }
}