light-sdk-macros 0.23.0

Macros for Programs using the Light SDK for ZK Compression
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Unit tests for LightCompressible derive macro.
//!
//! Extracted from `light_pdas/account/light_compressible.rs`.

use syn::{parse_quote, DeriveInput};

use crate::light_pdas::account::derive::derive_light_account;

#[test]
fn test_light_compressible_basic() {
    // No #[hash] or #[skip] needed - SHA256 hashes entire struct, compression_info auto-skipped
    let input: DeriveInput = parse_quote! {
        pub struct UserRecord {
            pub owner: Pubkey,
            pub name: String,
            pub score: u64,
            pub compression_info: Option<CompressionInfo>,
        }
    };

    let result = derive_light_account(input);
    assert!(result.is_ok(), "LightCompressible should succeed");

    let output = result.unwrap().to_string();

    // Should contain LightHasherSha output
    assert!(output.contains("DataHasher"), "Should implement DataHasher");
    assert!(
        output.contains("ToByteArray"),
        "Should implement ToByteArray"
    );

    // Should contain LightDiscriminator output
    assert!(
        output.contains("LightDiscriminator"),
        "Should implement LightDiscriminator"
    );
    assert!(
        output.contains("LIGHT_DISCRIMINATOR"),
        "Should have discriminator constant"
    );

    // Should contain Compressible output (HasCompressionInfo, CompressAs, Size)
    assert!(
        output.contains("HasCompressionInfo"),
        "Should implement HasCompressionInfo"
    );
    assert!(output.contains("CompressAs"), "Should implement CompressAs");
    assert!(output.contains("Size"), "Should implement Size");

    // Should contain CompressiblePack output (Pack, Unpack, Packed struct)
    assert!(output.contains("Pack"), "Should implement Pack");
    assert!(output.contains("Unpack"), "Should implement Unpack");
    assert!(
        output.contains("PackedUserRecord"),
        "Should generate Packed struct"
    );
}

#[test]
fn test_light_compressible_with_compress_as() {
    // compress_as still works - no #[hash] or #[skip] needed
    let input: DeriveInput = parse_quote! {
        #[compress_as(start_time = 0, score = 0)]
        pub struct GameSession {
            pub session_id: u64,
            pub player: Pubkey,
            pub start_time: u64,
            pub score: u64,
            pub compression_info: Option<CompressionInfo>,
        }
    };

    let result = derive_light_account(input);
    assert!(
        result.is_ok(),
        "LightCompressible with compress_as should succeed"
    );

    let output = result.unwrap().to_string();

    // compress_as attribute should be processed
    assert!(output.contains("CompressAs"), "Should implement CompressAs");
}

#[test]
fn test_light_compressible_no_pubkey_fields() {
    let input: DeriveInput = parse_quote! {
        pub struct SimpleRecord {
            pub id: u64,
            pub value: u32,
            pub compression_info: Option<CompressionInfo>,
        }
    };

    let result = derive_light_account(input);
    assert!(
        result.is_ok(),
        "LightCompressible without Pubkey fields should succeed"
    );

    let output = result.unwrap().to_string();

    // Should still generate everything
    assert!(output.contains("DataHasher"), "Should implement DataHasher");
    assert!(
        output.contains("LightDiscriminator"),
        "Should implement LightDiscriminator"
    );
    assert!(
        output.contains("HasCompressionInfo"),
        "Should implement HasCompressionInfo"
    );

    // For structs without Pubkey fields, PackedSimpleRecord should be a type alias
    // (implementation detail of CompressiblePack)
}

#[test]
fn test_light_compressible_enum_fails() {
    let input: DeriveInput = parse_quote! {
        pub enum NotAStruct {
            A,
            B,
        }
    };

    let result = derive_light_account(input);
    assert!(result.is_err(), "LightCompressible should fail for enums");
}

#[test]
fn test_light_compressible_missing_compression_info() {
    let input: DeriveInput = parse_quote! {
        pub struct MissingCompressionInfo {
            pub id: u64,
            pub value: u32,
        }
    };

    let result = derive_light_account(input);
    // Compressible derive validates compression_info field
    assert!(
        result.is_err(),
        "Should fail without compression_info field"
    );
}