HPSVM

https://github.com/longcipher/hpsvm
Admin
HPSVM is a fast and lightweight Rust library for testing Solana programs with an in-process VM,...
Tokens:87,139
Snippets:892
Trust Score:6.5
License:Apache-2.0
Update:4 months ago
Show doc for...
Tokens:
Raw
### Basic HPSVM Setup

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/05-patterns-and-advanced.md

Use this pattern for a quick start with default HPSVM configurations, including airdrops, enabled sysvars, and default programs.

```rust
use hpsvm::HPSVM;

let mut svm = HPSVM::new();
// svm is ready to use with program-test defaults
```

--------------------------------

### Add rumdl and cargo-tarpaulin to Justfile setup

Source: https://github.com/longcipher/hpsvm/blob/master/specs/2026-06-17-01-quick-wins/tasks.md

This snippet shows the commands to add `rumdl` and `cargo-tarpaulin` to the `just setup` recipe in the `Justfile`. Ensure these commands are added after existing install lines.

```bash
cargo install rumdl
cargo install cargo-tarpaulin
```

--------------------------------

### Install Read-Through Account Source

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Use `with_account_source` to install a read-through account source. This is used when local state misses an account.

```rust
use hpsvm_fork_rpc::RpcForkSource;

let fork_source = RpcForkSource::builder()
    .with_rpc_url("http://127.0.0.1:8899")
    .with_slot(1)
    .build();

let svm = HPSVM::builder()
    .with_program_test_defaults()
    .with_account_source(fork_source)
    .build()?;
```

--------------------------------

### Install an Execution Inspector

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Use `with_inspector` to install an execution inspector before the VM is built. This is useful for logging or monitoring transaction execution.

```rust
struct LoggingInspector;

impl Inspector for LoggingInspector {
    fn on_transaction_start(&self, _svm: &HPSVM, _tx: &SanitizedTransaction) {
        println!("Transaction started");
    }
}

let svm = HPSVM::builder()
    .with_program_test_defaults()
    .with_inspector(LoggingInspector)
    .build()?;
```

--------------------------------

### Install Foundry Dependencies with Soldeer

Source: https://github.com/longcipher/hpsvm/blob/master/AGENTS.md

Use `soldeer` for managing Solidity dependencies. This command installs them.

```bash
forge soldeer install
```

--------------------------------

### GitHub Actions CI Workflow (YAML)

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/05-patterns-and-advanced.md

An example GitHub Actions workflow for running integration tests, including checkout, Rust toolchain setup, and cargo commands.

```yaml
name: Integration Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: dtolnay/rust-toolchain@stable
      - name: Run tests
        run: cargo test --all
      - name: Run benches
        run: cargo bench --all
```

--------------------------------

### RpcForkSource Build Example

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/04-companion-crates.md

Builds the configured RPC-backed account source after setting the RPC URL and slot.

```rust
let fork_source = RpcForkSource::builder()
    .with_rpc_url("http://127.0.0.1:8899")
    .with_slot(1)
    .build();
```

--------------------------------

### RpcForkSource Builder Example

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/04-companion-crates.md

Demonstrates how to create and configure an RPC-backed account source using the builder pattern and integrate it with HPSVM.

```rust
use hpsvm_fork_rpc::RpcForkSource;
use hpsvm::HPSVM;

let fork_source = RpcForkSource::builder()
    .with_rpc_url("http://127.0.0.1:8899")
    .with_slot(100)
    .build();

let svm = HPSVM::builder()
    .with_program_test_defaults()
    .with_account_source(fork_source)
    .build()?;
```

--------------------------------

### Example: Load Firedancer Fixture

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/04-companion-crates.md

Demonstrates how to load a Firedancer fixture from a protobuf file using `FiredancerFixture::load`.

```rust
use hpsvm_fixture_fd::FiredancerFixture;

let fixture = FiredancerFixture::load("fixture.pb")?;
```

--------------------------------

### with_inspector

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Installs an execution inspector that observes top-level transaction activity.

```APIDOC
## with_inspector

### Description
Installs an execution inspector that observes top-level transaction activity.

### Method
`with_inspector`

### Parameters
- `inspector` (I: Inspector + 'static) - Description not provided

### Example
```rust
struct MyInspector;

impl Inspector for MyInspector {
    fn on_transaction_start(&self, _svm: &HPSVM, _tx: &SanitizedTransaction) {
        println!("Transaction started");
    }
}

let svm = HPSVM::new().with_inspector(MyInspector);
```
```

--------------------------------

### Custom HPSVM Environment Setup

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/05-patterns-and-advanced.md

Configure HPSVM with fine-grained control over features, sysvars, programs, signature verification, and lamports.

```rust
use hpsvm::HPSVM;
use agave_feature_set::FeatureSet;

let mut svm = HPSVM::builder()
    .with_feature_set(FeatureSet::default())
    .with_builtins()
    .with_sysvars()
    .with_default_programs()
    .with_sigverify(false)
    .with_lamports(500_000_000) // 0.5 SOL
    .build()?;
```

--------------------------------

### Initialize ComputeUnitBencher

Source: https://github.com/longcipher/hpsvm/blob/master/docs/superpowers/specs/2026-04-29-hpsvm-mollusk-absorption-design.md

Create a new instance of `ComputeUnitBencher` with the provided HPSVM virtual machine. This is the starting point for setting up single-fixture benchmarks.

```rust
impl ComputeUnitBencher {
    pub fn new(vm: hpsvm::HPSVM) -> Self;
    // ... other methods
}

```

--------------------------------

### Create and Use HPSVM with RPC Forking

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/04-companion-crates.md

Demonstrates how to create an HPSVM instance that fetches missing accounts from a live Solana network (devnet in this example) using RpcForkSource. This is useful for testing programs that interact with on-chain state.

