Cara Menggunakan getTokenAccountsByDelegate

​

Kasus Penggunaan Umum

• Mencantumkan Aset yang Didelegasikan: Menampilkan semua akun token yang telah memberikan wewenang delegasi kepada dompet atau program tertentu.
• Pengelolaan Token Otomatis: Layanan yang melakukan tindakan atas nama pengguna (misalnya, pembuat pasar otomatis dan protokol staking yang mengelola imbalan dalam bentuk token) dapat menggunakan metode ini untuk menemukan akun yang boleh berinteraksi dengannya.
• Mengaudit Delegasi: Meninjau akun yang telah mendelegasikan wewenang kepada alamat tertentu.
• Mencabut Delegasi: Mengidentifikasi akun token yang wewenang delegasinya perlu dicabut (meskipun pencabutan itu sendiri merupakan transaksi terpisah).

​

Parameter Permintaan

1. delegatePubkey (string, wajib): Kunci publik akun delegasi yang dikodekan dalam base-58 dan akun token terkaitnya ingin Anda temukan.
2. filter (object, wajib): Object JSON yang harus menentukan mint atau programId untuk memfilter akun:
   • mint (string): Kunci publik mint token tertentu yang dikodekan dalam base-58. Jika diberikan, kueri hanya akan mengembalikan akun token dari jenis token tersebut yang didelegasikan kepada delegatePubkey.
   • programId (string): Kunci publik Token Program yang memiliki akun tersebut, yang dikodekan dalam base-58. Biasanya, ini adalah SPL Token Program standar (TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA) atau Token-2022 Program (TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb).
3. options (object, opsional): Object konfigurasi opsional dengan bidang umum berikut:
   • commitment (string, opsional): Menentukan tingkat komitmen.
   • encoding (string, opsional): Pengodean untuk data akun. "jsonParsed" sangat disarankan karena mengembalikan informasi akun yang dapat dibaca manusia. Opsi lainnya mencakup "base64" dan "base64+zstd". Nilai default-nya adalah "base64" jika tidak ditentukan.
   • dataSlice (object, opsional): Memungkinkan Anda mengambil hanya bagian tertentu dari data akun. Berisi bidang offset (usize) dan length (usize). Hanya berlaku untuk pengodean base58, base64, atau base64+zstd.
   • minContextSlot (u64, opsional): Slot minimum tempat permintaan dapat dievaluasi.

​

Struktur Respons

• pubkey (string): Kunci publik akun token itu sendiri yang dikodekan dalam base-58.
• account (object): Object yang berisi informasi mendetail tentang akun token:
  • lamports (u64): Saldo lamport akun token (untuk pembebasan biaya sewa).
  • owner (string): Kunci publik program yang memiliki akun ini (misalnya, Token Program).
  • data: Data akun. Jika pengodean "jsonParsed" digunakan, nilainya akan berupa object dengan bidang program (misalnya, "spl-token") dan bidang parsed yang berisi informasi terstruktur:
    • parsed.info: Object dengan detail seperti:
      • mint (string): Alamat mint token.
      • owner (string): Pemilik akun token (bukan delegasi).
      • tokenAmount (object): Total saldo token dalam akun ini (amount, decimals, uiAmount, uiAmountString).
      • delegate (string): Kunci publik delegasi (harus cocok dengan delegatePubkey dari permintaan).
      • delegatedAmount (object): Jumlah token yang boleh dikelola oleh delegasi (amount, decimals, uiAmount, uiAmountString).
      • isNative (boolean): Menunjukkan apakah akun menyimpan SOL terbungkus.
      • state (string): Status akun token (misalnya, "initialized").
    • parsed.type (string): Jenis akun (misalnya, "account").
  • executable (boolean): Apakah akun dapat dieksekusi.
  • rentEpoch (u64): Epoch berikutnya saat akun ini harus membayar biaya sewa.
  • space (u64, jika jsonParsed tidak digunakan): Panjang data mentah akun dalam byte.

{
  "jsonrpc": "2.0",
  "result": {
    "context": {
      "slot": 183458000
    },
    "value": [
      {
        "pubkey": "SomeTokenAccountPubkey1...",
        "account": {
          "data": {
            "program": "spl-token",
            "parsed": {
              "info": {
                "delegate": "DelegatePubkeyProvidedInRequest...",
                "delegatedAmount": {
                  "amount": "1000000000",
                  "decimals": 9,
                  "uiAmount": 1.0,
                  "uiAmountString": "1.0"
                },
                "isNative": false,
                "mint": "TokenMintPubkey...",
                "owner": "ActualOwnerOfTheTokenAccount...",
                "state": "initialized",
                "tokenAmount": {
                  "amount": "5000000000",
                  "decimals": 9,
                  "uiAmount": 5.0,
                  "uiAmountString": "5.0"
                }
              },
              "type": "account"
            },
            "space": 165
          },
          "executable": false,
          "lamports": 2039280,
          "owner": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // SPL Token Program
          "rentEpoch": 382
        }
      }
      // ... potentially other token accounts delegated to the same delegate
    ]
  },
  "id": 1
}

