From 4515e06da3d3d70ed88707ff8e8ebcc774b87160 Mon Sep 17 00:00:00 2001 From: Joe Date: Mon, 16 Oct 2023 13:41:02 +0200 Subject: [PATCH] token-group: create collections example --- Cargo.lock | 16 + Cargo.toml | 1 + token-group/example/Cargo.toml | 28 ++ token-group/example/src/entrypoint.rs | 23 ++ token-group/example/src/lib.rs | 10 + token-group/example/src/processor.rs | 225 +++++++++++++ .../example/tests/initialize_collection.rs | 176 ++++++++++ .../tests/initialize_collection_member.rs | 237 ++++++++++++++ token-group/example/tests/setup.rs | 81 +++++ .../tests/update_collection_authority.rs | 209 ++++++++++++ .../tests/update_collection_max_size.rs | 302 ++++++++++++++++++ token-group/interface/src/error.rs | 6 + 12 files changed, 1314 insertions(+) create mode 100644 token-group/example/Cargo.toml create mode 100644 token-group/example/src/entrypoint.rs create mode 100644 token-group/example/src/lib.rs create mode 100644 token-group/example/src/processor.rs create mode 100644 token-group/example/tests/initialize_collection.rs create mode 100644 token-group/example/tests/initialize_collection_member.rs create mode 100644 token-group/example/tests/setup.rs create mode 100644 token-group/example/tests/update_collection_authority.rs create mode 100644 token-group/example/tests/update_collection_max_size.rs diff --git a/Cargo.lock b/Cargo.lock index 234414e21de..8a79f2f2fb1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7176,6 +7176,22 @@ dependencies = [ "thiserror", ] +[[package]] +name = "spl-token-group-example" +version = "0.1.0" +dependencies = [ + "solana-program", + "solana-program-test", + "solana-sdk", + "spl-discriminator 0.1.0", + "spl-pod 0.1.0", + "spl-token-2022 0.9.0", + "spl-token-client", + "spl-token-group-interface", + "spl-token-metadata-interface 0.2.0", + "spl-type-length-value 0.3.0", +] + [[package]] name = "spl-token-group-interface" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index 209c1a091e7..8f74cfd9653 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -41,6 +41,7 @@ members = [ "stake-pool/cli", "stake-pool/program", "stateless-asks/program", + "token-group/example", "token-group/interface", "token-lending/cli", "token-lending/program", diff --git a/token-group/example/Cargo.toml b/token-group/example/Cargo.toml new file mode 100644 index 00000000000..851b742dcf5 --- /dev/null +++ b/token-group/example/Cargo.toml @@ -0,0 +1,28 @@ +[package] +name = "spl-token-group-example" +version = "0.1.0" +description = "Solana Program Library Token Group Example" +authors = ["Solana Labs Maintainers "] +repository = "https://github.com/solana-labs/solana-program-library" +license = "Apache-2.0" +edition = "2021" + +[dependencies] +solana-program = "1.16.16" +spl-pod = { version = "0.1.0", path = "../../libraries/pod" } +spl-token-2022 = { version = "0.9.0", path = "../../token/program-2022" } +spl-token-group-interface = { version = "0.1.0", path = "../interface" } +spl-type-length-value = { version = "0.3.0", path = "../../libraries/type-length-value" } + +[dev-dependencies] +solana-program-test = "1.16.16" +solana-sdk = "1.16.16" +spl-discriminator = { version = "0.1.0", path = "../../libraries/discriminator" } +spl-token-client = { version = "0.7", path = "../../token/client" } +spl-token-metadata-interface = { version = "0.2", path = "../../token-metadata/interface" } + +[lib] +crate-type = ["cdylib", "lib"] + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] \ No newline at end of file diff --git a/token-group/example/src/entrypoint.rs b/token-group/example/src/entrypoint.rs new file mode 100644 index 00000000000..a5ae85f308e --- /dev/null +++ b/token-group/example/src/entrypoint.rs @@ -0,0 +1,23 @@ +//! Program entrypoint + +use { + crate::processor, + solana_program::{ + account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, + program_error::PrintProgramError, pubkey::Pubkey, + }, + spl_token_group_interface::error::TokenGroupError, +}; + +entrypoint!(process_instruction); +fn process_instruction( + program_id: &Pubkey, + accounts: &[AccountInfo], + instruction_data: &[u8], +) -> ProgramResult { + if let Err(error) = processor::process(program_id, accounts, instruction_data) { + error.print::(); + return Err(error); + } + Ok(()) +} \ No newline at end of file diff --git a/token-group/example/src/lib.rs b/token-group/example/src/lib.rs new file mode 100644 index 00000000000..d476bbbab83 --- /dev/null +++ b/token-group/example/src/lib.rs @@ -0,0 +1,10 @@ +//! Crate defining an example program for creating SPL token collections +//! using the SPL Token Group interface. + +#![deny(missing_docs)] +#![cfg_attr(not(test), forbid(unsafe_code))] + +pub mod processor; + +#[cfg(not(feature = "no-entrypoint"))] +mod entrypoint; diff --git a/token-group/example/src/processor.rs b/token-group/example/src/processor.rs new file mode 100644 index 00000000000..86862c43dcc --- /dev/null +++ b/token-group/example/src/processor.rs @@ -0,0 +1,225 @@ +//! Program state processor + +use { + solana_program::{ + account_info::{next_account_info, AccountInfo}, + entrypoint::ProgramResult, + msg, + program_error::ProgramError, + program_option::COption, + pubkey::Pubkey, + }, + spl_pod::optional_keys::OptionalNonZeroPubkey, + spl_token_2022::{extension::StateWithExtensions, state::Mint}, + spl_token_group_interface::{ + error::TokenGroupError, + instruction::{ + InitializeGroup, TokenGroupInterfaceInstruction, UpdateGroupAuthority, + UpdateGroupMaxSize, + }, + state::{Group, Member}, + }, + spl_type_length_value::state::TlvStateMut, +}; + +fn check_update_authority( + update_authority_info: &AccountInfo, + expected_update_authority: &OptionalNonZeroPubkey, +) -> Result<(), ProgramError> { + if !update_authority_info.is_signer { + return Err(ProgramError::MissingRequiredSignature); + } + let update_authority = Option::::from(*expected_update_authority) + .ok_or(TokenGroupError::ImmutableGroup)?; + if update_authority != *update_authority_info.key { + return Err(TokenGroupError::IncorrectAuthority.into()); + } + Ok(()) +} + +/// Processes a [InitializeGroup](enum.GroupInterfaceInstruction.html) +/// instruction for a `Collection` +pub fn process_initialize_collection( + _program_id: &Pubkey, + accounts: &[AccountInfo], + data: InitializeGroup, +) -> ProgramResult { + // Assumes one has already created a mint for the collection. + let account_info_iter = &mut accounts.iter(); + + // Accounts expected by this instruction: + // + // 0. `[w]` Collection (Group) + // 1. `[]` Mint + // 2. `[s]` Mint authority + let collection_info = next_account_info(account_info_iter)?; + let mint_info = next_account_info(account_info_iter)?; + let mint_authority_info = next_account_info(account_info_iter)?; + + { + // IMPORTANT: this example program is designed to work with any + // program that implements the SPL token interface, so there is no + // ownership check on the mint account. + let mint_data = mint_info.try_borrow_data()?; + let mint = StateWithExtensions::::unpack(&mint_data)?; + + if !mint_authority_info.is_signer { + return Err(ProgramError::MissingRequiredSignature); + } + if mint.base.mint_authority.as_ref() != COption::Some(mint_authority_info.key) { + return Err(TokenGroupError::IncorrectAuthority.into()); + } + } + + // Allocate a TLV entry for the space and write it in + let mut buffer = collection_info.try_borrow_mut_data()?; + let mut state = TlvStateMut::unpack(&mut buffer)?; + let (collection, _) = state.init_value::(false)?; + *collection = Group::new(data.update_authority, data.max_size.into()); + + Ok(()) +} + +/// Processes an +/// [UpdateGroupMaxSize](enum.GroupInterfaceInstruction.html) +/// instruction for a `Collection` +pub fn process_update_collection_max_size( + _program_id: &Pubkey, + accounts: &[AccountInfo], + data: UpdateGroupMaxSize, +) -> ProgramResult { + let account_info_iter = &mut accounts.iter(); + + // Accounts expected by this instruction: + // + // 0. `[w]` Collection (Group) + // 1. `[s]` Update authority + let collection_info = next_account_info(account_info_iter)?; + let update_authority_info = next_account_info(account_info_iter)?; + + let mut buffer = collection_info.try_borrow_mut_data()?; + let mut state = TlvStateMut::unpack(&mut buffer)?; + let collection = state.get_first_value_mut::()?; + + check_update_authority(update_authority_info, &collection.update_authority)?; + + // Update the max size (zero-copy) + collection.update_max_size(data.max_size.into())?; + + Ok(()) +} + +/// Processes a +/// [UpdateGroupAuthority](enum.GroupInterfaceInstruction.html) +/// instruction for a `Collection` +pub fn process_update_collection_authority( + _program_id: &Pubkey, + accounts: &[AccountInfo], + data: UpdateGroupAuthority, +) -> ProgramResult { + let account_info_iter = &mut accounts.iter(); + + // Accounts expected by this instruction: + // + // 0. `[w]` Collection (Group) + // 1. `[s]` Current update authority + let collection_info = next_account_info(account_info_iter)?; + let update_authority_info = next_account_info(account_info_iter)?; + + let mut buffer = collection_info.try_borrow_mut_data()?; + let mut state = TlvStateMut::unpack(&mut buffer)?; + let mut collection = state.get_first_value_mut::()?; + + check_update_authority(update_authority_info, &collection.update_authority)?; + + // Update the authority (zero-copy) + collection.update_authority = data.new_authority; + + Ok(()) +} + +/// Processes a [InitializeMember](enum.GroupInterfaceInstruction.html) +/// instruction for a `Collection` +pub fn process_initialize_collection_member( + _program_id: &Pubkey, + accounts: &[AccountInfo], +) -> ProgramResult { + // For this group, we are going to assume the collection has been + // initialized, and we're also assuming a mint _and_ metadata have been + // created for the member. + // Collection memebers in this example can have their own separate + // metadata that differs from the metadata of the collection. + let account_info_iter = &mut accounts.iter(); + + // Accounts expected by this instruction: + // + // 0. `[w]` Collection Member (Member) + // 1. `[]` Collection Member (Member) Mint + // 2. `[s]` Collection Member (Member) Mint authority + // 3. `[w]` Collection (Group) + // 4. `[s]` Collection (Group) update authority + let member_info = next_account_info(account_info_iter)?; + let member_mint_info = next_account_info(account_info_iter)?; + let member_mint_authority_info = next_account_info(account_info_iter)?; + let collection_info = next_account_info(account_info_iter)?; + let collection_update_authority_info = next_account_info(account_info_iter)?; + + // Mint checks on the member + { + // IMPORTANT: this example program is designed to work with any + // program that implements the SPL token interface, so there is no + // ownership check on the mint account. + let member_mint_data = member_mint_info.try_borrow_data()?; + let member_mint = StateWithExtensions::::unpack(&member_mint_data)?; + + if !member_mint_authority_info.is_signer { + return Err(ProgramError::MissingRequiredSignature); + } + if member_mint.base.mint_authority.as_ref() != COption::Some(member_mint_authority_info.key) + { + return Err(TokenGroupError::IncorrectAuthority.into()); + } + } + + // Increment the size of the collection + let mut buffer = collection_info.try_borrow_mut_data()?; + let mut state = TlvStateMut::unpack(&mut buffer)?; + let collection = state.get_first_value_mut::()?; + + check_update_authority( + collection_update_authority_info, + &collection.update_authority, + )?; + let member_number = collection.increment_size()?; + + // Allocate a TLV entry for the space and write it in + let mut buffer = member_info.try_borrow_mut_data()?; + let mut state = TlvStateMut::unpack(&mut buffer)?; + let (member, _) = state.init_value::(false)?; + *member = Member::new(*collection_info.key, member_number.into()); + + Ok(()) +} + +/// Processes an `SplTokenGroupInstruction` +pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> ProgramResult { + let instruction = TokenGroupInterfaceInstruction::unpack(input)?; + match instruction { + TokenGroupInterfaceInstruction::InitializeGroup(data) => { + msg!("Instruction: InitializeCollection"); + process_initialize_collection(program_id, accounts, data) + } + TokenGroupInterfaceInstruction::UpdateGroupMaxSize(data) => { + msg!("Instruction: UpdateCollectionMaxSize"); + process_update_collection_max_size(program_id, accounts, data) + } + TokenGroupInterfaceInstruction::UpdateGroupAuthority(data) => { + msg!("Instruction: UpdateCollectionAuthority"); + process_update_collection_authority(program_id, accounts, data) + } + TokenGroupInterfaceInstruction::InitializeMember(_) => { + msg!("Instruction: InitializeCollectionMember"); + process_initialize_collection_member(program_id, accounts) + } + } +} diff --git a/token-group/example/tests/initialize_collection.rs b/token-group/example/tests/initialize_collection.rs new file mode 100644 index 00000000000..c1c341d5cdc --- /dev/null +++ b/token-group/example/tests/initialize_collection.rs @@ -0,0 +1,176 @@ +#![cfg(feature = "test-sbf")] + +mod setup; + +use { + setup::{setup_mint_and_metadata, setup_program_test}, + solana_program::{instruction::InstructionError, pubkey::Pubkey, system_instruction}, + solana_program_test::tokio, + solana_sdk::{ + signature::Keypair, + signer::Signer, + transaction::{Transaction, TransactionError}, + }, + spl_token_client::token::Token, + spl_token_group_interface::{ + error::TokenGroupError, instruction::initialize_group, state::Group, + }, + spl_token_metadata_interface::state::TokenMetadata, + spl_type_length_value::{ + error::TlvError, + state::{TlvState, TlvStateBorrowed}, + }, +}; + +#[tokio::test] +async fn test_initialize_collection() { + let program_id = Pubkey::new_unique(); + let collection = Keypair::new(); + let collection_mint = Keypair::new(); + let collection_mint_authority = Keypair::new(); + let collection_metadata = Keypair::new(); + let collection_metadata_update_authority = Keypair::new(); + + let collection_metadata_state = TokenMetadata { + update_authority: None.try_into().unwrap(), + mint: collection_mint.pubkey(), + name: "The Coolest Collection".to_string(), + symbol: "COOL".to_string(), + uri: "https://cool.com".to_string(), + additional_metadata: vec![], + }; + let collection_group_state = Group { + update_authority: None.try_into().unwrap(), + size: 0.into(), + max_size: 50.into(), + }; + + let (context, client, payer) = setup_program_test(&program_id).await; + + let token_client = Token::new( + client, + &spl_token_2022::id(), + &collection_mint.pubkey(), + Some(0), + payer.clone(), + ); + + setup_mint_and_metadata( + &token_client, + &collection_mint, + &collection_mint_authority, + &collection_metadata.pubkey(), + &collection_metadata_update_authority.pubkey(), + &collection_metadata_state, + payer, + ) + .await; + + let mut context = context.lock().await; + + let rent = context.banks_client.get_rent().await.unwrap(); + let space = TlvStateBorrowed::get_base_len() + std::mem::size_of::(); + let rent_lamports = rent.minimum_balance(space); + + // Fail: mint authority not signer + let mut init_group_ix = initialize_group( + &program_id, + &collection.pubkey(), + &collection_mint.pubkey(), + &collection_mint_authority.pubkey(), + collection_group_state.update_authority.try_into().unwrap(), + collection_group_state.max_size.into(), + ); + init_group_ix.accounts[2].is_signer = false; + let transaction = Transaction::new_signed_with_payer( + &[ + system_instruction::create_account( + &context.payer.pubkey(), + &collection.pubkey(), + rent_lamports, + space.try_into().unwrap(), + &program_id, + ), + init_group_ix, + ], + Some(&context.payer.pubkey()), + &[&context.payer, &collection], + context.last_blockhash, + ); + assert_eq!( + context + .banks_client + .process_transaction(transaction) + .await + .unwrap_err() + .unwrap(), + TransactionError::InstructionError(1, InstructionError::MissingRequiredSignature) + ); + + // Success: create the collection + let transaction = Transaction::new_signed_with_payer( + &[ + system_instruction::create_account( + &context.payer.pubkey(), + &collection.pubkey(), + rent_lamports, + space.try_into().unwrap(), + &program_id, + ), + initialize_group( + &program_id, + &collection.pubkey(), + &collection_mint.pubkey(), + &collection_mint_authority.pubkey(), + collection_group_state.update_authority.try_into().unwrap(), + collection_group_state.max_size.into(), + ), + ], + Some(&context.payer.pubkey()), + &[&context.payer, &collection_mint_authority, &collection], + context.last_blockhash, + ); + context + .banks_client + .process_transaction(transaction) + .await + .unwrap(); + + // Fetch the collection account and ensure it matches our state + let fetched_collection_account = context + .banks_client + .get_account(collection.pubkey()) + .await + .unwrap() + .unwrap(); + let fetched_meta = TlvStateBorrowed::unpack(&fetched_collection_account.data).unwrap(); + let fetched_collection_group_state = fetched_meta.get_first_value::().unwrap(); + assert_eq!(fetched_collection_group_state, &collection_group_state); + + // Fail: can't initialize twice + let transaction = Transaction::new_signed_with_payer( + &[initialize_group( + &program_id, + &collection.pubkey(), + &collection_mint.pubkey(), + &collection_mint_authority.pubkey(), + Pubkey::new_unique().into(), // Intentionally changed + collection_group_state.max_size.into(), + )], + Some(&context.payer.pubkey()), + &[&context.payer, &collection_mint_authority], + context.last_blockhash, + ); + assert_eq!( + context + .banks_client + .process_transaction(transaction) + .await + .unwrap_err() + .unwrap(), + TransactionError::InstructionError( + 0, + InstructionError::Custom(TlvError::TypeAlreadyExists as u32) + ) + ); +} diff --git a/token-group/example/tests/initialize_collection_member.rs b/token-group/example/tests/initialize_collection_member.rs new file mode 100644 index 00000000000..15a8c3fceb8 --- /dev/null +++ b/token-group/example/tests/initialize_collection_member.rs @@ -0,0 +1,237 @@ +#![cfg(feature = "test-sbf")] + +mod setup; + +use { + setup::{setup_mint_and_metadata, setup_program_test}, + solana_program::{instruction::InstructionError, pubkey::Pubkey, system_instruction}, + solana_program_test::tokio, + solana_sdk::{ + signature::Keypair, + signer::Signer, + transaction::{Transaction, TransactionError}, + }, + spl_token_client::token::Token, + spl_token_group_interface::{ + instruction::{initialize_group, initialize_member}, + state::{Group, Member}, + }, + spl_token_metadata_interface::state::TokenMetadata, + spl_type_length_value::state::{TlvState, TlvStateBorrowed}, +}; + +#[tokio::test] +async fn test_initialize_collection_member() { + let program_id = Pubkey::new_unique(); + let collection = Keypair::new(); + let collection_mint = Keypair::new(); + let collection_mint_authority = Keypair::new(); + let collection_metadata = Keypair::new(); + let collection_update_authority = Keypair::new(); + let member = Keypair::new(); + let member_mint = Keypair::new(); + let member_mint_authority = Keypair::new(); + + let collection_metadata_state = TokenMetadata { + update_authority: None.try_into().unwrap(), + mint: collection_mint.pubkey(), + name: "The Coolest Collection".to_string(), + symbol: "COOL".to_string(), + uri: "https://cool.com".to_string(), + additional_metadata: vec![], + }; + let collection_group_state = Group { + update_authority: Some(collection_update_authority.pubkey()) + .try_into() + .unwrap(), + size: 30.into(), + max_size: 50.into(), + }; + + let (context, client, payer) = setup_program_test(&program_id).await; + + setup_mint_and_metadata( + &Token::new( + client.clone(), + &spl_token_2022::id(), + &collection_mint.pubkey(), + Some(0), + payer.clone(), + ), + &collection_mint, + &collection_mint_authority, + &collection_metadata.pubkey(), + &collection_update_authority.pubkey(), + &collection_metadata_state, + payer.clone(), + ) + .await; + Token::new( + client, + &spl_token_2022::id(), + &member_mint.pubkey(), + Some(0), + payer.clone(), + ) + .create_mint( + &member_mint_authority.pubkey(), + None, + vec![], + &[&member_mint], + ) + .await + .unwrap(); + + let mut context = context.lock().await; + + let rent = context.banks_client.get_rent().await.unwrap(); + let space = TlvStateBorrowed::get_base_len() + std::mem::size_of::(); + let rent_lamports = rent.minimum_balance(space); + + let transaction = Transaction::new_signed_with_payer( + &[ + system_instruction::create_account( + &context.payer.pubkey(), + &collection.pubkey(), + rent_lamports, + space.try_into().unwrap(), + &program_id, + ), + initialize_group( + &program_id, + &collection.pubkey(), + &collection_mint.pubkey(), + &collection_mint_authority.pubkey(), + collection_group_state.update_authority.try_into().unwrap(), + collection_group_state.max_size.into(), + ), + ], + Some(&context.payer.pubkey()), + &[&context.payer, &collection_mint_authority, &collection], + context.last_blockhash, + ); + context + .banks_client + .process_transaction(transaction) + .await + .unwrap(); + + let member_space = TlvStateBorrowed::get_base_len() + std::mem::size_of::(); + let member_rent_lamports = rent.minimum_balance(member_space); + + // Fail: member mint authority not signer + let mut init_member_ix = initialize_member( + &program_id, + &member.pubkey(), + &member_mint.pubkey(), + &member_mint_authority.pubkey(), + &collection.pubkey(), + &collection_update_authority.pubkey(), + ); + init_member_ix.accounts[2].is_signer = false; + let transaction = Transaction::new_signed_with_payer( + &[ + system_instruction::create_account( + &context.payer.pubkey(), + &member.pubkey(), + member_rent_lamports, + member_space.try_into().unwrap(), + &program_id, + ), + init_member_ix, + ], + Some(&context.payer.pubkey()), + &[&context.payer, &member, &collection_update_authority], + context.last_blockhash, + ); + assert_eq!( + context + .banks_client + .process_transaction(transaction) + .await + .unwrap_err() + .unwrap(), + TransactionError::InstructionError(1, InstructionError::MissingRequiredSignature) + ); + + // Fail: group update authority not signer + let mut init_member_ix = initialize_member( + &program_id, + &member.pubkey(), + &member_mint.pubkey(), + &member_mint_authority.pubkey(), + &collection.pubkey(), + &collection_update_authority.pubkey(), + ); + init_member_ix.accounts[4].is_signer = false; + let transaction = Transaction::new_signed_with_payer( + &[ + system_instruction::create_account( + &context.payer.pubkey(), + &member.pubkey(), + member_rent_lamports, + member_space.try_into().unwrap(), + &program_id, + ), + init_member_ix, + ], + Some(&context.payer.pubkey()), + &[&context.payer, &member, &member_mint_authority], + context.last_blockhash, + ); + assert_eq!( + context + .banks_client + .process_transaction(transaction) + .await + .unwrap_err() + .unwrap(), + TransactionError::InstructionError(1, InstructionError::MissingRequiredSignature) + ); + + // Success: initialize member + let transaction = Transaction::new_signed_with_payer( + &[ + system_instruction::create_account( + &context.payer.pubkey(), + &member.pubkey(), + member_rent_lamports, + member_space.try_into().unwrap(), + &program_id, + ), + initialize_member( + &program_id, + &member.pubkey(), + &member_mint.pubkey(), + &member_mint_authority.pubkey(), + &collection.pubkey(), + &collection_update_authority.pubkey(), + ), + ], + Some(&context.payer.pubkey()), + &[ + &context.payer, + &member, + &member_mint_authority, + &collection_update_authority, + ], + context.last_blockhash, + ); + context + .banks_client + .process_transaction(transaction) + .await + .unwrap(); + + // Fetch the member account and ensure it matches our state + let member_account = context + .banks_client + .get_account(member.pubkey()) + .await + .unwrap() + .unwrap(); + let fetched_meta = TlvStateBorrowed::unpack(&member_account.data).unwrap(); + let fetched_collection_member_state = fetched_meta.get_first_value::().unwrap(); + assert_eq!(fetched_collection_member_state.group, collection.pubkey()); + assert_eq!(u32::from(fetched_collection_member_state.member_number), 1); +} diff --git a/token-group/example/tests/setup.rs b/token-group/example/tests/setup.rs new file mode 100644 index 00000000000..93206f11462 --- /dev/null +++ b/token-group/example/tests/setup.rs @@ -0,0 +1,81 @@ +#![cfg(feature = "test-sbf")] + +use { + solana_program_test::{processor, tokio::sync::Mutex, ProgramTest, ProgramTestContext}, + solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer}, + spl_token_client::{ + client::{ + ProgramBanksClient, ProgramBanksClientProcessTransaction, ProgramClient, + SendTransaction, SimulateTransaction, + }, + token::{ExtensionInitializationParams, Token}, + }, + spl_token_metadata_interface::state::TokenMetadata, + std::sync::Arc, +}; + +/// Set up a program test +pub async fn setup_program_test( + program_id: &Pubkey, +) -> ( + Arc>, + Arc>, + Arc, +) { + let mut program_test = ProgramTest::new( + "spl_token_group_example", + *program_id, + processor!(spl_token_group_example::processor::process), + ); + program_test.prefer_bpf(false); + program_test.add_program( + "spl_token_2022", + spl_token_2022::id(), + processor!(spl_token_2022::processor::Processor::process), + ); + let context = program_test.start_with_context().await; + let payer = Arc::new(context.payer.insecure_clone()); + let context = Arc::new(Mutex::new(context)); + let client: Arc> = + Arc::new(ProgramBanksClient::new_from_context( + Arc::clone(&context), + ProgramBanksClientProcessTransaction, + )); + (context, client, payer) +} + +/// Set up a Token-2022 mint and metadata +pub async fn setup_mint_and_metadata( + token_client: &Token, + mint_keypair: &Keypair, + mint_authority_keypair: &Keypair, + metadata_pubkey: &Pubkey, + metadata_update_authority_pubkey: &Pubkey, + token_metadata: &TokenMetadata, + payer: Arc, +) { + token_client + .create_mint( + &mint_authority_keypair.pubkey(), + None, + vec![ExtensionInitializationParams::MetadataPointer { + authority: Some(*metadata_update_authority_pubkey), + metadata_address: Some(*metadata_pubkey), + }], + &[mint_keypair], + ) + .await + .unwrap(); + token_client + .token_metadata_initialize_with_rent_transfer( + &payer.pubkey(), + metadata_update_authority_pubkey, + &mint_authority_keypair.pubkey(), + token_metadata.name.clone(), + token_metadata.symbol.clone(), + token_metadata.uri.clone(), + &[&payer, mint_authority_keypair], + ) + .await + .unwrap(); +} diff --git a/token-group/example/tests/update_collection_authority.rs b/token-group/example/tests/update_collection_authority.rs new file mode 100644 index 00000000000..06c5d4ece55 --- /dev/null +++ b/token-group/example/tests/update_collection_authority.rs @@ -0,0 +1,209 @@ +#![cfg(feature = "test-sbf")] + +mod setup; + +use { + setup::{setup_mint_and_metadata, setup_program_test}, + solana_program::{instruction::InstructionError, pubkey::Pubkey, system_instruction}, + solana_program_test::tokio, + solana_sdk::{ + signature::Keypair, + signer::Signer, + transaction::{Transaction, TransactionError}, + }, + spl_token_client::token::Token, + spl_token_group_interface::{ + error::TokenGroupError, + instruction::{initialize_group, update_group_authority}, + state::Group, + }, + spl_token_metadata_interface::state::TokenMetadata, + spl_type_length_value::state::{TlvState, TlvStateBorrowed, TlvStateMut}, +}; + +#[tokio::test] +async fn test_update_collection_authority() { + let program_id = Pubkey::new_unique(); + let collection = Keypair::new(); + let collection_mint = Keypair::new(); + let collection_mint_authority = Keypair::new(); + let collection_metadata = Keypair::new(); + let collection_update_authority = Keypair::new(); + + let collection_metadata_state = TokenMetadata { + update_authority: None.try_into().unwrap(), + mint: collection_mint.pubkey(), + name: "The Coolest Collection".to_string(), + symbol: "COOL".to_string(), + uri: "https://cool.com".to_string(), + additional_metadata: vec![], + }; + let collection_group_state = Group { + update_authority: Some(collection_update_authority.pubkey()) + .try_into() + .unwrap(), + size: 30.into(), + max_size: 50.into(), + }; + + let (context, client, payer) = setup_program_test(&program_id).await; + + let token_client = Token::new( + client, + &spl_token_2022::id(), + &collection_mint.pubkey(), + Some(0), + payer.clone(), + ); + + setup_mint_and_metadata( + &token_client, + &collection_mint, + &collection_mint_authority, + &collection_metadata.pubkey(), + &collection_update_authority.pubkey(), + &collection_metadata_state, + payer, + ) + .await; + + let mut context = context.lock().await; + + let rent = context.banks_client.get_rent().await.unwrap(); + let space = TlvStateBorrowed::get_base_len() + std::mem::size_of::(); + let rent_lamports = rent.minimum_balance(space); + + let transaction = Transaction::new_signed_with_payer( + &[ + system_instruction::create_account( + &context.payer.pubkey(), + &collection.pubkey(), + rent_lamports, + space.try_into().unwrap(), + &program_id, + ), + initialize_group( + &program_id, + &collection.pubkey(), + &collection_mint.pubkey(), + &collection_mint_authority.pubkey(), + collection_group_state.update_authority.try_into().unwrap(), + collection_group_state.max_size.into(), + ), + ], + Some(&context.payer.pubkey()), + &[&context.payer, &collection_mint_authority, &collection], + context.last_blockhash, + ); + context + .banks_client + .process_transaction(transaction) + .await + .unwrap(); + + // Fail: update authority not signer + let mut update_ix = update_group_authority( + &program_id, + &collection.pubkey(), + &collection_update_authority.pubkey(), + None, + ); + update_ix.accounts[1].is_signer = false; + let transaction = Transaction::new_signed_with_payer( + &[update_ix], + Some(&context.payer.pubkey()), + &[&context.payer], + context.last_blockhash, + ); + assert_eq!( + context + .banks_client + .process_transaction(transaction) + .await + .unwrap_err() + .unwrap(), + TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature) + ); + + // Fail: incorrect update authority + let transaction = Transaction::new_signed_with_payer( + &[update_group_authority( + &program_id, + &collection.pubkey(), + &collection.pubkey(), + None, + )], + Some(&context.payer.pubkey()), + &[&context.payer, &collection], + context.last_blockhash, + ); + assert_eq!( + context + .banks_client + .process_transaction(transaction) + .await + .unwrap_err() + .unwrap(), + TransactionError::InstructionError( + 0, + InstructionError::Custom(TokenGroupError::IncorrectAuthority as u32) + ) + ); + + // Success: update authority + let transaction = Transaction::new_signed_with_payer( + &[update_group_authority( + &program_id, + &collection.pubkey(), + &collection_update_authority.pubkey(), + None, + )], + Some(&context.payer.pubkey()), + &[&context.payer, &collection_update_authority], + context.last_blockhash, + ); + context + .banks_client + .process_transaction(transaction) + .await + .unwrap(); + + // Fetch the account and assert the new authority + let fetched_collection_account = context + .banks_client + .get_account(collection.pubkey()) + .await + .unwrap() + .unwrap(); + let fetched_meta = TlvStateBorrowed::unpack(&fetched_collection_account.data).unwrap(); + let fetched_collection_group_state = fetched_meta.get_first_value::().unwrap(); + assert_eq!( + fetched_collection_group_state.update_authority, + None.try_into().unwrap(), + ); + + // Fail: immutable group + let transaction = Transaction::new_signed_with_payer( + &[update_group_authority( + &program_id, + &collection.pubkey(), + &collection_update_authority.pubkey(), + Some(collection_update_authority.pubkey()), + )], + Some(&context.payer.pubkey()), + &[&context.payer, &collection_update_authority], + context.last_blockhash, + ); + assert_eq!( + context + .banks_client + .process_transaction(transaction) + .await + .unwrap_err() + .unwrap(), + TransactionError::InstructionError( + 0, + InstructionError::Custom(TokenGroupError::ImmutableGroup as u32) + ) + ); +} diff --git a/token-group/example/tests/update_collection_max_size.rs b/token-group/example/tests/update_collection_max_size.rs new file mode 100644 index 00000000000..19128d5ddc2 --- /dev/null +++ b/token-group/example/tests/update_collection_max_size.rs @@ -0,0 +1,302 @@ +#![cfg(feature = "test-sbf")] + +mod setup; + +use { + setup::{setup_mint_and_metadata, setup_program_test}, + solana_program::{instruction::InstructionError, pubkey::Pubkey, system_instruction}, + solana_program_test::tokio, + solana_sdk::{ + account::Account as SolanaAccount, + signature::Keypair, + signer::Signer, + transaction::{Transaction, TransactionError}, + }, + spl_token_client::token::Token, + spl_token_group_interface::{ + error::TokenGroupError, + instruction::{initialize_group, update_group_max_size}, + state::Group, + }, + spl_token_metadata_interface::state::TokenMetadata, + spl_type_length_value::state::{TlvState, TlvStateBorrowed, TlvStateMut}, +}; + +#[tokio::test] +async fn test_update_collection_max_size() { + let program_id = Pubkey::new_unique(); + let collection = Keypair::new(); + let collection_mint = Keypair::new(); + let collection_mint_authority = Keypair::new(); + let collection_metadata = Keypair::new(); + let collection_update_authority = Keypair::new(); + + let collection_metadata_state = TokenMetadata { + update_authority: None.try_into().unwrap(), + mint: collection_mint.pubkey(), + name: "The Coolest Collection".to_string(), + symbol: "COOL".to_string(), + uri: "https://cool.com".to_string(), + additional_metadata: vec![], + }; + let collection_group_state = Group { + update_authority: Some(collection_update_authority.pubkey()) + .try_into() + .unwrap(), + size: 30.into(), + max_size: 50.into(), + }; + + let (context, client, payer) = setup_program_test(&program_id).await; + + let token_client = Token::new( + client, + &spl_token_2022::id(), + &collection_mint.pubkey(), + Some(0), + payer.clone(), + ); + + setup_mint_and_metadata( + &token_client, + &collection_mint, + &collection_mint_authority, + &collection_metadata.pubkey(), + &collection_update_authority.pubkey(), + &collection_metadata_state, + payer, + ) + .await; + + let mut context = context.lock().await; + + let rent = context.banks_client.get_rent().await.unwrap(); + let space = TlvStateBorrowed::get_base_len() + std::mem::size_of::(); + let rent_lamports = rent.minimum_balance(space); + + let transaction = Transaction::new_signed_with_payer( + &[ + system_instruction::create_account( + &context.payer.pubkey(), + &collection.pubkey(), + rent_lamports, + space.try_into().unwrap(), + &program_id, + ), + initialize_group( + &program_id, + &collection.pubkey(), + &collection_mint.pubkey(), + &collection_mint_authority.pubkey(), + collection_group_state.update_authority.try_into().unwrap(), + collection_group_state.max_size.into(), + ), + ], + Some(&context.payer.pubkey()), + &[&context.payer, &collection_mint_authority, &collection], + context.last_blockhash, + ); + context + .banks_client + .process_transaction(transaction) + .await + .unwrap(); + + // Fail: update authority not signer + let mut update_ix = + update_group_max_size(&program_id, &collection.pubkey(), &collection.pubkey(), 100); + update_ix.accounts[1].is_signer = false; + let transaction = Transaction::new_signed_with_payer( + &[update_ix], + Some(&context.payer.pubkey()), + &[&context.payer], + context.last_blockhash, + ); + assert_eq!( + context + .banks_client + .process_transaction(transaction) + .await + .unwrap_err() + .unwrap(), + TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature) + ); + + // Fail: incorrect update authority + let transaction = Transaction::new_signed_with_payer( + &[update_group_max_size( + &program_id, + &collection.pubkey(), + &collection.pubkey(), + 100, + )], + Some(&context.payer.pubkey()), + &[&context.payer, &collection], + context.last_blockhash, + ); + assert_eq!( + context + .banks_client + .process_transaction(transaction) + .await + .unwrap_err() + .unwrap(), + TransactionError::InstructionError( + 0, + InstructionError::Custom(TokenGroupError::IncorrectAuthority as u32) + ) + ); + + // Fail: size exceeds new max size + let fetched_collection_account = context + .banks_client + .get_account(collection.pubkey()) + .await + .unwrap() + .unwrap(); + let mut data = fetched_collection_account.data; + let mut state = TlvStateMut::unpack(&mut data).unwrap(); + let collection_data = state.get_first_value_mut::().unwrap(); + collection_data.size = 30.into(); + context.set_account( + &collection.pubkey(), + &SolanaAccount { + data, + ..fetched_collection_account + } + .into(), + ); + let transaction = Transaction::new_signed_with_payer( + &[update_group_max_size( + &program_id, + &collection.pubkey(), + &collection_update_authority.pubkey(), + 20, + )], + Some(&context.payer.pubkey()), + &[&context.payer, &collection_update_authority], + context.last_blockhash, + ); + assert_eq!( + context + .banks_client + .process_transaction(transaction) + .await + .unwrap_err() + .unwrap(), + TransactionError::InstructionError( + 0, + InstructionError::Custom(TokenGroupError::SizeExceedsNewMaxSize as u32) + ) + ); + + // Success: update max size + let transaction = Transaction::new_signed_with_payer( + &[update_group_max_size( + &program_id, + &collection.pubkey(), + &collection_update_authority.pubkey(), + 100, + )], + Some(&context.payer.pubkey()), + &[&context.payer, &collection_update_authority], + context.last_blockhash, + ); + context + .banks_client + .process_transaction(transaction) + .await + .unwrap(); + + // Fetch the account and assert the new max size + let fetched_collection_account = context + .banks_client + .get_account(collection.pubkey()) + .await + .unwrap() + .unwrap(); + let fetched_meta = TlvStateBorrowed::unpack(&fetched_collection_account.data).unwrap(); + let fetched_collection_group_state = fetched_meta.get_first_value::().unwrap(); + assert_eq!(fetched_collection_group_state.max_size, 100.into()); + + // Fail: immutable group + // Need to reset the test to run this + let (context, client, payer) = setup_program_test(&program_id).await; + + let token_client = Token::new( + client, + &spl_token_2022::id(), + &collection_mint.pubkey(), + Some(0), + payer.clone(), + ); + + setup_mint_and_metadata( + &token_client, + &collection_mint, + &collection_mint_authority, + &collection_metadata.pubkey(), + &collection_update_authority.pubkey(), + &collection_metadata_state, + payer, + ) + .await; + + let mut context = context.lock().await; + + let rent = context.banks_client.get_rent().await.unwrap(); + let space = TlvStateBorrowed::get_base_len() + std::mem::size_of::(); + let rent_lamports = rent.minimum_balance(space); + + let transaction = Transaction::new_signed_with_payer( + &[ + system_instruction::create_account( + &context.payer.pubkey(), + &collection.pubkey(), + rent_lamports, + space.try_into().unwrap(), + &program_id, + ), + initialize_group( + &program_id, + &collection.pubkey(), + &collection_mint.pubkey(), + &collection_mint_authority.pubkey(), + None.try_into().unwrap(), + collection_group_state.max_size.into(), + ), + ], + Some(&context.payer.pubkey()), + &[&context.payer, &collection_mint_authority, &collection], + context.last_blockhash, + ); + context + .banks_client + .process_transaction(transaction) + .await + .unwrap(); + + let transaction = Transaction::new_signed_with_payer( + &[update_group_max_size( + &program_id, + &collection.pubkey(), + &collection_update_authority.pubkey(), + 100, + )], + Some(&context.payer.pubkey()), + &[&context.payer, &collection_update_authority], + context.last_blockhash, + ); + assert_eq!( + context + .banks_client + .process_transaction(transaction) + .await + .unwrap_err() + .unwrap(), + TransactionError::InstructionError( + 0, + InstructionError::Custom(TokenGroupError::ImmutableGroup as u32) + ) + ); +} diff --git a/token-group/interface/src/error.rs b/token-group/interface/src/error.rs index f2eff4d60f2..12f35763b27 100644 --- a/token-group/interface/src/error.rs +++ b/token-group/interface/src/error.rs @@ -11,4 +11,10 @@ pub enum TokenGroupError { /// Size is greater than max size #[error("Size is greater than max size")] SizeExceedsMaxSize, + /// Group is immutable + #[error("Group is immutable")] + ImmutableGroup, + /// Incorrect authority + #[error("Incorrect authority")] + IncorrectAuthority, }