```rust
use hpsvm::HPSVM;
use hpsvm_fork_rpc::RpcForkSource;

// Create a fork source for devnet at a specific slot
let fork_source = RpcForkSource::builder()
    .with_rpc_url("https://api.devnet.solana.com")
    .with_slot(150_000_000)
    .build();

// Create an SVM that reads missing accounts from devnet
let mut svm = HPSVM::builder()
    .with_program_test_defaults()
    .with_account_source(fork_source)
    .build()?;

// Add your program to test
let program_bytes = std::fs::read("target/deploy/my_program.so")?;
svm.add_program(my_program_id, &program_bytes)?;

// Execute transactions - accounts not in svm will be fetched from devnet
let result = svm.send_transaction(tx)?;
```

--------------------------------

### Try Get Account with Source Error Handling

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Retrieves account data, preserving failures from a configured external source. Use this to distinguish between 'account doesn't exist' and 'source failed'.

```rust
pub fn try_get_account(
    &self,
    address: &Address,
) -> Result<Option<Account>, AccountSourceError>

```

--------------------------------

### with_inspector

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Installs an execution inspector before the VM is built. This method allows you to hook into the VM's execution lifecycle to observe or modify behavior.

```APIDOC
## with_inspector<I: Inspector + 'static>(self, inspector: I) -> HpsvmBuilder<State>

### Description
Install an execution inspector before the VM is built.

### Method
`with_inspector`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
struct LoggingInspector;

impl Inspector for LoggingInspector {
    fn on_transaction_start(&self, _svm: &HPSVM, _tx: &SanitizedTransaction) {
        println!("Transaction started");
    }
}

let svm = HPSVM::builder()
    .with_program_test_defaults()
    .with_inspector(LoggingInspector)
    .build()?;
```

### Response
#### Success Response
Returns a `HpsvmBuilder<State>` with the inspector installed.

#### Response Example
None
```

--------------------------------

### Build HPSVM with Basic Configuration

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Constructs an HPSVM instance with default feature set, builtins, sysvars, and signature verification enabled. This is a common starting point for creating an HPSVM.

```rust
let svm = HPSVM::builder()
    .with_feature_set(FeatureSet::default())
    .with_builtins()
    .with_sysvars()
    .with_sigverify(true)
    .build()?;
```

--------------------------------

### HPSVM with Proptest

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/INDEX.md

Illustrates using HPSVM in property-based tests with the `proptest` crate. This example generates random `u64` values for testing.

```rust
use proptest::prelude::*;
use hpsvm::HPSVM;

proptest! {
    #[test]
    fn test_property(amount in 1u64..1_000_000) {
        let mut svm = HPSVM::new();
        // ... property-based test
    }
}
```

--------------------------------

### Initialize ComputeUnitMatrixBencher

Source: https://github.com/longcipher/hpsvm/blob/master/docs/superpowers/specs/2026-04-29-hpsvm-mollusk-absorption-design.md

Create a new instance of `ComputeUnitMatrixBencher` for running matrix comparisons across multiple program binaries. This is the starting point for setting up matrix benchmarks.

```rust
impl ComputeUnitMatrixBencher {
    pub fn new() -> Self;
    // ... other methods
}

```

--------------------------------

### with_account_source

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Installs a read-through account source that is used when local state misses an account. This is useful for providing external account data to the HPSVM environment.

```APIDOC
## with_account_source

### Description
Install a read-through account source used when local state misses an account.

### Method
`with_account_source`

### Parameters
#### Path Parameters
- **source** (`impl AccountSource`) - Required - Account source implementation

### Request Example
```rust
use hpsvm_fork_rpc::RpcForkSource;

let fork_source = RpcForkSource::builder()
    .with_rpc_url("http://127.0.0.1:8899")
    .with_slot(1)
    .build();

let svm = HPSVM::builder()
    .with_program_test_defaults()
    .with_account_source(fork_source)
    .build()?;
```
```

--------------------------------

### with_lamports

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Changes the initial lamports in the airdrop account. This sets the starting balance for the account that receives airdropped lamports.

```APIDOC
## with_lamports(self, lamports: u64) -> HpsvmBuilder<State>

### Description
Change the initial lamports in the airdrop account.

### Method
`with_lamports`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let svm = HPSVM::builder()
    .with_program_test_defaults()
    .with_lamports(5_000_000_000) // 5 SOL
    .build()?;
```

### Response
#### Success Response
Returns a `HpsvmBuilder<State>` with the initial lamports set.

#### Response Example
None
```

--------------------------------

### Get Account Information

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Retrieves all information associated with a given account address. Returns None if the account does not exist.

```rust
pub fn get_account(&self, address: &Address) -> Option<Account>

```

```rust
let account = svm.get_account(&some_address)?;
println!("Lamports: {}", account.lamports);
```

--------------------------------

### HpsvmBuilder::new

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Creates a new HpsvmBuilder instance in the initial feature-configurable state (`FeatureConfigOpen`). This is the starting point for configuring an HPSVM environment.

```APIDOC
## HpsvmBuilder::new

### Description
Creates a new builder in the feature-configurable state.

### Method
Rust function call

### Parameters
None

### Returns
HpsvmBuilder<FeatureConfigOpen>

### Example
```rust
use hpsvm::HPSVM;

let builder = HPSVM::builder();
```
```

--------------------------------

### Execute Fixture with Program and Config

Source: https://github.com/longcipher/hpsvm/blob/master/docs/superpowers/specs/2026-04-29-hpsvm-mollusk-absorption-design.md

Use this command to run a specific fixture or a directory of fixtures against a candidate binary set. Specify the fixture path, program binary, and configuration file.

```text
hpsvm fixture run \
  --fixture fixtures/system-transfer \
  --program 11111111111111111111111111111111=./target/deploy/my_program.so \
  --config checks.yaml
```

--------------------------------

### Basic Solana Program Test with HPSVM

Source: https://github.com/longcipher/hpsvm/blob/master/README.md

Demonstrates initializing the SVM, airdropping SOL, creating a transfer instruction, building and signing a transaction, executing it, and verifying account balances. Ensure you have the necessary Solana crates imported.

