Forem: Raza

A buzzword-free Solana crash course for founders, devs, and investors

Raza — Wed, 21 Feb 2024 10:40:16 +0000

I'm gonna explain everything you need to know about Solana and I'll try doing it without using buzzwords. There are three parts to this, I recommend skimming parts that you feel comfortable with!

Who is this for?
Someone who's never used a blockchain and doesn’t understand what Solana, Bitcoin, or Ethereum are (even a little bit).

What is Solana?

Solana is a platform for building applications on top of.

Practically, it’s a network of computers that run common software that lets you use them for running code and storing data. Anyone can run these computers and there’s thousands of them worldwide.

People have built and deployed thousands of applications on Solana. Anyone can use them by visiting their websites, like regular apps.

Alongside all of these computers and the applications that run on top of them, Solana is the millions of humans that form communities to push forward their goals, innovate, and have fun.

The network

Solana is an open network, meaning anyone can join or use it without asking for permission or requesting access. This also means anyone can run the code or read the data that’s already on the network. This is permissionlessness.

Many apps publish their code and document how you can interact with them using your code, so you can build apps on top of existing programs on the network. This is composability.

While frowned upon as it’s against the open-source spirit, it is possible to publish code/data on Solana that is private: if you don’t share how to interact with it, no one can.

The applications

Blockchain networks are mainly used for financial applications. The idea (and reality) is that a shared digital space for confirmable transactions is more efficient and fairer than traditional financial spaces.

Imagine a banking system that doesn’t close on the weekends, lets you move your money without restrictions, and guarantees that your money won’t disappear (unless you make it).

Solana allows blockchains to expand beyond financial apps to anything that can benefit from its unique qualities — games, art, social media, physical infrastructure.

The communities

When everyone can participate and has control and ownership of what's being built, communities naturally form.

There’s a bunch of tools and services on Solana to help communities coordinate, govern, and fundraise. You can easily combine resources and vote on decisions, so the only limits are human coordination.

How does Solana work?

I’ll keep it short: a large number of computers with specific hardware requirements talk to each other to validate and transmit messages. The messages are called “transactions”, which are a verifiable message format, that tell the computers what users are doing with their data.

If you broadcast a transaction message stating “I transfer 1 USD to Raza”, the computers running the network check if you have 1 USD to transfer, and if you do, they deduct 1 USD from your balances and add it to mine. All of this adds up to a platform you can build apps on.

As computing infrastructure, Solana is similar to AWS/GCP/Azure/Vercel. You write and deploy code, and users interact with it from a client (website, mobile app).

The main differences are:

Decentralization - Vercel can decide that your app ain’t vibin with their terms of service and kick you off. Solana can’t. The network is run by thousands of individual computers owned by me and you, not a CEO. The network as a collective decides what happens.

Composability - You’ve got a program on AWS that I want to interact with. This isn’t possible unless you explicitly expose it to me. On Solana, everything can interact, so software compounds faster.

Openness - Twitter/Reddit increased their API costs a stupid amount. All of your data on these services is now inaccessible. Data on Solana is public and permanent — if you know how to read it, you’ll never lose it.

Pay per action - Solana is more like public transport than a car you rent. You only pay for what you use. Every time you write, update, or delete data on the network, you pay a small fee based on the computational intensity of your actions.

Why build on Solana?

Web2 platforms (AWS/GCP/Azure/Vercel) are great for duplication and an infinite number of something. Solana is better for things that need scarcity, like currencies.

Here’s a bunch of qualities that are built in to Solana, at the platform level:

Scarcity - it’s impossible to duplicate assets.
Sovereignty - users can self-custody and they get to own their data.
Trustless - no need to trust anyone, everything is guaranteed with math (cryptography).
Security - no one can change your data or update your programs (unless you leave a hole somewhere).
Composability - build on top of existing resources, save time and money.
Performance - Recreating these things faster and cheaper (while staying decentralized) than Solana is virtually impossible.

Does your app/service need Solana?
To answer that, ask yourself how easy it would be to build these on your own versus using the ones available on Solana.

Most use-cases don’t benefit from being on the blockchain. If you don’t need two or more of these qualities, you probably don’t need to build on Solana.

