is it possible to know the caller of an instruction

Question

TL;DR, how can I get the address of the person calling an instruction inside my anchor program.

In my anchor program, I want to know the person who is calling my program.

Say I have an instruction that doesn't require a Signer but I have a list of blocked addresses I don't want to be able to call this instruction, how can I do this in anchor.

I think in Ethereum msg.sender. How can I do it in an anchor program?

#[derive(Accounts)]
pub struct Expire<'info> {
    #[account(mut)]
    pub dummy: AccountInfo<'info>,
    #[account(
        mut,
    )]
    pub token_account: Account<'info, TokenAccount>,
    #[account(mut)]
    pub mint: Box<Account<'info, Mint>>, 
    
    #[account(mut)]
    pub dummyDataAccount: Box<Account<'info, DummyDataAccount>>,

    pub system_program: Program<'info, System>,
    pub metadata_program: Program<'info, Metadata>,
}

In the above program, dummy can be a user's address or a PDA.

The payer is the dummyDataAccount

Answer 1

I think you can pass the list of blocked addresses, lets say _access_control, then check whether the payer address is in the list of addresses. Something along the lines of

if !_access_control.contains(&ctx.accounts.dummy.key){
        return Err(ProgramError::IllegalOwner.into());
    }

for dummy, or the dummy data account.

You can store the list in the contract, or u can pass it as an argument for the fn.

Answer 2

The answer is unfortunately simple: you can't! The fee payer for the transaction is not exposed to a program.

Answer 3

Your best bet is probably to add a Signer if you want this functionality. However, even if you have a Signer, a blocked wallet can always sign with another account and send the tx, you can't see which of the signers sent the tx.

Wallets are so cheap and easy to create that blocking users by wallet key is unlikely to be an effective mitigation anyways.