Blockchain is an immutable public ledger that securely stores data or information, making it less susceptible to hacking or modification. It is a decentralized/distributed digital transaction ledger devoid of central governance or a third party. It protects data by distributing it across all nodes in its ecosystem. When blockchain came to the limelight in 2008, it started as a decentralized P2P public database of transactions; this earliest form of the blockchain is known as Blockchain 1.0. As developers keep exploring more use cases of the blockchain technology with a robust framework and more utilities, they successfully developed another version of the blockchain, the Blockchain 2.0. Blockchain 2.0 incorporates the earliest version of the blockchain and added more features like transparency, improved security, and smart contract. The advent of smart contracts in blockchain technology is genuine in all these features. What is Smart Contract? A smart contract is a self-executing digital term of agreement embedded in strings of codes to be executed when the specified conditions have been met. It is the trusted tool between two anonymous parties that enables them to transact with each other without concern. It is accurate, efficient, secure, and transparent. Blockchains that supports smart contract have the edge over those that don't. This is because smart contract broadens the use cases of blockchain technology. For example, smart contracts allow for the development of several crypto tokens on a single blockchain, i.e., a single blockchain can be a host to multiple tokens, including the native cryptocurrency of such blockchain. Another use case of the smart contract in blockchain technology is that it enables the minting of Non-fungible tokens—NFTs. These use cases, and many more are the drives behind blockchains with smart contracts such that non-smart contract-based blockchains are seeking ways to include it in their blockchain network. Such an example is the recent Bitcoin soft-fork, themed "Taproot." One of the blockchain networks that support the smart contract is Solana. What is Solana? Solana is a public blockchain that runs on a BFT—Byzantine Fault Tolerance—themed Tower Consensus. The Tower consensus leverages the Proof-of-History consensus mechanism. As one of the fastest blockchain networks, Solana can process about 710,000 TPS. Solana was created by a former executive of Qualcomm, Anatoly Yakovenko, in 2017. It supports the smart contract and Dapps creation alongside DeFi platforms and NFT marketplaces. The native cryptocurrency of the Solana network is SOL which is used to offset transaction fees on the network and is also traded on the crypto market. All applications or solutions of the Solana network were possible because of the smart contract it supports. How to Write Smart Contract in Solana Using the Anchor Software An Anchor is a software tool for Solana's Sealevel runtime providing handy development tools like: Interface Definition Language–IDL–specification Rust crates and eDSL–embedded Domain Specific Language–for writing Solana programs TypeScript package to generate clients from IDL CLI and workspace management to develop complete applications. Generally, the Anchor incredibly makes creating smart contracts easy on the Solana network.
Before delving into the nitty-gritty of this subject, let's familiarize ourselves with some terms : Rust is a remarkable multi-purpose programming language that will be used to develop this smart contract. Rust : This includes the command-line interface–CLI. Solana Tool Suite Now, let's proceed. To start with, we need to create a new anchor project: anchor init counterapp You should see the following files and folders in the project structure: : This is the directory or location of the Smart contract program : The javascript test code is found here test : The launch script migrations : The frontend will be built here app Now, let’s find file from the program directory lib.rs declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");

#[program]
pub mod counterapp {
    use super::*;
    pub fn initialize(ctx: Context<Initialize>) -> ProgramResult {       
        Ok(())
    }
}
#[derive(Accounts)]
pub struct Initialize {} This is the most straightforward CLI program. It has a function initialize that, when called, successfully executes. The "initialize struct" defines the context of the "initialize" function. After setting up our project, the next is to create our counter application. To achieve that, we must first set up an account to save our data. In case you're wondering what the account's purpose is, accounts are means for Solana Sealevel users to store and retrieve data. Recall that we’ve defined two structs: the struct is our which comprises variables that will store our count. CounterAccount Account #[derive(Accounts)]
pub struct Create<'info> {
    
    #[account(init, payer=user, space = 16+16)]
    pub counter_account: Account<'info, CounterAccount>,
    
    #[account(mut)]
    pub user: Signer<'info>,
    
    pub system_program: Program<'info, System>,
}
#[account]
pub struct CounterAccount {
    pub count: u64,
} The struct is the instruction struct that defines the context for creating an account. Create The defines the instructions and constraints for Anchor’s pre-processing while building context. # [account (…) ] Next is to create our function: pub fn create(ctx: Context<Create>) -> ProgramResult {
    let counter_account = &mut ctx.accounts.counter_account;
    counter_account.count = 0;
    Ok(())
} The the function will be our RPC request handler which takes the context previously created with struct. create Create Now that we’re done, let’s write the test function and launch our smart contract. import * as anchor from '@project-serum/anchor';
import { Program } from '@project-serum/anchor';
import { Counterapp } from '../target/types/counterapp';describe('counterapp', () => {    const provider = anchor.Provider.env()
    anchor.setProvider(provider);    const program = anchor.workspace.Counterapp as Program<Counterapp>;    const counterAccount = anchor.web3.Keypair.generate();    it('Is initialized!', async () => {
        await program.rpc.create({
            accounts: {
                counterAccount: counterAccount.publicKey,
                user: provider.wallet.publicKey,
                systemProgram: anchor.web3.SystemProgram.programId,
            },
            signers: [counterAccount]
        } as any)
    });    it("Increment counter", async () => {
        await program.rpc.increment({
            accounts: {
                counterAccount: counterAccount.publicKey
            }
        } as any)
    })    it("Fetch account", async () => {
        const account: any = await
        program.account.counterAccount.fetch(counterAccount.publicKey)
        console.log(account.count)
    })
}); Now, run the test. anchor test We can now launch the program after the test passes. Ensure that the is running. solana-test-validator anchor deploy

Solana

Alongside

fees

Fetch

Initialized

Qualcomm

Super

Target

How to Identify and Avoid Scams on Uniswap

How to Create A Smart Contract to Mint NFTs on NEAR Protocol

Read My Stories

Too Long; Didn't Read

CTA: Download the FREE AI Productivity Shift report

How to Create Smart Contracts in Solana Using Anchor

How to Create Smart Contracts in Solana Using Anchor

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

A Comprehensive Guide on How to Buy Land on Sandbox

Build a Solana Crowdfunding App using React

How to Mint Solana NFTs Using Anchor and Metaplex

The many ways to make audio with Anchor

Weighing the Anchor

A Comprehensive Guide on How to Buy Land on Sandbox

Build a Solana Crowdfunding App using React

How to Mint Solana NFTs Using Anchor and Metaplex

The many ways to make audio with Anchor

Weighing the Anchor

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps