Solana Good Contract Examples for Builders

Are you trying to get into Solana sensible contract growth? In that case, you might be precisely the place it’s essential be, as this text introduces Solana growth by exploring Solana sensible contract examples. Exploring these is vastly useful because it provides us an outline of how Web3 contracts are structured on the Solana community. Nonetheless, earlier than diving into the examples, we’ll return to fundamentals by learning the intricacies of sensible contracts and their structure. With that stated, in case you are already conversant in what Web3 contracts are and need to dissect those outlined on this article immodestly, be happy to leap to the “Solana Good Contract Instance” part!

Solana is a outstanding programmable blockchain, and like many different networks, Solana options Web3 contracts. Nonetheless, in contrast to different Ethereum options, Solana shouldn’t be EVM-compatible (incompatible with Ethereum Digital Machine). As such, it signifies that Solana sensible contract growth differs in comparison with different EVM chains. 

Because of this, this text begins by diving deeper into the intricacies of Web3 contracts, adopted by a bit exploring the distinction between Solana and EVM sensible contracts. After you have a extra profound understanding of Solana sensible contracts, the remaining elements define a couple of examples to provide you an concept of their construction.

Moreover, in case you are enthusiastic about Solana growth, take a look at Moralis’ Solana API. That is considered one of Moralis’ choices of enterprise-grade Web3 APIs, making blockchain growth considerably extra accessible and Moralis a perfect “Web3 for enterprise” different! Furthermore, it doesn’t matter what Web3 initiatives you wish to create, enroll with Moralis to entry a extra seamless developer expertise! 

What are Good Contracts? 

Earlier than diving into the Solana sensible contract examples, we are going to return to fundamentals and discover the intricacies of sensible contracts. If you’re already conversant in the elemental ideas of sensible contracts, be happy to leap straight to the ”Solana Good Contract Examples” part. In any other case, be part of us as we reply the query, ”what are sensible contracts?”. 

Good contracts (Web3 contracts) are packages hosted on a blockchain community executing predefined actions depending on predefined situations. Moreover, Web3 builders use sensible contracts to automate the execution of agreements between two or extra events. As such, Web3 contracts share the identical basic operate as conventional contracts, solely that code mediates these digital packages as a substitute of standard intermediaries.

Good contracts develop the essential notion behind Bitcoin, which is sending and receiving belongings with out intermediaries, by enabling the safe automation of any deal. Consequently, sensible contracts make it potential to automate much more advanced transactions/offers, and since they run on blockchain networks, they provide excessive reliability, safety, and borderless accessibility.  

Moreover, Web3 contracts are the spine of the blockchain business. These enable builders to create revolutionary dapps, tokens, and different Web3 initiatives. Additionally, sensible contracts are utilized in every little thing from revolutionizing monetary instruments to recreation logic. Every time a contract has been deployed on a blockchain community, they’re typically irreversible or immutable, which means that the contract can’t be altered. The immutability – together with the deterministic attribute of sensible contracts – ensures that members could be sure of outcomes. 

Curiously, sensible contracts are typically referred to as ”digital merchandising machines”, as merchandising machines are a great analogy for explaining the performance of a sensible contract. Like a standard merchandising machine, sensible contracts assure a specific output with the right enter. Nonetheless, the transaction is commonly extra advanced than receiving a snack or soda. 

Does Solana Have Good Contracts? 

Does Solana have sensible contracts? The reply to this query is sure! Solana is a programmable decentralized blockchain enabling the creation of scalable, user-friendly dapps, and like all programmable blockchain networks, Solana options sensible contracts. Nonetheless, Solana sensible contracts are totally different from, for instance, EVM Web3 contracts. 

Solana’s sensible contract structure barely differs from the extra standard EVM-based blockchain fashions. For example, Ethereum sensible contracts have the code/logic and the state accrued in solely single contracts deployed on the Ethereum community. In terms of Solana, sensible contracts (or packages) are stateless or “read-only”, containing simply this system logic. 

As quickly as a contract deploys, it turns into potential to work together with them by means of exterior accounts. The accounts are then accountable for storing the info regarding this system interplay. Consequently, this creates a separation between the logic (packages) and the state (accounts). 

