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

use crate::{
    constraints::is_mint_for_stake_vault,
    errors::TriadProtocolError,
    state::{ StakeTokenArgs, StakeVault },
    StakeV2,
    User,
};
use anchor_lang::prelude::*;
use anchor_spl::token_2022::{ Token2022, transfer_checked, TransferChecked };
use anchor_spl::{ associated_token::AssociatedToken, token_interface::{ Mint, TokenAccount } };

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

    #[account(mut, seeds = [StakeVault::PREFIX_SEED, args.stake_vault.as_bytes()], bump)]
    pub stake_vault: Box<Account<'info, StakeVault>>,

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

    #[account(
        init,
        payer = signer,
        space = StakeV2::SPACE,
        seeds = [
            StakeV2::PREFIX_SEED,
            signer.to_account_info().key().as_ref(),
            args.name.as_bytes(),
        ],
        bump
    )]
    pub stake: Box<Account<'info, StakeV2>>,

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

    #[account(
        mut, 
        constraint = from_ata.amount >= args.amount && signer.key() == from_ata.owner && from_ata.mint == mint.key(),
    )]
    pub from_ata: Box<InterfaceAccount<'info, TokenAccount>>,

    #[account(
        init_if_needed,
        payer = signer,
        associated_token::mint = mint,
        associated_token::authority = stake_vault
    )]
    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 stake_token(ctx: Context<StakeToken>, args: StakeTokenArgs) -> Result<()> {
    let mint = &ctx.accounts.mint.to_account_info();
    let stake = &mut ctx.accounts.stake;
    let stake_vault = &mut ctx.accounts.stake_vault;
    let user = &mut ctx.accounts.user;

    if stake_vault.is_locked {
        return Err(TriadProtocolError::StakeVaultLocked.into());
    }

    stake.bump = ctx.bumps.stake;
    stake.authority = *ctx.accounts.signer.key;
    stake.init_ts = Clock::get()?.unix_timestamp;
    stake.withdraw_ts = 0;
    stake.claimed_ts = 0;
    stake.name = args.name;
    stake.mint = *mint.key;
    stake.boost = false;
    stake.stake_vault = stake_vault.key();
    stake.claimed = 0;
    stake.available = 0;
    stake.amount = args.amount;

    stake_vault.token_staked += args.amount;

    user.staked += args.amount;

    let result = user.staked / (10u64).pow(stake_vault.token_decimals as u32) / 10000;

    if result > (i16::MAX as u64) {
        return Err(TriadProtocolError::StakeOverflow.into());
    } else {
        user.swaps = result as i16;
    }

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

    Ok(())
}