solana_client_ext 0.1.1

Solana client extension for compute unit optimization and detailed transaction results
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

# Solana Rust Client Extension

This crate provides extensions for the Solana Rust client, focusing on compute unit estimation and optimization. It also provides transaction execution details via the `ReturnStruct` for more robust transaction processing.

## Features
* Estimates compute units for Solana transactions
* Optimizes compute unit usage by adding a compute budget instruction
* Returns detailed transaction execution information:
  * Success/failure status
  * Compute units used
  * Detailed result message or error information

## Usage

To use this crate, add it to your `Cargo.toml` file:

```toml
[dependencies]
solana-client-ext = { git = "https://github.com/bergabman/Solana-Rust-Client-Extension.git", version ="0.1.0"} # Replace with the right version
```

### Basic Usage Example

```rust
use solana_client::rpc_client::RpcClient;
use solana_client_ext::RpcClientExt;
use solana_sdk::{
    message::Message, signature::Keypair, signer::Signer, system_instruction,
    transaction::Transaction,
};

fn main() {
    let rpc_client = RpcClient::new("https://api.devnet.solana.com");
    let keypair = Keypair::new();
    let keypair2 = Keypair::new();
    let created_ix = system_instruction::transfer(&keypair.pubkey(), &keypair2.pubkey(), 10000);
    let mut msg = Message::new(&[created_ix], Some(&keypair.pubkey()));

    let optimized_cu = rpc_client
        .optimize_compute_units_msg(&mut msg, &[&keypair])
        .unwrap();
    println!("Optimized compute units: {}", optimized_cu);

    let tx = Transaction::new(&[&keypair], msg, rpc_client.get_latest_blockhash().unwrap());
    let result = rpc_client
        .send_and_confirm_transaction_with_spinner(&tx)
        .unwrap();

    println!(
        "Transaction signature: https://explorer.solana.com/tx/{}?cluster=devnet",
        result
    );
}
```

### Using ReturnStruct for Detailed Transaction Information

You can also get detailed transaction results using the `ReturnStruct`:

```rust
use solana_client::rpc_client::RpcClient;
use solana_client_ext::{RpcClientExt, RollUpChannel};
use solana_sdk::{
    pubkey::Pubkey, signature::Keypair, signer::Signer, system_instruction,
    transaction::Transaction,
};

fn main() {
    let rpc_client = RpcClient::new("https://api.devnet.solana.com");
    let keypair = Keypair::new();
    
    // Create a simple transfer transaction
    let transfer_ix = system_instruction::transfer(
        &keypair.pubkey(), 
        &Pubkey::new_unique(), 
        10000
    );
    let msg = Message::new(&[transfer_ix], Some(&keypair.pubkey()));
    let blockhash = rpc_client.get_latest_blockhash().unwrap();
    let tx = Transaction::new(&[&keypair], msg, blockhash);
    
    // Process the transaction and get detailed results
    let accounts = tx.message.account_keys.clone();
    let rollup_c = RollUpChannel::new(accounts, &rpc_client);
    let results = rollup_c.process_rollup_transfers(&[tx.clone()]);
    
    // Display transaction results
    for (i, result) in results.iter().enumerate() {
        println!("Transaction {}: Success={}, CU={}, Result: {}", 
            i, result.success, result.cu, result.result);
    }
}
```

[tx](img/opt.png)