Build on Solana because you want to push forward and do something that's never been done before. Build on Solana because you know you can get rich by creating better products.

Example 1: Payments
If you use Stripe or Paypal, you’ll lose at least 3% in payment processor fees. Solana fees are $0.0006 per transaction (paid by users). This isn’t theoretical — you can set up a Shopify store that accepts virtual USD payments on Solana right now using the Solana Pay Shopify app.

Example 2: Physical infrastructure
If you don’t have an infinite budget, the best way to build an alternative to Google Maps is by letting regular people contribute map data. Users buy hardware, contribute data, and get rewarded. Coordination, payouts, and payment for usage of map data is all done on the Solana network.

The Solana ecosystem

The bigger apps and communities in the ecosystem are financial - exchanges, trading, banking, stablecoins. While there’s a bunch of infrastructure and B2B companies, the ethos of the ecosystem is to build consumer apps and solve real problems, not sell shovels in a gold rush.

The range of apps is limited to the people that want to build them and we’re seeing games, social apps, and more come up.

Here’s a map of the big ecosystem players from Messari:

It’s normal if some of these labels don’t make sense. Each of these uses one or more of the previously mentioned qualities of Solana. I suggest picking one area you’re interested in and digging into it. A Google/Twitter search will get you far enough to be able to navigate yourself.

Getting started on Solana

First, create an identity. This is normally an email address and a password. On Solana, you’ll generate a wallet, which consists of a public key and a private key — these are similar to an email and password, except if you leak your private key, everything you own in that identity is gone.

Wallet apps secure and control your public/private keypair. The most popular one is Phantom wallet.

To do anything on Solana, you need the SOL token, the native currency of the network, for paying transaction fees. $1 USD worth of SOL will let you pay for 1000+ transactions. Instead of buying crypto, I recommend earning it via bounties: earn.superteam.fun.

What now? Buy, trade, invest, shop, create, whatever you want.

Terms, topics, and buzzwords

Can’t run from buzzwords forever. Here I’ve got the most common terms explained in casual language.

Transaction - messages users send to Solana network computers to change account data, like asset transfers, purchases, and complex actions like buy orders.

Instruction - the atomic unit of a transaction. One transaction can do multiple things. Each action in the transaction is an instruction.

On-chain - short for “on the blockchain”. When you do things on the Solana network (vs on a private database), you have to pay, and those things are a lot more secure.

Off-chain - Not on the blockchain. Example: your salary in your bank account. To get it on-chain, transfer from your bank account to an exchange bank account, and receive on-chain money.

Validator - a computer on Solana that validates (checks/verifies/confirms) and adds transactions to the ledger (list of previous transactions). They do this cause they get paid.

Signature - a string of text used to verify that an action came from a specific identity. Just like a checkbook, these are used to make sure that other people can’t change your data/assets. Think of them like a fingerprint scan; only you can unlock your phone.

Stake - anyone can join the network and submit false data (e.g. taking 69 USD from my account 😠). To prevent this, validators must lock up SOL tokens to participate. If you submit false data, the protocol will seize your SOL.

Oracle - services that bring off-chain data (like weather, Gold price) on-chain. These are a middleman, but they’re run trustlessly.

Mint - create new assets on chain. Example: new virtual dollars (USDC) are minted when you transfer money from your bank to the bank of the company that runs USDC.

Program/smart contract - this is code that lives on the Solana network that’s used to do things. Think of it like backend logic.

Account - where data is stored on Solana. This data can be program code or user data. Similar to a database entry or Excel row.

Mainnet/testnet/devnet - there are three Solana networks. Mainnet is for real money and all the apps. Testnet and devnet are for developers with fake money to test things.

Developer overview

You can learn to build Solana apps in as little as a weekend. The majority of Solana development is building clients that interact with programs already deployed on the blockchain (web and mobile). There’s plenty of libraries and SDKs that make your job easier.

If you want to build something truly novel that hasn’t been done before, you’ll write Solana programs (smart contracts) in Rust. I suggest starting with building clients (even just Node.js scripts) to get a feel for Solana and then move to Rust.

Solana offloads data formatting (among other things) to developers so the network can process faster. Data you get from the chain directl is in bytes. SDKs handle deserialization (converting it into text from 1’s and 0’s, aka decoding). You also need to encode data before sending to the chain.

