Add CI, justfile, and switch litesvm to git dep

- Add GitHub Actions CI with lint and test jobs using just commands
- Add justfile for local dev (build, test, lint, format)
- Switch litesvm from local path to Lightprotocol fork git dep
- Apply nightly rustfmt formatting

Author: ananas-block

.github/workflows/ci.yml

@@ -0,0 +1,54 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  SOLANA_CLI_VERSION: "2.2.13"
+  RUST_TOOLCHAIN: "1.86.0"
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: ${{ env.RUST_TOOLCHAIN }}
+          components: clippy
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: nightly
+          components: rustfmt
+      - uses: extractions/setup-just@v2
+      - run: just lint
+
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: ${{ env.RUST_TOOLCHAIN }}
+      - name: Cache Solana CLI tools
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/solana/
+            ~/.local/share/solana/
+          key: solana-cli-${{ runner.os }}-${{ env.SOLANA_CLI_VERSION }}
+      - name: Install Solana CLI
+        run: |
+          sh -c "$(curl -sSfL https://release.anza.xyz/v${{ env.SOLANA_CLI_VERSION }}/install)"
+          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
+      - uses: extractions/setup-just@v2
+      - run: just test

Cargo.lock

@@ -35,8 +35,8 @@ syn = { version = "2.0", features = ["visit", "visit-mut", "full"] }
 darling = "0.21"
 heck = "0.5"
 sha2 = "0.10"
-# LiteSVM local fork + pinned transitive deps to match litesvm 3.0.x
-litesvm = { path = "/Users/ananas/dev/litesvm/crates/litesvm" }
+# LiteSVM fork + pinned transitive deps to match litesvm 3.0.x
+litesvm = { git = "https://github.com/Lightprotocol/litesvm.git", branch = "jorrit/feat-get-program-accounts-v3" }
 # Pin litesvm transitive deps to =3.0.5 (litesvm not yet compatible with 3.1.x)
 agave-feature-set = "=3.0.5"
 agave-reserved-account-keys = "=3.0.5"

Cargo.toml

@@ -0,0 +1,38 @@
+# Instruction Decoder
+set dotenv-load
+
+export SBF_OUT_DIR := "target/deploy"
+
+default:
+    @just --list
+
+# === Build ===
+build:
+    cargo build --workspace
+
+build-sbf:
+    cd examples/counter && cargo build-sbf
+
+# === Test ===
+test: build-sbf
+    cargo test --workspace
+
+# === Lint & Format ===
+lint:
+    cargo +nightly fmt --all -- --check
+    cargo clippy --workspace \
+        --no-deps \
+        -- -A unexpected-cfgs \
+           -D warnings
+
+format:
+    cargo +nightly fmt --all
+
+# === Clean ===
+clean:
+    cargo clean
+
+# === Info ===
+info:
+    @echo "Solana: $(solana --version)"
+    @echo "Rust: $(rustc --version)"

justfile

@@ -52,9 +52,8 @@ pub use formatter::{Colors, TransactionFormatter};
 #[cfg(not(target_os = "solana"))]
 pub use programs::{
     AccountCompressionInstructionDecoder, CTokenInstructionDecoder,
-    ComputeBudgetInstructionDecoder, LightSystemInstructionDecoder,
-    RegistryInstructionDecoder, SplTokenInstructionDecoder, SystemInstructionDecoder,
-    Token2022InstructionDecoder,
+    ComputeBudgetInstructionDecoder, LightSystemInstructionDecoder, RegistryInstructionDecoder,
+    SplTokenInstructionDecoder, SystemInstructionDecoder, Token2022InstructionDecoder,
 };
 // Re-export registry
 #[cfg(not(target_os = "solana"))]

light-instruction-decoder/src/lib.rs

@@ -13,14 +13,14 @@
 // Allow the macro-generated code to reference types from this crate
 extern crate self as light_instruction_decoder;
 
-use borsh::BorshDeserialize;
 use crate::programs::light_types::{
-    InstructionDataInvoke, InstructionDataInvokeCpi,
+    CompressedAccountInfo, InAccount, InstructionDataInvoke, InstructionDataInvokeCpi,
     InstructionDataInvokeCpiWithAccountInfo, InstructionDataInvokeCpiWithReadOnly,
+    NewAddressParamsAssignedPacked, NewAddressParamsPacked,
     OutputCompressedAccountWithPackedContext, PackedCompressedAccountWithMerkleContext,
-    NewAddressParamsPacked, NewAddressParamsAssignedPacked, PackedReadOnlyAddress,
-    CompressedAccountInfo, InAccount,
+    PackedReadOnlyAddress,
 };
