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

> Pelajari kasus penggunaan getSignaturesForAddress, contoh kode, parameter permintaan, struktur respons, dan tips.

Metode RPC [`getSignaturesForAddress`](https://www.helius.dev/docs/api-reference/rpc/http/getsignaturesforaddress) memungkinkan Anda mengambil daftar tanda tangan transaksi terkonfirmasi yang melibatkan alamat akun tertentu. Ini berguna untuk mengambil riwayat transaksi suatu akun. Tanda tangan dikembalikan dalam urutan kronologis terbalik (yang terbaru lebih dahulu).

<Tip>
  Untuk pemfilteran dan pengurutan tingkat lanjut serta riwayat akun token, gunakan [`getTransactionsForAddress`](/docs/id/rpc/gettransactionsforaddress). Perhatikan bahwa `getSignaturesForAddress` tidak menyertakan transaksi yang melibatkan akun token terkait.
</Tip>

## Kasus Penggunaan Umum

* **Riwayat Transaksi Akun:** Menampilkan transaksi sebelumnya dari dompet pengguna. Untuk penguraian riwayat transaksi yang lebih canggih, pertimbangkan untuk menggunakan [Enhanced Transactions API](https://www.helius.dev/docs/enhanced-transactions) dari Helius.
* **Audit Aktivitas:** Meninjau semua transaksi yang terkait dengan kontrak pintar atau akun tertentu.
* **Pencarian Transaksi Tertentu:** Menemukan transaksi tertentu dengan menelusuri riwayat akun jika hanya alamat yang terlibat yang diketahui.
* **Pengindeksan Data:** Membuat indeks transaksi lokal agar kueri dan analisis dapat dilakukan lebih cepat.

## Parameter Permintaan

1. **`address`** (`string`): (Wajib) Kunci publik akun yang dikodekan dalam base-58 untuk mengambil tanda tangan transaksi.
2. **`options`** (`object`, opsional): Objek konfigurasi opsional dengan bidang berikut:
   * **`limit`** (`number`, opsional): Jumlah maksimum tanda tangan yang akan dikembalikan. Nilai default-nya adalah 1000 dan nilai maksimum yang diizinkan adalah 1000.
   * **`before`** (`string`, opsional): Tanda tangan transaksi yang dikodekan dalam base-58. Jika diberikan, kueri akan mulai mencari transaksi sebelum tanda tangan ini.
   * **`until`** (`string`, opsional): Tanda tangan transaksi yang dikodekan dalam base-58. Jika diberikan, kueri akan mencari transaksi hingga tanda tangan ini tercapai (tidak termasuk tanda tangan tersebut).
   * **`commitment`** (`string`, opsional): Menentukan [tingkat komitmen](https://www.helius.dev/blog/solana-commitment-levels) yang akan digunakan untuk kueri. Nilai yang didukung adalah `finalized` atau `confirmed`. Komitmen `processed` tidak didukung. Jika dihilangkan, komitmen default dari node RPC akan digunakan (biasanya `finalized`).
   * **`minContextSlot`** (`number`, opsional): Slot minimum tempat permintaan dapat dievaluasi. Ini bukan filter untuk transaksi historis, tetapi menetapkan slot minimum untuk konteks node.

<Warning>
  **Batch Tidak Didukung**

  Metode arsip ini tidak mendukung pemrosesan batch. Buat permintaan satu per satu saja.
</Warning>

## Struktur Respons

Bidang `result` dalam respons JSON-RPC adalah array objek informasi tanda tangan. Setiap objek memiliki struktur berikut:

* **`signature`** (`string`): Tanda tangan transaksi yang dikodekan dalam base-58.
* **`slot`** (`u64`): Slot tempat transaksi diproses.
* **`err`** (`object` | `null`): Objek kesalahan jika transaksi gagal, atau `null` jika berhasil.
* **`memo`** (`string` | `null`): Memo yang terkait dengan transaksi, jika ada.
* **`blockTime`** (`i64` | `null`): Perkiraan waktu produksi blok yang berisi transaksi, sebagai stempel waktu Unix (detik sejak epoch). `null` jika tidak tersedia.
* **`confirmationStatus`** (`string` | `null`): Status konfirmasi transaksi (misalnya, `processed`, `confirmed`, `finalized`). `null` jika tidak tersedia (misalnya, untuk respons Helius yang lebih lama).

## Contoh

### 1. Mendapatkan Tanda Tangan Terbaru untuk Alamat

Contoh ini mengambil tanda tangan transaksi terbaru (hingga 1000) untuk alamat tertentu.

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <api-key> with your Helius API key
  # Replace SYSTEM_PROGRAM_ID with the address you want to query
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getSignaturesForAddress",
      "params": [
        "11111111111111111111111111111111" 
      ]
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection, PublicKey } = require('@solana/web3.js');

  async function getLatestSignatures() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    // Replace with the public key you want to query
    const address = new PublicKey('11111111111111111111111111111111'); 

    try {
      const signatures = await connection.getSignaturesForAddress(address);
      if (signatures && signatures.length > 0) {
        console.log(`Found ${signatures.length} signatures:`);
        signatures.forEach((sigInfo, index) => {
          console.log(`--- Signature ${index + 1} ---`);
          console.log(`  Signature: ${sigInfo.signature}`);
          console.log(`  Slot: ${sigInfo.slot}`);
          console.log(`  Block Time: ${sigInfo.blockTime ? new Date(sigInfo.blockTime * 1000).toLocaleString() : 'N/A'}`);
          console.log(`  Error: ${JSON.stringify(sigInfo.err)}`);
          console.log(`  Memo: ${sigInfo.memo || 'N/A'}`);
          console.log(`  Confirmation Status: ${sigInfo.confirmationStatus || 'N/A'}`);
        });
      } else {
        console.log('No signatures found for this address.');
      }
    } catch (error) {
      console.error('Error fetching signatures:', error);
    }
  }

  getLatestSignatures();
  ```
</CodeGroup>

### 2. Mendapatkan Tanda Tangan dengan Batas

Contoh ini mengambil sejumlah tanda tangan transaksi terbaru sesuai jumlah yang ditentukan untuk suatu alamat.

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <api-key> with your Helius API key
  # Replace TARGET_ACCOUNT_ADDRESS with the address you want to query
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getSignaturesForAddress",
      "params": [
        "TARGET_ACCOUNT_ADDRESS",
        {
          "limit": 5 
        }
      ]
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection, PublicKey } = require('@solana/web3.js');

  async function getLimitedSignatures() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    // Replace with the public key you want to query
    const address = new PublicKey('Vote111111111111111111111111111111111111111'); 
    const limit = 5;

    try {
      const signatures = await connection.getSignaturesForAddress(address, { limit });
      console.log(`Fetched up to ${limit} signatures:`);
      signatures.forEach((sigInfo, index) => {
        console.log(`${index + 1}. Signature: ${sigInfo.signature}, Slot: ${sigInfo.slot}`);
      });
    } catch (error) {
      console.error(`Error fetching limited signatures for ${address.toBase58()}:`, error);
    }
  }

  getLimitedSignatures();
  ```
</CodeGroup>

### 3. Melakukan Paginasi pada Riwayat Transaksi

Contoh ini menunjukkan cara mengambil riwayat transaksi dalam beberapa batch menggunakan parameter `before`.

<CodeGroup>
  ```bash cURL theme={"system"}
  # Initial request (get the latest 2)
  # Replace <api-key> with your Helius API key
  # Replace TARGET_ACCOUNT_ADDRESS with the address you want to query
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getSignaturesForAddress",
      "params": [
        "TARGET_ACCOUNT_ADDRESS",
        { "limit": 2 }
      ]
    }'

  # Suppose the last signature from the above response was LAST_SIGNATURE_FROM_PREVIOUS_BATCH
  # Fetch the next 2 transactions before that one
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getSignaturesForAddress",
      "params": [
        "TARGET_ACCOUNT_ADDRESS",
        { 
          "limit": 2,
          "before": "LAST_SIGNATURE_FROM_PREVIOUS_BATCH" 
        }
      ]
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection, PublicKey } = require('@solana/web3.js');

  async function paginateSignatures() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    // Replace with the public key you want to query - e.g. a known active address
    const address = new PublicKey('Vote111111111111111111111111111111111111111'); 
    const batchSize = 2;
    let lastSignature = null;
    let allSignatures = [];
    const maxPages = 3; // Limit how many pages we fetch for this example

    try {
      for (let i = 0; i < maxPages; i++) {
        console.log(`Fetching page ${i + 1}...`);
        const options = { limit: batchSize };
        if (lastSignature) {
          options.before = lastSignature;
        }

        const signatures = await connection.getSignaturesForAddress(address, options);
        
        if (signatures.length === 0) {
          console.log('No more signatures found.');
          break;
        }

        signatures.forEach(sigInfo => {
          allSignatures.push(sigInfo.signature);
          console.log(`  Found: ${sigInfo.signature} in slot ${sigInfo.slot}`);
        });
        
        lastSignature = signatures[signatures.length - 1]?.signature;

        if (signatures.length < batchSize || !lastSignature) {
           console.log('Fetched all available signatures or reached end of page.');
           break;
        }
        // Optional: Add a small delay if making many sequential requests
        // await new Promise(resolve => setTimeout(resolve, 200)); 
      }
      console.log(`
  Total signatures fetched (${allSignatures.length}):`);
      allSignatures.forEach((sig, idx) => console.log(`${idx + 1}. ${sig}`));

    } catch (error) {
      console.error('Error paginating signatures:', error);
    }
  }

  paginateSignatures();
  ```
</CodeGroup>

## Tips untuk Developer

* **Paginasi:** Untuk mendapatkan riwayat transaksi lengkap dari akun aktif, Anda kemungkinan perlu membuat beberapa permintaan dengan menggunakan parameter `before` bersama tanda tangan terakhir yang diterima dalam batch sebelumnya dan `limit`.
* **Batas Laju:** Perhatikan batas laju node RPC saat mengambil riwayat transaksi dalam jumlah besar.
* **Urutan:** Tanda tangan selalu dikembalikan dari yang terbaru hingga terlama.
* **Parameter `limit`:** Parameter `limit` dapat bernilai antara 1 dan 1000. Jika tidak ditentukan, nilai default-nya adalah 1000.
* **Parameter `until`:** Parameter ini dapat digunakan untuk menghentikan pengambilan tanda tangan saat tanda tangan lama yang telah diketahui tercapai. Ini berguna jika Anda hanya membutuhkan transaksi hingga titik tertentu.
* **`minContextSlot`:** Parameter ini tidak memfilter transaksi historis. Parameter ini menentukan slot minimum yang harus digunakan node RPC sebagai konteks saat mengevaluasi permintaan. Jika status node lebih lama daripada slot ini, node dapat mengembalikan kesalahan.
* **Detail Transaksi:** Metode ini hanya mengembalikan tanda tangan dan informasi dasar. Untuk mendapatkan detail transaksi lengkap, gunakan metode `getTransaction` dengan setiap tanda tangan.
* **Batasan Akun Token:** Metode ini hanya mengembalikan transaksi yang secara langsung merujuk alamat yang diberikan. Metode ini tidak menyertakan transaksi yang melibatkan akun token milik alamat tersebut. Untuk riwayat token lengkap yang mencakup akun token terkait, gunakan [`getTransactionsForAddress`](/docs/id/rpc/gettransactionsforaddress) dengan filter `tokenAccounts`.

Dengan menggunakan `getSignaturesForAddress` beserta opsi paginasinya, Anda dapat mengambil dan mengelola riwayat transaksi secara efektif untuk alamat Solana apa pun.

## Metode Terkait

<CardGroup cols={2}>
  <Card title="getTransactionsForAddress" href="/docs/id/rpc/gettransactionsforaddress">
    Pemfilteran dan pengurutan tingkat lanjut serta riwayat akun token
  </Card>

  <Card title="getTransaction" href="/docs/id/api-reference/rpc/http/gettransaction">
    Dapatkan detail transaksi lengkap dari tanda tangan
  </Card>
</CardGroup>