RPC Nodes

To read/write from the blockchain, you’ll send API requests to an RPC node - a computer in the network that doesn't participate in validation/consensus, but only receives and sends data. It takes your transactions and submits them to the rest of the network.

Reading blockchain data

All you need is the account address of where it’s stored and how the data is formatted. Send an API request to an RPC node and you’ll get back a response if your query was valid.

Create a connection, fetch the data, decode it, interpret it.

Writing blockchain data

You write to Solana by interacting with existing on-chain programs or publishing new ones. To publish a new program, write it in Rust and use tools like Solana CLI or Anchor CLI to deploy it on-chain.

To interact with existing deployed programs on Solana, you can either:

use an SDK (like Solana web3.js). These handle data formatting and fill in boilerplate/configs. or
do all of the encoding and structuring yourself if you’re working with a custom program that doesn’t have an SDK.

Start building

Developers

Solana developer portal: Solana.com/developers

Full-stack Solana development course: soldev.app/course

Solana for Javascript developers: https://www.youtube.com/watch?v=9ayz-5-h_vY

A deep dive on Solana transactions: https://www.youtube.com/watch?v=cu5GNWnN7IU

Founders

The Solana Foundation provides equity-free grants to get you started. They also have a venture arm — Solana Ventures, that offers advice, funding, and intros when you’re ready to scale.

Solana Foundation grants: https://solana.org/grants

YC request for startups: Stablecoin Finance

Superteam ideas to build: https://build.superteam.fun/

Superteam grants: https://earn.superteam.fun/grants/

Solana focused accelerator: https://www.colosseum.org/accelerator

The tech of the future is here. Go out and build what you want to see exist.

Solana for Javascript developers

Raza — Thu, 12 Oct 2023 19:09:02 +0000

Javascript. The water of programming languages: shapeless, formless. When you put it on the frontend, it becomes the frontend. When you put it on the backend, it becomes the backend. Take a sip, here's everything you need to know about developing on Solana with Javascript.

I'm going to assume you're a some-stack web developer: front, back, full, that can write Javascript.

🎉 Congratulations, I declare you a Solana developer. 🎉

No other skills necessary. Get to the end of this article and I'll even give you a certificate.

What even is Solana?

To a Javascript dev, Solana is just another backend. It's always on, highly optimized, doesn't go down, and it has virtually infinite reads, all for free. Oh, and you can write data to it at cheapish rates. What more can you ask for?

Proof of History, Tower BFT, Sealevel, yada yada. You don't need to understand how it all works. I don't. All I know is that it's a global computer that synchronizes state at the speed of light.

What stays the same?

A lot more than you think. Everything is still just an app of some sort - web app, mobile app, desktop app, Samsung smart fridge app. You'll build the same UIs with most of the same libraries using your favourite tools - VSCode, Vercel, Dreamweaver, Notepad.txt.

What changes?

The two big changes are authentication and data.

Authentication

Instead of JWTs and session tokens, you'll be interacting with “wallets”: middlemen applications between your code and the user that handle their credentials securely. If your app is a restaurant kitchen and customers are your users, wallet apps are the waiters, confirming orders and delivering food between you two.

Wallet <> app communication is pretty well documented and there’s tons of templates and examples out there. Just npm i the components and jam them into your app:

Here's wallet adapters and components for React, Svelte, and Angular:
React, Official - https://github.com/solana-labs/wallet-adapter
Svelte - https://github.com/svelte-on-solana/wallet-adapter
Angular - https://github.com/danmt/wallet-adapter-angular-sample

You can event take wallet connections one step further and implement "Sign in With Solana" - https://siws.web3auth.io/ - a complete alternate solution to traditional profiles.

The only authentication you do "on the backend" is verifying wallet signatures. Since most wallets are browser extensions, it's possible to "impersonate" another wallet by injecting JS. To ensure users are who they say they are, you ask them to sign a unique message, usually a timestamp or ID, and then check that the signature is valid for their address.

Once again - you don't need to fully understand how wallet signatures work when getting started, follow the docs and you'll be good to go.

The last type of authentication is custodial wallets - you make a wallet for the user and control it. This is frowned upon, not only because it's whack, but also because it defeats the whole purpose of being on the blockchain - giving users full control of their identities.

