@solana-program/compute-budget 0.14.0 → 0.16.0

package/src/estimateAndSetComputeLimit.ts

@@ -0,0 +1,58 @@
+import { TransactionMessage, TransactionMessageWithFeePayer } from '@solana/kit';
+
+import { MAX_COMPUTE_UNIT_LIMIT, PROVISORY_COMPUTE_UNIT_LIMIT } from './constants';
+import {
+    EstimateComputeUnitLimitFactoryFunction,
+    EstimateComputeUnitLimitFactoryFunctionConfig,
+} from './estimateComputeLimitInternal';
+import { findSetComputeUnitLimitInstructionIndexAndUnits } from './introspect';
+import { updateOrAppendSetComputeUnitLimitInstruction } from './setComputeLimit';
+
+type EstimateAndUpdateProvisoryComputeUnitLimitFactoryFunction = <
+    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer,
+>(
+    transactionMessage: TTransactionMessage,
+    config?: EstimateComputeUnitLimitFactoryFunctionConfig,
+) => Promise<TTransactionMessage>;
+
+/**
+ * Given a transaction message, if it does not have an explicit compute unit limit,
+ * estimates the compute unit limit and updates the transaction message with
+ * the estimated limit. Otherwise, returns the transaction message unchanged.
+ *
+ * It requires a function that estimates the compute unit limit.
+ *
+ * @example
+ * ```ts
+ * const estimateAndUpdateCUs = estimateAndUpdateProvisoryComputeUnitLimitFactory(
+ *     estimateComputeUnitLimitFactory({ rpc })
+ * );
+ *
+ * const transactionMessageWithCUs = await estimateAndUpdateCUs(transactionMessage);
+ * ```
+ *
+ * @see {@link estimateAndUpdateProvisoryComputeUnitLimitFactory}
+ */
+export function estimateAndUpdateProvisoryComputeUnitLimitFactory(
+    estimateComputeUnitLimit: EstimateComputeUnitLimitFactoryFunction,
+): EstimateAndUpdateProvisoryComputeUnitLimitFactoryFunction {
+    return async function fn(transactionMessage, config) {
+        const instructionDetails = findSetComputeUnitLimitInstructionIndexAndUnits(transactionMessage);
+
+        // If the transaction message already has a compute unit limit instruction
+        // which is set to a specific value — i.e. not 0 or the maximum limit —
+        // we don't need to estimate the compute unit limit.
+        if (
+            instructionDetails &&
+            instructionDetails.units !== PROVISORY_COMPUTE_UNIT_LIMIT &&
+            instructionDetails.units !== MAX_COMPUTE_UNIT_LIMIT
+        ) {
+            return transactionMessage;
+        }
+
+        return updateOrAppendSetComputeUnitLimitInstruction(
+            await estimateComputeUnitLimit(transactionMessage, config),
+            transactionMessage,
+        );
+    };
+}

package/src/estimateComputeLimit.ts

