Setting up locally

PDAs with Gage

PDA deep dive

Build on-chain comments

CPIs with Gage

The Cross Program Boss fight

Mint tokens for users

Build a payment system with CPIs

Testing with Gage

Testing Solana programs

Writing tests in Rust

Build a staking UI

Build a token minter

Put it all together

Local Env Setup and PDAS

Cross Program Invocations

Testing

Ship a Staking App

Solana Development I

Our movie review program is decent, but it's not very web3. All we're doing right now is using Solana as a database. Let's spice it up by giving people tokens for using our app! We'll mint tokens to someone every time they review a movie or leave a comment. Think of it like StackOverflow but with tokens instead of upvotes.You can pick up where you left off in your last local environment, or set up a new one by copying <a target="_blank" href="https://beta.solpg.io/6313104b88a7fca897ad7d19">this</a> or:<pre style="display: block; overflow-x: auto; background: rgb(28, 29, 33); color: rgb(192, 197, 206); padding: 0.5em;"><code class="language-text" style="white-space: pre;">git clone https://github.com/buildspace/solana-movie-program/
cd solana-movie-program
git checkout solution-add-comments
npm i
</code></pre>We'll be using the SPL token program to make all of this magic happen so go ahead and update the dependencies in <code>Cargo.toml</code>:<pre style="display: block; overflow-x: auto; background: rgb(28, 29, 33); color: rgb(192, 197, 206); padding: 0.5em;"><code class="language-text" style="white-space: pre;">[dependencies]
solana-program = "~1.10.29"
borsh = "0.9.3"
thiserror = "1.0.31"
spl-token = { version="3.2.0", features = [ "no-entrypoint" ] }
spl-associated-token-account = { version="=1.0.5", features = [ "no-entrypoint" ] }
</code></pre>Let's quickly test out that everything builds with these new dependencies with <code>cargo build-bpf</code>.We're ready to get building!<h4>🤖 Set up the token mint</h4>We'll start by creating a token mint. Reminder: a token mint is a special account that holds data about our token.This is a new instruction, so we'll follow the same steps as we did when we added support for comments:<ol><li>Update the instruction enum</li><li>Update the unpack function</li><li>Update the <code>process_instruction</code> funciton</li></ol>From the top in <code>instruction.rs</code>, we've got the enum update:<pre style="display: block; overflow-x: auto; background: rgb(28, 29, 33); color: rgb(192, 197, 206); padding: 0.5em;"><code class="language-text" style="white-space: pre;">pub enum MovieInstruction {
 AddMovieReview {
 title: String,
 rating: u8,
 description: String,
 },
 UpdateMovieReview {
 title: String,
 rating: u8,
 description: String,
 },
 AddComment {
 comment: String,
 },
 InitializeMint,
}
</code></pre>We won't need any fields here - all it takes to call that function is addresses!Next, we'll update the unpack function:<pre style="display: block; overflow-x: auto; background: rgb(28, 29, 33); color: rgb(192, 197, 206); padding: 0.5em;"><code class="language-text" style="white-space: pre;">impl MovieInstruction {
 pub fn unpack(input: &amp;[u8]) -&gt; Result&lt;Self, ProgramError&gt; {
 let (&amp;variant, rest) = input
 .split_first()
 .ok_or(ProgramError::InvalidInstructionData)?;
 Ok(match variant {
 0 =&gt; {
 let payload = MovieReviewPayload::try_from_slice(rest).unwrap();
 Self::AddMovieReview {
 title: payload.title,
 rating: payload.rating,
 description: payload.description,
 }
 }
 1 =&gt; {
 let payload = MovieReviewPayload::try_from_slice(rest).unwrap();
 Self::UpdateMovieReview {
 title: payload.title,
 rating: payload.rating,
 description: payload.description,
 }
 }
 2 =&gt; {
 let payload = CommentPayload::try_from_slice(rest).unwrap();
 Self::AddComment {
 comment: payload.comment,
 }
 }
 // New variant added here
 3 =&gt; Self::InitializeMint,
 _ =&gt; return Err(ProgramError::InvalidInstructionData),
 })
 }
}
</code></pre>You'll immediately notice an error in the <code>process_instruction</code> match statement in <code>processor.rs</code> since we're not handling all the cases. Let's fix this by bringing in our new SPL imports and adding to the match statement:<pre style="display: block; overflow-x: auto; background: rgb(28, 29, 33); color: rgb(192, 197, 206); padding: 0.5em;"><code class="language-text" style="white-space: pre;">// Update imports at the top
use solana_program::{
 //Existing imports within solana_program

 sysvar::{rent::Rent, Sysvar, rent::ID as RENT_PROGRAM_ID},
 native_token::LAMPORTS_PER_SOL,
 system_program::ID as SYSTEM_PROGRAM_ID
}
use spl_associated_token_account::get_associated_token_address;
use spl_token::{instruction::initialize_mint, ID as TOKEN_PROGRAM_ID};

