superstate-allowlist-interface 0.1.0

use crate::{
    get_admin_pda, get_allowlist_program_pda, get_private_allowed_account_pda,
    get_private_allowlist_pda, get_public_allowed_account_pda,
};
use borsh::{BorshDeserialize, BorshSerialize};
use solana_instruction::{AccountMeta, Instruction};
use solana_program_error::ProgramError;
use solana_pubkey::Pubkey;

const SYSTEM_PROGRAM_ID: Pubkey = Pubkey::from_str_const("11111111111111111111111111111111");

#[derive(Clone, Debug, PartialEq, BorshDeserialize, BorshSerialize)]
pub enum AllowlistInstruction {
    /// Initializes the allowlist admin account.
    ///
    /// It creates a new system account.
    ///
    /// This can only be called once.
    ///
    /// The `InitializeAdminAuthority` instruction MUST be in the same Transaction as the program deployment
    /// Otherwise another party can acquire ownership of the uninitialized admin account.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[signer]` The Admin Authority account
    ///   1. `[writable]` The Admin's Program Derived Account
    ///   2. `[]` System Program
    InitializeAdminAuthority,

    /// Updates the allowlist admin account.
    ///
    /// This can only be called by the existing admin authority.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[signer]` The current Admin Authority account
    ///   1. `[signer]` The new Admin Authority account
    ///   2. `[writable]` The Admin's Program Derived Account
    UpdateAdminAuthority,

    /// Associates a Token Mint as a Private Instrument.
    ///
    /// This can only be called by the existing admin authority.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[signer]` The Admin Authority account
    ///   1. `[]` The Admin's Program Derived Account
    ///   2. `[]` The token mint for the private instrument
    ///   3. `[writable]` The Private Allowlist's Program Derived Account
    ///   4. `[]` System Program
    AdminAddPrivateAllowlist,

    /// Changes Token Mint from a Public Instrument to a Private Instrument.
    ///
    /// This can only be called by the existing admin authority.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[signer]` The Admin Authority account
    ///   1. `[]` The Admin's Program Derived Account
    ///   2. `[]` The token mint for the private instrument
    ///   3. `[writable]` The Private Allowlist's Program Derived Account
    ///   4. `[]` System Program
    AdminRemovePrivateAllowlist,

    /// Thaws the underlying Token Account of the provided system wallet account
    /// if the wallet is on the allow list.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[]` The token mint
    ///   1. `[]` The wallet system account Program Derived Address for the Public Instrument Allowlist
    ///   2. `[]` The wallet system account Program Derived Address for the Private Instrument Allowlist
    ///   3. `[writable]` The wallet's Token Account for the Mint
    ///   4. `[]` The token program
    ///   5. `[]` The Allowlist PDA for the Freeze Authority
    Thaw {
        /// The wallet system account that is being thawed (e.g. the Token Account owner)
        user_system_account: Pubkey,
    },

    /// Adds a new account to the Public Instrument Allowlist, and can only be called by the `Admin Authority`.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[signer]` The Admin Authority account
    ///   1. `[]` The Admin's Program Derived Account
    ///   2. `[signer]` The wallet system account to add to the allow list. Note: this can optionally be a signer.
    ///   3. `[]` The wallet system account Program Derived Address for the Private Instrument Allowlist
    ///   4. `[]` System Program
    AdminAddPublicAllowedAccount,

    /// Adds a new account to the Private Instrument Allowlist, and can only be called by the `Admin Authority`.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[signer]` The Admin Authority account
    ///   1. `[]` The Admin's Program Derived Account
    ///   2. `[signer]` The wallet system account to add to the allow list. Note: this can optionally be a signer.
    ///   3. `[]` The wallet system account Program Derived Address for the Private Instrument Allowlist
    ///   4. `[]` The token mint for the private instrument
    ///   5. `[]` System Program
    AdminAddPrivateAllowedAccount,

    /// Removes an existing account from the allowlist, and can only be called by the `Admin Authority`.
    ///
    /// This instruction WILL NOT freeze existing Token Accounts, which is instead done via `AdminFreeze`.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[signer]` The Admin Authority account
    ///   1. `[]` The Admin's Program Derived Account
    ///   2. `[]` The wallet system account to remove from the allow list.
    ///   3. `[]` The wallet system account Program Derived Address for the allow list
    AdminRemovePublicAllowedAccount,

