add fetch_accounts, wip

Author: SwenSchaeferjohann

Cargo.lock

@@ -53,6 +53,7 @@ members = [
     "sdk-tests/anchor-compressible",
     "sdk-tests/anchor-compressible-derived",
     "sdk-tests/native-compressible",
+    "fetch-accounts",
 ]
 
 resolver = "2"

Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "fetch_accounts"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "fetch_test"
+path = "src/main.rs"
+
+[[bin]]
+name = "fetch_rpc"
+path = "src/main_rpc.rs"
+
+[dependencies]
+solana-sdk = "2.2"
+solana-client = "2.2"
+solana-rpc-client = "2.2"
+solana-rpc-client-api = "2.2"
+light-client = { path = "../sdk-libs/client" }
+light-program-test = { path = "../sdk-libs/program-test", features = ["devenv"] }
+tokio = { version = "1.45.1", features = ["rt", "macros", "rt-multi-thread"] }
+base64 = "0.22"
+serde_json = "1.0"

cli/accounts/test_batched_cpi_context_7Hp52chxaew8bW1ApR4fck2bh6Y8qA1pu3qwH6N9zaLj.json

@@ -0,0 +1,75 @@
+# Account Fetcher Scripts
+
+Two standalone Rust scripts to fetch Solana accounts and save them as JSON files.
+
+## Building
+
+```bash
+cd fetch_accounts
+cargo build --release
+```
+
+## Usage
+
+### 1. Test Environment Fetcher (`fetch_test`)
+
+This script uses the Light Protocol test environment to fetch accounts from test state trees:
+
+```bash
+cargo run --bin fetch_test
+```
+
+Or after building:
+
+```bash
+./target/release/fetch_test
+```
+
+This will:
+
+- Initialize a test environment
+- Get all state tree infos
+- Fetch accounts from the first two trees' cpi_context addresses
+- Save them as JSON files in the current directory
+
+### 2. RPC Fetcher (`fetch_rpc`)
+
+This script fetches accounts from a live Solana RPC endpoint:
+
+```bash
+# Using default localhost:8899
+cargo run --bin fetch_rpc <address1> <address2> ...
+
+# Using custom RPC endpoint
+RPC_URL=https://api.mainnet-beta.solana.com cargo run --bin fetch_rpc <address1> <address2> ...
+```
+
+Example:
+
+```bash
+cargo run --bin fetch_rpc 11111111111111111111111111111111 TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
+```
+
+## Output Format
+
+Both scripts save accounts in the following JSON format:
+
+```json
+{
+  "pubkey": "...",
+  "account": {
+    "lamports": 1000000,
+    "data": ["base64_encoded_data", "base64"],
+    "owner": "...",
+    "executable": false,
+    "rentEpoch": 0,
+    "space": 165
+  }
+}
+```
+
+## Notes
+
+- The test fetcher (`fetch_test`) requires the Light Protocol development environment
+- The RPC fetcher (`fetch_rpc`) can connect to any Solana RPC endpoint
+- JSON files are saved in the current working directory

fetch-accounts/Cargo.toml

@@ -0,0 +1,102 @@
+use base64::encode;
+use light_client::indexer::Indexer;
+use light_program_test::{LightProgramTest, ProgramTestConfig, Rpc};
+use serde_json::json;
+use solana_sdk::pubkey::Pubkey;
+use std::fs::File;
+use std::io::Write;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Starting to fetch accounts...");
+
+    // Initialize test environment
+    // You can adjust the config based on your needs
+    let config = ProgramTestConfig::new_v2(false, None);
+    let rpc = LightProgramTest::new(config).await?;
+
+    // Get tree infos
+    let tree_infos = rpc.get_state_tree_infos();
+    println!("Found {} tree infos", tree_infos.len());
+
+    // Get a random state tree info
+    let random_info = rpc.get_random_state_tree_info();
+    match random_info {
+        Ok(info) => println!("Random info: {:?}", info),
+        Err(e) => println!("Error getting random info: {:?}", e),
+    }
+
+    // Check if we have at least 2 tree infos
+    if tree_infos.len() < 2 {
+        println!("Warning: Less than 2 tree infos available");
+        return Ok(());
+    }
+
+    // Get the cpi_context addresses
+    let address_0 = tree_infos[0]
+        .cpi_context
+        .ok_or("No cpi_context for tree_info[0]")?;
+    let address_1 = tree_infos[1]
+        .cpi_context
+        .ok_or("No cpi_context for tree_info[1]")?;
+
+    println!("Address 0: {}", address_0);
+    println!("Address 1: {}", address_1);
+
+    // Fetch accounts
+    let account_0 = rpc
+        .get_account(address_0)
+        .await?
+        .ok_or("Account 0 not found")?;
+    let account_1 = rpc
+        .get_account(address_1)
+        .await?
+        .ok_or("Account 1 not found")?;
+
+    println!("Fetched account_0: {} bytes", account_0.data.len());
+    println!("Fetched account_1: {} bytes", account_1.data.len());
+
+    // Write accounts to JSON files
+    write_account_json(
+        &account_0,
+        &address_0,
+        &format!("test_batched_cpi_context_{}.json", address_0),
+    )?;
+    write_account_json(
+        &account_1,
+        &address_1,
+        &format!("test_batched_cpi_context_{}.json", address_1),
+    )?;
+
+    println!("Successfully wrote account JSON files");
+    println!("Account 0 details: lamports={}, owner={}, executable={}, data_len={}", 
+        account_0.lamports, account_0.owner, account_0.executable, account_0.data.len());
+    println!("Account 1 details: lamports={}, owner={}, executable={}, data_len={}", 
+        account_1.lamports, account_1.owner, account_1.executable, account_1.data.len());
+
+    Ok(())
+}
+
+fn write_account_json(
+    account: &solana_sdk::account::Account,
+    pubkey: &Pubkey,
+    filename: &str,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let data_base64 = encode(&account.data);
+    let json_obj = json!({
+        "pubkey": pubkey.to_string(),
+        "account": {
+            "lamports": account.lamports,
+            "data": [data_base64, "base64"],
+            "owner": account.owner.to_string(),
+            "executable": account.executable,
+            "rentEpoch": account.rent_epoch,
+            "space": account.data.len(),
+        }
+    });
+    
+    let mut file = File::create(filename)?;
+    file.write_all(json_obj.to_string().as_bytes())?;
+    
+    Ok(())
+}

