update example and tests

Author: Mahhheshh

basics/favorites/poseidon/migrations/deploy.ts

@@ -4,7 +4,7 @@
 
 const anchor = require("@coral-xyz/anchor");
 
-module.exports = async function (provider) {
+module.exports = async (provider) => {
   // Configure client to use the provider.
   anchor.setProvider(provider);
 

basics/favorites/poseidon/programs/poseidon/src/lib.rs

@@ -3,31 +3,40 @@ declare_id!("GsGBeoB6fFTWfUrHhKYTjtXvuiKCC7shhhQqXeQsTLJ2");
 #[program]
 pub mod favorites {
     use super::*;
-    pub fn initialize(ctx: Context<InitializeContext>, number: u8) -> Result<()> {
+    pub fn initialize(
+        ctx: Context<InitializeContext>,
+        number: u8,
+        color: String,
+        hobbies: Vec<String>,
+    ) -> Result<()> {
         ctx.accounts.state.owner = ctx.accounts.user.key();
         ctx.accounts.state.number = number;
+        ctx.accounts.state.color = color;
+        ctx.accounts.state.hobbies = hobbies;
         ctx.accounts.state.bump = ctx.bumps.state;
         Ok(())
     }
 }
 #[derive(Accounts)]
 pub struct InitializeContext<'info> {
+    #[account(mut)]
+    pub user: Signer<'info>,
     #[account(
         init,
         payer = user,
-        space = 42,
+        space = 130,
         seeds = [b"favorites",
         user.key().as_ref()],
         bump,
     )]
     pub state: Account<'info, FavoritesState>,
-    #[account(mut)]
-    pub user: Signer<'info>,
     pub system_program: Program<'info, System>,
 }
 #[account]
 pub struct FavoritesState {
     pub owner: Pubkey,
     pub number: u8,
+    pub color: String,
+    pub hobbies: Vec<String>,
     pub bump: u8,
 }

basics/favorites/poseidon/tests/bankrun.test.ts

@@ -0,0 +1,81 @@
+import { describe, it } from 'node:test';
+import * as anchor from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { BankrunProvider } from 'anchor-bankrun';
+import { assert } from 'chai';
+import { startAnchor } from 'solana-bankrun';
+import type { Favorites } from '../target/types/favorites';
+
+const web3 = anchor.web3;
+const IDL = require('../target/idl/favorites.json');
+const PROGRAM_ID = new PublicKey(IDL.address);
+
+describe('Favorites Bankrun', async () => {
+    // Use the cluster and the keypair from Anchor.toml
+    // Load programs into anchor-bankrun
+    const context = await startAnchor('', [{ name: 'favorites_program', programId: PROGRAM_ID }], []);
+    const provider = new BankrunProvider(context);
+    anchor.setProvider(provider);
+    const user = (provider.wallet as anchor.Wallet).payer;
+    const someRandomGuy = anchor.web3.Keypair.generate();
+  
+    const program = new anchor.Program<Favorites>(IDL, provider);
+  
+    // Here"s what we want to write to the blockchain
+    const favoriteNumber = 23;
+    const favoriteColor = 'purple';
+    const favoriteHobbies = ['skiing', 'skydiving', 'biking'];
+  
+    // We don"t need to airdrop if we"re using the local cluster
+    // because the local cluster gives us 1,000,000 SOL
+    const balance = await context.banksClient.getBalance(user.publicKey);
+    const balanceInSOL = balance / BigInt(web3.LAMPORTS_PER_SOL);
+    const formattedBalance = new Intl.NumberFormat().format(balanceInSOL);
+    console.log(`Balance: ${formattedBalance} SOL`);
+  
+    it('Writes our favorites to the blockchain', async () => {
+      await program.methods
+        // set_favourites in Rust becomes setFavorites in TypeScript
+        .initialize(favoriteNumber, favoriteColor, favoriteHobbies)
+        // Sign the transaction
+        .signers([user])
+        // Send the transaction to the cluster or RPC
+        .rpc();
+  
+      // Find the PDA for the user"s favorites
+      const favoritesPdaAndBump = web3.PublicKey.findProgramAddressSync([Buffer.from('favorites'), user.publicKey.toBuffer()], program.programId);
+      const favoritesPda = favoritesPdaAndBump[0];
+      const dataFromPda = await program.account.favoritesState.fetch(favoritesPda);
+      // And make sure it matches!
+      assert.equal(dataFromPda.color, favoriteColor);
+      // A little extra work to make sure the BNs are equal
+      assert.equal(dataFromPda.number.toString(), favoriteNumber.toString());
+      // And check the hobbies too
+      assert.deepEqual(dataFromPda.hobbies, favoriteHobbies);
+    });
+  
+    it('Updates the favorites', async () => {
+      const newFavoriteHobbies = ['skiing', 'skydiving', 'biking', 'swimming'];
+      try {
+        await program.methods.initialize(favoriteNumber, favoriteColor, newFavoriteHobbies).signers([user]).rpc();
+      } catch (error) {
+        const errorMessage = (error as Error).message;
+        assert.isTrue(errorMessage.includes('SendTransactionError'));
+      }
+    });
+  
+    it('Rejects transactions from unauthorized signers', async () => {
+      try {
+        await program.methods
+          // set_favourites in Rust becomes setFavorites in TypeScript
+          .initialize(favoriteNumber, favoriteColor, favoriteHobbies)
+          // Sign the transaction
+          .signers([someRandomGuy])
+          // Send the transaction to the cluster or RPC
+          .rpc();
+      } catch (error) {
+        const errorMessage = (error as Error).message;
+        assert.isTrue(errorMessage.includes('unknown signer'));
+      }
+    });
+  });