@@ -0,0 +1,77 @@
+import {
+    estimateComputeUnitLimit,
+    EstimateComputeUnitLimitFactoryConfig,
+    EstimateComputeUnitLimitFactoryFunction,
+} from './estimateComputeLimitInternal';
+
+/**
+ * Use this utility to estimate the actual compute unit cost of a given transaction message.
+ *
+ * Correctly budgeting a compute unit limit for your transaction message can increase the
+ * probability that your transaction will be accepted for processing. If you don't declare a compute
+ * unit limit on your transaction, validators will assume an upper limit of 200K compute units (CU)
+ * per instruction.
+ *
+ * Since validators have an incentive to pack as many transactions into each block as possible, they
+ * may choose to include transactions that they know will fit into the remaining compute budget for
+ * the current block over transactions that might not. For this reason, you should set a compute
+ * unit limit on each of your transaction messages, whenever possible.
+ *
+ * > [!WARNING]
+ * > The compute unit estimate is just that -- an estimate. The compute unit consumption of the
+ * > actual transaction might be higher or lower than what was observed in simulation. Unless you
+ * > are confident that your particular transaction message will consume the same or fewer compute
+ * > units as was estimated, you might like to augment the estimate by either a fixed number of CUs
+ * > or a multiplier.
+ *
+ * > [!NOTE]
+ * > If you are preparing an _unsigned_ transaction, destined to be signed and submitted to the
+ * > network by a wallet, you might like to leave it up to the wallet to determine the compute unit
+ * > limit. Consider that the wallet might have a more global view of how many compute units certain
+ * > types of transactions consume, and might be able to make better estimates of an appropriate
+ * > compute unit budget.
+ *
+ * > [!INFO]
+ * > In the event that a transaction message does not already have a `SetComputeUnitLimit`
+ * > instruction, this function will add one before simulation. This ensures that the compute unit
+ * > consumption of the `SetComputeUnitLimit` instruction itself is included in the estimate.
+ *
+ * @param config
+ *
+ * @example
+ * ```ts
+ * import { getSetComputeUnitLimitInstruction } from '@solana-program/compute-budget';
+ * import { createSolanaRpc, estimateComputeUnitLimitFactory, pipe } from '@solana/kit';
+ *
+ * // Create an estimator function.
+ * const rpc = createSolanaRpc('http://127.0.0.1:8899');
+ * const estimateComputeUnitLimit = estimateComputeUnitLimitFactory({ rpc });
+ *
+ * // Create your transaction message.
+ * const transactionMessage = pipe(
+ *     createTransactionMessage({ version: 'legacy' }),
+ *     /* ... *\/
+ * );
+ *
+ * // Request an estimate of the actual compute units this message will consume. This is done by
+ * // simulating the transaction and grabbing the estimated compute units from the result.
+ * const estimatedUnits = await estimateComputeUnitLimit(transactionMessage);
+ *
+ * // Set the transaction message's compute unit budget.
+ * const transactionMessageWithComputeUnitLimit = prependTransactionMessageInstruction(
+ *     getSetComputeUnitLimitInstruction({ units: estimatedUnits }),
+ *     transactionMessage,
+ * );
+ * ```
+ */
+export function estimateComputeUnitLimitFactory({
+    rpc,
+}: EstimateComputeUnitLimitFactoryConfig): EstimateComputeUnitLimitFactoryFunction {
+    return async function estimateComputeUnitLimitFactoryFunction(transactionMessage, config) {
+        return await estimateComputeUnitLimit({
+            ...config,
+            rpc,
+            transactionMessage,
+        });
+    };
+}

package/src/estimateComputeLimitInternal.ts

