feat: add zero copy new, enum support

chore: move tests into separate dir

refactor: rename Deserialize & deserializeMut -> ZeroCopyAt, ZeroCopyAtMut

refacator: use fully qualified import paths

test: add further functional tests and fix macro issues

test: new_zero_copy

Author: ananas-block

.github/workflows/rust.yml

@@ -54,7 +54,9 @@ jobs:
               cargo test -p light-verifier --all-features
               cargo test -p light-merkle-tree-metadata --all-features
               cargo test -p light-zero-copy --features "std, mut, derive"
-              cargo test -p light-zero-copy-derive --features "mut"
+              cargo test -p light-zero-copy --no-default-features  # Test no_std compatibility
+              cargo build -p light-zero-copy --no-default-features  # Ensure no_std builds
+              cargo test -p light-zero-copy-derive --all-features
               cargo test -p light-hash-set --all-features
           - name: program-libs-slow
             packages: light-bloom-filter light-indexed-merkle-tree light-batched-merkle-tree

Cargo.lock

@@ -5,7 +5,7 @@ use anchor_lang::prelude::*;
 use light_compressed_account::instruction_data::{
     invoke_cpi::InstructionDataInvokeCpi, zero_copy::ZInstructionDataInvokeCpi,
 };
-use light_zero_copy::{borsh::Deserialize, errors::ZeroCopyError};
+use light_zero_copy::{errors::ZeroCopyError, traits::ZeroCopyAt};
 use zerocopy::{little_endian::U32, Ref};
 
 /// Collects instruction data without executing a compressed transaction.

anchor-programs/system/src/cpi_context_account.rs

@@ -389,7 +389,7 @@ impl ZCompressedAccount<'_> {
 #[cfg(test)]
 mod tests {
     use light_hasher::Poseidon;
-    use light_zero_copy::borsh::Deserialize;
+    use light_zero_copy::traits::ZeroCopyAt;
     use num_bigint::BigUint;
     use rand::Rng;
 

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

@@ -1,5 +1,5 @@
 use borsh::BorshDeserialize;
-use light_zero_copy::borsh::Deserialize;
+use light_zero_copy::traits::ZeroCopyAt;
 
 use super::{
     error::ParseIndexerEventError,

program-libs/compressed-account/src/indexer_event/parse.rs

@@ -1,4 +1,4 @@
-use light_zero_copy::{borsh::Deserialize, errors::ZeroCopyError, ZeroCopyMut};
+use light_zero_copy::{errors::ZeroCopyError, traits::ZeroCopyAt,ZeroCopyMut};
 use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout, Ref, Unaligned};
 
 use crate::{AnchorDeserialize, AnchorSerialize};
@@ -35,9 +35,9 @@ impl Default for CompressedProof {
     }
 }
 
-impl<'a> Deserialize<'a> for CompressedProof {
-    type Output = Ref<&'a [u8], Self>;
-    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::Output, &'a [u8]), ZeroCopyError> {
+impl<'a> ZeroCopyAt<'a> for CompressedProof {
+    type ZeroCopyAt = Ref<&'a [u8], Self>;
+    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::ZeroCopyAt, &'a [u8]), ZeroCopyError> {
         Ok(Ref::<&[u8], CompressedProof>::from_prefix(bytes)?)
     }
 }

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

@@ -4,7 +4,7 @@ use std::{
 };
 
 use light_zero_copy::{
-    borsh::Deserialize, errors::ZeroCopyError, slice::ZeroCopySlice, slice_mut::ZeroCopySliceMut,
+    errors::ZeroCopyError, slice::ZeroCopySlice, slice_mut::ZeroCopySliceMut, traits::ZeroCopyAt,
 };
 use zerocopy::{
     little_endian::{U32, U64},
@@ -87,8 +87,8 @@ impl Deref for InsertIntoQueuesInstructionData<'_> {
     }
 }
 
