Staking Program For Graduated Tokens

Author: jack-landon

packages/program/programs/staking/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "staking_rewards"
+version = "0.1.0"
+description = "Created with Anchor"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "staking"
+
+[features]
+default = []
+cpi = ["no-entrypoint"]
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+idl-build = ["anchor-lang/idl-build", "anchor-spl/idl-build"]
+
+[dependencies]
+anchor-lang = {version = "0.30.1", features=["init-if-needed"]}
+anchor-spl = "0.30.1"
+solana-program = "=2.0.3"

packages/program/programs/staking/Xargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

packages/program/programs/staking/src/constants.rs

@@ -0,0 +1,13 @@
+use anchor_lang::prelude::*;
+
+// SEEDS -> ALWAYS PREFIX WITH POOL KEY
+// Reward = reward + mint.key
+// User = signer.key
+// UserReward = reward + mint.key + user.key
+pub const SEED_POOL: &[u8] = b"pool";
+pub const SEED_STAKING_TOKEN_ACCOUNT: &[u8] = b"staking_token_account";
+pub const SEED_REWARD_TOKEN_ACCOUNT: &[u8] = b"reward_token_account";
+pub const SEED_USER: &[u8] = b"user";
+
+#[constant]
+pub const PRECISION: u64 = 1_000_000_000;

packages/program/programs/staking/src/errors.rs

@@ -0,0 +1,41 @@
+use anchor_lang::prelude::*;
+
+#[error_code]
+pub enum ErrorCode {
+  #[msg("Not Distributor")]
+  NotDistributor,
+  #[msg("Zero Amount Added")]
+  ZeroAmount,
+  #[msg("Insufficient Funds")]
+  InsufficientFunds,
+  #[msg("Not Reward Register")]
+  NotRewardRegister,
+  #[msg("Reward Already Exists")]
+  RewardAlreadyExists,
+  #[msg("Pool Already Initialized")]
+  AlreadyInitialized,
+  #[msg("Invalid Rewards Distributor")]
+  InvalidDistributor,
+  #[msg("Math Overflow")]
+  Overflow,
+  #[msg("User Account Not Provided")]
+  UserAccountNotProvided,
+  #[msg("User Reward Account Not Provided")]
+  UserRewardNotProvided,
+  #[msg("User Reward Accounts Have Different Length to Reward Accounts")]
+  RewardsUnalignedWithUserRewards,
+  #[msg("Rewards Passed Do Not Equal the Amount of Rewards in the Pool")]
+  PoolRewardsUnequalToRewardsPassed,
+  #[msg("Order of Rewards Not Same As Pool")]
+  MismatchedReward,
+  #[msg("Mint doesn't Match Reward Mint")]
+  InvalidMint,
+  #[msg("Reward Period Is Still Active")]
+  RewardsStillActive,
+  #[msg("Pool Does Not Match User Account")]
+  MismatchedUserPool,
+  #[msg("Zero Reward Rate")]
+  ZeroRewardRate,
+  #[msg("Invalid Duration")]
+  InvalidDuration,
+}

packages/program/programs/staking/src/events.rs

@@ -0,0 +1,63 @@
+use anchor_lang::prelude::*;
+
+#[event]
+pub struct InitializedPoolEvent {
+    pub pool: Pubkey,
+    pub mint: Pubkey,
+    pub reward: Pubkey,
+    pub distributor: Pubkey,
+    pub staking_token_program: Pubkey,
+    pub reward_token_program: Pubkey,
+    pub duration: u64,
+    pub timestamp: u64,
+    pub mint_decimals: u8,
+    pub reward_mint_decimals: u8,
+}
+
+#[event]
+pub struct AddedRewardEvent {
+    pub pool: Pubkey,
+    pub contributor: Pubkey,
+    pub reward_token_program: Pubkey,
+    pub amount: u64,
+    pub new_pool_reward_amount: u64,
+    pub timestamp: u64,
+}
+
+#[event]
+pub struct DepositEvent {
+    pub pool: Pubkey,
+    pub depositor: Pubkey,
+    pub amount: u64,
+    pub timestamp: u64,
+}
+
+#[event]
+pub struct WithdrawEvent {
+    pub pool: Pubkey,
+    pub withdrawer: Pubkey,
+    pub amount: u64,
+    pub timestamp: u64,
+}
+
+#[event]
+pub struct ClaimEvent {
+    pub pool: Pubkey,
+    pub recipient: Pubkey,
+    pub amount: u64,
+    pub timestamp: u64,
+}
+
+#[event]
+pub struct SetDistributorEvent {
+    pub pool: Pubkey,
+    pub new_distributor: Pubkey,
+    pub timestamp: u64,
+}
+
+#[event]
+pub struct SetDurationEvent {
+    pub pool: Pubkey,
+    pub duration: u64,
+    pub timestamp: u64,
+}