    /// Removes an existing account from the allowlist, and can only be called by the `Admin Authority`.
    ///
    /// This instruction WILL NOT freeze existing Token Accounts, which is instead done via `AdminFreeze`.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[signer]` The Admin Authority account
    ///   1. `[]` The Admin's Program Derived Account
    ///   2. `[]` The wallet system account to remove from the allow list.
    ///   3. `[]` The wallet system account Program Derived Address for the allow list
    ///   4. `[]` The token mint for the private instrument
    AdminRemovePrivateAllowedAccount,

    /// Freezes an Token Account, and can only be called by the `Admin Authority`.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[signer]` The Admin Authority account
    ///   1. `[]` The Admin's Program Derived Account
    ///   2. `[]` The wallet system account
    ///   3. `[writable]` The wallet's Token Account for the Mint
    ///   4. `[]` The token mint
    ///   5. `[]` The token program
    ///   6. `[]` The Allowlist PDA for the Freeze Authority
    AdminFreeze,

    /// Burns tokens by removing them from an account. If they account is
    /// frozen, it will unfreeze it first, and then refreeze it.
    ///
    /// This instruction can only be called by the `Admin Authority`
    ///
    /// The wallet address does NOT need to be on the allowlist to be burned.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[signer]` The Admin Authority account
    ///   1. `[]` The Admin's Program Derived Account
    ///   2. `[]` The wallet system account
    ///   3. `[writable]` The wallet's Token Account for the Mint
    ///   4. `[]` The token mint
    ///   5. `[]` The token program
    ///   6. `[]` The Allowlist PDA for the Freeze Authority
    AdminBurn {
        /// The amount of tokens to burn.
        amount: u64,
        /// Expected number of base 10 digits to the right of the decimal place.
        decimals: u8,
    },
}

pub fn initialize_admin_authority(
    allowlist_program_id: &Pubkey,
    admin_authority_pubkey: &Pubkey,
) -> Result<Instruction, ProgramError> {
    let data = borsh::to_vec(&AllowlistInstruction::InitializeAdminAuthority)?;

    let (global_admin_pda, _) = get_admin_pda(allowlist_program_id);

    let accounts = vec![
        AccountMeta::new(*admin_authority_pubkey, true),
        AccountMeta::new(global_admin_pda, false),
        AccountMeta::new_readonly(SYSTEM_PROGRAM_ID, false),
    ];

    Ok(Instruction {
        program_id: *allowlist_program_id,
        accounts,
        data,
    })
}

pub fn update_admin_authority(
    allowlist_program_id: &Pubkey,
    current_admin_authority_pubkey: &Pubkey,
    new_admin_authority_pubkey: &Pubkey,
) -> Result<Instruction, ProgramError> {
    let data = borsh::to_vec(&AllowlistInstruction::UpdateAdminAuthority)?;

    let (global_admin_pda, _) = get_admin_pda(allowlist_program_id);

    let accounts = vec![
        AccountMeta::new(*current_admin_authority_pubkey, true),
        AccountMeta::new(*new_admin_authority_pubkey, true),
        AccountMeta::new(global_admin_pda, false),
    ];

    Ok(Instruction {
        program_id: *allowlist_program_id,
        accounts,
        data,
    })
}

pub fn admin_add_private_allowlist(
    allowlist_program_id: &Pubkey,
    admin_authority_pubkey: &Pubkey,
    mint_pubkey: &Pubkey,
    system_program_pubkey: &Pubkey,
) -> Result<Instruction, ProgramError> {
    let data = borsh::to_vec(&AllowlistInstruction::AdminAddPrivateAllowlist)?;

    let (global_admin_pda, _) = get_admin_pda(allowlist_program_id);
    let (private_allowlist_pda, _) = get_private_allowlist_pda(mint_pubkey, allowlist_program_id);

    let accounts = vec![
        AccountMeta::new(*admin_authority_pubkey, true),
        AccountMeta::new_readonly(global_admin_pda, false),
        AccountMeta::new_readonly(*mint_pubkey, false),
        AccountMeta::new(private_allowlist_pda, false),
        AccountMeta::new_readonly(*system_program_pubkey, false),
    ];

    Ok(Instruction {
        program_id: *allowlist_program_id,
        accounts,
        data,
    })
}

pub fn admin_remove_private_allowlist(
    allowlist_program_id: &Pubkey,
    admin_authority_pubkey: &Pubkey,
    mint_pubkey: &Pubkey,
) -> Result<Instruction, ProgramError> {
    let data = borsh::to_vec(&AllowlistInstruction::AdminRemovePrivateAllowlist)?;

    let (global_admin_pda, _) = get_admin_pda(allowlist_program_id);
    let (private_allowlist_pda, _) = get_private_allowlist_pda(mint_pubkey, allowlist_program_id);

    let accounts = vec![
        AccountMeta::new(*admin_authority_pubkey, true),
        AccountMeta::new_readonly(global_admin_pda, false),
        AccountMeta::new_readonly(*mint_pubkey, false),
        AccountMeta::new(private_allowlist_pda, false),
    ];

    Ok(Instruction {
        program_id: *allowlist_program_id,
        accounts,
        data,
    })
}

