svmscope 0.6.0

Transaction autopsy for Solana — decode any mainnet transaction, replay it locally in an embedded SVM, and mutate state to see what happens.
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

//! Exact recursive reconstruction: rebuild an account to *now* via the
//! dependency-cone engine, and compare to actual on-chain state byte-for-byte.
//!
//!   RPC=<url> cargo run --example reconstruct_exact -- <address> [budget]

use svmscope::reconstruct::{Reconstructor, RpcLedger};
use svmscope::Scope;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rpc =
        std::env::var("RPC").unwrap_or_else(|_| "https://api.mainnet-beta.solana.com".to_string());
    let mut args = std::env::args().skip(1);
    let address = args.next().expect("usage: … <address> [budget]");
    let budget: usize = args.next().and_then(|s| s.parse().ok()).unwrap_or(150);

    let scope = Scope::new(&rpc);
    let ledger = RpcLedger::new(&rpc);
    let tip = scope.client().get_slot()?;

    println!("exact-reconstructing {address} to slot {tip} (budget {budget} replays)…");
    let mut r = Reconstructor::new(&scope, &ledger, budget);
    let recon = r.reconstruct(&address, tip + 1)?;
    println!(
        "  replays: {}   exact-cone: {}   exists: {}",
        r.replays(),
        recon.exact,
        recon.state.is_some()
    );

    let actual = scope.account_data(&address)?;
    match (recon.state, actual) {
        (Some(rc), Some(ac)) => {
            let full = rc.data == ac.data;
            println!(
                "  data {} vs {} bytes · FULL MATCH: {}",
                rc.data.len(),
                ac.data.len(),
                if full { "✅" } else { "❌" }
            );
            // Spotlight the SPL token amount (offset 64..72), the coupled field
            // the naive engine got wrong.
            if rc.data.len() >= 72 && ac.data.len() >= 72 {
                let amt = |d: &[u8]| u64::from_le_bytes(d[64..72].try_into().unwrap());
                println!(
                    "  amount@64: reconstructed {} · actual {} · {}",
                    amt(&rc.data),
                    amt(&ac.data),
                    if amt(&rc.data) == amt(&ac.data) {
                        "✅ exact"
                    } else {
                        "❌ off"
                    }
                );
            }
            if !full {
                let n = rc.data.len().min(ac.data.len());
                let diffs: Vec<usize> = (0..n).filter(|&i| rc.data[i] != ac.data[i]).collect();
                println!("  differing offsets: {:?}", &diffs[..diffs.len().min(12)]);
            }
        }
        (a, b) => println!(
            "  existence: reconstructed={} actual={}",
            a.is_some(),
            b.is_some()
        ),
    }
    Ok(())
}