triad-protocol 0.1.4

Triad protocol, trade solana projects
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

use crate::constants::{ ADMIN, TTRIAD_MINT };
use crate::constraints::{ is_authority_for_stake, is_mint_for_stake };
use crate::{ errors::TriadProtocolError, StakeVault };
use crate::{ StakeV2, User };
use anchor_lang::prelude::*;
use anchor_spl::token_2022::{ close_account, CloseAccount, Token2022 };
use anchor_spl::{
    associated_token::AssociatedToken,
    token_interface::{ transfer_checked, Mint, TokenAccount, TransferChecked },
};
use std::str::FromStr;

#[derive(Accounts)]
pub struct WithdrawStake<'info> {
    #[account(mut)]
    pub signer: Signer<'info>,

    #[account(mut)]
    pub stake_vault: Box<Account<'info, StakeVault>>,

    #[account(mut, constraint = user.authority == *signer.key)]
    pub user: Box<Account<'info, User>>,

    #[account(mut, close = signer, constraint = is_authority_for_stake(&stake, &signer)?)]
    pub stake: Box<Account<'info, StakeV2>>,

    /// CHECK: Just Admin account the recovery the rent
    #[account(mut, constraint = admin.key.to_string() == ADMIN)]
    pub admin: AccountInfo<'info>,

    #[account(mut, constraint = is_mint_for_stake(&stake, &mint.key())?)]
    pub mint: Box<InterfaceAccount<'info, Mint>>,

    #[account(mut)]
    pub from_ata: Box<InterfaceAccount<'info, TokenAccount>>,

    #[account(
        init_if_needed,
        payer = signer,
        constraint = to_ata.owner == *signer.key && to_ata.mint == mint.key(),
        associated_token::mint = mint,
        associated_token::authority = signer
    )]
    pub to_ata: Box<InterfaceAccount<'info, TokenAccount>>,

    pub token_program: Program<'info, Token2022>,
    pub associated_token_program: Program<'info, AssociatedToken>,
    pub system_program: Program<'info, System>,
}

pub fn withdraw_stake(ctx: Context<WithdrawStake>) -> Result<()> {
    let stake = &mut ctx.accounts.stake;
    let stake_vault = &mut ctx.accounts.stake_vault;
    let user = &mut ctx.accounts.user;

    if stake.withdraw_ts > Clock::get()?.unix_timestamp {
        return Err(TriadProtocolError::StakeLocked.into());
    }

    let signer: &[&[&[u8]]] = &[
        &[b"stake_vault", stake_vault.name.as_bytes(), &[stake_vault.bump]],
    ];

    let is_token_stake = stake.mint.eq(&Pubkey::from_str(TTRIAD_MINT).unwrap());

    let mut amount = 1;

    if is_token_stake {
        amount = stake.amount;
    }

    transfer_checked(
        CpiContext::new_with_signer(
            ctx.accounts.token_program.to_account_info(),
            TransferChecked {
                from: ctx.accounts.from_ata.to_account_info().clone(),
                mint: ctx.accounts.mint.to_account_info().clone(),
                to: ctx.accounts.to_ata.to_account_info().clone(),
                authority: stake_vault.to_account_info(),
            },
            signer
        ),
        amount,
        ctx.accounts.mint.decimals
    )?;

    if is_token_stake {
        stake_vault.token_staked -= stake.amount;
        user.staked -= stake.amount;
    } else {
        close_account(
            CpiContext::new_with_signer(
                ctx.accounts.token_program.to_account_info(),
                CloseAccount {
                    account: ctx.accounts.from_ata.to_account_info(),
                    destination: ctx.accounts.admin.to_account_info(),
                    authority: stake_vault.to_account_info(),
                },
                signer
            )
        )?;

        stake_vault.nft_staked -= 1;
    }

    Ok(())
}