packages/program/programs/staking/src/instructions/add_reward.rs

@@ -0,0 +1,97 @@
+use anchor_lang::prelude::*;
+use anchor_spl::token_interface::{Mint, TokenAccount, TokenInterface, TransferChecked, transfer_checked};
+use crate::{constants::{SEED_POOL, SEED_REWARD_TOKEN_ACCOUNT}, events::AddedRewardEvent, state::Pool, utils::update_reward};
+use crate::errors::ErrorCode;
+
+#[derive(Accounts)]
+pub struct AddReward<'info> {
+    #[account(mut)]
+    signer: Signer<'info>,
+
+    pub mint: InterfaceAccount<'info, Mint>,
+    #[account(
+        mint::token_program = reward_token_program,
+    )]
+    pub reward_mint: InterfaceAccount<'info, Mint>,
+
+    #[account(
+        mut,
+        seeds = [SEED_POOL, mint.key().as_ref(), reward_mint.key().as_ref()],
+        bump = pool.bump,
+    )]
+    pub pool: Account<'info, Pool>,
+
+    #[account(
+        init_if_needed,
+        payer = signer,
+        seeds = [SEED_REWARD_TOKEN_ACCOUNT, pool.key().as_ref()],
+        token::mint = reward_mint,
+        token::authority = pool_reward_token_account,
+        token::token_program = reward_token_program,
+        bump,
+    )]
+    pub pool_reward_token_account: InterfaceAccount<'info, TokenAccount>,
+
+    #[account(
+        mut,
+        associated_token::mint = reward_mint,
+        associated_token::authority = signer,
+        associated_token::token_program = reward_token_program,
+    )]
+    pub user_reward_token_account: InterfaceAccount<'info, TokenAccount>,
+
+    pub reward_token_program: Interface<'info, TokenInterface>,
+    pub system_program: Program<'info, System>,
+}
+
+pub fn process_add_reward(ctx: Context<AddReward>, amount: u64) -> Result<()> {
+    require!(amount > 0, ErrorCode::ZeroAmount);
+    
+    let pool = &mut ctx.accounts.pool;
+
+    require!(pool.mint == ctx.accounts.mint.key(), ErrorCode::InvalidMint);
+
+    let current_timestamp = Clock::get()?.unix_timestamp as u64;
+
+    require!( ctx.accounts.signer.key() == pool.distributor, ErrorCode::NotDistributor);
+
+    // Initializing pool_reward_token_account if not initialized
+    if pool.reward_token_account == Pubkey::default() {
+        pool.reward_token_account = ctx.accounts.pool_reward_token_account.key();
+        pool.bump_reward_token_account = ctx.bumps.pool_reward_token_account
+    }
+
+    update_reward(pool, None)?;
+
+    if current_timestamp >= pool.period_finish {
+        pool.reward_rate = amount.saturating_div(pool.duration);
+    } else {
+        let remaining: u64 = pool.period_finish.saturating_sub(current_timestamp);
+        let leftover: u64 = remaining.saturating_mul(pool.reward_rate);
+        pool.reward_rate = (amount.saturating_add(leftover)).saturating_div(pool.duration);
+    }
+
+    require!(pool.reward_rate > 0, ErrorCode::ZeroRewardRate);
+
+    pool.last_updated = current_timestamp;
+    pool.period_finish = current_timestamp.saturating_add(pool.duration);
+
+    // Do Transfer
+    let transfer_cpi_accounts = TransferChecked {
+        from: ctx.accounts.user_reward_token_account.to_account_info(),
+        to: ctx.accounts.pool_reward_token_account.to_account_info(),
+        authority: ctx.accounts.signer.to_account_info(),
+        mint: ctx.accounts.reward_mint.to_account_info(),
+    };
+
+    let cpi_program = ctx.accounts.reward_token_program.to_account_info();
+    let cpi_ctx = CpiContext::new(cpi_program, transfer_cpi_accounts);
+
+    transfer_checked(cpi_ctx, amount, ctx.accounts.reward_mint.decimals)?;
+
+    let new_pool_reward_amount = pool.duration.saturating_mul(pool.reward_rate);
+
+    emit!(AddedRewardEvent { pool: pool.key(), contributor: ctx.accounts.signer.key(), reward_token_program: ctx.accounts.reward_token_program.key(), amount: amount, new_pool_reward_amount: new_pool_reward_amount, timestamp: current_timestamp });
+
+    Ok(())
+}