-impl<'a> Deserialize<'a> for InsertIntoQueuesInstructionData<'a> {
-    type Output = Self;
+impl<'a> ZeroCopyAt<'a> for InsertIntoQueuesInstructionData<'a> {
+    type ZeroCopyAt = Self;
     fn zero_copy_at(bytes: &'a [u8]) -> std::result::Result<(Self, &'a [u8]), ZeroCopyError> {
         let (meta, bytes) = Ref::<&[u8], InsertIntoQueuesInstructionDataMeta>::from_prefix(bytes)?;
 

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

@@ -1,6 +1,6 @@
 use std::ops::{Deref, DerefMut};
 
-use light_zero_copy::{borsh::Deserialize, errors::ZeroCopyError, slice::ZeroCopySliceBorsh};
+use light_zero_copy::{errors::ZeroCopyError, slice::ZeroCopySliceBorsh, traits::ZeroCopyAt};
 use zerocopy::{
     little_endian::{U16, U32, U64},
     FromBytes, Immutable, IntoBytes, KnownLayout, Ref, Unaligned,
@@ -198,10 +198,10 @@ pub struct ZOutAccountInfo<'a> {
     pub data: &'a [u8],
 }
 
-impl<'a> Deserialize<'a> for ZOutAccountInfo<'a> {
-    type Output = ZOutAccountInfo<'a>;
+impl<'a> ZeroCopyAt<'a> for ZOutAccountInfo<'a> {
+    type ZeroCopyAt = ZOutAccountInfo<'a>;
 
-    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::Output, &'a [u8]), ZeroCopyError> {
+    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::ZeroCopyAt, &'a [u8]), ZeroCopyError> {
         let (meta, bytes) = Ref::<&[u8], ZOutAccountInfoMeta>::from_prefix(bytes)?;
         let (len, bytes) = Ref::<&'a [u8], U32>::from_prefix(bytes)?;
         let (data, bytes) = bytes.split_at(u64::from(*len) as usize);
@@ -394,9 +394,9 @@ impl<'a> Deref for ZInstructionDataInvokeCpiWithAccountInfo<'a> {
     }
 }
 
