adapt to zero copy refactor & fix tests

Author: ananas-block

program-libs/compressed-account/src/compressed_account.rs

@@ -12,6 +12,7 @@ use crate::{
     AnchorDeserialize, AnchorSerialize, CompressedAccountError, Pubkey, TreeType,
 };
 
+#[repr(C)]
 #[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopyMut)]
 pub struct PackedCompressedAccountWithMerkleContext {
     pub compressed_account: CompressedAccount,
@@ -134,6 +135,7 @@ pub struct ReadOnlyCompressedAccount {
     pub root_index: u16,
 }
 
+#[repr(C)]
 #[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopyMut)]
 pub struct PackedReadOnlyCompressedAccount {
     pub account_hash: [u8; 32],
@@ -150,6 +152,7 @@ pub struct MerkleContext {
     pub tree_type: TreeType,
 }
 
+#[repr(C)]
 #[derive(
     Debug,
     Clone,
@@ -228,6 +231,7 @@ pub fn pack_merkle_context(
         .collect::<Vec<_>>()
 }
 
+#[repr(C)]
 #[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopyMut)]
 pub struct CompressedAccount {
     pub owner: Pubkey,
@@ -245,6 +249,7 @@ pub struct InCompressedAccount {
     pub address: Option<[u8; 32]>,
 }
 
+#[repr(C)]
 #[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopyMut)]
 pub struct CompressedAccountData {
     pub discriminator: [u8; 8],

program-libs/compressed-account/src/instruction_data/cpi_context.rs

@@ -7,6 +7,7 @@ use crate::{
     AnchorDeserialize, AnchorSerialize,
 };
 
+#[repr(C)]
 #[derive(
     AnchorSerialize, AnchorDeserialize, Debug, Clone, Copy, PartialEq, Eq, Default, ZeroCopyMut,
 )]

program-libs/compressed-account/src/instruction_data/data.rs

@@ -26,12 +26,14 @@ pub struct OutputCompressedAccountWithContext {
     pub merkle_tree: Pubkey,
 }
 
+#[repr(C)]
 #[derive(Debug, PartialEq, Default, Clone, AnchorDeserialize, AnchorSerialize, ZeroCopyMut)]
 pub struct OutputCompressedAccountWithPackedContext {
     pub compressed_account: CompressedAccount,
     pub merkle_tree_index: u8,
 }
 
+#[repr(C)]
 #[derive(
     Debug, PartialEq, Default, Clone, Copy, AnchorDeserialize, AnchorSerialize, ZeroCopyMut,
 )]
@@ -42,6 +44,7 @@ pub struct NewAddressParamsPacked {
     pub address_merkle_tree_root_index: u16,
 }
 
+#[repr(C)]
 #[derive(
     Debug, PartialEq, Default, Clone, Copy, AnchorDeserialize, AnchorSerialize, ZeroCopyMut,
 )]
@@ -92,6 +95,7 @@ pub struct NewAddressParamsAssigned {
     pub assigned_account_index: Option<u8>,
 }
 
+#[repr(C)]
 #[derive(
     Debug, PartialEq, Default, Clone, Copy, AnchorDeserialize, AnchorSerialize, ZeroCopyMut,
 )]

program-libs/compressed-account/src/instruction_data/with_readonly.rs

@@ -1,6 +1,8 @@
 use std::ops::Deref;
 
