Learn to build on Solana with Figment Learn

Solana 101

Build a crypto wallet for the Solana blockchain by leveraging the @solana/web3.js Javascript library to access accounts, fetch data, and transfer tokens

Build a Solana Wallet

From all the “Ethereum killers”, Solana emerged in 2021 as the hottest one, with the most engaged developer community. Through a unique blend of eight technological innovations (including Proof of History), it alleviates many of the problems that plague other blockchains and has been able to reach record levels of speed and transaction volumes.

Solana

< 1 hour

1 hour

1.5 hours

2 hours +

Beginner

Intermediate

Advanced

JS/TS

Rust

High Throughput

React

NodeJS

Smart contracts

Javascript

IPFS

Arweave

Next.js

NFTs

Payment

Time Commitment

Difficulty

Programming Language

Feature

Technology

Learn how to create and deploy a Crowdfunding dApp on Solana

Build a Crowdfunding platform on Solana

Learn about the technical innovations of Solana with pop culture icons The Simpsons

Explaining Solana with The Simpsons

We no longer host the Pathway pages on this website, the content has moved to the `learn-web3-dapp` repository at <https://github.com/figment-networks/learn-web3-dapp#-get-started>.

The workflow for Pathways is easy to follow:

- Using the `learn-web3-dapp` code repository, you will be running a local development server (`yarn dev`)
- Each Pathway is accessible from the main page displayed when the development server is running
- Once you begin a Pathway, your completion progress is saved in the local storage of your web browser
- Each Pathway has a similar goal: To guide you through using various code libraries to work with different parts of the web3 stack
- Many of the individual steps of a Pathway provide you with coding challenges, so that you can learn by doing
- You will need to complete the code as explained in the instructions before moving on to the next step
- All of the coding challenges have solutions which are blurred until you click on them, to prevent you from being stuck
- Once you have completed a Pathway, you should have a working knowledge of that protocol which will help you tackle larger projects