The excellence above outlines an important distinction between Solana and different EVM-compatible blockchains in relation to sensible contracts. Since there are variations within the sensible contract structure between EVM chains and Solana, there are additionally variations in how they’re constructed. Builders use the Solidity programming language to jot down EVM-compatible sensible contracts. In the meantime, for Solana contracts, builders write utilizing Rust, C, and C++.

As such, if you wish to get into Solana sensible contract growth, it is perhaps a good suggestion to turn into more adept within the aforementioned programming languages. Nonetheless, there are already many deployed packages/sensible contracts on the Solana community so that you can work together with. Accordingly, you solely have to create new sensible contracts often when constructing on the Solana blockchain! 

Solana Good Contract Examples

With a greater understanding of sensible contracts and what they entail within the context of Solana, the next part dives into some Solana pattern sensible contracts. It will present an outline of what Solana sensible contracts would possibly seem like, making the earlier explanations extra easy. 

Particularly, this part covers three Solana sensible contract examples: 

”hello_world” – The primary pattern sensible contract is ”hello_world”, which is accountable for merely displaying a ”Hi there World!!” message when somebody calls this system. ”tic_tac_toe” – The second Solana pattern sensible contract is known as ”tic_tac_toe”, which is a little more advanced since this contract is accountable for dealing with the sport logic of a tic-tac-toe recreation.”micro_blog” – The ultimate instance we are going to study additional is known as ”micro_blog”, which takes care of the required logic for a microblog. 

Nonetheless, allow us to bounce straight into the primary of our Solana sensible contract examples and look carefully on the ”hello_world” contract!

The ”hello_world” Contract

The primary of our three Solana pattern sensible contracts, ”hello_world”, is comparatively easy. Yow will discover all the code for this sensible contract beneath:

use solana_program::{
account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, msg, pubkey::Pubkey,
};

entrypoint!(hello_world);

pub fn hello_world(
_program_id: &Pubkey, // Public key of the account this system was loaded into
accounts: &[AccountInfo], // All accounts required to course of the instruction
_instruction_data: &[u8], // Serialized instruction-specific information
) -> ProgramResult {
msg!(“Hi there {:}!!”, accounts[0].key);
Okay(())
}

Every time somebody calls this sensible contract, it triggers a Solana transaction that the customers have to signal. After they signal the message, it autonomously returns the contract’s information log, which, on this case, is a ”Hi there World!!” message.

The ”tic_tac_toe” Contract

Subsequent, allow us to take a more in-depth have a look at ”tic-tac-toe”, the second pattern sensible contract. This contract is extra advanced than the earlier one because it dealt with the logic for a multiplayer tic-tac-toe recreation. Nonetheless, that is the whole lot of the Solana sensible contract’s code:

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

pub fn win_check(strikes: [u32; 9]) -> u32 {
// Participant 1 transfer will likely be marked as 1 and participant 2 as 2
let [m1, m2, m3, m4, m5, m6, m7, m8, m9] = strikes;
if (m1 == 1 && m2 == 1 && m3 == 1)
|| (m1 == 1 && m4 == 1 && m7 == 1)
|| (m7 == 1 && m8 == 1 && m9 == 1)
|| (m3 == 1 && m6 == 1 && m9 == 1)
|| (m1 == 1 && m5 == 1 && m9 == 1)
|| (m3 == 1 && m5 == 1 && m7 == 1)
|| (m2 == 1 && m5 == 1 && m8 == 1)
|| (m4 == 1 && m5 == 1 && m6 == 1)
{
// Situation for Participant 1 Win
return 1;
} else if (m1 == 2 && m2 == 2 && m3 == 2)
|| (m1 == 2 && m4 == 2 && m7 == 2)
|| (m7 == 2 && m8 == 2 && m9 == 2)
|| (m3 == 2 && m6 == 2 && m9 == 2)
|| (m1 == 2 && m5 == 2 && m9 == 2)
|| (m3 == 2 && m5 == 2 && m7 == 2)
|| (m2 == 2 && m5 == 2 && m8 == 2)
|| (m4 == 2 && m5 == 2 && m6 == 2)
{
// Situation for Participant 2 Win
return 2;
} else if (m1 == 1 || m1 == 2)
&& (m2 == 1 || m2 == 2)
&& (m3 == 1 || m3 == 2)
&& (m4 == 1 || m4 == 2)
&& (m5 == 1 || m5 == 2)
&& (m6 == 1 || m6 == 2)
&& (m7 == 1 || m7 == 2)
&& (m8 == 1 || m8 == 2)
&& (m9 == 1 || m9 == 2)
{
// Situation for Draw
return 3;
} else {
return 0;
}
}