-use light_zero_copy::{errors::ZeroCopyError, slice::ZeroCopySliceBorsh, traits::ZeroCopyAt, ZeroCopyMut};
+use light_zero_copy::{
+    errors::ZeroCopyError, slice::ZeroCopySliceBorsh, traits::ZeroCopyAt, ZeroCopyMut,
+};
 use zerocopy::{
     little_endian::{U16, U32, U64},
     FromBytes, Immutable, IntoBytes, KnownLayout, Ref, Unaligned,
@@ -30,6 +32,7 @@ use crate::{
     AnchorDeserialize, AnchorSerialize, CompressedAccountError,
 };
 
+#[repr(C)]
 #[derive(Debug, Default, PartialEq, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopyMut)]
 pub struct InAccount {
     pub discriminator: [u8; 8],
@@ -193,6 +196,7 @@ impl<'a> Deref for ZInAccount<'a> {
     }
 }
 
+#[repr(C)]
 #[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopyMut)]
 pub struct InstructionDataInvokeCpiWithReadOnly {
     /// 0 With program ids

program-libs/compressed-account/src/instruction_data/zero_copy_set.rs

@@ -1,4 +1,4 @@
-use light_zero_copy::borsh::Deserialize;
+use light_zero_copy::traits::ZeroCopyAt;
 use zerocopy::little_endian::U16;
 
 use crate::{
@@ -53,7 +53,7 @@ impl ZInAccountMut<'_> {
         &mut self,
         discriminator: [u8; 8],
         data_hash: [u8; 32],
-        merkle_context: &<PackedMerkleContext as Deserialize>::Output,
+        merkle_context: &<PackedMerkleContext as ZeroCopyAt>::ZeroCopyAt,
         root_index: U16,
         lamports: u64,
         address: Option<&[u8]>,
@@ -126,7 +126,7 @@ impl ZInstructionDataInvokeCpiWithReadOnlyMut<'_> {
         &mut self,
         bump: u8,
         invoking_program_id: &Pubkey,
-        input_proof: Option<<CompressedProof as Deserialize>::Output>,
+        input_proof: Option<<CompressedProof as ZeroCopyAt>::ZeroCopyAt>,
         cpi_context: &Option<impl CompressedCpiContextTrait>,
     ) -> Result<(), CompressedAccountError> {
         self.mode = 1; // Small ix mode

program-libs/compressed-account/src/pubkey.rs

@@ -1,6 +1,6 @@
 #[cfg(feature = "bytemuck-des")]
 use bytemuck::{Pod, Zeroable};
-use light_zero_copy::{errors::ZeroCopyError, traits::ZeroCopyAt};
+use light_zero_copy::{errors::ZeroCopyError, traits::{ZeroCopyAt, ZeroCopyAtMut, ZeroCopyStructInner, ZeroCopyStructInnerMut}, ZeroCopyNew};
 use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout, Ref, Unaligned};
 
 use crate::{AnchorDeserialize, AnchorSerialize};
@@ -48,16 +48,15 @@ pub struct Pubkey(pub(crate) [u8; 32]);
 
 impl<'a> ZeroCopyNew<'a> for Pubkey {
     type ZeroCopyConfig = ();
-    type Output = zerocopy::Ref<&'a mut [u8], Pubkey>;
-    fn byte_len(_config: &Self::ZeroCopyConfig) -> usize {
-        32
+    type Output = <Self as ZeroCopyAtMut<'a>>::ZeroCopyAtMut;
+    fn byte_len(_config: &Self::ZeroCopyConfig) -> Result<usize, ZeroCopyError> {
+        Ok(32)
     }
     fn new_zero_copy(
         bytes: &'a mut [u8],
         _config: Self::ZeroCopyConfig,
     ) -> Result<(Self::Output, &'a mut [u8]), ZeroCopyError> {
-        let (key, rest) = zerocopy::Ref::from_prefix(bytes)?;
-        Ok((key, rest))
+        <Self as ZeroCopyAtMut<'a>>::zero_copy_at_mut(bytes)
     }
 }
 
@@ -107,13 +106,13 @@ impl<'a> ZeroCopyAt<'a> for Pubkey {
     }
 }
 
-impl<'a> DeserializeMut<'a> for Pubkey {
-    type Output = Ref<&'a mut [u8], Pubkey>;
+impl<'a> ZeroCopyAtMut<'a> for Pubkey {
+    type ZeroCopyAtMut = Ref<&'a mut [u8], Pubkey>;
 
     #[inline]
     fn zero_copy_at_mut(
         bytes: &'a mut [u8],
-    ) -> Result<(Self::Output, &'a mut [u8]), ZeroCopyError> {
+    ) -> Result<(Self::ZeroCopyAtMut, &'a mut [u8]), ZeroCopyError> {
         Ok(Ref::<&mut [u8], Pubkey>::from_prefix(bytes)?)
     }
 }

program-libs/ctoken-types/src/instructions/create_associated_token_account.rs

@@ -6,6 +6,7 @@ use crate::{
     AnchorDeserialize, AnchorSerialize,
 };
 
+#[repr(C)]
 #[derive(Debug, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopy)]
 pub struct CreateAssociatedTokenAccountInstructionData {
     /// The owner of the associated token account

program-libs/ctoken-types/src/instructions/create_compressed_mint.rs

@@ -12,6 +12,7 @@ use crate::{
     AnchorDeserialize, AnchorSerialize, CTokenError,
 };
 
+#[repr(C)]
 #[derive(Debug, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopy)]
 pub struct CreateCompressedMintInstructionData {
     pub decimals: u8,
@@ -29,6 +30,7 @@ pub struct CreateCompressedMintInstructionData {
     pub proof: Option<CompressedProof>,
 }
 
+#[repr(C)]
 #[derive(Debug, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopy)]
 pub struct CompressedMintWithContext {
     pub leaf_index: u32,
@@ -38,6 +40,7 @@ pub struct CompressedMintWithContext {
     pub mint: CompressedMintInstructionData,
 }
 
+#[repr(C)]
 #[derive(Debug, PartialEq, Eq, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopy)]
 pub struct CompressedMintInstructionData {
     /// Version for upgradability
@@ -109,6 +112,7 @@ impl TryFrom<CompressedMint> for CompressedMintInstructionData {
         })
     }
 }
+#[repr(C)]
 #[derive(
     Debug, Clone, PartialEq, Eq, AnchorSerialize, AnchorDeserialize, ZeroCopy, ZeroCopyMut,
 )]

program-libs/ctoken-types/src/instructions/create_spl_mint.rs

@@ -6,6 +6,7 @@ use crate::{
     AnchorSerialize,
 };
 
+#[repr(C)]
 #[derive(ZeroCopy, AnchorDeserialize, AnchorSerialize, Clone, Debug)]
 pub struct CreateSplMintInstructionData {
     pub mint_bump: u8,

program-libs/ctoken-types/src/instructions/extensions/mod.rs

@@ -126,12 +126,12 @@ impl ZExtensionInstructionData<'_> {
 }
 
 // Manual implementation of zero-copy traits for ExtensionInstructionData
-impl<'a> light_zero_copy::borsh::Deserialize<'a> for ExtensionInstructionData {
-    type Output = ZExtensionInstructionData<'a>;
+impl<'a> light_zero_copy::traits::ZeroCopyAt<'a> for ExtensionInstructionData {
+    type ZeroCopyAt = ZExtensionInstructionData<'a>;
 
     fn zero_copy_at(
         data: &'a [u8],
-    ) -> Result<(Self::Output, &'a [u8]), light_zero_copy::errors::ZeroCopyError> {
+    ) -> Result<(Self::ZeroCopyAt, &'a [u8]), light_zero_copy::errors::ZeroCopyError> {
         // Read discriminant (first 1 byte for borsh enum)
         if data.is_empty() {
             return Err(light_zero_copy::errors::ZeroCopyError::ArraySize(