For less experienced developers or for anybody who wants to dive in without needing to set up a development environment, **[we recommend using Gitpod](https://gitpod.io/#https://github.com/figment-networks/learn-web3-dapp)** to work with the `learn-web3-dapp` project (this requires you to have a GitHub account to sign in). Gitpod can save you a considerable amount of time, as you don't have to install dependencies or set up any software - everything just works! Gitpod provides you with a fully functional Visual Studio Code editor running in your browser, so you can jump right in. This is what it looks like: 

![Gitpod UI](https://raw.githubusercontent.com/figment-networks/learn-tutorials/master/assets/gitpod-firstlook.png?raw=true)

If you are an experienced developer, or if you prefer to use a different code editor, [cloning the repo locally](https://github.com/figment-networks/learn-web3-dapp#-clone-locally) is still possible, however you might encounter various system configuration issues depending on how your local environment is set up. It will be more difficult to develop on a Windows system than on Linux or MacOS, and there are also some known issues with developing Solana programs on Windows. It is strongly recommended to use the [Windows Subsystem for Linux](https://docs.microsoft.com/en-us/windows/wsl/install#manual-installation-steps) (WSL) if you are running Windows 10. 

If you are cloning the repo locally, a minimum of **NodeJS version 14.17 is required**. Some of the Pathways will require use of the [Rust toolchain](https://rustup.rs/). If you are developing on Linux, you will want to make sure you have the [build-essential](https://itsfoss.com/build-essential-ubuntu/) package installed, as the `cc` linker is required for compiling Solana programs.

Deploy a program

Learn how to build a clone of the Solana Explorer to display information about blocks and transactions using React

Make a Solana Explorer clone using React

Create storage for the program

# What is Solana?

Solana is an open-source project implementing a new, high-performance, permissionless blockchain. The Solana Foundation is based in Geneva, Switzerland and maintains the open-source project. Its goal is to provide a platform that enables developers to create DApps without needing to design around performance bottlenecks. Solana features a new timestamp system called Proof-of-History (PoH) that enables automatically ordered transactions. It also uses a Proof of Stake (PoS) consensus algorithm to help secure the network. Additional design goals include sub-second settlement times, low transaction costs, and support for all LLVM compatible smart contract languages.

# **What can you build on Solana?**

Solana offers a highly scalable platform for Web 3 applications which can now unlock mainstream usage. There are already over 150 projects live on Solana, with a majority of DeFi projects, although NFTs, social apps, and games are starting to launch on the network.

# **The Solana network**

* **Transaction Fees** The network Cluster sets transaction fees based on recent processing history. Transaction fees on Solana are estimated at $10 for 1 million transactions.
* **Transaction Speed & Finality** : Solana can manage up to 65,000 transactions per second and block times at 400ms. This makes Solana one of the fastest production blockchain available, and 4,000 times faster than Ethereum.
* **Languages supported** : Solana applications are built on Rust, but also support C and C++.
* **EVM compatibility** : Solana is not EVM compatible but it offers [a bidirectional token bridge](https://solana.com/wormhole) between Solana and Ethereum so projects can move tokenized assets across blockchains.
* **Role of the SOL token** : The token is used to pay for the transaction fees in the network and to reward participant in the Proof of Stake consensus 


# Gentle introduction to Solanas

{% embed url="https://youtu.be/xiJEESddB5A" caption="Say Hello to Solana" %}

{% embed url="https://youtu.be/4dNuMXBjpr0" caption="Solana Core Concepts (Community Video)" %}



What is Solana?

Connect to Solana

# Introduction

In this tutorial we will be creating a marketplace and a [non-fungible token](https://www.blockchain-council.org/blockchain/a-quick-guide-to-fungible-vs-non-fungible-tokens/), otherwise known as an NFT, using the **Solana** blockchain. Since NFTs can be made as single or multiple editions, they can be used to represent real-world objects like music, art, in-game items and videos.

We are going to create our NFT on our own marketplace. Refer to this [existing marketplace](https://jacobmakarsky.github.io/metaplex#/art/create) I created as an example, built with [Metaplex](https://github.com/metaplex-foundation/metaplex).

Once we create the NFT, we will be able to list it for sale on larger marketplaces such as [DigitalEyes](https://digitaleyes.market/) or [Solanart](https://solanart.io/).

Note: Bullet points in this tutorial are calls to action. 

# Prerequisites

* You will need around $2 USD of [SOL](https://coinmarketcap.com/currencies/solana/) accessible, which we will send to a browser wallet. You can get some SOL through an exchange, such as [FTX](https://ftx.com/#a=13426316).
* Something to upload in the NFT, such as an image, video, audio file or an AR/3D file (.glb).
* A [Github account](https://github.com/)
* [Git](https://git-scm.com/) installed

## Create and fund an SOL wallet

We are going to create a wallet on Solana using Phantom wallet. Follow the steps on Phantom's website on [how to create a browser wallet](https://help.phantom.app/hc/en-us/articles/4406388623251-How-to-create-a-new-wallet).

Since minting an NFT on the blockchain causes a change in the data on the blockchain, we will have to pay for the transaction. Solana uses [SOL token](https://coinmarketcap.com/currencies/solana/) to pay for their transactions, so we will need to fund our new phantom wallet with SOL token. 

Follow the steps on Phantom's website here on [how to deposit SOL](https://help.phantom.app/hc/en-us/articles/4406393831187-How-to-deposit-SOL).

# Fork and clone the Metaplex repository

We are going to fork the Metaplex repository to our own Github account so that we can host it easily on Github pages.

* Fork the [Metaplex repository](https://github.com/metaplex-foundation/metaplex)

![metaplexRepo](https://github.com/figment-networks/learn-tutorials/raw/master/assets/metaplexRepo.png)

Now, we need to copy all of the Metaplex files over to our computer.

* Create a folder on your desktop called "myNftMarketplace"

* Copy the location of the folder

* Change directory to your marketplace folder in the command line

```text
cd /Users/yourusername/Desktop/myNftMarketplace 
```

* Clone the repository to your marketplace folder

```text
git clone https://github.com/yourusername/metaplex.git
```

All of the files from the Metaplex repository will now be downloaded into our folder.

# Change the default addresses

When we deploy the website, we want it to save in the Metaplex repository we forked on Github. This will allow us to easily get our own live marketplace online.

* Change the deployment address to your Github username

![deployAddressSol](https://github.com/figment-networks/learn-tutorials/raw/master/assets/deployAddressSol.png)

Notice where my name is. This should be where our Github username goes. Make sure to follow the path taken, on the left of the picture, to get to the `package.json` file.

* Change the store's wallet address

![storeWalletAddress](https://github.com/figment-networks/learn-tutorials/raw/master/assets/storeWalletAddress.png)

This is where we add the public address of our browser wallet, so the store knows who to give administrative access. Make sure to follow the path taken, on the left of the picture, to get to the `.env` file.

# Setup and deploy our store

We are in the final stages of making our store live! Now, we will download all of the necessary packages that will allow us to deploy our marketplace website. 

* Change directory to the `js` folder in the command line

```text
cd metaplex/js
```

We should still have our terminal open from before, when we changed directory into our marketplace folder. Now, we changed directory to the `js` folder. 

* Run the following command to install all of the dependencies:

```text
yarn
```

This command will begin downloading all of the dependencies that are required to work with the code. When we cloned the Metaplex repository, it didn't download the packages for us, it only downloaded the code that says what packages/dependencies are required. 

The command will take a moment to finish downloading everything. When it is complete, it will output `Done` at the end.

* Run the following command to check that all of the dependencies are working:

```text
yarn bootstrap
```

We can now test our new NFT marketplace locally before we upload it to Github Pages.

* Run the following command to check that all the dependencies are in place and working as intended:

```text
yarn start
```

It may take several minutes for everything to compile. Once the terminal says `compiled successfully`, we can visit `http://localhost:3000/#/` to view our brand new marketplace! But, this is only good for browsing around. Wait until we get it live online to connect a wallet and mint something.

* Run the following command to build the project files:

```text
yarn build
```

![yarnBuildSol](https://github.com/figment-networks/learn-tutorials/raw/master/assets/yarnBuildSol.png)

When it is complete, we should see it output `Done`, indicating the build has finished. We will now be able to see the `build` folder that was created inside the `js` folder.

* Change directory to the `web` folder

```text
cd packages/web
```

* Run the following command while inside the `packages/web` folder to deploy:

```text
yarn deploy
```

Once complete, we should again see the output `Done`, indicating the deployment has finished. This command has deployed the marketplace site to our Github repository, which means... our marketplace is live! Now we can go check out the fresh new NFT marketplace operating on Solana, hosted on Github Pages.

Congratulations! The URL for our marketplace will most likely be located at `https://yourusername.github.io/metaplex#/`, unless you changed the URL for your website in the Github repository's settings. For example, my marketplace is located at `https://jacobmakarsky.github.io/metaplex#/`. 

Now, we can move on to creating our own NFT on Solana by using the marketplace UI.

# Mint an NFT on a marketplace

There are many marketplaces on Solana for listing NFT's, but only very recently was a tool created that allows the everyday user to mint their own NFT, called [Metaplex](https://www.metaplex.com/).

Metaplex allows us to create our own NFT marketplace, but does not have one general NFT marketplace for everyone to use. I made a marketplace for us to use in this tutorial [under my github here](https://jacobmakarsky.github.io/metaplex#/art/create). 

* Head over to the "My Items" tab

![myItemsPage](https://github.com/figment-networks/learn-tutorials/raw/master/assets/myItemsPage.png)

* Click "Create" at the top

![createNFTButton](https://github.com/figment-networks/learn-tutorials/raw/master/assets/createNFTButton.png)

Now we should be on the "Category" section. 

* Choose which kind of NFT we are creating. 

I created an AR file that people could interact with on [Vecteezy](https://www.vectary.com/3d-modeling-news/create-ar-content-ARkit-ios12/). If you take this route to make something quick, make sure you export to .obj file type, and then convert the 2 files given after conversion to .glb [here](https://products.aspose.app/3d/conversion/obj-to-glb). Making an AR file gives us the ability to interact with and spin our NFT around. 

* On the "Upload" section, follow the instructions and upload what's required depending on the category of the NFT you chose. ***Make sure your filename does not have spaces in it.*** 

* Press "Continue to Mint".

![uploadNFTImages](https://github.com/figment-networks/learn-tutorials/raw/master/assets/uploadNFTImages.png)

* Go ahead and give the NFT a cool title and a description about what it is. 

Feel free to stick in a link or any info that would help someone understand what the NFT is. Or, leave the description empty and mysterious. 

The maximum supply is the number of prints that would be created of the NFT, with each NFT being a numbered edition. The creator can set the “Maximum Supply” of the master edition just like a regular mint on Solana, with the main difference being that each print is a numbered edition created from it. - [Metaplex Developer Guide](https://docs.metaplex.com/)

The attributes, for example, would be "background: blue", "eyes: closed", "mouth: smoking" etc.

* Press "Continue to Royalties".

![nftInfoPage](https://github.com/figment-networks/learn-tutorials/raw/master/assets/nftInfoPage.png)

Metaplex allows us to modify the royalties and amount to split of the initial sale. 

* Set a royalties percentage, so the creators will recieve part of every future sale that happens of the NFT.

Make sure to add creators if anyone else had taken part in creating the NFT.

![nftRoyaltiesPage](https://github.com/figment-networks/learn-tutorials/raw/master/assets/nftRoyaltiesPage.png)

It's time to launch our NFT!

* Make sure there is enough SOL in your browser wallet and click "Pay with SOL". 

It will take up to a few minutes for the NFT to upload, as the metadata (title, description, attributes etc.) is being saved on [Arweave](https://www.arweave.org/). This is a blockchain tool for storing data eternally. Storing data on the Solana chain itself would be too expensive, so our non-fungible token on Solana contains a link to where the NFT information is stored on Arweave. 

![nftLaunchPage](https://github.com/figment-networks/learn-tutorials/raw/master/assets/nftLaunchPage.png)

Wooo! Your new NFT should be finished minting. Congratulations, you now have an accessible NFT on the Solana network. What can we do with it now?

![nftMintFinished](https://github.com/figment-networks/learn-tutorials/raw/master/assets/nftMintFinished.png)

* Check the "My Items" tab for your NFT

![myItemsPage](https://github.com/figment-networks/learn-tutorials/raw/master/assets/myItemsPage.png)

You should be able to see your NFT on the [My Items](https://jacobmakarsky.github.io/metaplex#/artworks) page. 

If you've been using a Phantom browser wallet, go ahead and check your "Collectibles" tab. Your brand new NFT should appear in your wallet! It may take some time for the images and metadata to be synced around. 

![phantomCollectibles](https://github.com/figment-networks/learn-tutorials/raw/master/assets/phantomCollectibles.png)

# BONUS: List the NFT for sale

Awesome, we now have our own NFT that we can view inside our wallet. We certainly don't have to list our fresh NFT for sale if we don't want to, but for the sake of education, let's go ahead and try listing it. 

* Go to [DigitalEyes](https://digitaleyes.market/)

I wouldn't recommend listing the NFT on the marketplace I made for us (even though I do plan to make it cool in the future), so for now DigitalEyes is the best option. 

* Connect your wallet

![connectWalletToMarket](https://github.com/figment-networks/learn-tutorials/raw/master/assets/connectWalletToMarket.png)

* Go to the "Sell" tab 

![yourNFTs](https://github.com/figment-networks/learn-tutorials/raw/master/assets/yourNFTs.png)

* Click on the NFT you want to sell

* Choose the amount you want to sell it for and list the NFT

![listNFTButton](https://github.com/figment-networks/learn-tutorials/raw/master/assets/listNFTButton.png)

* Approve the transaction to list the NFT

The transaction cost me 0.1 SOL, so make sure you have enough SOL in your wallet to list the NFT. 

![approveNFTTransaction](https://github.com/figment-networks/learn-tutorials/raw/master/assets/approveNFTTransaction.png)

Now we should be able to see our NFT listed on the marketplace! Search for the "Unverifeyed" collection in the search bar, and scroll to your NFT. The marketplaces are still in development, so hopefully it'll be much easier to search for the NFT's soon. 

![listedNFTs](https://github.com/figment-networks/learn-tutorials/raw/master/assets/listedNFTs.png)

Go ahead and click on the NFT that's listed. You'll see the option to unlist it and some labels saying "Unverifeyed". This is just because DigitalEyes has not verified our NFT, so they aren't sure if it's a fake copy of an exisiting collection. For any questions about DigitalEyes, such as getting your NFT verified, [go here](https://digitaleyes.market/faq). 

# Conclusion

Woohoo! If you made it through all the steps, you have successfully created your own NFT marketplace and NFT on the Solana blockchain. If you completed the bonus, you now have an NFT on a popular worldwide marketplace 👍

# Next Steps

In this tutorial, we created our own NFT marketplace and NFT on the Solana blockchain, using Metaplex for minting and DigitalEyes for listing. Feel free to continue experimenting by attempting to mint more NFT's, listing them on our own marketplace, sending the token around to other wallets, creating a collection, etc.

# About the author

This tutorial was created by Jacob Makarsky. He can be found on [Github](https://github.com/jacobmakarsky) or the [Figment Forum](https://community.figment.io/u/jacobmakarsky/summary).

# References

* [James Bachini](https://www.youtube.com/watch?v=_36JcJRAHHI)
* [Solana's Blog](https://solana.blog/solana-metaplex-tutorial-deploy-your-own-store-mint-nfts-and-setup-auctions/)


Learn how to deploy a Metaplex marketplace that allows you to mint and sell your own NFTs on Solana

Create a Solana NFT marketplace and mint NFTs using Metaplex

# Access

Getting access to accounts is obviously a critical feature for any wallet application, and given our choice of architecture, we don't have to worry about encrypting and decrypting passwords to log in and out.

The beauty of public-key cryptography is that the private key is effectively your password. And while securing crypto applications is more sophisticated than simply using your private key as a password, especially for industrial-strength wallets, we can achieve the basic functionality of accessing a wallet by leveraging what we learned in [Step 2](https://learn.figment.io/tutorials/solana-wallet-step-2) for creating wallets.

## Recovery phrase

Recall that we've built a type of wallet called a Hierarchical Deterministic (HD) wallet, which means we can map our 12-word phrase to a seed. Since the keypair that makes the account is derived from this seed, as long as we have the recovery phrase, we can get access to the keypair and therefore the account.

{% sidenote title="Box 6.1: Industrial-Strength Wallet Access" %}
In the context of an industrial-strength wallet, you would use the phrase as a recovery mechanism only. Day-to-day access would be enabled through the use of passwords. However, the analogy of the phrase serving as a type of very secure but somewhat cumbersome password still holds. Wallets like [MetaMask](https://metamask.io/) and [Phantom](https://phantom.app/) handle first-time access using recovery phrases and rely on locally encrypted password hashes for subsequent logins.

If you saved your test account's recovery phrase, we'll use it now. Feel free to click log out at the top right. Once we've finished this step, you'll once again have access to your devnet SOL.

# Implementation 🧩

Navigate to the app's home page at [http://localhost:3000](http://localhost:3000). If you click on the **Get Existing Wallet** button, you'll be routed to the page for importing the recovery phrase. But if you click on **Import** after pasting your phrase, you'll notice a message in the console that reads, "Recovery functionality not implemented yet!".

For this feature to work, we need to implement a function that uses the phrase to generate a seed, and then uses the seed to retrieve the keypair (i.e. access the account). 

Recall that in [Step 2](https://learn.figment.io/tutorials/solana-wallet-step-2) we first generated a mnemonic phrase with the Bip39 library by leveraging the `generateMnemonic` function. Then, in order to generate a keypair, we had to convert the phrase to a seed that could be be consumed by Solana's `Keypair` class to generate the `Keypair` that would grant us access to the account.

## Seed from phrase

In this case, we already have a phrase because the user imported it but the rest of the code mirrors [Step 2](https://learn.figment.io/tutorials/solana-wallet-step-2). We can convert the phrase into a seed and then leverage the `fromSeed` method from `Keypair` to access the account.

```javascript
const seed = Bip39.mnemonicToSeedSync(inputMnemonic).slice(0, 32);
const importedAccount = Keypair.fromSeed(seed);
```

With those two lines of code, we have effectively implemented authentication and allowed users to access their accounts from any device as long as they have their recovery phrase.

##### _Listing 6.2: Code for Recovering an Account_
```javascript
const handleImport = async (values: any) => {
  setLoading(true);
  const inputMnemonic = values.phrase.trim().toLowerCase();
  setMnemonic(inputMnemonic);

  const seed = Bip39.mnemonicToSeedSync(inputMnemonic).slice(0, 32);
  const importedAccount = Keypair.fromSeed(seed);
  setAccount(importedAccount);
};
```

This is a good point to reflect on what we've just completed. Clearly we built a crypto wallet capable of performing basic actions on Solana.

But taking a step back, we built something capable of performing actions that have long been the sole purview of giant financial institutions. Think about it. By understanding a few concepts, leveraging some libraries, and writing a few lines of code, you just built a trustless, decentralized bank. Let that sink in.

# Challenge 🏋️

Navigate to `pages/recover.tsx` in your editor and follow the steps included as comments to finish writing the function. We include a description along with a link to the documentation you need to review in order to implement each line. The relevant code block is also included in [Listing 6.1](#listing-61-instructions-for-writing-recover-function) below.

##### _Listing 6.1: Instructions for writing recover function_
```javascript
// *Step 6*: implement a function that recovers an account based on a mnemonic phrase
const handleImport = async (values: any) => {
  console.log("Recovery functionality not implemented yet!");

  setLoading(true);
  const inputMnemonic = values.phrase.trim().toLowerCase();
  setMnemonic(inputMnemonic);

  // (a) review the import guidance on lines 9 and 11
  // (b) convert the mnemonic to seed bytes
  // Documentation Reference: https://github.com/bitcoinjs/bip39
  const seed = new Uint8Array();

  // (c) use the seed to import the account (i.e. keypair)
  // Documentation Reference:
  //   https://solana-labs.github.io/solana-web3.js/classes/Keypair.html
  //   https://solana-labs.github.io/solana-web3.js/classes/Keypair.html#fromSeed
  const importedAccount = null;
  setAccount(importedAccount);

  // (d) You can now delete the console.log statement since the function is implemented!
};
```


Step 6: Recover an Account 🔐

# Airdrop basics

We've now generated a wallet and connected it to the Solana blockchain. In the previous step, we confirmed that our account's balance is zero but wouldn't it be nice to fund our account so we can see the balance change?

You might be wondering whether we'll now need to transfer real money so we can test the account, but as we discussed in [Step 3](https://learn.figment.io/tutorials/solana-wallet-step-3), a blockchain's devnet typically provides a way to test transactions without risking real economic value.

In this step, we'll be building functionality to allow users to "airdrop" SOL tokens into their devnet account. In the crypto world, an airdrop is a way for the protocol to distribute tokens to account holders for free. 


![Figure 5: We're about reinforce our supply lines with some devnet SOL](https://raw.githubusercontent.com/figment-networks/learn-tutorials/master/solana/solana-wallet/assets/airdrop.jpeg)

{% label %}
Figure 5: We're about reinforce our supply lines with some devnet SOL

In this case, we'll be tapping into the native devnet airdrop functionality built into Solana to fund our account. This is in contrast to mainnet airdrops performed by blockchain protocols and crypto projects, which are usually issued to reward early adopters or contributors.

{% sidenote title="Box 4.1: Growth Hacking with Aidrops" %}
Protocols and companies use airdrops as a marketing technique to hype their launch and catalyze user growth. By issuing tokens to users that joined by a certain date or performed some action on the protocol, they can spread the word and, if the airdrop is successful, make more people aware of the solution they're building. For example, the Stellar Development Foundation performed a $125 million airdrop in late 2018 to get Stellar Lumens in the hands of crypto users and try to boost mainstream adoptions.

On the right side of the wallet dashboard, you'll find a button with the label **Airdrop**. You might notice that this button goes away if you change the network. This is because the functionality we're implementing is only active for devnet. Moreover, you'll notice a tooltip help icon informing users that they'll receive 1 devnet SOL by clicking on **Airdrop**.

Once we've completed this step, our balance will automatically increase when we click **Airdrop**. This will position us well for [Step 5](https://learn.figment.io/tutorials/solana-wallet-step-5) where we'll build functionality to send funds to other Solana accounts.

# Implementation 🧩

In [Step 3](https://learn.figment.io/tutorials/solana-wallet-step-3) we learned how to instantiate a connection to one of Solana's networks, and how to assign our account's public key property to a variable. We can apply that same code here to start writing the `handleAirdrop` function in `utils/index.ts`:

```javascript
const connection = new Connection(clusterApiUrl(network), "confirmed");
const publicKey = account.publicKey;
```

## Airdrop function

Following our previous heuristic of searching the docs for keywords, we can now search for "airdrop" to see if there's a function we can leverage. Lo and behold the `Connection` class has a `requestAirdrop` function that looks promising. It takes in two properties - `to: PublicKey` and `lamports: number` - and returns a `promise` that resolves to a string.

You might be wondering what a "lamport" is. Solana's native token, SOL, is divisible into 1 billion lamports. You can think of lamports as the cents to SOL's dollar.

![Figure 6: This is also a lamport. Leslie Lamport is the lamport's namesake. He's a computer scientist who has made key contributions to distributed systems](https://raw.githubusercontent.com/figment-networks/learn-tutorials/master/solana/solana-wallet/assets/leslie.jpeg)

{% label %}
Figure 6: This is also a lamport. Leslie Lamport is the lamport's namesake. He's a computer scientist who has made key contributions to distributed systems


It's not clear from the documentation, but after a little research you can confirm that the returned string represents a confirmation ID or `signature`. From a function design standpoint, it seems reasonable that to request an airdrop we should pass in the account address (public key) and the amount of funds we're requesting.

```javascript
const confirmation = await connection.requestAirdrop(
  publicKey,
  1000000000
);
```

The above function will work just fine and our users will be able to airdrop 1 SOL every time they click on the button. But you can clean it up a bit by importing and passing in the `LAMPORTS_PER_SOL` constant, which itself equals one billion, from web3.js.

```javascript
const confirmation = await connection.requestAirdrop(
  publicKey,
  LAMPORTS_PER_SOL
);
```

{% sidenote title="Box 4.2: Where Do Devnet Airdrops Come From?" %}
Devnet airdrops come from smart contracts deployed with a high initial token balance and a transfer function that allows anyone to request tokens into their devnet account. These so-called faucets are designed to help developers test dApps before going live on mainnet. In our case, the airdrop function is sending a request to a smart contract that transfers devnet SOL from the original supply to your account by updating the balances of both accounts.

## Confirming airdrop

Finally, before we can refresh our account's balance automatically, we need a way to make sure the blockchain ledger has been updated with our airdropped funds before we call `refreshBalance`. As with any database-type operations, blockchain state changes are asynchronous. In fact, given the decentralized nature of most blockchain protocols, some updates [can take a while](https://twitter.com/CryptoKitties/status/937444644740198400?s=20).

With that in mind, we need to wait for the airdrop to be confirmed before refreshing the balance. Searching the docs once again, we can see that our `Connection` class includes a `confirmTransaction` method that takes in a confirmation `signature` and `commitment`, and returns a `promise` that resolves once the transaction is confirmed by the network.

```javascript
await connection.confirmTransaction(confirmation, "confirmed");
```

Note that we don't need to assign a variable to the confirmation here. Once our wallet knows that the transaction was confirmed by the network, it can call `refreshBalance` and update the balance for the account.

```javascript
return await refreshBalance(network, account);
```

Avid readers might have noticed that the balance in our account looks wrong. It reads one billion SOL when it should read 1 SOL. Now that we know what lamports are, how they relate to SOL, and how to use the `LAMPORTS_PER_SOL` constant, we can go back to our `refreshBalance` function and fix the bug by updating its return value.

```javascript
return balance / LAMPORTS_PER_SOL;
```

![Figure 7: Getting close to the summit](https://raw.githubusercontent.com/figment-networks/learn-tutorials/master/solana/solana-wallet/assets/climbing.jpeg)

{% label %}
Figure 7: Getting close to the summit

We've come a long way and now have a better idea of how blockchain protocols work. We built a wallet by creating a keypair, connected to the network, fetched data from it, and successfully requested test tokens. We've covered all of the basic Web 3 interactions except the most important one - transferring funds. We'll do that next in [Step 5](https://learn.figment.io/tutorials/solana-wallet-step-5), so brace yourself.

##### _Listing 4.2: Code for airdropping funds_
```javascript
const handleAirdrop = async (network: Cluster, account: Keypair | null) => {
  if (!account) return;

  try {
    const connection = new Connection(clusterApiUrl(network), "confirmed");
    const publicKey = account.publicKey;
    const confirmation = await connection.requestAirdrop(
      publicKey,
      LAMPORTS_PER_SOL
    );
    const result = await connection.confirmTransaction(confirmation, "confirmed");
    return await refreshBalance(network, account);
  } catch (error) {
    console.log(error);
    return;
  }
};

const refreshBalance = async (network: Cluster, account: Keypair | null) => {
  if (!account) return;

  try {
    .
    .
    .
    return balance / LAMPORTS_PER_SOL;
  } catch (error) {
    .
    .
    .
  }
};
```

# Challenge 🏋️

If you open the browser's console from the `/wallet` page, and click on the **Airdrop** button, you'll notice a message that reads, "Airdrop functionality not implemented yet!". Navigate to `utils/index.ts` in your editor and follow the steps included as comments to finish writing the `handleAirdrop` function. We include a description along with a link to the documentation you need to review in order to implement each line. The relevant code block is also included in [Listing 4.1](#listing-41-instructions-for-writing-airdrop-function) below.

##### _Listing 4.1: Instructions for writing airdrop function_
```javascript
const handleAirdrop = async (network: Cluster, account: Keypair | null) => {
  // This line ensures the function returns before running if no account has been set
  if (!account) return;

  try {
    // (a) review the import guidance on line 1
    // (b) instantiate a connection using clusterApiUrl with the active network passed in as an argument
    // Documentation References:
    //   https://solana-labs.github.io/solana-web3.js/classes/Connection.html
    //   https://solana-labs.github.io/solana-web3.js/modules.html#clusterApiUrl
    console.log("Airdrop functionality not implemented yet!");
    const connection = "";

    // (c) get the key using one of the accessors on the account passed in as an argument
    // Documentation Reference: https://solana-labs.github.io/solana-web3.js/classes/Keypair.html
    const publicKey = "";

    // (d) request the airdrop using the connection instance
    // Note that you should include the amount to airdrop (consider using the LAMPORTS_PER_SOL constant from the web3.js library)
    // Documentation Reference: https://solana-labs.github.io/solana-web3.js/classes/Connection.html
    const confirmation = "";

    // (d) confirm the transaction using the connection instance and the confirmation string returned from the airdrop
    // Documentation Reference: https://solana-labs.github.io/solana-web3.js/classes/Connection.html
    const result = "";

    // (e) Refactor the refreshBalance function to return balances in SOL instead of Lamports (Hint: LAMPORTS_PER_SOL)

    // This line returns the balance after the airdrop so the UI can be refreshed
    return await refreshBalance(network, account);
    // (f) You can now delete the console.log statement since the function is implemented!
  } catch (error) {
    console.log(error);
    return;
  }
};
```


Step 4: Airdrop Funds 🪂

Discover how to make your own pay-to-play game platform on Solana

Build a pay-to-play gaming platform on Solana

Get the balance

🎓 Pathway complete!

Setup the project

Learn how to build a decentralized mail app on Solana using Rust and React

Create a fullstack mail dApp on Solana

Explaining Solana and its Innovations without technical jargon

Create beautiful front-ends for Solana dApps using the Chakra UI library

Making a front-end for your Solana dApp with Chakra UI

# Blockchain requests

Crypto wallets serve one primary function - storing your private keys. By storing your private keys, they allow you to manage - transfer, receive, organize - your digital assets. Part of that functionality requires the wallet to retrieve certain data that is stored onchain to display on your user dashboard.

A balance represents a certain amount of cryptocurrency or tokens held by an account. If you think of the blockchain as a database that keeps ownership records, and of the public keys as the owner IDs, then you can think of the balances as an integer column in the database that tracks how much of a certain token each owner holds.

We'll be connecting to one of Solana's networks, and fetching the balance for the account we just created. Later in [Step 4](https://learn.figment.io/tutorials/solana-wallet-step-4), we'll be funding the account with test tokens using the airdrop function.

## Networks

The concept of various networks for a single protocol is similar to that of different environments for an app (e.g. development, test, production, etc). Typically blockchain protocols have a main network or mainnet, which refers to the production blockchain with real economic value and official transactions, and at least one experimentation network, which refers to an identical blockchain used to test features before they go live on mainnet.

![Figure 4: It's always important to test on devnet before deploying on mainnet](https://raw.githubusercontent.com/figment-networks/learn-tutorials/master/solana/solana-wallet/assets/consultant.jpeg)

{% label %}
Figure 4: It's always important to test on devnet before deploying on mainnet

Solana has a production network called mainnet and two experimentation networks called testnet and devnet. Solana's devnet is designed for developers and users to play with various features and debug dApps before launching on mainnet with real economic consequences. The testnet is where Solana tests potential protocol updates.

You'll notice the wallet includes a dropdown at the top-right that allows users to select what network they want to connect to. This allows the wallet to manage assets specific to the connected network. Our default network is devnet since we'll be using it to receive test tokens in [Step 4](https://learn.figment.io/tutorials/solana-wallet-step-4) and then transfer them in [Step 5](https://learn.figment.io/tutorials/solana-wallet-step-5), but the functionality we'll build will work for any of the Solana networks.

# Implementation 🧩

In [Step 2](https://learn.figment.io/tutorials/solana-wallet-step-2), we discussed how a wallet is more like a keychain that holds keypairs representing an account address and the key to access it. We built a function that allowed us to generate a unique account and the corresponding phrase that works like a password for accessing the account. Now we need to connect with the Solana blockchain so we can fetch the account's balance, which at this point should be zero because we just created it.

## Connecting

The first step for interacting with any blockchain is to instantiate a connection. Conveniently there's a `Connection` class in web3.js designed to do just that. By reviewing the documentation, we notice the `Connection` constructor requires two arguments: `endpoint: string` and `commitmentOrConfig?: Commitment | ConnectionConfig`.

The description for `endpoint` mentions that it's a "URL to the fullnode JSON RPC endpoint". Since we don't have a URL for the connection, we need to either find one from Solana or look for a function that will return a URL. By searching the web3.js docs for "URL", we see that there's a function called `clusterApiUrl` that returns the "RPC API URL for the specified cluster". Moreover, if we review the `Cluster` type, we see that it refers to the network we want to connect to.

As for `commitmentOrConfig`, it looks like the definition for `Commitment` types describes it as the "level of commitment desired when querying state", which is a meaningless definition to us at this point. However, it looks like `Commitment` can be one of several strings so we should choose one and test the function. In this case, we can choose "confirmed" as a reasonable guess and move forward.

{% sidenote title="Box 3.1: A Note on Technical Sophistication" %}
In his ground-breaking series on software development, Michael Hartl and the [Learn Enough](https://www.learnenough.com/) team introduced the concept of _technical sophistication_ as a key attribute of the technical development process. They define it as "the combination of hard and soft skills that make it seem like you can magically solve any technical problem." Figuring things out and being resourceful is at least half the battle, and sometimes the whole war. When in doubt, refer to the [xkcd flowchart](https://m.xkcd.com/627/).

Putting the above together, we can start implementing the `refreshBalance` function with a connection instance in `utils/index.ts`:

```javascript
const connection = new Connection(clusterApiUrl(network), "confirmed");
console.log(connection)

// console:
> Connection {_commitment: 'confirmed', _confirmTransactionInitialTimeout: undefined, _rpcEndpoint: 'https://api.devnet.solana.com', _rpcWsEndpoint: 'wss://api.devnet.solana.com/', _rpcClient: ClientBrowser, …}
```

## Fetching data

Now that we have a connection, we need to fetch our account's balance. We might speculate that there should be a `getBalance` function that takes an account's public address as a parameter, and returns the account's balance. Searching for the keyword "balance" in the web3.js docs, we can see that, not only is there a `getBalance` method, but it's a `Connection` class method.

Reviewing the `getBalance` method on `Connection`, we can see it expects the account's public key as a parameter.

```javascript
const publicKey = account.publicKey;
const balance = await connection.getBalance(publicKey);
console.log(balance);

// console:
> 0;
```

There are a few ways to structure this part of the function. We've chosen to assign the `publicKey` variable to the account's public key, and then pass that into `getBalance` to query the network for the balance.

From the docs, we know `getBalance` returns a promise so we use `await` and assign its return value to the `balance` variable. By logging `balance`, we can see our account has zero balance as expected.

But that's a bit anticlimactic. We know it's a new account and it should have zero balance. Nothing changed on the frontend because the default value was zero. We need to fund the account to see the balance change, and we'll do just that in [Step 4](https://learn.figment.io/tutorials/solana-wallet-step-4).

##### _Listing 3.2: Code for fetching a balance_
```javascript
const refreshBalance = async (network: Cluster, account: Keypair | null) => {
  if (!account) return;

  try {
    const connection = new Connection(clusterApiUrl(network), "confirmed");
    const publicKey = account.publicKey;
    const balance = await connection.getBalance(publicKey);
    return balance;
  } catch (error) {
    console.log(error);
    return 0;
  }
};
```

# Challenge 🏋️

If you open the browser's console from the `/wallet` page, you'll notice a message that reads, "Balance functionality not implemented yet!". Navigate to `utils/index.ts` in your editor and follow the steps included as comments to finish writing the `refreshBalance` function. We include a description along with a link to the documentation you need to review in order to implement each line. The relevant code block is also included in [Listing 3.1](#listing-31-instructions-for-fetching-an-accounts-balance) below.

##### _Listing 3.1: Instructions for fetching an account's balance_
```javascript
// *Step 3*: implement a function that gets an account's balance
const refreshBalance = async (network: Cluster, account: Keypair | null) => {
  // This line ensures the function returns before running if no account has been set
  if (!account) return 0;

  try {
    // (a) review the import guidance on line 1
    // (b) instantiate a connection using clusterApiUrl with the active network passed in as an argument
    // Documentation References:
    //   https://solana-labs.github.io/solana-web3.js/classes/Connection.html
    //   https://solana-labs.github.io/solana-web3.js/modules.html#clusterApiUrl
    console.log("Balance functionality not implemented yet!");
    const connection = "";

    // (c) get the key using one of the accessors on the account passed in as an argument
    // Documentation Reference: https://solana-labs.github.io/solana-web3.js/classes/Keypair.html
    const publicKey = "";

    // (d) get the account's balance using the connection instance
    // Documentation Reference: https://solana-labs.github.io/solana-web3.js/classes/Connection.html
    const balance = 0;

    return balance;
    // (e) You can now delete the console.log statement since the function is implemented!
  } catch (error) {
    console.log(error);
    return 0;
  }
};
```


Step 3: Fetch a Balance ⚖️ 

Transfer some SOL

Learn how to create a collection of unique NFTs on Solana

Build unique generative NFTs on Solana with Candy Machine v2 and Hashlips Engine

# Introduction

In this tutorial, we will be creating a token on the Solana blockchain with no coding needed. Tokens have many functionalities, such as a [social token](https://www.nasdaq.com/articles/social-tokens%3A-get-ready-for-the-next-massive-crypto-trend-2021-04-29), a [utility token](https://invao.org/token-classes-explained-coin-vs-utility-token-vs-security-token/), or a [coin](https://invao.org/token-classes-explained-coin-vs-utility-token-vs-security-token/). 

Solana has a [Token Program](https://spl.solana.com/token), written in [Rust](https://www.rust-lang.org/), that will allow us to create our own token. We will only need to use a simple command-line interface to create and send our tokens around.

This tutorial will typically show a call to action in the form of a bullet point. Please note that if you need help with or would like to explore the usage of any command referenced in this tutorial, add the --help flag after the command.

* For example:

```
solana --help
```

# Prerequisites

* Basic familiarity with a [command-line interface](https://en.wikipedia.org/wiki/Command-line_interface)
* Basic familiarity with Git & GitHub
* Around $1 USD of [SOL](https://coinmarketcap.com/currencies/solana/) accessible. Get SOL through an exchange, such as [FTX](https://ftx.com/#a=13426316), or by swapping tokens on [Serum](https://projectserum.com/#/).
  * **NOTE:** FTX and Solana are closely linked. FTX's sister company Alameda Research is an investor in Solana, and FTX also operates its own decentralized exchange called Serum on the Solana blockchain.

# Requirements

* [GitHub account](https://github.com/)
* [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) installed
* [Rust](https://rustup.rs/) installed
* [Solana Tool Suite](https://docs.solana.com/cli/install-solana-cli-tools) installed

# Create a SOL wallet

First we are going to create a SOL wallet to handle our transactions, using the command line.

* Create a new wallet, which will return the public key (pubkey):

```
solana-keygen new
```

If you already have a local Solana keypair already but want to generate a new one for this tutorial: **Be sure to back up any existing public keys & seed phrases before performing this step**, or you may lose access to assets on Solana! Check `~/.config/solana/id.json` for any public keys. Use the `--force` flag to generate over an existing keypair:

```
 solana-keygen new --force
```


The output should look like:

```text
Generating a new keypair

For added security, enter a BIP39 passphrase

NOTE! This passphrase improves security of the recovery seed phrase NOT the
keypair file itself, which is stored as insecure plain text

BIP39 Passphrase (empty for none):
```

You can enter a passphrase or leave it empty. The `solana-keygen` command will now output the pubkey and seed phrase:

```text
Wrote new keypair to /.config/solana/id.json
================================================================================
pubkey: 7UX2i7SucgLMQcfZ75s3VXmZZY4YRUyJN9X1RgfMoDUi
================================================================================
Save this seed phrase and your BIP39 passphrase to recover your new keypair:
still auto damp sphere silly remain first utility announce material luxury robe
================================================================================
```

The created JSON wallet file is located at `~/.config/solana/id.json` in your filesystem.

{% hint style="warning" %}
Write the seed phrase down somewhere safe!
{% endhint %}

# Fund the wallet

We will now use that public key $pubkey$ to fund our wallet with SOL. The SOL is needed to pay for transactions and any changes we make to the blockchain, for example, the transaction that creates our token.

We will need to get SOL into this wallet from a wallet such as the [Sollet](https://chrome.google.com/webstore/detail/sollet/fhmfendgdocmcbmfikdcogofphimnkno?hl=en) browser wallet, after acquiring SOL from [FTX](https://ftx.com/#a=13426316) $or swapping tokens on [Serum](https://projectserum.com/#/)$. 

* Send 0.1 SOL to our command-line wallet

![sendToCLIWallet](https://github.com/figment-networks/learn-tutorials/raw/master/assets/sendToCLIWallet.png)

* Check the balance of the wallet with the public key in this input being **your** wallet's public key

```bash
solana balance 7UX2i7SucgLMQcfZ75s3VXmZZY4YRUyJN9X1RgfMoDUi
```

The returned balance should match the exact amount that you sent to the wallet.

# Create the token

* Install the **spl-token** CLI

  ```bash
  cargo install spl-token-cli
  ```

* Create the token, which will return the **tokenAddress**

  ```bash
  spl-token create-token
  ```

The command will output an address for the token and a transaction signature :

```text
Creating token B7kRCw1kiB4KxdSKveA3GW4gUc7N4PFiBZTKGRVNXtj6

Signature: 4ELSGXv7Eh6sFnzcM7XvVLmZUZrWbCsF7DoKYpj14qmMzohh9b79AqTXnUYTaLKUuFQLASBHrPMKhEbrM7h8cjMr
```

> If you do not have any SOL in your wallet to pay for the transaction, you will receive an error:

```
Creating token AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM
Fee payer, 7UX2i7SucgLMQcfZ75s3VXmZZY4YRUyJN9X1RgfMoDUi,
 has insufficient balance: 0.0014716 required, 0 available
```


After running `create-token` above, we have created our own token on Solana. There is much more you can do with this.

* Check the balance of the wallet with the public key input being **your** wallet's public key:

```bash
solana balance 7UX2i7SucgLMQcfZ75s3VXmZZY4YRUyJN9X1RgfMoDUi
```

Your balance will decrease, indicating the transaction fees and deployment cost have been paid.   
Congratulations, your token is officially created 👍

# Create an account to handle the tokens

Now we need to create an [account](https://docs.solana.com/developing/programming-model/accounts) that can work with the tokens.

* Create an account, which will return the **accountAddress**, with the **token address** being your token's address:

For example:

```bash
spl-token create-account AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM
```

The output will once again include an address and a transaction signature:

```bash
Creating account 7UX2i7SucgLMQcfZ75s3VXmZZY4YRUyJN9X1RgfMoDUi
Signature: 42Sa5eK9dMEQyvD9GMHuKxXf55WLZ7tfjabUKDhNoZRAxj9MsnN7omriWMEHXLea3aYpjZ862qocRLVikvkHkyfy
```

* Check the balance of the wallet with the public key in this input being **your** wallet's public key:

```text
solana balance 7UX2i7SucgLMQcfZ75s3VXmZZY4YRUyJN9X1RgfMoDUi
```

# Mint the tokens

It's time to mint some tokens and practice transferring them around. For the **mintAmount**, you can specify any number. Why not try 💰 1,000,000 💰 just for fun? Normally this would be based on factors like how big you expect the tokens market cap to be and if you plan to airdrop any amount to users.

The **recipientAddress** would be the account you created to handle the tokens in the previous step.

* Mint tokens:

```text
spl-token mint tokenAddress mintAmount recipientAddress
```

For example:

```bash
spl-token mint AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM 100 7UX2i7SucgLMQcfZ75s3VXmZZY4YRUyJN9X1RgfMoDUi
```

The output should include a token address, the recipient address and a transaction signature:

```bash
Minting 100 tokens
  Token: AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM
  Recipient: 7UX2i7SucgLMQcfZ75s3VXmZZY4YRUyJN9X1RgfMoDUi
Signature: 41mARH42fPkbYn1mvQ6hYLjmJtjW98NXwd6pHqEYg9p8RnuoUsMxVd16RkStDHEzcS2sfpSEpFscrJQn3HkHzLaa
```

> Remember, if you are lost or would like to to explore what any of these commands do or how to use them, it's always possible to use the `--help` flag with any of the Solana CLI tools to get more information.

```text
spl-token mint --help
```

Go ahead and check your wallet balance after this transaction if you'd like. Once the tokens have finished minting, it's time to think about security: "What's stopping me from minting an infinite amount of these tokens?"

# Limit supply to prevent unlimited minting

It is crucial to prevent infinite minting of our token, once enough have been created.

* Disable minting:

```text
spl-token authorize tokenAddress mint --disable
```

* Check token balance of existing accounts:

```text
spl-token accounts
```

The output should look like:

```bash
Token                                         Balance
------------------------------------------------------------
AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM  1000000
```

Check the wallet balance too if you'd like. It will show the difference after the transaction.

# Transfer token to a browser wallet

_This step is optional_, but now we are going to send all of the token from our command-line-created wallet to our browser wallet. You must have some SOL in your browser wallet so it can automatically add the token.

* Send token to browser wallet

```text
spl-token transfer --fund-recipient tokenAddress transferAmount recipientAddress
```

For example:

```bash
spl-token transfer AQoKYV7tYpTrFZN6P5oUufbQKAUr9mNYGe1TTJC9wajM 1000000 vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg
```

This time, the **recipientAddress** should be _your_ browser wallet address.

The output should look like:

```bash
Transfer 50 tokens
  Sender: 7UX2i7SucgLMQcfZ75s3VXmZZY4YRUyJN9X1RgfMoDUi
  Recipient: vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg
  Recipient associated token account: F59618aQB8r6asXeMcB9jWuY6NEx1VduT9yFo1GTi1ks

Signature: 5a3qbvoJQnTAxGPHCugibZTbSu7xuTgkxvF4EJupRjRXGgZZrnWFmKzfEzcqKF2ogCaF4QKVbAtuFx7xGwrDUcGd
```

After the transaction is confirmed on the Solana cluster, you should see your new token in your browser wallet! However, there's an obvious problem! It has no name...

# Submit a pull request to Solana to register token

Our token is created and live on Solana, but is not yet officially recognized. We need to get all the required information for the token ready for submission.

* Enter your user home directory, where you can clone the token list on your computer. 

* Clone the [Solana token list](https://github.com/solana-labs/token-list):

```text
git clone https://github.com/solana-labs/token-list
```

We now have the `token-list` cloned, so we can add our token's image and information for uploading.

* You will need to create the directory matching the **tokenAddress** inside of `token-list/assets/mainnet/`.
* Copy and paste your token's logo inside the cloned `token-list` , in the `token-list/assets/mainnet/<mint address>/`directory.

Go ahead and name the logo file `logo.png` for raster logos or `logo.svg`if you are using vector graphics. Solana prefers logos be either one of those file types.

* Open the token list file at `token-list/src/tokens/solana.tokenlist.json` to add your token to the list like so:

![](https://github.com/figment-networks/learn-tutorials/raw/master/assets/SOLTokenList.png)

This example token will be a social token, so be sure to not copy that unless your token is also a social token. The required information is:

```json
{
  "chainId": 101,
  "address": " ",
  "symbol": " ",
  "name": " ",
  "decimals": 0,
  "logoURI": "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/<ADDRESS/logo.png",
  "tags": [
    "social-token",
  ],
  "extensions": {
    "website": "https://<YOUR WEBSITE URL>.com"
  }
}
```

The link for the token image must point at the GitHub user content site; just change the token address to your token address, and the logo filename to your logo filename and type.

* Save the `token-list/src/tokens/solana.tokenlist.json` file.
* Fork the [token-list](https://github.com/solana-labs/token-list) repository to your own GitHub account by pressing the **Fork** button in the top right of the repository page.

This will add the `token-list` GitHub repository to your GitHub, which will enable you to upload your changes to the forked repository and then request the original repository to accept your changes.

* While still inside your `token-list` folder in the command line, set the url of your local repository to **your** forked version on GitHub:

```text
git remote set-url origin https://github.com/<YOUR GITHUB USERNAME>/token-list
```

* Add all the files from the `token-list` to your local repository:

```text
git add .
```

* Commit the files:

```text
git commit -m "first commit for <YOUR TOKEN SYMBOL & NAME>"
```

* Push the changes:

```text
git push origin main
```

You should now see the changes in your forked repository on GitHub.

* Go to the token list [pull requests page](https://github.com/solana-labs/token-list/pulls)
* Select the **New pull request** button

![](https://github.com/figment-networks/learn-tutorials/raw/master/assets/screen-shot-2021-08-12-at-12.19.19-pm.png)

* Select the highlighted **compare across forks** option in the subtitle below the **Compare changes** header

![](https://github.com/figment-networks/learn-tutorials/raw/master/assets/solCompareForks.png)

* Select your forked repository from the **head repository** dropdown list

![](https://github.com/figment-networks/learn-tutorials/raw/master/assets/solHeadRepo.png)

You should see 2 changed files; your token changes and the logo image.

* Ensure these details are correct. For example, the directory containing the logo image should exactly match your token address in the token list. 

We are now ready to create the pull request.

* Go ahead and click the green **Create pull request** button.
* Once finished adding a title and filling out the details, press the green **Create pull request** button again.

Congratulations! Your token is now on the way to being official. Only if we could actually trade the token though...

# BONUS: Add a market for your token on Serum

You've made it! Your token is live and has a name. It can now be sent around and used for whatever its utility may be. But, there is no trading pair for the token to be traded on. I did not make a market for my social token as I do not want it to be traded.

Note: It costs roughly **10-15 SOL** to create a market, which right now is around **$350 USD**.

* Head over to [Serum](https://dex.projectserum.com/#/list-new-market) and connect your chosen wallet in the top right.
* Fill out the form

The **Base Token Mint Address** will be your tokenAddress, and the **Quote Token Mint Address** will be what token you want your token paired to. I would use USDT for my example.

Once submitted, you should have a live market that can trade the tokens.

# Conclusion

Woohoo! If you made it through all the steps, you have successfully created your own token on the Solana blockchain. If you completed the bonus, you now have a tradable token 👍

# Next Steps

In this tutorial, we built our own token on the Solana blockchain using Solana's command-line interface or "CLI". Feel free to continue experimenting by attempting to mint more of the token, sending the token around to other wallets, creating a market for it, making a liquidity pool on [Raydium](https://raydium.io/liquidity/), etc. Check back in the future for a tutorial on how to make a [non-fungible token](https://www.blockchain-council.org/blockchain/a-quick-guide-to-fungible-vs-non-fungible-tokens/) on Solana as well.

# About the author

This tutorial was created by Jacob Makarsky. He can be found on [Github](https://github.com/jacobmakarsky).

# References

* [Solana Token Program](https://spl.solana.com/token)
* [Loop Creative Andy](https://www.youtube.com/watch?v=1cn-HnG_yns)


Create a token on the Solana blockchain with no coding needed

Create a token on Solana

# Not the end

Congratulations! You've built a crypto wallet that is capable of managing on-chain digital assets on the Solana protocol.

## Reflection

By writing a function to generate a mnemonic phrase and using it to create a keypair in [Step 2](https://learn.figment.io/tutorials/solana-wallet-step-2), you gave the wallet access to a unique account. You then implemented functionality to connect to one of Solana's networks and fetch balance data from it in [Step 3](https://learn.figment.io/tutorials/solana-wallet-step-3).

Next, you wrote functionality to request test tokens via an airdrop in [Step 4](https://learn.figment.io/tutorials/solana-wallet-step-4). And after that you sent some of those funds to another account by learning how to initiate and confirm fund transfers in [Step 5](https://learn.figment.io/tutorials/solana-wallet-step-5). Finally, you learned how to recover an account in [Step 6](https://learn.figment.io/tutorials/solana-wallet-step-6) by leveraging the same code we used in [Step 2](https://learn.figment.io/tutorials/solana-wallet-step-2).

In the process of building the wallet, you learned some of the fundamentals of developing for Web 3. You learned how the frontend of the stack is practically identical to what you're already used to. You also learned that interacting with blockchain protocols means leveraging API libraries that help you create, read and update data in a familiar way.

Importantly, you learned just enough about public-key cryptography, crypto wallets, and blockchain concepts like airdrops, keypairs, and mnemonics to unlock a whole world of learning paths to explore next.

## This is the way

Web 3 holds a world of promise for the future of the internet. Moreover, there are vasts areas of greenspace for developers to build amazing things and a ton of low hanging fruit problems to solve.

The opportunities are endless and we wish you well on your journey!

![Figure 10: This is just the beginning, godspeed!](https://raw.githubusercontent.com/figment-networks/learn-tutorials/master/solana/solana-wallet/assets/begin.jpeg)

{% label %}
Figure 10: This is just the beginning, godspeed!

# Additional Resources 💻 

- [Figment Learn Pathways](https://learn.figment.io/)
- [Solana Protocol Documentation](https://docs.solana.com/developing/programming-model/overview)
- [Solana Web3.js Documentation](https://solana-labs.github.io/solana-web3.js/)
- [BIP32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki): On HD Wallets
- [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki): On Recovery Phrases
- [Why the Blockchain Matters](https://seths.blog/2021/05/why-the-blockchain-matters/) by Seth Godin
- [The Quest for Digital Cash](https://bitcoinmagazine.com/.amp/culture/bitcoin-adam-back-and-digital-cash) by Bitcoin Magazine
- [The Code Book: The Science of Secrecy from Ancient Egypt to Quantum Cryptography](https://www.worldcat.org/title/code-book-the-science-of-secrecy-from-ancient-egypt-to-quantum-cryptography/oclc/738479322) by Simon Singh
- [Ethereum Documentation](https://ethereum.org/en/developers/docs/intro-to-ethereum/)
- [Mastering Ethereum: Building Smart Contracts and DApps](https://github.com/ethereumbook/ethereumbook) by Andreas M. Antonopoulos, Gavin Wood


Conclusion 🏁

Learn how to create a simple blog dApp on Solana using Rust and React

Create a simple blog dApp on Solana

You're about to learn how to develop a wallet for the [Solana](https://solana.com/) protocol. As you build, we'll dive into some of the fundamentals of Web 3 so you can start cultivating an understanding for blockchain technology and decentralized applications (dApps).

# Prerequisites 📋

There are no formal blockchain or Web 3 prerequisites for this tutorial, but you should have some experience with [TypeScript](https://www.typescriptlang.org/) and [React](https://reactjs.org/). Ideally you have heard about [Solana](https://solana.com/), and know that it's a public blockchain protocol capable of running smart contracts with significant scalability advantages.

Having said that, feel free to give it a shot even if you don't meet the above prerequisites since you'll likely get a lot out of it anyway. Just be extra patient because it may be a bit more difficult to navigate.

We think of ourselves as your guide - for a brief amount of time - on your journey to build a better internet. We hope you walk away with a better understanding of Web 3 technologies and perhaps even a bit more confidence to tackle significant problems.

We've tried to show you the door (or maybe part of it). Your job is to discover your path and walk it courageously.

![Figure 1: You take the red pill — you stay in Wonderland and I show you how deep the rabbit hole goes](https://raw.githubusercontent.com/figment-networks/learn-tutorials/master/solana/solana-wallet/assets/cat.jpeg?raw=true)

{% label %}
Figure 1: You take the red pill — you stay in Wonderland and I show you how deep the rabbit hole goes

# System dependencies 💻

Make sure you have [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git), [Node](https://nodejs.org/en/) and [yarn](https://yarnpkg.com/getting-started/install) installed.

# Setting up 🧱 

You'll be building Solana interactions on top of a [Next.js](https://nextjs.org/) app that we have pre-built for you. This way you can skip the development phase you're familiar with (e.g. writing React components and Next pages) and dive right into the blockchain-specific phase.

First, clone [the repo](https://github.com/figment-networks/wallet-tutorial) in your system and install the app dependencies by running the following three commands in your terminal:

##### _Listing 1.1: Set up commands to run on your terminal_
```text
$ git clone https://github.com/figment-networks/wallet-tutorial.git
$ cd wallet-tutorial
$ yarn
```

Then, run `yarn dev` in your terminal to start the development server on port 3000. The terminal should print output similar to that in [Listing 1.2](#listing-12-terminal-message-on-app-start-up) informing you that the app is available to be viewed at [http://localhost:3000](http://localhost:3000).

##### _Listing 1.2: Terminal message on app start up_
```text
yarn run v1.22.11
$ yarn dev
ready - started server on 0.0.0.0:3000, url: http://localhost:3000
info  - Using webpack 5. Reason: Enabled by default https://nextjs.org/docs/messages/webpack5
event - compiled successfully
```

# Tutorial structure 🏗 

The tutorial is structured as a set of steps that break down the process of developing the wallet functionality for the pre-built Next.js app. Each step discusses key concepts and mental models that create the necessary context for you to better understand what we're building and why. Think of this as the warm up.

After the warm up, we provide a step-by-step implementation of the functionality including a code snippet of the full solution. After building context with the warm up, this serves as a way for us to guide you through the logic of the implementation and helps scaffold your mental model for the topic.

The implementation is followed by a challenge that aims to give you just enough instructions and references to allow you to implement the functionality on your own if you want to take a shot at it. This allows you to exercise [active recall](https://en.wikipedia.org/wiki/Active_recall) and increases your mind's ability to make connections.

# Wallet preview 🔍

By the time you're done with this tutorial, you'll have a functional wallet capable of changing the state of the Solana blockchain by receiving and transferring onchain funds. In [Step 2](https://learn.figment.io/tutorials/solana-wallet-step-2), we'll generate a 12-word phrase that will grant us access to a wallet.

![](https://github.com/figment-networks/learn-tutorials/blob/master/solana/solana-wallet/assets/create.png?raw=true)

Then we'll build a function to fetch the balance of our newly created wallet in [Step 3](https://learn.figment.io/tutorials/solana-wallet-step-3) before leveraging functionality to issue "test tokens" through something called an "airdrop" that we'll explore in [Step 4](https://learn.figment.io/tutorials/solana-wallet-step-4).

![](https://github.com/figment-networks/learn-tutorials/blob/master/solana/solana-wallet/assets/airdrop.png?raw=true)

Having added funds to our wallet, we'll build the ability to transfer funds to another wallet in [Step 5](https://learn.figment.io/tutorials/solana-wallet-step-5) using bank checks as a scaffolding analogy.

![](https://github.com/figment-networks/learn-tutorials/blob/master/solana/solana-wallet/assets/transfer.png?raw=true)

Finally, we'll use the phrase we generated in [Step 2](https://learn.figment.io/tutorials/solana-wallet-step-2) to recover access to it in [Step 6](https://learn.figment.io/tutorials/solana-wallet-step-6).

![](https://github.com/figment-networks/learn-tutorials/blob/master/solana/solana-wallet/assets/import.png?raw=true)

Although building a production-ready, non-custodial wallet like [Phantom](https://phantom.app/) or [MetaMask](https://metamask.io/) is beyond the scope of this tutorial, by the end of it you'll have developed a foundation of judgment that will let you better allocate your learning time as you explore new projects. To assist with that, we'll end the tutorial with a list of [additional resources](https://learn.figment.io/tutorials/solana-wallet-conclusion#additional-resources) that you'll be well prepared to explore.

![Figure 2: A journey of a thousand miles begins with a single step](https://raw.githubusercontent.com/figment-networks/learn-tutorials/master/solana/solana-wallet/assets/journey.jpeg?raw=true)

{% label %}
Figure 2: A journey of a thousand miles begins with a single step


“Any fool can know. The point is to understand.”
― Albert Einstein

Step 1: Getting Up and Running 🏃

Get data from the program

We no longer host the Pathway pages on this website, the content has moved to the `learn-web3-dapp` repository at <https://github.com/figment-networks/learn-web3-dapp#-get-started>.

For less experienced developers or for anyone who wants to dive in without complicated setup, **[we recommend using Gitpod](https://gitpod.io/#https://github.com/figment-networks/learn-web3-dapp)** to work with the `learn-web3-dapp` project (this requires you to have a GitHub account to sign in). Gitpod can save you a considerable amount of time, as you don't have to install dependencies or set up a development environment - everything just works!

If you are an experienced developer, [cloning the repo locally](https://github.com/figment-networks/learn-web3-dapp#-clone-locally) is still possible, however you might encounter various system configuration issues depending on how your local environment is set up. A minimum of NodeJS version 14.17 is recommended, and you'll want to make sure you have the `build-essential` package installed. You'll also want to make sure your Rust toolchain is up to date and that you have the `wasm32-unknown-unknown` target triple set up and installed.


You can now access the Solana 101 Pathway on our GitHub repo.

The Solana Pathway has moved to learn-web3-dapp

# Introduction
What is Solana? As a non-developer, this may be difficult to understand when explained by a code-speaking engineer. By definition, Solana is a decentralized blockchain built to enable scalable, user-friendly apps for the world.¹ Famous for being based on 8 core innovations, Solana offers high throughput and low transaction costs, delivering a web-scale product for DeFi, NFTs, Web3, and more.

![Solana](https://github.com/figment-networks/learn-tutorials/raw/master/assets/solanalogo.jpeg) 

In this tutorial, we will review and discuss each of these innovations in terms suitable for anyone to grasp. If you're not a developer or fluent in the world of code, you’re in the right place to learn what Solana is, and more importantly — what it brings to the table.

# Prerequisites 
* General knowledge and understanding of blockchain and its use-cases

# Solana’s 8 Core Innovations
Boasting the fastest speeds in the industry, Solana can handle over 50,000 transactions per second (tps). The protocol does this while ensuring that costs never exceed $0.01 per transaction for the users and developers. At this performance level, Solana would be over 2500x faster and 559x cheaper than present-day Ethereum!

How is this possible??
## 1. Proof-of-History (PoH)
This is Solana’s secret sauce. If you’re familiar with blockchain in general, you surely have heard of Proof-of-Stake (PoS) and Proof-of-Work (PoW). Solana employs the popular and effective Proof-of-Stake method to secure their blockchain and then adds an upgrade — **Proof-of-History**. This supercharges the blockchain.

To conceptualize PoH, think of blockchains like amusement parks. At these amusement parks, you have to wait in line at one of the many entry gates to provide your ticket and be admitted. Receiving entry to the park is the equivalent of having your transaction processed and included in the next block added to the chain. For the park, it’s a top priority that all entry gates are on the same page in terms of who gets admitted and when. 

To do so, popular amusement parks like Ethereum require that gate workers radio each other to discuss and agree upon which people are going to be a part of the next group let into the park — leaving the patrons standing in line staring at their watches. If it’s a busy day at the park, you can only imagine how arduous and time-consuming that process can be. As a result, lines can be long and ticket prices do soar.

To avoid this, Solana went around to their gate operators and gave them all a special printer. This printer records the time a patrons’ ticket was handed in at the gate, converts it to a secure string of characters, and prints it on the ticket. This is often described as a cryptographic timestamp. Each ticket ran through the printer receives a timestamp that references the ticket stamped directly before it — cementing security and improving order certainty. If you found one of these tickets on the ground, you would in essence have a history of every guest that ever entered the park up until that ticket was printed. This is very powerful for the park’s top priority — tracking who was admitted and when. 

By doing this bit of upfront due diligence, Solana gate operators can let a group into the park first and agree on order after. When it’s time to discuss the order of events there’s no arguing because there’s nothing to argue. The gate operators quickly order the collected tickets by timestamp, high-five, and get back to work.

PoH is the fuel used to power Solana’s arsenal of cutting-edge innovations. In the following sections, you will learn how this is the key to streamlining the flow of patrons into its’ park with high security and at lightning-fast speeds.

## 2. Tower BFT
This is Solana’s consensus algorithm. It can be best categorized as a unique version of Practical Byzantine Fault Tolerance (pBFT). To grasp this, let’s first briefly describe both.

**Practical Byzantine Fault Tolerance (pBFT)** — a leader is chosen amongst the parties attempting to come to a consensus. When a request comes in, the leader broadcasts it to everyone in the group. When it receives identical responses from more than two-thirds (> 2/3) of the group, it reaches a consensus. For blockchain, parties coming to a consensus are nodes in the network, and among them, a new leader is chosen in each consensus round.

**Tower BFT** — pBFT that leverages Proof-of-History (PoH). A leader broadcasts a request to all parties asking them to vote on what they deem the present state of the blockchain is. Except for this time, parties cannot vote for a particular state of the blockchain unless it includes the state they voted for in a previous consensus round. This is possible because PoH will show their record of voting in future consensus votes. This allows for faster throughput, favoring liveliness over certainty when put to scale; each new vote is subsequently reaffirming prior votes, providing exponential consensus and incentive to vote in alignment with the majority to earn the rewards of validating a block. Tower BFT does not require confirmation on consensus before moving to the next vote, they can handle a continuous stream of voting rounds with this system. Each voting round inherently contributes to the consensus of previous rounds.

## Transaction Flow
If you further expand our amusement park analogy, you get a more accurate depiction of what is actually going on at Solana. The flow of admitting guests to the park goes like this:

* Gate operators choose a fellow gate to be the leader
* The leader processes everyones’ tickets (transactions), time-stamping each with their printer — this orders them according to time (PoH)
* In processing everyones’ tickets, the leader generates a copy of what they think the state of the amusement park (blockchain) now looks like and signs it
* The leader sends copies of the ordered tickets and its signed copy of processed transactions to the rest of the gates (broadcast)
* The receiving gates process the series of tickets (transactions) and create their own signed copy of what they think the composition of the park now looks like (confirmations)
* Each published confirmation by the other gates serves as a vote for the consensus algorithm (Tower BFT)
* A new leader is chosen and the process repeats for the next batch of guests waiting to get in

![Transaction Flow](https://github.com/figment-networks/learn-tutorials/raw/master/assets/solana_txn_flow.png)

Source: [Solana Whitepaper](https://solana.com/solana-whitepaper.pdf)

## Optimizing the Blockchain
Solana innovates every task occurring on the blockchain, leaving no stone unturned. Below you will learn how **Gulfstream** eliminates transaction pools, **Sealevel** allows smart contracts to run in parallel, and **Pipelining** optimizes validation.

## 3. Gulfstream
Pending/unconfirmed transactions waiting to be added to the blockchain typically sit in pools. Think about the amusement park analogy, this is the line to get into the park. Gate operators are talking to each other about who is waiting in line and which group to let in next. The bigger the line, the more demand the park is seeing, and not meeting. When Solana is letting people onto the premises of their park, they know which gates are going to be letting the next group of people in next (which node will be the next leader). This enables Solana workers to direct patrons to the appropriate gates in advance, allowing gate operators to process and order transactions ahead of time so when it is their turn to open the gate, they can do it in a near-instant. Therefore, Solana has no lines at its’ park.

## 4. Sealevel
Historically, the state of a blockchain is altered linearly, one by one processing transactions (smart contracts). Sealevel allows Solana to process thousands of smart contracts in parallel. Back to the amusement park we go.

As the pending transactions arrive at their assigned gate, they are sorted into lines by specific transaction type. This allows the park to prepare for what is incoming. Using an innovative processing system, gate operators can then process all of the different sorted lines concurrently. Additionally, Sealevel takes advantage of CPU and GPU hardware design which allows for a single instruction to be applied to multiple data points simultaneously. This means each proverbial sorted line at the entry gate can be processed all at the same time. Think of an entry location with 5 lines, each specific to how they’re gaining entry, each line side by side, each processed in batches. That’s efficiency — that’s Sealevel.

## 5. Pipelining
Pipelining is a commonly used method of sequential processing (typically in CPU design) where system throughput is increased by organizing the execution of multiple instructions simultaneously. On the Solana network, this is how transaction processing is handled for validation optimization. 

Done in four stages, the “Transaction Processing Unit”, or TPU, is comprised of Fetching, Signature Verification, Banking, and Writing. Solana takes advantage of using different hardware to handle different steps in the process like an assembly line would during manufacturing. The idea is to keep the different hardware, and thus the mechanism, busy at all times — optimizing output (validating blocks and distributing block rewards).

The process is such:

1. **Data Fetching Stage** — querying incoming transactions to collect specific data points in preparation of transaction execution, like a patient survey in a doctor’s office.
    
    * Hardware used: *Kernel Space* — the core of a computer operating system, possessing complete system control and facilitates interactions between hardware and software. Think of this like the quarterback of the machine, receiving incoming play calls and distributing the ball accordingly.

![Kernel](https://github.com/figment-networks/learn-tutorials/raw/master/assets/kernel.png)

Source: Wikipedia³

2. **Signature Verification Stage** — ensuring that incoming transaction requests are all unique and legitimate.
    * Hardware used: *Graphics Processing Unit (GPU)* - a specialized electronic circuit designed to rapidly manipulate and alter memory to accelerate the creation of images in a frame buffer intended for output to a display device.³ This definition is fitting because a GPU is typically seen as the hardware used to produce images. However, a GPU’s parallel structure has been massively beneficial in processing large blocks of data in parallel via algorithms — Solana’s bread and butter.

3. **Banking Stage** — the actual finance portion of the transaction where tokens are distributed, PoH is also leveraged in this stage.
    * Hardware used: *Central Processing Unit (CPU)* - main processor executing instructions in a computer program

4. **Writing Stage** — recording the transaction in permanent memory and subsequently broadcasting it to downstream validator nodes.
    * Hardware used: *Kernel Space*

At the end of the assembly line when the TPU is broadcasting blocks to validators, all of the other stages are hard at work fetching new data, verifying signatures, and crediting tokens. This allows Solana to process incoming transactions like a well-oiled machine.

## Maintaining the Blockchain

After creating a new block, the Leader begins propagating the block data to the rest of the nodes for them to update their records, a process optimized by **Turbine**. Like all systems which create a running list of records, creating a database of accounts is paramount. To do so, Solana chooses a unique approach which is labeled their **Cloudbreak** innovation. Lastly, to maintain the record of the blockchain unbiasedly and for redundancy, Solana has nodes dedicated to archiving the blockchain, called **Archivers**. This of course employs a unique solution built for optimizing the process — a common theme.

## 6. Turbine
A node can only handle so many transmissions per second, so to handle more you add more nodes to the blockchain, right? Unfortunately, in doing so you increase the amount of data and locations to populate the data — a throttling effect on the blockchain. Solana solves this with Turbine.

Traditionally, data from the block created via consensus would be sent from the Leader (discussed above) to the rest of the group for them to incorporate into their copy of the blockchain. Picture the process like this: The leader of the group creates a painting (a block). Everyone in the group needs a copy of the painting, so the leader sends each one a copy individually. Each copy is not small, and therefore this takes a lot of time and effort. With Turbine, the leader instead cuts his painting into a bunch of equal-sized pieces and randomly hands them out. Each member in the group then makes a copy and hands their piece to the person next to them, and vice versa, until everyone has a complete painting for themselves.

To increase security, members are placed in groups, called “neighborhoods”. Those with the most invested in the project are placed in the neighborhood closest to the leader and ordered in a weighted hierarchy thereafter. Neighborhoods are responsible for passing some of their pieces of the painting to the below neighborhoods, and so on. In case everyone is not doing their part in sharing the pieces of the painting, the leader distributes extra copies of each piece — adding robustness to the process.

Turbine implements this methodology for block data, enabling faster, safer, and more efficient data propagation to the blockchain.

## 7. Cloudbreak
Memory is usually used to keep track of accounts in a distributed system. This can lead to performance bottlenecking where the size of the network becomes a limitation in storage capacity and access speed. Solana again turns to hardware for optimization.

Solana chooses to distribute its database horizontally across multiple storage devices — in this case, SSDs. Blocks of data are segmented and distributed in sequential order amongst the SSD cards. Think of a block of data coming into the database for storage as a deck of unshuffled playing cards, and the players at the card table as the SSD cards. The incoming deck of cards (packet of data) is comprised of four suits (accounts) to be stored. The cards are distributed one by one to a table of 13 players, each receiving one card from each suit by the time all of the cards have been handed out. Each card in a suit can then be thought of as a segment of data. At the end of this, the storage structure of the deck (data packet) looks like this:

![Data Storage](https://github.com/figment-networks/learn-tutorials/raw/master/assets/data_deck.png)

The account “Clubs” being stored, is horizontally distributed in a logical and sequential order amongst the players. Since each player, or storage device, can be accessed simultaneously, the systems’ total throughput is increased. This is commonly referred to as data striping. Each additional player added to the table adds not only storage space, but also the number of concurrent access sources available. Sequential organization of data is also optimal for CPU usage, adding another performance boost to boot.

Hardware wins for Solana again. Taken as a whole, Cloudbreak allows for the blockchain to increase concurrent operations, scale with Moore’s law, and leverage hardware-operation synergy. The result? Exceptional performance.

## 8. Archivers
Archivers refers to Solana’s distributed ledger which stores massive amounts of data, maintaining records of the entire state of the blockchain. Archival nodes do not participate in consensus. Rather, they are the keepers of history (hence the name).

At full capacity, the network is projected to generate 1 GB/s of data, which equates to 4 petabytes of data a year. To put that in perspective, 1 PB of data is equal to 1,000,000 GB of data. For example, one would need 368 football fields worth of 1GB flash drives to store a year’s worth of Solana history! It’s an unfathomable amount. Now say every node on the network had to store all of that data? It would either one, not be possible, or two, result in only a small concentration of corporate entities being able to support the network — eliminating decentralization.

Neither is acceptable for the team at Solana. Their solution? Sticking to their fundamental optimization techniques. Similar to the approach for Turbine and Cloudbreak where data is parceled out, Solana divides ledger history into small pieces which are distributed to archival nodes. The number of pieces it divides outgoing history into is determined by a target replication rate (how many copies of the ledger they want) and desired fault tolerance. These metrics are dependent on the number of archivers and the amount of space they signal as available for storage. 

Seems a little risky though doesn’t it? Taking the whole history and distributing it in pieces amongst various parties. Solana quells this fear very smartly, ensuring security in its’ quest to efficiently archive the blockchain.

Insert **Proof-of-Replication**. For Solana, it’s Proof-of-replication supercharged by — you guessed it — Proof-of-History. PoH is there to do what it does best — *make this process move fast.* Proof-of-Replication put simply, is the system by which an archival node verifies that it has not only allocated the space to store the blockchain data but that it’s also storing the exact data it promised to keep. The system does this by encrypting the data when storing it. Then at a later time, the Solana network can request the archival node to prove it’s doing what it said it would do — store the blockchain history. The encryption allows the archival node to replicate the data at a fast speed and provide it back to the network, proving the archival node is keeping its promise. If it takes too long, the Solana network will know that the archival node is being dishonest, scrambling to replicate the data and cover its tracks.

Yet again the blockchain moves from a problem threatening decentralization, scalability, and security, to a solution reinforcing their exceptionalism in achieving all three.

*Refer to Section 1. Proof-of-History (PoH) to learn more about the verification speed and certainty advantages PoH provides.*

# Conclusion
When you combine all 8 of these innovations, you get a web-scale blockchain. One that is high performance, secure, and apt to open up a world of innovation. PoH can reduce messaging overhead for the Solana machine, enabling sub-second finality times. Solana’s commitment to optimization and forethought to scale with hardware is worth noting as well.

At the end of the day, for the non-developer, blockchains are all an attempt to create a fault-tolerant replicated state machine. Every blockchain in competition comes at this problem with a different approach. Anchored by Proof-of-History, and guided by a team committed to delivering the best Web3 ecosystem possible, Solana is poised to make waves in the industry for years to come.

# About the Author
This tutorial was written by Brandon Goss, an aspiring crypto and blockchain research analyst. You can reach out to Brandon on [Figment Forum](https://community.figment.io/u/brandonmichaelgoss/summary) if you have any questions pertaining to this guide or Solana. 

# References
[1] [Solana](https://solana.com/#)

[2] [Dune Analytics, Gas Prices ⛽️ by @alex_kroger](https://dune.xyz/kroeger0x/gas-prices)

[3] [Wikipedia, Kernel (Operating System)](https://en.wikipedia.org/wiki/Graphics_processing_unit)


Learn about Solana with easy language aimed at beginners

Solana's Innovations - a jargon-free explanation

Learn how to make your own token streaming protocol on Solana

Build a token streaming protocol

# Crypto gateway

Crypto wallets are the most critical piece of user-facing infrastructure in the blockchain space. In the same way that the browser brought the web to a mass audience by providing an easy-to-use gateway into the underlying servers and databases, wallets provide users with an easy-to-use gateway into blockchain protocols.

A wallet is less like the wallet you use for your credit cards, and a lot more like a keychain. If you think of a blockchain as a giant bank safe with digital safety deposit boxes, wallets are the keychains where you keep the key to your box. Once you have access to a box, you can manage the contents of it by receiving, sending, holding and spending digital assets.

![Figure 3: Wallets hold private keys to your public address on a blockchain](https://raw.githubusercontent.com/figment-networks/learn-tutorials/master/solana/solana-wallet/assets/safe.jpeg?raw=true)

{% label %}
Figure 3: Wallets hold private keys to your public address on a blockchain

We can think of the box itself as a chunk of memory on the blockchain. The digital box location is referred to as a public key, or more intuitively as a public address, and can be shared with anyone in the same way you might share your address to receive mail at home. As the name implies, this is widely available to others on the network and it is the identifier others use to send digital assets to a box.

The key that can unlock the safety deposit box is referred to as the private key. Anyone with access to a box's private key has access to the box, which is why it's paramount to keep the key private - hence the name, private key.

# HD wallets

In this tutorial, we'll be building a type of wallet called a Hierarchical Deterministic (HD) wallet. We don't need to dive into the full definition of HD wallets here, but it's important to know that they enable the ability to store the private key as a 12-, 18-, or 24-word phrase referred to as a secret recovery phrase or mnemonic phrase. You'll be using a JavaScript library called [Bip39](https://github.com/bitcoinjs/bip39) to facilitate the generation of this phrase, which in turn can be converted into a private key to create a wallet.

{% sidenote title="Box 2.1: Why is the secret recovery phrase also called a mnemonic?" %}
The concept of a mnemonic phrase was introduced by Bitcoin Improvement Proposal 39 (BIP39). The term "mnemonic" refers to a pattern that makes something easier to remember. For instance, some of you might be familiar with the order of operations mnemonic in math: PEMDAS, or "please excuse my dear aunt Sally". The motivation for BIP39 was that "a mnemonic code or sentence is superior for human interaction compared to the handling of raw binary or hexadecimal representations of a wallet seed."

Run and open the app in your browser at [http://localhost:3000](http://localhost:3000). You'll notice the frontend offers the user the option to create a new wallet or import an existing wallet.

Clicking on **Create New Wallet** routes the user to a `/generate` page signaling to our user that by clicking **Generate**, the app will generate a key phrase and thus create a new wallet. But when we click **Generate**, we're routed to a `/phrase` page with an empty phrase container.

# Implementation 🧩

For the app to work, we need to implement a function that generates a phrase and uses it to create a wallet when the `/phrase` page renders. In your editor, navigate to `pages/phrase.tsx`.

In order to generate the phrase, we need to leverage an external library that satisfies the [BIP39 specification](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki), which set the standard for generating phrases for deterministic keys. 

Fortunately, there's the [Bip39 library](https://github.com/bitcoinjs/bip39). It provides us with the functionality we need to generate the phrase and later convert it into the seed we need to generate our Solana wallet keys.

We already installed the library when we ran `yarn` during set up because we included it into the pre-built app's [package.json](https://github.com/figment-networks/wallet-tutorial/blob/main/package.json). So all we need to do is import it:

```javascript
import * as Bip39 from "bip39";
```

## Recovery phrase

Recall that secret recovery phrases are also called mnemonics and Bip39 includes the method `generateMnemonic()` for generating mnemonic phrases. We can call it and replace the variable currently assigned to an empty string:

```javascript
const generatedMnemonic = Bip39.generateMnemonic();
```

This allows us to set the phrase in state and display it for our user to write down and store safely. With this step we have effectively created our wallet because the phrase by itself will allow its holder to access the account that matches it.

{% sidenote title="Box 2.2: The conservation of blockchain accounts" %}
Even though most of the community refers to accounts as being created, technically blockchain accounts can't be created or destroyed. These accounts are mathematical addresses in a system where their existence is established mathematically at inception by the system's architecture. It's more accurate to think of the mnemonic as obtaining the key to access a pre-existing, empty account.

## Keypairs and seeds

Before we can connect to the account on the blockchain, however, we need to convert the phrase into a form that the blockchain can understand. After all, mnemonic phrases are abstractions that translate a long, archaic number into a more human-friendly form.

We need to convert the phrase into bytes so the Solana web3.js library can use it to generate a `keypair` object. The `keypair` will be the wallet account consisting of a public key that can encrypt data and a private key that can decrypt data.

{% sidenote title="Box 2.3: Public-key cryptography" %}
At a high-level public-key cryptography is a cryptographic system that uses keypairs to transmit information securely. Each keypair consists of a public key, which is widely known across the system, and a private key, which should be kept secret by its owner. Suppose Bob wants to send a secure message to Alice while ensuring that, even if Eve intercepts it, she can't read it. Bob would encrypt the message using Alice's public key and then send the message. Because of something called a one-way function, the public key cannot be used to decrypt the message. The only way the message can be decrypted is with the private key that complements the public key used by Bob - that is, the private key that Alice holds. Bob can rest assured that no one but Alice will be able to read the message. The ability to encrypt information without the need to pre-share symmetric keys was a massive technological development. And the history behind these breakthroughs is well worth studying if you're so inclined. We've included a few suggestions as additional resources at the end of the tutorial.

By reviewing Solana's web3.js [documentation](https://solana-labs.github.io/solana-web3.js/index.html), we see that there's a `Keypair` class defined as "an account keypair used for signing transactions." This is exactly what we need to generate using the mnemonic phrase.

We notice that the `Keypair` class has a `fromSeed` method that generates a keypair from a 32-byte seed. It also mentions that the seed needs to be a `Uint8Array`, which means we'll need a way to convert our `string` phrase into a `Uint8Array`.

Going back to the Bip39 library we see a method called `mnemonicToSeedSync(mnemonic)` that returns some sort of `Buffer` object that looks like a list of hexadecimal numbers. We can test this by running it in our application and passing in the mnemonic we generated:

```javascript
const seed = Bip39.mnemonicToSeedSync(generatedMnemonic);
console.log(seed)

// console:
> Uint8Array(64);
```

It looks like we're close. The `Keypair` class requires a 32-byte `Uint8Array` and we're getting a 64-byte `Uint8Array`. We can slice the seed and keep only the first 32 bytes:

```javascript
const seed = Bip39.mnemonicToSeedSync(generatedMnemonic).slice(0, 32);
console.log(seed)

// console:
> Uint8Array(32);
```

With the seed in the right format, we can use `Keypair`'s `fromSeed` method to generate an account keypair:

```javascript
const newAccount = Keypair.fromSeed(seed);
```

We then set the account into context state and we have access to a Solana wallet.

Once you implement the functionality, make sure you save the recovery phrase before you click **Finish** on the browser. We'll be using it in [Step 6](https://learn.figment.io/tutorials/solana-wallet-step-6) to access the wallet once after logging out. 

Once you click on **Finish**, you'll be routed to the wallet page that displays the account's dashboard. You'll notice this page includes a few other features. We'll discuss the Network dropdown in [Step 3](https://learn.figment.io/tutorials/solana-wallet-step-3) while implementing the crucial functionality of showing users their balance.

In [Step 4](https://learn.figment.io/tutorials/solana-wallet-step-4) we'll dive into airdrops and make the **Airdrop** button functional, and in [Step 5](https://learn.figment.io/tutorials/solana-wallet-step-5) we'll enable the **Send** button and transfer funds.

##### _Listing 2.2: Code for creating a wallet_
```javascript
const generatedMnemonic = Bip39.generateMnemonic();
setMnemonic(generatedMnemonic);

const seed = Bip39.mnemonicToSeedSync(generatedMnemonic).slice(0, 32);
const newAccount = Keypair.fromSeed(seed);
setAccount(newAccount);
```

![](https://github.com/figment-networks/learn-tutorials/blob/master/solana/solana-wallet/assets/dashboard.png?raw=true)

# Challenge 🏋️ 

In your editor, navigate to `pages/phrase.tsx` and follow the steps included as comments to finish writing the function. We include a description along with a link to the documentation you need to review in order to implement each line. The relevant code block is also included in [Listing 2.1](#listing-21-instructions-for-generating-a-phrase-and-creating-a-wallet) below.

##### _Listing 2.1: Instructions for generating a phrase and creating a wallet_
```javascript
useEffect(() => {
  // *Step 2*: implement a function that generates a mnemonic when the page renders, and uses it to create a wallet (i.e. account)
  // (a) review the import guidance on lines 9 and 11
  // (b) generate a mnemonic phrase by importing Bip39 and then implementing the appropriate method on the imported Bip39 instance
  // Documentation Reference: https://github.com/bitcoinjs/bip39
  const generatedMnemonic = "";

  // This line saves the mnemonic phrase to context state so we can display it for the wallet user to copy
  setMnemonic(generatedMnemonic);

  // (c) convert the mnemonic to seed bytes and make sure it's 32-bytes (Hint: console log the seed to see how many bytes you have vs how many you need)
  // Documentation Reference: https://github.com/bitcoinjs/bip39
  const seed = new Uint8Array();

  // (d) use the seed to generate a new account (i.e. a new keypair)
  // Documentation Reference:
  //   https://solana-labs.github.io/solana-web3.js/classes/Keypair.html
  //   https://solana-labs.github.io/solana-web3.js/classes/Keypair.html#fromSeed
  const newAccount = null;

  // This line sets the account to context state so it can be used by the app
  setAccount(newAccount);
}, []);
```


Defining a crypto wallet and how it works

Step 2: Create a Wallet 💼

Fund the account with SOL

Learn how to create and deploy a blogging dApp on Solana using the Anchor framework

Build a blog dApp using the Anchor framework

Send data to the program

# Sign and send

Now that we've funded our account with test tokens on devnet, we can start to think about how we might use those funds. In a real-world application, we might want to swap SOL for another token, pay for goods or services in SOL, or even gift someone some SOL. To do that we need a way to let the network ledger know that our account should transfer funds to another account.

Thinking about it from first principles, we know we'll need a function that takes in two addresses - the sender and the recipient. We also know that we'll need to pass in an amount - the number of SOL or lamports that we want to send.

But there's one more important component: we need to prove to the network that we are in fact the owner of those funds and that we approve the transfer.

## Paper checks

Consider a traditional paper check that you might use to pay your landlord. The check has your name and address printed on the top left. It includes a field for you to write the recipient's name along with a field for you to write the amount you're paying. Finally, it includes a field for you to sign the check to validate to the bank that you're approving the transfer.

![Figure 8: Crypto transactions are like digital checks (with real signatures)](https://raw.githubusercontent.com/figment-networks/learn-tutorials/master/solana/solana-wallet/assets/check.jpeg)

{% label %}
Figure 8: Crypto transactions are like digital checks (with real signatures)

Let's pretend that banks actually use those signatures to validate that you actually signed the check and it's not someone else forging your signature (spoiler alert: they don't for the most part).

## Blockchain transfers

The blockchain model of transferring funds is pretty similar. You need a way to sign the transaction so the network can confirm it as valid and change the corresponding balances.

The concept of cryptographic signing is fascinating, but well beyond the scope of this tutorial. We'll provide [additional resources](#additional-resources) at the end if you want to explore it more, but recall that your keys, along with hashing algorithms and a one-way function, are designed for this very purpose. The signature authenticates the sender and proves to the recipient that the message hasn't been compromised.

With those building blocks in mind, we're ready to search the docs for a way to send and confirm a transaction.

# Implementation 🧩

If you click on the **Send** button on the wallet dashboard, a drawer component opens up that shows a form structured as a paper check thus building on our analogy above. It includes all the components of a transaction but the **Sign and Send** button doesn't work yet.

Navigating to `components/TransactionLayout/index.tsx` we see a partially implemented `transfer` function.

Based on [Step 3](https://learn.figment.io/tutorials/solana-wallet-step-3) and [Step 4](https://learn.figment.io/tutorials/solana-wallet-step-4) we know that we're going to need a connection to the network. We can once again leverage our previous code:

```javascript
const connection = new Connection(clusterApiUrl(network), "confirmed");
```

## Transactions

We can guess that we'll need to build some sort of transaction object and send it through the connection, but it's not immediately obvious how we might do that. By searching the docs, it looks like there are two ways to send transactions - the `sendTransaction` method in `Connection` and the general function `sendAndConfirmTransaction`.

We're going to want to request a confirmation so we can update our balance after sending the transaction, so the latter seems like a good option to try.

Reading through the function's specs, it looks like we need to pass in a `connection`, some sort of `transaction` object and a `signers array`. Moreover, the description says that this function will "sign, send and confirm a transaction" so it looks like we're on the right track. We can begin by importing this function and using it, knowing that we're going to build out its inputs next.

```javascript
const confirmation = await sendAndConfirmTransaction(
  connection,
  transaction,
  signers
);
```

We already have a `connection`, so we can immediately turn to the `transaction` parameter. Following the link to the `Transaction` class in the docs, it looks like to create a `transaction` object, we can use its constructor.

```javascript
const transaction = new Transaction()
console.log(transaction)

// console:
> Transaction {signatures: Array(0), feePayer: undefined, instructions: Array(0), recentBlockhash: undefined, nonceInfo: undefined}
```

Looking at the transaction we created, it clearly lacks any of the components we need for a valid transaction like `sender`, `recipient` and `amount`, but it seems to have a familiar structure that we should be able to populate. You could research each of them, but let's jump right into the `instructions` property as it seems like a promising place to start.

Unfortunately, the docs aren't very intuitive in how to progress but we can leverage our technical sophistication. There's a very useful class called `SystemProgram` with a `transfer` method, which "generates a transaction instruction that transfers lamports from one account to another." This seems like exactly what we need.

## Transfer

The `transfer` method takes in a `TransferParams` object that requires a `sender`, `recipient` and `amount` in lamports. That matches the data we're hoping to use for our transaction and we can get that from the account in context state and the form inputs. The resulting instructions look like this:

```javascript
const instructions = SystemProgram.transfer({
  fromPubkey: account.publicKey,
  toPubkey: new PublicKey(form.to),
  lamports: form.amount,
});
```

Notice that we have to instantiate a `PublicKey` for the recipient because the form is passing in the key as a string but the `toPubkey` property expects a `PublicKey` type. To incorporate these into our transaction, we can use the `add` method:

```javascript
transaction.add(instructions);
```

Or with a bit of on the fly refactoring, we can simply instantiate the transaction after creating the instructions and add them immediately:

```javascript
const transaction = new Transaction().add(instructions);
```

We have two out of the three parameters ready for the `sendAndConfirmTransaction` function - `connection` and `transaction`.

## Signing

Now we need the `signers array`. From the function's specification, we know `signers` will be an array with at least one `Signer` object. Reviewing the `Signer` type in the docs, it looks like it's an object with two properties - `publicKey` and `privateKey`. We can get both from the `account`, so we can build the `signers array`.

```javascript
const signers = [
  {
    publicKey: account.publicKey,
    secretKey: account.secretKey,
  },
];
```

## Send and confirm

Now that all three parameters are complete, we can finally call `sendAndConfirmTransaction` and await its confirmation.

```javascript
const confirmation = await sendAndConfirmTransaction(
  connection,
  transaction,
  signers
);
```

With that we have a fully functional feature capable of transferring funds between Solana accounts. To complete the feature, we need to make sure we call the `refreshBalance` function to update the account's balance after transferring funds.

```javascript
const updatedBalance = await refreshBalance(network, account);
setBalance(updatedBalance);
```

## Test driving

If you haven't already, airdrop some devnet SOL into your account and test transferring funds to another account. If you have another account to use, feel free to do that. Otherwise you can send the devnet SOL back to the smart contract that sent them to you (these are called faucets)! Here's its public address: 9B5XszUGdMaxCZ7uSQhPzdks5ZQSmWxrmzCSvtJ6Ns6g.

Once you fill in the public address of your recipient and the amount, say one million lamports, the **Sign and Send** button will be enabled. Once you click **Sign and Send** you will see a successful message displayed at the top of the page along with a link to the [Solana Block Explorer](https://explorer.solana.com/?cluster=devnet) at the top left of the check.

## Block explorer

The [Solana Block Explorer](https://explorer.solana.com/?cluster=devnet) is a simple dashboard that allows you to search for specific blocks, accounts, transactions, contracts and tokens by network. It displays all the information related to the item you searched for.

![Figure 9: Oh the places you'll go!](https://raw.githubusercontent.com/figment-networks/learn-tutorials/master/solana/solana-wallet/assets/explore.jpeg)

{% label %}
Figure 9: Oh the places you'll go!

In this case, if you click the link on the check, you'll be able to see a basic overview of the transfer you just issued. In the middle of the page, you'll see our transfer's information - mainly, the sender (your public address) and how much SOL you sent; and the recipient (the other public address) and how much SOL they received. In fact, you can check whether you sent the SOL back to the same contract that sent it to you by clicking on the previous transaction in the Transaction History.

You might notice a field labeled "Fee (SOL)". If you scroll to the Account Input(s), you'll also notice that it was charged to your account. While the recipient received the funds you specified, your account was deducted the amount you sent plus a small fee. These [transaction fees](https://docs.solana.com/transaction_fees) are designed to reward validators for the compute power spent to process transactions.

At this point, your Solana wallet is almost complete, except for one major flaw. You can create a wallet, and even transfer funds from it. But you can't access an existing wallet. We'll fix that in [Step 6](https://learn.figment.io/tutorials/solana-wallet-step-6) where we'll once again leverage the Bip39 library to access an account based on a mnemonic phrase.

##### _Listing 5.2: Code for transferring funds_
```javascript
const transfer = async () => {
  if (!account) return;

  try {
    setTransactionSig("");

    const connection = new Connection(clusterApiUrl(network), "confirmed");

    const instructions = SystemProgram.transfer({
      fromPubkey: account.publicKey,
      toPubkey: new PublicKey(form.to),
      lamports: form.amount,
    });

    const transaction = new Transaction().add(instructions);

    const signers = [
      {
        publicKey: account.publicKey,
        secretKey: account.secretKey,
      },
    ];

    setSending(true);
    const confirmation = await sendAndConfirmTransaction(
      connection,
      transaction,
      signers
    );
    setTransactionSig(confirmation);
    setSending(false);

    const updatedBalance = await refreshBalance(network, account);
    setBalance(updatedBalance);
    message.success(`Transaction confirmed`);
  } catch (error) {
    message.error("Transaction failed, please check your inputs and try again");
    console.log(error);
  }
};
```

# Challenge 🏋️

Navigate to `components/TransactionLayout/index.tsx` in your editor and follow the steps included as comments to finish writing the `transfer` function. We include a description along with a link to the documentation you need to review in order to implement each line. The relevant code block is also included in [Listing 5.1](#listing-51-instructions-for-writing-transfer-function) below.

##### _Listing 5.1: Instructions for writing transfer function_
```javascript
// *Step 5*: implement a function that transfer funds
const transfer = async () => {
  // This line ensures the function returns before running if no account has been set
  if (!account) return;

  try {
    // (a) review the import guidance on line 1
    // (b) instantiate a connection using clusterApiUrl with the active network passed in as an argument
    // Documentation References:
    //   https://solana-labs.github.io/solana-web3.js/classes/Connection.html
    //   https://solana-labs.github.io/solana-web3.js/modules.html#clusterApiUrl
    console.log("Sign and Send not yet implemented!");
    const connection = "";
    setTransactionSig("");
    // (c) leverage the SystemProgram class to create transfer instructions that include your account's public key, the public key from your sender field in the form, and the amount from the form
    // Documentation Reference:
    //   https://solana-labs.github.io/solana-web3.js/classes/SystemProgram.html
    //   https://solana-labs.github.io/solana-web3.js/classes/SystemProgram.html#transfer
    const instructions = {};

    // (d) instantiate a transaction object and add the instructions
    // Documentation Reference:
    //   https://solana-labs.github.io/solana-web3.js/classes/Transaction.html
    //   https://solana-labs.github.io/solana-web3.js/classes/Transaction.html#add
    const transaction = {};

    // (e) use your account to create a signers interface
    // Documentation Reference:
    //   https://solana-labs.github.io/solana-web3.js/interfaces/Signer.html
    //   note: signers is an array with a single item - an object with two properties
    const signers = [{}];

    setSending(true);
    // (f) send the transaction and await its confirmation
    // Documentation Reference: https://solana-labs.github.io/solana-web3.js/modules.html#sendAndConfirmTransaction
    const confirmation = "";
    setTransactionSig(confirmation);
    setSending(false);

    const updatedBalance = await refreshBalance(network, account);
    setBalance(updatedBalance);
    message.success(`Transaction confirmed`);
    // (g) You can now delete the console.log statement since the function is implemented!
  } catch (error) {
    console.log(error);
    message.error("Transaction failed, please check your inputs and try again");
  }
};
```
