> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Cara Menggunakan getTokenAccountsByDelegate

> Pelajari kasus penggunaan getTokenAccountsByDelegate, contoh kode, parameter permintaan, struktur respons, dan kiat.

Metode RPC [`getTokenAccountsByDelegate`](https://www.helius.dev/docs/api-reference/rpc/http/gettokenaccountsbydelegate) mengambil semua akun SPL Token yang telah menyetujui kunci publik tertentu sebagai delegasi. Delegasi memiliki wewenang untuk melakukan tindakan tertentu pada akun token, seperti mentransfer atau membakar token, hingga jumlah yang didelegasikan.

Metode ini berguna untuk layanan yang mengelola wewenang yang didelegasikan atau perlu mengetahui akun token mana yang dapat diwakili oleh kunci tertentu.

## 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](https://www.helius.dev/blog/solana-commitment-levels).
   * **`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

Bidang `result.value` dalam respons JSON-RPC adalah array object. Setiap object mewakili akun token yang memiliki `delegatePubkey` sebagai delegasinya dan sesuai dengan kriteria `filter`. Setiap object dalam array memiliki dua bidang:

* **`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.

**Contoh Respons (dengan pengodean `jsonParsed`):**

```json theme={"system"}
{
  "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

<CodeGroup>
  ```bash cURL theme={"system"}
  # 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>
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  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 });
  ```
</CodeGroup>

## 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.

Panduan ini memberikan ringkasan lengkap tentang penggunaan `getTokenAccountsByDelegate` untuk menemukan akun SPL Token berdasarkan delegasi yang telah disetujuinya.