packages/program/programs/staking/src/instructions/claim.rs

@@ -0,0 +1,87 @@
+use anchor_lang::prelude::*;
+use anchor_spl::token_interface::{Mint, TokenAccount, TokenInterface, TransferChecked, transfer_checked};
+use crate::{constants::{SEED_POOL, SEED_REWARD_TOKEN_ACCOUNT, SEED_USER}, events::ClaimEvent, state::{Pool, User}, utils::update_reward};
+use crate::errors::ErrorCode;
+
+#[derive(Accounts)]
+pub struct Claim<'info> {
+    #[account(mut)]
+    pub signer: Signer<'info>,
+
+    pub mint: InterfaceAccount<'info, Mint>,
+    pub reward_mint: InterfaceAccount<'info, Mint>,
+    
+    #[account(
+        mut,
+        seeds = [SEED_POOL, mint.key().as_ref(), reward_mint.key().as_ref()],
+        bump = pool.bump,
+    )]
+    pub pool: Account<'info, Pool>,
+
+    #[account(
+        mut,
+        seeds = [SEED_REWARD_TOKEN_ACCOUNT, pool.key().as_ref()],
+        bump = pool.bump_reward_token_account,
+    )]
+    pub pool_reward_token_account: InterfaceAccount<'info, TokenAccount>,
+
+    #[account(
+        mut,
+        seeds = [SEED_USER, pool.key().as_ref(), signer.key().as_ref()],
+        bump,
+    )]
+    pub user: Account<'info, User>,
+
+    #[account(
+        mut, // Don't need to init as this is done during deposit
+        associated_token::mint = reward_mint,
+        associated_token::authority = signer,
+        associated_token::token_program = reward_token_program,
+    )]
+    pub user_reward_token_account: InterfaceAccount<'info, TokenAccount>,
+
+    pub reward_token_program: Interface<'info, TokenInterface>,
+}
+
+pub fn process_claim(ctx: Context<Claim>) -> Result<()> {
+    let pool = &mut ctx.accounts.pool;
+    let user = &mut ctx.accounts.user;
+
+    require!(pool.mint == ctx.accounts.mint.key(), ErrorCode::InvalidMint);
+
+    update_reward(pool, Some(user))?;
+
+    let cpi_program = ctx.accounts.reward_token_program.to_account_info();
+
+    let cpi_accounts = TransferChecked {
+        from: ctx.accounts.pool_reward_token_account.to_account_info(),
+        to: ctx.accounts.user_reward_token_account.to_account_info(),
+        authority: ctx.accounts.pool_reward_token_account.to_account_info(),
+        mint: ctx.accounts.reward_mint.to_account_info()
+    };
+
+    let pool_key = pool.key();
+
+    // from account seeds + from account bump
+    let signer_seeds: &[&[&[u8]]] = &[
+        &[
+            SEED_REWARD_TOKEN_ACCOUNT,
+            pool_key.as_ref(),
+            &[pool.bump_reward_token_account],
+        ]
+    ];
+
+    let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer_seeds);
+
+    let amount = user.pending_payout;
+
+    transfer_checked(cpi_ctx, amount, ctx.accounts.reward_mint.decimals)?;
+
+    user.pending_payout = 0;
+
+    let timestamp = Clock::get()?.unix_timestamp as u64;
+
+    emit!(ClaimEvent { pool: pool.key(), recipient: ctx.accounts.signer.key(), amount: amount, timestamp: timestamp });
+
+    Ok(())
+}