diff --git a/.github/workflows/pull-request-token-group.yml b/.github/workflows/pull-request-token-group.yml
new file mode 100644
index 00000000000..b0dc891ba83
--- /dev/null
+++ b/.github/workflows/pull-request-token-group.yml
@@ -0,0 +1,68 @@
+name: Token-Group Pull Request
+
+on:
+  pull_request:
+    paths:
+    - 'token-group/**'
+    - 'token/program-2022/**'
+    - 'ci/*-version.sh'
+    - '.github/workflows/pull-request-token-group.yml'
+  push:
+    branches: [master]
+    paths:
+    - 'token-group/**'
+    - 'token/program-2022/**'
+    - 'ci/*-version.sh'
+    - '.github/workflows/pull-request-token-group.yml'
+
+jobs:
+  cargo-test-sbf:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set env vars
+        run: |
+          source ci/rust-version.sh
+          echo "RUST_STABLE=$rust_stable" >> $GITHUB_ENV
+          source ci/solana-version.sh
+          echo "SOLANA_VERSION=$solana_version" >> $GITHUB_ENV
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ env.RUST_STABLE }}
+          override: true
+          profile: minimal
+
+      - uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: cargo-build-${{ hashFiles('**/Cargo.lock') }}-${{ env.RUST_STABLE}}
+
+      - uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cargo/bin/rustfilt
+          key: cargo-sbf-bins-${{ runner.os }}
+
+      - uses: actions/cache@v2
+        with:
+          path: ~/.cache/solana
+          key: solana-${{ env.SOLANA_VERSION }}
+
+      - name: Install dependencies
+        run: |
+          ./ci/install-build-deps.sh
+          ./ci/install-program-deps.sh
+          echo "$HOME/.local/share/solana/install/active_release/bin" >> $GITHUB_PATH
+
+      - name: Test token-group with "serde" activated
+        run: |
+          cargo test \
+            --manifest-path=token-group/interface/Cargo.toml \
+            -- --nocapture
+
+      - name: Build and test example
+        run: ./ci/cargo-test-sbf.sh token-group/example
diff --git a/Cargo.lock b/Cargo.lock
index 93eef674bcb..b1039ac8258 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7188,6 +7188,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 4825c596d30..38d6fd3c4f1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -42,6 +42,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..227d5e4cde1
--- /dev/null
+++ b/token-group/example/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+name = "spl-token-group-example"
+version = "0.1.0"
+description = "Solana Program Library Token Group Example"
+authors = ["Solana Labs Maintainers <maintainers@solanalabs.com>"]
+repository = "https://github.com/solana-labs/solana-program-library"
+license = "Apache-2.0"
+edition = "2021"
+
+[features]
+no-entrypoint = []
+test-sbf = []
+
+[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-token-metadata-interface = { version = "0.2", path = "../../token-metadata/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" }
+
+[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..762ec75255a
--- /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::<TokenGroupError>();
+        return Err(error);
+    }
+    Ok(())
+}
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..8dbd27ffc51
--- /dev/null
+++ b/token-group/example/src/processor.rs
@@ -0,0 +1,349 @@
+//! Program state processor
+
+use {
+    solana_program::{
+        account_info::{next_account_info, AccountInfo},
+        entrypoint::ProgramResult,
+        msg,
+        program::invoke,
+        program_error::ProgramError,
+        program_option::COption,
+        pubkey::Pubkey,
+    },
+    spl_pod::optional_keys::OptionalNonZeroPubkey,
+    spl_token_2022::{
+        extension::{
+            metadata_pointer::MetadataPointer, BaseStateWithExtensions, StateWithExtensions,
+        },
+        state::Mint,
+    },
+    spl_token_group_interface::{
+        error::TokenGroupError,
+        instruction::{
+            InitializeGroup, TokenGroupInstruction, UpdateGroupAuthority, UpdateGroupMaxSize,
+        },
+        state::{TokenGroup, TokenGroupMember},
+    },
+    spl_token_metadata_interface::state::TokenMetadata,
+    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::<Pubkey>::from(*expected_update_authority)
+        .ok_or(TokenGroupError::ImmutableGroup)?;
+    if update_authority != *update_authority_info.key {
+        return Err(TokenGroupError::IncorrectAuthority.into());
+    }
+    Ok(())
+}
+
+/// Processes an [InitializeGroup](enum.GroupInterfaceInstruction.html)
+/// instruction
+pub fn process_initialize_group(
+    _program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    data: InitializeGroup,
+) -> ProgramResult {
+    // Assumes one has already created a mint for the group.
+    let account_info_iter = &mut accounts.iter();
+
+    // Accounts expected by this instruction:
+    //
+    //   0. `[w]`   Group
+    //   1. `[]`    Mint
+    //   2. `[s]`   Mint authority
+    let group_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::<Mint>::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 = group_info.try_borrow_mut_data()?;
+    let mut state = TlvStateMut::unpack(&mut buffer)?;
+    let (group, _) = state.init_value::<TokenGroup>(false)?;
+    *group = TokenGroup::new(data.update_authority, data.max_size.into());
+
+    Ok(())
+}
+
+/// Processes an
+/// [UpdateGroupMaxSize](enum.GroupInterfaceInstruction.html)
+/// instruction
+pub fn process_update_group_max_size(
+    _program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    data: UpdateGroupMaxSize,
+) -> ProgramResult {
+    let account_info_iter = &mut accounts.iter();
+
+    // Accounts expected by this instruction:
+    //
+    //   0. `[w]`   Group
+    //   1. `[s]`   Update authority
+    let group_info = next_account_info(account_info_iter)?;
+    let update_authority_info = next_account_info(account_info_iter)?;
+
+    let mut buffer = group_info.try_borrow_mut_data()?;
+    let mut state = TlvStateMut::unpack(&mut buffer)?;
+    let group = state.get_first_value_mut::<TokenGroup>()?;
+
+    check_update_authority(update_authority_info, &group.update_authority)?;
+
+    // Update the max size (zero-copy)
+    group.update_max_size(data.max_size.into())?;
+
+    Ok(())
+}
+
+/// Processes an
+/// [UpdateGroupAuthority](enum.GroupInterfaceInstruction.html)
+/// instruction
+pub fn process_update_group_authority(
+    _program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    data: UpdateGroupAuthority,
+) -> ProgramResult {
+    let account_info_iter = &mut accounts.iter();
+
+    // Accounts expected by this instruction:
+    //
+    //   0. `[w]`   Group
+    //   1. `[s]`   Current update authority
+    let group_info = next_account_info(account_info_iter)?;
+    let update_authority_info = next_account_info(account_info_iter)?;
+
+    let mut buffer = group_info.try_borrow_mut_data()?;
+    let mut state = TlvStateMut::unpack(&mut buffer)?;
+    let mut group = state.get_first_value_mut::<TokenGroup>()?;
+
+    check_update_authority(update_authority_info, &group.update_authority)?;
+
+    // Update the authority (zero-copy)
+    group.update_authority = data.new_authority;
+
+    Ok(())
+}
+
+/// Processes an [InitializeMember](enum.GroupInterfaceInstruction.html)
+/// instruction
+pub fn process_initialize_member(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
+    // For this group, we are going to assume the group has been
+    // initialized, and we're also assuming a mint has been created for the
+    // member.
+    // Group members in this example can have their own separate
+    // metadata that differs from the metadata of the group, since
+    // metadata is not involved here.
+    let account_info_iter = &mut accounts.iter();
+
+    // Accounts expected by this instruction:
+    //
+    //   0. `[w]`   Member
+    //   1. `[]`    Member Mint
+    //   2. `[s]`   Member Mint authority
+    //   3. `[w]`   Group
+    //   4. `[s]`   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 group_info = next_account_info(account_info_iter)?;
+    let group_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::<Mint>::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 group
+    let mut buffer = group_info.try_borrow_mut_data()?;
+    let mut state = TlvStateMut::unpack(&mut buffer)?;
+    let group = state.get_first_value_mut::<TokenGroup>()?;
+
+    check_update_authority(group_update_authority_info, &group.update_authority)?;
+    let member_number = group.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::<TokenGroupMember>(false)?;
+    *member = TokenGroupMember::new(*group_info.key, member_number);
+
+    Ok(())
+}
+
+/// Processes a [InitializeMember](enum.GroupInterfaceInstruction.html)
+/// instruction for an `Edition`.
+///
+/// This function demonstrates using this interface for editions as well.
+fn process_initialize_edition_reprint(
+    _program_id: &Pubkey,
+    accounts: &[AccountInfo],
+) -> ProgramResult {
+    // Here we are going to assume the original has been created and
+    // initialized as a group, then we can use the original to print "reprints"
+    // from it.
+    // We're also assuming a mint _and_ metadata have been created for _both_
+    // the original and the reprint.
+    let account_info_iter = &mut accounts.iter();
+
+    // Accounts expected by this instruction:
+    //
+    //   0. `[w]`   Reprint (Member)
+    //   1. `[]`    Reprint (Member) Mint
+    //   2. `[s]`   Reprint (Member) Mint authority
+    //   3. `[w]`   Original (Group)
+    //   4. `[s]`   Original (Group) update authority
+    let reprint_info = next_account_info(account_info_iter)?;
+    // Note this particular example _also_ requires the mint to be writable!
+    let reprint_mint_info = next_account_info(account_info_iter)?;
+    let reprint_mint_authority_info = next_account_info(account_info_iter)?;
+    let original_info = next_account_info(account_info_iter)?;
+    let original_update_authority_info = next_account_info(account_info_iter)?;
+
+    // Additional accounts expected by this instruction:
+    //
+    //   5. `[]`    Original (Group) Mint
+    //   6. `[]`    SPL Token 2022 program
+    let original_mint_info = next_account_info(account_info_iter)?;
+    let _program_2022_info = next_account_info(account_info_iter)?;
+
+    // Mint & metadata checks on the original
+    let original_token_metadata = {
+        // 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 original_mint_data = original_mint_info.try_borrow_data()?;
+        let original_mint = StateWithExtensions::<Mint>::unpack(&original_mint_data)?;
+
+        // Make sure the metadata pointer is pointing to the mint itself
+        let metadata_pointer = original_mint.get_extension::<MetadataPointer>()?;
+        let metadata_pointer_address = Option::<Pubkey>::from(metadata_pointer.metadata_address);
+        if metadata_pointer_address != Some(*original_mint_info.key) {
+            return Err(ProgramError::InvalidAccountData);
+        }
+
+        // Extract the token metadata
+        original_mint.get_variable_len_extension::<TokenMetadata>()?
+    };
+
+    // Mint checks on the reprint
+    {
+        // 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 reprint_mint_data = reprint_mint_info.try_borrow_data()?;
+        let reprint_mint = StateWithExtensions::<Mint>::unpack(&reprint_mint_data)?;
+
+        if !reprint_mint_authority_info.is_signer {
+            return Err(ProgramError::MissingRequiredSignature);
+        }
+        if reprint_mint.base.mint_authority.as_ref()
+            != COption::Some(reprint_mint_authority_info.key)
+        {
+            return Err(TokenGroupError::IncorrectAuthority.into());
+        }
+
+        // Make sure the metadata pointer is pointing to the mint itself
+        let metadata_pointer = reprint_mint.get_extension::<MetadataPointer>()?;
+        let metadata_pointer_address = Option::<Pubkey>::from(metadata_pointer.metadata_address);
+        if metadata_pointer_address != Some(*reprint_mint_info.key) {
+            return Err(ProgramError::InvalidAccountData);
+        }
+    }
+
+    // Increment the size of the editions
+    let mut buffer = original_info.try_borrow_mut_data()?;
+    let mut state = TlvStateMut::unpack(&mut buffer)?;
+    let original = state.get_first_value_mut::<TokenGroup>()?;
+
+    check_update_authority(original_update_authority_info, &original.update_authority)?;
+    let reprint_number = original.increment_size()?;
+
+    // Allocate a TLV entry for the space and write it in
+    let mut buffer = reprint_info.try_borrow_mut_data()?;
+    let mut state = TlvStateMut::unpack(&mut buffer)?;
+    let (reprint, _) = state.init_value::<TokenGroupMember>(false)?;
+    *reprint = TokenGroupMember::new(*original_info.key, reprint_number);
+
+    // Use the original metadata to initialize the reprint metadata
+    let cpi_instruction = spl_token_metadata_interface::instruction::initialize(
+        &spl_token_2022::id(),
+        reprint_mint_info.key,
+        original_update_authority_info.key,
+        reprint_mint_info.key,
+        reprint_mint_authority_info.key,
+        original_token_metadata.name,
+        original_token_metadata.symbol,
+        original_token_metadata.uri,
+    );
+    let cpi_account_infos = &[
+        reprint_mint_info.clone(),
+        original_update_authority_info.clone(),
+        reprint_mint_info.clone(),
+        reprint_mint_authority_info.clone(),
+    ];
+    invoke(&cpi_instruction, cpi_account_infos)?;
+
+    Ok(())
+}
+
+/// Processes an `SplTokenGroupInstruction`
+pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> ProgramResult {
+    let instruction = TokenGroupInstruction::unpack(input)?;
+    match instruction {
+        TokenGroupInstruction::InitializeGroup(data) => {
+            msg!("Instruction: InitializeGroup");
+            process_initialize_group(program_id, accounts, data)
+        }
+        TokenGroupInstruction::UpdateGroupMaxSize(data) => {
+            msg!("Instruction: UpdateGroupMaxSize");
+            process_update_group_max_size(program_id, accounts, data)
+        }
+        TokenGroupInstruction::UpdateGroupAuthority(data) => {
+            msg!("Instruction: UpdateGroupAuthority");
+            process_update_group_authority(program_id, accounts, data)
+        }
+        TokenGroupInstruction::InitializeMember(_) => {
+            // For demonstration purposes, we'll use the number of accounts
+            // provided to determine which type of member to initialize.
+            if accounts.len() == 5 {
+                msg!("Instruction: InitializeMember");
+                process_initialize_member(program_id, accounts)
+            } else {
+                msg!("Instruction: InitializeEdition");
+                process_initialize_edition_reprint(program_id, accounts)
+            }
+        }
+    }
+}
diff --git a/token-group/example/tests/initialize_edition.rs b/token-group/example/tests/initialize_edition.rs
new file mode 100644
index 00000000000..262273ca9aa
--- /dev/null
+++ b/token-group/example/tests/initialize_edition.rs
@@ -0,0 +1,314 @@
+#![cfg(feature = "test-sbf")]
+
+mod setup;
+
+use {
+    setup::{setup_mint, setup_mint_and_metadata, setup_program_test},
+    solana_program::{
+        borsh0_10::get_instance_packed_len,
+        instruction::{AccountMeta, Instruction, InstructionError},
+        pubkey::Pubkey,
+        system_instruction,
+    },
+    solana_program_test::tokio,
+    solana_sdk::{
+        signature::Keypair,
+        signer::Signer,
+        transaction::{Transaction, TransactionError},
+    },
+    spl_token_2022::{
+        extension::{BaseStateWithExtensions, StateWithExtensions},
+        state::Mint,
+    },
+    spl_token_client::token::{ExtensionInitializationParams, Token},
+    spl_token_group_interface::{
+        instruction::{initialize_group, initialize_member},
+        state::{TokenGroup, TokenGroupMember},
+    },
+    spl_token_metadata_interface::state::TokenMetadata,
+    spl_type_length_value::state::{TlvState, TlvStateBorrowed},
+};
+
+fn initialize_edition_reprint(
+    program_id: &Pubkey,
+    reprint: &Pubkey,
+    reprint_mint: &Pubkey,
+    reprint_mint_authority: &Pubkey,
+    original: &Pubkey,
+    original_update_authority: &Pubkey,
+    original_mint: &Pubkey,
+) -> Instruction {
+    let mut ix = initialize_member(
+        program_id,
+        reprint,
+        reprint_mint,
+        reprint_mint_authority,
+        original,
+        original_update_authority,
+    );
+    // Our program requires the reprint mint to be writable
+    ix.accounts[1].is_writable = true;
+    ix.accounts.extend_from_slice(&[
+        AccountMeta::new_readonly(*original_mint, false),
+        AccountMeta::new_readonly(spl_token_2022::id(), false),
+    ]);
+    ix
+}
+
+#[tokio::test]
+async fn test_initialize_edition_reprint() {
+    let program_id = Pubkey::new_unique();
+    let original = Keypair::new();
+    let original_mint = Keypair::new();
+    let original_mint_authority = Keypair::new();
+    let original_update_authority = Keypair::new();
+    let reprint = Keypair::new();
+    let reprint_mint = Keypair::new();
+    let reprint_mint_authority = Keypair::new();
+
+    let original_metadata_state = TokenMetadata {
+        update_authority: None.try_into().unwrap(),
+        mint: original_mint.pubkey(),
+        name: "The Coolest Collection".to_string(),
+        symbol: "COOL".to_string(),
+        uri: "https://cool.com".to_string(),
+        additional_metadata: vec![],
+    };
+    let original_group_state = TokenGroup {
+        update_authority: Some(original_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(),
+            &original_mint.pubkey(),
+            Some(0),
+            payer.clone(),
+        ),
+        &original_mint,
+        &original_mint_authority,
+        &original_metadata_state,
+        payer.clone(),
+    )
+    .await;
+    // Add the metadata pointer extension ahead of time
+    setup_mint(
+        &Token::new(
+            client.clone(),
+            &spl_token_2022::id(),
+            &reprint_mint.pubkey(),
+            Some(0),
+            payer.clone(),
+        ),
+        &reprint_mint,
+        &reprint_mint_authority,
+        vec![ExtensionInitializationParams::MetadataPointer {
+            authority: Some(reprint_mint_authority.pubkey()),
+            metadata_address: Some(reprint_mint.pubkey()),
+        }],
+    )
+    .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::<TokenGroup>();
+    let rent_lamports = rent.minimum_balance(space);
+
+    let transaction = Transaction::new_signed_with_payer(
+        &[
+            system_instruction::create_account(
+                &context.payer.pubkey(),
+                &original.pubkey(),
+                rent_lamports,
+                space.try_into().unwrap(),
+                &program_id,
+            ),
+            initialize_group(
+                &program_id,
+                &original.pubkey(),
+                &original_mint.pubkey(),
+                &original_mint_authority.pubkey(),
+                original_group_state.update_authority.try_into().unwrap(),
+                original_group_state.max_size.into(),
+            ),
+        ],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &original_mint_authority, &original],
+        context.last_blockhash,
+    );
+    context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap();
+
+    let metadata_space = TlvStateBorrowed::get_base_len()
+        + get_instance_packed_len(&original_metadata_state).unwrap();
+    let metadata_rent_lamports = rent.minimum_balance(metadata_space);
+
+    let reprint_space = TlvStateBorrowed::get_base_len() + std::mem::size_of::<TokenGroupMember>();
+    let reprint_rent_lamports = rent.minimum_balance(reprint_space);
+
+    // Fail: reprint mint authority not signer
+    let mut init_reprint_ix = initialize_edition_reprint(
+        &program_id,
+        &reprint.pubkey(),
+        &reprint_mint.pubkey(),
+        &reprint_mint_authority.pubkey(),
+        &original.pubkey(),
+        &original_update_authority.pubkey(),
+        &original_mint.pubkey(),
+    );
+    init_reprint_ix.accounts[2].is_signer = false;
+    let transaction = Transaction::new_signed_with_payer(
+        &[
+            system_instruction::create_account(
+                &context.payer.pubkey(),
+                &reprint.pubkey(),
+                reprint_rent_lamports,
+                reprint_space.try_into().unwrap(),
+                &program_id,
+            ),
+            // Fund the mint with rent for metadata
+            system_instruction::transfer(
+                &context.payer.pubkey(),
+                &reprint_mint.pubkey(),
+                metadata_rent_lamports,
+            ),
+            init_reprint_ix,
+        ],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &reprint, &original_update_authority],
+        context.last_blockhash,
+    );
+    assert_eq!(
+        context
+            .banks_client
+            .process_transaction(transaction)
+            .await
+            .unwrap_err()
+            .unwrap(),
+        TransactionError::InstructionError(2, InstructionError::MissingRequiredSignature)
+    );
+
+    // Fail: group update authority not signer
+    let mut init_reprint_ix = initialize_edition_reprint(
+        &program_id,
+        &reprint.pubkey(),
+        &reprint_mint.pubkey(),
+        &reprint_mint_authority.pubkey(),
+        &original.pubkey(),
+        &original_update_authority.pubkey(),
+        &original_mint.pubkey(),
+    );
+    init_reprint_ix.accounts[4].is_signer = false;
+    let transaction = Transaction::new_signed_with_payer(
+        &[
+            system_instruction::create_account(
+                &context.payer.pubkey(),
+                &reprint.pubkey(),
+                reprint_rent_lamports,
+                reprint_space.try_into().unwrap(),
+                &program_id,
+            ),
+            // Fund the mint with rent for metadata
+            system_instruction::transfer(
+                &context.payer.pubkey(),
+                &reprint_mint.pubkey(),
+                metadata_rent_lamports,
+            ),
+            init_reprint_ix,
+        ],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &reprint, &reprint_mint_authority],
+        context.last_blockhash,
+    );
+    assert_eq!(
+        context
+            .banks_client
+            .process_transaction(transaction)
+            .await
+            .unwrap_err()
+            .unwrap(),
+        TransactionError::InstructionError(2, InstructionError::MissingRequiredSignature)
+    );
+
+    // Success: initialize edition reprint
+    let transaction = Transaction::new_signed_with_payer(
+        &[
+            system_instruction::create_account(
+                &context.payer.pubkey(),
+                &reprint.pubkey(),
+                reprint_rent_lamports,
+                reprint_space.try_into().unwrap(),
+                &program_id,
+            ),
+            // Fund the mint with rent for metadata
+            system_instruction::transfer(
+                &context.payer.pubkey(),
+                &reprint_mint.pubkey(),
+                metadata_rent_lamports,
+            ),
+            initialize_edition_reprint(
+                &program_id,
+                &reprint.pubkey(),
+                &reprint_mint.pubkey(),
+                &reprint_mint_authority.pubkey(),
+                &original.pubkey(),
+                &original_update_authority.pubkey(),
+                &original_mint.pubkey(),
+            ),
+        ],
+        Some(&context.payer.pubkey()),
+        &[
+            &context.payer,
+            &reprint,
+            &reprint_mint_authority,
+            &original_update_authority,
+        ],
+        context.last_blockhash,
+    );
+    context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap();
+
+    // Fetch the reprint account and ensure it matches our state
+    let reprint_account = context
+        .banks_client
+        .get_account(reprint.pubkey())
+        .await
+        .unwrap()
+        .unwrap();
+    let fetched_meta = TlvStateBorrowed::unpack(&reprint_account.data).unwrap();
+    let fetched_original_reprint_state =
+        fetched_meta.get_first_value::<TokenGroupMember>().unwrap();
+    assert_eq!(fetched_original_reprint_state.group, original.pubkey());
+    assert_eq!(u32::from(fetched_original_reprint_state.member_number), 1);
+
+    // Fetch the reprint's metadata and ensure it matches our original
+    let reprint_mint_account = context
+        .banks_client
+        .get_account(reprint_mint.pubkey())
+        .await
+        .unwrap()
+        .unwrap();
+    let fetched_reprint_meta =
+        StateWithExtensions::<Mint>::unpack(&reprint_mint_account.data).unwrap();
+    let fetched_reprint_metadata = fetched_reprint_meta
+        .get_variable_len_extension::<TokenMetadata>()
+        .unwrap();
+    assert_eq!(fetched_reprint_metadata.name, original_metadata_state.name);
+    assert_eq!(
+        fetched_reprint_metadata.symbol,
+        original_metadata_state.symbol
+    );
+    assert_eq!(fetched_reprint_metadata.uri, original_metadata_state.uri);
+}
diff --git a/token-group/example/tests/initialize_group.rs b/token-group/example/tests/initialize_group.rs
new file mode 100644
index 00000000000..a1ef3d71e0c
--- /dev/null
+++ b/token-group/example/tests/initialize_group.rs
@@ -0,0 +1,159 @@
+#![cfg(feature = "test-sbf")]
+
+mod setup;
+
+use {
+    setup::{setup_mint, 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, state::TokenGroup},
+    spl_type_length_value::{
+        error::TlvError,
+        state::{TlvState, TlvStateBorrowed},
+    },
+};
+
+#[tokio::test]
+async fn test_initialize_group() {
+    let program_id = Pubkey::new_unique();
+    let group = Keypair::new();
+    let group_mint = Keypair::new();
+    let group_mint_authority = Keypair::new();
+
+    let group_state = TokenGroup {
+        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(),
+        &group_mint.pubkey(),
+        Some(0),
+        payer.clone(),
+    );
+    setup_mint(
+        &token_client,
+        &group_mint,
+        &group_mint_authority,
+        vec![],
+    )
+    .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::<TokenGroup>();
+    let rent_lamports = rent.minimum_balance(space);
+
+    // Fail: mint authority not signer
+    let mut init_group_ix = initialize_group(
+        &program_id,
+        &group.pubkey(),
+        &group_mint.pubkey(),
+        &group_mint_authority.pubkey(),
+        group_state.update_authority.try_into().unwrap(),
+        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(),
+                &group.pubkey(),
+                rent_lamports,
+                space.try_into().unwrap(),
+                &program_id,
+            ),
+            init_group_ix,
+        ],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group],
+        context.last_blockhash,
+    );
+    assert_eq!(
+        context
+            .banks_client
+            .process_transaction(transaction)
+            .await
+            .unwrap_err()
+            .unwrap(),
+        TransactionError::InstructionError(1, InstructionError::MissingRequiredSignature)
+    );
+
+    // Success: create the group
+    let transaction = Transaction::new_signed_with_payer(
+        &[
+            system_instruction::create_account(
+                &context.payer.pubkey(),
+                &group.pubkey(),
+                rent_lamports,
+                space.try_into().unwrap(),
+                &program_id,
+            ),
+            initialize_group(
+                &program_id,
+                &group.pubkey(),
+                &group_mint.pubkey(),
+                &group_mint_authority.pubkey(),
+                group_state.update_authority.try_into().unwrap(),
+                group_state.max_size.into(),
+            ),
+        ],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group_mint_authority, &group],
+        context.last_blockhash,
+    );
+    context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap();
+
+    // Fetch the group account and ensure it matches our state
+    let fetched_group_account = context
+        .banks_client
+        .get_account(group.pubkey())
+        .await
+        .unwrap()
+        .unwrap();
+    let fetched_meta = TlvStateBorrowed::unpack(&fetched_group_account.data).unwrap();
+    let fetched_group_state = fetched_meta.get_first_value::<TokenGroup>().unwrap();
+    assert_eq!(fetched_group_state, &group_state);
+
+    // Fail: can't initialize twice
+    let transaction = Transaction::new_signed_with_payer(
+        &[initialize_group(
+            &program_id,
+            &group.pubkey(),
+            &group_mint.pubkey(),
+            &group_mint_authority.pubkey(),
+            Pubkey::new_unique().into(), // Intentionally changed
+            group_state.max_size.into(),
+        )],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group_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_member.rs b/token-group/example/tests/initialize_member.rs
new file mode 100644
index 00000000000..1088e1b0626
--- /dev/null
+++ b/token-group/example/tests/initialize_member.rs
@@ -0,0 +1,220 @@
+#![cfg(feature = "test-sbf")]
+
+mod setup;
+
+use {
+    setup::{setup_mint, 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::{TokenGroup, TokenGroupMember},
+    },
+    spl_type_length_value::state::{TlvState, TlvStateBorrowed},
+};
+
+#[tokio::test]
+async fn test_initialize_group_member() {
+    let program_id = Pubkey::new_unique();
+    let group = Keypair::new();
+    let group_mint = Keypair::new();
+    let group_mint_authority = Keypair::new();
+    let group_update_authority = Keypair::new();
+    let member = Keypair::new();
+    let member_mint = Keypair::new();
+    let member_mint_authority = Keypair::new();
+
+    let group_state = TokenGroup {
+        update_authority: Some(group_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(
+        &Token::new(
+            client.clone(),
+            &spl_token_2022::id(),
+            &group_mint.pubkey(),
+            Some(0),
+            payer.clone(),
+        ),
+        &group_mint,
+        &group_mint_authority,
+        vec![],
+    )
+    .await;
+    setup_mint(
+        &Token::new(
+            client.clone(),
+            &spl_token_2022::id(),
+            &member_mint.pubkey(),
+            Some(0),
+            payer.clone(),
+        ),
+        &member_mint,
+        &member_mint_authority,
+        vec![],
+    )
+    .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::<TokenGroup>();
+    let rent_lamports = rent.minimum_balance(space);
+
+    let transaction = Transaction::new_signed_with_payer(
+        &[
+            system_instruction::create_account(
+                &context.payer.pubkey(),
+                &group.pubkey(),
+                rent_lamports,
+                space.try_into().unwrap(),
+                &program_id,
+            ),
+            initialize_group(
+                &program_id,
+                &group.pubkey(),
+                &group_mint.pubkey(),
+                &group_mint_authority.pubkey(),
+                group_state.update_authority.try_into().unwrap(),
+                group_state.max_size.into(),
+            ),
+        ],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group_mint_authority, &group],
+        context.last_blockhash,
+    );
+    context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap();
+
+    let member_space = TlvStateBorrowed::get_base_len() + std::mem::size_of::<TokenGroupMember>();
+    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(),
+        &group.pubkey(),
+        &group_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, &group_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(),
+        &group.pubkey(),
+        &group_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(),
+                &group.pubkey(),
+                &group_update_authority.pubkey(),
+            ),
+        ],
+        Some(&context.payer.pubkey()),
+        &[
+            &context.payer,
+            &member,
+            &member_mint_authority,
+            &group_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_group_member_state = fetched_meta.get_first_value::<TokenGroupMember>().unwrap();
+    assert_eq!(fetched_group_member_state.group, group.pubkey());
+    assert_eq!(u32::from(fetched_group_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..73187287f39
--- /dev/null
+++ b/token-group/example/tests/setup.rs
@@ -0,0 +1,101 @@
+#![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<Mutex<ProgramTestContext>>,
+    Arc<dyn ProgramClient<ProgramBanksClientProcessTransaction>>,
+    Arc<Keypair>,
+) {
+    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<dyn ProgramClient<ProgramBanksClientProcessTransaction>> =
+        Arc::new(ProgramBanksClient::new_from_context(
+            Arc::clone(&context),
+            ProgramBanksClientProcessTransaction,
+        ));
+    (context, client, payer)
+}
+
+/// Set up a Token-2022 mint
+pub async fn setup_mint<T: SendTransaction + SimulateTransaction>(
+    token_client: &Token<T>,
+    mint_keypair: &Keypair,
+    mint_authority_keypair: &Keypair,
+    extensions: Vec<ExtensionInitializationParams>,
+) {
+    token_client
+        .create_mint(
+            &mint_authority_keypair.pubkey(),
+            None,
+            extensions,
+            &[mint_keypair],
+        )
+        .await
+        .unwrap();
+}
+
+/// Set up a Token-2022 mint and metadata
+///
+/// Note: Not every test uses this function, so we need to ignore the
+/// lint warning.
+#[allow(dead_code)]
+pub async fn setup_mint_and_metadata<T: SendTransaction + SimulateTransaction>(
+    token_client: &Token<T>,
+    mint_keypair: &Keypair,
+    mint_authority_keypair: &Keypair,
+    token_metadata: &TokenMetadata,
+    payer: Arc<Keypair>,
+) {
+    token_client
+        .create_mint(
+            &mint_authority_keypair.pubkey(),
+            None,
+            vec![ExtensionInitializationParams::MetadataPointer {
+                authority: Some(mint_authority_keypair.pubkey()),
+                metadata_address: Some(mint_keypair.pubkey()),
+            }],
+            &[mint_keypair],
+        )
+        .await
+        .unwrap();
+    token_client
+        .token_metadata_initialize_with_rent_transfer(
+            &payer.pubkey(),
+            &mint_authority_keypair.pubkey(), // Also the metadata update authority
+            &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_group_authority.rs b/token-group/example/tests/update_group_authority.rs
new file mode 100644
index 00000000000..1f578cb27de
--- /dev/null
+++ b/token-group/example/tests/update_group_authority.rs
@@ -0,0 +1,193 @@
+#![cfg(feature = "test-sbf")]
+
+mod setup;
+
+use {
+    setup::{setup_mint, 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::TokenGroup,
+    },
+    spl_type_length_value::state::{TlvState, TlvStateBorrowed},
+};
+
+#[tokio::test]
+async fn test_update_group_authority() {
+    let program_id = Pubkey::new_unique();
+    let group = Keypair::new();
+    let group_mint = Keypair::new();
+    let group_mint_authority = Keypair::new();
+    let group_update_authority = Keypair::new();
+
+    let group_state = TokenGroup {
+        update_authority: Some(group_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(),
+        &group_mint.pubkey(),
+        Some(0),
+        payer.clone(),
+    );
+    setup_mint(
+        &token_client,
+        &group_mint,
+        &group_mint_authority,
+        vec![],
+    )
+    .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::<TokenGroup>();
+    let rent_lamports = rent.minimum_balance(space);
+
+    let transaction = Transaction::new_signed_with_payer(
+        &[
+            system_instruction::create_account(
+                &context.payer.pubkey(),
+                &group.pubkey(),
+                rent_lamports,
+                space.try_into().unwrap(),
+                &program_id,
+            ),
+            initialize_group(
+                &program_id,
+                &group.pubkey(),
+                &group_mint.pubkey(),
+                &group_mint_authority.pubkey(),
+                group_state.update_authority.try_into().unwrap(),
+                group_state.max_size.into(),
+            ),
+        ],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group_mint_authority, &group],
+        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,
+        &group.pubkey(),
+        &group_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,
+            &group.pubkey(),
+            &group.pubkey(),
+            None,
+        )],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group],
+        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,
+            &group.pubkey(),
+            &group_update_authority.pubkey(),
+            None,
+        )],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group_update_authority],
+        context.last_blockhash,
+    );
+    context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap();
+
+    // Fetch the account and assert the new authority
+    let fetched_group_account = context
+        .banks_client
+        .get_account(group.pubkey())
+        .await
+        .unwrap()
+        .unwrap();
+    let fetched_meta = TlvStateBorrowed::unpack(&fetched_group_account.data).unwrap();
+    let fetched_group_state = fetched_meta.get_first_value::<TokenGroup>().unwrap();
+    assert_eq!(
+        fetched_group_state.update_authority,
+        None.try_into().unwrap(),
+    );
+
+    // Fail: immutable group
+    let transaction = Transaction::new_signed_with_payer(
+        &[update_group_authority(
+            &program_id,
+            &group.pubkey(),
+            &group_update_authority.pubkey(),
+            Some(group_update_authority.pubkey()),
+        )],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group_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_group_max_size.rs b/token-group/example/tests/update_group_max_size.rs
new file mode 100644
index 00000000000..978c9000d98
--- /dev/null
+++ b/token-group/example/tests/update_group_max_size.rs
@@ -0,0 +1,295 @@
+#![cfg(feature = "test-sbf")]
+
+mod setup;
+
+use {
+    setup::{setup_mint, 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::TokenGroup,
+    },
+    spl_type_length_value::state::{TlvState, TlvStateBorrowed, TlvStateMut},
+};
+
+#[tokio::test]
+async fn test_update_group_max_size() {
+    let program_id = Pubkey::new_unique();
+    let group = Keypair::new();
+    let group_mint = Keypair::new();
+    let group_mint_authority = Keypair::new();
+    let group_update_authority = Keypair::new();
+
+    let group_state = TokenGroup {
+        update_authority: Some(group_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(),
+        &group_mint.pubkey(),
+        Some(0),
+        payer.clone(),
+    );
+    setup_mint(
+        &token_client,
+        &group_mint,
+        &group_mint_authority,
+        vec![],
+    )
+    .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::<TokenGroup>();
+    let rent_lamports = rent.minimum_balance(space);
+
+    let transaction = Transaction::new_signed_with_payer(
+        &[
+            system_instruction::create_account(
+                &context.payer.pubkey(),
+                &group.pubkey(),
+                rent_lamports,
+                space.try_into().unwrap(),
+                &program_id,
+            ),
+            initialize_group(
+                &program_id,
+                &group.pubkey(),
+                &group_mint.pubkey(),
+                &group_mint_authority.pubkey(),
+                group_state.update_authority.try_into().unwrap(),
+                group_state.max_size.into(),
+            ),
+        ],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group_mint_authority, &group],
+        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, &group.pubkey(), &group.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,
+            &group.pubkey(),
+            &group.pubkey(),
+            100,
+        )],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group],
+        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_group_account = context
+        .banks_client
+        .get_account(group.pubkey())
+        .await
+        .unwrap()
+        .unwrap();
+    let mut data = fetched_group_account.data;
+    let mut state = TlvStateMut::unpack(&mut data).unwrap();
+    let group_data = state.get_first_value_mut::<TokenGroup>().unwrap();
+    group_data.size = 30.into();
+    context.set_account(
+        &group.pubkey(),
+        &SolanaAccount {
+            data,
+            ..fetched_group_account
+        }
+        .into(),
+    );
+    let transaction = Transaction::new_signed_with_payer(
+        &[update_group_max_size(
+            &program_id,
+            &group.pubkey(),
+            &group_update_authority.pubkey(),
+            20,
+        )],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group_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,
+            &group.pubkey(),
+            &group_update_authority.pubkey(),
+            100,
+        )],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group_update_authority],
+        context.last_blockhash,
+    );
+    context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap();
+
+    // Fetch the account and assert the new max size
+    let fetched_group_account = context
+        .banks_client
+        .get_account(group.pubkey())
+        .await
+        .unwrap()
+        .unwrap();
+    let fetched_meta = TlvStateBorrowed::unpack(&fetched_group_account.data).unwrap();
+    let fetched_group_state = fetched_meta.get_first_value::<TokenGroup>().unwrap();
+    assert_eq!(fetched_group_state.max_size, 100.into());
+}
+
+// Fail: immutable group
+#[tokio::test]
+async fn test_update_group_max_size_fail_immutable_group() {
+    let program_id = Pubkey::new_unique();
+    let group = Keypair::new();
+    let group_mint = Keypair::new();
+    let group_mint_authority = Keypair::new();
+    let group_update_authority = Keypair::new();
+
+    let group_state = TokenGroup {
+        update_authority: Some(group_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(),
+        &group_mint.pubkey(),
+        Some(0),
+        payer.clone(),
+    );
+    setup_mint(
+        &token_client,
+        &group_mint,
+        &group_mint_authority,
+        vec![],
+    )
+    .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::<TokenGroup>();
+    let rent_lamports = rent.minimum_balance(space);
+
+    let transaction = Transaction::new_signed_with_payer(
+        &[
+            system_instruction::create_account(
+                &context.payer.pubkey(),
+                &group.pubkey(),
+                rent_lamports,
+                space.try_into().unwrap(),
+                &program_id,
+            ),
+            initialize_group(
+                &program_id,
+                &group.pubkey(),
+                &group_mint.pubkey(),
+                &group_mint_authority.pubkey(),
+                None,
+                group_state.max_size.into(),
+            ),
+        ],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group_mint_authority, &group],
+        context.last_blockhash,
+    );
+    context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap();
+
+    let transaction = Transaction::new_signed_with_payer(
+        &[update_group_max_size(
+            &program_id,
+            &group.pubkey(),
+            &group_update_authority.pubkey(),
+            100,
+        )],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &group_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,
 }