+use borsh::BorshDeserialize;
 use light_instruction_decoder_derive::InstructionDecoder;
 use solana_instruction::AccountMeta;
 use solana_pubkey::Pubkey;
@@ -565,9 +565,24 @@ pub fn resolve_invoke_cpi_readonly_account_names(
     // Normal Mode: Fixed LightSystemAccounts (6 accounts)
     add_name("fee_payer", accounts, &mut idx, &mut known_pubkeys);
     add_name("authority", accounts, &mut idx, &mut known_pubkeys);
-    add_name("registered_program_pda", accounts, &mut idx, &mut known_pubkeys);
-    add_name("account_compression_authority", accounts, &mut idx, &mut known_pubkeys);
-    add_name("account_compression_program", accounts, &mut idx, &mut known_pubkeys);
+    add_name(
+        "registered_program_pda",
+        accounts,
+        &mut idx,
+        &mut known_pubkeys,
+    );
+    add_name(
+        "account_compression_authority",
+        accounts,
+        &mut idx,
+        &mut known_pubkeys,
+    );
+    add_name(
+        "account_compression_program",
+        accounts,
+        &mut idx,
+        &mut known_pubkeys,
+    );
     add_name("system_program", accounts, &mut idx, &mut known_pubkeys);
 
     names
@@ -650,9 +665,24 @@ pub fn resolve_invoke_cpi_account_info_account_names(
     // Normal Mode: Fixed LightSystemAccounts (6 accounts)
     add_name("fee_payer", accounts, &mut idx, &mut known_pubkeys);
     add_name("authority", accounts, &mut idx, &mut known_pubkeys);
-    add_name("registered_program_pda", accounts, &mut idx, &mut known_pubkeys);
-    add_name("account_compression_authority", accounts, &mut idx, &mut known_pubkeys);
-    add_name("account_compression_program", accounts, &mut idx, &mut known_pubkeys);
+    add_name(
+        "registered_program_pda",
+        accounts,
+        &mut idx,
+        &mut known_pubkeys,
+    );
+    add_name(
+        "account_compression_authority",
+        accounts,
+        &mut idx,
+        &mut known_pubkeys,
+    );
+    add_name(
+        "account_compression_program",
+        accounts,
+        &mut idx,
+        &mut known_pubkeys,
+    );
     add_name("system_program", accounts, &mut idx, &mut known_pubkeys);
 
     names

light-instruction-decoder/src/programs/light_system.rs

@@ -27,6 +27,6 @@ pub mod light_token;
 pub mod registry;
 
 pub use account_compression::AccountCompressionInstructionDecoder;
-pub use light_token::CTokenInstructionDecoder;
 pub use light_system::LightSystemInstructionDecoder;
+pub use light_token::CTokenInstructionDecoder;
 pub use registry::RegistryInstructionDecoder;

light-instruction-decoder/src/programs/mod.rs

@@ -143,7 +143,11 @@ fn transaction_log_to_snapshot(log: &EnhancedTransactionLog) -> TransactionSnaps
         status: log.status.text(),
         fee: log.fee,
         compute_used: log.compute_used,
-        instructions: log.instructions.iter().map(instruction_to_snapshot).collect(),
+        instructions: log
+            .instructions
+            .iter()
+            .map(instruction_to_snapshot)
+            .collect(),
     }
 }
 