```rust
use hpsvm::HPSVM;
use solana_address::Address;
use solana_keypair::Keypair;
use solana_message::Message;
use solana_signer::Signer;
use solana_system_interface::instruction::transfer;
use solana_transaction::Transaction;

// Create keypairs for testing
let from_keypair = Keypair::new();
let from = from_keypair.pubkey();
let to = Address::new_unique();

// Initialize the SVM with default configuration
let mut svm = HPSVM::new();

// Airdrop SOL to the sender account
svm.airdrop(&from, 10_000).unwrap();

// Create a transfer instruction
let instruction = transfer(&from, &to, 64);

// Build and sign the transaction
let tx = Transaction::new(
    &[&from_keypair],
    Message::new(&[instruction], Some(&from)),
    svm.latest_blockhash(),
);

// Execute the transaction
let tx_result = svm.send_transaction(tx).unwrap();

// Verify the results
let from_account = svm.get_account(&from).unwrap();
let to_account = svm.get_account(&to).unwrap();
assert_eq!(from_account.lamports, 4936);  // 10000 - 64 - fee
assert_eq!(to_account.lamports, 64);
```

--------------------------------

### Install Inspector for HPSVM Transactions

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Installs an execution inspector to observe top-level transaction activity. The inspector must implement the `Inspector` trait.

```rust
pub fn with_inspector<I: Inspector + 'static>(mut self, inspector: I) -> Self
```

```rust
struct MyInspector;

impl Inspector for MyInspector {
    fn on_transaction_start(&self, _svm: &HPSVM, _tx: &SanitizedTransaction) {
        println!("Transaction started");
    }
}

let svm = HPSVM::new().with_inspector(MyInspector);
```

--------------------------------

### Build Foundry Project

Source: https://github.com/longcipher/hpsvm/blob/master/AGENTS.md

Standard command to build a Foundry project.

```bash
forge build
```

--------------------------------

### get_compute_budget

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Gets the current compute budget.

```APIDOC
## get_compute_budget

### Description
Gets the current compute budget.

### Method
`get_compute_budget`

### Returns
- `Option<ComputeBudget>`
```

--------------------------------

### get_balance

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Gets the balance (lamports) of the provided account.

```APIDOC
## get_balance

### Description
Gets the balance (lamports) of the provided account.

### Method
`&self`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **address** (`&Address`) - Required - The address of the account to query.

### Response
#### Success Response (200)
- **Option<u64>** - The balance of the account, if it exists.

#### Response Example
(No explicit example provided in source)
```

--------------------------------

### Create Basic HPSVM Environment

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Use `HPSVM::new()` for a simple test environment with default configurations, including sysvars, feature accounts, builtins, default programs, signature verification, blockhash checking, and an initial airdrop.

```rust
use hpsvm::HPSVM;

let mut svm = HPSVM::new();
let balance = svm.get_balance(&some_address);
```

--------------------------------

### Get Latest Blockhash

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Retrieves the latest blockhash from the HPSVM environment.

```rust
pub const fn latest_blockhash(&self) -> Hash
```

--------------------------------

### HPSVM::new()

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Creates a basic HPSVM test environment with default configurations. This includes enabling sysvars, feature accounts, builtins, default programs, signature verification, and blockhash checking, along with initializing the airdrop account.

```APIDOC
## HPSVM::new()

### Description
Creates a basic test environment with default configuration. It applies standard program-test defaults: enables sysvars, feature accounts, builtins, default programs, signature verification, and blockhash checking. It initializes the airdrop account with 1 billion SOL.

### Method
`new() -> Self`

### Parameters
None

### Returns
`Self` - A new HPSVM instance with default settings.

### Example
```rust
use hpsvm::HPSVM;

let mut svm = HPSVM::new();
let balance = svm.get_balance(&some_address);
```
```

--------------------------------

### Sysvar Management

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/INDEX.md

Methods for setting and getting system variables (sysvars).

```APIDOC
## Sysvar Management

### Description
Provides functionality to manage system variables (sysvars) within the HPSVM environment.

### Methods
- `set_sysvar<T>(sysvar) -> Result<(), HPSVMError>`: Sets a system variable.
- `get_sysvar<T>() -> T`: Retrieves a system variable.
```

--------------------------------

### Run All Benchmarks

Source: https://github.com/longcipher/hpsvm/blob/master/README.md

Execute all defined benchmarks using cargo.

```bash
cargo bench
```

--------------------------------

### Run Just Commands for Formatting, Linting, and Testing

Source: https://github.com/longcipher/hpsvm/blob/master/AGENTS.md

Execute a sequence of development workflow commands including formatting, linting, and various testing stages.

```bash
just format
just lint
just test
just bdd
just test-all
```

--------------------------------

### Get Compute Budget in HPSVM

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Retrieves the current compute budget of the HPSVM runtime.

```rust
pub const fn get_compute_budget(&self) -> Option<ComputeBudget>
```

--------------------------------

### latest_blockhash

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Gets the latest blockhash from the current block environment. This is used for transaction validation.

```APIDOC
## latest_blockhash

### Description
Gets the latest blockhash.

### Method
`latest_blockhash(&self) -> Hash`

### Response
- `Hash` - The latest blockhash.
```

--------------------------------

### Run All Unit Tests with All Features

Source: https://github.com/longcipher/hpsvm/blob/master/specs/2026-06-17-02-performance/design.md

Execute all unit tests for the project, ensuring all features are enabled.

```bash
cargo test --all-features
```

--------------------------------

### Get Transaction Metadata

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/03-types-and-results.md

Retrieves the transaction metadata captured during the execution of an HPSVM transaction.

```rust
pub fn meta(&self) -> &TransactionMetadata
```

--------------------------------

### Compare Fixture Snapshots with Baseline and Candidate

Source: https://github.com/longcipher/hpsvm/blob/master/docs/superpowers/specs/2026-04-29-hpsvm-mollusk-absorption-design.md

Execute a fixture set against baseline and candidate program sets to compare snapshots. Use the `--ignore` flag to exclude specific metrics from the comparison.