​

Contoh Kode

# Replace <DELEGATE_PUBKEY> and <TOKEN_MINT_PUBKEY> or <TOKEN_PROGRAM_ID>
# Example using programId (SPL Token Program)
curl -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getTokenAccountsByDelegate",
    "params": [
      "<DELEGATE_PUBKEY>",
      { "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
      { "encoding": "jsonParsed" }
    ]
  }' \
  <YOUR_RPC_URL>

# Example using a specific mint
curl -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getTokenAccountsByDelegate",
    "params": [
      "<DELEGATE_PUBKEY>",
      { "mint": "<TOKEN_MINT_PUBKEY>" },
      { "encoding": "jsonParsed", "commitment": "confirmed" }
    ]
  }' \
  <YOUR_RPC_URL>

const { Connection, PublicKey } = require('@solana/web3.js');

async function findDelegatedAccounts(delegateAddress, filter, encoding = 'jsonParsed') {
  // Replace with your RPC endpoint
  const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
  const delegatePubKey = new PublicKey(delegateAddress);

  try {
    let actualFilter;
    if (filter.mint) {
      actualFilter = { mint: new PublicKey(filter.mint) };
    } else if (filter.programId) {
      actualFilter = { programId: new PublicKey(filter.programId) };
    } else {
      console.error("Filter must contain either 'mint' or 'programId'");
      return;
    }

    const accounts = await connection.getTokenAccountsByDelegate(
      delegatePubKey,
      actualFilter,
      { encoding }
    );

    console.log(`Found ${accounts.value.length} token accounts delegated to ${delegateAddress}:`);
    accounts.value.forEach(accInfo => {
      console.log(`  Token Account: ${accInfo.pubkey.toBase58()}`);
      if (encoding === 'jsonParsed' && accInfo.account.data.parsed) {
        console.log(`    Mint: ${accInfo.account.data.parsed.info.mint}`);
        console.log(`    Owner: ${accInfo.account.data.parsed.info.owner}`);
        console.log(`    Delegated Amount: ${accInfo.account.data.parsed.info.delegatedAmount.uiAmountString}`);
      }
      // console.log(JSON.stringify(accInfo.account.data, null, 2)); // For full data
    });

  } catch (error) {
    console.error(`Error fetching token accounts by delegate for ${delegateAddress}:`, error);
  }
}

// Replace with an actual delegate public key
const exampleDelegate = '4Nd1mBQtrMJVYVfKf2PJy9NZUZdTAsp7D4xWLs4gDB4T'; 

// Example 1: Find all SPL Token program accounts delegated to `exampleDelegate`
findDelegatedAccounts(exampleDelegate, { programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA' });

// Example 2: Find accounts for a specific mint (e.g., USDC) delegated to `exampleDelegate`
// const usdcMint = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
// findDelegatedAccounts(exampleDelegate, { mint: usdcMint });

​

Kiat untuk Pengembang

• Persyaratan Filter: Anda harus memberikan mint atau programId dalam parameter filter. Anda tidak dapat membuat kueri untuk semua akun yang didelegasikan di seluruh jenis token tanpa salah satu filter ini.
• Pengodean: Penggunaan "jsonParsed" untuk opsi encoding sangat disarankan agar data lebih mudah ditangani karena opsi ini mendekode data akun biner menjadi format JSON terstruktur.
• Performa: Kueri dengan programId dapat memerlukan lebih banyak sumber daya daripada kueri dengan mint, terutama jika delegasi memiliki wewenang atas berbagai jenis token. Beberapa penyedia RPC mungkin menerapkan batas laju yang lebih ketat untuk metode ini.
• Jumlah yang Didelegasikan: delegatedAmount dalam respons menunjukkan jumlah maksimum token yang saat ini boleh digunakan oleh delegasi. Jumlah ini dapat lebih kecil daripada total tokenAmount dalam akun.
• Mencabut Delegasi: Metode ini hanya mengambil informasi. Untuk mencabut delegasi, pemilik akun token harus mengirimkan instruksi Revoke ke SPL Token Program.