Validation check on inputs

Question

I have a sign_up function :

pub fn sign_up(ctx: Context<SignUp> , user_name: String , phone: String , email: String) -> Result<()> {// Code is here }

and one of the arguments is user_name and i need to check the user_name that has been sent to be unique among all accounts that is being created with this function and that requires me to look at other users user_name as check whether the user_name is taken or not ? and other usernames are in the data accounts of other users .

Note : I have also other arguments i need to check out the validation.

What do you guys suggest me to do ?

I don't know if PDA will work for this .

Answer 1

You can use a PDA for you user account like so:

#[derive(Accounts)]
#[instruction(name: String)]
pub struct SignUp<'info> {
    #[account(mut)]
    pub signer: Signer<'info>,

    #[account(
        init,
        payer = signer,
        space = UserState::LEN,
        seeds = [b"user".as_ref(), name.as_bytes()]
        bump,
        constraint = some_validation_function(name),
    )]
    pub user: Account<'info, UserState>,
    
    /// The rest of your context accounts
}

Using the name provided as a function argument (don't forget to update the program function accordingly) in the account seeds makes sure the acccount has a unique name. If you need more validation, you can use a constraint as shown above.

Later, you can work without passing the argument by using directly the name if you stored it in the user account:

#[derive(Accounts)]
pub struct OtherFunction<'info> {
    #[account(mut)]
    pub signer: Signer<'info>,

    #[account(
        mut,
        seeds = [b"user".as_ref(), user.name.as_bytes()]
        bump,
    )]
    pub user: Account<'info, UserState>,
    
    /// The rest of your context accounts
}

Answer 2

Yes, PDAs are exactly what you should use. That enforces uniqueness and makes it such that only one possible address can be generated for a particular username. Other attempts to sign-up with the same username would then fail.