typhoon-accounts 0.3.0

Account types and traits
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

use {solana_account_view::AccountView, typhoon_traits::Discriminator};

/// Discriminator matching with length-optimized comparison strategies.
/// Uses different comparison methods based on discriminator length:
/// - `1-8` bytes: Unaligned integer reads for maximum performance
/// - `>8` bytes: Standard slice comparison
#[inline(always)]
pub fn discriminator_matches<T: Discriminator>(info: &AccountView) -> bool {
    let discriminator = T::DISCRIMINATOR;
    let len = discriminator.len();
    let data_ptr = info.data_ptr();

    // Choose optimal comparison strategy based on discriminator length

    // Use unaligned integer reads for small discriminators (most common case)
    // SAFETY: We've already verified that data.len() >= discriminator.len()
    // in the caller before calling this function, so we know we have at least
    // `len` bytes available for reading. Unaligned reads are safe for primitive
    // types on all supported architectures. The pointer casts to smaller integer
    // types (u16, u32, u64) are valid because we're only reading the exact number
    // of bytes specified by `len`.
    unsafe {
        match len {
            0 => true, // No discriminator to check
            1 => *data_ptr == discriminator[0],
            2 => {
                let data_val = (data_ptr as *const u16).read_unaligned();
                let disc_val = u16::from_le_bytes([discriminator[0], discriminator[1]]);
                data_val == disc_val
            }
            4 => {
                let data_val = (data_ptr as *const u32).read_unaligned();
                let disc_val = u32::from_le_bytes([
                    discriminator[0],
                    discriminator[1],
                    discriminator[2],
                    discriminator[3],
                ]);
                data_val == disc_val
            }
            8 => {
                let data_val = (data_ptr as *const u64).read_unaligned();
                let disc_val = u64::from_le_bytes([
                    discriminator[0],
                    discriminator[1],
                    discriminator[2],
                    discriminator[3],
                    discriminator[4],
                    discriminator[5],
                    discriminator[6],
                    discriminator[7],
                ]);
                data_val == disc_val
            }
            _ => {
                let data = core::slice::from_raw_parts(data_ptr, len);
                data == discriminator
            }
        }
    }
}