fetch-accounts/README.md

@@ -0,0 +1,102 @@
+use base64::encode;
+use serde_json::json;
+use solana_client::rpc_client::RpcClient;
+use solana_sdk::pubkey::Pubkey;
+use std::fs::File;
+use std::io::Write;
+use std::str::FromStr;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Configure these based on your needs
+    let rpc_url = std::env::var("RPC_URL").unwrap_or_else(|_| "http://localhost:8899".to_string());
+    
+    // Replace these with actual addresses you want to fetch
+    // You can pass them as command line arguments or environment variables
+    let addresses: Vec<&str> = vec![
+        // Add your addresses here, e.g.:
+        // "11111111111111111111111111111111",
+        // "22222222222222222222222222222222",
+    ];
+
+    if addresses.is_empty() {
+        println!("Please add addresses to fetch in the source code or pass them as arguments");
+        println!("Usage: cargo run --bin fetch_rpc <address1> <address2> ...");
+        
+        // Check for command line arguments
+        let args: Vec<String> = std::env::args().collect();
+        if args.len() > 1 {
+            fetch_accounts_from_args(&rpc_url, &args[1..])?;
+        }
+        return Ok(());
+    }
+
+    let client = RpcClient::new(rpc_url.clone());
+    println!("Connected to RPC: {}", rpc_url);
+
+    for address_str in addresses {
+        fetch_and_save_account(&client, address_str)?;
+    }
+
+    Ok(())
+}
+
+fn fetch_accounts_from_args(rpc_url: &str, addresses: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let client = RpcClient::new(rpc_url.to_string());
+    println!("Connected to RPC: {}", rpc_url);
+
+    for address_str in addresses {
+        fetch_and_save_account(&client, address_str)?;
+    }
+
+    Ok(())
+}
+
+fn fetch_and_save_account(client: &RpcClient, address_str: &str) -> Result<(), Box<dyn std::error::Error>> {
+    let pubkey = Pubkey::from_str(address_str)?;
+    println!("Fetching account: {}", pubkey);
+
+    match client.get_account(&pubkey) {
+        Ok(account) => {
+            println!("Fetched account: {} bytes", account.data.len());
+            
+            let filename = format!("account_{}.json", pubkey);
+            write_account_json(&account, &pubkey, &filename)?;
+            
+            println!("Saved to: {}", filename);
+            println!("  Lamports: {}", account.lamports);
+            println!("  Owner: {}", account.owner);
+            println!("  Executable: {}", account.executable);
+            println!("  Data length: {}", account.data.len());
+            println!();
+        }
+        Err(e) => {
+            println!("Error fetching account {}: {:?}", pubkey, e);
+        }
+    }
+
+    Ok(())
+}
+
+fn write_account_json(
+    account: &solana_sdk::account::Account,
+    pubkey: &Pubkey,
+    filename: &str,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let data_base64 = encode(&account.data);
+    let json_obj = json!({
+        "pubkey": pubkey.to_string(),
+        "account": {
+            "lamports": account.lamports,
+            "data": [data_base64, "base64"],
+            "owner": account.owner.to_string(),
+            "executable": account.executable,
+            "rentEpoch": account.rent_epoch,
+            "space": account.data.len(),
+        }
+    });
+    
+    let mut file = File::create(filename)?;
+    file.write_all(json_obj.to_string().as_bytes())?;
+    
+    Ok(())
+}

fetch-accounts/src/main.rs

@@ -258,8 +258,8 @@ export const cpiContext2Pubkey = 'cpi2cdhkH5roePvcudTgUL8ppEBfTay1desGh8G8QxK';
 // V2 testing.
 export const batchMerkleTree = 'HLKs5NJ8FXkJg8BrzJt56adFYYuwg5etzDtBbQYTsixu'; // v2 merkle tree (includes nullifier queue)
 export const batchQueue = '6L7SzhYB3anwEQ9cphpJ1U7Scwj57bx2xueReg7R9cKU'; // v2 output queue
-// export const batchCpiContext = '7Hp52chxaew8bW1ApR4fck2bh6Y8qA1pu3qwH6N9zaLj';
-export const batchCpiContext = 'HwtjxDvFEXiWnzeMeWkMBzpQN45A95rTJNZmz1Z3pe8R';
+export const batchCpiContext = '7Hp52chxaew8bW1ApR4fck2bh6Y8qA1pu3qwH6N9zaLj';
+// export const batchCpiContext = 'HwtjxDvFEXiWnzeMeWkMBzpQN45A95rTJNZmz1Z3pe8R';
 export const confirmConfig: ConfirmOptions = {
     commitment: 'confirmed',
     preflightCommitment: 'confirmed',

fetch-accounts/src/main_rpc.rs

@@ -40,6 +40,8 @@ light-sdk = { workspace = true }
 light-compressed-account = { workspace = true, features = ["anchor"] }
 light-client = { workspace = true, features = ["devenv"] }
 light-token-client = { workspace = true }
+base64 = { workspace = true }
+serde_json = { workspace = true }
 
 [lints.rust.unexpected_cfgs]
 level = "allow"