```text
hpsvm fixture compare \
  --fixture fixtures/token \
  --baseline Tokenkeg...=./artifacts/v1.so \
  --candidate Tokenkeg...=./artifacts/v2.so \
  --ignore compute-units
```

--------------------------------

### block_env

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Gets the current block environment, which includes the latest blockhash and the current slot number.

```APIDOC
## block_env

### Description
Gets the current block environment.

### Method
`block_env(&self) -> BlockEnv`

### Response
- `BlockEnv` - A struct containing `latest_blockhash` and `slot` fields.
```

--------------------------------

### Get Transaction from History

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Retrieves a transaction from the HPSVM's transaction history using its signature.

```rust
pub fn get_transaction(&self, signature: &Signature) -> Option<&TransactionResult>
```

--------------------------------

### Run Runtime Benchmarks

Source: https://github.com/longcipher/hpsvm/blob/master/specs/2026-06-17-02-performance/design.md

Execute the runtime benchmarks using the 'just' command.

```bash
just bench-runtime
```

--------------------------------

### Get Fee Payer Address

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/03-types-and-results.md

Returns the fee payer address, if one was validated for this transaction.

```rust
pub fn fee_payer(&self) -> Option<Address>
```

--------------------------------

### Consume and Get Underlying Proto

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/04-companion-crates.md

Consumes the FiredancerFixture and returns the underlying Firedancer protobuf message.

```rust
pub fn into_proto(self) -> fd_codec::proto::InstrFixture
```

--------------------------------

### HPSVM CLI Main Entry Point

Source: https://github.com/longcipher/hpsvm/blob/master/docs/superpowers/plans/2026-04-30-hpsvm-product-layer-phase1.md

Parses command-line arguments and dispatches to the appropriate subcommand (Inspect or Run fixture).

```rust
mod error;
mod fixture;
mod program_map;

use std::path::PathBuf;

use clap::{Args, Parser, Subcommand};

use crate::fixture::{inspect_fixture, run_fixture};

#[derive(Parser)]
#[command(name = "hpsvm")]
struct Cli {
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    Fixture(FixtureArgs),
}

#[derive(Args)]
struct FixtureArgs {
    #[command(subcommand)]
    command: FixtureCommand,
}

#[derive(Subcommand)]
enum FixtureCommand {
    Inspect {
        fixture: PathBuf,
    },
    Run {
        fixture: PathBuf,
        #[arg(long = "program")]
        programs: Vec<String>,
    },
}

fn main() -> Result<(), error::CliError> {
    match Cli::parse().command {
        Command::Fixture(args) => match args.command {
            FixtureCommand::Inspect { fixture } => inspect_fixture(&fixture),
            FixtureCommand::Run { fixture, programs } => run_fixture(&fixture, &programs),
        },
    }
}

```

--------------------------------

### Get Reference to Underlying Proto

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/04-companion-crates.md

Retrieves a reference to the inner Firedancer protobuf message from a FiredancerFixture.

```rust
pub fn as_proto(&self) -> &fd_codec::proto::InstrFixture
```

--------------------------------

### set_account_source

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Installs a read-through account source for future lookups and invalidates previously transacted but uncommitted outcomes.

```APIDOC
## set_account_source

### Description
Installs a read-through account source for future lookups and invalidates previously transacted but uncommitted outcomes.

### Method
`set_account_source`

### Parameters
- `source` (impl AccountSource + 'static) - Description not provided
```

--------------------------------

### Load Fixture from File

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/04-companion-crates.md

Loads a captured instruction execution from a JSON or binary file using the Fixture::load method. Ensure the path points to a valid fixture file.

```rust
use hpsvm_fixture::Fixture;

let fixture = Fixture::load("fixtures/my_instruction.json")?;
```

--------------------------------

### Get Block Environment

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Retrieves the current block environment, which includes the latest blockhash and slot number.

```rust
pub const fn block_env(&self) -> BlockEnv
```

--------------------------------

### Check All Targets and Features

Source: https://github.com/longcipher/hpsvm/blob/master/specs/2026-06-17-02-performance/design.md

Perform a syntax check on all targets and features of the project.

```bash
cargo check --all-targets --all-features
```

--------------------------------

### Get Post-Execution Accounts Snapshot

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/03-types-and-results.md

Retrieves the writable post-execution account snapshot captured by the `transact` method.

```rust
pub fn post_accounts(&self) -> &[(Address, AccountSharedData)]
```

--------------------------------

### Configure hpsvm with Features (TOML)

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/05-patterns-and-advanced.md

Demonstrates how to enable specific features for hpsvm in Cargo.toml for development and production builds.

```toml
# Testing with everything
[dev-dependencies]
hpsvm = { version = "0.1.6", features = ["serde", "precompiles", "register-tracing"] }

# Minimal for production
[dependencies]
hpsvm = "0.1.6"

# With RPC forking
[dev-dependencies]
hpsvm-fork-rpc = "0.1.6"
```

--------------------------------

### get_sysvar

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Gets a sysvar from the test environment. This method allows retrieving the current state of various system variables.

```APIDOC
## get_sysvar

### Description
Gets a sysvar from the test environment.

### Method
`get_sysvar<T>(&self) -> T where T: Sysvar + SysvarId + DeserializeOwned`

### Parameters
- **T** - The type of the sysvar to retrieve. Must implement `Sysvar`, `SysvarId`, and `DeserializeOwned`.

### Response
- `T` - The requested sysvar object.
```

--------------------------------

### Rust: FixtureRunner and End-to-End Replay Validation Tests

Source: https://github.com/longcipher/hpsvm/blob/master/docs/superpowers/plans/2026-04-30-hpsvm-product-layer-phase1.md

Contains tests for the FixtureRunner, demonstrating how to build a fixture, replay transactions against a cloned VM, and apply default comparison settings.

