light-compressed-token-sdk 0.23.0

Low-level SDK for compressed token operations on Light Protocol
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

//! Solana-compatible token types using `solana_pubkey::Pubkey`.
//!
//! This module provides convenience types that use standard Solana pubkeys
//! instead of byte arrays for easier integration.

use light_compressed_account::compressed_account::CompressedAccountWithMerkleContext;
use light_sdk::light_hasher::{sha256::Sha256BE, HasherError};
use solana_program_error::ProgramError;
use solana_pubkey::Pubkey;

use crate::{AnchorDeserialize, AnchorSerialize};

#[derive(Clone, Copy, Debug, PartialEq, Eq, AnchorDeserialize, AnchorSerialize, Default)]
#[repr(u8)]
pub enum AccountState {
    #[default]
    Initialized = 0,
    Frozen = 1,
}

impl From<AccountState> for light_token_interface::state::CompressedTokenAccountState {
    fn from(state: AccountState) -> Self {
        match state {
            AccountState::Initialized => {
                light_token_interface::state::CompressedTokenAccountState::Initialized
            }
            AccountState::Frozen => {
                light_token_interface::state::CompressedTokenAccountState::Frozen
            }
        }
    }
}

impl TryFrom<u8> for AccountState {
    type Error = ProgramError;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(AccountState::Initialized),
            1 => Ok(AccountState::Frozen),
            _ => Err(ProgramError::InvalidAccountData),
        }
    }
}

/// TokenData using standard Solana pubkeys.
///
/// For zero-copy operations, use `TokenData` from `light_token_interface`.
#[derive(Debug, PartialEq, Eq, AnchorDeserialize, AnchorSerialize, Clone, Default)]
pub struct TokenData {
    /// The mint associated with this account
    pub mint: Pubkey,
    /// The owner of this account
    pub owner: Pubkey,
    /// The amount of tokens this account holds
    pub amount: u64,
    /// Optional delegate authorized to transfer tokens
    pub delegate: Option<Pubkey>,
    /// The account's state
    pub state: AccountState,
    /// TLV extensions for compressed token accounts
    pub tlv: Option<Vec<light_token_interface::state::ExtensionStruct>>,
}

impl TokenData {
    /// TokenDataVersion 3
    /// CompressedAccount Discriminator `[0,0,0,0,0,0,0,4]`
    #[inline(always)]
    pub fn hash_sha_flat(&self) -> Result<[u8; 32], HasherError> {
        use light_sdk::light_hasher::Hasher;
        let bytes = self.try_to_vec().map_err(|_| HasherError::BorshError)?;
        Sha256BE::hash(bytes.as_slice())
    }
}

/// TokenData with merkle context for verification
#[derive(Debug, Clone, PartialEq)]
pub struct TokenDataWithMerkleContext {
    pub token_data: TokenData,
    pub compressed_account: CompressedAccountWithMerkleContext,
}

impl TokenDataWithMerkleContext {
    /// Only works for sha flat hash
    pub fn hash(&self) -> Result<[u8; 32], HasherError> {
        if let Some(data) = self.compressed_account.compressed_account.data.as_ref() {
            match data.discriminator {
                [0, 0, 0, 0, 0, 0, 0, 4] => self.token_data.hash_sha_flat(),
                _ => Err(HasherError::EmptyInput),
            }
        } else {
            Err(HasherError::EmptyInput)
        }
    }
}

impl From<TokenData> for light_token_interface::state::TokenData {
    fn from(data: TokenData) -> Self {
        use light_token_interface::state::CompressedTokenAccountState;

        Self {
            mint: data.mint.to_bytes().into(),
            owner: data.owner.to_bytes().into(),
            amount: data.amount,
            delegate: data.delegate.map(|d| d.to_bytes().into()),
            state: match data.state {
                AccountState::Initialized => CompressedTokenAccountState::Initialized as u8,
                AccountState::Frozen => CompressedTokenAccountState::Frozen as u8,
            },
            tlv: data.tlv,
        }
    }
}

impl From<light_token_interface::state::TokenData> for TokenData {
    fn from(data: light_token_interface::state::TokenData) -> Self {
        Self {
            mint: Pubkey::new_from_array(data.mint.to_bytes()),
            owner: Pubkey::new_from_array(data.owner.to_bytes()),
            amount: data.amount,
            delegate: data.delegate.map(|d| Pubkey::new_from_array(d.to_bytes())),
            state: AccountState::try_from(data.state).unwrap_or(AccountState::Initialized),
            tlv: data.tlv,
        }
    }
}

/// Type alias for backward compatibility
pub type InputTokenDataCompressible =
    light_token_interface::instructions::transfer2::MultiTokenTransferOutputData;