#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct GameAccount {
pub player1: String,
pub player2: String,
pub strikes: [u32; 9],
pub game_status: u32,
pub next_move: u32,
}

entrypoint!(tic_tac_toe);

pub fn tic_tac_toe(
_program_id: &Pubkey,
accounts: &[AccountInfo],
instruction_data: &[u8],
) -> ProgramResult {
let game_account = &accounts[0];
let player1 = accounts[1].key.to_string();
let player2 = accounts[2].key.to_string();

let instruction: u32 = instruction_data[0].into();
let played_by: u32 = instruction_data[1].into();
let move_positon: usize = instruction_data[2].into();

match instruction {
// Create New Sport or Reset the Sport Information
0 => {
msg!(“Instruction 0 Begin”);
let game_data = GameAccount {
player1,
player2,
strikes: [0, 0, 0, 0, 0, 0, 0, 0, 0],
game_status: 0,
next_move: 1,
};
msg!(“Sport Creation Profitable!!”);
msg!(“Participant 1: {:?}”, game_data.player1);
msg!(“Participant 2: {:?}”, game_data.player2);
game_data.serialize(&mut &mut game_account.information.borrow_mut()[..])?;
msg!(“Instruction 0 Finish”);
}
// Play recreation!!
1 => {
msg!(“Instruction 1 Begin”);
let mut game_data = GameAccount::try_from_slice(&game_account.information.borrow())?;
if game_data.game_status == 0 {
msg!(“Participant 1: {:?}”, game_data.player1);
msg!(“Participant 2: {:?}”, game_data.player2);

// Confirm and updating strikes in Sport Account
if (game_data.strikes[move_positon] == 0) && (game_data.next_move == played_by) {
if game_data.next_move == 1 {
game_data.strikes[move_positon] = 1;
game_data.next_move = 2
} else if game_data.next_move == 2 {
game_data.strikes[move_positon] = 2;
game_data.next_move = 1
}
} else {
msg!(” Incorrect Transfer”);
}

let game_status = win_check(game_data.strikes);

match game_status {
0 => {
// Log the following participant to maneuver
msg!(“Subsequent transfer: Participant {}”, game_data.next_move);
}
1 => {
game_data.game_status = 1;
msg!(“Participant 1 received the sport.”);
}
2 => {
game_data.game_status = 2;
msg!(“Participant 2 received the sport.”);
}
3 => {
game_data.game_status = 3;
msg!(“It is a Draw.”);
}
_ => {
msg!(“Sport Error!!”);
}
}
// Write the up to date information to account.
game_data.serialize(&mut &mut game_account.information.borrow_mut()[..])?;
msg!(“Instruction 1 Finish”);
} else {
msg!(” Incorrect Transfer.”);
}
}
// Invalid Instruction
_ => {
msg!(“Invalid Instruction”);
}
}

Okay(())
}

The code above is accountable for the entire tic-tac-toe’s recreation logic, which handles a number of facets of the sport. Initially, the contract checks if the 2 gamers have already got a recreation presently on the best way. If not, the sensible contract creates a brand new recreation from scratch. Moreover, the contract checks if the correct participant is making a transfer and updates the state of the sport accordingly. 

After every transfer, the contract calls the ”win_check()” operate to test if both of the gamers has received the sport. Lastly, the sport state returns to the customers, enabling them to see updates to the gameboard in actual time!

The ”micro_blog” Contract 

The ultimate of our three preliminary Solana pattern sensible contracts is ”micro_blog”. Similar to the primary instance, this can be a comparatively easy contract. Under, you can find the whole lot of the code: 

use borsh::{BorshDeserialize, BorshSerialize};
use std::str;

use solana_program::{
account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, msg,
program_error::ProgramError, pubkey::Pubkey,
};