```rust
use hpsvm::HPSVM;
use hpsvm_fixture::{CaptureBuilder, FixtureRunner, RuntimeFixtureConfig};
use hpsvm_result::{AccountSnapshot, Compare, ExecutionSnapshot, ResultConfig};
use solana_address::Address;
use solana_keypair::Keypair;
use solana_message::Message;
use solana_signer::Signer;
use solana_system_interface::instruction::transfer;
use solana_transaction::versioned::VersionedTransaction;

fn snapshot_account(svm: &HPSVM, address: Address) -> AccountSnapshot {
    let account = svm.get_account(&address).unwrap();
    AccountSnapshot {
        address,
        lamports: account.lamports,
        owner: account.owner,
        executable: account.executable,
        rent_epoch: account.rent_epoch,
        data: account.data,
    }
}

fn build_fixture() -> hpsvm_fixture::Fixture {
    let mut svm = HPSVM::new();
    let payer = Keypair::new();
    let recipient = Address::new_unique();

    svm.airdrop(&payer.pubkey(), 10_000).unwrap();
    let tx = VersionedTransaction::from(solana_transaction::Transaction::new(
        &[&payer],
        Message::new(&[transfer(&payer.pubkey(), &recipient, 64)], Some(&payer.pubkey())),
        svm.latest_blockhash(),
    ));
    let baseline = ExecutionSnapshot::from_outcome(&svm.transact(tx.clone()));

    CaptureBuilder::new("runner-transfer")
        .runtime(RuntimeFixtureConfig {
            slot: svm.block_env().slot,
            log_bytes_limit: None,
            sigverify: true,
            blockhash_check: false,
        })
        .pre_accounts(vec![
            snapshot_account(&svm, payer.pubkey()),
            snapshot_account(&svm, recipient),
        ])
        .baseline(baseline)
        .compares(Compare::everything())
        .capture_transaction(&tx)
        .unwrap()
}

#[test]
fn runner_replays_transaction_fixture_against_a_cloned_vm() {
    let fixture = build_fixture();
    let mut runner = FixtureRunner::new(HPSVM::new());

    let execution = runner.run(&fixture).unwrap();

    assert!(execution
        .snapshot
        .compare_with(&fixture.expectations.baseline, &Compare::everything(), &ResultConfig {
            panic: false,
            verbose: true,
        }));
}

#[test]
fn runner_can_apply_fixture_default_compares() {
    let mut fixture = build_fixture();
    fixture.expectations.baseline.compute_units_consumed += 1;
    fixture.expectations.compares = Compare::everything_but_compute_units();

    let mut runner = FixtureRunner::new(HPSVM::new());
    let pass = runner
        .run_and_validate(
            &fixture,
            &ResultConfig {
                panic: false,
                verbose: true,
            },
        )
        .unwrap();

    assert!(pass);
}

```

--------------------------------

### Get Airdrop Pubkey

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Returns the public key of the internal account used for airdropping funds in the HPSVM environment.

```rust
pub fn airdrop_pubkey(&self) -> Address
```

--------------------------------

### HPSVM Build and Test Commands

Source: https://github.com/longcipher/hpsvm/blob/master/specs/context.md

Lists essential commands for building, linting, formatting, testing, and checking the HPSVM project using Cargo and Just.

```text
Install   | `cargo build --workspace`                        | exit 0              
Lint      | `just lint`                                      | exit 0, no errors   
Format    | `just format`                                    | exit 0              
Tests     | `cargo test --all-features`                      | all pass            
BDD       | `cargo test -p hpsvm --test bdd`                 | all pass            
Check     | `cargo check --all-targets --all-features`       | exit 0              
Clippy    | `cargo +nightly clippy --all -- -D warnings ...` | exit 0, no errors   
```

--------------------------------

### Get Sysvar from HPSVM

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Retrieves a sysvar from the test environment. This is useful for inspecting the current state of system variables.

```rust
pub fn get_sysvar<T>(&self) -> T
where
    T: Sysvar + SysvarId + DeserializeOwned,
```

```rust
use solana_clock::Clock;

let clock = svm.get_sysvar::<Clock>();
println!("Slot: {}", clock.slot);
```

--------------------------------

### with_custom_syscall

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Queues a custom syscall for both runtime environments. The builder applies the registration during `build()`, simplifying the process for callers.

```APIDOC
## with_custom_syscall

### Description
Queue a custom syscall for both runtime environments.

### Method
`with_custom_syscall`

### Parameters
#### Path Parameters
- **name** (`&str`) - Required - Syscall name (e.g., "sol_log_data")
- **syscall** (`BuiltinFunction<InvokeContext<'static, 'static>>`) - Required - Syscall implementation

### Note
The builder stores the registration and applies it once during `build()`, so callers do not have to reason about whether builtins or cached programs have already been loaded.
```

--------------------------------

### Get Account Balance

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Retrieves the balance (lamports) of a provided account address. Returns None if the account does not exist.

```rust
pub fn get_balance(&self, address: &Address) -> Option<u64>

```

--------------------------------

### Implement `Compare::everything` in Rust

Source: https://github.com/longcipher/hpsvm/blob/master/docs/superpowers/plans/2026-04-30-hpsvm-product-layer-phase1.md

Provides a method to generate a comprehensive list of all comparison criteria for execution results. This includes status, included status, compute units, fee, return data, logs, inner instruction count, and all accounts.

```rust
impl Compare {
    pub fn everything() -> Vec<Self> {
        vec![
            Self::Status,
            Self::Included,
            Self::ComputeUnits,
            Self::Fee,
            Self::ReturnData,
            Self::Logs,
            Self::InnerInstructionCount,
            Self::Accounts(AccountCompareScope::All),
        ]
    }

    pub fn everything_but_compute_units() -> Vec<Self> {
        vec![
            Self::Status,
            Self::Included,
            Self::Fee,
            Self::ReturnData,
            Self::Logs,
            Self::InnerInstructionCount,
            Self::Accounts(AccountCompareScope::All),
        ]
    }
}
```

--------------------------------

### Forking from Mainnet for Testing

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/05-patterns-and-advanced.md

Test against mainnet state by using `RpcForkSource` to fetch accounts on-demand. Configure the RPC URL and slot for the fork.

