Token transfer

Outline

It is a necessary operation to transfer tokens between accounts. Use transfer instruction of token program to perform transfer operation.

The final outcome of this chapter could be found here

How to transfer a token to other account?

So far, we have created a mint and minted it to an account. But how to transfer the mint to other accounts?

It also involves the same process. Create a TransferTokenToAnother context and create an instruction transfer_token_to_another to achieve the end goal.

How to create a TransferTokenToAnother context?

Below is the struct that we define for transferring a spl_token_mint token to other account.

// Transfer token to another account
#[derive(Accounts)]
pub struct TransferTokenToAnother<'info> {
    #[account(
         seeds = [
            b"spl-token-mint".as_ref(),
         ],
        bump = vault.spl_token_mint_bump,
    )]
    pub spl_token_mint: Account<'info, Mint>, // ---> 1

    #[account(
        seeds = [
            b"vault"
        ],
        bump = vault.bump, // --> 2
    )]
    pub vault: Account<'info, Vault>,

    #[account(
        mut,
        associated_token::mint = spl_token_mint,
        associated_token::authority = payer
    )]
    pub payer_mint_ata: Box<Account<'info, TokenAccount>>, // --> 3

    #[account(mut)]
    pub payer: Signer<'info>, // ---> 4

    pub system_program: Program<'info, System>, // ---> 5
    pub token_program: Program<'info, Token>,   // ---> 6

    pub rent: Sysvar<'info, Rent>, // ---> 7

    pub associated_token_program: Program<'info, AssociatedToken>, // ---> 8

    #[account(
        init,
        payer = payer,
        associated_token::mint = spl_token_mint,
        associated_token::authority = another_account
    )]
    pub another_mint_ata: Box<Account<'info, TokenAccount>>, // --> 9

    /// CHECK : We just pass the account info for the demonstration purpose. Ideally this is either signer or trusted account
    pub another_account: AccountInfo<'info>, // ---> 10
}

1. We pass the spl_token_mint account without any mut or init decoration.
2. We pass the vault. This can be used for security purpose.
3. payer_mint_ata account from which we are transferring token to another ata
4. payer signer who is transferring the token
5. system_program account for executing the instruction.
6. token_program account used for performing transfer operation
7. init decorator uses rent account for creating account
8. We are creating a new ata account. Hence we pass associated_token_program
9. another_mint_ata account to which we transfer the token.
10. another_account account is the owner of another_mint_ata

Create a transfer_token_to_another instruction for transferring a token.

    pub fn transfer_token_to_another(ctx : Context<TransferTokenToAnother>) -> Result<()> {
        let cpi_context = CpiContext::new(
            ctx.accounts.token_program.to_account_info(),
            token::Transfer {
                from : ctx.accounts.payer_mint_ata.to_account_info(),
                to : ctx.accounts.another_mint_ata.to_account_info(),
                authority : ctx.accounts.payer.to_account_info()
            },
        );
        token::transfer(cpi_context, 1)?;
        Ok(())
    }

Time to test the transfer_token_to_another instruction.

Let us first create anotherWallet and add it to the root of the test case.

const anotherWallet = anchor.web3.Keypair.generate(); // newly created another wallet

And add some sols to the wallet using addSols function in before function block.

  before("Add sols to wallet ", async () => {
    await addSols(provider, payer.publicKey);
    await addSols(provider, anotherWallet.publicKey); // add sols to another wallet 
  });

We will test case in spl-token.ts. Add the following in your test file.

  it("should transfer 1 token from payer_mint_ata to another_mint_ata", async () => {
    try {
      
      const [splTokenMint, _1] = await findSplTokenMintAddress();

      const [vaultMint, _2] = await findVaultAddress();

      const [payerMintAta, _3] = await findAssociatedTokenAccount(
        payer.publicKey,
        splTokenMint
      );

      const [anotherMintAta, _4] = await findAssociatedTokenAccount(
        anotherWallet.publicKey,
        splTokenMint
      );

      const tx = await program.methods
        .transferTokenToAnother()
        .accounts({
          splTokenMint: splTokenMint,
          vault: vaultMint,
          associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
          tokenProgram: TOKEN_PROGRAM_ID,
          systemProgram: SystemProgram.programId,
          payerMintAta: payerMintAta,
          payer: payer.publicKey,
          anotherMintAta: anotherMintAta,
          rent: anchor.web3.SYSVAR_RENT_PUBKEY,
          anotherAccount: anotherWallet.publicKey,
        })
        .signers([payer])
        .rpc();

      console.log("Your transaction signature", tx);
    } catch (err) {
      console.log(err);
    }
  });

Run the command

anchor test

Then the output should be a success as shown below.

So, far we have understood how minting and transfer work. In the next sections we will discuss about freezing a token account.