@@ -231,8 +235,7 @@ fn parse_inner_instructions(
 
         let mut ix_log = EnhancedInstructionLog::new(inner_idx, program_id, program_name);
         ix_log.data = inner_ix.instruction.data.clone();
-        ix_log.accounts =
-            resolve_accounts(&inner_ix.instruction.accounts, account_keys, message);
+        ix_log.accounts = resolve_accounts(&inner_ix.instruction.accounts, account_keys, message);
 
         // stack_height 1 = top-level, 2 = direct CPI child, 3+ = deeper nesting
         let depth = (inner_ix.stack_height as usize).saturating_sub(1);

tests/src/lib.rs

@@ -19,21 +19,25 @@ fn setup() -> (LiteSVM, Keypair) {
     let program_bytes = include_bytes!("../../target/deploy/counter.so");
     let _ = svm.add_program(COUNTER_PROGRAM_ID, program_bytes);
     let payer = deterministic_keypair(10);
-    svm.airdrop(&payer.pubkey(), 10 * LAMPORTS_PER_SOL)
-        .unwrap();
+    svm.airdrop(&payer.pubkey(), 10 * LAMPORTS_PER_SOL).unwrap();
     (svm, payer)
 }
 
 /// Build an Anchor instruction: 8-byte discriminator + borsh-serialized args
-fn anchor_ix(program_id: &Pubkey, discriminator: &[u8; 8], data: &[u8], accounts: Vec<solana_instruction::AccountMeta>) -> solana_instruction::Instruction {
+fn anchor_ix(
+    program_id: &Pubkey,
+    discriminator: &[u8; 8],
+    data: &[u8],
+    accounts: Vec<solana_instruction::AccountMeta>,
+) -> solana_instruction::Instruction {
     let mut ix_data = discriminator.to_vec();
     ix_data.extend_from_slice(data);
     solana_instruction::Instruction::new_with_bytes(*program_id, &ix_data, accounts)
 }
 
 /// Compute Anchor discriminator: sha256("global:<name>")[..8]
 fn anchor_discriminator(name: &str) -> [u8; 8] {
-    use sha2::{Sha256, Digest};
+    use sha2::{Digest, Sha256};
     let mut hasher = Sha256::new();
     hasher.update(format!("global:{name}").as_bytes());
     let hash = hasher.finalize();
@@ -56,7 +60,10 @@ fn test_decode_initialize() {
         vec![
             solana_instruction::AccountMeta::new(counter.pubkey(), true),
             solana_instruction::AccountMeta::new(payer.pubkey(), true),
-            solana_instruction::AccountMeta::new_readonly(solana_pubkey::pubkey!("11111111111111111111111111111111"), false),
+            solana_instruction::AccountMeta::new_readonly(
+                solana_pubkey::pubkey!("11111111111111111111111111111111"),
+                false,
+            ),
         ],
     );
 
@@ -94,12 +101,18 @@ fn test_decode_increment_and_set() {
         vec![
             solana_instruction::AccountMeta::new(counter.pubkey(), true),
             solana_instruction::AccountMeta::new(payer.pubkey(), true),
-            solana_instruction::AccountMeta::new_readonly(solana_pubkey::pubkey!("11111111111111111111111111111111"), false),
+            solana_instruction::AccountMeta::new_readonly(
+                solana_pubkey::pubkey!("11111111111111111111111111111111"),
+                false,
+            ),
         ],
     );
     let msg = Message::new(&[init_ix], Some(&payer.pubkey()));
     let tx = Transaction::new(&[&payer, &counter], msg, svm.latest_blockhash());
-    svm.send_transaction(solana_transaction::versioned::VersionedTransaction::from(tx)).unwrap();
+    svm.send_transaction(solana_transaction::versioned::VersionedTransaction::from(
+        tx,
+    ))
+    .unwrap();
 
     // Increment
     let inc_ix = anchor_ix(
@@ -180,8 +193,10 @@ fn test_decode_configure() {
     );
     let msg = Message::new(&[init_ix], Some(&payer.pubkey()));
     let tx = Transaction::new(&[&payer, &counter], msg, svm.latest_blockhash());
-    svm.send_transaction(solana_transaction::versioned::VersionedTransaction::from(tx))
-        .unwrap();
+    svm.send_transaction(solana_transaction::versioned::VersionedTransaction::from(
+        tx,
+    ))
+    .unwrap();
 
     // Build configure instruction data:
     // new_value: u64, multiplier: u16, enabled: bool, label: [u8; 32], nonce: u64
@@ -243,9 +258,15 @@ fn test_decode_configure() {
 
     // Verify decoded fields
     let fields = snapshot.instructions[0].decoded_fields.as_ref().unwrap();
-    assert!(fields.iter().any(|f| f.name == "new_value" && f.value == "999"));
-    assert!(fields.iter().any(|f| f.name == "multiplier" && f.value == "7"));
-    assert!(fields.iter().any(|f| f.name == "nonce" && f.value == "12345"));
+    assert!(fields
+        .iter()
+        .any(|f| f.name == "new_value" && f.value == "999"));
+    assert!(fields
+        .iter()
+        .any(|f| f.name == "multiplier" && f.value == "7"));
+    assert!(fields
+        .iter()
+        .any(|f| f.name == "nonce" && f.value == "12345"));
 
     insta::assert_json_snapshot!("counter_configure", snapshot);
 }

tests/tests/counter_program.rs

@@ -17,8 +17,7 @@ fn deterministic_keypair(seed_byte: u8) -> Keypair {
 fn setup() -> (LiteSVM, Keypair) {
     let mut svm = LiteSVM::new();
     let payer = deterministic_keypair(1);
-    svm.airdrop(&payer.pubkey(), 10 * LAMPORTS_PER_SOL)
-        .unwrap();
+    svm.airdrop(&payer.pubkey(), 10 * LAMPORTS_PER_SOL).unwrap();
     (svm, payer)
 }