```rust
use hpsvm_fork_rpc::RpcForkSource;

let fork = RpcForkSource::builder()
    .with_rpc_url("https://api.mainnet-beta.solana.com")
    .with_slot(200_000_000)
    .build();

let mut svm = HPSVM::builder()
    .with_program_test_defaults()
    .with_account_source(fork)
    .build()?;

// Mainnet accounts are available on-demand
let result = svm.send_transaction(tx)?;
```

--------------------------------

### Build HPSVM with Custom Compute Budget and Programs

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Creates an HPSVM with a custom compute budget, default programs, signature verification, blockhash check, lamports, and log byte limit. Use this for more advanced configurations.

```rust
use agave_feature_set::FeatureSet;
use hpsvm::HPSVM;
use solana_compute_budget::compute_budget::ComputeBudget;

fn build_custom_svm() -> Result<HPSVM, hpsvm::error::HPSVMError> {
    let mut budget = ComputeBudget::default();
    budget.compute_unit_limit = 300_000;

    let feature_set = FeatureSet::default();

    HPSVM::builder()
        .with_feature_set(feature_set)
        .with_builtins()
        .with_sysvars()
        .with_default_programs()
        .with_compute_budget(budget)
        .with_sigverify(true)
        .with_blockhash_check(true)
        .with_lamports(2_000_000_000) // 2 SOL
        .with_log_bytes_limit(Some(20_000))
        .build()
}
```

--------------------------------

### Get Signature Verification Status in HPSVM

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Returns a boolean indicating whether signature verification is currently enabled in the HPSVM runtime.

```rust
pub const fn get_sigverify(&self) -> bool
```

--------------------------------

### Account Source Switching for Fallback

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/05-patterns-and-advanced.md

Switch the account source to an external RPC for fallback when accounts are not found locally.

```rust
// Read accounts from external source
let fork = RpcForkSource::builder()
    .with_rpc_url("http://127.0.0.1:8899")
    .build();

svm.set_account_source(fork);

// Now missing accounts are fetched from RPC
```

--------------------------------

### Get Transaction Execution Status

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/03-types-and-results.md

Returns the execution status that `commit_transaction` will commit if the outcome provenance still matches the target VM.

```rust
pub fn status(&self) -> &Result<()>
```

--------------------------------

### Run Fixture Function

Source: https://github.com/longcipher/hpsvm/blob/master/docs/superpowers/plans/2026-04-30-hpsvm-product-layer-phase1.md

Loads a fixture, parses program arguments, preloads programs, and runs the fixture validation.

```rust
pub fn run_fixture(path: &Path, program_args: &[String]) -> Result<(), CliError> {
    let fixture = Fixture::load(path)?;
    let programs = parse_program_map(program_args)?;
    let mut runner = preload_runner(FixtureRunner::new(HPSVM::new()), &fixture, &programs);

    let pass = runner.run_and_validate(
        &fixture,
        &ResultConfig {
            panic: false,
            verbose: true,
        },
    )?;

    if pass {
        println!("PASS: {}", path.display());
        Ok(())
    } else {
        eprintln!("FAIL: {}", path.display());
        std::process::exit(1);
    }
}

```

--------------------------------

### Test Foundry Project

Source: https://github.com/longcipher/hpsvm/blob/master/AGENTS.md

Standard command to run tests in a Foundry project.

```bash
forge test
```

--------------------------------

### Set Account Source in HPSVM

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Installs a read-through account source for future lookups. This is an advanced reconfiguration method for managing account data.

```rust
pub fn set_account_source(&mut self, source: impl AccountSource + 'static)
```

--------------------------------

### Queue Custom Syscall

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Use `with_custom_syscall` to queue a custom syscall for both runtime environments. The registration is applied during `build()`.

```rust
pub fn with_custom_syscall(
    mut self,
    name: &str,
    syscall: BuiltinFunction<InvokeContext<'static, 'static>>,
) -> Self
```

--------------------------------

### RpcForkSourceBuilder::build()

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/04-companion-crates.md

Builds and returns a configured RpcForkSource instance based on the builder's settings.

```APIDOC
## RpcForkSourceBuilder::build()

### Description
Builds and returns a configured RpcForkSource instance based on the builder's settings.

### Method
Rust function call

### Endpoint
N/A

### Parameters
N/A

### Request Example
```rust
let fork_source = RpcForkSource::builder()
    .with_rpc_url("http://127.0.0.1:8899")
    .with_slot(1)
    .build();
```

### Response
#### Success Response
- **RpcForkSource**: An instance of the RPC-backed account source.
```

--------------------------------

### Compare Fresh Benchmark Run with Committed Baselines

Source: https://github.com/longcipher/hpsvm/blob/master/README.md

Compare a fresh benchmark run with the committed baselines for both hotpath and runtime.

```bash
just bench-hotpath
```

```bash
just bench-baseline-compare
```

--------------------------------

### Call pretty_logs Method

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/03-types-and-results.md

Demonstrates how to use the `pretty_logs` method to retrieve formatted transaction logs with ANSI color codes.

```rust
println!("{}", result.meta.pretty_logs());
```

--------------------------------

### Get Accounts View (Advanced)

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Returns a read-only view of the internal accounts database for advanced inspection. Use `get_account` for normal account retrieval.

```rust
pub const fn accounts(&self) -> AccountsView<'_>

```

--------------------------------

### Load and Compare Fixtures in Rust

Source: https://github.com/longcipher/hpsvm/blob/master/docs/superpowers/plans/2026-04-30-hpsvm-product-layer-phase1.md

Loads a fixture, parses program arguments, and compares baseline and candidate snapshots. Handles configuration loading and optional ignoring of compute units.

