You’ve come to the right place if you’re looking to learn how to create Solana programs and smart contracts.
How to Construct and Implement a Solana Smart Contract? It is necessary to clone the repository before deploying the program or smart contract.
This technical article will cover how to Build and Deploy a Solana Smart Contractas well as examples of writing, deploying, and interacting with smart contracts on the Solana Devnet cluster.
What is Solana?
The Solana blockchain ecosystem is a decentralized one created to get around the scalability and congestion problems that plague other blockchains today. The blockchain’s main goal is to increase scalabilities, including higher transaction per second (TPS) and quick confirmation times.
It’s an open-source project that combines cutting-edge technologies from companies like Intel, Netscape, Google, and Qualcomm to help Solana uphold high performance standards. Read our insight on Solana to get a comprehensive analysis of the man.
How to Build a Smart Contract on Solana?
This section teaches you how to build and use the “hello world” Solana smart contract.’ The HelloWorld program in the Rust programming language prints its results to the console. To make the work easier, a Solana environment on Windows must first be set up before the development can begin.
1. Set Up a Solana Development Environment
It can be difficult for many people to run the smart contract code directly from Windows. In order to write the code in Windows and then compile the Rust smart contract into a.so file, it is advised to install the Ubuntu version of WSL (Windows Subsystem for Linux).
Here are the commands to set up the Solana development environment:
apt upgradeapt updateapt install nodejsapt install npmapt install python3-pipcurl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | shsh -c "$(curl -sSfL https://release.solana.com/v1.5.7/install)"source $HOME/.cargo/envexport PATH="/root/.local/share/solana/install/active_release/bin:$PATH"export RUST_LOG=solana_runtime::system_instruction_processor=trace,solana_runtime::message_processor=debug,solana_bpf_loader=debug,solana_rbpf=debugsolana-test-validator --logNext, run the Hello World application to test it:
git clone https://github.com/solana-labs/example-helloworld.git cd example-HelloWorld/npm installnpm run build:program-rust2. Create Solana Smart Contract in Rust Programming Language
Requisites:
You require the following installation for deploying smart contracts:
- NodJS v14 or greater and NPM
- The latest stable Rust build
- Solana CLI v1.7.11 or later
- Git
About the HelloWorld Program
The smart contract or program HelloWorld prints output to the console. In addition, it keeps track of the precise number of times the HelloWorld program has been called for the specified account and counts those calls in addition to counting them. By dissecting the code into its various parts, let’s comprehend its concept.
The first section establishes the “process_instruction” function as the program’s entry point and specifies some standard parameters for the Solana program. This section uses borsh (Binary Object Representation Serializer for Hashing) to serialize and deserialize parameters that are passed to and from the deployed program in addition to this function.
Use the given command to setup the HelloWorld program:
use borsh::{BorshDeserialize, BorshSerialize};
use solana_program::{
account_info::{next_account_info, AccountInfo},
entrypoint,
entrypoint::ProgramResult,
msg,
program_error::ProgramError,
pubkey::Pubkey,
};
/// Define the type of state stored in accounts
#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct GreetingAccount {
/// number of greetings
pub counter: u32,
}
// Declare and export the program's entrypoint
entrypoint!(process_instruction);The program_id, a public key for the server where the program is being deployed, and accountInfo—the account used to initiate communication—are then passed to the process_instruction function.
pub fn process_instruction(
program_id: &Pubkey, // Public key of the account the hello world program was loaded into
accounts: &[AccountInfo], // The account to say hello to
_instruction_data: &[u8], // Ignored, all helloworld instructions are hellosThe function then retrieves the number that is stored for the current account, increases the value by 1, writes the change back, and displays a message.
// Increment and store the number of times the account has been greeted
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(())3. Deploy the Smart Contract
It is necessary to clone the repository before deploying the program or smart contract.
git clone https://github.com/solana-labs/example-helloworld
cd example-HelloWorldFollowing completion of this, you can change the current environment to Devnet, the test network used by Solana developers to create smart contracts.
solana config set --url https://api.devnet.solana.com You must then produce a fresh keypair after this. The Solana Devnet’s deployed programs or smart contracts can be engaged with using this keypair. However, this technique is only effective as a demonstration because it is deemed insecure for key storage. As a result, for security purposes, you will be promoted to passphrase.
Solana-keygen new --forceYou can use the airdrop program to get the needed SOL tokens once you’ve created an account. You also need a few imports for the deployment of smart contracts for this. Use this command to request SOL tokens into your newly generated account:
Solana airdrop 5You can now begin building the hello world program. To construct it, use the command below.
npm run build:program-rustDeploy the application to Devnet once it has been created. With the previous command’s output, you get the commando to run the program, which looks similar to the following:
Solana program deploy dist/program/HelloWorld.soThus, the Hello World programs and the associated program ID were successfully deployed to Devnet. The Solana Devnet Explorer lets you authenticate the program.
Solana’s Architecture and Programming Model
A high-performance blockchain with block times under a second, Solana can handle thousands of transactions per second. This is accomplished using the Proof of History cryptographic function, a brand-new, cutting-edge cryptographic function, as part of a Byzantine Fault Tolerant (BFT) consensus mechanism.
Proof of History
A high-frequency verifiable delay function, also known as a VDF, is used in Proof of History (PoH) to create a cryptographically verifiable order of events (in this case, transactions) over time. This basically means that PoH functions as a cryptographic clock that allows the network to agree on the timing and sequence of events without having to wait for communication from other nodes. Proof of History’s sequential outputs of a constant hashed blockchain state provide a verifiable order of events over time, similar to how an ancient water clock can record the passage of time by observing rising water levels.
Instead of a traditional blockchain scenario where a single process verifies and bundles up all the transactions to be included in the next block, this enables the ordered events to be processed in parallel, which improves the network’s performance.
Imagine a large 100-piece puzzle as a straightforward analogy. A person or people would typically need a certain amount of time to finish the puzzle in a typical situation. But consider if, prior to assembly, each puzzle piece had been stamped with a number that corresponded to its location on the board, from top left to bottom right.
The puzzle can be solved more quickly by having several people concentrate on a different section because the precise arrangement of the puzzle pieces and their location within the puzzle are known in advance. This is the impact of a verifiable time series of events on the consensus mechanism: it enables the processing to be divided into multiple parallel processes.
Smart Contract Architecture
In contrast to conventional EVM-based blockchains, Solana offers a unique smart contract architecture. In conventional EVM-based chains, state and contract code/logic are combined into a single on-chain contract. A smart contract (or program) using Solana is stateless or read-only and only contains program logic.
Smart contracts can be used by external accounts to interact with them after deployment. Data pertaining to program interaction is stored in the accounts that communicate with the programs. This establishes a logical division between state (accounts) and contract logic (programs). Solana and smart contracts based on EVMs differ significantly in this regard.
Accounts on Solana and Ethereum are not the same thing. Solana accounts, unlike Ethereum accounts, which are references to people’s wallets, can store data (including wallet information).
Additionally, Solana provides a CLI and JSON RPC API that decentralized applications can use to communicate with the Solana blockchain. In order for clients to communicate with the blockchain and Solana software, they can also use one of the currently available SDKs.
What’s the Architecture of Solana Smart Contract?
Compared to conventional EVM-enabled blockchains, Solana’s smart contract model is unique. Code/logic and state are combined into a single contract that is deployed on-chain in a traditional EVM-based contract. A smart contract on Solana, in contrast, is only capable of running program logic and is always in read-only or stateless mode. The smart contract can be accessed by external accounts after it has been deployed, and these accounts can communicate with the program to store information about how the program interacts.
In this way, state (accounts) and contract logic (programs) are logically separated, which is a key distinction between conventional EVM-enabled smart contracts and Solana smart contracts. Additionally, accounts on Solana and other blockchains (like Ethereum) differ significantly from one another. Unlike Ethereum accounts, which only serve as references to users’ wallets, accounts on Solana store data (such as wallet information).
A CLI and JSON RPC API are also included with Solana to improve DApps’ interaction with the platform. Additionally, decentralized applications can communicate with the Solana blockchain and its programs by using the existing SDKs.
Conclusion
The use of decentralized apps is expanding as more industries adopt blockchain and decentralized technologies. Solana is a fast, scalable, and affordable ecosystem that makes it easier to create decentralized applications and smart contracts. It also frequently publishes updates.
Because Solana provides a plethora of cutting-edge resources, including frameworks, SDKs, and developers tools, developers like us are eager to build on it. Additionally, the platform has intrusive tools like Solana CLI (which enables command-line interaction with the protocol) and Solana Explorer (which enables users to search transactions and accounts across different Solana clusters).)