// Create a struct to retailer Weblog rely
#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct BlogCount {
pub total_blogs: u32,
}

// Perform to transform buffer array again to string
pub fn buffer_to_string(buffer: &[u8]) -> &str {
let s = match str::from_utf8(buffer) {
Okay(v) => v,
Err(e) => panic!(“Invalid UTF-8 sequence: {}”, e),
};
return s;
}

entrypoint!(micro_blog);

pub fn micro_blog(
program_id: &Pubkey,
accounts: &[AccountInfo],
instruction_data: &[u8],
) -> ProgramResult {
let information = buffer_to_string(&instruction_data);

let account = &accounts[0];

// Verify if the account is owned by this program, else throw an error.
if account.proprietor != program_id {
msg!(
“Account {:?} doesn’t have this system id {} as proprietor”,
account,
program_id
);
return Err(ProgramError::IncorrectProgramId);
}

// Increment and retailer the variety of occasions person created a brand new weblog.
let mut blog_counter = BlogCount::try_from_slice(&account.information.borrow())?;
blog_counter.total_blogs += 1;
blog_counter.serialize(&mut &mut account.information.borrow_mut()[..])?;

// Save the info to the transaction logs
msg!(“Writer: {}”, accounts[1].key);
msg!(“Weblog No: {}”, blog_counter.total_blogs);
msg!(“Weblog: {}”, information);

Okay(())
}

The aim of this contract is to retailer weblog information and observe what number of posts customers publish. Consequently, the contract reads information from a frontend utility, that are person inputs within the type of weblog posts. As soon as a person points a message, the contract will increase the quantity that retains observe of what number of posts have been revealed by that person. 

This covers the primary three Solana pattern sensible contracts. Nonetheless, we are going to discover the fourth instance subsequent, which is a bit particular because it pertains to NFTs. 

Solana NFT Good Contract Examples

There’s an abundance of examples we might define herein. Nonetheless, since we solely have a lot time on our fingers, we’ll have a look at one rigorously chosen instance. Now, earlier than wanting nearer at our selection amongst a number of totally different Solana NFT sensible contract examples, it’s price mentioning Metaplex. Metaplex is a outstanding NFT ecosystem for video games, marketplaces, arts, collectibles, and so on. The protocol combines instruments and sensible contracts, enabling a seamless workflow for creating and launching NFTs. So, if you wish to be taught extra about Solana NFT sensible contract growth, it’s price trying out Metaplex. 

Furthermore, we deliver up Metaplex as a result of the Solana NFT sensible contract we showcase beneath relies on the protocol. Extra particularly, we are going to briefly study the Solana NFT sensible contract for Metaplex’s Sweet Machine. That is what the whole lot of the code seems to be like: 

use anchor_lang::prelude::*;

pub use errors::CandyError;
use directions::*;
pub use state::*;
pub use utils::*;

pub mod constants;
pub mod errors;
mod directions;
mod state;
mod utils;

declare_id!(“CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR”);

#[program]
pub mod candy_machine_core {
use tremendous::*;

/// Add the configuration (title + uri) of every NFT to the account information.
pub fn add_config_lines(
ctx: Context<AddConfigLines>,
index: u32,
config_lines: Vec<ConfigLine>,
) -> Outcome<()> {
directions::add_config_lines(ctx, index, config_lines)
}

/// Initialize the sweet machine account with the desired information.
pub fn initialize(ctx: Context<Initialize>, information: CandyMachineData) -> Outcome<()> {
directions::initialize(ctx, information)
}

/// Mint an NFT. Solely the sweet machine mint authority is allowed to mint.
pub fn mint<‘data>(ctx: Context<‘_, ‘_, ‘_, ‘data, Mint<‘data>>) -> Outcome<()> {
directions::mint(ctx)
}

/// Set a brand new authority of the sweet machine.
pub fn set_authority(ctx: Context<SetAuthority>, new_authority: Pubkey) -> Outcome<()> {
directions::set_authority(ctx, new_authority)
}

/// Set the gathering mint for the sweet machine.
pub fn set_collection(ctx: Context<SetCollection>) -> Outcome<()> {
directions::set_collection(ctx)
}

/// Set a brand new mint authority of the sweet machine.
pub fn set_mint_authority(ctx: Context<SetMintAuthority>) -> Outcome<()> {
directions::set_mint_authority(ctx)
}

/// Replace the sweet machine configuration.
pub fn replace(ctx: Context<Replace>, information: CandyMachineData) -> Outcome<()> {
directions::replace(ctx, information)
}

/// Withdraw the hire lamports and ship them to the authority handle.
pub fn withdraw(ctx: Context<Withdraw>) -> Outcome<()> {
directions::withdraw(ctx)
}
}

The code above allows all of the performance for the NFT sweet machine. Consequently, it takes care of all of the logic for asset administration, index technology/choice, and minting NFTs. Furthermore, the contract makes it potential to mint particular person NFTs or create them in bulk. 

That covers this tutorial’s Solana NFT sensible contract instance. The next part will rapidly present you implement and deploy any of the Solana sensible contract examples!

How one can Deploy the Solana Good Contract Examples

If you end up performed writing a contract, similar to one of many Solana sensible contract examples talked about on this article, you want a approach to construct and deploy them to the Solana community. Consequently, this part outlines the steps on this course of by exhibiting you deploy the ”hello_world” contract, which was considered one of our Solana sensible contract examples from one of many earlier sections.

First up, in case you have not already, arrange Rust, the Solana CLI, and a Solana pockets. Subsequent up, open an IDE of your selection and begin a brand new terminal. From there, arrange a ”Hi there World” Cargo challenge by working the next command within the terminal: 

cargo init hello_world –lib

It will create a Cargo library in your listing with the recordsdata for constructing the Solana sensible contract examples. You’ll be able to then navigate to the ”hello_world” file with the command beneath:

cd hello_world

Subsequent, open the ”Cargo.toml” file, copy the code snippet beneath, and add it on the backside of the file: 

[lib]
title = “hello_world”
crate-type = [“cdylib”, “lib”]

You’ll be able to then navigate again to the terminal and add the Solana program package deal by working this command: 

cargo add solana_program

Lastly, open the ”src/lib.rs” file and exchange all of its contents with the ”hello_world” contract code from the ”Solana Good Contract Examples” part:

use solana_program::{
account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, msg, pubkey::Pubkey,
};

entrypoint!(hello_world);

pub fn hello_world(
_program_id: &Pubkey, // Public key of the account this system was loaded into
accounts: &[AccountInfo], // All accounts required to course of the instruction
_instruction_data: &[u8], // Serialized instruction-specific information
) -> ProgramResult {
msg!(“Hi there {:}!!”, accounts[0].key);
Okay(())
}

With the contract code at your disposal, you need to now be capable of construct the Solana sensible contract by inputting the next Cargo command and working it within the terminal:

cargo build-bpf

From there, all that continues to be is to deploy the contract utilizing the command beneath: 

solana program deploy ./goal/deploy/hello_world.so

Now that’s it! You’ve gotten now efficiently created and deployed the ”hello_world” contract. Now you can use the identical precept for every other Solana sensible contract examples you need to deploy! 

Abstract – Solana Good Contract Examples

If you happen to adopted alongside this far, you will have now seen a top level view of 4 totally different Solana sensible contract examples. This text coated every little thing from a easy ”hello_world” sensible contract displaying a ”Hi there World!!” message to a extra advanced Solana NFT contract accountable for minting tokens. As such, we hope this supplied perception into the construction of Solana sensible contracts. Additionally, we hope it has impressed you to create your very personal Solana sensible contracts! 

If you happen to discovered this information useful, take a look at some extra content material right here at Moralis’ Web3 weblog. The weblog gives contemporary and thrilling Web3 growth content material for brand new and extra skilled builders. For instance, take a look at one of many current guides on Dogechain or add recordsdata to IPFS! 

Furthermore, think about enrolling in Moralis Academy if you wish to hone your Solana sensible contract growth abilities. For instance, take a look at the ”Rust Programming” course to turn into extra outstanding in Solana sensible contract growth! 

Moreover, if you wish to construct subtle Solana dapps, enroll with Moralis instantly. With the varied Web3 APIs of Moralis, you may leverage the total energy of blockchain know-how to construct dapps faster!