Orca

1//! State transition types
2
3use crate::curve::base::SwapCurve;
4use arrayref::{array_mut_ref, array_ref, array_refs, mut_array_refs};
5use solana_program::{
6    program_error::ProgramError,
7    program_pack::{IsInitialized, Pack, Sealed},
8    pubkey::Pubkey,
9};
10
11/// Program states.
12#[repr(C)]
13#[derive(Debug, Default, PartialEq)]
14pub struct SwapInfo {
15    /// Initialized state.
16    pub is_initialized: bool,
17    /// Nonce used in program address.
18    /// The program address is created deterministically with the nonce,
19    /// swap program id, and swap account pubkey.  This program address has
20    /// authority over the swap's token A account, token B account, and pool
21    /// token mint.
22    pub nonce: u8,
23
24    /// Program ID of the tokens being exchanged.
25    pub token_program_id: Pubkey,
26
27    /// Token A
28    pub token_a: Pubkey,
29    /// Token B
30    pub token_b: Pubkey,
31
32    /// Pool tokens are issued when A or B tokens are deposited.
33    /// Pool tokens can be withdrawn back to the original A or B token.
34    pub pool_mint: Pubkey,
35
36    /// Mint information for token A
37    pub token_a_mint: Pubkey,
38    /// Mint information for token B
39    pub token_b_mint: Pubkey,
40
41    /// Pool token account to receive trading and / or withdrawal fees
42    pub pool_fee_account: Pubkey,
43
44    /// Swap curve parameters, to be unpacked and used by the SwapCurve, which
45    /// calculates swaps, deposits, and withdrawals
46    pub swap_curve: SwapCurve,
47}
48
49impl Sealed for SwapInfo {}
50impl IsInitialized for SwapInfo {
51    fn is_initialized(&self) -> bool {
52        self.is_initialized
53    }
54}
55
56impl Pack for SwapInfo {
57    const LEN: usize = 291;
58
59    /// Unpacks a byte buffer into a [SwapInfo](struct.SwapInfo.html).
60    fn unpack_from_slice(input: &[u8]) -> Result<Self, ProgramError> {
61        let input = array_ref![input, 0, 291];
62        #[allow(clippy::ptr_offset_with_cast)]
63        let (
64            is_initialized,
65            nonce,
66            token_program_id,
67            token_a,
68            token_b,
69            pool_mint,
70            token_a_mint,
71            token_b_mint,
72            pool_fee_account,
73            swap_curve,
74        ) = array_refs![input, 1, 1, 32, 32, 32, 32, 32, 32, 32, 65];
75        Ok(Self {
76            is_initialized: match is_initialized {
77                [0] => false,
78                [1] => true,
79                _ => return Err(ProgramError::InvalidAccountData),
80            },
81            nonce: nonce[0],
82            token_program_id: Pubkey::new_from_array(*token_program_id),
83            token_a: Pubkey::new_from_array(*token_a),
84            token_b: Pubkey::new_from_array(*token_b),
85            pool_mint: Pubkey::new_from_array(*pool_mint),
86            token_a_mint: Pubkey::new_from_array(*token_a_mint),
87            token_b_mint: Pubkey::new_from_array(*token_b_mint),
88            pool_fee_account: Pubkey::new_from_array(*pool_fee_account),
89            swap_curve: SwapCurve::unpack_from_slice(swap_curve)?,
90        })
91    }
92
93    fn pack_into_slice(&self, output: &mut [u8]) {
94        let output = array_mut_ref![output, 0, 291];
95        let (
96            is_initialized,
97            nonce,
98            token_program_id,
99            token_a,
100            token_b,
101            pool_mint,
102            token_a_mint,
103            token_b_mint,
104            pool_fee_account,
105            swap_curve,
106        ) = mut_array_refs![output, 1, 1, 32, 32, 32, 32, 32, 32, 32, 65];
107        is_initialized[0] = self.is_initialized as u8;
108        nonce[0] = self.nonce;
109        token_program_id.copy_from_slice(self.token_program_id.as_ref());
110        token_a.copy_from_slice(self.token_a.as_ref());
111        token_b.copy_from_slice(self.token_b.as_ref());
112        pool_mint.copy_from_slice(self.pool_mint.as_ref());
113        token_a_mint.copy_from_slice(self.token_a_mint.as_ref());
114        token_b_mint.copy_from_slice(self.token_b_mint.as_ref());
115        pool_fee_account.copy_from_slice(self.pool_fee_account.as_ref());
116        self.swap_curve.pack_into_slice(&mut swap_curve[..]);
117    }
118}
119
120#[cfg(test)]
121mod tests {
122    use super::*;
123    use crate::curve::flat::FlatCurve;
124
125    use std::convert::TryInto;
126
127    #[test]
128    fn test_swap_info_packing() {
129        let nonce = 255;
130        let curve_type_raw: u8 = 1;
131        let curve_type = curve_type_raw.try_into().unwrap();
132        let token_program_id_raw = [1u8; 32];
133        let token_a_raw = [1u8; 32];
134        let token_b_raw = [2u8; 32];
135        let pool_mint_raw = [3u8; 32];
136        let token_a_mint_raw = [4u8; 32];
137        let token_b_mint_raw = [5u8; 32];
138        let pool_fee_account_raw = [6u8; 32];
139        let token_program_id = Pubkey::new_from_array(token_program_id_raw);
140        let token_a = Pubkey::new_from_array(token_a_raw);
141        let token_b = Pubkey::new_from_array(token_b_raw);
142        let pool_mint = Pubkey::new_from_array(pool_mint_raw);
143        let token_a_mint = Pubkey::new_from_array(token_a_mint_raw);
144        let token_b_mint = Pubkey::new_from_array(token_b_mint_raw);
145        let pool_fee_account = Pubkey::new_from_array(pool_fee_account_raw);
146        let trade_fee_numerator = 1;
147        let trade_fee_denominator = 4;
148        let owner_trade_fee_numerator = 3;
149        let owner_trade_fee_denominator = 10;
150        let owner_withdraw_fee_numerator = 2;
151        let owner_withdraw_fee_denominator = 7;
152        let host_fee_numerator = 5;
153        let host_fee_denominator = 20;
154        let calculator = Box::new(FlatCurve {
155            trade_fee_numerator,
156            trade_fee_denominator,
157            owner_trade_fee_numerator,
158            owner_trade_fee_denominator,
159            owner_withdraw_fee_numerator,
160            owner_withdraw_fee_denominator,
161            host_fee_numerator,
162            host_fee_denominator,
163        });
164        let swap_curve = SwapCurve {
165            curve_type,
166            calculator,
167        };
168        let is_initialized = true;
169        let swap_info = SwapInfo {
170            is_initialized,
171            nonce,
172            token_program_id,
173            token_a,
174            token_b,
175            pool_mint,
176            token_a_mint,
177            token_b_mint,
178            pool_fee_account,
179            swap_curve,
180        };
181
182        let mut packed = [0u8; SwapInfo::LEN];
183        SwapInfo::pack_into_slice(&swap_info, &mut packed);
184        let unpacked = SwapInfo::unpack(&packed).unwrap();
185        assert_eq!(swap_info, unpacked);
186
187        let mut packed = vec![];
188        packed.push(1u8);
189        packed.push(nonce);
190        packed.extend_from_slice(&token_program_id_raw);
191        packed.extend_from_slice(&token_a_raw);
192        packed.extend_from_slice(&token_b_raw);
193        packed.extend_from_slice(&pool_mint_raw);
194        packed.extend_from_slice(&token_a_mint_raw);
195        packed.extend_from_slice(&token_b_mint_raw);
196        packed.extend_from_slice(&pool_fee_account_raw);
197        packed.push(curve_type_raw);
198        packed.extend_from_slice(&trade_fee_numerator.to_le_bytes());
199        packed.extend_from_slice(&trade_fee_denominator.to_le_bytes());
200        packed.extend_from_slice(&owner_trade_fee_numerator.to_le_bytes());
201        packed.extend_from_slice(&owner_trade_fee_denominator.to_le_bytes());
202        packed.extend_from_slice(&owner_withdraw_fee_numerator.to_le_bytes());
203        packed.extend_from_slice(&owner_withdraw_fee_denominator.to_le_bytes());
204        packed.extend_from_slice(&host_fee_numerator.to_le_bytes());
205        packed.extend_from_slice(&host_fee_denominator.to_le_bytes());
206        let unpacked = SwapInfo::unpack(&packed).unwrap();
207        assert_eq!(swap_info, unpacked);
208
209        let packed = [0u8; SwapInfo::LEN];
210        let swap_info: SwapInfo = Default::default();
211        let unpack_unchecked = SwapInfo::unpack_unchecked(&packed).unwrap();
212        assert_eq!(unpack_unchecked, swap_info);
213        let err = SwapInfo::unpack(&packed).unwrap_err();
214        assert_eq!(err, ProgramError::UninitializedAccount);
215    }
216}

JavaScript Tests