> ## Documentation Index
> Fetch the complete documentation index at: https://docs.raydium.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Rent dan rent yang dapat diklaim kembali
> Solana mengurangi minimum rent-exempt sebesar 90% melalui lima langkah di bawah SIMD-0437. Akun yang didanai sebelum setiap langkah sekarang menyimpan lebih dari yang mereka butuhkan — apa kelebihan itu, program mana yang mengembalikannya, dan cara menemukan serta mengklaimnya kembali.
**Halaman ini diterjemahkan secara otomatis oleh AI. Versi bahasa Inggris adalah acuan resmi.**
[Lihat versi bahasa Inggris →](/solana-fundamentals/rent-and-reclaimable-rent)
Rent adalah deposit yang dapat dikembalikan, bukan biaya. SIMD-0437 menurunkan deposit yang harus dipegang setiap akun, dalam lima langkah yang gated secara independen. Akun yang dibuat sebelum suatu langkah mempertahankan saldo yang mereka didanai, jadi setiap langkah meninggalkan mereka dalam kondisi over-funded. Program SPL Token dan Token-2022 dapat mengembalikan perbedaan itu melalui `WithdrawExcessLamports` tanpa menutup akun atau menyentuh saldo token-nya. Tidak ada yang kedaluwarsa — kelebihan itu tetap berada di akun Anda sendiri sampai Anda memilih untuk memindahkannya.
Baca [Account model](/id/solana-fundamentals/account-model) terlebih dahulu jika Anda baru mengenal cara akun Solana didanai.
## Apa itu rent sebenarnya
Setiap akun di Solana menyimpan deposit SOL yang diukur berdasarkan ruang yang ditempatinya. Deposit ini tidak dihabiskan — deposit dikembalikan sepenuhnya ketika akun ditutup. Rumusnya adalah:
```
minimum_balance(data_len) = (ACCOUNT_STORAGE_OVERHEAD + data_len) × lamports_per_byte
```
`ACCOUNT_STORAGE_OVERHEAD` adalah 128 byte tetap yang setiap akun bayar terlepas dari muatannya. `lamports_per_byte` adalah konstanta jaringan yang SIMD-0437 ubah.
Akun SPL token standar 165-byte oleh karena itu selalu berharga `(128 + 165) × 6,960 = 2,039,280` lamports — \~0.00203928 SOL yang Anda lihat dipotong setiap kali dompet membuka akun token terkait.
## Apa yang SIMD-0437 ubah
SIMD-0437 mengurangi `lamports_per_byte` dari 6,960 menjadi 696 — pengurangan 90% — diluncurkan melalui lima feature gate terpisah sehingga validator dapat menyerap efek pertumbuhan state satu langkah pada satu waktu.
| Langkah | `lamports_per_byte` | Dipotong dari asli | Rent untuk akun token 165-byte |
| -------- | ------------------- | ------------------ | ------------------------------ |
| — (asli) | 6,960 | — | 2,039,280 lamports |
| 1 | 6,333 | 9% | 1,855,569 lamports |
| 2 | 5,080 | 27% | 1,488,440 lamports |
| 3 | 2,575 | 63% | 754,475 lamports |
| 4 | 1,322 | 81% | 387,346 lamports |
| 5 | 696 | 90% | 203,928 lamports |
Langkah 1 diaktifkan di mainnet pada 3 September 2026. Langkah-langkah yang tersisa diluncurkan saat feature gate mereka diaktifkan; perlakukan jadwal sebagai dapat berubah dan baca nilai langsung dari cluster daripada hardcoding-nya.
SIMD-0437 bergantung pada SIMD-0194, yang menghapuskan ambang rent exemption "untuk menghindari matematika floating point yang tidak perlu saat menetapkan parameter rent pada aktivasi fitur". Dalam praktiknya, sysvar `Rent` sekarang membawa `lamports_per_byte_year = 6,333` dengan `exemption_threshold = 1.0`, daripada pemisahan `3,480 × 2` lama yang menghasilkan 6,960. Jangan kalikan kedua field itu sendiri — panggil `getMinimumBalanceForRentExemption` dan biarkan cluster menjawab.
## Mengapa akun yang ada menyimpan terlalu banyak
Menurunkan konstanta mengubah apa yang akun *butuhkan*. Ini tidak mengubah apa yang akun *miliki*. Akun yang didanai pada 6,960 lamports per byte mempertahankan saldo itu setelah langkah 1 diaktifkan, jadi akun itu over-funded sebesar:
```
excess = (128 + data_len) × (old_rate − new_rate)
```
Untuk akun SPL token 165-byte setelah langkah 1 itu adalah `293 × (6,960 − 6,333) = 183,711` lamports, atau \~0.000184 SOL per akun. Akun Token-2022 yang membawa ekstensi lebih besar, jadi menyimpan lebih banyak secara proporsional — akun 182-byte adalah over-funded sebesar `310 × 627 = 194,370` lamports.
Secara individual itu adalah debu. Dompet yang telah berinteraksi dengan beberapa ratus token selama bertahun-tahun menyimpan kelipatan bermakna darinya, dan pada langkah 5 setiap akun 165-byte memiliki 1,835,352 lamports (\~0.00184 SOL) yang duduk di atas minimumnya.
## Akun mana yang dapat mengembalikannya
Lamports kelebihan dalam akun yang dimiliki program hanya dapat dipindahkan oleh program itu. Apakah Anda dapat mengklaim rent tanpa menutup akun oleh karena itu sepenuhnya bergantung pada program mana yang memilikinya.
Keduanya mengekspos `WithdrawExcessLamports`. Akun tetap terbuka, mempertahankan saldo token-nya, dan hanya turun ke minimum saat ini.
Tidak ada instruksi yang setara. Rent hanya dirilis ketika akun ditutup — operasi destruktif dengan prasyarat-nya sendiri, bukan rent sweep.
Secara konkret, untuk tipe akun yang dipegang pengguna Raydium:
| Akun | Pemilik | Dapat mengembalikan kelebihan di tempat? |
| ---------------------------------- | --------------------------------------------- | -------------------------------------------------------------------------- |
| Akun token SPL | `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA` | Ya — `WithdrawExcessLamports` |
| Akun token Token-2022 | `TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb` | Ya — `WithdrawExcessLamports` |
| Akun token SOL terbungkus (native) | salah satu program token | Tidak — lihat di bawah |
| Posisi CLMM | Raydium CLMM | Tidak — rent dikembalikan ketika posisi ditutup |
| OpenBook v1 open orders | OpenBook v1 | Tidak — hanya `CloseOpenOrders` |
| OpenBook v2 open orders | OpenBook v2 | Tidak — hanya `close_open_orders_account` |
| Akun Stake | Program Stake | Tidak — SIMD-0490 menetapkan `rent_exempt_reserve` pada 2,282,880 lamports |
Akun SOL terbungkus adalah satu pengecualian program token: saldo lamport mereka *adalah* saldo token mereka, jadi kedua program menolaknya dengan `TokenError::NativeNotSupported`. Token-2022 menambahkan `UnwrapLamports` (discriminant 45) untuk kasus itu; `@solana/spl-token` mengirimkan `createUnwrapLamportsInstruction` untuk itu sejak 0.4.15. Lewati akun native dalam rent sweep dan tangani mereka dengan sengaja.
## Instruksi `WithdrawExcessLamports`
Discriminant **38** dalam enum instruksi kedua program token. Dari `spl-token-interface`:
```rust theme={null}
/// This instruction is to be used to rescue SOL sent to any TokenProgram
/// owned account by sending them to any other account, leaving behind only
/// lamports for rent exemption.
///
/// 0. `[writable]` Source Account owned by the token program
/// 1. `[writable]` Destination account
/// 2. `[signer]` Authority
/// 3. `..3+M` `[signer]` M signer accounts
WithdrawExcessLamports,
```
Tiga properti membuatnya aman untuk dijalankan pada setiap akun dalam dompet:
* **Ini tidak mengambil jumlah.** Program menghitung `source.lamports − rent.minimum_balance(source.data_len())` sendiri, jadi tidak pernah dapat mengambil akun di bawah minimum saat ini, dan tetap benar saat langkah-langkah selanjutnya diaktifkan.
* **Ini tidak menutup apa pun.** Akun mempertahankan data, pemilik, dan saldo token-nya.
* **Ini idempoten.** Menjalankannya terhadap akun yang sudah di minimum memindahkan nol lamports dan berhasil.
Akun token yang dibekukan masih memenuhi syarat: pembekuan membatasi pergerakan token, bukan lamports.
### Membangun instruksi
`@solana/spl-token` tidak mengekspor builder untuk itu. Sejak `0.4.15` entri enum masih dikomentar:
```ts theme={null}
// packages/spl-token/src/instructions/types.ts
export enum TokenInstruction {
// ...
TransferHookExtension = 36,
// ConfidentialTransferFeeExtension = 37,
// WithdrawalExcessLamports = 38, // ← not exposed
MetadataPointerExtension = 39,
// ...
}
```
Enkode langsung. Muatan adalah satu byte discriminant:
```ts theme={null}
import { PublicKey, TransactionInstruction } from "@solana/web3.js";
export function createWithdrawExcessLamportsInstruction(params: {
source: PublicKey; // the token account holding excess lamports
destination: PublicKey; // where the excess goes — usually the wallet itself
authority: PublicKey; // owner of `source`, or the multisig account
multiSigners?: PublicKey[];
programId: PublicKey; // TOKEN_PROGRAM_ID or TOKEN_2022_PROGRAM_ID
}): TransactionInstruction {
const { source, destination, authority, multiSigners = [], programId } = params;
return new TransactionInstruction({
programId,
keys: [
{ pubkey: source, isSigner: false, isWritable: true },
{ pubkey: destination, isSigner: false, isWritable: true },
{ pubkey: authority, isSigner: !multiSigners.length, isWritable: false },
...multiSigners.map((pubkey) => ({ pubkey, isSigner: true, isWritable: false })),
],
data: Buffer.from([38]),
});
}
```
Lewatkan `programId` masing-masing akun. Instruksi SPL Token dan Token-2022 dapat berbagi transaksi, tetapi masing-masing harus ditujukan ke program yang memiliki akun sumber-nya.
Diukur di mainnet, instruksi ini memerlukan 270 compute unit pada program SPL Token dan 1,414 pada Token-2022 — dapat diabaikan kedua-duanya. Batasan nyata adalah ukuran transaksi, bukan compute.
## Menemukan akun yang dapat diklaim kembali
Jangan turunkan kelebihan dari rate yang hardcoded. Tanyakan kepada cluster apa yang setiap akun butuhkan sekarang, sehingga kode yang sama terus bekerja melalui semua lima langkah:
```ts theme={null}
const [tokenResp, token2022Resp] = await Promise.all([
connection.getTokenAccountsByOwner(owner, { programId: TOKEN_PROGRAM_ID }),
connection.getTokenAccountsByOwner(owner, { programId: TOKEN_2022_PROGRAM_ID }),
]);
const raw = [...tokenResp.value, ...token2022Resp.value];
// one lookup per distinct account size — a wallet normally has two or three
const spaces = Array.from(new Set(raw.map(({ account }) => account.data.length)));
const minimums = new Map(
await Promise.all(
spaces.map(async (space) => [space, await connection.getMinimumBalanceForRentExemption(space)] as const),
),
);
const reclaimable = raw.filter(({ account }) => {
// wrapped SOL carries its token balance as lamports — both programs refuse it.
// The `is_native` COption tag sits at offset 109 in the token account layout,
// which Token-2022 preserves before its extension data.
if (account.data.readUInt32LE(109) === 1) return false;
return account.lamports > minimums.get(account.data.length)!;
});
```
`getMinimumBalanceForRentExemption(0)` adalah side-channel yang berguna: ini mengembalikan tepat `128 × lamports_per_byte`, jadi membagi dengan 128 memberi tahu Anda langkah rollout mana yang cluster aktifkan tanpa mengurai sysvar `Rent`.
## Batching: berapa banyak yang muat dalam satu transaksi
Setiap instruksi `WithdrawExcessLamports` berkontribusi satu kunci akun writable unik — 32 byte dalam pesan yang dikompilasi — ditambah sekitar 7 byte pengkodean instruksi. Destination, authority dan fee payer semuanya adalah dompet yang sama, jadi mereka memerlukan satu kunci di antara mereka.
Terhadap batas transaksi 1,232-byte, kira-kira 26 instruksi muat setelah compute-budget instructions dan blockhash dihitung. **Dua puluh per transaksi** adalah angka kerja yang aman, dan itulah yang digunakan implementasi Raydium sendiri. Dompet dengan 116 akun yang dapat diklaim oleh karena itu melakukan sweep dalam enam transaksi, pada biaya dasar 5,000-lamport masing-masing.
Perhatikan ekonominya: biaya dikenakan per transaksi, bukan per akun. Mengklaim lebih sedikit akun tidak mengurangi biaya, itulah mengapa partial sweep jarang sepadan dengan round trip tambahan.
## Mengklaim melalui Raydium
Halaman [raydium.io/reclaim-rent](https://raydium.io/reclaim-rent) memindai akun SPL Token dan Token-2022 dompet yang terhubung, menampilkan total yang dibagi berdasarkan program, dan melakukan sweep semuanya dalam transaksi batch. Pemindaian adalah read-only — tidak ada signature sampai Anda menekan **Reclaim all rent**.
Halaman dengan sengaja hanya mencakup akun token. Tipe akun yang dapat merilis rent hanya dengan menutup dikecualikan daripada dicantumkan sebagai tidak tersedia, karena menutup akun adalah tindakan yang berbeda dan destruktif.
## Mengklaim dari demo SDK
**Banner versi.** Demo menargetkan `@raydium-io/raydium-sdk-v2@0.2.42-alpha` terhadap Solana mainnet-beta, diverifikasi 2026-09. `WithdrawExcessLamports` dikodekan dengan tangan dan independen dari versi SDK; SDK hanya digunakan untuk pembuatan dan batching transaksi.
Dua script dalam [`raydium-sdk-V2-demo/src/rent`](https://github.com/raydium-io/raydium-sdk-V2-demo/tree/master/src/rent):
```bash theme={null}
# read-only: what can this wallet reclaim, and what would it be worth after all five steps
yarn dev src/rent/checkReclaimableRent.ts
yarn dev src/rent/checkReclaimableRent.ts
# build, simulate (DRY_RUN = true by default), then send the batched sweep
yarn dev src/rent/reclaimRent.ts
```
`reclaimRent.ts` melakukan batch pada 20 akun per transaksi dan menandatangani semua batch dalam satu pass:
```ts theme={null}
const batches = chunk(report.accounts, ACCOUNTS_PER_TX);
const builtTxs = await Promise.all(
batches.map(async (batch) => {
const builder = new TxBuilder({
connection,
feePayer: owner.publicKey,
cluster: raydium.cluster,
owner: raydium.owner,
});
builder.addInstruction({
instructions: batch.map((account) =>
createWithdrawExcessLamportsInstruction({
source: account.pubkey,
destination: owner.publicKey,
authority: owner.publicKey,
programId: account.programId,
}),
),
});
return builder.versionBuild({ txVersion });
}),
);
// versionMultiBuild puts the calling builder's transaction first and appends
// extraPreBuildData after it, so batch 1 drives and batches 2..n follow in order
const [firstTx, ...restTxs] = builtTxs;
const { execute } = await firstTx.builder.versionMultiBuild({ txVersion, extraPreBuildData: restTxs });
const { txIds } = await execute({ sequentially: true });
```
Simulasikan sebelum Anda mengirim. `simulateTransaction` dengan `accounts.addresses` mengembalikan saldo lamport pasca-eksekusi, yang merupakan cara termurah untuk mengkonfirmasi aritmatika cocok dengan apa yang sebenarnya akan dilakukan cluster.
## Haruskah Anda mengklaim sekarang atau menunggu?
Keduanya baik-baik saja, dan perbedaannya kecil kedua-duanya:
* **Kelebihan tidak akan pergi ke mana pun.** Itu tetap berada di akun Anda sendiri. Tidak ada yang kedaluwarsa, tidak ada yang disapu, tidak ada deadline yang berlaku.
* **Menunggu menghasilkan bunga.** Setiap langkah merilis lebih banyak dari akun yang sama, dan satu sweep setelah langkah 5 memerlukan biaya yang sama dalam fee seperti satu sweep hari ini.
* **Mengklaim sekarang tidak mengorbankan langkah-langkah selanjutnya.** Akun yang Anda sweep hari ini hanya berada di minimum saat ini; langkah berikutnya membuatnya over-funded lagi dan Anda dapat melakukan sweep lagi.
Satu-satunya biaya nyata dari mengklaim awal adalah biaya dasar, dan satu-satunya biaya nyata dari menunggu adalah bahwa lamports tetap tidak bergerak sedikit lebih lama.
## Bacaan lebih lanjut
Proposal itu sendiri — lima feature gate dan alasan untuk melangkah pengurangan.
Halaman rollout Solana: langkah saat ini, jadwal, dan apa yang berubah untuk akun baru.
Ekonomi, dan risiko pertumbuhan state yang dirancang untuk dikelola rollout bertahap.
Bagaimana akun Solana didanai, dimiliki, dan ditutup — latar belakang untuk semuanya di atas.