@@ -0,0 +1,167 @@
+import {
+    TransactionMessage,
+    Commitment,
+    compileTransaction,
+    getBase64EncodedWireTransaction,
+    getSolanaErrorFromTransactionError,
+    isSolanaError,
+    isTransactionMessageWithDurableNonceLifetime,
+    pipe,
+    Rpc,
+    RpcSimulateTransactionResult,
+    SimulateTransactionApi,
+    Slot,
+    SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT,
+    SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT,
+    SolanaError,
+    Transaction,
+    TransactionMessageWithFeePayer,
+} from '@solana/kit';
+
+import { MAX_COMPUTE_UNIT_LIMIT } from './constants';
+import { updateOrAppendSetComputeUnitLimitInstruction } from './setComputeLimit';
+
+export type EstimateComputeUnitLimitFactoryConfig = Readonly<{
+    /** An object that supports the {@link SimulateTransactionApi} of the Solana RPC API */
+    rpc: Rpc<SimulateTransactionApi>;
+}>;
+
+export type EstimateComputeUnitLimitFactoryFunction = (
+    transactionMessage: TransactionMessage & TransactionMessageWithFeePayer,
+    config?: EstimateComputeUnitLimitFactoryFunctionConfig,
+) => Promise<number>;
+
+export type EstimateComputeUnitLimitFactoryFunctionConfig = {
+    abortSignal?: AbortSignal;
+    /**
+     * Compute the estimate as of the highest slot that has reached this level of commitment.
+     *
+     * @defaultValue Whichever default is applied by the underlying {@link RpcApi} in use. For
+     * example, when using an API created by a `createSolanaRpc*()` helper, the default commitment
+     * is `"confirmed"` unless configured otherwise. Unmitigated by an API layer on the client, the
+     * default commitment applied by the server is `"finalized"`.
+     */
+    commitment?: Commitment;
+    /**
+     * Prevents accessing stale data by enforcing that the RPC node has processed transactions up to
+     * this slot
+     */
+    minContextSlot?: Slot;
+};
+
+type EstimateComputeUnitLimitConfig = EstimateComputeUnitLimitFactoryFunctionConfig &
+    Readonly<{
+        rpc: Rpc<SimulateTransactionApi>;
+        transactionMessage: TransactionMessage & TransactionMessageWithFeePayer;
+    }>;
+
+/**
+ * Simulates a transaction message on the network and returns the number of compute units it
+ * consumed during simulation.
+ *
+ * The estimate this function returns can be used to set a compute unit limit on the transaction.
+ * Correctly budgeting a compute unit limit for your transaction message can increase the probability
+ * that your transaction will be accepted for processing.
+ *
+ * If you don't declare a compute unit limit on your transaction, validators will assume an upper
+ * limit of 200K compute units (CU) per instruction. Since validators have an incentive to pack as
+ * many transactions into each block as possible, they may choose to include transactions that they
+ * know will fit into the remaining compute budget for the current block over transactions that
+ * might not. For this reason, you should set a compute unit limit on each of your transaction
+ * messages, whenever possible.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { getSetComputeLimitInstruction } from '@solana-program/compute-budget';
+ * import { createSolanaRpc, getComputeUnitEstimateForTransactionMessageFactory, pipe } from '@solana/kit';
+ *
+ * // Create an estimator function.
+ * const rpc = createSolanaRpc('http://127.0.0.1:8899');
+ * const getComputeUnitEstimateForTransactionMessage =
+ *     getComputeUnitEstimateForTransactionMessageFactory({ rpc });
+ *
+ * // Create your transaction message.
+ * const transactionMessage = pipe(
+ *     createTransactionMessage({ version: 'legacy' }),
+ *     /* ... *\/
+ * );
+ *
+ * // Request an estimate of the actual compute units this message will consume.
+ * const computeUnitsEstimate =
+ *     await getComputeUnitEstimateForTransactionMessage(transactionMessage);
+ *
+ * // Set the transaction message's compute unit budget.
+ * const transactionMessageWithComputeUnitLimit = prependTransactionMessageInstruction(
+ *     getSetComputeLimitInstruction({ units: computeUnitsEstimate }),
+ *     transactionMessage,
+ * );
+ * ```
+ *
+ * > [!WARNING]
+ * > The compute unit estimate is just that &ndash; an estimate. The compute unit consumption of the
+ * > actual transaction might be higher or lower than what was observed in simulation. Unless you
+ * > are confident that your particular transaction message will consume the same or fewer compute
+ * > units as was estimated, you might like to augment the estimate by either a fixed number of CUs
+ * > or a multiplier.
+ *
+ * > [!NOTE]
+ * > If you are preparing an _unsigned_ transaction, destined to be signed and submitted to the
+ * > network by a wallet, you might like to leave it up to the wallet to determine the compute unit
+ * > limit. Consider that the wallet might have a more global view of how many compute units certain
+ * > types of transactions consume, and might be able to make better estimates of an appropriate
+ * > compute unit budget.
+ */
+export async function estimateComputeUnitLimit({
+    transactionMessage,
+    ...configs
+}: EstimateComputeUnitLimitConfig): Promise<number> {
+    const replaceRecentBlockhash = !isTransactionMessageWithDurableNonceLifetime(transactionMessage);
+    const transaction = pipe(
+        transactionMessage,
+        m => updateOrAppendSetComputeUnitLimitInstruction(MAX_COMPUTE_UNIT_LIMIT, m),
+        compileTransaction,
+    );
+
+    return await simulateTransactionAndGetConsumedUnits({
+        transaction,
+        replaceRecentBlockhash,
+        ...configs,
+    });
+}
+
+type SimulateTransactionAndGetConsumedUnitsConfig = Omit<EstimateComputeUnitLimitConfig, 'transactionMessage'> &
+    Readonly<{ replaceRecentBlockhash?: boolean; transaction: Transaction }>;
+
+async function simulateTransactionAndGetConsumedUnits({
+    abortSignal,
+    rpc,
+    transaction,
+    ...simulateConfig
+}: SimulateTransactionAndGetConsumedUnitsConfig): Promise<number> {
+    const wireTransactionBytes = getBase64EncodedWireTransaction(transaction);
+
+    try {
+        const response = await rpc
+            .simulateTransaction(wireTransactionBytes, { ...simulateConfig, encoding: 'base64', sigVerify: false })
+            .send({ abortSignal });
+        const { err: transactionError, ...simulationResult } = response.value as RpcSimulateTransactionResult;
+        if (simulationResult.unitsConsumed == null) {
+            // This should never be hit, because all RPCs should support `unitsConsumed` by now.
+            throw new SolanaError(SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT);
+        }
+        if (transactionError) {
+            throw new SolanaError(SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT, {
+                ...simulationResult,
+                cause: getSolanaErrorFromTransactionError(transactionError),
+            });
+        }
+        // FIXME(https://github.com/anza-xyz/agave/issues/1295): The simulation response returns
+        // compute units as a u64, but the `SetComputeLimit` instruction only accepts a u32. Until
+        // this changes, downcast it.
+        return simulationResult.unitsConsumed > 4_294_967_295n ? 4_294_967_295 : Number(simulationResult.unitsConsumed);
+    } catch (e) {
+        if (isSolanaError(e, SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT)) throw e;
+        throw new SolanaError(SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT, { cause: e });
+    }
+}