-impl<'a> Deserialize<'a> for InstructionDataInvokeCpiWithAccountInfo {
-    type Output = ZInstructionDataInvokeCpiWithAccountInfo<'a>;
-    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::Output, &'a [u8]), ZeroCopyError> {
+impl<'a> ZeroCopyAt<'a> for InstructionDataInvokeCpiWithAccountInfo {
+    type ZeroCopyAt = ZInstructionDataInvokeCpiWithAccountInfo<'a>;
+    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::ZeroCopyAt, &'a [u8]), ZeroCopyError> {
         let (meta, bytes) =
             Ref::<&[u8], ZInstructionDataInvokeCpiWithReadOnlyMeta>::from_prefix(bytes)?;
         let (proof, bytes) = Option::<Ref<&[u8], CompressedProof>>::zero_copy_at(bytes)?;

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

@@ -1,8 +1,6 @@
 use std::ops::Deref;
 
-use light_zero_copy::{
-    borsh::Deserialize, errors::ZeroCopyError, slice::ZeroCopySliceBorsh, 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,
@@ -346,9 +344,9 @@ impl<'a> Deref for ZInstructionDataInvokeCpiWithReadOnly<'a> {
     }
 }
 
-impl<'a> Deserialize<'a> for InstructionDataInvokeCpiWithReadOnly {
-    type Output = ZInstructionDataInvokeCpiWithReadOnly<'a>;
-    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::Output, &'a [u8]), ZeroCopyError> {
+impl<'a> ZeroCopyAt<'a> for InstructionDataInvokeCpiWithReadOnly {
+    type ZeroCopyAt = ZInstructionDataInvokeCpiWithReadOnly<'a>;
+    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::ZeroCopyAt, &'a [u8]), ZeroCopyError> {
         let (meta, bytes) =
             Ref::<&[u8], ZInstructionDataInvokeCpiWithReadOnlyMeta>::from_prefix(bytes)?;
         let (proof, bytes) = Option::<Ref<&[u8], CompressedProof>>::zero_copy_at(bytes)?;
@@ -375,10 +373,9 @@ impl<'a> Deserialize<'a> for InstructionDataInvokeCpiWithReadOnly {
             (slices, bytes)
         };
 
-        let (output_compressed_accounts, bytes) =
-            <Vec<ZOutputCompressedAccountWithPackedContext<'a>> as Deserialize<'a>>::zero_copy_at(
-                bytes,
-            )?;
+        let (output_compressed_accounts, bytes) = <Vec<
+            ZOutputCompressedAccountWithPackedContext<'a>,
+        > as ZeroCopyAt<'a>>::zero_copy_at(bytes)?;
 
         let (read_only_addresses, bytes) =
             ZeroCopySliceBorsh::<'a, ZPackedReadOnlyAddress>::from_bytes_at(bytes)?;

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

@@ -1,6 +1,6 @@
 use std::{mem::size_of, ops::Deref};
 
-use light_zero_copy::{borsh::Deserialize, errors::ZeroCopyError, slice::ZeroCopySliceBorsh};
+use light_zero_copy::{errors::ZeroCopyError, slice::ZeroCopySliceBorsh, traits::ZeroCopyAt};
 use zerocopy::{
     little_endian::{U16, U32, U64},
     FromBytes, Immutable, IntoBytes, KnownLayout, Ref, Unaligned,
@@ -32,8 +32,8 @@ pub struct ZPackedReadOnlyAddress {
     pub address_merkle_tree_account_index: u8,
 }
 
-impl<'a> Deserialize<'a> for ZPackedReadOnlyAddress {
-    type Output = Self;
+impl<'a> ZeroCopyAt<'a> for ZPackedReadOnlyAddress {
+    type ZeroCopyAt = Self;
     fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self, &'a [u8]), ZeroCopyError> {
         let (address, bytes) = bytes.split_at(size_of::<[u8; 32]>());
         let (address_merkle_tree_root_index, bytes) = U16::ref_from_prefix(bytes)?;
@@ -99,9 +99,9 @@ impl ZPackedMerkleContext {
     }
 }
 
-impl<'a> Deserialize<'a> for ZPackedMerkleContext {
-    type Output = Ref<&'a [u8], Self>;
-    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::Output, &'a [u8]), ZeroCopyError> {
+impl<'a> ZeroCopyAt<'a> for ZPackedMerkleContext {
+    type ZeroCopyAt = Ref<&'a [u8], Self>;
+    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::ZeroCopyAt, &'a [u8]), ZeroCopyError> {
         let (ref_value, bytes) = Ref::<&[u8], Self>::from_prefix(bytes)?;
         Ok((ref_value, bytes))
     }
@@ -171,8 +171,8 @@ impl<'a> From<&ZOutputCompressedAccountWithPackedContext<'a>>
     }
 }
 
-impl<'a> Deserialize<'a> for ZOutputCompressedAccountWithPackedContext<'a> {
-    type Output = Self;
+impl<'a> ZeroCopyAt<'a> for ZOutputCompressedAccountWithPackedContext<'a> {
+    type ZeroCopyAt = Self;
 
     #[inline]
     fn zero_copy_at(vec: &'a [u8]) -> Result<(Self, &'a [u8]), ZeroCopyError> {
@@ -215,8 +215,8 @@ impl From<&ZCompressedAccountData<'_>> for CompressedAccountData {
     }
 }
 
-impl<'a> Deserialize<'a> for ZCompressedAccountData<'a> {
-    type Output = Self;
+impl<'a> ZeroCopyAt<'a> for ZCompressedAccountData<'a> {
+    type ZeroCopyAt = Self;
 
     #[inline]
     fn zero_copy_at(
@@ -281,8 +281,8 @@ impl From<&ZCompressedAccount<'_>> for CompressedAccount {
     }
 }
 
-impl<'a> Deserialize<'a> for ZCompressedAccount<'a> {
-    type Output = Self;
+impl<'a> ZeroCopyAt<'a> for ZCompressedAccount<'a> {
+    type ZeroCopyAt = Self;
 
     #[inline]
     fn zero_copy_at(bytes: &'a [u8]) -> Result<(ZCompressedAccount<'a>, &'a [u8]), ZeroCopyError> {
@@ -399,8 +399,8 @@ impl Deref for ZPackedCompressedAccountWithMerkleContext<'_> {
     }
 }
 
-impl<'a> Deserialize<'a> for ZPackedCompressedAccountWithMerkleContext<'a> {
-    type Output = Self;
+impl<'a> ZeroCopyAt<'a> for ZPackedCompressedAccountWithMerkleContext<'a> {
+    type ZeroCopyAt = Self;
     fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self, &'a [u8]), ZeroCopyError> {
         let (compressed_account, bytes) = ZCompressedAccount::zero_copy_at(bytes)?;
         let (meta, bytes) =
@@ -491,8 +491,8 @@ impl<'a> InstructionData<'a> for ZInstructionDataInvoke<'a> {
         unimplemented!()
     }
 }
