Vérifier une adresse

Envoyer des tokens à la mauvaise adresse peut entraîner une perte permanente de fonds. La vérification d'adresse garantit que vous n'envoyez des tokens qu'à des adresses qui peuvent correctement les recevoir et y accéder.

Comprendre les adresses Solana

Les comptes Solana ont deux types d'adresses, sur courbe et hors courbe.

Adresses sur courbe

Les adresses standard sont les clés publiques des paires de clés Ed25519. Ces adresses :

• Ont une clé privée correspondante qui peut signer des transactions
• Sont utilisées comme adresses de portefeuille

Adresses hors courbe (PDA)

Les adresses dérivées de programme sont dérivées de manière déterministe à partir d'un ID de programme et de seeds. Ces adresses :

• N'ont pas de clé privée correspondante
• Ne peuvent être signées que par le programme dont l'adresse a été dérivée

Types de comptes dans les paiements

Utilisez l'adresse pour récupérer un compte depuis le réseau, vérifiez son propriétaire de programme et son type de compte pour déterminer comment traiter l'adresse.

Comptes du System Program (portefeuilles)

Les comptes détenus par le System Program sont des portefeuilles standard. Pour envoyer des tokens SPL à un portefeuille, vous dérivez et utilisez son compte de tokens associé (ATA).

Après avoir dérivé l'adresse ATA, vérifiez si le token account existe on-chain. Si l'ATA n'existe pas, vous pouvez inclure une instruction pour créer le token account du destinataire dans la même transaction que le transfert. Cependant, cela nécessite de payer le rent pour le nouveau token account. Étant donné que le destinataire possède l' ATA, les SOL payés pour le rent ne peuvent pas être récupérés par l'expéditeur.

Comptes de jetons

Les comptes de jetons appartiennent au Token Program ou au Token-2022 Program et contiennent des soldes de jetons. Si l'adresse que vous recevez appartient à un programme de jetons, vous devez vérifier que le compte est un compte de jetons (et non un mint account) et correspond au mint account de jeton attendu avant d'envoyer.

Mint accounts

Les mint accounts suivent l'offre de jetons et les métadonnées d'un jeton spécifique. Les mint accounts appartiennent également aux Token Programs mais ne sont pas des destinataires valides pour les transferts de jetons. Tenter d'envoyer des jetons à une adresse de mint entraîne l'échec de la transaction, mais aucun fonds n'est perdu.

Autres comptes

Les comptes appartenant à d'autres programmes nécessitent une décision politique. Certains comptes (par exemple, les portefeuilles multisig) peuvent être des propriétaires valides de comptes de jetons, tandis que d'autres doivent être rejetés.

Flux de vérification

Le diagramme suivant présente un arbre de décision de référence pour valider une adresse :

Démo

L'exemple suivant montre uniquement la logique de validation d'adresse. Il s'agit de code de référence à des fins d'illustration.

La démo ci-dessous utilise trois résultats possibles :

/**
 * Validates an input address and classifies it as a wallet, token account, or invalid.
 *
 * @param inputAddress - The address to validate
 * @param rpc - Optional RPC client (defaults to mainnet)
 * @returns Classification result:
 *   - IS_WALLET: Valid wallet address
 *   - IS_TOKEN_ACCOUNT: Valid token account
 *   - REJECT: Invalid address for transfers
 */
export async function validateAddress(
  inputAddress: Address,
  rpc: Rpc<GetAccountInfoApi> = defaultRpc
): Promise<ValidationResult> {
  const account = await fetchJsonParsedAccount(rpc, inputAddress);
  // Log the account data for demo
  console.log("\nAccount:", account);

  // Account doesn't exist on-chain
  if (!account.exists) {
    // Off-curve = PDA that doesn't exist as an account
    // Reject conservatively to avoid sending to an address that may be inaccessible.
    if (isOffCurveAddress(inputAddress)) {
      return { type: "REJECT", reason: "PDA doesn't exist as an account" };
    }
    // On-curve = valid keypair address, treat as unfunded wallet
    return { type: "IS_WALLET" };
  }

  // Account exists, check program owner
  const owner = account.programAddress;

  // System Program = wallet
  if (owner === SYSTEM_PROGRAM) {
    return { type: "IS_WALLET" };
  }

  // Token Program or Token-2022, check if token account
  if (owner === TOKEN_PROGRAM || owner === TOKEN_2022_PROGRAM) {
    const accountType = (
      account.data as { parsedAccountMeta?: { type?: string } }
    ).parsedAccountMeta?.type;

    if (accountType === "account") {
      return { type: "IS_TOKEN_ACCOUNT" };
    }
    // Reject if not a token account (mint account)
    return {
      type: "REJECT",
      reason: "Not a token account"
    };
  }

  // Unknown program owner
  return { type: "REJECT", reason: "Unknown program owner" };
}

// =============================================================================
// Examples
// =============================================================================

/**
 * Validates an input address and classifies it as a wallet, token account, or invalid.
 *
 * @param inputAddress - The address to validate
 * @param rpc - Optional RPC client (defaults to mainnet)
 * @returns Classification result:
 *   - IS_WALLET: Valid wallet address
 *   - IS_TOKEN_ACCOUNT: Valid token account
 *   - REJECT: Invalid address for transfers
 */
export async function validateAddress(
  inputAddress: Address,
  rpc: Rpc<GetAccountInfoApi> = defaultRpc
): Promise<ValidationResult> {
  const account = await fetchJsonParsedAccount(rpc, inputAddress);
  // Log the account data for demo
  console.log("\nAccount:", account);

  // Account doesn't exist on-chain
  if (!account.exists) {
    // Off-curve = PDA that doesn't exist as an account
    // Reject conservatively to avoid sending to an address that may be inaccessible.
    if (isOffCurveAddress(inputAddress)) {
      return { type: "REJECT", reason: "PDA doesn't exist as an account" };
    }
    // On-curve = valid keypair address, treat as unfunded wallet
    return { type: "IS_WALLET" };
  }

  // Account exists, check program owner
  const owner = account.programAddress;

  // System Program = wallet
  if (owner === SYSTEM_PROGRAM) {
    return { type: "IS_WALLET" };
  }

  // Token Program or Token-2022, check if token account
  if (owner === TOKEN_PROGRAM || owner === TOKEN_2022_PROGRAM) {
    const accountType = (
      account.data as { parsedAccountMeta?: { type?: string } }
    ).parsedAccountMeta?.type;

    if (accountType === "account") {
      return { type: "IS_TOKEN_ACCOUNT" };
    }
    // Reject if not a token account (mint account)
    return {
      type: "REJECT",
      reason: "Not a token account"
    };
  }

  // Unknown program owner
  return { type: "REJECT", reason: "Unknown program owner" };
}

// =============================================================================
// Examples
// =============================================================================