Data

Everything is stored on the big global computer (i.e. blockchain state). The majority of your data reads will be one of:

What assets does this user have in their wallet/account?
What data is stored in their program accounts?

All of this will be read directly from the blockchain, but don’t worry about how you’ll be doing that. There’s some very smart people out there taking all the raw data on the blockchain and putting it into a pretty API for you to consume. The Solana Foundation offers free JSON-RPC endpoints, so you can just slap the URL into your code and get started.

Reading data

The process of reading data is largely the same as a regular backend. You set up a connection to the backend (RPC endpoint), you define what you want to read and you get the data.

The solana-web3.js library handles all the complexity of formatting these requests, and it has a pretty comprehensive API, here's what a simple balance read looks like:

import { Connection, PublicKey, clusterApiUrl } from "@solana/web3.js";

// Connection to the endpoint
const connection = new Connection(clusterApiUrl("devnet"));
// Defining which address we're gonna read
const address = new PublicKey('CenYq6bDRB7p73EjsPEpiYN7uveyPUTdXkDkgUduboaN');
// Making the read call
const balance = await connection.getBalance(address);

console.log(`The balance of the account at ${address} is ${balance} lamports`); 
console.log(`✅ Finished!`)

This is the simplest version of it. When reading from programs (also known as smart contracts), you have to take a few more steps and you need to know how the data you're reading is structured.

In a nutshell, you also have to:

Define the schema of the data you're reading
Deserialize it (think of this like converting formats)

There's a well-documented library called project-serum/borsh that's commonly used for deserialisation.

Rejoice, for you have been given the gift of literacy. Go forth and read.

Create, Update, Delete - All about blockchain interactions

"Writing" data to the network just means interacting with programs deployed on the network that change the state of accounts. You have two options of doing this:

Use the existing libraries and their built in transaction "templates"
Create a transaction from scratch on your own

#1 is easy for common transaction types and when interacting with system programs. You'll need to do #2 when interacting with custom programs.

Let's take a look at #1. The beauty of the solana-web3.js library is that it lets you create, update, and delete from a single Node.js file.

Create a new currency. Send a million people unique images. Gamble your net worth in a game of Plinko. Just hit node index.js and your financial future is in the hands of a computer.

Let's say you've decided to launch your own coin. To do that, you'll interact with the token program and create a "mint" account, that can mint all the tokens you want.

Here's what that looks like:

import { createMint } from '@solana/spl-token';
import { clusterApiUrl, Connection, Keypair, LAMPORTS_PER_SOL } from '@solana/web3.js';

// Create new keypairs that you need 

// Address paying the fees for this tx
const payer = Keypair.generate();
// Address allowed to mint tokens
const mintAuthority = Keypair.generate();
// Address allowed to freeze tokens
const freezeAuthority = Keypair.generate();

// Connect to the network
const connection = new Connection(
  clusterApiUrl('devnet'),
  'confirmed'
);

// Call the built-in createMint function
const mint = await createMint(
  connection,
  payer, 
  mintAuthority.publicKey, 
  freezeAuthority.publicKey,
  9 // The number of decimals of the token
);

// Log the address of the mint account
console.log(mint.toBase58());

This script sets up a connection, creates the necessary keys, adn then sends a transaction to create a mint account (which is then used to mint tokens).

Again, you'll be doing this via wallets most often, not Node scripts. The user will come to your website, connect their wallet, click a series of buttons, and you'll send their wallet a transaction. The flow will be the same as above, but you'll just use their wallet that's passed in through the DOM instead of creating new keys.

These are the two most used libraries for creating, minting, and transferring tokens and NFTs:
https://github.com/metaplex-foundation/js
https://spl.solana.com/token

Craft, for you have been given the gift of creation.

Here's a super handy collection of examples on how to do common interactions:
https://github.com/solana-developers/web3-examples

Where to from here?

You can now create million dollar apps on Solana using nothing but Javascript. Start by getting your hands dirty with an idea that feels fun or by modifying somethign from a tutorial (plently of them on SolDev).

Here's your certificate!

Now go and build! Here's some ideas - https://build.superteam.fun/ideas