Building on Solana: A Deep Dive into Rust & Anchor Programs

Ever heard of smart contracts? Of course, you have. But on Solana, we call them programs. These aren’t just any smart contracts—they're the logic that powers decentralized applications (dApps) on the Solana blockchain. Imagine programs as on-chain accounts storing executable logic, ready to be called into action by a trigger known as an instruction.

So, what’s cool about Solana programs? Well, they’re stateless, which means they don’t store any data themselves. Instead, they can create new accounts to store and manage data. This stateless design helps keep the blockchain efficient and scalable.

Key Takeaways:

• Programs are the Solana equivalent of smart contracts.
   
• They are stateless but can manage state by creating accounts.
   
• Programs can be updated unless made immutable by revoking the upgrade authority.
   

• Native Rust: Writing Solana programs directly in Rust without any framework. This approach offers flexibility but comes with a steeper learning curve.
   
• Anchor: A framework that simplifies Solana development by reducing boilerplate code. Think of it as Rust on steroids. Anchor uses Rust macros to handle the heavy lifting, making it the ideal choice for beginners and pros alike.
   

In the decentralized world, trust is everything. That’s why verifiable builds are so important on Solana. A verifiable build ensures that the on-chain program matches the publicly available source code. This level of transparency builds trust among users and developers alike.

1. SolanaFM Explorer: Search for a program address and navigate to the "Verification" tab.
    
2. Verification Tools: Use the Solana Verifiable Build CLI by Ellipsis Labs to independently verify that the on-chain program aligns with its published source code.
    
3. Anchor’s Built-In Support: Anchor provides built-in support for verifiable builds, making the verification process even smoother.
    

What You Will Do

In this tutorial, you'll:

• Set up your Solana development environment.
• Write a simple "Hello World" program in Rust.
• Deploy the program to Solana's Devnet.
• Interact with the program via a client.
   

What You Will Need

• Basic knowledge of Solana fundamentals.
• Basic understanding of Rust programming.
• A modern web browser (e.g., Google Chrome).
• A terminal with access to Solana CLI.
  
   

Setting Up Your Environment

1. Install Rust and Cargo:

   If you haven’t already, install Rust and Cargo by following the official guide:

   COPY

   1curl --proto '=https' --tlsv1.2 -sSf <https://sh.rustup.rs> | sh
   2

2. Install Solana CLI:

   The Solana Command Line Interface (CLI) is essential for interacting with the Solana blockchain. Install it using the following command:

   COPY

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

3. Create a New Project:

   Create a new directory for your project and navigate into it:

   COPY

   1mkdir solana-hello-world && cd solana-hello-world
   2

4. Initialize a New Cargo Project:

   Create a new Rust project with Cargo:

   COPY

   1cargo new --lib hello_world
   2cd hello_world
   3

5. Set Up Your Program:

   Open the lib.rs file in your favorite code editor and replace the contents with the following:

   

   This basic program logs "Hello, Solana!" whenever it's invoked.

    

Building and Deploying Your Program

1. Build Your Program:

   Compile your program to ensure there are no errors:

   COPY

   1cargo build-bpf
   2

2. Create a New Wallet:

   Generate a new Solana wallet for Devnet:

   COPY

   1solana-keygen new --outfile ~/my-solana-wallet.json
   2solana config set --keypair ~/my-solana-wallet.json
   3

3. Airdrop SOL to Your Wallet:

   Request some SOL tokens to deploy your program on Devnet:

   COPY

   1solana airdrop 2
   2

4. Deploy Your Program:

   Deploy your program to the Solana blockchain:

   COPY

   1solana program deploy ./target/deploy/hello_world.so
   2

   Note the program's public key, which will be used to interact with it.

    

Interacting with Your Program

1. Create a Client:

   Write a simple Rust client to call your program:
   
   

2. Run Your Client:

   Execute the client to interact with your program:

   COPY

   1cargo run
   2

   If successful, you’ll see your transaction's signature in the console, and the "Hello, Solana!" message will be logged on Solana Explorer.

    

What You Will Do

In this tutorial, you'll:

• Set up your development environment.
• Write a "Hello World" program using Anchor.
• Deploy the program to Solana's Devnet.
• Interact with the program via a TypeScript client.
   

What You Will Need

• Basic knowledge of Solana fundamentals.
• Basic understanding of Rust and TypeScript programming.
• A modern web browser (e.g., Google Chrome).
   

Setting Up Your Environment

1. Install Rust and Cargo:

   Follow the steps in the previous tutorial to install Rust and Cargo.

2. Install Anchor:

   Install the Anchor CLI via Cargo:

   COPY

   1
   2cargo install --git <https://github.com/coral-xyz/anchor> avm --locked
   3anchor upgrade
   4
   5

3. Set Up Your Project:

   Create a new Anchor project:

   COPY

   1
   2anchor init hello_anchor
   3cd hello_anchor
   4
   5

4. Write Your Program:

   Open the lib.rs file in the programs/hello_anchor/src/ directory and replace the contents with:

   

   This program logs "Hello, Anchor!" to the console when executed.

    

Building and Deploying Your Program

1. Build Your Program:

   Compile your Anchor program:

   COPY

   1anchor build
   2

2. Deploy to Devnet:

   Deploy your program to Solana Devnet:

   COPY

   1anchor deploy
   2

   Your program's public key will be displayed in the terminal after deployment.

    

Interacting with Your Program

1. Set Up Your Client:

   Open the tests/hello_anchor.ts file and replace the contents with:
    

   
    

2. Run the Client:

   Execute the client test to interact with your program:

   COPY

   1anchor test
   2

   After running the test, check the Solana Explorer for your transaction, where you’ll see the "Hello, Anchor!" message.

    

Building on Solana is more than just writing programs; it’s about creating the future of decentralized applications. Whether you choose to go full Rust or embrace the simplicity of Anchor, Solana offers the tools and infrastructure to bring your ideas to life. So, what will you build next?

When building and deploying on Solana, it’s crucial to ensure the security of your project. Make sure to audit your code with a reputable firm like QuillAudits to safeguard your work and protect your users.