feat: permissioned fee vault and close fee vault

programs/dynamic-fee-sharing/src/event.rs

@@ -27,3 +27,12 @@ pub struct EvtClaimFee {
     pub index: u8,
     pub claimed_fee: u64,
 }
+
+#[event]
+pub struct EvtCloseFeeVault {
+    pub fee_vault: Pubkey,
+    pub admin: Pubkey,
+    pub fee_receiver: Pubkey,
+    pub rent_receiver: Pubkey,
+    pub remaining_fee: u64,
+}

programs/dynamic-fee-sharing/src/instructions/ix_close_permission_fee_vault.rs

@@ -0,0 +1,74 @@
+use crate::{
+    constants::seeds::FEE_VAULT_AUTHORITY_PREFIX, 
+    event::EvtCloseFeeVault, 
+    state::FeeVault, 
+    utils::token::transfer_from_fee_vault
+};
+use anchor_lang::prelude::*;
+use anchor_spl::token_interface::{Mint, TokenAccount, TokenInterface};
+
+#[event_cpi]
+#[derive(Accounts)]
+pub struct ClosePermissionFeeVaultCtx<'info> {
+    /// CHECK: pool authority
+    #[account(
+            seeds = [
+                FEE_VAULT_AUTHORITY_PREFIX.as_ref(),
+            ],
+            bump,
+        )]
+    pub fee_vault_authority: UncheckedAccount<'info>,
+
+    #[account(
+        mut,
+        has_one = admin,
+        has_one = token_vault,
+        has_one = token_mint, 
+        close = rent_receiver
+    )]
+    pub fee_vault: AccountLoader<'info, FeeVault>,
+
+    #[account(mut)]
+    pub token_vault: Box<InterfaceAccount<'info, TokenAccount>>,
+
+    #[account(
+        mint::token_program = token_program,
+    )]
+    pub token_mint: Box<InterfaceAccount<'info, Mint>>,
+
+    /// CHECK: rent fee receiver
+    #[account(mut)]
+    pub rent_receiver: UncheckedAccount<'info>,
+
+    /// CHECK: remaining fee receiver
+    #[account(mut)]
+    pub fee_receiver: Box<InterfaceAccount<'info, TokenAccount>>,
+
+    pub admin: Signer<'info>,
+
+    pub token_program: Interface<'info, TokenInterface>,
+}
+
+pub fn handle_close_permission_fee_vault(ctx: Context<ClosePermissionFeeVaultCtx>) -> Result<()> {
+    let remaining_fee = ctx.accounts.token_vault.amount;
+    if remaining_fee > 0 {
+        transfer_from_fee_vault(
+            ctx.accounts.fee_vault_authority.to_account_info(),
+            &ctx.accounts.token_mint,
+            &ctx.accounts.token_vault,
+            &ctx.accounts.fee_receiver,
+            &ctx.accounts.token_program,
+            remaining_fee,
+        )?;
+
+        emit_cpi!(EvtCloseFeeVault{
+            fee_vault: ctx.accounts.fee_vault.key(),
+            admin: ctx.accounts.admin.key(),
+            fee_receiver: ctx.accounts.fee_receiver.key(),
+            rent_receiver: ctx.accounts.rent_receiver.key(),
+            remaining_fee
+        })
+    }
+
+    Ok(())
+}

programs/dynamic-fee-sharing/src/instructions/ix_initialize_fee_vault.rs

@@ -108,6 +108,7 @@ pub fn handle_initialize_fee_vault(
         &Pubkey::default(),
         0,
         FeeVaultType::NonPdaAccount.into(),
+        &Pubkey::default(),
     )?;
 
     emit_cpi!(EvtInitializeFeeVault {
@@ -130,6 +131,7 @@ pub fn create_fee_vault<'info>(
     base: &Pubkey,
     fee_vault_bump: u8,
     fee_vault_type: u8,
+    admin: &Pubkey,
 ) -> Result<()> {
     require!(is_supported_mint(&token_mint)?, FeeVaultError::InvalidMint);
 
@@ -145,6 +147,7 @@ pub fn create_fee_vault<'info>(
         fee_vault_bump,
         fee_vault_type,
         &params.users,
+        admin,
     )?;
     Ok(())
 }

programs/dynamic-fee-sharing/src/instructions/ix_initialize_fee_vault_pda.rs