pub fn admin_add_public_allowed_account(
    allowlist_program_id: &Pubkey,
    admin_authority_pubkey: &Pubkey,
    user_account_pubkey: &Pubkey,
    user_account_is_payer: bool,
    system_program_id: &Pubkey,
) -> Result<Instruction, ProgramError> {
    let data = borsh::to_vec(&AllowlistInstruction::AdminAddPublicAllowedAccount)?;

    let (global_admin_pda, _) = get_admin_pda(allowlist_program_id);
    let (user_allowed_account_to_add, _) =
        get_public_allowed_account_pda(user_account_pubkey, allowlist_program_id);

    let user_account_meta = if user_account_is_payer {
        AccountMeta::new(*user_account_pubkey, true)
    } else {
        AccountMeta::new_readonly(*user_account_pubkey, false)
    };

    let accounts = vec![
        AccountMeta::new(*admin_authority_pubkey, true),
        AccountMeta::new_readonly(global_admin_pda, false),
        user_account_meta,
        AccountMeta::new(user_allowed_account_to_add, false),
        AccountMeta::new_readonly(*system_program_id, false),
    ];

    Ok(Instruction {
        program_id: *allowlist_program_id,
        accounts,
        data,
    })
}

pub fn admin_add_private_allowed_account(
    allowlist_program_id: &Pubkey,
    admin_authority_pubkey: &Pubkey,
    user_account_pubkey: &Pubkey,
    user_account_is_payer: bool,
    mint_pubkey: &Pubkey,
    system_program_pubkey: &Pubkey,
) -> Result<Instruction, ProgramError> {
    let data = borsh::to_vec(&AllowlistInstruction::AdminAddPrivateAllowedAccount)?;

    let (global_admin_pda, _) = get_admin_pda(allowlist_program_id);
    let (user_allowed_account_to_add, _) =
        get_private_allowed_account_pda(user_account_pubkey, mint_pubkey, allowlist_program_id);

    let user_account_meta = if user_account_is_payer {
        AccountMeta::new(*user_account_pubkey, true)
    } else {
        AccountMeta::new_readonly(*user_account_pubkey, false)
    };

    let accounts = vec![
        AccountMeta::new(*admin_authority_pubkey, true),
        AccountMeta::new_readonly(global_admin_pda, false),
        user_account_meta,
        AccountMeta::new(user_allowed_account_to_add, false),
        AccountMeta::new_readonly(*mint_pubkey, false),
        AccountMeta::new_readonly(*system_program_pubkey, false),
    ];

    Ok(Instruction {
        program_id: *allowlist_program_id,
        accounts,
        data,
    })
}

pub fn admin_remove_public_allowed_account(
    allowlist_program_id: &Pubkey,
    admin_authority_pubkey: &Pubkey,
    user_account_pubkey: &Pubkey,
) -> Result<Instruction, ProgramError> {
    let data = borsh::to_vec(&AllowlistInstruction::AdminRemovePublicAllowedAccount)?;

    let (global_admin_pda, _) = get_admin_pda(allowlist_program_id);
    let (user_allowed_account_to_remove, _) =
        get_public_allowed_account_pda(user_account_pubkey, allowlist_program_id);

    let accounts = vec![
        AccountMeta::new(*admin_authority_pubkey, true),
        AccountMeta::new_readonly(global_admin_pda, false),
        AccountMeta::new_readonly(*user_account_pubkey, false),
        AccountMeta::new(user_allowed_account_to_remove, false),
    ];

    Ok(Instruction {
        program_id: *allowlist_program_id,
        accounts,
        data,
    })
}

pub fn admin_remove_private_allowed_account(
    allowlist_program_id: &Pubkey,
    admin_authority_pubkey: &Pubkey,
    user_account_pubkey: &Pubkey,
    mint_pubkey: &Pubkey,
) -> Result<Instruction, ProgramError> {
    let data = borsh::to_vec(&AllowlistInstruction::AdminRemovePrivateAllowedAccount)?;

    let (global_admin_pda, _) = get_admin_pda(allowlist_program_id);
    let (user_allowed_account_to_remove, _) =
        get_private_allowed_account_pda(user_account_pubkey, mint_pubkey, allowlist_program_id);

    let accounts = vec![
        AccountMeta::new(*admin_authority_pubkey, true),
        AccountMeta::new_readonly(global_admin_pda, false),
        AccountMeta::new_readonly(*user_account_pubkey, false),
        AccountMeta::new(user_allowed_account_to_remove, false),
        AccountMeta::new_readonly(*mint_pubkey, false),
    ];

    Ok(Instruction {
        program_id: *allowlist_program_id,
        accounts,
        data,
    })
}