-impl<'a> Deserialize<'a> for ZInstructionDataInvoke<'a> {
-    type Output = Self;
+impl<'a> ZeroCopyAt<'a> for ZInstructionDataInvoke<'a> {
+    type ZeroCopyAt = Self;
     fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self, &'a [u8]), ZeroCopyError> {
         let (proof, bytes) = Option::<CompressedProof>::zero_copy_at(bytes)?;
         let (input_compressed_accounts_with_merkle_context, bytes) =
@@ -682,8 +682,8 @@ impl<'a> From<ZInstructionDataInvokeCpi<'a>> for ZInstructionDataInvoke<'a> {
     }
 }
 
-impl<'a> Deserialize<'a> for ZInstructionDataInvokeCpi<'a> {
-    type Output = Self;
+impl<'a> ZeroCopyAt<'a> for ZInstructionDataInvokeCpi<'a> {
+    type ZeroCopyAt = Self;
     fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self, &'a [u8]), ZeroCopyError> {
         let (proof, bytes) = Option::<CompressedProof>::zero_copy_at(bytes)?;
         let (new_address_params, bytes) = ZeroCopySliceBorsh::from_bytes_at(bytes)?;
@@ -717,8 +717,8 @@ impl<'a> Deserialize<'a> for ZInstructionDataInvokeCpi<'a> {
     }
 }
 
-impl Deserialize<'_> for CompressedCpiContext {
-    type Output = Self;
+impl ZeroCopyAt<'_> for CompressedCpiContext {
+    type ZeroCopyAt = Self;
     fn zero_copy_at(bytes: &[u8]) -> Result<(Self, &[u8]), ZeroCopyError> {
         let (set_context, bytes) = u8::zero_copy_at(bytes)?;
         let (first_set_context, bytes) = u8::zero_copy_at(bytes)?;
@@ -745,9 +745,9 @@ pub struct ZPackedReadOnlyCompressedAccount {
     pub root_index: U16,
 }
 
-impl<'a> Deserialize<'a> for ZPackedReadOnlyCompressedAccount {
-    type Output = Ref<&'a [u8], Self>;
-    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::Output, &'a [u8]), ZeroCopyError> {
+impl<'a> ZeroCopyAt<'a> for ZPackedReadOnlyCompressedAccount {
+    type ZeroCopyAt = Ref<&'a [u8], Self>;
+    fn zero_copy_at(bytes: &'a [u8]) -> Result<(Self::ZeroCopyAt, &'a [u8]), ZeroCopyError> {
         Ok(Ref::<&[u8], Self>::from_prefix(bytes)?)
     }
 }