Send USDC on Solana

const TEE_BASE = "https://tee.express.magiclabs.com";

async function teeRequest<T>(path: string, jwt: string, body: object): Promise<T> {
  const res = await fetch(`${TEE_BASE}${path}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${jwt}`,
      "X-Magic-Secret-Key": "YOUR_SECRET_KEY",
      "X-OIDC-Provider-ID": "YOUR_OIDC_PROVIDER_ID",
      "X-Magic-Chain": "SOL",
    },
    body: JSON.stringify(body),
  });
  if (!res.ok) throw new Error(`TEE error: ${res.status}`);
  return res.json();
}

const { public_address: walletAddress } = await teeRequest<{ public_address: string }>(
  "/v1/wallet", jwt, { chain: "SOL" }
);

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

const connection = new Connection("YOUR_SOLANA_RPC_URL");

async function signAndSend(jwt: string, walletAddress: string, transaction: Transaction) {
  const walletPubkey = new PublicKey(walletAddress);

  // Serialize the transaction message as base64
  const messageBytes = transaction.serializeMessage();
  const messageBase64 = Buffer.from(messageBytes).toString("base64");

  // Sign via TEE
  const { signature } = await teeRequest<{ signature: string }>(
    "/v1/wallet/sign/message", jwt, { message_base64: messageBase64 }
  );

  // Attach signature to the transaction
  const sigBytes = signature.startsWith("0x")
    ? Buffer.from(signature.slice(2), "hex")
    : Buffer.from(signature, "base64");
  transaction.addSignature(walletPubkey, sigBytes);

  // Broadcast
  const txSignature = await connection.sendRawTransaction(transaction.serialize());
  await connection.confirmTransaction(txSignature);

  return txSignature;
}

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

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

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

  // Get Associated Token Accounts
  const senderATA = await getAssociatedTokenAddress(USDC_MINT, walletPubkey);
  const recipientATA = await getAssociatedTokenAddress(USDC_MINT, recipient);

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

  // Create recipient's token account if it doesn't exist
  try {
    await getAccount(connection, recipientATA);
  } catch {
    transaction.add(
      createAssociatedTokenAccountInstruction(
        walletPubkey,  // 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
      walletPubkey,   // owner of source account
      transferAmount, // amount in smallest units
    )
  );

  return await signAndSend(jwt, walletAddress, transaction);
}

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

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

  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(walletAddress);
console.log(`Balance: ${balance} USDC`);

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