Feat/solana missing features

package.json

@@ -1,7 +1,6 @@
 {
   "type": "module",
   "scripts": {
-    "anchor:script": "anchor run script --",
     "build": "RUSTUP_TOOLCHAIN=\"nightly-2024-05-09\" anchor build",
     "test": "yarn test:anchor && yarn test:cargo",
     "test:cargo": "anchor run test-cargo",

programs/access-control/Cargo.toml

@@ -15,6 +15,7 @@ no-entrypoint = []
 no-idl = []
 no-log-ix-name = []
 idl-build = ["anchor-lang/idl-build"]
+anchor-debug = []
 
 [dependencies]
 anchor-lang = "0.30.1"

programs/data-feed/Cargo.toml

@@ -15,6 +15,7 @@ no-entrypoint = []
 no-idl = []
 no-log-ix-name = []
 idl-build = ["anchor-lang/idl-build"]
+anchor-debug = []
 
 [dependencies]
 anchor-lang = "0.30.1"

programs/midas-vault/Cargo.toml

@@ -15,6 +15,7 @@ no-entrypoint = []
 no-idl = []
 no-log-ix-name = []
 idl-build = ["anchor-lang/idl-build", "anchor-spl/idl-build"]
+anchor-debug = []
 
 [dependencies]
 anchor-lang = "0.30.1"

programs/midas-vault/src/errors.rs

@@ -42,4 +42,6 @@ pub enum MidasVaultsError {
     InvalidVaultProvided,
     #[msg("The new value is the same as the old one")]
     ValueDidntChange,
+    #[msg("Max supply cap exceeded")]
+    MaxSupplyCapExceeded,
 }

programs/midas-vault/src/events.rs

@@ -113,6 +113,8 @@ pub struct MinterVaultUpdatedEvent {
     pub first_deposit_min_m_tokens: Option<u64>,
     /// mint authority pda (token-authority program)
     pub mint_authority_pda: Option<Pubkey>,
+    /// max supply cap for mToken minting
+    pub max_supply_cap: Option<u64>,
 }
 
 #[event]

programs/midas-vault/src/instructions/minter_vault/approve_mint_request.rs

@@ -7,10 +7,9 @@ use token_authority::{
 };
 
 use crate::{
-    constants::{ac_roles, ONE},
-    events::MinterVaultRequestApprovedEvent,
+    constants::ac_roles,
     state::{MintVaultRequestState, MinterVaultState, VaultCommonState},
-    utils::{close_account, mint_token, require_variation_tolerance, Closable},
+    utils::{close_account, minter, Closable},
 };
 
 #[derive(Accounts)]
@@ -29,7 +28,9 @@ pub struct ApproveMintRequest<'info> {
     pub user_account: AccountInfo<'info>,
 
     /// Vault common state account
-    #[account()]
+    #[account(
+        address = minter_vault.common_vault
+    )]
     pub vault_common: Account<'info, VaultCommonState>,
 
     /// Admin role of authority