pub fn thaw(
    allowlist_program_id: &Pubkey,
    mint_pubkey: &Pubkey,
    user_token_account_owner_pubkey: &Pubkey,
    user_token_account_pubkey: &Pubkey,
    token_program_id: &Pubkey,
) -> Result<Instruction, ProgramError> {
    let data = borsh::to_vec(&AllowlistInstruction::Thaw {
        user_system_account: *user_token_account_owner_pubkey,
    })?;

    let (user_public_allowed_account_pda, _) =
        get_public_allowed_account_pda(user_token_account_owner_pubkey, allowlist_program_id);

    let (user_private_allowed_account_pda, _) = get_private_allowed_account_pda(
        user_token_account_owner_pubkey,
        mint_pubkey,
        allowlist_program_id,
    );

    let (allowlist_pda, _) = get_allowlist_program_pda(allowlist_program_id);

    let (private_allowlist_pda, _) = get_private_allowlist_pda(mint_pubkey, allowlist_program_id);

    let accounts = vec![
        AccountMeta::new_readonly(*mint_pubkey, false),
        AccountMeta::new(*user_token_account_pubkey, false),
        AccountMeta::new_readonly(user_public_allowed_account_pda, false),
        AccountMeta::new_readonly(user_private_allowed_account_pda, false),
        AccountMeta::new_readonly(private_allowlist_pda, false),
        AccountMeta::new_readonly(*token_program_id, false),
        AccountMeta::new_readonly(allowlist_pda, false),
    ];

    Ok(Instruction {
        program_id: *allowlist_program_id,
        accounts,
        data,
    })
}

pub fn admin_freeze(
    allowlist_program_id: &Pubkey,
    admin_authority_pubkey: &Pubkey,
    user_token_account_owner_pubkey: &Pubkey,
    user_token_account_pubkey: &Pubkey,
    mint_pubkey: &Pubkey,
    token_program_id: &Pubkey,
) -> Result<Instruction, ProgramError> {
    let data = borsh::to_vec(&AllowlistInstruction::AdminFreeze)?;

    let (global_admin_pda, _) = get_admin_pda(allowlist_program_id);

    let (allowlist_pda, _) = get_allowlist_program_pda(allowlist_program_id);

    let accounts = vec![
        AccountMeta::new(*admin_authority_pubkey, true),
        AccountMeta::new(global_admin_pda, false),
        AccountMeta::new_readonly(*user_token_account_owner_pubkey, false),
        AccountMeta::new(*user_token_account_pubkey, false),
        AccountMeta::new_readonly(*mint_pubkey, false),
        AccountMeta::new_readonly(*token_program_id, false),
        AccountMeta::new_readonly(allowlist_pda, false),
    ];

    Ok(Instruction {
        program_id: *allowlist_program_id,
        accounts,
        data,
    })
}

#[allow(clippy::too_many_arguments)]
pub fn admin_burn(
    allowlist_program_id: &Pubkey,
    admin_authority_pubkey: &Pubkey,
    user_token_account_owner_pubkey: &Pubkey,
    user_token_account_pubkey: &Pubkey,
    mint_pubkey: &Pubkey,
    token_program_id: &Pubkey,
    amount: u64,
    decimals: u8,
) -> Result<Instruction, ProgramError> {
    let data = borsh::to_vec(&AllowlistInstruction::AdminBurn { amount, decimals })?;

    let (global_admin_pda, _) = get_admin_pda(allowlist_program_id);

    let (allowlist_pda, _) = get_allowlist_program_pda(allowlist_program_id);

    let accounts = vec![
        AccountMeta::new(*admin_authority_pubkey, true),
        AccountMeta::new_readonly(global_admin_pda, false),
        AccountMeta::new_readonly(*user_token_account_owner_pubkey, false),
        AccountMeta::new(*user_token_account_pubkey, false),
        AccountMeta::new(*mint_pubkey, false),
        AccountMeta::new_readonly(*token_program_id, false),
        AccountMeta::new_readonly(allowlist_pda, false),
    ];

    Ok(Instruction {
        program_id: *allowlist_program_id,
        accounts,
        data,
    })
}