package/src/generated/index.ts

@@ -0,0 +1,10 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+export * from './instructions';
+export * from './programs';

package/src/generated/instructions/index.ts

@@ -0,0 +1,13 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+export * from './requestHeapFrame';
+export * from './requestUnits';
+export * from './setComputeUnitLimit';
+export * from './setComputeUnitPrice';
+export * from './setLoadedAccountsDataSizeLimit';

package/src/generated/instructions/requestHeapFrame.ts

@@ -0,0 +1,114 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    combineCodec,
+    getStructDecoder,
+    getStructEncoder,
+    getU32Decoder,
+    getU32Encoder,
+    getU8Decoder,
+    getU8Encoder,
+    transformEncoder,
+    type AccountMeta,
+    type Address,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+    type Instruction,
+    type InstructionWithAccounts,
+    type InstructionWithData,
+    type ReadonlyUint8Array,
+} from '@solana/kit';
+import { COMPUTE_BUDGET_PROGRAM_ADDRESS } from '../programs';
+
+export const REQUEST_HEAP_FRAME_DISCRIMINATOR = 1;
+
+export function getRequestHeapFrameDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU8Encoder().encode(REQUEST_HEAP_FRAME_DISCRIMINATOR);
+}
+
+export type RequestHeapFrameInstruction<
+    TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<TRemainingAccounts>;
+
+export type RequestHeapFrameInstructionData = {
+    discriminator: number;
+    /**
+     * Requested transaction-wide program heap size in bytes.
+     * Must be multiple of 1024. Applies to each program, including CPIs.
+     */
+    bytes: number;
+};
+
+export type RequestHeapFrameInstructionDataArgs = {
+    /**
+     * Requested transaction-wide program heap size in bytes.
+     * Must be multiple of 1024. Applies to each program, including CPIs.
+     */
+    bytes: number;
+};
+
+export function getRequestHeapFrameInstructionDataEncoder(): FixedSizeEncoder<RequestHeapFrameInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU8Encoder()],
+            ['bytes', getU32Encoder()],
+        ]),
+        value => ({ ...value, discriminator: REQUEST_HEAP_FRAME_DISCRIMINATOR }),
+    );
+}
+
+export function getRequestHeapFrameInstructionDataDecoder(): FixedSizeDecoder<RequestHeapFrameInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU8Decoder()],
+        ['bytes', getU32Decoder()],
+    ]);
+}
+
+export function getRequestHeapFrameInstructionDataCodec(): FixedSizeCodec<
+    RequestHeapFrameInstructionDataArgs,
+    RequestHeapFrameInstructionData
+> {
+    return combineCodec(getRequestHeapFrameInstructionDataEncoder(), getRequestHeapFrameInstructionDataDecoder());
+}
+
+export type RequestHeapFrameInput = {
+    bytes: RequestHeapFrameInstructionDataArgs['bytes'];
+};
+
+export function getRequestHeapFrameInstruction<TProgramAddress extends Address = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS>(
+    input: RequestHeapFrameInput,
+    config?: { programAddress?: TProgramAddress },
+): RequestHeapFrameInstruction<TProgramAddress> {
+    // Program address.
+    const programAddress = config?.programAddress ?? COMPUTE_BUDGET_PROGRAM_ADDRESS;
+
+    // Original args.
+    const args = { ...input };
+
+    return Object.freeze({
+        data: getRequestHeapFrameInstructionDataEncoder().encode(args as RequestHeapFrameInstructionDataArgs),
+        programAddress,
+    } as RequestHeapFrameInstruction<TProgramAddress>);
+}
+
+export type ParsedRequestHeapFrameInstruction<TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS> = {
+    programAddress: Address<TProgram>;
+    data: RequestHeapFrameInstructionData;
+};
+
+export function parseRequestHeapFrameInstruction<TProgram extends string>(
+    instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedRequestHeapFrameInstruction<TProgram> {
+    return {
+        programAddress: instruction.programAddress,
+        data: getRequestHeapFrameInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/instructions/requestUnits.ts

@@ -0,0 +1,115 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    combineCodec,
+    getStructDecoder,
+    getStructEncoder,
+    getU32Decoder,
+    getU32Encoder,
+    getU8Decoder,
+    getU8Encoder,
+    transformEncoder,
+    type AccountMeta,
+    type Address,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+    type Instruction,
+    type InstructionWithAccounts,
+    type InstructionWithData,
+    type ReadonlyUint8Array,
+} from '@solana/kit';
+import { COMPUTE_BUDGET_PROGRAM_ADDRESS } from '../programs';
+
+export const REQUEST_UNITS_DISCRIMINATOR = 0;
+
+export function getRequestUnitsDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU8Encoder().encode(REQUEST_UNITS_DISCRIMINATOR);
+}
+
+export type RequestUnitsInstruction<
+    TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<TRemainingAccounts>;
+
+export type RequestUnitsInstructionData = {
+    discriminator: number;
+    /** Units to request for transaction-wide compute. */
+    units: number;
+    /** Prioritization fee lamports. */
+    additionalFee: number;
+};
+
+export type RequestUnitsInstructionDataArgs = {
+    /** Units to request for transaction-wide compute. */
+    units: number;
+    /** Prioritization fee lamports. */
+    additionalFee: number;
+};
+
+export function getRequestUnitsInstructionDataEncoder(): FixedSizeEncoder<RequestUnitsInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU8Encoder()],
+            ['units', getU32Encoder()],
+            ['additionalFee', getU32Encoder()],
+        ]),
+        value => ({ ...value, discriminator: REQUEST_UNITS_DISCRIMINATOR }),
+    );
+}
+
+export function getRequestUnitsInstructionDataDecoder(): FixedSizeDecoder<RequestUnitsInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU8Decoder()],
+        ['units', getU32Decoder()],
+        ['additionalFee', getU32Decoder()],
+    ]);
+}
+
+export function getRequestUnitsInstructionDataCodec(): FixedSizeCodec<
+    RequestUnitsInstructionDataArgs,
+    RequestUnitsInstructionData
+> {
+    return combineCodec(getRequestUnitsInstructionDataEncoder(), getRequestUnitsInstructionDataDecoder());
+}
+
+export type RequestUnitsInput = {
+    units: RequestUnitsInstructionDataArgs['units'];
+    additionalFee: RequestUnitsInstructionDataArgs['additionalFee'];
+};
+
+export function getRequestUnitsInstruction<TProgramAddress extends Address = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS>(
+    input: RequestUnitsInput,
+    config?: { programAddress?: TProgramAddress },
+): RequestUnitsInstruction<TProgramAddress> {
+    // Program address.
+    const programAddress = config?.programAddress ?? COMPUTE_BUDGET_PROGRAM_ADDRESS;
+
+    // Original args.
+    const args = { ...input };
+
+    return Object.freeze({
+        data: getRequestUnitsInstructionDataEncoder().encode(args as RequestUnitsInstructionDataArgs),
+        programAddress,
+    } as RequestUnitsInstruction<TProgramAddress>);
+}
+
+export type ParsedRequestUnitsInstruction<TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS> = {
+    programAddress: Address<TProgram>;
+    data: RequestUnitsInstructionData;
+};
+
+export function parseRequestUnitsInstruction<TProgram extends string>(
+    instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedRequestUnitsInstruction<TProgram> {
+    return {
+        programAddress: instruction.programAddress,
+        data: getRequestUnitsInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/instructions/setComputeUnitLimit.ts

@@ -0,0 +1,110 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    combineCodec,
+    getStructDecoder,
+    getStructEncoder,
+    getU32Decoder,
+    getU32Encoder,
+    getU8Decoder,
+    getU8Encoder,
+    transformEncoder,
+    type AccountMeta,
+    type Address,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+    type Instruction,
+    type InstructionWithAccounts,
+    type InstructionWithData,
+    type ReadonlyUint8Array,
+} from '@solana/kit';
+import { COMPUTE_BUDGET_PROGRAM_ADDRESS } from '../programs';
+
+export const SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR = 2;
+
+export function getSetComputeUnitLimitDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU8Encoder().encode(SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR);
+}
+
+export type SetComputeUnitLimitInstruction<
+    TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<TRemainingAccounts>;
+
+export type SetComputeUnitLimitInstructionData = {
+    discriminator: number;
+    /** Transaction-wide compute unit limit. */
+    units: number;
+};
+
+export type SetComputeUnitLimitInstructionDataArgs = {
+    /** Transaction-wide compute unit limit. */
+    units: number;
+};
+
+export function getSetComputeUnitLimitInstructionDataEncoder(): FixedSizeEncoder<SetComputeUnitLimitInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU8Encoder()],
+            ['units', getU32Encoder()],
+        ]),
+        value => ({ ...value, discriminator: SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR }),
+    );
+}
+
+export function getSetComputeUnitLimitInstructionDataDecoder(): FixedSizeDecoder<SetComputeUnitLimitInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU8Decoder()],
+        ['units', getU32Decoder()],
+    ]);
+}
+
+export function getSetComputeUnitLimitInstructionDataCodec(): FixedSizeCodec<
+    SetComputeUnitLimitInstructionDataArgs,
+    SetComputeUnitLimitInstructionData
+> {
+    return combineCodec(getSetComputeUnitLimitInstructionDataEncoder(), getSetComputeUnitLimitInstructionDataDecoder());
+}
+
+export type SetComputeUnitLimitInput = {
+    units: SetComputeUnitLimitInstructionDataArgs['units'];
+};
+
+export function getSetComputeUnitLimitInstruction<
+    TProgramAddress extends Address = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,
+>(
+    input: SetComputeUnitLimitInput,
+    config?: { programAddress?: TProgramAddress },
+): SetComputeUnitLimitInstruction<TProgramAddress> {
+    // Program address.
+    const programAddress = config?.programAddress ?? COMPUTE_BUDGET_PROGRAM_ADDRESS;
+
+    // Original args.
+    const args = { ...input };
+
+    return Object.freeze({
+        data: getSetComputeUnitLimitInstructionDataEncoder().encode(args as SetComputeUnitLimitInstructionDataArgs),
+        programAddress,
+    } as SetComputeUnitLimitInstruction<TProgramAddress>);
+}
+
+export type ParsedSetComputeUnitLimitInstruction<TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS> = {
+    programAddress: Address<TProgram>;
+    data: SetComputeUnitLimitInstructionData;
+};
+
+export function parseSetComputeUnitLimitInstruction<TProgram extends string>(
+    instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedSetComputeUnitLimitInstruction<TProgram> {
+    return {
+        programAddress: instruction.programAddress,
+        data: getSetComputeUnitLimitInstructionDataDecoder().decode(instruction.data),
+    };
+}