```rust
// bin/hpsvm-cli/src/fixture.rs
use std::path::Path;

use hpsvm::HPSVM;
use hpsvm_fixture::{Fixture, FixtureRunner};
use hpsvm_result::ResultConfig;

use crate::{
    config::load_compares,
    error::CliError,
    program_map::{parse_program_map, preload_runner},
};

pub fn inspect_fixture(path: &Path) -> Result<(), CliError> {
    let fixture = Fixture::load(path)?;
    println!("{}", serde_json::to_string_pretty(&fixture)?);
    Ok(())
}

pub fn run_fixture(path: &Path, program_args: &[String]) -> Result<(), CliError> {
    let fixture = Fixture::load(path)?;
    let programs = parse_program_map(program_args)?;
    let mut runner = preload_runner(FixtureRunner::new(HPSVM::new()), &fixture, &programs);

    let pass = runner.run_and_validate(
        &fixture,
        &ResultConfig {
            panic: false,
            verbose: true,
        },
    )?;

    if pass {
        println!("PASS: {}", path.display());
        Ok(())
    } else {
        eprintln!("FAIL: {}", path.display());
        std::process::exit(1)
    }
}

pub fn compare_fixture(
    path: &Path,
    baseline_program_args: &[String],
    candidate_program_args: &[String],
    config_path: Option<&Path>,
    ignore_compute_units: bool,
) -> Result<(), CliError> {
    let fixture = Fixture::load(path)?;
    let compares = load_compares(config_path, &fixture.expectations.compares, ignore_compute_units)?;

    let baseline_programs = parse_program_map(baseline_program_args)?;
    let candidate_programs = parse_program_map(candidate_program_args)?;

    let mut baseline_runner = preload_runner(FixtureRunner::new(HPSVM::new()), &fixture, &baseline_programs);
    let mut candidate_runner = preload_runner(FixtureRunner::new(HPSVM::new()), &fixture, &candidate_programs);

    let baseline_snapshot = baseline_runner.run(&fixture)?.snapshot;
    let candidate_snapshot = candidate_runner.run(&fixture)?.snapshot;

    let pass = baseline_snapshot.compare_with(
        &candidate_snapshot,
        &compares,
        &ResultConfig {
            panic: false,
            verbose: true,
        },
    );

    if pass {
        println!("PASS: {}", path.display());
        Ok(())
    } else {
        eprintln!("FAIL: {}", path.display());
        std::process::exit(1)
    }
}

```

--------------------------------

### Seal Feature Configuration with Default Programs

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Queues the standard default programs (System, Compute Budget, Config, Stake, Vote, and BPF loader) and seals the feature selection window.

```rust
pub fn with_default_programs(mut self) -> HpsvmBuilder<FeatureConfigSealed>
```

--------------------------------

### Set Compute Budget

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Configure the compute budget for runtime environments using `with_compute_budget`. This sets limits on computation units.

```rust
use solana_compute_budget::compute_budget::ComputeBudget;

let mut budget = ComputeBudget::default();
budget.compute_unit_limit = 200_000;

let svm = HPSVM::builder()
    .with_program_test_defaults()
    .with_compute_budget(budget)
    .build()?;
```

--------------------------------

### add_program_from_file

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/01-hpsvm-core.md

Adds an SBF program to the test environment directly from a file path. This is a convenience method for loading programs.

```APIDOC
## add_program_from_file

### Description
Adds an SBF program from a file path.

### Method
`add_program_from_file(&mut self, program_id: impl Into<Address>, path: impl AsRef<Path>) -> Result<(), HPSVMError>`

### Parameters
- **program_id** (impl Into<Address>) - The ID of the program to add.
- **path** (impl AsRef<Path>) - The file path to the program's binary.

### Response
- `Result<(), HPSVMError>` - Ok if the program was added successfully, or an HPSVMError if it failed.
```

--------------------------------

### build(self) -> Result<HPSVM, HPSVMError>

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Materializes the build plan into a runnable `HPSVM`. This method consumes the builder and returns a `Result` which is either a successfully built `HPSVM` or an `HPSVMError`.

```APIDOC
## build(self) -> Result<HPSVM, HPSVMError>

### Description
Materialize the build plan into a runnable `HPSVM`.

### Method
This is a method on the builder object, typically called after configuring various aspects of the HPSVM.

### Returns
- `Result<HPSVM, HPSVMError>`: On success, returns the constructed `HPSVM`. On failure, returns an `HPSVMError`.

### Errors
- `HPSVMError::MissingRuntimeComponent`: Required runtime surfaces not materialized (e.g., builtins need sysvars).
- `HPSVMError::RuntimeEnvironment`: Failed to refresh runtime environments.
- `HPSVMError::CustomSyscallRegistration`: Failed to register custom syscall.
- `HPSVMError::InvalidPath`: File I/O error.
- `HPSVMError::InvalidLoader`: Invalid program loader.

### Example
```rust
let svm = HPSVM::builder()
    .with_feature_set(FeatureSet::default())
    .with_builtins()
    .with_sysvars()
    .with_sigverify(true)
    .build()?;
```
```

--------------------------------

### Build Solana Test Programs

Source: https://github.com/longcipher/hpsvm/blob/master/README.md

Builds Solana programs for testing using the `cargo build-sbf` command. This command is typically run from the test programs directory.

```bash
cd crates/hpsvm/test_programs
cargo build-sbf

```

--------------------------------

### Run Clippy with Warnings as Errors

Source: https://github.com/longcipher/hpsvm/blob/master/specs/2026-06-17-02-performance/design.md

Execute Clippy with the nightly toolchain, applying all lints and treating warnings as errors.

```bash
cargo +nightly clippy --all -- -D warnings
```

--------------------------------

### Compute Budget Configuration

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/05-patterns-and-advanced.md

Configure specific compute unit limits and log pubkey linear costs for programs by passing a `ComputeBudget` struct to the HPSVM builder.

```rust
use solana_compute_budget::compute_budget::ComputeBudget;

let mut budget = ComputeBudget::default();
budget.compute_unit_limit = 500_000;
budget.log_pubkey_linear_cost = 100;

let svm = HPSVM::builder()
    .with_program_test_defaults()
    .with_compute_budget(budget)
    .build()?;
```

--------------------------------

