Gated mint program

Anchor.toml

@@ -9,6 +9,7 @@ skip-lint = false
 bid_wall = "WALL8ucBuUyL46QYxwYJjidaFYhdvxUFrgvBxPshERx"
 conditional_vault = "VLTX1ishMBbcX3rdBWGssxawAo1Q2X2qxYFYqiGodVg"
 futarchy = "FUTARELBfJfQ8RDGhg1wdhddq1odMAJUePHFuBYfUxKq"
+gated_mint = "GaTEjZy6eMdHg2BcL8dk3iE78jkJ9sPtyw1q2tMNi8PA"
 launchpad = "MooNyh4CBUYEKyXVnjGYQ8mEiJDpGvJMdvrZx1iGeHV"
 launchpad_v7 = "moontUzsdepotRGe5xsfip7vLPTJnVuafqdUWexVnPM"
 launchpad_v8 = "moonDJUoHteKkGATejA5bdJVwJ6V6Dg74gyqyJTx73n"

programs/gated_mint/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "gated_mint"
+version = "0.1.0"
+description = "Created with Anchor"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "gated_mint"
+
+[features]
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+cpi = ["no-entrypoint"]
+default = []
+production = []
+
+[dependencies]
+anchor-lang = { version = "0.29.0", features = ["init-if-needed", "event-cpi"] }
+anchor-spl = "0.29.0"
+solana-program = "=1.17.14"
+spl-token = "=4.0.0"
+solana-security-txt = "1.1.1"

programs/gated_mint/src/constants.rs

@@ -0,0 +1,20 @@
+use anchor_lang::prelude::Pubkey;
+use anchor_lang::solana_program::pubkey;
+
+pub const WHITELISTED_PROGRAMS: &[Pubkey] = &[
+    pubkey!("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"),
+    pubkey!("FUTARELBfJfQ8RDGhg1wdhddq1odMAJUePHFuBYfUxKq"),
+    pubkey!("moonDJUoHteKkGATejA5bdJVwJ6V6Dg74gyqyJTx73n"),
+    pubkey!("VLTX1ishMBbcX3rdBWGssxawAo1Q2X2qxYFYqiGodVg"),
+    pubkey!("WALL8ucBuUyL46QYxwYJjidaFYhdvxUFrgvBxPshERx"),
+    pubkey!("gvnr27cVeyW3AVf3acL7VCJ5WjGAphytnsgcK1feHyH"),
+    pubkey!("cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"),
+];
+
+pub const TOKEN_ACCOUNT_LEN: usize = 165;
+pub const TOKEN_ACCOUNT_MINT_OFFSET: usize = 0;
+pub const TOKEN_ACCOUNT_STATE_OFFSET: usize = 108;
+
+pub const TOKEN_STATE_UNINITIALIZED: u8 = 0;
+pub const TOKEN_STATE_INITIALIZED: u8 = 1;
+pub const TOKEN_STATE_FROZEN: u8 = 2;

programs/gated_mint/src/error.rs

@@ -0,0 +1,21 @@
+use anchor_lang::prelude::*;
+
+#[error_code]
+pub enum GatedMintError {
+    #[msg("Unauthorized: signer is not the gated mint admin")]
+    UnauthorizedAdmin,
+    #[msg("Unauthorized: signer is not the current freeze authority of the mint")]
+    UnauthorizedFreezeAuthority,
+    #[msg("Mint mismatch: account does not match the expected gated mint")]
+    MintMismatch,
+    #[msg("Gating is already disabled for this mint")]
+    GatingDisabled,
+    #[msg("Gating must be disabled to call this instruction")]
+    GatingNotDisabled,
+    #[msg("Target program is not on the gated_mint whitelist")]
+    TargetProgramNotWhitelisted,
+    #[msg("Target program may not be the gated_mint program itself")]
+    SelfInvocation,
+    #[msg("Invalid token account: account is not a valid SPL Token account of the gated mint")]
+    InvalidTokenAccount,
+}

programs/gated_mint/src/events.rs

