feat: zero-copy-derive

Author: ananas-block

Cargo.lock

@@ -13,6 +13,7 @@ members = [
     "program-libs/hash-set",
     "program-libs/indexed-merkle-tree",
     "program-libs/indexed-array",
+    "program-libs/zero-copy-derive",
     "programs/account-compression",
     "programs/system",
     "programs/compressed-token",

Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "light-zero-copy-derive"
+version = "0.1.0"
+edition = "2021"
+license = "Apache-2.0"
+description = "Proc macro for zero-copy deserialization"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "2.0", features = ["full", "extra-traits"] }
+lazy_static = "1.4"
+
+[dev-dependencies]
+trybuild = "1.0"
+rand = "0.8"
+borsh = { workspace = true }
+light-zero-copy = { workspace = true, features = ["std"] }
+zerocopy = { workspace = true, features = ["derive"] }

program-libs/zero-copy-derive/Cargo.toml

@@ -0,0 +1,103 @@
+# Light-Zero-Copy-Derive
+
+A procedural macro for deriving zero-copy deserialization for Rust structs used with Solana programs.
+
+## Features
+
+This crate provides two key derive macros:
+
+1. `#[derive(ZeroCopy)]` - Implements zero-copy deserialization with:
+   - The `zero_copy_at` and `zero_copy_at_mut` methods for deserialization
+   - Full Borsh compatibility for serialization/deserialization
+   - Efficient memory representation with no copying of data
+   - `From<Z<StructName>>` and `From<Z<StructName>Mut>` implementations for easy conversion back to the original struct
+
+2. `#[derive(ZeroCopyEq)]` - Adds equality comparison support:
+   - Compare zero-copy instances with regular struct instances
+   - Can be used alongside `ZeroCopy` for complete functionality
+   - Derivation for Options<struct> is not robust and may not compile.
+
+## Rules for Zero-Copy Deserialization
+
+The macro follows these rules when generating code:
+
+1. Creates a `ZStruct` for your struct that follows zero-copy principles
+   1. Fields are extracted into a meta struct until reaching a `Vec`, `Option` or non-`Copy` type
+   2. Vectors are represented as `ZeroCopySlice` and not included in the meta struct
+   3. Integer types are replaced with their zerocopy equivalents (e.g., `u16` → `U16`)
+   4. Fields after the first vector are directly included in the `ZStruct` and deserialized one by one
+   5. If a vector contains a nested vector (non-`Copy` type), it must implement `Deserialize`
+   6. Elements in an `Option` must implement `Deserialize`
+   7. Types that don't implement `Copy` must implement `Deserialize` and are deserialized one by one
+
+## Usage
+
+### Basic Usage
+
+```rust
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_zero_copy_derive::ZeroCopy;
+use light_zero_copy::{borsh::Deserialize, borsh_mut::DeserializeMut};
+
+#[repr(C)]
+#[derive(Debug, PartialEq, BorshSerialize, BorshDeserialize, ZeroCopy)]
+pub struct MyStruct {
+    pub a: u8,
+    pub b: u16,
+    pub vec: Vec<u8>,
+    pub c: u64,
+}
+let my_struct = MyStruct {
+    a: 1,
+    b: 2,
+    vec: vec![1u8; 32],
+    c: 3,
+};
+// Use the struct with zero-copy deserialization
+let mut bytes = my_struct.try_to_vec().unwrap();
+
+// Immutable zero-copy deserialization
+let (zero_copy, _remaining) = MyStruct::zero_copy_at(&bytes).unwrap();
+
+// Convert back to original struct using From implementation
+let converted: MyStruct = zero_copy.clone().into();
+assert_eq!(converted, my_struct);
+
+// Mutable zero-copy deserialization with modification
+let (mut zero_copy_mut, _remaining) = MyStruct::zero_copy_at_mut(&mut bytes).unwrap();
+zero_copy_mut.a = 42;
+
+// The change is reflected when we convert back to the original struct
+let modified: MyStruct = zero_copy_mut.into();
+assert_eq!(modified.a, 42);
+
+// And also when we deserialize directly from the modified bytes
+let borsh = MyStruct::try_from_slice(&bytes).unwrap();
+assert_eq!(borsh.a, 42u8);
+```
+
+### With Equality Comparison
+
+```rust
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_zero_copy_derive::ZeroCopy;
+
+#[repr(C)]
+#[derive(Debug, PartialEq, BorshSerialize, BorshDeserialize, ZeroCopy)]
+pub struct MyStruct {
+    pub a: u8,
+    pub b: u16,
+    pub vec: Vec<u8>,
+    pub c: u64,
+}
+let my_struct = MyStruct {
+    a: 1,
+    b: 2,
+    vec: vec![1u8; 32],
+    c: 3,
+};
+// Use the struct with zero-copy deserialization
+let mut bytes = my_struct.try_to_vec().unwrap();
+let (zero_copy, _remaining) = MyStruct::zero_copy_at(&bytes).unwrap();
+assert_eq!(zero_copy, my_struct);
+```