Solana Development Notes Part 1: Rust Essentials for Blockchain Builders

Blockchain technology continues to evolve at a rapid pace, and Solana has emerged as one of the most high-performance, scalable public blockchains today. With its unique architecture and blazing-fast transaction speeds, Solana is attracting developers from around the world. This article dives into the foundational concepts of Solana development, focusing on Rust—the preferred language for building secure and efficient on-chain programs.

Whether you're a seasoned Rust developer or transitioning into blockchain, this guide will walk you through setting up your environment, understanding Solana's account model, and deploying your first "Hello World" program.

Understanding Solana: A High-Performance Blockchain

Solana is a permissionless, decentralized blockchain designed to deliver high throughput without compromising security or decentralization. Launched in early 2020, it supports over 800 global nodes and achieves up to 65,000 transactions per second (TPS) with an average block time of just 400 milliseconds.

What sets Solana apart is its innovative Proof of History (PoH) consensus mechanism. PoH acts as a decentralized clock that timestamps events before they are validated, eliminating the need for nodes to constantly synchronize time. This significantly boosts network efficiency and enables parallel processing of transactions.

Core Keywords:

Solana development
Rust blockchain programming
On-chain programs
Solana CLI
Account model
BPF bytecode
Sealevel runtime
Proof of History (PoH)

👉 Get started with Solana development tools and resources today.

On-Chain Programs: Solana’s Smart Contracts

In Solana, smart contracts are referred to as on-chain programs. These programs run within the Sealevel parallel runtime environment and are written primarily in Rust or C. The development workflow involves:

Writing logic in Rust
Compiling it into Berkeley Packet Filter (BPF) bytecode (.so file)
Deploying the compiled program to the Solana blockchain
Interacting via client applications using the Solana JSON RPC API

Clients can use official SDKs in JavaScript/TypeScript, Python, or Rust to send transactions and read data from the chain.

Solana’s Unique Account Model

Like Ethereum, Solana uses an account-based model—but with key differences that enhance scalability and security.

Each account contains the following fields:

lamports: The account's balance in lamports (1 SOL = 1,000,000,000 lamports)
owner: The public key of the program that owns the account
executable: Indicates whether the account stores program code
data: Arbitrary state data stored by the program
rent_epoch: Tracks when rent is due; accounts must pay rent unless they are rent-exempt

Two Types of Accounts:

Executable accounts: Store immutable BPF bytecode (i.e., the program itself)
Non-executable accounts: Hold mutable state data used by programs

Unlike Ethereum—where contract code and state reside in the same account—Solana separates them. A program (executable account) cannot store state directly. Instead, it writes data to separate, non-executable accounts it owns.

✅ Key Rule: Only the owning program can modify an account’s data. Other programs may read it but cannot alter it.

This design enables better parallelism and improves performance across the Sealevel execution engine.

For deeper insights, refer to the official Solana Account Model documentation.

Setting Up Your Development Environment

Before writing any code, you need to configure your local environment with essential tools.

Install Prerequisites

Ensure you have the latest stable versions of:

Node.js and npm
Rust (via rustup)

Then install the Solana CLI, the primary tool for interacting with Solana clusters.

Installing Solana CLI

Run this command in your terminal:

sh -c "$(curl -sSfL https://release.solana.com/stable/install)"

Upon successful installation, you’ll see output like:

downloading stable installer
✨ stable commit e9bef425 initialized
Adding export PATH="~/.local/share/solana/install/active_release/bin:$PATH" to ~/.profile

Apply the PATH changes by restarting your terminal or running:

export PATH="~/.local/share/solana/install/active_release/bin:$PATH"

Verify installation:

solana --version
# Output: solana-cli 1.7.18 (src:e9bef425; feat:140464022)

To update an existing CLI:

solana-install update

Configuring the Solana CLI

Connect to a Cluster

Solana offers multiple environments:

localhost: Local test validator
devnet: Public developer network (free SOL via airdrop)
testnet: For testing new features
mainnet-beta: Live production network

Set your target cluster:

solana config set --url localhost    # For local development
solana config set --url devnet       # For testing with free tokens

Create a Wallet Account

Generate a new keypair:

solana-keygen new

This creates a file at ~/.config/solana/id.json. While convenient for development, avoid this method in production due to security risks.

