never kill yourself

Author: 0xrinegade

config.json

@@ -1,5 +1,5 @@
 {
-  "rpc_url": "https://api.mainnet-beta.solana.com",
+  "rpc_url": "https://api.opensvm.com",
   "commitment": "confirmed",
   "protocol_version": "2024-11-05"
 }

src/config.rs

@@ -21,7 +21,7 @@ impl Config {
 
         // Fall back to environment variables
         let rpc_url = env::var("SOLANA_RPC_URL")
-            .unwrap_or_else(|_| "http://api.opensvm.com".to_string());
+            .unwrap_or_else(|_| "https://api.opensvm.com".to_string());
 
         let commitment = env::var("SOLANA_COMMITMENT")
             .unwrap_or_else(|_| "confirmed".to_string());

tests/e2e.rs

@@ -2,26 +2,27 @@ use solana_client::nonblocking::rpc_client::RpcClient;
 use solana_sdk::{
     commitment_config::CommitmentConfig,
     pubkey::Pubkey,
+    signer::{keypair::Keypair, Signer},
 };
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_blockchain_operations() {
+async fn test_solana_operations() {
     // Connect to Solana devnet
+    // Use Solana's devnet endpoint
+    // Use official devnet with longer timeout
     let rpc_url = "https://api.opensvm.com".to_string();
-    let client = RpcClient::new_with_commitment(rpc_url.clone(), CommitmentConfig::confirmed());
+    let timeout = std::time::Duration::from_secs(60);
+    let commitment = CommitmentConfig::finalized();
+    let client = RpcClient::new_with_timeout_and_commitment(rpc_url.clone(), timeout, commitment);
 
-    // Configure RPC client to support latest transaction versions
-    let config = solana_client::rpc_config::RpcBlockConfig {
-        encoding: None,
-        transaction_details: None,
-        rewards: None,
-        commitment: None,
-        max_supported_transaction_version: Some(0),
-    };
-
     println!("\nTesting health check:");
-    let health = client.get_health().await.unwrap();
-    println!("Health status: {:?}", health);
+    match client.get_health().await {
+        Ok(health) => println!("Health status: {:?}", health),
+        Err(err) => {
+            println!("Error details: {:?}", err);
+            panic!("Health check failed: {}", err);
+        }
+    }
 
     println!("\nTesting version info:");
     let version = client.get_version().await.unwrap();
@@ -56,13 +57,39 @@ async fn test_blockchain_operations() {
         }
     }
 
-    // Get block data using a slot we know exists from recent transactions
-    if let Some(first_sig) = signatures.first() {
-        println!("\nTesting block data for slot {}:", first_sig.slot);
-        let block = client.get_block_with_config(first_sig.slot, config).await;
-        match block {
-            Ok(block) => println!("Block data: {:#?}", block),
-            Err(e) => println!("Could not fetch block: {}", e),
-        }
+    // Test creating a new keypair and getting its info
+    println!("\nTesting keypair operations:");
+    let keypair = Keypair::new();
+    let pubkey = keypair.pubkey();
+    println!("Generated keypair with pubkey: {}", pubkey);
+    
+    // Get account info (should be empty/not found)
+    match client.get_account(&pubkey).await {
+        Ok(account) => println!("Account exists with {} lamports", account.lamports),
+        Err(e) => println!("Account not found as expected: {}", e),
+    }
+
+    // Get minimum rent
+    println!("\nTesting rent calculation:");
+    let rent = client.get_minimum_balance_for_rent_exemption(0).await.unwrap();
+    println!("Minimum balance for rent exemption: {} lamports", rent);
+
+    // Get recent block
+    println!("\nTesting block info:");
+    let slot = client.get_slot().await.unwrap();
+    println!("Current slot: {}", slot);
+    
+    // Get block production
+    println!("\nTesting block production:");
+    let production = client.get_block_production().await.unwrap();
+    println!("Block production: {:?}", production);
+
+    // Get cluster nodes
+    println!("\nTesting cluster info:");
+    let nodes = client.get_cluster_nodes().await.unwrap();
+    println!("Found {} cluster nodes", nodes.len());
+    for node in nodes.iter().take(3) {
+        let version = node.version.as_ref().map_or("unknown", |v| v.as_str());
+        println!("  {}: {}", node.pubkey, version);
     }
 }