need some assistance in creating an associate token account from the program. So we need users to be sending a SPL token to our program. To keep the account unique for each user we want to create PDA for each user. Each user's PDA will have an ATA, where users will send their tokens to. So program will then withdraw the tokens and do the necessary actions. 

I am fairly new to Rust and stuck while creating ATA from the program. Below is the code I am trying to execute.

```
invoke(
        &create_associated_token_account(
            initializer.key,
            pda_ata.key,
            token.key,
            associated_system_program.key
        ),
        &[initializer.clone(), pda_ata.clone(), token.clone(), associated_system_program.clone()],
    )?;
```

Error I see in Logs:

'Instruction references an unknown account xxxxxxxx',

failed: An account required by the instruction is missing


So I want a user to 

- send 5 CUSTOM TOKENS
- Program to Receive above 5 tokens and add to the user's tally.
- Once there are 10 TOKENS received then a user can perform an action.

What should be the best approach to this via one INSTRUCTION? 

 - create PDA for each user create ATA for the PDA program to transfer
   from User's ATA to PDA ATA


Here is the complete function


```
pub fn create_user_token_pda(
    program_id: &Pubkey,
    accounts: &[AccountInfo]
) -> ProgramResult {

    let account_info_iter = &mut accounts.iter();

    let initializer = next_account_info(account_info_iter)?;
    let pda_user_token = next_account_info(account_info_iter)?;
    let pda_user_token_ata = next_account_info(account_info_iter)?;
    let token = next_account_info(account_info_iter)?;
    let system_program = next_account_info(account_info_iter)?;
    let associated_system_program = next_account_info(account_info_iter)?;

    if !initializer.is_signer {
        msg!("Missing required signature");
        return Err(ProgramError::MissingRequiredSignature);
    }

    msg!("token: {}", token.key);
    msg!("pda_user_token: {}", pda_user_token.key);
    msg!("pda_user_token_ata: {}", pda_user_token_ata.key);
    msg!("associated_system_program: {}", associated_system_program.key);

    let rent = Rent::get()?;
    let rent_lamports = rent.minimum_balance(1);

    let (user_token, user_token_bump) =
        Pubkey::find_program_address(&[initializer.key.as_ref(), "token".as_ref()], program_id);
    if user_token != *pda_user_token.key {
        msg!("Invalid seeds for PDA");
        return Err(ProgramError::InvalidArgument);
    }

    msg!("create user token pda");

    if **pda_user_token.try_borrow_lamports()? == 0 {

        invoke_signed(
            &system_instruction::create_account(
                initializer.key,
                pda_user_token.key,
                rent_lamports,
                1,
                program_id,
            ),
            &[
                initializer.clone(),
                pda_user_token.clone(),
                system_program.clone(),
            ],
            &[&[initializer.key.as_ref(), "token".as_ref(), &[user_token_bump]]],
        )?;
    }

    let associated_token_address = get_associated_token_address(
        pda_user_token.key,
        token.key
    );
    msg!("associated_token_address: {}", associated_token_address.to_string());

    invoke(
        &create_associated_token_account(
            initializer.key,
            pda_user_token_ata.key,
            token.key,
            associated_system_program.key
        ),
        &[initializer.clone(), pda_user_token_ata.clone(), token.clone(), associated_system_program.clone()],
    )?;

    msg!("created user token pda");

    Ok(())
}
```

Thanks