Solana: How to transfer Solana tokens to another account?

Transferring Tokens Owned by a Solana Program: A Step-by-Step Guide

As a Solana developer, you are probably familiar with the flexibility and scalability of the Solana blockchain. However, when working with token ownership models, a common challenge is transferring tokens from one program to another account. In this article, we will explore how to implement an instruction in your Solana program that allows for token transfers.

Understanding Token Ownership

Before diving into the solution, it is important to understand token ownership in Solana. A token is considered “owned” by a user when it has a unique public key (address) associated with it. This public key serves as the identity of the owner, and all transactions involving tokens are tied to that address.

Instruction: transfer

The “transfer” instruction is the most commonly used method for transferring tokens between Solana accounts. It allows you to transfer a certain amount of tokens from one account to another, using the program’s public key as the source address and the recipient’s account as the destination address.

Here is an example of how you can implement this instruction:

“solana

use solana-program-lib::instruction::{Instruction, ProgramId};

use solana_program::{

account_info::next_account_info,

entrypoint::ProgramResult,

program_error::PrintError,

pubkey::Pubkey,

};

pub struct TokenOwnershipInstruction {

src_account: Pubkey,

dst_account: Pubkey,

quantity: u64,

}

impl TokenOwnershipInstruction {

pub fn new(src_account: Pubkey, dst_account: Pubkey, amount: u64) -> Self {

Self { src_account, dst_account, amount }

}

pub fn execute(&self, context: &mut solana_program::exec_context::ExecContext) -> ProgramResult {

let next_account_info = next_account_info(context)?;

let src_user = next_account_info.user_id;

let src_token = self.src_account;

// Check if the token owner has sufficient balance

if src_user.balance < self.amount {

return solana_program::Error::InvalidArgument(

format!(“Insufficient balance to transfer token: {}”,

src_user.balance),

);

}

// Create a new token transfer instruction

let instruction = Instruction::new(

TokenOwnershipInstruction::new(src_token, self.dst_account, self.amount),

&[],

);

// Execute the instruction using the transfer function from solana-program-lib

solana_program::program_lib::instruction::invoke_single(&instruction, &self.src_account)?;

return OK(())

}

}

Example use case



To demonstrate how to use this instruction in your program, you can create a simple user account and pass some SPL tokens to it:

rust

use solana_program::{

account_info::{next_account_info, Pubkey},

entrypoint::ProgramResult,

program_error::PrintError,

pubkey::Pubkey,

};

pub struct UserAccount {

accounts: Vec,

}

impl UserAccount {

fn new() -> Self {

let user_account = next_account_info(Pubkey::new())?;

// Initialize the SPL token account with an empty balance

let spl_token_account = next_account_info(Pubkey::new()).unwrap();

solana_program::instruction::invoke_single(

&solana_program::instruction::transfer(

&user_account,

spl_token_account,

100u64,

),

&[],

)?