light-token 0.23.0

SDK for Light Tokens
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

#![cfg(feature = "compressible")]

use light_account::PackedAccounts;
use light_token::{
    compat::{PackedCompressibleTokenDataWithVariant, TokenData, TokenDataWithVariant},
    pack::Pack,
};
use solana_pubkey::Pubkey;

#[test]
fn test_token_data_packing() {
    let mut remaining_accounts = PackedAccounts::default();

    let owner = Pubkey::new_unique();
    let mint = Pubkey::new_unique();
    let delegate = Pubkey::new_unique();

    let token_data = TokenData {
        owner,
        mint,
        amount: 1000,
        delegate: Some(delegate),
        state: Default::default(),
        tlv: None,
    };

    // Pack the token data
    let packed = token_data.pack(&mut remaining_accounts).unwrap();

    // Verify the packed data
    assert_eq!(packed.owner, 0); // First pubkey gets index 0
    assert_eq!(packed.mint, 1); // Second pubkey gets index 1
    assert_eq!(packed.delegate, 2); // Third pubkey gets index 2
    assert_eq!(packed.amount, 1000);
    assert!(packed.has_delegate);
    assert_eq!(packed.version, 3); // TokenDataVersion::ShaFlat

    // Verify remaining_accounts contains the pubkeys
    let pubkeys = remaining_accounts.packed_pubkeys();
    assert_eq!(pubkeys[0], owner);
    assert_eq!(pubkeys[1], mint);
    assert_eq!(pubkeys[2], delegate);
}

#[test]
fn test_token_data_with_variant_packing() {
    use anchor_lang::{AnchorDeserialize, AnchorSerialize};

    #[derive(Debug, Clone, Copy, AnchorSerialize, AnchorDeserialize)]
    enum MyVariant {
        TypeA = 0,
        TypeB = 1,
    }

    impl Pack for MyVariant {
        type Packed = Self;

        fn pack(
            &self,
            _remaining_accounts: &mut PackedAccounts,
        ) -> Result<Self::Packed, solana_program_error::ProgramError> {
            Ok(*self)
        }
    }

    let mut remaining_accounts = PackedAccounts::default();

    let token_with_variant = TokenDataWithVariant {
        variant: MyVariant::TypeA,
        token_data: TokenData {
            owner: Pubkey::new_unique(),
            mint: Pubkey::new_unique(),
            amount: 500,
            delegate: None,
            state: Default::default(),
            tlv: None,
        },
    };

    // Pack the wrapper
    let packed: PackedCompressibleTokenDataWithVariant<MyVariant> =
        token_with_variant.pack(&mut remaining_accounts).unwrap();

    // Verify variant is unchanged
    assert!(matches!(packed.variant, MyVariant::TypeA));

    // Verify token data is packed
    assert_eq!(packed.token_data.owner, 0);
    assert_eq!(packed.token_data.mint, 1);
    assert_eq!(packed.token_data.amount, 500);
    assert!(!packed.token_data.has_delegate);
}

#[test]
fn test_deduplication_in_packing() {
    let mut remaining_accounts = PackedAccounts::default();

    let shared_owner = Pubkey::new_unique();
    let shared_mint = Pubkey::new_unique();

    let token1 = TokenData {
        owner: shared_owner,
        mint: shared_mint,
        amount: 100,
        delegate: None,
        state: Default::default(),
        tlv: None,
    };

    let token2 = TokenData {
        owner: shared_owner, // Same owner
        mint: shared_mint,   // Same mint
        amount: 200,
        delegate: None,
        state: Default::default(),
        tlv: None,
    };

    // Pack both tokens
    let packed1 = token1.pack(&mut remaining_accounts).unwrap();
    let packed2 = token2.pack(&mut remaining_accounts).unwrap();

    // Both should reference the same indices
    assert_eq!(packed1.owner, packed2.owner);
    assert_eq!(packed1.mint, packed2.mint);

    // Only 2 unique pubkeys should be stored
    let pubkeys = remaining_accounts.packed_pubkeys();
    assert_eq!(pubkeys.len(), 2);
}