### Configure with Program Test Defaults

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Queues the runtime surfaces typically used by `HPSVM::new()`. If no feature set was explicitly chosen, it defaults to a fully-enabled set. Otherwise, the explicitly chosen feature set is retained.

```rust
pub fn with_program_test_defaults(mut self) -> HpsvmBuilder<FeatureConfigSealed>
```

```rust
let svm = HPSVM::builder()
    .with_program_test_defaults()
    .build()?;
```

--------------------------------

### HpsvmBuilder::with_default_programs

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Queues the standard default programs (System, Compute Budget, Config, Stake, Vote, and BPF loader) and seals the feature selection window, transitioning the builder to the `FeatureConfigSealed` state.

```APIDOC
## HpsvmBuilder::with_default_programs

### Description
Queue the standard default programs and seal the feature selection window.

### Method
Rust function call

### Parameters
None

### Returns
HpsvmBuilder<FeatureConfigSealed>

### Example
```rust
let svm = HPSVM::builder()
    .with_default_programs()
    .build()?;
```
```

--------------------------------

### HPSVM with Rust Test Framework

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/INDEX.md

Demonstrates basic instantiation of HPSVM within a Rust unit test. Ensure the `hpsvm` crate is added as a dependency.

```rust
#[cfg(test)]
mod tests {
    use hpsvm::HPSVM;

    #[test]
    fn test_instruction() {
        let mut svm = HPSVM::new();
        // ... test code
    }
}
```

--------------------------------

### Inspect Fixture Function

Source: https://github.com/longcipher/hpsvm/blob/master/docs/superpowers/plans/2026-04-30-hpsvm-product-layer-phase1.md

Loads a fixture from a given path and prints its JSON representation to standard output.

```rust
use std::path::Path;

use hpsvm::HPSVM;
use hpsvm_fixture::{Fixture, FixtureRunner};
use hpsvm_result::ResultConfig;

use crate::{
    error::CliError,
    program_map::{parse_program_map, preload_runner},
};

pub fn inspect_fixture(path: &Path) -> Result<(), CliError> {
    let fixture = Fixture::load(path)?;
    println!("{}", serde_json::to_string_pretty(&fixture)?);
    Ok(())
}

```

--------------------------------

### Capturing and Replaying Instructions with Fixtures

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/04-companion-crates.md

Utilize `hpsvm-fixture` to capture specific on-chain instructions and their associated accounts, saving them as reusable fixtures. These fixtures can later be loaded and replayed for consistent testing. Supports JSON format.

```rust
use hpsvm_fixture::{CaptureBuilder, FixtureFormat};

fn capture_instruction() -> Result<(), Box<dyn std::error::Error>> {
    let fixture = CaptureBuilder::new()
        .with_instruction(instruction)
        .with_accounts(accounts)
        .build()?;

    // Save to JSON
    fixture.save("fixtures/my_instruction.json", FixtureFormat::Json)?;

    // Later, load and replay
    let loaded = hpsvm_fixture::Fixture::load("fixtures/my_instruction.json")?;
    Ok(())
}

```

--------------------------------

### Add anstyle dependency

Source: https://github.com/longcipher/hpsvm/blob/master/specs/2026-06-17-01-quick-wins/tasks.md

Command to add the `anstyle` dependency to the workspace.

```bash
cargo add anstyle --workspace
```

--------------------------------

### Iterating Account Diffs After Transaction

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/03-types-and-results.md

Demonstrates how to iterate through account differences from a transaction outcome and print lamport changes.

```rust
let outcome = svm.transact(tx);
for diff in &outcome.meta().diagnostics.account_diffs {
    println!("Address: {}", diff.address);
    if let (Some(pre), Some(post)) = (&diff.pre, &diff.post) {
        println!("  Lamports: {} -> {}", pre.lamports, post.lamports);
    }
}
```

--------------------------------

### with_default_programs

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/02-builder-api.md

Queues the standard default programs after the feature set has been locked in.

```APIDOC
## with_default_programs

### Description
Queue the standard default programs after the feature set has been locked in.

### Method
`with_default_programs(self) -> HpsvmBuilder<FeatureConfigSealed>`

### Parameters
This method does not take any parameters.

### Response
Returns an `HpsvmBuilder<FeatureConfigSealed>` instance.
```

--------------------------------

### Set Output Directory for Benchmark Results

Source: https://github.com/longcipher/hpsvm/blob/master/docs/superpowers/specs/2026-04-29-hpsvm-mollusk-absorption-design.md

Specify the directory where benchmark results, including reports and snapshots, will be saved. This helps organize output from multiple benchmark runs.

```rust
impl ComputeUnitBencher {
    // ... other methods
    pub fn output_dir(self, path: impl Into<std::path::PathBuf>) -> Self;
    // ... other methods
}

```

--------------------------------

### Execute Matrix Compute Unit Benchmark

Source: https://github.com/longcipher/hpsvm/blob/master/docs/superpowers/specs/2026-04-29-hpsvm-mollusk-absorption-design.md

Execute the configured matrix benchmark, comparing the specified fixtures across all registered program binaries. Returns a `MatrixReport` or a `BenchError`.

```rust
impl ComputeUnitMatrixBencher {
    // ... other methods
    pub fn execute(self) -> Result<MatrixReport, BenchError>;
}

```

--------------------------------

### Format Code

Source: https://github.com/longcipher/hpsvm/blob/master/README.md

Format the project's code according to standard Rust formatting.

```bash
cargo fmt
```

--------------------------------

### Enable Serde Serialization

Source: https://github.com/longcipher/hpsvm/blob/master/_autodocs/03-types-and-results.md

Shows how to add the 'serde' feature to Cargo.toml to enable serialization for HPSVM types.

```toml
[dev-dependencies]
hpsvm = { version = "0.1.6", features = ["serde"] }
```

--------------------------------

### Initialize Fuzz Targets with Cargo Fuzz

Source: https://github.com/longcipher/hpsvm/blob/master/AGENTS.md

Initialize the standard layout for fuzzing targets within a specific crate.

```bash
cargo fuzz init
```
Tokens:
Raw