---
title: Transfer Tokens
description:
  Move tokens between token accounts for the same mint with Token Program
  transfer instructions.
url: /docs/tokens/basics/transfer-tokens
type: tutorial
prerequisites:
  - /docs/tokens/basics/create-token-account
  - /docs/tokens/basics/mint-tokens
related:
  - /docs/tokens/basics/approve-delegate
  - /docs/tokens/basics/revoke-delegate
  - /docs/tokens/basics/burn-tokens
  - /docs/tokens/basics/sync-native
---

## What Does Transferring Tokens Do?

Transferring tokens moves tokens from one token account to another token account
for the same mint.

Transfers do not change the mint supply. Transfers only update balances between
token accounts.

## How to Transfer Tokens

Transferring tokens uses the Token Program's _rs`Transfer`_ or
_rs`TransferChecked`_ instruction.

The examples below use _rs`TransferChecked`_, which requires the caller to
provide the mint and decimals so the instruction can verify the expected mint
and token precision before moving tokens between accounts.

In the Token Extension Program, _rs`Transfer`_ is deprecated in favor of
_rs`TransferChecked`_ or _rs`TransferCheckedWithFee`_.

The source account owner or an approved delegate signs the transfer. In the
Token Extension Program, a mint permanent delegate can also authorize the
transfer if the mint has the permanent delegate extension enabled.

### Source Reference