pub fn process_instruction(
 program_id: &amp;Pubkey,
 accounts: &amp;[AccountInfo],
 instruction_data: &amp;[u8],
) -&gt; ProgramResult {
 let instruction = MovieInstruction::unpack(instruction_data)?;
 match instruction {
 MovieInstruction::AddMovieReview {
 title,
 rating,
 description,
 } =&gt; add_movie_review(program_id, accounts, title, rating, description),
 MovieInstruction::UpdateMovieReview {
 title,
 rating,
 description,
 } =&gt; update_movie_review(program_id, accounts, title, rating, description),
 MovieInstruction::AddComment { comment } =&gt; add_comment(program_id, accounts, comment),
 // New instruction handled here to initialize the mint account
 MovieInstruction::InitializeMint =&gt; initialize_token_mint(program_id, accounts),
 }
}
// Rest of the file remains the same
</code></pre>Finally, we can implement the <code>initialize_token_mint</code> account at the bottom of <code>processor.rs</code> after the <code>add_comment</code> function:<pre style="display: block; overflow-x: auto; background: rgb(28, 29, 33); color: rgb(192, 197, 206); padding: 0.5em;"><code class="language-text" style="white-space: pre;">pub fn initialize_token_mint(program_id: &amp;Pubkey, accounts: &amp;[AccountInfo]) -&gt; ProgramResult {
 let account_info_iter = &amp;mut accounts.iter();

 // The order of accounts is not arbitrary, the client will send them in this order
 // Whoever sent in the transaction
 let initializer = next_account_info(account_info_iter)?;
 // Token mint PDA - derived on the client
 let token_mint = next_account_info(account_info_iter)?;
 // Token mint authorirty (this should be you)
 let mint_auth = next_account_info(account_info_iter)?;
 // System program to create a new account
 let system_program = next_account_info(account_info_iter)?;
 // Solana Token program address
 let token_program = next_account_info(account_info_iter)?;
 // System account to calcuate the rent
 let sysvar_rent = next_account_info(account_info_iter)?;

 // Derive the mint PDA again so we can validate it
 // The seed is just "token_mint"
 let (mint_pda, mint_bump) = Pubkey::find_program_address(&amp;[b"token_mint"], program_id);
 // Derive the mint authority so we can validate it
 // The seed is just "token_auth"
 let (mint_auth_pda, _mint_auth_bump) =
 Pubkey::find_program_address(&amp;[b"token_auth"], program_id);

 msg!("Token mint: {:?}", mint_pda);
 msg!("Mint authority: {:?}", mint_auth_pda);

 // Validate the important accounts passed in
 if mint_pda != *token_mint.key {
 msg!("Incorrect token mint account");
 return Err(ReviewError::IncorrectAccountError.into());
 }

 if *token_program.key != TOKEN_PROGRAM_ID {
 msg!("Incorrect token program");
 return Err(ReviewError::IncorrectAccountError.into());
 }

 if *mint_auth.key != mint_auth_pda {
 msg!("Incorrect mint auth account");
 return Err(ReviewError::IncorrectAccountError.into());
 }

 if *system_program.key != SYSTEM_PROGRAM_ID {
 msg!("Incorrect system program");
 return Err(ReviewError::IncorrectAccountError.into());
 }

 if *sysvar_rent.key != RENT_PROGRAM_ID {
 msg!("Incorrect rent program");
 return Err(ReviewError::IncorrectAccountError.into());
 }

 // Calculate the rent
 let rent = Rent::get()?;
 // We know the size of a mint account is 82 (remember it lol)
 let rent_lamports = rent.minimum_balance(82);

 // Create the token mint PDA
 invoke_signed(
 &amp;system_instruction::create_account(
 initializer.key,
 token_mint.key,
 rent_lamports,
 82, // Size of the token mint account
 token_program.key,
 ),
 // Accounts we're reading from or writing to 
 &amp;[
 initializer.clone(),
 token_mint.clone(),
 system_program.clone(),
 ],
 // Seeds for our token mint account
 &amp;[&amp;[b"token_mint", &amp;[mint_bump]]],
 )?;

 msg!("Created token mint account");

 // Initialize the mint account
 invoke_signed(
 &amp;initialize_mint(
 token_program.key,
 token_mint.key,
 mint_auth.key,
 Option::None, // Freeze authority - we don't want anyone to be able to freeze!
 9, // Number of decimals
 )?,
 // Which accounts we're reading from or writing to
 &amp;[token_mint.clone(), sysvar_rent.clone(), mint_auth.clone()],
 // The seeds for our token mint PDA
 &amp;[&amp;[b"token_mint", &amp;[mint_bump]]],
 )?;

 msg!("Initialized token mint");

 Ok(())
}
</code></pre>At a high level, here's what's happening here:<ol><li>Iterate through list of accounts to extract them</li><li>Derive token mint PDA</li><li>Validate all of the important accounts passed in:</li><li class="ql-indent-1">Token mint account</li><li class="ql-indent-1">Mint authority account (this should be you)</li><li class="ql-indent-1">System program</li><li class="ql-indent-1">Token program</li><li class="ql-indent-1">Sysvar rent - the rent calculation account</li><li>Calculate rent for the mint account</li><li>Create the token mint PDA</li><li>Initialize the mint account</li></ol>Go over the code comments, I added context wherever I could!You'll now be getting an error since we're calling a new error without declaring it. Pop open <code>error.rs</code> and add <code>IncorrectAccountError</code> to the <code>ReviewError</code> enum:<pre style="display: block; overflow-x: auto; background: rgb(28, 29, 33); color: rgb(192, 197, 206); padding: 0.5em;"><code class="language-text" style="white-space: pre;">#[derive(Debug, Error)]
pub enum ReviewError {
 #[error("Account not initialized yet")]
 UninitializedAccount,

