Solana has emerged as one of the most promising blockchains in the Web3 ecosystem, launching in 2017 with a bold mission: to solve the scalability challenges that have long plagued major blockchain networks. While many platforms struggle with slow transaction speeds and high fees, Solana delivers fast, low-cost transactions—making it an ideal environment for developers building decentralized applications (dApps).
What sets Solana apart isn't just speed—it's the platform’s support for on-chain programs, which are self-executing pieces of code triggered by specific conditions. These programs function similarly to smart contracts on other blockchains but operate with greater efficiency. For example, you could write a Solana program that automatically transfers funds from one user to another only if a particular sports team wins a match—or create a lending protocol that issues interest-bearing loans without relying on traditional financial institutions.
This automation eliminates intermediaries, reducing costs and increasing transparency. While Ethereum pioneered programmable blockchains, Solana offers several compelling advantages:
- Faster transactions: Solana can process thousands of transactions per second.
- Lower fees: Transaction costs are fractions of a cent, compared to Ethereum’s often expensive gas fees.
- Developer-friendly languages: Built using Rust—a powerful, widely-used systems programming language—Solana opens doors for developers beyond blockchain.
- Rapid growth: The ecosystem is expanding quickly, attracting new projects and talent.
In this guide, we’ll walk through building a simple airdrop project using @solana/web3.js, the official JavaScript library for interacting with the Solana blockchain. An airdrop involves creating and distributing tokens—typically for testing purposes. Though our token will have no real monetary value, this exercise is crucial for learning how to deploy and manage assets on Solana without spending real funds.
👉 Discover how to start building on Solana with powerful developer tools
Prerequisites
Before diving into coding, ensure you have a foundational understanding of:
- Blockchain fundamentals
- JavaScript programming
- Node.js and npm (Node Package Manager)
With these skills, you’ll be well-equipped to follow along and begin your journey into Solana development.
What Is a Solana Wallet?
A Solana wallet is a digital tool that enables users to send, receive, and manage SOL (Solana’s native cryptocurrency) and other tokens. At its core, a wallet interacts directly with the Solana blockchain via cryptographic key pairs.
Each wallet consists of two components:
- Public Key: This acts like an email address—you can share it freely so others can send you funds.
- Private Key (Secret Key): This serves as your password. It allows you to sign transactions and access your funds. Never share your private key; doing so risks complete loss of assets.
Just like needing an email account to send or receive messages, you need a wallet to participate in the Solana network.
Introducing @solana/web3.js
To programmatically interact with the Solana blockchain, we use @solana/web3.js—a powerful JavaScript SDK provided by Solana Labs. This library enables developers to create wallets, query balances, send transactions, and deploy programs—all from within a Node.js environment.
Let’s set up our development workspace.
Setting Up the Development Environment
Open your terminal and run the following commands:
mkdir airdrop-project
cd airdrop-project
npm init -yThis initializes a new Node.js project and generates a package.json file to manage dependencies.
Now install the Solana Web3.js package:
npm install --save @solana/web3.jsOnce installed, create a new file called index.js in your project directory. This will be the main script for our airdrop application.
Creating a Wallet Programmatically
In index.js, import the necessary modules:
const {
Connection,
PublicKey,
clusterApiUrl,
Keypair,
LAMPORTS_PER_SOL
} = require('@solana/web3.js');We’ll use the Keypair class to generate a new wallet:
const wallet = Keypair.generate();This creates a cryptographically secure wallet with both public and private keys. To view them:
console.log("Public Key:", wallet.publicKey.toBase58());
console.log("Private Key (raw):", wallet.secretKey);⚠️ Security Note: Never expose your private key in production code or public repositories.
Run the script with node index.js to see your generated keys.
Checking Wallet Balance
To retrieve the wallet’s balance, we need to connect to the Solana network. We’ll use the devnet cluster for testing:
const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');Now, define an asynchronous function to fetch the balance:
const getWalletBalance = async (wallet) => {
try {
const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
const balance = await connection.getBalance(wallet.publicKey);
console.log(`Wallet Balance: ${balance / LAMPORTS_PER_SOL} SOL`);
} catch (error) {
console.error(error.toString());
}
};Notice we divide the balance by LAMPORTS_PER_SOL to convert from lamports (the smallest unit) to readable SOL.
Airdropping Test SOL
Since new wallets start with zero balance, we’ll request test SOL via an airdrop:
const airdropSol = async (wallet) => {
try {
const connection = new Connection(clusterApiUrl('devnet'), 'confirmed');
const signature = await connection.requestAirdrop(
wallet.publicKey,
LAMPORTS_PER_SOL // 1 SOL
);
const latestBlockHash = await connection.getLatestBlockhash();
await connection.confirmTransaction({
blockhash: latestBlockHash.blockhash,
lastValidBlockHeight: latestBlockHash.lastValidBlockHeight,
signature: signature,
});
console.log("Airdrop successful!");
} catch (error) {
console.error(error.toString());
}
};Finally, update the main execution flow:
const main = async () => {
await getWalletBalance(wallet);
await airdropSol(wallet);
await getWalletBalance(wallet);
};
main();Run node index.js again—you should now see a balance before and after the airdrop!
👉 Learn how to build and test dApps securely on Solana
Frequently Asked Questions
Q: What is lamport in Solana?
A: A lamport is the smallest divisible unit of SOL, equivalent to 0.000000001 SOL. It's named after computer scientist Leslie Lamport.
Q: Can I use this wallet on mainnet?
A: Yes, but only after securing your private key and connecting to mainnet-beta. Never test with real funds.
Q: How often can I request an airdrop on devnet?
A: Devnet airdrops are rate-limited. You can typically request up to 1–2 SOL per hour per address.
Q: Is @solana/web3.js the only SDK available?
A: No—there are community-supported SDKs in Python, Rust, and Dart—but web3.js is the official and most widely used.
Q: Do I need to pay for transactions on devnet?
A: No—devnet uses test SOL distributed via airdrops, so all operations are free.
Q: Where can I view my wallet balance online?
A: Use the Solana Explorer and paste your public key into the search bar (set network to devnet).
By completing this tutorial, you've taken your first steps into Solana development. You’ve learned how to generate wallets, check balances, and request test tokens—all essential skills for building decentralized applications.
With your test SOL ready, you’re now prepared to explore more advanced topics like deploying smart contracts, creating custom tokens with SPL Token Standard, and interacting with DeFi protocols.