| Item                   | Description                                                                                                                                                                                      | Token Program                                                                                                  | Token Extension Program                                                                                              |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| _rs`Account`_          | The token account state stores the balances updated by a transfer.                                                                                                                               | [Source](https://github.com/solana-program/token/blob/program%40v9.0.0/interface/src/state.rs#L84-L108)        | [Source](https://github.com/solana-program/token-2022/blob/program%40v10.0.0/interface/src/state.rs#L99-L123)        |
| _rs`Transfer`_         | A transfer instruction that moves tokens between token accounts without requiring the caller to provide the mint or decimals. In the Token Extension Program, use _rs`TransferChecked`_ instead. | [Source](https://github.com/solana-program/token/blob/program%40v9.0.0/interface/src/instruction.rs#L89-L108)  | [Source](https://github.com/solana-program/token-2022/blob/program%40v10.0.0/interface/src/instruction.rs#L121-L149) |
| _rs`TransferChecked`_  | A transfer instruction that requires the caller to provide the mint and decimals and checks those values before moving tokens between token accounts of the same mint.                           | [Source](https://github.com/solana-program/token/blob/program%40v9.0.0/interface/src/instruction.rs#L245-L273) | [Source](https://github.com/solana-program/token-2022/blob/program%40v10.0.0/interface/src/instruction.rs#L308-L339) |
| _rs`process_transfer`_ | Shared processor logic for token transfers.                                                                                                                                                      | [Source](https://github.com/solana-program/token/blob/program%40v9.0.0/program/src/processor.rs#L227-L341)     | [Source](https://github.com/solana-program/token-2022/blob/program%40v10.0.0/program/src/processor.rs#L308-L579)     |

### Typescript

The `Kit` examples below show the recommended approach using `@solana/kit`.
Legacy examples using `@solana/web3.js` are included for reference.

#### Kit

<CodeTabs storage="token-ts-kit" flags="r">

```ts !! title="Plugin"
import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { solanaRpc, rpcAirdrop } from "@solana/kit-plugin-rpc";
import { generatedPayer, airdropPayer } from "@solana/kit-plugin-signer";
import {
  findAssociatedTokenPda,
  tokenProgram,
  TOKEN_PROGRAM_ADDRESS
} from "@solana-program/token";

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)))
  // !mark[/\.use\(tokenProgram\(\)\)/]
  .use(tokenProgram());

const mint = await generateKeyPairSigner();
const recipient = await generateKeyPairSigner();

// !collapse(1:16) collapsed
// Setup: create a mint and fund the payer's ATA before transferring tokens.
await client.sendTransaction([
  client.token.instructions.createMint({
    newMint: mint,
    decimals: 2,
    mintAuthority: client.payer.address,
    freezeAuthority: client.payer.address
  }),
  await client.token.instructions.mintToATA({
    mint: mint.address,
    owner: client.payer.address,
    mintAuthority: client.payer,
    amount: 100n,
    decimals: 2
  })
]);

const result = await client.token.instructions
  // !mark(1:7)
  .transferToATA({
    mint: mint.address, // Mint for the token being transferred.
    authority: client.payer, // Owner or delegate approving the transfer.
    recipient: recipient.address, // Account that owns the destination token account.
    amount: 25n, // Token amount in base units.
    decimals: 2 // Decimals defined on the mint account.
  })
  .sendTransaction();

const [sourceTokenAccount] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: client.payer.address,
  tokenProgram: TOKEN_PROGRAM_ADDRESS
});

const [destinationTokenAccount] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: recipient.address,
  tokenProgram: TOKEN_PROGRAM_ADDRESS
});

const [sourceTokenAccountData, destinationTokenAccountData] =
  await client.token.accounts.token.fetchAll([
    sourceTokenAccount,
    destinationTokenAccount
  ]);

console.log("Mint Address:", mint.address);
console.log("\nSource Token Account Address:", sourceTokenAccount);
console.log("Source Token Account:", sourceTokenAccountData.data);
console.log("\nDestination Token Account Address:", destinationTokenAccount);
console.log("Destination Token Account:", destinationTokenAccountData.data);
console.log("\nTransaction Signature:", result.context.signature);
```

```ts !! title="Instruction Plan"
import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { solanaRpc, rpcAirdrop } from "@solana/kit-plugin-rpc";
import { generatedPayer, airdropPayer } from "@solana/kit-plugin-signer";
import {
  fetchAllToken,
  findAssociatedTokenPda,
  getCreateMintInstructionPlan,
  getMintToATAInstructionPlanAsync,
  getTransferToATAInstructionPlanAsync,
  TOKEN_PROGRAM_ADDRESS
} from "@solana-program/token";

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

const mint = await generateKeyPairSigner();
const recipient = await generateKeyPairSigner();

// !collapse(1:18) collapsed
// Setup: create a mint and fund the payer's ATA before transferring tokens.
await client.sendTransaction([
  getCreateMintInstructionPlan({
    payer: client.payer,
    newMint: mint,
    decimals: 2,
    mintAuthority: client.payer.address,
    freezeAuthority: client.payer.address
  }),
  await getMintToATAInstructionPlanAsync({
    payer: client.payer,
    mint: mint.address,
    owner: client.payer.address,
    mintAuthority: client.payer,
    amount: 100n,
    decimals: 2
  })
]);

const result = await client.sendTransaction(
  // !mark(1:8)
  await getTransferToATAInstructionPlanAsync({
    payer: client.payer, // Account funding account creation.
    mint: mint.address, // Mint for the token being transferred.
    authority: client.payer, // Owner or delegate approving the transfer.
    recipient: recipient.address, // Account that owns the destination token account.
    amount: 25n, // Token amount in base units.
    decimals: 2 // Decimals defined on the mint account.
  })
);

const [sourceTokenAccount] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: client.payer.address,
  tokenProgram: TOKEN_PROGRAM_ADDRESS
});

const [destinationTokenAccount] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: recipient.address,
  tokenProgram: TOKEN_PROGRAM_ADDRESS
});

const [sourceTokenAccountData, destinationTokenAccountData] =
  await fetchAllToken(client.rpc, [
    sourceTokenAccount,
    destinationTokenAccount
  ]);

console.log("Mint Address:", mint.address);
console.log("\nSource Token Account Address:", sourceTokenAccount);
console.log("Source Token Account:", sourceTokenAccountData.data);
console.log("\nDestination Token Account Address:", destinationTokenAccount);
console.log("Destination Token Account:", destinationTokenAccountData.data);
console.log("\nTransaction Signature:", result.context.signature);
```

```ts !! title="Instructions"
import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { solanaRpc, rpcAirdrop } from "@solana/kit-plugin-rpc";
import { generatedPayer, airdropPayer } from "@solana/kit-plugin-signer";
import {
  fetchAllToken,
  findAssociatedTokenPda,
  getCreateAssociatedTokenInstructionAsync,
  getCreateMintInstructionPlan,
  getMintToATAInstructionPlanAsync,
  getTransferCheckedInstruction,
  TOKEN_PROGRAM_ADDRESS
} from "@solana-program/token";

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

const mint = await generateKeyPairSigner();
const recipient = await generateKeyPairSigner();

const [sourceTokenAccount] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: client.payer.address,
  tokenProgram: TOKEN_PROGRAM_ADDRESS
});

const [destinationTokenAccount] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: recipient.address,
  tokenProgram: TOKEN_PROGRAM_ADDRESS
});

// !collapse(1:23) collapsed
// Setup: create a mint, fund the payer's ATA, and create the recipient's ATA.
await client.sendTransaction([
  getCreateMintInstructionPlan({
    payer: client.payer,
    newMint: mint,
    decimals: 2,
    mintAuthority: client.payer.address,
    freezeAuthority: client.payer.address
  }),
  await getMintToATAInstructionPlanAsync({
    payer: client.payer,
    mint: mint.address,
    owner: client.payer.address,
    mintAuthority: client.payer,
    amount: 100n,
    decimals: 2
  }),
  await getCreateAssociatedTokenInstructionAsync({
    payer: client.payer,
    mint: mint.address,
    owner: recipient.address
  })
]);

const result = await client.sendTransaction([
  // !mark(1:8)
  getTransferCheckedInstruction({
    source: sourceTokenAccount, // Token account sending the tokens.
    mint: mint.address, // Mint for the token being transferred.
    destination: destinationTokenAccount, // Token account receiving the tokens.
    authority: client.payer, // Owner or delegate approving the transfer.
    amount: 25n, // Token amount in base units.
    decimals: 2 // Decimals defined on the mint account.
  })
]);

const [sourceTokenAccountData, destinationTokenAccountData] =
  await fetchAllToken(client.rpc, [
    sourceTokenAccount,
    destinationTokenAccount
  ]);

console.log("Mint Address:", mint.address);
console.log("\nSource Token Account Address:", sourceTokenAccount);
console.log("Source Token Account:", sourceTokenAccountData.data);
console.log("\nDestination Token Account Address:", destinationTokenAccount);
console.log("Destination Token Account:", destinationTokenAccountData.data);
console.log("\nTransaction Signature:", result.context.signature);
```

</CodeTabs>

#### Web3.js

<CodeTabs storage="token-ts-legacy" flags="r">

```ts !! title="Helper Function"
import { Connection, Keypair, LAMPORTS_PER_SOL } from "@solana/web3.js";
import {
  createAssociatedTokenAccount,
  createMint,
  getAccount,
  mintToChecked,
  TOKEN_PROGRAM_ID,
  transferChecked
} from "@solana/spl-token";

// !collapse(1:66) collapsed
// Setup: create a mint, fund the payer's ATA, and create the recipient's ATA.
const connection = new Connection("http://localhost:8899", "confirmed");
const latestBlockhash = await connection.getLatestBlockhash();

const feePayer = Keypair.generate();
const recipient = Keypair.generate();

const airdropSignature = await connection.requestAirdrop(
  feePayer.publicKey,
  LAMPORTS_PER_SOL
);
await connection.confirmTransaction({
  blockhash: latestBlockhash.blockhash,
  lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
  signature: airdropSignature
});

const mintPubkey = await createMint(
  connection,
  feePayer,
  feePayer.publicKey,
  feePayer.publicKey,
  2,
  Keypair.generate(),
  {
    commitment: "confirmed"
  },
  TOKEN_PROGRAM_ID
);

const feePayerATA = await createAssociatedTokenAccount(
  connection,
  feePayer,
  mintPubkey,
  feePayer.publicKey,
  {
    commitment: "confirmed"
  },
  TOKEN_PROGRAM_ID
);

const recipientATA = await createAssociatedTokenAccount(
  connection,
  feePayer,
  mintPubkey,
  recipient.publicKey,
  {
    commitment: "confirmed"
  },
  TOKEN_PROGRAM_ID
);

await mintToChecked(
  connection,
  feePayer,
  mintPubkey,
  feePayerATA,
  feePayer,
  100,
  2,
  [],
  {
    commitment: "confirmed"
  },
  TOKEN_PROGRAM_ID
);

// !mark(1:15)
const result = await transferChecked(
  connection, // Connection to the local validator.
  feePayer, // Account paying transaction fees.
  feePayerATA, // Token account sending the tokens.
  mintPubkey, // Mint for the token being transferred.
  recipientATA, // Token account receiving the tokens.
  feePayer, // Owner or delegate approving the transfer.
  25, // Token amount in base units.
  2, // Decimals defined on the mint account.
  [], // Additional multisig signers.
  {
    commitment: "confirmed" // Confirmation options for the transaction.
  },
  TOKEN_PROGRAM_ID // Token program to invoke.
);

const senderTokenAccount = await getAccount(
  connection,
  feePayerATA,
  "confirmed",
  TOKEN_PROGRAM_ID
);
const recipientTokenAccount = await getAccount(
  connection,
  recipientATA,
  "confirmed",
  TOKEN_PROGRAM_ID
);

console.log("Mint Address:", mintPubkey.toBase58());
console.log("\nSource Token Account Address:", feePayerATA.toBase58());
console.log("Source Token Account:", senderTokenAccount);
console.log("\nDestination Token Account Address:", recipientATA.toBase58());
console.log("Destination Token Account:", recipientTokenAccount);
console.log("\nTransaction Signature:", result);
```

```ts !! title="Instructions"
import {
  Connection,
  Keypair,
  sendAndConfirmTransaction,
  SystemProgram,
  Transaction,
  LAMPORTS_PER_SOL
} from "@solana/web3.js";
import {
  ASSOCIATED_TOKEN_PROGRAM_ID,
  createAssociatedTokenAccountInstruction,
  createInitializeMintInstruction,
  createMintToCheckedInstruction,
  createTransferCheckedInstruction,
  getAccount,
  getAssociatedTokenAddressSync,
  getMinimumBalanceForRentExemptMint,
  MINT_SIZE,
  TOKEN_PROGRAM_ID
} from "@solana/spl-token";

// !collapse(1:86) collapsed
// Setup: create a mint, fund the payer's ATA, and create the recipient's ATA.
const connection = new Connection("http://localhost:8899", "confirmed");
const latestBlockhash = await connection.getLatestBlockhash();

const feePayer = Keypair.generate();
const recipient = Keypair.generate();

const airdropSignature = await connection.requestAirdrop(
  feePayer.publicKey,
  LAMPORTS_PER_SOL
);
await connection.confirmTransaction({
  blockhash: latestBlockhash.blockhash,
  lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
  signature: airdropSignature
});

const mint = Keypair.generate();
const mintRent = await getMinimumBalanceForRentExemptMint(connection);
const feePayerATA = getAssociatedTokenAddressSync(
  mint.publicKey,
  feePayer.publicKey,
  false, // allowOwnerOffCurve
  TOKEN_PROGRAM_ID,
  ASSOCIATED_TOKEN_PROGRAM_ID
);

const recipientATA = getAssociatedTokenAddressSync(
  mint.publicKey,
  recipient.publicKey,
  false, // allowOwnerOffCurve
  TOKEN_PROGRAM_ID,
  ASSOCIATED_TOKEN_PROGRAM_ID
);

await sendAndConfirmTransaction(
  connection,
  new Transaction({
    feePayer: feePayer.publicKey,
    blockhash: latestBlockhash.blockhash,
    lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
  }).add(
    SystemProgram.createAccount({
      fromPubkey: feePayer.publicKey,
      newAccountPubkey: mint.publicKey,
      space: MINT_SIZE,
      lamports: mintRent,
      programId: TOKEN_PROGRAM_ID
    }),
    createInitializeMintInstruction(
      mint.publicKey,
      2,
      feePayer.publicKey,
      feePayer.publicKey,
      TOKEN_PROGRAM_ID
    ),
    createAssociatedTokenAccountInstruction(
      feePayer.publicKey,
      feePayerATA,
      feePayer.publicKey,
      mint.publicKey,
      TOKEN_PROGRAM_ID,
      ASSOCIATED_TOKEN_PROGRAM_ID
    ),
    createAssociatedTokenAccountInstruction(
      feePayer.publicKey,
      recipientATA,
      recipient.publicKey,
      mint.publicKey,
      TOKEN_PROGRAM_ID,
      ASSOCIATED_TOKEN_PROGRAM_ID
    ),
    createMintToCheckedInstruction(
      mint.publicKey,
      feePayerATA,
      feePayer.publicKey,
      100,
      2,
      [],
      TOKEN_PROGRAM_ID
    )
  ),
  [feePayer, mint]
);

const transferBlockhash = await connection.getLatestBlockhash();

const result = await sendAndConfirmTransaction(
  connection,
  new Transaction({
    feePayer: feePayer.publicKey,
    blockhash: transferBlockhash.blockhash,
    lastValidBlockHeight: transferBlockhash.lastValidBlockHeight
  }).add(
    // !mark(1:10)
    createTransferCheckedInstruction(
      feePayerATA, // Token account sending the tokens.
      mint.publicKey, // Mint for the token being transferred.
      recipientATA, // Token account receiving the tokens.
      feePayer.publicKey, // Owner or delegate approving the transfer.
      25, // Token amount in base units.
      2, // Decimals defined on the mint account.
      [], // Additional multisig signers.
      TOKEN_PROGRAM_ID // Token program to invoke.
    )
  ),
  [feePayer]
);

const senderTokenAccount = await getAccount(
  connection,
  feePayerATA,
  "confirmed",
  TOKEN_PROGRAM_ID
);
const recipientTokenAccount = await getAccount(
  connection,
  recipientATA,
  "confirmed",
  TOKEN_PROGRAM_ID
);

console.log("Mint Address:", mint.publicKey.toBase58());
console.log("\nSource Token Account Address:", feePayerATA.toBase58());
console.log("Source Token Account:", senderTokenAccount);
console.log("\nDestination Token Account Address:", recipientATA.toBase58());
console.log("Destination Token Account:", recipientTokenAccount);
console.log("\nTransaction Signature:", result);
```

</CodeTabs>

### Rust

<CodeTabs storage="token-rs" flags="r">

```rust !! title="Rust"
use anyhow::Result;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_commitment_config::CommitmentConfig;
use solana_sdk::{
    program_pack::Pack,
    signature::{Keypair, Signer},
    transaction::Transaction,
};
use solana_system_interface::instruction::create_account;
use spl_associated_token_account_interface::{
    address::get_associated_token_address, instruction::create_associated_token_account,
};
use spl_token_interface::{
    id as token_program_id,
    instruction::{initialize_mint, mint_to_checked, transfer_checked},
    state::{Account, Mint},
};

#[tokio::main]
async fn main() -> Result<()> {
    let client = RpcClient::new_with_commitment(
        String::from("http://localhost:8899"),
        CommitmentConfig::confirmed(),
    );
    let recipient = Keypair::new();

    // !collapse(1:72) collapsed
    // Setup: create a mint, fund the payer's ATA, and create the recipient's ATA.
    let fee_payer = Keypair::new();
    let decimals = 2;

    let airdrop_signature = client
        .request_airdrop(&fee_payer.pubkey(), 1_000_000_000)
        .await?;
    loop {
        let confirmed = client.confirm_transaction(&airdrop_signature).await?;
        if confirmed {
            break;
        }
    }

    let mint = Keypair::new();
    let mint_rent = client
        .get_minimum_balance_for_rent_exemption(Mint::LEN)
        .await?;
    let source_token_address = get_associated_token_address(
        &fee_payer.pubkey(),
        &mint.pubkey(),
    );
    let destination_token_address = get_associated_token_address(
        &recipient.pubkey(),
        &mint.pubkey(),
    );
    let latest_blockhash = client.get_latest_blockhash().await?;
    let setup_transaction = Transaction::new_signed_with_payer(
        &[
            create_account(
                &fee_payer.pubkey(),
                &mint.pubkey(),
                mint_rent,
                Mint::LEN as u64,
                &token_program_id(),
            ),
            initialize_mint(
                &token_program_id(),
                &mint.pubkey(),
                &fee_payer.pubkey(),
                Some(&fee_payer.pubkey()),
                decimals,
            )?,
            create_associated_token_account(
                &fee_payer.pubkey(),
                &fee_payer.pubkey(),
                &mint.pubkey(),
                &token_program_id(),
            ),
            create_associated_token_account(
                &fee_payer.pubkey(),
                &recipient.pubkey(),
                &mint.pubkey(),
                &token_program_id(),
            ),
            mint_to_checked(
                &token_program_id(),
                &mint.pubkey(),
                &source_token_address,
                &fee_payer.pubkey(),
                &[],
                100,
                decimals,
            )?,
        ],
        Some(&fee_payer.pubkey()),
        &[&fee_payer, &mint],
        latest_blockhash,
    );
    client
        .send_and_confirm_transaction(&setup_transaction)
        .await?;

    let transfer_amount = 25;
    let transaction = Transaction::new_signed_with_payer(
        &[
            // !mark(1:10)
            transfer_checked(
                &token_program_id(), // Token program to invoke.
                &source_token_address, // Token account sending the tokens.
                &mint.pubkey(), // Mint for the token being transferred.
                &destination_token_address, // Token account receiving the tokens.
                &fee_payer.pubkey(), // Owner or delegate approving the transfer.
                &[], // Additional multisig signers.
                transfer_amount, // Token amount in base units.
                decimals, // Decimals defined on the mint account.
            )?,
        ],
        Some(&fee_payer.pubkey()),
        &[&fee_payer],
        latest_blockhash,
    );

    let transaction_signature = client.send_and_confirm_transaction(&transaction).await?;
    let source_token_account = client.get_account(&source_token_address).await?;
    let source_token_data = Account::unpack(&source_token_account.data)?;
    let destination_token_account = client.get_account(&destination_token_address).await?;
    let destination_token_data = Account::unpack(&destination_token_account.data)?;

    println!("Mint Address: {}", mint.pubkey());
    println!("\nSource Token Account Address: {}", source_token_address);
    println!("Source Token Account: {:#?}", source_token_data);
    println!(
        "\nDestination Token Account Address: {}",
        destination_token_address
    );
    println!("Destination Token Account: {:#?}", destination_token_data);
    println!("\nTransaction Signature: {}", transaction_signature);

    Ok(())
}
```

</CodeTabs>

### Python

<CodeTabs flags="r">

```py !! title="Python"
#!/usr/bin/env python3

import asyncio
import json
from solana.rpc.async_api import AsyncClient
from solders.keypair import Keypair
from solders.message import Message
from solders.pubkey import Pubkey
from solders.system_program import create_account, CreateAccountParams
from solders.transaction import Transaction
from spl.token.async_client import AsyncToken
from spl.token.instructions import (
    create_associated_token_account,
    get_associated_token_address,
    initialize_mint,
    InitializeMintParams,
    mint_to_checked,
    MintToCheckedParams,
    transfer_checked,
    TransferCheckedParams,
)
from spl.token.constants import MINT_LEN, TOKEN_PROGRAM_ID

DECIMALS = 2
AMOUNT_TO_MINT = 100
AMOUNT_TO_TRANSFER = 25

async def main():
    rpc = AsyncClient("http://localhost:8899")

    receiver = Keypair()

    async with rpc:
        # !collapse(1:23) collapsed
        # Setup: create a mint, source token account, destination token account, and source token balance.
        fee_payer = Keypair()
        airdrop_signature = (await rpc.request_airdrop(fee_payer.pubkey(), 1_000_000_000)).value
        await rpc.confirm_transaction(airdrop_signature)
        mint = Keypair()
        source_token_account = get_associated_token_address(fee_payer.pubkey(), mint.pubkey())
        destination_token_account = get_associated_token_address(receiver.pubkey(), mint.pubkey())
        mint_rent = (await rpc.get_minimum_balance_for_rent_exemption(MINT_LEN)).value
        setup_instructions = [
            create_account(CreateAccountParams(from_pubkey=fee_payer.pubkey(), to_pubkey=mint.pubkey(), lamports=mint_rent, space=MINT_LEN, owner=TOKEN_PROGRAM_ID)),
            initialize_mint(InitializeMintParams(decimals=DECIMALS, program_id=TOKEN_PROGRAM_ID, mint=mint.pubkey(), mint_authority=fee_payer.pubkey())),
            create_associated_token_account(fee_payer.pubkey(), fee_payer.pubkey(), mint.pubkey(), TOKEN_PROGRAM_ID),
            create_associated_token_account(fee_payer.pubkey(), receiver.pubkey(), mint.pubkey(), TOKEN_PROGRAM_ID),
            mint_to_checked(MintToCheckedParams(program_id=TOKEN_PROGRAM_ID, mint=mint.pubkey(), dest=source_token_account, mint_authority=fee_payer.pubkey(), amount=AMOUNT_TO_MINT, decimals=DECIMALS)),
        ]
        setup_blockhash = await rpc.get_latest_blockhash()
        setup_transaction = Transaction(
            [fee_payer, mint],
            Message(setup_instructions, fee_payer.pubkey()),
            setup_blockhash.value.blockhash,
        )
        await rpc.send_transaction(setup_transaction)
        token = AsyncToken(rpc, mint.pubkey(), TOKEN_PROGRAM_ID, fee_payer)

        # !mark(1:11)
        transfer_tokens_instruction = transfer_checked(
            TransferCheckedParams(
                program_id=TOKEN_PROGRAM_ID,  # Token program to invoke.
                source=source_token_account,  # Token account sending the tokens.
                mint=mint.pubkey(),  # Mint for the token being transferred.
                dest=destination_token_account,  # Token account receiving the tokens.
                owner=fee_payer.pubkey(),  # Account that owns the source token account.
                amount=AMOUNT_TO_TRANSFER,  # Token amount in base units.
                decimals=DECIMALS,  # Decimals defined on the mint account.
            )
        )
        latest_blockhash = await rpc.get_latest_blockhash()
        transaction = Transaction(
            [fee_payer],
            Message([transfer_tokens_instruction], fee_payer.pubkey()),
            latest_blockhash.value.blockhash,
        )
        result = await rpc.send_transaction(transaction)

        source_token_account_info = await token.get_account_info(source_token_account)
        destination_token_account_info = await token.get_account_info(destination_token_account)
        source_account = {
            key: str(value) if isinstance(value, Pubkey) else value
            for key, value in source_token_account_info._asdict().items()
        }
        destination_account = {
            key: str(value) if isinstance(value, Pubkey) else value
            for key, value in destination_token_account_info._asdict().items()
        }

        print("Mint Address:", mint.pubkey())
        print("\nSource Token Account Address:", source_token_account)
        print("Source Token Account:")
        print(json.dumps(source_account, indent=2))
        print("\nDestination Token Account Address:", destination_token_account)
        print("Destination Token Account:")
        print(json.dumps(destination_account, indent=2))
        print("\nTransaction Signature:", result.value)

if __name__ == "__main__":
    asyncio.run(main())
```

</CodeTabs>