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
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

#![no_std]

pub use {accounts::*, discriminator::*, programs::*};
use {
    solana_account_view::{AccountView, Ref, RefMut},
    solana_address::Address,
    solana_program_error::ProgramError,
    typhoon_errors::Error,
    typhoon_traits::{Accessor, DataStrategy, Discriminator, MutAccessor},
};

mod accounts;
mod discriminator;
mod programs;

pub trait FromAccountInfo<'a>: Sized {
    fn try_from_info(info: &'a AccountView) -> Result<Self, Error>;
}

pub trait ReadableAccount: AsRef<AccountView> {
    #[inline(always)]
    fn address(&self) -> &Address {
        self.as_ref().address()
    }

    #[inline(always)]
    fn owned_by(&self, owner: &Address) -> bool {
        self.as_ref().owned_by(owner)
    }

    #[inline(always)]
    fn lamports(&self) -> u64 {
        self.as_ref().lamports()
    }

    #[inline(always)]
    fn raw_data(&self) -> Result<Ref<'_, [u8]>, ProgramError> {
        self.as_ref().try_borrow()
    }
}

pub trait WritableAccount: ReadableAccount {
    #[inline(always)]
    fn assign(&self, new_owner: &Address) {
        unsafe {
            self.as_ref().assign(new_owner);
        }
    }

    #[inline(always)]
    fn resize(&self, new_len: usize) -> Result<(), Error> {
        self.as_ref().resize(new_len).map_err(Into::into)
    }

    #[inline(always)]
    fn set_lamports(&self, lamports: u64) {
        self.as_ref().set_lamports(lamports);
    }

    #[inline(always)]
    fn raw_mut_data(&self) -> Result<RefMut<'_, [u8]>, ProgramError> {
        self.as_ref().try_borrow_mut()
    }
}

pub trait SignerAccount: ReadableAccount {}

pub trait AccountData: ReadableAccount {
    type Data: Discriminator + DataStrategy;
}

pub trait ReadableAccountData: AccountData {
    #[inline(always)]
    fn data(&self) -> Result<Ref<'_, Self::Data>, ProgramError>
    where
        <Self::Data as DataStrategy>::Strategy:
            for<'a> Accessor<'a, Self::Data, Data = &'a Self::Data>,
    {
        Ref::try_map(self.as_ref().try_borrow()?, |data| {
            <<Self::Data as DataStrategy>::Strategy as Accessor<'_, Self::Data>>::access(
                &data[Self::Data::DISCRIMINATOR.len()..],
            )
        })
        .map_err(|_| ProgramError::InvalidAccountData)
    }

    #[inline(always)]
    fn data_owned(&self) -> Result<Self::Data, ProgramError>
    where
        <Self::Data as DataStrategy>::Strategy: for<'a> Accessor<'a, Self::Data, Data = Self::Data>,
    {
        self.as_ref().check_borrow()?;
        let data = unsafe { self.as_ref().borrow_unchecked() };
        <<Self::Data as DataStrategy>::Strategy as Accessor<'_, Self::Data>>::access(
            &data[Self::Data::DISCRIMINATOR.len()..],
        )
    }

    #[inline(always)]
    fn data_unchecked(
        &self,
    ) -> Result<
        <<Self::Data as DataStrategy>::Strategy as Accessor<'_, Self::Data>>::Data,
        ProgramError,
    >
    where
        <Self::Data as DataStrategy>::Strategy: for<'a> Accessor<'a, Self::Data>,
    {
        let data = unsafe { self.as_ref().borrow_unchecked() };
        <<Self::Data as DataStrategy>::Strategy as Accessor<'_, Self::Data>>::access(
            &data[Self::Data::DISCRIMINATOR.len()..],
        )
    }
}

impl<T> ReadableAccountData for T where T: AccountData {}

pub trait WritableAccountData: AccountData + WritableAccount {
    #[inline(always)]
    fn mut_data(&self) -> Result<RefMut<'_, Self::Data>, Error>
    where
        <Self::Data as DataStrategy>::Strategy:
            for<'a> MutAccessor<'a, Self::Data, Data = &'a mut Self::Data>,
    {
        RefMut::try_map(self.as_ref().try_borrow_mut()?, |data| {
            <<Self::Data as DataStrategy>::Strategy as MutAccessor<'_, Self::Data>>::access_mut(
                &mut data[Self::Data::DISCRIMINATOR.len()..],
            )
        })
        .map_err(|_| ProgramError::InvalidAccountData.into())
    }
}

impl<T> WritableAccountData for T where T: AccountData + WritableAccount {}

pub trait FromRaw<'a> {
    fn from_raw(info: &'a AccountView) -> Self;
}