Add associated-token-account program

Author: mvines

Cargo.lock

@@ -1,5 +1,6 @@
 [workspace]
 members = [
+  "associated-token-account/program",
   "memo/program",
   "shared-memory/program",
   "stake-pool/program",

Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "spl-associated-token-account"
+version = "1.0.0"
+description = "SPL Associated Token Account"
+authors = ["Solana Maintainers <[email protected]>"]
+repository = "https://github.com/solana-labs/solana-program-library"
+license = "Apache-2.0"
+edition = "2018"
+
+[features]
+exclude_entrypoint = []
+
+[dependencies]
+solana-program = "1.4.4"
+spl-token = { path = "../../token/program", features = ["exclude_entrypoint"] }
+
+[dev-dependencies]
+solana-program-test = "1.4.4"
+solana-sdk = "1.4.4"
+tokio = { version = "0.3", features = ["macros"]}
+
+[lib]
+crate-type = ["cdylib", "lib"]

associated-token-account/program/Cargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

associated-token-account/program/Xargo.toml

@@ -0,0 +1,21 @@
+use std::process::{exit, Command};
+
+fn main() {
+    if std::env::var("XARGO").is_err()
+        && std::env::var("RUSTC_WRAPPER").is_err()
+        && std::env::var("RUSTC_WORKSPACE_WRAPPER").is_err()
+    {
+        println!(
+            "cargo:warning=(not a warning) Building BPF {} program",
+            std::env::var("CARGO_PKG_NAME").unwrap()
+        );
+        if !Command::new("cargo")
+            .arg("build-bpf")
+            .status()
+            .expect("Failed to build bpf")
+            .success()
+        {
+            exit(1);
+        }
+    }
+}

associated-token-account/program/build.rs

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+set -ex
+cd "$(dirname "$0")"
+cargo clippy
+cargo build
+cargo build-bpf
+
+if [[ $1 = -v ]]; then
+  export RUST_LOG=solana=debug
+fi
+
+bpf=1 cargo test
+# TODO: bpf=0 not supported until native CPI rework in the monorepo completes
+#bpf=0 cargo test

associated-token-account/program/run-tests.sh

@@ -0,0 +1,16 @@
+//! Program entrypoint
+
+#![cfg(all(target_arch = "bpf", not(feature = "exclude_entrypoint")))]
+
+use solana_program::{
+    account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, pubkey::Pubkey,
+};
+
+entrypoint!(process_instruction);
+fn process_instruction(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    crate::processor::process_instruction(program_id, accounts, instruction_data)
+}

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

@@ -0,0 +1,75 @@
+//! Convention for associating token accounts with a primary account (such as a user wallet)
+#![deny(missing_docs)]
+#![forbid(unsafe_code)]
+
+mod entrypoint;
+pub mod processor;
+
+// Export current sdk types for downstream users building with a different sdk version
+pub use solana_program;
+use solana_program::{
+    instruction::{AccountMeta, Instruction},
+    program_pack::Pack,
+    pubkey::Pubkey,
+    sysvar,
+};
+
+solana_program::declare_id!("3medvrcM8s3UnkoYqqV3RAURii1ysuT5oD7t8nmfgJmj");
+
+pub(crate) fn get_associated_token_address_and_bump_seed(
+    wallet_address: &Pubkey,
+    spl_token_mint_address: &Pubkey,
+    program_id: &Pubkey,
+) -> (Pubkey, u8) {
+    Pubkey::find_program_address(
+        &[
+            &wallet_address.to_bytes(),
+            &spl_token::id().to_bytes(),
+            &spl_token_mint_address.to_bytes(),
+        ],
+        program_id,
+    )
+}
+
+/// Derives the associated SPL token address for the given wallet address and SPL Token mint
+pub fn get_associated_token_address(
+    wallet_address: &Pubkey,
+    spl_token_mint_address: &Pubkey,
+) -> Pubkey {
+    get_associated_token_address_and_bump_seed(&wallet_address, &spl_token_mint_address, &id()).0
+}
+
+/// Create an associated token account for a wallet address
+///
+/// Accounts expected by this instruction:
+///
+///   0. `[writeable,signer]` Funding account (must be a system account)
+///   1. `[writeable]` Associated token account address
+///   2. `[]` Wallet address for the new associated token account
+///   3. `[]` The SPL token mint for the associated token account
+///   4. `[]` System program
+///   4. `[]` SPL Token program
+///   5. `[]` Rent sysvar
+///
+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);
+
+    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![],
+    }
+}

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

