> ## 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. # Migrasi dari getSignaturesForAddress + getTransaction ke getTransactionsForAddress > Ganti perulangan getSignaturesForAddress + getTransaction dengan satu panggilan getTransactionsForAddress — pemetaan parameter, kode sebelum/sesudah, dan paginasi. ## Mengapa perlu bermigrasi? Cara standar untuk mengambil riwayat transaksi suatu alamat di Solana memerlukan dua langkah: panggil `getSignaturesForAddress` untuk mencantumkan tanda tangan, lalu panggil `getTransaction` satu kali untuk setiap tanda tangan guna mengambil detailnya. Untuk 1.000 transaksi, diperlukan 1.001 permintaan HTTP. [`getTransactionsForAddress`](/docs/id/rpc/gettransactionsforaddress) adalah metode RPC eksklusif Helius yang menggabungkan kedua langkah menjadi satu panggilan. Metode ini mengembalikan hingga 1.000 transaksi lengkap per permintaan, dengan pemfilteran, pengurutan dua arah, dan dukungan akun token yang tidak tersedia pada metode standar. | | `getSignaturesForAddress` + `getTransaction` | `getTransactionsForAddress` | | -------------------------------------- | -------------------------------------------- | ------------------------------------------ | | Permintaan untuk 1.000 transaksi | 1.001 | 1 | | Kredit untuk 1.000 transaksi lengkap | \~1.001 (1 kredit per panggilan) | 100 (10 kredit per 100 transaksi) | | Riwayat associated token account (ATA) | Tidak disertakan | Disertakan melalui `filters.tokenAccounts` | | Filter rentang waktu dan slot | Tidak | Ya | | Filter status (berhasil/gagal) | Tidak | Ya | | Urutan pengurutan | Hanya yang terbaru terlebih dahulu | Yang terbaru atau terlama terlebih dahulu | | Paginasi | Tanda tangan `before`/`until` | `paginationToken` | Hasilnya: penggunaan kredit sekitar 10x lebih sedikit, perjalanan bolak-balik 1.000x lebih sedikit, serta tidak perlu batching sisi klien, penanganan batas laju, atau logika percobaan ulang untuk fan-out `getTransaction`. ## Sebelum dan sesudah Berikut adalah tugas yang sama — mengambil 1.000 transaksi terakhir untuk suatu alamat beserta detail lengkapnya — dengan kedua pola tersebut: ```javascript Before (two methods) theme={"system"} const rpcUrl = 'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY'; // Step 1: Get signatures (1 request) const sigResponse = await fetch(rpcUrl, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getSignaturesForAddress', params: ['YOUR_ADDRESS_HERE', { limit: 1000 }] }) }); const { result: signatures } = await sigResponse.json(); // Step 2: Get transaction details (1,000 additional requests) const transactions = await Promise.all( signatures.map(async (sig) => { const txResponse = await fetch(rpcUrl, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getTransaction', params: [sig.signature, { maxSupportedTransactionVersion: 1 }] }) }); const { result } = await txResponse.json(); return result; }) ); ``` ```javascript After (one method) theme={"system"} const response = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getTransactionsForAddress', params: [ 'YOUR_ADDRESS_HERE', { transactionDetails: 'full', maxSupportedTransactionVersion: 1, limit: 1000 } ] }) }); const { result } = await response.json(); const transactions = result.data; // Full transactions, same shape as getTransaction ``` `getTransactionsForAddress` bukan bagian dari RPC Solana standar, sehingga `@solana/web3.js` tidak memiliki helper `Connection` untuk metode ini. Panggil metode tersebut dengan permintaan JSON-RPC mentah seperti yang ditunjukkan di atas — metode ini berfungsi pada endpoint Helius yang sama dengan lalu lintas RPC Anda lainnya. ## Pemetaan parameter Setiap opsi dari alur dua langkah lama memiliki padanan langsung. Sebagian besar nama tetap sama — hanya paginasi yang bekerja secara berbeda. ### Dari getSignaturesForAddress | Opsi lama | Padanan baru | | ---------------- | ----------------------------------------------------------------------------- | | `limit` | `limit` — batas maksimum tetap 1.000 | | `before` | `paginationToken` dari respons sebelumnya | | `until` | `filters.signature.gt` | | `commitment` | `commitment` — hanya `confirmed` atau `finalized`; `processed` tidak didukung | | `minContextSlot` | `minContextSlot` — tidak berubah | ### Dari getTransaction | Opsi lama | Padanan baru | | -------------------------------- | ---------------------------------------------------------------- | | `encoding` | `encoding` — berlaku ketika `transactionDetails` adalah `"full"` | | `maxSupportedTransactionVersion` | `maxSupportedTransactionVersion` — tidak berubah | | `commitment` | `commitment` — aturan yang sama seperti di atas | Dua kemampuan sama sekali tidak memiliki padanan lama: * `filters` — persempit hasil berdasarkan `blockTime`, `slot`, `status`, `tokenTransfer`, atau `tokenAccounts` di sisi server, alih-alih mengambil semuanya dan memfilternya dalam kode Anda. * `sortOrder: "asc"` — hasil kronologis (yang terlama terlebih dahulu), yang tidak dapat dikembalikan oleh metode standar tanpa mengambil seluruh riwayat dan membalik urutannya. ## Langkah migrasi `getTransactionsForAddress` bersifat eksklusif untuk Helius. Metode ini berfungsi pada `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY` (dan devnet) — endpoint yang sama dengan yang telah digunakan oleh panggilan Anda jika Anda merupakan pelanggan Helius. Tidak diperlukan perubahan API key atau paket. Hapus panggilan `getSignaturesForAddress` dan perulangan `getTransaction`. Buat satu permintaan `getTransactionsForAddress` dengan `transactionDetails: "full"`, serta gunakan kembali nilai `encoding`, `maxSupportedTransactionVersion`, dan `commitment` Anda seperti yang ditunjukkan dalam [pemetaan parameter](#pemetaan-parameter). Jika Anda hanya memerlukan tanda tangan (misalnya, untuk diteruskan ke pipeline yang sudah ada), gunakan `transactionDetails: "signatures"` sebagai gantinya — biayanya tetap 10 kredit per panggilan. Pembungkus respons berubah dalam tiga hal: * Hasil berada di `result.data` (sebuah array), bukan langsung di `result`. * Setiap entri mode lengkap adalah `{ slot, transactionIndex, blockTime, transaction, meta }`. Objek `transaction` dan `meta` memiliki bentuk yang sama persis dengan hasil yang dikembalikan `getTransaction`, sehingga kode penguraian Anda dapat digunakan tanpa perubahan. * Entri mode tanda tangan cocok dengan keluaran `getSignaturesForAddress` (`signature`, `slot`, `err`, `memo`, `blockTime`, `confirmationStatus`), ditambah bidang `transactionIndex` baru. Satu perbedaan perilaku yang perlu diperhatikan: dengan pola lama, panggilan `getTransaction` dapat mengembalikan `null` untuk suatu tanda tangan. Dengan `getTransactionsForAddress`, setiap entri dalam `result.data` merupakan transaksi lengkap — hapus penanganan null untuk detail yang tidak tersedia. Ganti perulangan kursor `before` dengan `paginationToken`: ```javascript theme={"system"} let paginationToken = null; const allTransactions = []; do { const response = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getTransactionsForAddress', params: [ 'YOUR_ADDRESS_HERE', { transactionDetails: 'full', maxSupportedTransactionVersion: 1, limit: 1000, ...(paginationToken && { paginationToken }) } ] }) }); const { result } = await response.json(); allTransactions.push(...result.data); paginationToken = result.paginationToken; } while (paginationToken); ``` Perulangan berakhir ketika `paginationToken` adalah `null` — Anda tidak perlu lagi membandingkan daftar tanda tangan atau melacak sendiri tanda tangan terakhir. Jika Anda menggunakan `until` untuk berhenti pada tanda tangan yang diketahui, gantilah dengan `filters.signature: { gt: "KNOWN_SIGNATURE" }`. Jika Anda menggunakannya untuk berhenti pada titik waktu tertentu, `filters.blockTime` atau `filters.slot` biasanya lebih sesuai. Pola lama sama sekali melewatkan aktivitas associated token account (ATA), kecuali Anda juga memanggil `getTokenAccountsByOwner` dan mengambil tanda tangan untuk setiap akun token. Untuk menyertakannya, tambahkan satu filter: ```json theme={"system"} { "filters": { "tokenAccounts": "balanceChanged" } } ``` `balanceChanged` mengembalikan transaksi yang mereferensikan dompet atau mengubah saldo akun token apa pun yang dimilikinya, sekaligus memfilter spam. Lihat [associated token account](/docs/id/rpc/gettransactionsforaddress#akun-token-terkait) untuk opsi `none`/`balanceChanged`/`all` dan catatan khusus untuk periode sebelum 2022. Untuk alamat contoh, ambil riwayat dengan kedua cara dan bandingkan kumpulan tanda tangannya. Ketika `filters.tokenAccounts` tidak ditetapkan (nilai default `none`), `getTransactionsForAddress` mengembalikan transaksi yang sama dengan `getSignaturesForAddress` untuk rentang yang sama. Kemudian lakukan deployment dan hapus jalur kode lama. ## Perbedaan perilaku yang perlu ditinjau Sebagian besar migrasi dapat dilakukan sebagai penggantian langsung, tetapi periksa hal-hal berikut sebelum merilisnya: * **Commitment.** `processed` tidak didukung; gunakan `confirmed` atau `finalized`. Jika kode lama Anda melakukan polling riwayat terbaru pada `processed`, beralihlah ke `confirmed`. * **Pengukuran penggunaan.** Respons transaksi lengkap berbiaya 10 kredit per 100 transaksi yang dikembalikan (minimum 10 kredit); respons yang hanya berisi tanda tangan berbiaya tetap 10 kredit. Pola lama berbiaya 1 kredit per panggilan — lebih murah per permintaan, tetapi jauh lebih mahal per transaksi yang diambil. Respons yang gagal tidak dikenai biaya. Lihat [pengukuran penggunaan](/docs/id/rpc/gettransactionsforaddress#pengukuran-penggunaan). * **Dukungan jaringan.** Mainnet memiliki retensi tanpa batas. Devnet didukung dengan retensi selama 2 minggu. Testnet tidak didukung. * **Alamat yang dicadangkan.** Sejumlah kecil alamat sistem (Vote Program, System Program, sysvar) dialihkan ke jalur arsip fallback atau mengembalikan hasil kosong. Jika Anda mengindeks alamat-alamat tersebut, tinjau [batasan dan kasus khusus](/docs/id/rpc/gettransactionsforaddress#batasan-dan-kasus-khusus). * **Beberapa alamat.** Seperti alur lama, satu permintaan mencakup satu alamat. Kueri alamat secara paralel lalu gabungkan hasilnya; lihat [beberapa alamat](/docs/id/rpc/gettransactionsforaddress#beberapa-alamat). ## Pertanyaan umum ### Apakah getTransactionsForAddress merupakan metode RPC Solana standar? Tidak. Metode ini eksklusif untuk Helius dan tersedia di endpoint RPC Helius. RPC Solana standar dan penyedia lain hanya menawarkan `getSignaturesForAddress` dan `getTransaction`. Panggilan RPC Anda yang lain tidak terpengaruh — metode ini berada pada endpoint yang sama bersama seluruh cakupan RPC standar. ### Apakah saya masih memerlukan getTransaction setelah bermigrasi? Hanya untuk pencarian satu kali ketika Anda sudah memiliki tanda tangan tanpa konteks alamat, misalnya untuk memverifikasi transaksi tertentu yang ditempelkan oleh pengguna. Untuk semua riwayat berbasis alamat — backfill, pengindeksan, feed aktivitas dompet — `getTransactionsForAddress` menggantikan kedua metode tersebut. ### Apakah metode ini berfungsi dengan @solana/web3.js? Metode ini tidak tersedia dalam kelas `Connection`, tetapi dapat digunakan dengan klien HTTP apa pun melalui URL RPC Helius Anda. Gunakan `fetch` (atau padanannya dalam bahasa Anda) dengan isi JSON-RPC standar, seperti yang ditunjukkan dalam contoh di atas. Anda tetap dapat menggunakan `Connection` untuk semua hal lainnya. ### Apakah metode ini akan mengembalikan transaksi yang sama dengan getSignaturesForAddress? Ya. Dengan pengaturan default (`filters.tokenAccounts: "none"`), metode ini mengembalikan transaksi yang mereferensikan alamat yang dikueri — kumpulan yang sama dengan `getSignaturesForAddress`. Menetapkan `tokenAccounts` ke `balanceChanged` atau `all` akan mengembalikan lebih banyak hasil: aktivitas dari associated token account milik dompet juga ditambahkan, yang tidak dapat dilihat oleh metode standar. ### Berapa biayanya dibandingkan dengan pola lama? Mengambil 1.000 transaksi lengkap memerlukan 100 kredit dengan `getTransactionsForAddress`, dibandingkan dengan sekitar 1.001 kredit (dan 1.001 permintaan) menggunakan `getSignaturesForAddress` + `getTransaction`. Respons yang hanya berisi tanda tangan berbiaya tetap 10 kredit per panggilan. Lihat [kredit Helius](/docs/id/billing/credits) untuk harga lengkap. ## Biarkan agen AI melakukan migrasi Jika Anda menggunakan Claude Code, Cursor, atau agen pemrograman lainnya, tempelkan prompt di bawah ini ke sesi agen repositori Anda. Agen tersebut akan menemukan pola lama dalam basis kode Anda dan menulis ulang kode tersebut. ````markdown theme={"system"} Migrate this codebase from the two-step Solana transaction history pattern (getSignaturesForAddress followed by getTransaction) to the single Helius RPC method getTransactionsForAddress. ## Background getTransactionsForAddress is a Helius-exclusive JSON-RPC method served on standard Helius RPC endpoints (https://mainnet.helius-rpc.com/?api-key=...). It returns up to 1,000 full transactions per call, replacing one getSignaturesForAddress call plus one getTransaction call per signature. Docs: https://www.helius.dev/docs/rpc/gettransactionsforaddress.md ## Step 1: Find the old pattern Search for: - getSignaturesForAddress calls (via @solana/web3.js Connection, raw JSON-RPC, or another SDK) whose signatures are then passed to getTransaction / getParsedTransaction / getTransactions - Pagination loops using `before` or `until` signature cursors - getTokenAccountsByOwner calls used only to fetch per-token-account signature history Leave standalone getTransaction calls (single-signature lookups with no address context) unchanged. ## Step 2: Rewrite each call site Replace the two-step flow with one raw JSON-RPC request (web3.js has no Connection helper for this method): ```javascript const response = await fetch(HELIUS_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getTransactionsForAddress', params: [ address, // base-58 string { transactionDetails: 'full', // or 'signatures' if only signatures were used maxSupportedTransactionVersion: 1, // carry over from the old getTransaction options encoding: 'json', // carry over ('json', 'jsonParsed', 'base64', 'base58') limit: 1000, // up to 1,000 // paginationToken: '...', // from the previous response, for page 2+ // sortOrder: 'desc', // 'desc' (default, newest first) or 'asc' // filters: { ... } // optional, see mapping below } ] }) }); const { result } = await response.json(); // result.data -> array of transactions // result.paginationToken -> string cursor, or null when done ``` Parameter mapping: - limit -> limit - before: -> paginationToken (preferred) or filters: { signature: { lt: } } - until: -> filters: { signature: { gt: } } - commitment -> commitment ('confirmed' or 'finalized' only; if the old code used 'processed', use 'confirmed') - minContextSlot -> minContextSlot - encoding / maxSupportedTransactionVersion (from getTransaction) -> same names, top level of the config object Response shape: - Full mode: each entry is { slot, transactionIndex, blockTime, transaction, meta }. transaction and meta are identical in shape to getTransaction results, so existing parsing code carries over. Entries are never null - remove null-handling that existed for missing getTransaction results. - Signatures mode: entries match getSignaturesForAddress output ({ signature, slot, err, memo, blockTime, confirmationStatus }) plus transactionIndex. Pagination: loop while result.paginationToken is non-null, passing it back as paginationToken. Remove manual last-signature tracking. If the old code fetched signatures for the wallet's token accounts too (getTokenAccountsByOwner + per-account getSignaturesForAddress), replace all of it with one call using filters: { tokenAccounts: 'balanceChanged' } and delete the merge/dedupe logic. ## Step 3: Constraints and cleanup - The endpoint must be a Helius RPC URL; other providers do not serve this method. Do not change endpoints for other RPC calls. - Remove now-unused batching, throttling, and retry helpers that existed only for the getTransaction fan-out. - One request covers one address; keep parallel queries for multi-address code. - Preserve the surrounding code style and error handling conventions. ## Step 4: Verify - Run the project's type checks and tests. - Do NOT make any RPC calls yourself. Instead, write a standalone script (e.g. scripts/verify-gtfa-migration.mjs) that fetches history for one address both ways - the old getSignaturesForAddress + getTransaction flow and the new getTransactionsForAddress call with default filters - and prints whether the signature sets match, listing any differences. Read the RPC URL from an environment variable and the address from a CLI argument; never hardcode an API key. - Tell the user how to run it, for example: HELIUS_RPC_URL="https://mainnet.helius-rpc.com/?api-key=..." \ node scripts/verify-gtfa-migration.mjs
- Summarize every call site changed and flag any you were unsure about. ```` Prompt ini bersifat mandiri — agen tidak memerlukan akses ke halaman ini. Untuk dokumentasi siap pakai bagi agen, pencarian MCP, dan keterampilan, lihat [Helius untuk agen AI](/docs/id/agents/overview). ## Langkah berikutnya Tutorial lengkap yang membahas filter, pengurutan, paginasi, dan akun token. Skema permintaan dan respons lengkap. Gunakan getTransactionsForAddress untuk melakukan backfill dan menyinkronkan indeks Solana. Bandingkan semua metode data historis Solana.