View your public key:

solana-keygen pubkey

Check your balance:

solana balance

On devnet, request test SOL:

solana airdrop 2

You now have 2 test SOL to cover transaction fees.

👉 Explore advanced wallet management and secure key handling techniques.

Building Your First Solana Program: Hello World

Let’s build and deploy a simple "Hello World" on-chain program that counts how many times it has been called.

Project Structure

The example-helloworld project includes:

example-helloworld/
├── src/
│   ├── program-rust/       # Rust-based on-chain program
│   └── client/             # TypeScript client for interaction
├── package.json
└── tsconfig.json

We’ll focus on program-rust/src/lib.rs—the core logic—and the client-side interaction.

On-Chain Program Explained

Here’s the critical part of lib.rs:

use borsh::{BorshDeserialize, BorshSerialize};
use solana_program::{
    account_info::{next_account_info, AccountInfo},
    entrypoint,
    msg,
    pubkey::Pubkey,
};

#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct GreetingAccount {
    pub counter: u32,
}

entrypoint!(process_instruction);

pub fn process_instruction(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    _instruction_data: &[u8],
) -> ProgramResult {
    msg!("Hello World Rust program entrypoint");

    let accounts_iter = &mut accounts.iter();
    let account = next_account_info(accounts_iter)?;

    if account.owner != program_id {
        return Err(ProgramError::IncorrectProgramId);
    }

    let mut greeting_account = GreetingAccount::try_from_slice(&account.data.borrow())?;
    greeting_account.counter += 1;
    greeting_account.serialize(&mut &mut account.data.borrow_mut()[..])?;

    msg!("Greeted {} time(s)!", greeting_account.counter);
    Ok(())
}

Key Concepts:

entrypoint!: Defines the function called when the program runs.
GreetingAccount: A custom struct serialized using Borsh to store state.
msg!: Logs messages visible via solana logs.
The program increments a counter each time it's invoked.

Client Interaction with TypeScript

The client uses @solana/web3.js to interact with the deployed program.

Key steps include:

Connecting to the cluster
Funding a payer account
Deploying the program
Creating a greeting account
Sending transactions to increment the counter

After deployment, each call to sayHello() increases the counter stored on-chain.

Deploying Locally: Step-by-Step

Clone the repo:

git clone https://github.com/solana-labs/example-helloworld.git
cd example-helloworld

Build the program:
```
cd src/program-rust/
cargo build-bpf
```
Output: helloworld.so in /target/deploy

Start local validator:

solana config set --url localhost
solana-test-validator

Deploy:
```
solana program deploy target/deploy/helloworld.so
```
Returns: Program Id: 6AArMEBpFhhtU2mBnEMEPeEH7xkhfUwPseUeG4fhLYto
Run client:
```
npm install
npm run start
```

Output confirms interaction success:

Eq7bcsg5p6AaYiPnfiia99ESsuq4B4jYpVbWZhQ94Zvy has been greeted 1 time(s)

Use solana logs to debug failed transactions.

Frequently Asked Questions (FAQ)

Q1: Why use Rust for Solana development?

Rust ensures memory safety and prevents common bugs like null pointers and buffer overflows—critical for secure blockchain applications.

Q2: What is BPF bytecode?

BPF (Berkeley Packet Filter) is a lightweight virtual machine format used by Solana to execute on-chain programs efficiently and securely.

Q3: Can I modify another program’s account?

Only if your program owns it. Otherwise, modifications are rejected, ensuring data integrity.

Q4: How do I handle errors in on-chain programs?

Return a ProgramResult—Ok(()) for success or Err(ProgramError) for failure. Use msg! for debugging logs.

Q5: Is local development safe?

Yes, for testing. But never use default key storage (id.json) in production—opt for hardware wallets or encrypted keystores.

Q6: How does Solana achieve high TPS?

Through PoH for time ordering, Sealevel for parallel execution, and Turbine for fast block propagation.

Final Thoughts

This introduction covered Solana’s core architecture, account model, environment setup, and deploying your first on-chain program using Rust. You’re now equipped to explore more complex dApps, token programs, and DeFi protocols on Solana.

As you advance, remember to follow best practices in security, testing, and optimization.

👉 Accelerate your blockchain journey with powerful tools and ecosystem support.