60 Days of Solana
This Solana course is designed for engineers with a beginner or intermediate background in Ethereum or EVM development to get up to speed quickly with Solana program development.
The difficulty engineers face when learning blockchain programming for the first time is they have to learn a new computation model, learn a new language, and learn a new development framework.
If you have already developed on an Ethereum or Ethereum compatible blockchain, you already have a pretty good idea of the computation model and can focus on the language and the framework instead.
Our goal is to leverage your past experience with Ethereum to learn Solana faster.
It is not necessary for you to start from zero.
Solana has a different model of how to run a blockchain than Ethereum does, but not too different.
Rather than jump into explaining all the differences, this tutorial attempts to compress key information into the following paradigm:
“I know how to do X in Ethereum, how do I do X in Solana?
And under certain circumstances,
“I cannot do X in Solana, why is that?”
We’re taking this approach because it’s far easier to develop a mental model for something new if you are able to map over concepts from a mental model you already have.
If you’re like most programmers, Solidity was probably easy to learn for you. It’s nearly one-to-one with JavaScript. However, designing smart contracts was probably a challenge because it’s quite unlike other applications.
We want you to come away with an understanding of how Solana and Ethereum are similar, as well as the key ways in which they differ.
(Note: We talk about Ethereum often throughout this series, but all the ideas are applicable for other EVM-compatible blockchains, such as Avalanche and Polygon).
All blockchains are decentralized state machines
Solana does have a radically different architecture, but it’s fundamentally doing the same thing Ethereum is doing:
It is a distributed state machine that undergoes transitions based on signed transactions where the cost of execution is paid in the ecosystem’s native token (ETH for Ethereum, and SOL for Solana).
Our goal is to leverage your EVM knowledge as a springboard for your Solana development journey.
If a frontend web developer and a backend API/Database engineer both decided to learn mobile app development, most engineers would say the frontend web developer has a massive head start over the backend engineer, even though web development and mobile development are not the same field even if the dev experiences can be very similar with some toolchains.
Using that line of reasoning, we at RareSkills believe that a competent EVM smart contract engineer should be able to pick up Solana faster than an engineer who hasn’t programmed a blockchain before.
This course is designed to lean into that advantage.
We start with the aspects of Solana that are similar to Ethereum
If you look at our outline, you’ll see that it seems like we cover more intermediate subjects (by Solidity standards) like gas usage before we cover more fundamental things (like how to update storage variables). This is by design.
Start with the EVM's equivalent in SolanaWe want to lead with the topics where we can lean on a one-to-one mapping from a concept in Ethereum. We assume you know storage is an important subject and can wait a little bit before we dive into it.
We want to lead with the topics where we can lean on a one-to-one mapping from a concept in Ethereum. We assume you know storage is an important subject and can wait a little bit before we dive into it.
Ease your transition with bite-sized exercisesIt’s already going to feel awkward using a new framework. Giving you a bunch of bite-sized exercises that rely on a familiar mental model will ease the transition. Using both a new framework and a new mental model at the same time is a turn-off. We want you to experience a lot of small victories early on so you can hit the more unfamiliar aspects with some momentum.
It’s already going to feel awkward using a new framework. Giving you a bunch of bite-sized exercises that rely on a familiar mental model will ease the transition. Using both a new framework and a new mental model at the same time is a turn-off. We want you to experience a lot of small victories early on so you can hit the more unfamiliar aspects with some momentum.
An active learning journeyWe have included exercises throughout the tutorial, labeled with the bold word Exercise. These will be hands-on applications of the knowledge you just gained. You should do them! Active learning always beats passive reading.
We have included exercises throughout the tutorial, labeled with the bold word Exercise. These will be hands-on applications of the knowledge you just gained. You should do them! Active learning always beats passive reading.
We expect you’re familiar with SolidityIf you’ve never done smart contract development, this tutorial isn’t written directly to you. We assume you know Solidity at a beginner-intermediate level. If the Solidity examples feel unfamiliar, practice our free Solidity tutorial for a week, then come back here.
If you’ve never done smart contract development, this tutorial isn’t written directly to you. We assume you know Solidity at a beginner-intermediate level. If the Solidity examples feel unfamiliar, practice our free Solidity tutorial for a week, then come back here.
Day 8-10 are not critical, they only explain some syntax which is likely unfamiliar to most readers. However, you can write Solana programs and follow along while treating the unusual syntax as boilerplate. Feel free to skim over those days.
Accounts are one of the most complicated topics in Solana development because they are considerably more flexible than Ethereum storage variables., so we go over them slowly. Each tutorial will progressively reinforce concepts, so don’t worry if all the new information doesn’t stick right away.
Initializing Accounts in Solana and Anchor
Solana counter tutorial: reading and writing data to accounts
Read account data with Solana web3 js and Anchor
Creating "mappings" and "nested mapping" in Solana
Cost of storage, maximum storage size, and account resizing in Solana
Reading an account balance in Anchor: address(account).balance in Solana
Function modifiers (view, pure, payable) and fallback functions in Solana: why they don't exist
Transferring SOL and building a payment splitter: "msg.value" in Solana
Modifying accounts using different signers
PDA (Program Derived Address) vs Keypair Account in Solana
Understanding Account Ownership in Solana: Transferring SOL out of a PDA
Init_if_needed in Anchor and the Reinitialization Attack
Multicall in Solana: Batching Transactions and Transaction Size Limit
Owner vs Authority in Solana
Deleting and Closing Accounts and Programs in Solana
#[derive(Accounts)] in Anchor: different kinds of accounts
Reading Another Anchor Program's Account Data On Chain
Cross Program Invocation In Anchor
This module describes how tokens, especially SPL tokens and Token-2022 work in detail.
How the SPL Token Works
Transferring SPL Tokens with Anchor and Web3.js
Token Sale with Total Supply Tutorial
Basic Bank Tutorial with SPL Tokens and Anchor
How Metaplex Metadata for Tokens Works
Implementing Token Metadata with Metaplex
Time Travel Testing with LiteSVM
The Solana Token 2022 Specification
Interest Bearing Token Part 1
Interest Bearing Token Part 2
This module explores more advanced design patterns and low-level topics.
This section shows how to develop Solana programs in pure Rust and without a framework.
Native Solana: Program Entry and Execution
Native Solana: Reading Account Data
Native Solana: Borsh Serialization
Native Solana: Cross-Program Invocation with invoke and invoke_signed
Native Solana: Creating Accounts For Storage I
Native Solana: Creating Accounts For Storage II
Native Solana: Function Dispatching
Native Solana: Essential Security Checks
Learn how to write Solana programs in raw assembly
Rust program to SBF compilation
Introduction to sBPF Virtual Machine and Instruction Set
Tracing SBF Instruction Execution and Compute Costs
Solana Program Execution and Input Serialization
Instruction Processor and Runtime Setup
sBPF Memory Layout and Register Conventions
Reading Solana Instruction inputs using sBPF assembly
Solana Syscalls: Logging in sBPF Assembly
Acknowledgement
We would like to thank Faybian Byrd, Devtooligan, and Abhi Gulati, for their careful review and feedback of this work. This work was supported by a grant from the Solana Foundation.