1---
2title: Compute Budget Program
3description: Kit-compatible @solana-program/compute-budget client for CU limits, priority fees, heap frames, CU estimation, and retry strategies.
4---
5 
6# Compute Budget Program
7 
8Program address: `ComputeBudget111111111111111111111111111111`
9 
10```ts
11import { COMPUTE_BUDGET_PROGRAM_ADDRESS } from '@solana-program/compute-budget';
12```
13 
14Correctly budgeting compute units for your transaction increases the probability it gets accepted for processing. Without a declared CU limit, validators assume 200K CU per instruction. Since validators pack blocks to maximize throughput, they prefer transactions with tight budgets that clearly fit in remaining block space. Pairing a tight CU limit with a priority fee gives validators direct incentive to include your transaction. Total fee = base fee (5,000 lamports/sig) + (CU consumed × price per CU in micro-lamports).
15 
16## Instructions
17 
18### Set Compute Unit Limit
19 
20If you're using a Kit client built with the `solanaRpc` / `solanaLocalRpc` / `solanaDevnetRpc` / `solanaMainnetRpc` plugins (from `@solana/kit-plugin-rpc`), CU estimation is handled automatically via `client.sendTransaction()` — you don't need this. Use the manual instructions below when building transactions with `pipe()` or when you need direct control. See [overview.md](../overview.md) and [plugins.md](../plugins.md).
21 
22Always set based on simulation — overestimate wastes block space, underestimate fails the transaction.
23 
24```ts
25import { getSetComputeUnitLimitInstruction } from '@solana-program/compute-budget';
26 
27const ix = getSetComputeUnitLimitInstruction({ units: 200_000 });
28```
29 
30### Set Compute Unit Price (Priority Fee)
31 
32Price per CU in micro-lamports — higher values improve inclusion during congestion.
33 
34```ts
35import { getSetComputeUnitPriceInstruction } from '@solana-program/compute-budget';
36 
37const ix = getSetComputeUnitPriceInstruction({ microLamports: 1000n });
38```
39 
40### Request Heap Frame
41 
42Increases BPF heap beyond the default 32 KB — only needed when programs allocate large data structures (large account deserialization, Merkle trees, ZK proofs). Most transactions don't need this.
43 
44```ts
45import { getRequestHeapFrameInstruction } from '@solana-program/compute-budget';
46 
47const ix = getRequestHeapFrameInstruction({ bytes: 256 * 1024 }); // 256 KB
48```
49 
50## CU Estimation Helpers
51 
52Simulate before sending to set a tight CU limit and avoid overpaying on priority fees.
53 
54### Basic Estimator
55 
56```ts
57import { estimateComputeUnitLimitFactory } from '@solana-program/compute-budget';
58 
59const estimateCU = estimateComputeUnitLimitFactory({ rpc });
60const estimatedUnits = await estimateCU(transactionMessage);
61```
62 
63### Auto-Update Estimator
64 
65Estimates CU and updates the transaction message automatically:
66 
67```ts
68import {
69  estimateComputeUnitLimitFactory,
70  estimateAndUpdateProvisoryComputeUnitLimitFactory,
71} from '@solana-program/compute-budget';
72 
73const estimateAndUpdateCU = estimateAndUpdateProvisoryComputeUnitLimitFactory(
74  estimateComputeUnitLimitFactory({ rpc })
75);
76 
77// Returns message with CU limit instruction added/updated
78const updatedMessage = await estimateAndUpdateCU(transactionMessage);
79```
80 
81## Transaction Helpers
82 
83### Update or Append Instructions
84 
85```ts
86import {
87  updateOrAppendSetComputeUnitLimitInstruction,
88  updateOrAppendSetComputeUnitPriceInstruction,
89} from '@solana-program/compute-budget';
90 
91// Update CU limit (or add if not present)
92const msg1 = updateOrAppendSetComputeUnitLimitInstruction(
93  (current) => current === null ? 200_000 : current,
94  transactionMessage
95);
96 
97// Update priority fee dynamically
98const msg2 = updateOrAppendSetComputeUnitPriceInstruction(
99  (current) => current === null ? 1000n : current * 2n, // Double on retry
100  transactionMessage
101);
102```
103 
104## Full Pattern: Build, Estimate, Send
105 
106Build with priority fee → estimate CU via simulation → refresh blockhash (simulation consumed time) → sign and send.
107 
108```ts
109import {
110  pipe, createTransactionMessage, setTransactionMessageFeePayerSigner,
111  setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstruction,
112  prependTransactionMessageInstruction, signTransactionMessageWithSigners,
113  sendAndConfirmTransactionFactory, assertIsTransactionWithBlockhashLifetime,
114} from '@solana/kit';
115import {
116  getSetComputeUnitPriceInstruction,
117  estimateComputeUnitLimitFactory,
118  estimateAndUpdateProvisoryComputeUnitLimitFactory,
119} from '@solana-program/compute-budget';
120 
121async function sendWithComputeBudget(rpc, rpcSubscriptions, signer, instruction) {
122  // Setup CU estimator
123  const estimateAndUpdateCU = estimateAndUpdateProvisoryComputeUnitLimitFactory(
124    estimateComputeUnitLimitFactory({ rpc })
125  );
126 
127  // 1. Build base message with priority fee
128  const { value: simBlockhash } = await rpc.getLatestBlockhash().send();
129 
130  let message = pipe(
131    createTransactionMessage({ version: 0 }),
132    m => setTransactionMessageFeePayerSigner(signer, m),
133    m => setTransactionMessageLifetimeUsingBlockhash(simBlockhash, m),
134    m => appendTransactionMessageInstruction(instruction, m),
135    m => prependTransactionMessageInstruction(
136      getSetComputeUnitPriceInstruction({ microLamports: 1000n }),
137      m
138    ),
139  );
140 
141  // 2. Estimate CU via simulation (adds/updates CU limit instruction)
142  message = await estimateAndUpdateCU(message);
143 
144  // 3. IMPORTANT: Refresh blockhash after estimation
145  const { value: freshBlockhash } = await rpc.getLatestBlockhash().send();
146  message = setTransactionMessageLifetimeUsingBlockhash(freshBlockhash, message);
147 
148  // 4. Sign and send
149  const sendAndConfirm = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });
150  const signed = await signTransactionMessageWithSigners(message);
151  assertIsTransactionWithBlockhashLifetime(signed);
152  return sendAndConfirm(signed, { commitment: 'confirmed' });
153}
154```
155 
156## Priority Fee Estimation
157 
158Don't hardcode priority fees — use your RPC provider's fee estimation API to set competitive rates for current network conditions:
159 
160- [Helius Priority Fee API](https://docs.helius.dev/solana-apis/priority-fee-api)
161- [QuickNode Priority Fee Add-on](https://marketplace.quicknode.com/add-on/solana-priority-fee)
162- [Triton Priority Fees API](https://docs.triton.one/chains/solana/improved-priority-fees-api)
163