basics/favorites/poseidon/tests/favourits.test.ts

@@ -27,10 +27,11 @@ describe("account favorites program", () => {
 
     const favorites = {
       number: 2,
-      // color: "blue",
+      color: "blue",
+      hobbies: ["coding", "chess"],
     };
     await program.methods
-      .initialize(favorites.number)
+      .initialize(favorites.number, favorites.color, favorites.hobbies)
       .accounts({
         user: favoritesAccount.publicKey,
       })
@@ -41,12 +42,14 @@ describe("account favorites program", () => {
     console.log(`Owner: ${account.owner}`);
     console.log(`Number: ${account.number}`);
     console.log(`Bump: ${account.bump}`);
-    // console.log(`Color: ${account.color}`);
-
+    console.log(`Color: ${account.color}`);
+    console.log(`Hobbies: ${account.hobbies}`);
     expect(account.bump).to.be.a("number");
     expect(account.owner.toBase58()).to.equal(
       favoritesAccount.publicKey.toBase58()
     );
     expect(account.number).to.equal(favorites.number);
+    expect(account.color).to.equal(favorites.color);
+    expect(account.hobbies).to.deep.equal(favorites.hobbies);
   });
 });

basics/favorites/poseidon/ts-programs/src/favourits.ts

@@ -4,38 +4,33 @@ import {
   Signer,
   u8,
   type Result,
+  // Avoid using `as` for renaming imports in this case, as it can cause issues during the transpilation process.
+  String,
+  Vec,
 } from "@solanaturbine/poseidon";
 
-// * This program defines a Favorites class that allows a Solana user to store their favorite number.
-// * It uses Program Derived Addresses (PDAs) to securely manage the user's favorite data.
+// This program defines a Favorites class that allows a Solana user to store their favorite number.
+// It uses Program Derived Addresses (PDAs) to securely manage the user's favorite data.
 
 export default class Favorites {
   static PROGRAM_ID = new Pubkey(
     "GsGBeoB6fFTWfUrHhKYTjtXvuiKCC7shhhQqXeQsTLJ2"
   );
 
-  // Note: As of this implementation, the Poseidon framework does not support using arrays of strings
-  // (e.g., String[] or Array<String>) in the transaction context. Therefore,
-  // it is not possible to use collections of strings, such as hobbies: String[] or Array<String>.
-
-  // Additionally, working with string data types can lead to deserialization issues,
-  // specifically the `AccountDidNotDeserialize` error. This occurs because the framework may
-  // not correctly allocate the required space for PDAs that include string fields.
-
   initialize(
-    user: Signer,
     state: FavoritesState,
-    number: u8
-    // color: String,
-    // hobbies: Array<String>
+    user: Signer,
+    number: u8,
+    color: String<10>,
+    hobbies: Vec<String<10>, 5>
   ): Result {
     // Create a PDA using the seed combination ["favorites", user.key]
-    state.derive(["favorites", user.key]).init();
+    state.derive(["favorites", user.key]).init(user);
 
     state.owner = user.key; // Set the owner of the favorites state to the user's public key
     state.number = number; // Store the user's favorite number
-    // state.color = color; // Note: String handling is currently unsupported
-    // state.hobbies = hobbies; //  Note: Array of String is currently unsupported
+    state.color = color;
+    state.hobbies = hobbies;
     state.bump = state.getBump(); // Retrieve the bump seed for the PDA
   }
 }
@@ -45,7 +40,7 @@ export interface FavoritesState extends Account {
 
   // PDA properties
   number: u8; // The user's favorite number
-  // color: String; // Note: String handling is currently unsupported
-  // hobbies: Array<String>; // Note: String handling is currently unsupported
+  color: String<10>;
+  hobbies: Vec<String<10>, 5>;
   bump: u8; // Bump seed for the PDA
 }