ATA: Create explicit CreateAssociatedTokenAccount instruction (#2397)

* feat: create explicit CreateAssociatedTokenAccount instruction

* feat: add create_associated_token_account for explicit instruction

* chore: update comments and make clippy happy

* chore: redirect legacy instruction creator to new instruction

* chore: update comments

* wip: scaffold mint to instruction creator and test

* Revert "wip: scaffold mint to instruction creator and test"

This reverts commit f825405.

* chore: flag legacy create_associated_token_account as deprecated

* chore: rename CreateAssociatedTokenAccount to Create

* chore: move create_pda_account to tools:account

* chore: comment deprecated attribute to prevent warnings until 1.0.4 is released

* chore: fix test name

* feat: remove Rent account from explicit instruction

* chore: use current spl_token for implicit instruction test

* chore: replicate legacy implicit instruction in test

* chore: remove program name from instruction msg

Author: SebastianBor

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "spl-associated-token-account"
-version = "1.0.3"
+version = "1.0.4"
 description = "Solana Program Library Associated Token Account"
 authors = ["Solana Maintainers <[email protected]>"]
 repository = "https://github.com/solana-labs/solana-program-library"
@@ -12,6 +12,7 @@ no-entrypoint = []
 test-bpf = []
 
 [dependencies]
+borsh = "0.9.1"
 solana-program = "1.7.11"
 spl-token = { version = "3.2", path = "../../token/program", features = ["no-entrypoint"] }
 

associated-token-account/program/Cargo.toml

@@ -0,0 +1,48 @@
+//! Program instructions
+
+use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
+use solana_program::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+};
+
+use crate::{get_associated_token_address, id};
+
+/// Instructions supported by the AssociatedTokenAccount program
+#[derive(Clone, Debug, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
+pub enum AssociatedTokenAccountInstruction {
+    /// Creates an associated token account for the given wallet address and token mint
+    ///
+    ///   0. `[writeable,signer]` Funding account (must be a system account)
+    ///   1. `[writeable]` Associated token account address to be created
+    ///   2. `[]` Wallet address for the new associated token account
+    ///   3. `[]` The token mint for the new associated token account
+    ///   4. `[]` System program
+    ///   5. `[]` SPL Token program
+    Create,
+}
+
+/// Creates CreateAssociatedTokenAccount instruction
+pub fn create_associated_token_account(
+    funding_address: &Pubkey,
+    wallet_address: &Pubkey,
+    spl_token_mint_address: &Pubkey,
+) -> Instruction {
+    let associated_account_address =
+        get_associated_token_address(wallet_address, spl_token_mint_address);
+
+    let instruction_data = AssociatedTokenAccountInstruction::Create {};
+
+    Instruction {
+        program_id: id(),
+        accounts: vec![
+            AccountMeta::new(*funding_address, true),
+            AccountMeta::new(associated_account_address, false),
+            AccountMeta::new_readonly(*wallet_address, false),
+            AccountMeta::new_readonly(*spl_token_mint_address, false),
+            AccountMeta::new_readonly(solana_program::system_program::id(), false),
+            AccountMeta::new_readonly(spl_token::id(), false),
+        ],
+        data: instruction_data.try_to_vec().unwrap(),
+    }
+}

associated-token-account/program/src/instruction.rs

@@ -3,7 +3,9 @@
 #![forbid(unsafe_code)]
 
 mod entrypoint;
+pub mod instruction;
 pub mod processor;
+pub mod tools;
 
 // Export current SDK types for downstream users building with a different SDK version
 pub use solana_program;
