triad_protocol/instructions/stake/
stake_nft.rs

1use std::str::FromStr;
2use crate::{
3    constants::{ MYSTERY_BOX_PROGRAM, TRIAD_MYSTERY_BOX },
4    errors::TriadProtocolError,
5    state::{ StakeNFTArgs, StakeVault },
6    StakeV2,
7};
8use anchor_lang::prelude::*;
9use anchor_spl::token_2022::spl_token_2022::extension::BaseStateWithExtensions;
10use anchor_spl::token_2022::{
11    spl_token_2022::{ extension::PodStateWithExtensions, pod::PodMint },
12    Token2022,
13};
14use anchor_spl::{
15    associated_token::AssociatedToken,
16    token_interface::{ transfer_checked, Mint, TokenAccount, TransferChecked },
17};
18use spl_token_metadata_interface::state::TokenMetadata;
19
20#[derive(Accounts)]
21#[instruction(args: StakeNFTArgs)]
22pub struct StakeNFT<'info> {
23    #[account(mut)]
24    pub signer: Signer<'info>,
25
26    #[account(mut, seeds = [StakeVault::PREFIX_SEED, args.stake_vault.as_bytes()], bump)]
27    pub stake_vault: Box<Account<'info, StakeVault>>,
28
29    #[account(
30        init_if_needed,
31        payer = signer,
32        space = StakeV2::SPACE,
33        seeds = [
34            StakeV2::PREFIX_SEED,
35            signer.to_account_info().key().as_ref(),
36            args.name.as_bytes(),
37        ],
38        bump
39    )]
40    pub stake: Box<Account<'info, StakeV2>>,
41
42    #[account(
43        mut,
44        extensions::metadata_pointer::metadata_address = mint
45    )]
46    pub mint: Box<InterfaceAccount<'info, Mint>>,
47
48    #[account(
49        mut, 
50        constraint = from_ata.amount >= 1 && signer.key() == from_ata.owner && from_ata.mint == mint.key(),
51    )]
52    pub from_ata: Box<InterfaceAccount<'info, TokenAccount>>,
53
54    #[account(
55        init_if_needed,
56        payer = signer,
57        associated_token::mint = mint,
58        associated_token::authority = stake_vault
59    )]
60    pub to_ata: Box<InterfaceAccount<'info, TokenAccount>>,
61
62    pub token_program: Program<'info, Token2022>,
63    pub associated_token_program: Program<'info, AssociatedToken>,
64    pub system_program: Program<'info, System>,
65}
66
67pub fn stake_nft(ctx: Context<StakeNFT>, args: StakeNFTArgs) -> Result<()> {
68    let mint = &ctx.accounts.mint.to_account_info();
69    let buffer = mint.try_borrow_data()?;
70    let state = PodStateWithExtensions::<PodMint>::unpack(&buffer)?;
71    let token_metadata = state.get_variable_len_extension::<TokenMetadata>()?;
72
73    if token_metadata.update_authority.0 != Pubkey::from_str(TRIAD_MYSTERY_BOX).unwrap() {
74        return Err(TriadProtocolError::Unauthorized.into());
75    }
76
77    let (mint_seed, _bump) = Pubkey::find_program_address(
78        &[b"mint", args.name.as_bytes()],
79        &Pubkey::from_str(MYSTERY_BOX_PROGRAM).unwrap()
80    );
81
82    if mint_seed != *mint.key {
83        return Err(TriadProtocolError::Unauthorized.into());
84    }
85
86    let stake = &mut ctx.accounts.stake;
87    let stake_vault = &mut ctx.accounts.stake_vault;
88
89    if stake_vault.is_locked {
90        return Err(TriadProtocolError::StakeVaultLocked.into());
91    }
92
93    stake.bump = ctx.bumps.stake;
94    stake.authority = *ctx.accounts.signer.key;
95    stake.init_ts = Clock::get()?.unix_timestamp;
96    stake.withdraw_ts = 0;
97    stake.claimed_ts = 0;
98    stake.name = args.name;
99    stake.mint = *mint.key;
100    stake.boost = false;
101    stake.stake_vault = stake_vault.key();
102    stake.claimed = 0;
103    stake.available = 0;
104    stake.amount = 1;
105
106    stake_vault.nft_staked += 1;
107
108    transfer_checked(
109        CpiContext::new(ctx.accounts.token_program.to_account_info(), TransferChecked {
110            from: ctx.accounts.from_ata.to_account_info(),
111            mint: ctx.accounts.mint.to_account_info(),
112            to: ctx.accounts.to_ata.to_account_info(),
113            authority: ctx.accounts.signer.to_account_info(),
114        }),
115        1,
116        ctx.accounts.mint.decimals
117    )?;
118
119    Ok(())
120}