@@ -121,49 +122,36 @@ impl<'info> Closable for ApproveMintRequest<'info> {
 /// - `new_out_rate` - new out rate for the mint request.
 /// Using this value admin can correct the output mToken amount
 /// - `is_safe` - if true, will check variation tolerance before minting
+/// - `skip_on_supply_cap_exceeded` - if true, will skip minting and return success
 pub fn handle(
     ctx: Context<ApproveMintRequest>,
     request_id: u64,
     new_out_rate: u64,
     is_safe: bool,
+    skip_on_supply_cap_exceeded: bool,
 ) -> Result<()> {
-    let request = &ctx.accounts.mint_request;
-
-    if is_safe {
-        require_variation_tolerance(
-            &ctx.accounts.vault_common,
-            request.m_mint_rate.into(),
-            new_out_rate.into(),
-        )?;
+    match minter::approve_mint_request(
+        &ctx.accounts.mint_request,
+        &ctx.accounts.vault_common,
+        &ctx.accounts.minter_vault,
+        &ctx.accounts.m_mint,
+        &ctx.accounts.m_mint_user_ata,
+        &ctx.accounts.m_mint_token_program,
+        &ctx.accounts.user_account,
+        &ctx.accounts.token_authority,
+        &ctx.accounts.vault_minter_role,
+        &ctx.accounts.system_program,
+        &ctx.accounts.token_authority_program,
+        request_id,
+        new_out_rate.into(),
+        is_safe,
+        skip_on_supply_cap_exceeded,
+    ) {
+        Ok(true) => {
+            ctx.accounts.close()?;
+            Ok(())
+        }
+        Ok(false) => Ok(()),
+        Err(e) => Err(e),
     }
-
-    let amount_to_mint = (request.deposited_usd_wo_fees as u128)
-        .checked_mul(ONE.into())
-        .unwrap()
-        .checked_div(new_out_rate.into())
-        .unwrap();
-
-    mint_token(
-        &ctx.accounts.vault_common.key(),
-        &ctx.accounts.minter_vault.to_account_info(),
-        &ctx.accounts.user_account.to_account_info(),
-        &ctx.accounts.token_authority.to_account_info(),
-        &ctx.accounts.vault_minter_role.to_account_info(),
-        &ctx.accounts.m_mint.to_account_info(),
-        &ctx.accounts.m_mint_user_ata.to_account_info(),
-        &ctx.accounts.m_mint_token_program.to_account_info(),
-        &ctx.accounts.system_program.to_account_info(),
-        &ctx.accounts.token_authority_program.to_account_info(),
-        amount_to_mint.try_into().unwrap(),
-    )?;
-
-    ctx.accounts.close()?;
-
-    emit!(MinterVaultRequestApprovedEvent {
-        common_vault: ctx.accounts.vault_common.key(),
-        new_out_rate,
-        request_id
-    });
-
-    Ok(())
 }

programs/midas-vault/src/instructions/minter_vault/mint_instant.rs

@@ -20,7 +20,8 @@ use crate::{
     utils::{
         mint_token,
         minter::{self},
-        require_and_update_limit, transfer_token, validate_common, Validate, VaultActionId,
+        require_and_update_limit, transfer_token, validate_common, validate_max_supply_cap,
+        Validate, VaultActionId,
     },
 };
 
@@ -259,6 +260,14 @@ pub fn handle(
         )?;
     }
 
+    if !validate_max_supply_cap(
+        &ctx.accounts.m_mint,
+        &ctx.accounts.minter_vault,
+        params.m_token_amount.try_into().unwrap(),
+    ) {
+        return Err(MidasVaultsError::MaxSupplyCapExceeded.into());
+    }
+
     mint_token(
         &ctx.accounts.vault_common.key(),
         &ctx.accounts.minter_vault.to_account_info(),

programs/midas-vault/src/instructions/minter_vault/mod.rs

@@ -18,6 +18,14 @@ pub mod approve_mint_request;
 #[allow(ambiguous_glob_reexports)]
 pub use approve_mint_request::*;
 
+pub mod safe_approve_mint_request_at_current_rate;
+#[allow(ambiguous_glob_reexports)]
+pub use safe_approve_mint_request_at_current_rate::*;
+
+pub mod safe_approve_mint_request_at_request_rate;
+#[allow(ambiguous_glob_reexports)]
+pub use safe_approve_mint_request_at_request_rate::*;
+
 pub mod reject_mint_request;
 #[allow(ambiguous_glob_reexports)]
 pub use reject_mint_request::*;

programs/midas-vault/src/instructions/minter_vault/new_minter_vault.rs

@@ -57,15 +57,22 @@ pub struct NewMinterVault<'info> {
 /// # Arguments
 ///
 /// - `first_deposit_min_m_tokens` - minimum amount of mTokens required for the first deposit
-pub fn handle(ctx: Context<NewMinterVault>, first_deposit_min_m_tokens: u64) -> Result<()> {
+/// - `max_supply_cap` - maximum supply cap for mToken minting (use u64::MAX for no cap)
+pub fn handle(
+    ctx: Context<NewMinterVault>,
+    first_deposit_min_m_tokens: u64,
+    max_supply_cap: u64,
+) -> Result<()> {
     ctx.accounts.minter_vault.common_vault = ctx.accounts.vault_common.key();
     ctx.accounts.minter_vault.first_deposit_min_m_tokens = first_deposit_min_m_tokens;
     ctx.accounts.minter_vault.mint_authority_pda = ctx.accounts.token_authority.key();
+    ctx.accounts.minter_vault.max_supply_cap = max_supply_cap;
 
     emit!(MinterVaultUpdatedEvent {
         common_vault: ctx.accounts.vault_common.key(),
         first_deposit_min_m_tokens: Some(first_deposit_min_m_tokens),
-        mint_authority_pda: Some(ctx.accounts.token_authority.key())
+        mint_authority_pda: Some(ctx.accounts.token_authority.key()),
+        max_supply_cap: Some(max_supply_cap),
     });
 
     Ok(())

programs/midas-vault/src/instructions/minter_vault/reject_mint_request.rs

@@ -22,7 +22,9 @@ pub struct RejectMintRequest<'info> {
     pub user_account: AccountInfo<'info>,
 
     /// Vault common state account
-    #[account()]
+    #[account(
+        address = minter_vault.common_vault
+    )]
     pub vault_common: Account<'info, VaultCommonState>,
 
     /// Admin role of authority

programs/midas-vault/src/instructions/minter_vault/safe_approve_mint_request_at_current_rate.rs

@@ -0,0 +1,173 @@
+use access_control::{program::AccessControl, state::AccountAccessControlRoleState};
+use anchor_lang::prelude::*;
+use anchor_spl::token_interface::{Mint, TokenAccount, TokenInterface};
+use data_feed::state::FeedState;
+use token_authority::{
+    constants::ac_roles as ac_roles_token_authority, program::TokenAuthority,
+    state::TokenAuthorityState,
+};
+
+use crate::{
+    constants::ac_roles,
+    state::{MintVaultRequestState, MinterVaultState, VaultCommonState},
+    utils::{close_account, get_token_rate, minter, Closable},
+};
+
+#[derive(Accounts)]
+#[instruction(request_id: u64)]
+pub struct SafeApproveMintRequestAtCurrentRate<'info> {
+    /// Account with vault admin role
+    #[account(mut)]
+    pub authority: Signer<'info>,
+
+    /// CHECK:
+    /// request user account
+    #[account(
+        mut,
+        address = mint_request.user
+    )]
+    pub user_account: AccountInfo<'info>,
+
+    /// Vault common state account
+    #[account(
+        address = minter_vault.common_vault
+    )]
+    pub vault_common: Account<'info, VaultCommonState>,
+
+    /// Admin role of authority
+    #[account(
+        seeds = [AccountAccessControlRoleState::SEED, vault_common.ac_role.as_ref(), authority.key().as_ref(), ac_roles::VAULT_ADMIN],
+        seeds::program = AccessControl::id(),
+        bump,
+    )]
+    pub authority_ac_role: Account<'info, AccountAccessControlRoleState>,
+
+    /// Vault minter role
+    #[account(
+        seeds = [AccountAccessControlRoleState::SEED, token_authority.ac_role.as_ref(), minter_vault.key().as_ref(), ac_roles_token_authority::M_MINTER],
+        seeds::program = AccessControl::id(),
+        bump,
+    )]
+    pub vault_minter_role: Account<'info, AccountAccessControlRoleState>,
+
+    /// Minter vault state account
+    #[account(
+        mut,
+        seeds = [MinterVaultState::SEED, vault_common.key().as_ref()],
+        bump
+    )]
+    pub minter_vault: Account<'info, MinterVaultState>,
+
+    /// Mint vault request state account
+    #[account(
+        mut,
+        seeds = [MintVaultRequestState::SEED, minter_vault.key().as_ref(), &request_id.to_le_bytes()],
+        bump
+    )]
+    pub mint_request: Account<'info, MintVaultRequestState>,
+
+    /// Token authority state account (token-authority program)
+    #[account(
+        mut,
+        address = minter_vault.mint_authority_pda,
+        owner = TokenAuthority::id()
+    )]
+    pub token_authority: Account<'info, TokenAuthorityState>,
+
+    /// mMint ATA of `user_account`
+    #[account(
+        mut,
+        associated_token::token_program = m_mint_token_program,
+        associated_token::mint = m_mint,
+        associated_token::authority = user_account,
+    )]
+    pub m_mint_user_ata: Box<InterfaceAccount<'info, TokenAccount>>,
+
+    /// SPL mint account
+    #[account(
+        mut,
+        mint::token_program = m_mint_token_program,
+        address = vault_common.m_mint
+    )]
+    pub m_mint: Box<InterfaceAccount<'info, Mint>>,
+
+    /// mMint data feed state account
+    #[account(
+        address = vault_common.m_mint_feed
+    )]
+    pub m_mint_data_feed: Account<'info, FeedState>,
+
+    /// CHECK:
+    /// mMint underlying feed account
+    #[account(
+        address = m_mint_data_feed.underlying_feed
+    )]
+    pub m_mint_feed: AccountInfo<'info>,
+
+    /// SPL token program for mMint
+    pub m_mint_token_program: Interface<'info, TokenInterface>,
+    /// Token authority program
+    pub token_authority_program: Program<'info, TokenAuthority>,
+    /// System program
+    pub system_program: Program<'info, System>,
+}
+
+impl<'info> Closable for SafeApproveMintRequestAtCurrentRate<'info> {
+    /// close implementation for closing mint request
+    /// after it was processed
+    fn close(&mut self) -> Result<()> {
+        close_account(
+            &mut self.mint_request.to_account_info(),
+            &mut self.user_account,
+            &self.system_program,
+        )?;
+
+        Ok(())
+    }
+}
+
+/// Safely approves mint request at the current mToken rate from data feed.
+/// Validates variation tolerance between request rate and current rate.
+/// Will close mint request account after processing.
+/// Can only be called by the vault admin.
+///
+/// # Arguments
+///
+/// - `request_id` - id of the mint request
+/// - `skip_on_supply_cap_exceeded` - if true, will skip minting and return success
+pub fn handle(
+    ctx: Context<SafeApproveMintRequestAtCurrentRate>,
+    request_id: u64,
+    skip_on_supply_cap_exceeded: bool,
+) -> Result<()> {
+    let current_rate = get_token_rate(
+        &ctx.accounts.m_mint_data_feed,
+        &ctx.accounts.m_mint_feed,
+        false,
+    )?;
+
+    match minter::approve_mint_request(
+        &ctx.accounts.mint_request,
+        &ctx.accounts.vault_common,
+        &ctx.accounts.minter_vault,
+        &ctx.accounts.m_mint,
+        &ctx.accounts.m_mint_user_ata,
+        &ctx.accounts.m_mint_token_program,
+        &ctx.accounts.user_account,
+        &ctx.accounts.token_authority,
+        &ctx.accounts.vault_minter_role,
+        &ctx.accounts.system_program,
+        &ctx.accounts.token_authority_program,
+        request_id,
+        current_rate,
+        true,
+        skip_on_supply_cap_exceeded,
+    ) {
+        Ok(true) => {
+            ctx.accounts.close()?;
+            Ok(())
+        }
+        Ok(false) => Ok(()),
+        Err(e) => Err(e),
+    }
+}