Send USDC on Solana

import { Magic } from "magic-sdk";
import { SolanaExtension } from "@magic-ext/solana";
import { Connection, PublicKey } from "@solana/web3.js";

const magic = new Magic("YOUR_PUBLISHABLE_KEY", {
  extensions: [
    new SolanaExtension({
      rpcUrl: "YOUR_SOLANA_RPC_URL",
    }),
  ],
});

const connection = new Connection("YOUR_SOLANA_RPC_URL");

// Get the user's public key (after authentication)
const publicAddress = await magic.solana.getPublicAddress();
const userPublicKey = new PublicKey(publicAddress);

import {
  getAssociatedTokenAddress,
  createAssociatedTokenAccountInstruction,
  createTransferInstruction,
  getAccount,
} from "@solana/spl-token";

// USDC on Solana mainnet
const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
const USDC_DECIMALS = 6;

import { Transaction } from "@solana/web3.js";

async function sendUSDC(recipientAddress: string, amount: string) {
  const recipient = new PublicKey(recipientAddress);
  const transferAmount = BigInt(Math.round(parseFloat(amount) * 10 ** USDC_DECIMALS));

  // Get Associated Token Accounts for sender and recipient
  const senderATA = await getAssociatedTokenAddress(USDC_MINT, userPublicKey);
  const recipientATA = await getAssociatedTokenAddress(USDC_MINT, recipient);

  const blockhash = await connection.getLatestBlockhash();
  const transaction = new Transaction({
    ...blockhash,
    feePayer: userPublicKey,
  });

  // Create recipient's token account if it doesn't exist
  try {
    await getAccount(connection, recipientATA);
  } catch {
    transaction.add(
      createAssociatedTokenAccountInstruction(
        userPublicKey, // payer
        recipientATA,  // ATA to create
        recipient,     // owner of the new ATA
        USDC_MINT,     // token mint
      )
    );
  }

  // Add the transfer instruction
  transaction.add(
    createTransferInstruction(
      senderATA,     // source
      recipientATA,  // destination
      userPublicKey,  // owner of source account
      transferAmount, // amount in smallest units
    )
  );

  // Sign with Magic and broadcast
  const signedTransaction = await magic.solana.signTransaction(transaction, {
    requireAllSignatures: false,
    verifySignatures: true,
  });

  const signature = await connection.sendRawTransaction(
    Buffer.from(signedTransaction.rawTransaction, "base64")
  );

  await connection.confirmTransaction({
    signature,
    ...blockhash,
  });

  return signature;
}

// Send 10 USDC
await sendUSDC("RecipientSolanaAddress", "10");

async function getUSDCBalance(ownerAddress: PublicKey) {
  const ata = await getAssociatedTokenAddress(USDC_MINT, ownerAddress);

  try {
    const account = await getAccount(connection, ata);
    const balance = Number(account.amount) / 10 ** USDC_DECIMALS;
    return balance.toString();
  } catch {
    // Token account doesn't exist — balance is zero
    return "0";
  }
}

const balance = await getUSDCBalance(userPublicKey);
console.log(`Balance: ${balance} USDC`);

// USDC on Solana (native, issued by Circle)
const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";