@@ -80,6 +80,7 @@ pub fn handle_initialize_fee_vault_pda(
         &ctx.accounts.base.key,
         ctx.bumps.fee_vault,
         FeeVaultType::PdaAccount.into(),
+        &Pubkey::default(),
     )?;
 
     emit_cpi!(EvtInitializeFeeVault {

programs/dynamic-fee-sharing/src/instructions/ix_initialize_permission_fee_vault.rs

@@ -0,0 +1,98 @@
+use crate::constants::seeds::FEE_VAULT_PREFIX;
+use crate::event::EvtInitializeFeeVault;
+use crate::state::FeeVaultType;
+use crate::{
+    constants::seeds::{FEE_VAULT_AUTHORITY_PREFIX, TOKEN_VAULT_PREFIX},
+    state::FeeVault,
+};
+use crate::{create_fee_vault, InitializeFeeVaultParameters};
+use anchor_lang::prelude::*;
+use anchor_spl::token_interface::{Mint, TokenAccount, TokenInterface};
+
+#[event_cpi]
+#[derive(Accounts)]
+pub struct InitializePermissionFeeVaultCtx<'info> {
+    #[account(
+        init,
+        seeds = [
+            FEE_VAULT_PREFIX.as_ref(),
+            base.key().as_ref(),
+            token_mint.key().as_ref(),
+        ],
+        bump,
+        payer = payer,
+        space = 8 + FeeVault::INIT_SPACE
+    )]
+    pub fee_vault: AccountLoader<'info, FeeVault>,
+
+    /// CHECK: pool authority
+    #[account(
+            seeds = [
+                FEE_VAULT_AUTHORITY_PREFIX.as_ref(),
+            ],
+            bump,
+        )]
+    pub fee_vault_authority: UncheckedAccount<'info>,
+
+    #[account(
+        init,
+        seeds = [
+            TOKEN_VAULT_PREFIX.as_ref(),
+            fee_vault.key().as_ref(),
+        ],
+        token::mint = token_mint,
+        token::authority = fee_vault_authority,
+        token::token_program = token_program,
+        payer = payer,
+        bump,
+    )]
+    pub token_vault: Box<InterfaceAccount<'info, TokenAccount>>,
+
+    #[account(
+        mint::token_program = token_program,
+    )]
+    pub token_mint: Box<InterfaceAccount<'info, Mint>>,
+
+    /// CHECK: owner
+    pub owner: UncheckedAccount<'info>,
+
+    /// CHECK: admin of fee vault
+    pub admin: UncheckedAccount<'info>,
+
+    pub base: Signer<'info>,
+
+    #[account(mut)]
+    pub payer: Signer<'info>,
+
+    pub token_program: Interface<'info, TokenInterface>,
+
+    // Sysvar for program account
+    pub system_program: Program<'info, System>,
+}
+
+pub fn handle_initialize_permission_fee_vault(
+    ctx: Context<InitializePermissionFeeVaultCtx>,
+    params: &InitializeFeeVaultParameters,
+) -> Result<()> {
+    create_fee_vault(
+        &ctx.accounts.token_mint,
+        params,
+        &ctx.accounts.fee_vault,
+        ctx.accounts.owner.key,
+        &ctx.accounts.token_vault.key(),
+        &ctx.accounts.base.key,
+        ctx.bumps.fee_vault,
+        FeeVaultType::PdaAccount.into(),
+        ctx.accounts.admin.key,
+    )?;
+
+    emit_cpi!(EvtInitializeFeeVault {
+        fee_vault: ctx.accounts.fee_vault.key(),
+        owner: ctx.accounts.owner.key(),
+        token_mint: ctx.accounts.token_mint.key(),
+        params: params.clone(),
+        base: ctx.accounts.base.key(),
+    });
+
+    Ok(())
+}

programs/dynamic-fee-sharing/src/instructions/mod.rs

@@ -8,3 +8,7 @@ pub mod ix_initialize_fee_vault_pda;
 pub use ix_initialize_fee_vault_pda::*;
 pub mod ix_fund_by_claiming_fee;
 pub use ix_fund_by_claiming_fee::*;
+pub mod ix_initialize_permission_fee_vault;
+pub use ix_initialize_permission_fee_vault::*;
+pub mod ix_close_permission_fee_vault;
+pub use ix_close_permission_fee_vault::*;

programs/dynamic-fee-sharing/src/lib.rs

@@ -33,6 +33,13 @@ pub mod dynamic_fee_sharing {
         instructions::handle_initialize_fee_vault_pda(ctx, &params)
     }
 
+    pub fn initialize_permission_fee_vault(
+        ctx: Context<InitializePermissionFeeVaultCtx>,
+        params: InitializeFeeVaultParameters,
+    ) -> Result<()> {
+        instructions::handle_initialize_permission_fee_vault(ctx, &params)
+    }
+
     pub fn fund_fee(ctx: Context<FundFeeCtx>, max_amount: u64) -> Result<()> {
         instructions::handle_fund_fee(ctx, max_amount)
     }
@@ -47,4 +54,8 @@ pub mod dynamic_fee_sharing {
     pub fn claim_fee(ctx: Context<ClaimFeeCtx>, index: u8) -> Result<()> {
         instructions::handle_claim_fee(ctx, index)
     }
+
+    pub fn close_permission_fee_vault(ctx: Context<ClosePermissionFeeVaultCtx>) -> Result<()> {
+        instructions::handle_close_permission_fee_vault(ctx)
+    }
 }

programs/dynamic-fee-sharing/src/state/fee_vault.rs

@@ -39,7 +39,8 @@ pub struct FeeVault {
     pub total_funded_fee: u64,
     pub fee_per_share: u128,
     pub base: Pubkey,
-    pub padding: [u128; 4],
+    pub admin: Pubkey,
+    pub padding: [u128; 2],
     pub users: [UserFee; MAX_USER],
 }
 const_assert_eq!(FeeVault::INIT_SPACE, 640);
@@ -67,6 +68,7 @@ impl FeeVault {
         fee_vault_bump: u8,
         fee_vault_type: u8,
         users: &[UserShare],
+        admin: &Pubkey,
     ) -> Result<()> {
         self.owner = *owner;
         self.token_flag = token_flag;
@@ -85,6 +87,7 @@ impl FeeVault {
         self.base = *base;
         self.fee_vault_bump = fee_vault_bump;
         self.fee_vault_type = fee_vault_type;
+        self.admin = *admin;
 
         Ok(())
     }