gmsol_store/events/
gt.rs

1use anchor_lang::prelude::*;
2use borsh::BorshSerialize;
3
4use crate::states::{gt::GtState, user};
5
6use super::Event;
7
8/// GT updated event.
9#[event]
10#[cfg_attr(feature = "debug", derive(derive_more::Debug))]
11#[derive(InitSpace)]
12pub struct GtUpdated {
13    /// Update kind.
14    pub kind: GtUpdateKind,
15    /// Receiver.
16    pub receiver: Option<Pubkey>,
17    /// Receiver Delta.
18    pub receiver_delta: u64,
19    /// Receiver balance.
20    pub receiver_balance: Option<u64>,
21    /// Minting cost.
22    pub minting_cost: u128,
23    /// Total minted.
24    pub total_minted: u64,
25    /// Grow steps.
26    pub grow_steps: u64,
27    /// Latest supply.
28    pub supply: u64,
29    /// Vault.
30    pub vault: u64,
31    #[cfg_attr(feature = "debug", debug(skip))]
32    reserved: [u8; 64],
33}
34
35/// GT Update Kind.
36#[derive(AnchorSerialize, AnchorDeserialize, InitSpace)]
37#[cfg_attr(feature = "debug", derive(derive_more::Debug))]
38pub enum GtUpdateKind {
39    /// Reward.
40    Reward,
41    /// Mint.
42    Mint,
43    /// Burn.
44    Burn,
45}
46
47impl gmsol_utils::InitSpace for GtUpdated {
48    const INIT_SPACE: usize = <Self as Space>::INIT_SPACE;
49}
50
51impl Event for GtUpdated {}
52
53impl GtUpdated {
54    fn new(
55        kind: GtUpdateKind,
56        minting_cost: Option<u128>,
57        delta: u64,
58        state: &GtState,
59        receiver: Option<&user::UserHeader>,
60    ) -> Self {
61        Self {
62            kind,
63            receiver: receiver.map(|header| header.owner),
64            receiver_delta: delta,
65            receiver_balance: receiver.map(|header| header.gt().amount()),
66            minting_cost: minting_cost.unwrap_or(state.minting_cost()),
67            total_minted: state.total_minted(),
68            grow_steps: state.grow_steps(),
69            supply: state.supply(),
70            vault: state.gt_vault(),
71            reserved: [0; 64],
72        }
73    }
74
75    /// Create a new rewarded event.
76    pub fn rewarded(amount: u64, state: &GtState, receiver: Option<&user::UserHeader>) -> Self {
77        Self::new(GtUpdateKind::Reward, None, amount, state, receiver)
78    }
79
80    /// Create a new minted event.
81    pub fn minted(
82        minting_cost: u128,
83        amount: u64,
84        state: &GtState,
85        receiver: Option<&user::UserHeader>,
86    ) -> Self {
87        Self::new(
88            GtUpdateKind::Mint,
89            Some(minting_cost),
90            amount,
91            state,
92            receiver,
93        )
94    }
95
96    /// Create a new burned event.
97    pub fn burned(amount: u64, state: &GtState, receiver: Option<&user::UserHeader>) -> Self {
98        Self::new(GtUpdateKind::Burn, None, amount, state, receiver)
99    }
100}