Adres verifiëren

Het versturen van tokens naar het verkeerde adres kan resulteren in permanent verlies van fondsen. Adresverificatie zorgt ervoor dat je alleen tokens verstuurt naar adressen die ze correct kunnen ontvangen en benaderen.

Solana-adressen begrijpen

Solana-accounts hebben twee soorten adressen: on-curve en off-curve.

On-curve adressen

Standaardadressen zijn de publieke sleutels van Ed25519-sleutelparen. Deze adressen:

• Hebben een bijbehorende private key die transacties kan ondertekenen
• Worden gebruikt als wallet-adressen

Off-curve adressen (PDA's)

Program Derived Addresses worden deterministisch afgeleid van een program-ID en seeds. Deze adressen:

• Hebben geen bijbehorende private key
• Kunnen alleen ondertekend worden door het programma waarvan het adres is afgeleid

Accounttypes bij betalingen

Gebruik het adres om een account op te halen van het netwerk, controleer de program owner en het accounttype om te bepalen hoe het adres moet worden behandeld.

System Program-accounts (wallets)

Accounts die eigendom zijn van het System Program zijn standaard wallets. Om SPL-tokens naar een wallet te versturen, leid je het Associated Token Account (ATA) af en gebruik je dat.

Nadat je het ATA-adres hebt afgeleid, controleer je of het token account on-chain bestaat. Als het ATA niet bestaat, kun je een instructie toevoegen om het token account van de ontvanger aan te maken in dezelfde transactie als de overdracht. Dit vereist echter het betalen van rent voor het nieuwe token account. Omdat de ontvanger eigenaar is van het ATA, kan de SOL die voor de rent is betaald niet worden teruggevorderd door de verzender.

Token accounts

Token accounts zijn eigendom van het Token Program of Token-2022 Program en bevatten tokensaldi. Als het adres dat je ontvangt eigendom is van een token program, moet je verifiëren dat het account een token account is (geen mint account) en overeenkomt met het verwachte token mint account voordat je verzendt.

Mint accounts

Mint accounts houden de tokenaanbod en metadata van een specifieke token bij. Mint accounts zijn ook eigendom van Token Programs maar zijn niet geldige ontvangers voor tokenoverdrachten. Een poging om tokens naar een mint-adres te verzenden resulteert in een mislukte transactie, maar er gaan geen fondsen verloren.

Andere accounts

Accounts die eigendom zijn van andere programma's vereisen een beleidsbeslissing. Sommige accounts (bijv. multisig wallets) kunnen geldige token account-eigenaren zijn, terwijl andere moeten worden afgewezen.

Verificatieproces

Het volgende diagram toont een referentiebeslissingsboom voor het valideren van een adres:

Demo

Het volgende voorbeeld toont alleen de adresvalidatielogica. Dit is referentiecode ter illustratie.

De onderstaande demo gebruikt drie mogelijke uitkomsten:

/**
 * 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
// =============================================================================