 #[error("PDA derived does not equal PDA passed in")]
 InvalidPDA,

 #[error("Input data exceeds max length")]
 InvalidDataLength,

 #[error("Rating greater than 5 or less than 1")]
 InvalidRating,

 // New error added
 #[error("Accounts do not match")]
 IncorrectAccountError,
}
</code></pre>Pretty self-explanatory :)Open up the target folder in your file explorer and get rid of the keypair in the deploy folder.In your console:<pre style="display: block; overflow-x: auto; background: rgb(28, 29, 33); color: rgb(192, 197, 206); padding: 0.5em;"><code class="language-bash" style="white-space: pre;">cargo build-bpf</code>
</pre>Copy and paste the deploy command that's printed out.If you get <code>insufficient funds</code> just run <code>solana airdrop 2</code>.Once you've deployed locally, it's time to test! We're going to use a local client script to test out initializing the account. Here's what you'll need to set up:<pre style="display: block; overflow-x: auto; background: rgb(28, 29, 33); color: rgb(192, 197, 206); padding: 0.5em;"><code class="language-bash" style="white-space: pre;">git clone https://github.com/buildspace/solana-movie-token-client
cd solana-movie-token-client
npm install
</code></pre>Before you can run the script you'll need to:<ol><li>Update <code>PROGRAM_ID</code> in <code>index.ts</code></li><li>Change connection to on line 67 to</li></ol><pre style="display: block; overflow-x: auto; background: rgb(28, 29, 33); color: rgb(192, 197, 206); padding: 0.5em;"><code class="language-text" style="white-space: pre;">const connection = new web3.Connection("http://localhost:8899");</code>
</pre><ol start="3"><li>Run <code>solana logs PROGRAM_ID_HERE</code> in a second console window</li></ol>You should now have a console logging all the outputs for this program and are ready to run the script!If you run <code>npm start</code> you should see the logs for the mint account creation :D

We're Under Maintenance