@@ -0,0 +1,63 @@
+use anchor_lang::prelude::*;
+
+#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
+pub struct CommonFields {
+    pub slot: u64,
+    pub unix_timestamp: i64,
+    pub gated_mint_config_seq_num: u64,
+}
+
+impl CommonFields {
+    pub fn new(clock: &Clock, seq_num: u64) -> Self {
+        Self {
+            slot: clock.slot,
+            unix_timestamp: clock.unix_timestamp,
+            gated_mint_config_seq_num: seq_num,
+        }
+    }
+}
+
+#[event]
+pub struct GatedMintInitializedEvent {
+    pub common: CommonFields,
+    pub gated_mint_config: Pubkey,
+    pub mint: Pubkey,
+    pub admin: Pubkey,
+    pub previous_freeze_authority: Pubkey,
+    pub pda_bump: u8,
+}
+
+#[event]
+pub struct WhitelistedUserAddedEvent {
+    pub common: CommonFields,
+    pub gated_mint_config: Pubkey,
+    pub whitelisted_user: Pubkey,
+    pub mint: Pubkey,
+    pub user: Pubkey,
+}
+
+#[event]
+pub struct GatedInvokeEvent {
+    pub common: CommonFields,
+    pub gated_mint_config: Pubkey,
+    pub mint: Pubkey,
+    pub caller: Pubkey,
+    pub target_program: Pubkey,
+    pub thawed_count: u32,
+    pub frozen_count: u32,
+}
+
+#[event]
+pub struct GatingDisabledEvent {
+    pub common: CommonFields,
+    pub gated_mint_config: Pubkey,
+    pub mint: Pubkey,
+}
+
+#[event]
+pub struct AccountThawedEvent {
+    pub common: CommonFields,
+    pub gated_mint_config: Pubkey,
+    pub mint: Pubkey,
+    pub token_account: Pubkey,
+}

programs/gated_mint/src/instructions/add_whitelisted_user.rs

@@ -0,0 +1,68 @@
+use anchor_lang::prelude::*;
+use anchor_spl::token::Mint;
+
+use crate::{
+    CommonFields, GatedMintConfig, GatedMintError, WhitelistedUser, WhitelistedUserAddedEvent,
+    WHITELISTED_USER_SEED,
+};
+
+#[event_cpi]
+#[derive(Accounts)]
+pub struct AddWhitelistedUser<'info> {
+    #[account(
+        mut,
+        has_one = mint @ GatedMintError::MintMismatch,
+        constraint = !gated_mint_config.gating_disabled @ GatedMintError::GatingDisabled,
+    )]
+    pub gated_mint_config: Account<'info, GatedMintConfig>,
+
+    #[account(address = gated_mint_config.admin @ GatedMintError::UnauthorizedAdmin)]
+    pub admin: Signer<'info>,
+
+    pub mint: Account<'info, Mint>,
+
+    /// CHECK: any pubkey may be whitelisted; not signed.
+    pub user: UncheckedAccount<'info>,
+
+    #[account(
+        init,
+        payer = payer,
+        space = 8 + WhitelistedUser::INIT_SPACE,
+        seeds = [WHITELISTED_USER_SEED, mint.key().as_ref(), user.key().as_ref()],
+        bump,
+    )]
+    pub whitelisted_user: Account<'info, WhitelistedUser>,
+
+    #[account(mut)]
+    pub payer: Signer<'info>,
+
+    pub system_program: Program<'info, System>,
+}
+
+impl AddWhitelistedUser<'_> {
+    pub fn validate(&self) -> Result<()> {
+        Ok(())
+    }
+
+    pub fn handle(ctx: Context<Self>) -> Result<()> {
+        let cfg = &mut ctx.accounts.gated_mint_config;
+        cfg.seq_num += 1;
+
+        ctx.accounts.whitelisted_user.set_inner(WhitelistedUser {
+            mint: ctx.accounts.mint.key(),
+            user: ctx.accounts.user.key(),
+            bump: ctx.bumps.whitelisted_user,
+        });
+
+        let clock = Clock::get()?;
+        emit_cpi!(WhitelistedUserAddedEvent {
+            common: CommonFields::new(&clock, cfg.seq_num),
+            gated_mint_config: cfg.key(),
+            whitelisted_user: ctx.accounts.whitelisted_user.key(),
+            mint: ctx.accounts.mint.key(),
+            user: ctx.accounts.user.key(),
+        });
+
+        Ok(())
+    }
+}

programs/gated_mint/src/instructions/disable_gating.rs

@@ -0,0 +1,37 @@
+use anchor_lang::prelude::*;
+
+use crate::{CommonFields, GatedMintConfig, GatedMintError, GatingDisabledEvent};
+
+#[event_cpi]
+#[derive(Accounts)]
+pub struct DisableGating<'info> {
+    #[account(
+        mut,
+        constraint = !gated_mint_config.gating_disabled @ GatedMintError::GatingDisabled,
+    )]
+    pub gated_mint_config: Account<'info, GatedMintConfig>,
+
+    #[account(address = gated_mint_config.admin @ GatedMintError::UnauthorizedAdmin)]
+    pub admin: Signer<'info>,
+}
+
+impl DisableGating<'_> {
+    pub fn validate(&self) -> Result<()> {
+        Ok(())
+    }
+
+    pub fn handle(ctx: Context<Self>) -> Result<()> {
+        let cfg = &mut ctx.accounts.gated_mint_config;
+        cfg.gating_disabled = true;
+        cfg.seq_num += 1;
+
+        let clock = Clock::get()?;
+        emit_cpi!(GatingDisabledEvent {
+            common: CommonFields::new(&clock, cfg.seq_num),
+            gated_mint_config: cfg.key(),
+            mint: cfg.mint,
+        });
+
+        Ok(())
+    }
+}