Change max size to u64 in interface

Author: jacksondoherty

token-group/interface/README.md

@@ -95,7 +95,7 @@ For a group:
 
 ```rust
 type OptionalNonZeroPubkey = Pubkey; // if all zeroes, interpreted as `None`
-type PodU32 = [u8; 4];
+type PodU64 = [u8; 8];
 type Pubkey = [u8; 32];
 
 /// Type discriminant: [214, 15, 63, 132, 49, 119, 209, 40]
@@ -107,9 +107,9 @@ pub struct TokenGroup {
     /// belongs to a particular mint
     pub mint: Pubkey,
     /// The current number of group members
-    pub size: PodU32,
+    pub size: PodU64,
     /// The maximum number of group members
-    pub max_size: PodU32,
+    pub max_size: PodU64,
 }
 ```
 
@@ -125,7 +125,7 @@ pub struct TokenGroupMember {
     /// The pubkey of the `TokenGroup`
     pub group: Pubkey,
     /// The member number
-    pub member_number: PodU32,
+    pub member_number: PodU64,
 }
 ```
 

token-group/interface/src/instruction.rs

@@ -11,7 +11,7 @@ use {
     spl_pod::{
         bytemuck::{pod_bytes_of, pod_from_bytes},
         optional_keys::OptionalNonZeroPubkey,
-        primitives::PodU32,
+        primitives::PodU64,
     },
 };
 
@@ -23,7 +23,7 @@ pub struct InitializeGroup {
     /// Update authority for the group
     pub update_authority: OptionalNonZeroPubkey,
     /// The maximum number of group members
-    pub max_size: PodU32,
+    pub max_size: PodU64,
 }
 
 /// Instruction data for updating the max size of a `Group`
@@ -32,7 +32,7 @@ pub struct InitializeGroup {
 #[discriminator_hash_input("spl_token_group_interface:update_group_max_size")]
 pub struct UpdateGroupMaxSize {
     /// New max size for the group
-    pub max_size: PodU32,
+    pub max_size: PodU64,
 }
 
 /// Instruction data for updating the authority of a `Group`
@@ -155,7 +155,7 @@ pub fn initialize_group(
     mint: &Pubkey,
     mint_authority: &Pubkey,
     update_authority: Option<Pubkey>,
-    max_size: u32,
+    max_size: u64,
 ) -> Instruction {
     let update_authority = OptionalNonZeroPubkey::try_from(update_authority)
         .expect("Failed to deserialize `Option<Pubkey>`");
@@ -180,7 +180,7 @@ pub fn update_group_max_size(
     program_id: &Pubkey,
     group: &Pubkey,
     update_authority: &Pubkey,
-    max_size: u32,
+    max_size: u64,
 ) -> Instruction {
     let data = TokenGroupInstruction::UpdateGroupMaxSize(UpdateGroupMaxSize {
         max_size: max_size.into(),

token-group/interface/src/state.rs

@@ -5,7 +5,7 @@ use {
     bytemuck::{Pod, Zeroable},
     solana_program::{program_error::ProgramError, pubkey::Pubkey},
     spl_discriminator::SplDiscriminate,
-    spl_pod::{error::PodSliceError, optional_keys::OptionalNonZeroPubkey, primitives::PodU32},
+    spl_pod::{error::PodSliceError, optional_keys::OptionalNonZeroPubkey, primitives::PodU64},
 };
 
 /// Data struct for a `TokenGroup`
@@ -19,39 +19,39 @@ pub struct TokenGroup {
     /// belongs to a particular mint
     pub mint: Pubkey,
     /// The current number of group members
-    pub size: PodU32,
+    pub size: PodU64,
     /// The maximum number of group members
-    pub max_size: PodU32,
+    pub max_size: PodU64,
 }
 
 impl TokenGroup {
     /// Creates a new `TokenGroup` state
-    pub fn new(mint: &Pubkey, update_authority: OptionalNonZeroPubkey, max_size: u32) -> Self {
+    pub fn new(mint: &Pubkey, update_authority: OptionalNonZeroPubkey, max_size: u64) -> Self {
         Self {
             mint: *mint,
             update_authority,
-            size: PodU32::default(), // [0, 0, 0, 0]
+            size: PodU64::default(), // [0, 0, 0, 0, 0, 0, 0, 0]
             max_size: max_size.into(),
         }
     }
 
     /// Updates the max size for a group
-    pub fn update_max_size(&mut self, new_max_size: u32) -> Result<(), ProgramError> {
+    pub fn update_max_size(&mut self, new_max_size: u64) -> Result<(), ProgramError> {
         // The new max size cannot be less than the current size
-        if new_max_size < u32::from(self.size) {
+        if new_max_size < u64::from(self.size) {
             return Err(TokenGroupError::SizeExceedsNewMaxSize.into());
         }
         self.max_size = new_max_size.into();
         Ok(())
     }
 
     /// Increment the size for a group, returning the new size
-    pub fn increment_size(&mut self) -> Result<u32, ProgramError> {
+    pub fn increment_size(&mut self) -> Result<u64, ProgramError> {
         // The new size cannot be greater than the max size
-        let new_size = u32::from(self.size)
+        let new_size = u64::from(self.size)
             .checked_add(1)
             .ok_or::<ProgramError>(PodSliceError::CalculationFailure.into())?;
-        if new_size > u32::from(self.max_size) {
+        if new_size > u64::from(self.max_size) {
             return Err(TokenGroupError::SizeExceedsMaxSize.into());
         }
         self.size = new_size.into();
@@ -70,11 +70,11 @@ pub struct TokenGroupMember {
     /// The pubkey of the `TokenGroup`
     pub group: Pubkey,
     /// The member number
-    pub member_number: PodU32,
+    pub member_number: PodU64,
 }
 impl TokenGroupMember {
     /// Creates a new `TokenGroupMember` state
-    pub fn new(mint: &Pubkey, group: &Pubkey, member_number: u32) -> Self {
+    pub fn new(mint: &Pubkey, group: &Pubkey, member_number: u64) -> Self {
         Self {
             mint: *mint,
             group: *group,
@@ -156,7 +156,7 @@ mod tests {
 
         let new_max_size = 30;
         group.update_max_size(new_max_size).unwrap();
-        assert_eq!(u32::from(group.max_size), new_max_size);
+        assert_eq!(u64::from(group.max_size), new_max_size);
 
         // Change the current size to 30
         group.size = 30.into();
@@ -170,7 +170,7 @@ mod tests {
 
         let new_max_size = 30;
         group.update_max_size(new_max_size).unwrap();
-        assert_eq!(u32::from(group.max_size), new_max_size);
+        assert_eq!(u64::from(group.max_size), new_max_size);
     }
 
     #[test]
@@ -183,7 +183,7 @@ mod tests {
         };
 
         group.increment_size().unwrap();
-        assert_eq!(u32::from(group.size), 1);
+        assert_eq!(u64::from(group.size), 1);
 
         // Try to increase the current size to 2, which is greater than the max size
         assert_eq!(