Function process

program/src/processor/initialize_account.rs:87–149

(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_data: &[u8],
)

}

pub(crate) fn process(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_data: &[u8],
) -> ProgramResult {
    let accounts = Accounts::parse(program_id, accounts)?;

    let Params { market, max_orders } =
        try_from_bytes(instruction_data).map_err(|_| ProgramError::InvalidInstructionData)?;

    let market_key_bytes = market.to_bytes();
    let (user_account_key, user_account_nonce) = Pubkey::find_program_address(
        &[&market_key_bytes, &accounts.user_owner.key.to_bytes()],
        program_id,
    );

    if &user_account_key != accounts.user.key {
        msg!("Provided an invalid user account for the specified market and owner");
        return Err(ProgramError::InvalidArgument);
    }

    if max_orders == &0 {
        msg!("The minimum number of orders an account should be able to hold is 1");
        return Err(ProgramError::InvalidArgument);
    }

    // (USER_ACCOUNT_HEADER_LEN as u64) + max_orders * (Order::LEN as u64);
    let space = max_orders
        .checked_mul(Order::LEN as u64)
        .and_then(|n| n.checked_add(USER_ACCOUNT_HEADER_LEN as u64))
        .ok_or(DexError::NumericalOverflow)?;

    let lamports = Rent::get()?.minimum_balance(space as usize);

    let allocate_account = create_account(
        accounts.fee_payer.key,
        accounts.user.key,
        lamports,
        space,
        program_id,
    );

    invoke_signed(
        &allocate_account,
        &[
            accounts.system_program.clone(),
            accounts.fee_payer.clone(),
            accounts.user.clone(),
        ],
        &[&[
            &market_key_bytes,
            &accounts.user_owner.key.to_bytes(),
            &[user_account_nonce],
        ]],
    )?;

    let mut user_account_data = accounts.user.data.borrow_mut();
    let u = UserAccount::from_buffer_unchecked(&mut user_account_data)?;