@@ -0,0 +1,113 @@
+//! Program state processor
+
+use crate::*;
+use solana_program::{
+    account_info::{next_account_info, AccountInfo},
+    entrypoint::ProgramResult,
+    info,
+    log::sol_log_compute_units,
+    program::{invoke, invoke_signed},
+    program_error::ProgramError,
+    pubkey::Pubkey,
+    rent::Rent,
+    system_instruction,
+    sysvar::Sysvar,
+};
+
+/// Instruction processor
+pub fn process_instruction(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    _input: &[u8],
+) -> ProgramResult {
+    let account_info_iter = &mut accounts.iter();
+
+    let funder_info = next_account_info(account_info_iter)?;
+    let associated_token_account_info = next_account_info(account_info_iter)?;
+    let wallet_account_info = next_account_info(account_info_iter)?;
+    let spl_token_mint_info = next_account_info(account_info_iter)?;
+    let system_program_info = next_account_info(account_info_iter)?;
+    let spl_token_program_info = next_account_info(account_info_iter)?;
+    let rent_sysvar_info = next_account_info(account_info_iter)?;
+
+    let (associated_token_address, bump_seed) = get_associated_token_address_and_bump_seed(
+        &wallet_account_info.key,
+        &spl_token_mint_info.key,
+        program_id,
+    );
+    if associated_token_address != *associated_token_account_info.key {
+        info!("Error: Associated address does not match seed derivation");
+        return Err(ProgramError::InvalidSeeds);
+    }
+
+    let associated_token_account_signer_seeds: &[&[_]] = &[
+        &wallet_account_info.key.to_bytes(),
+        &spl_token::id().to_bytes(),
+        &spl_token_mint_info.key.to_bytes(),
+        &[bump_seed],
+    ];
+
+    sol_log_compute_units();
+
+    // Fund the associated token account with the minimum balance to be rent exempt
+    let rent = &Rent::from_account_info(rent_sysvar_info)?;
+    let required_lamports = rent
+        .minimum_balance(spl_token::state::Account::LEN)
+        .max(1)
+        .saturating_sub(associated_token_account_info.lamports());
+
+    if required_lamports > 0 {
+        invoke(
+            &system_instruction::transfer(
+                &funder_info.key,
+                associated_token_account_info.key,
+                required_lamports,
+            ),
+            &[
+                funder_info.clone(),
+                associated_token_account_info.clone(),
+                system_program_info.clone(),
+            ],
+        )?;
+    }
+
+    // Allocate space for the associated token account
+    invoke_signed(
+        &system_instruction::allocate(
+            associated_token_account_info.key,
+            spl_token::state::Account::LEN as u64,
+        ),
+        &[
+            associated_token_account_info.clone(),
+            system_program_info.clone(),
+        ],
+        &[&associated_token_account_signer_seeds],
+    )?;
+
+    // Assign the associated token account to the SPL Token program
+    invoke_signed(
+        &system_instruction::assign(associated_token_account_info.key, &spl_token::id()),
+        &[
+            associated_token_account_info.clone(),
+            system_program_info.clone(),
+        ],
+        &[&associated_token_account_signer_seeds],
+    )?;
+
+    // Initialize the associated token account
+    invoke(
+        &spl_token::instruction::initialize_account(
+            &spl_token::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(),
+        ],
+    )
+}