@@ -65,25 +67,26 @@ fn get_associated_token_address_and_bump_seed_internal(
 ///   5. `[]` SPL Token program
 ///   6. `[]` Rent sysvar
 ///
+// TODO: Uncomment after 1.0.4 is released
+// #[deprecated(
+//     since = "1.0.4",
+//     note = "please use `instruction::create_associated_token_account` instead"
+// )]
 pub fn create_associated_token_account(
     funding_address: &Pubkey,
     wallet_address: &Pubkey,
     spl_token_mint_address: &Pubkey,
 ) -> Instruction {
-    let associated_account_address =
-        get_associated_token_address(wallet_address, spl_token_mint_address);
+    let mut instruction = instruction::create_associated_token_account(
+        funding_address,
+        wallet_address,
+        spl_token_mint_address,
+    );
 
-    Instruction {
-        program_id: id(),
-        accounts: vec![
-            AccountMeta::new(*funding_address, true),
-            AccountMeta::new(associated_account_address, false),
-            AccountMeta::new_readonly(*wallet_address, false),
-            AccountMeta::new_readonly(*spl_token_mint_address, false),
-            AccountMeta::new_readonly(solana_program::system_program::id(), false),
-            AccountMeta::new_readonly(spl_token::id(), false),
-            AccountMeta::new_readonly(sysvar::rent::id(), false),
-        ],
-        data: vec![],
-    }
+    // TODO: Remove after ATA 1.0.4 and Token 3.2.0 are released (Token::InitializeAccount3 is required if rent account is not provided)
+    instruction
+        .accounts
+        .push(AccountMeta::new_readonly(sysvar::rent::id(), false));
+
+    instruction
 }

associated-token-account/program/src/lib.rs

@@ -1,23 +1,45 @@
 //! Program state processor
 
 use crate::*;
+use crate::{instruction::AssociatedTokenAccountInstruction, tools::account::create_pda_account};
+use borsh::BorshDeserialize;
 use solana_program::{
     account_info::{next_account_info, AccountInfo},
     entrypoint::ProgramResult,
     msg,
-    program::{invoke, invoke_signed},
+    program::invoke,
     program_error::ProgramError,
     pubkey::Pubkey,
     rent::Rent,
-    system_instruction,
     sysvar::Sysvar,
 };
 
 /// Instruction processor
 pub fn process_instruction(
     program_id: &Pubkey,
     accounts: &[AccountInfo],
-    _input: &[u8],
+    input: &[u8],
+) -> ProgramResult {
+    let instruction = if input.is_empty() {
+        AssociatedTokenAccountInstruction::Create
+    } else {
+        AssociatedTokenAccountInstruction::try_from_slice(input)
+            .map_err(|_| ProgramError::InvalidInstructionData)?
+    };
+
+    msg!("{:?}", instruction);
+
+    match instruction {
+        AssociatedTokenAccountInstruction::Create {} => {
+            process_create_associated_token_account(program_id, accounts)
+        }
+    }
+}
+
+/// Processes CreateAssociatedTokenAccount instruction
+pub fn process_create_associated_token_account(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
 ) -> ProgramResult {
     let account_info_iter = &mut accounts.iter();
 
@@ -28,7 +50,11 @@ pub fn process_instruction(
     let system_program_info = next_account_info(account_info_iter)?;
     let spl_token_program_info = next_account_info(account_info_iter)?;
     let spl_token_program_id = spl_token_program_info.key;
-    let rent_sysvar_info = next_account_info(account_info_iter)?;
+
+    // TODO: Remove after ATA 1.0.4 and Token 3.2.0 are released and just use Rent::get()
+    let (rent_sysvar_info, rent) = next_account_info(account_info_iter)
+        .map(|info| (Some(info), Rent::from_account_info(info).unwrap()))
+        .unwrap_or((None, Rent::get().unwrap()));
 
     let (associated_token_address, bump_seed) = get_associated_token_address_and_bump_seed_internal(
         wallet_account_info.key,
@@ -48,11 +74,9 @@ pub fn process_instruction(
         &[bump_seed],
     ];
 
-    let rent = &Rent::from_account_info(rent_sysvar_info)?;
-
     create_pda_account(
         funder_info,
-        rent,
+        &rent,
         spl_token::state::Account::LEN,
         &spl_token::id(),
         system_program_info,
@@ -61,75 +85,38 @@ pub fn process_instruction(
     )?;
 
     msg!("Initialize the associated token account");
-    invoke(
-        &spl_token::instruction::initialize_account(
-            spl_token_program_id,
-            associated_token_account_info.key,
-            spl_token_mint_info.key,
-            wallet_account_info.key,
-        )?,
-        &[
-            associated_token_account_info.clone(),
-            spl_token_mint_info.clone(),
-            wallet_account_info.clone(),
-            rent_sysvar_info.clone(),
-            spl_token_program_info.clone(),
-        ],
-    )
-}
-
-fn create_pda_account<'a>(
-    funder: &AccountInfo<'a>,
-    rent: &Rent,
-    space: usize,
-    owner: &Pubkey,
-    system_program: &AccountInfo<'a>,
-    new_pda_account: &AccountInfo<'a>,
-    new_pda_signer_seeds: &[&[u8]],
-) -> ProgramResult {
-    if new_pda_account.lamports() > 0 {
-        let required_lamports = rent
-            .minimum_balance(space)
-            .max(1)
-            .saturating_sub(new_pda_account.lamports());
 
-        if required_lamports > 0 {
-            invoke(
-                &system_instruction::transfer(funder.key, new_pda_account.key, required_lamports),
-                &[
-                    funder.clone(),
-                    new_pda_account.clone(),
-                    system_program.clone(),
-                ],
-            )?;
-        }
-
-        invoke_signed(
-            &system_instruction::allocate(new_pda_account.key, space as u64),
-            &[new_pda_account.clone(), system_program.clone()],
-            &[new_pda_signer_seeds],
-        )?;
-
-        invoke_signed(
-            &system_instruction::assign(new_pda_account.key, owner),
-            &[new_pda_account.clone(), system_program.clone()],
-            &[new_pda_signer_seeds],
+    if let Some(rent_sysvar_info) = rent_sysvar_info {
+        invoke(
+            &spl_token::instruction::initialize_account(
+                spl_token_program_id,
+                associated_token_account_info.key,
+                spl_token_mint_info.key,
+                wallet_account_info.key,
+            )?,
+            &[
+                associated_token_account_info.clone(),
+                spl_token_mint_info.clone(),
+                wallet_account_info.clone(),
+                rent_sysvar_info.clone(),
+                spl_token_program_info.clone(),
+            ],
         )
     } else {
-        invoke_signed(
-            &system_instruction::create_account(
-                funder.key,
-                new_pda_account.key,
-                rent.minimum_balance(space).max(1),
-                space as u64,
-                owner,
-            ),
+        // Use InitializeAccount3 when Rent account is not provided
+        invoke(
+            &spl_token::instruction::initialize_account3(
+                spl_token_program_id,
+                associated_token_account_info.key,
+                spl_token_mint_info.key,
+                wallet_account_info.key,
+            )?,
             &[
-                funder.clone(),
-                new_pda_account.clone(),
-                system_program.clone(),
+                associated_token_account_info.clone(),
+                spl_token_mint_info.clone(),
+                wallet_account_info.clone(),
+                spl_token_program_info.clone(),
             ],
-            &[new_pda_signer_seeds],
         )
     }
 }