@solana-program/compute-budget 0.14.0 → 0.16.0

package/src/generated/instructions/setComputeUnitPrice.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,
+    getU64Decoder,
+    getU64Encoder,
+    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_PRICE_DISCRIMINATOR = 3;
+
+export function getSetComputeUnitPriceDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU8Encoder().encode(SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR);
+}
+
+export type SetComputeUnitPriceInstruction<
+    TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<TRemainingAccounts>;
+
+export type SetComputeUnitPriceInstructionData = {
+    discriminator: number;
+    /** Transaction compute unit price used for prioritization fees. */
+    microLamports: bigint;
+};
+
+export type SetComputeUnitPriceInstructionDataArgs = {
+    /** Transaction compute unit price used for prioritization fees. */
+    microLamports: number | bigint;
+};
+
+export function getSetComputeUnitPriceInstructionDataEncoder(): FixedSizeEncoder<SetComputeUnitPriceInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU8Encoder()],
+            ['microLamports', getU64Encoder()],
+        ]),
+        value => ({ ...value, discriminator: SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR }),
+    );
+}
+
+export function getSetComputeUnitPriceInstructionDataDecoder(): FixedSizeDecoder<SetComputeUnitPriceInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU8Decoder()],
+        ['microLamports', getU64Decoder()],
+    ]);
+}
+
+export function getSetComputeUnitPriceInstructionDataCodec(): FixedSizeCodec<
+    SetComputeUnitPriceInstructionDataArgs,
+    SetComputeUnitPriceInstructionData
+> {
+    return combineCodec(getSetComputeUnitPriceInstructionDataEncoder(), getSetComputeUnitPriceInstructionDataDecoder());
+}
+
+export type SetComputeUnitPriceInput = {
+    microLamports: SetComputeUnitPriceInstructionDataArgs['microLamports'];
+};
+
+export function getSetComputeUnitPriceInstruction<
+    TProgramAddress extends Address = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,
+>(
+    input: SetComputeUnitPriceInput,
+    config?: { programAddress?: TProgramAddress },
+): SetComputeUnitPriceInstruction<TProgramAddress> {
+    // Program address.
+    const programAddress = config?.programAddress ?? COMPUTE_BUDGET_PROGRAM_ADDRESS;
+
+    // Original args.
+    const args = { ...input };
+
+    return Object.freeze({
+        data: getSetComputeUnitPriceInstructionDataEncoder().encode(args as SetComputeUnitPriceInstructionDataArgs),
+        programAddress,
+    } as SetComputeUnitPriceInstruction<TProgramAddress>);
+}
+
+export type ParsedSetComputeUnitPriceInstruction<TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS> = {
+    programAddress: Address<TProgram>;
+    data: SetComputeUnitPriceInstructionData;
+};
+
+export function parseSetComputeUnitPriceInstruction<TProgram extends string>(
+    instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedSetComputeUnitPriceInstruction<TProgram> {
+    return {
+        programAddress: instruction.programAddress,
+        data: getSetComputeUnitPriceInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/instructions/setLoadedAccountsDataSizeLimit.ts

@@ -0,0 +1,107 @@
+/**
+ * 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_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR = 4;
+
+export function getSetLoadedAccountsDataSizeLimitDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU8Encoder().encode(SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR);
+}
+
+export type SetLoadedAccountsDataSizeLimitInstruction<
+    TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<TRemainingAccounts>;
+
+export type SetLoadedAccountsDataSizeLimitInstructionData = { discriminator: number; accountDataSizeLimit: number };
+
+export type SetLoadedAccountsDataSizeLimitInstructionDataArgs = { accountDataSizeLimit: number };
+
+export function getSetLoadedAccountsDataSizeLimitInstructionDataEncoder(): FixedSizeEncoder<SetLoadedAccountsDataSizeLimitInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU8Encoder()],
+            ['accountDataSizeLimit', getU32Encoder()],
+        ]),
+        value => ({ ...value, discriminator: SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR }),
+    );
+}
+
+export function getSetLoadedAccountsDataSizeLimitInstructionDataDecoder(): FixedSizeDecoder<SetLoadedAccountsDataSizeLimitInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU8Decoder()],
+        ['accountDataSizeLimit', getU32Decoder()],
+    ]);
+}
+
+export function getSetLoadedAccountsDataSizeLimitInstructionDataCodec(): FixedSizeCodec<
+    SetLoadedAccountsDataSizeLimitInstructionDataArgs,
+    SetLoadedAccountsDataSizeLimitInstructionData
+> {
+    return combineCodec(
+        getSetLoadedAccountsDataSizeLimitInstructionDataEncoder(),
+        getSetLoadedAccountsDataSizeLimitInstructionDataDecoder(),
+    );
+}
+
+export type SetLoadedAccountsDataSizeLimitInput = {
+    accountDataSizeLimit: SetLoadedAccountsDataSizeLimitInstructionDataArgs['accountDataSizeLimit'];
+};
+
+export function getSetLoadedAccountsDataSizeLimitInstruction<
+    TProgramAddress extends Address = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,
+>(
+    input: SetLoadedAccountsDataSizeLimitInput,
+    config?: { programAddress?: TProgramAddress },
+): SetLoadedAccountsDataSizeLimitInstruction<TProgramAddress> {
+    // Program address.
+    const programAddress = config?.programAddress ?? COMPUTE_BUDGET_PROGRAM_ADDRESS;
+
+    // Original args.
+    const args = { ...input };
+
+    return Object.freeze({
+        data: getSetLoadedAccountsDataSizeLimitInstructionDataEncoder().encode(
+            args as SetLoadedAccountsDataSizeLimitInstructionDataArgs,
+        ),
+        programAddress,
+    } as SetLoadedAccountsDataSizeLimitInstruction<TProgramAddress>);
+}
+
+export type ParsedSetLoadedAccountsDataSizeLimitInstruction<
+    TProgram extends string = typeof COMPUTE_BUDGET_PROGRAM_ADDRESS,
+> = { programAddress: Address<TProgram>; data: SetLoadedAccountsDataSizeLimitInstructionData };
+
+export function parseSetLoadedAccountsDataSizeLimitInstruction<TProgram extends string>(
+    instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedSetLoadedAccountsDataSizeLimitInstruction<TProgram> {
+    return {
+        programAddress: instruction.programAddress,
+        data: getSetLoadedAccountsDataSizeLimitInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/programs/computeBudget.ts

@@ -0,0 +1,181 @@
+/**
+ * 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 {
+    containsBytes,
+    extendClient,
+    getU8Encoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+    SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+    SolanaError,
+    type Address,
+    type ClientWithTransactionPlanning,
+    type ClientWithTransactionSending,
+    type Instruction,
+    type InstructionWithData,
+    type ReadonlyUint8Array,
+} from '@solana/kit';
+import { addSelfPlanAndSendFunctions, type SelfPlanAndSendFunctions } from '@solana/kit/program-client-core';
+import {
+    getRequestHeapFrameInstruction,
+    getRequestUnitsInstruction,
+    getSetComputeUnitLimitInstruction,
+    getSetComputeUnitPriceInstruction,
+    getSetLoadedAccountsDataSizeLimitInstruction,
+    parseRequestHeapFrameInstruction,
+    parseRequestUnitsInstruction,
+    parseSetComputeUnitLimitInstruction,
+    parseSetComputeUnitPriceInstruction,
+    parseSetLoadedAccountsDataSizeLimitInstruction,
+    type ParsedRequestHeapFrameInstruction,
+    type ParsedRequestUnitsInstruction,
+    type ParsedSetComputeUnitLimitInstruction,
+    type ParsedSetComputeUnitPriceInstruction,
+    type ParsedSetLoadedAccountsDataSizeLimitInstruction,
+    type RequestHeapFrameInput,
+    type RequestUnitsInput,
+    type SetComputeUnitLimitInput,
+    type SetComputeUnitPriceInput,
+    type SetLoadedAccountsDataSizeLimitInput,
+} from '../instructions';
+
+export const COMPUTE_BUDGET_PROGRAM_ADDRESS =
+    'ComputeBudget111111111111111111111111111111' as Address<'ComputeBudget111111111111111111111111111111'>;
+
+export enum ComputeBudgetInstruction {
+    RequestUnits,
+    RequestHeapFrame,
+    SetComputeUnitLimit,
+    SetComputeUnitPrice,
+    SetLoadedAccountsDataSizeLimit,
+}
+
+export function identifyComputeBudgetInstruction(
+    instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+): ComputeBudgetInstruction {
+    const data = 'data' in instruction ? instruction.data : instruction;
+    if (containsBytes(data, getU8Encoder().encode(0), 0)) {
+        return ComputeBudgetInstruction.RequestUnits;
+    }
+    if (containsBytes(data, getU8Encoder().encode(1), 0)) {
+        return ComputeBudgetInstruction.RequestHeapFrame;
+    }
+    if (containsBytes(data, getU8Encoder().encode(2), 0)) {
+        return ComputeBudgetInstruction.SetComputeUnitLimit;
+    }
+    if (containsBytes(data, getU8Encoder().encode(3), 0)) {
+        return ComputeBudgetInstruction.SetComputeUnitPrice;
+    }
+    if (containsBytes(data, getU8Encoder().encode(4), 0)) {
+        return ComputeBudgetInstruction.SetLoadedAccountsDataSizeLimit;
+    }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, {
+        instructionData: data,
+        programName: 'computeBudget',
+    });
+}
+
+export type ParsedComputeBudgetInstruction<TProgram extends string = 'ComputeBudget111111111111111111111111111111'> =
+    | ({ instructionType: ComputeBudgetInstruction.RequestUnits } & ParsedRequestUnitsInstruction<TProgram>)
+    | ({ instructionType: ComputeBudgetInstruction.RequestHeapFrame } & ParsedRequestHeapFrameInstruction<TProgram>)
+    | ({
+          instructionType: ComputeBudgetInstruction.SetComputeUnitLimit;
+      } & ParsedSetComputeUnitLimitInstruction<TProgram>)
+    | ({
+          instructionType: ComputeBudgetInstruction.SetComputeUnitPrice;
+      } & ParsedSetComputeUnitPriceInstruction<TProgram>)
+    | ({
+          instructionType: ComputeBudgetInstruction.SetLoadedAccountsDataSizeLimit;
+      } & ParsedSetLoadedAccountsDataSizeLimitInstruction<TProgram>);
+
+export function parseComputeBudgetInstruction<TProgram extends string>(
+    instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedComputeBudgetInstruction<TProgram> {
+    const instructionType = identifyComputeBudgetInstruction(instruction);
+    switch (instructionType) {
+        case ComputeBudgetInstruction.RequestUnits: {
+            return {
+                instructionType: ComputeBudgetInstruction.RequestUnits,
+                ...parseRequestUnitsInstruction(instruction),
+            };
+        }
+        case ComputeBudgetInstruction.RequestHeapFrame: {
+            return {
+                instructionType: ComputeBudgetInstruction.RequestHeapFrame,
+                ...parseRequestHeapFrameInstruction(instruction),
+            };
+        }
+        case ComputeBudgetInstruction.SetComputeUnitLimit: {
+            return {
+                instructionType: ComputeBudgetInstruction.SetComputeUnitLimit,
+                ...parseSetComputeUnitLimitInstruction(instruction),
+            };
+        }
+        case ComputeBudgetInstruction.SetComputeUnitPrice: {
+            return {
+                instructionType: ComputeBudgetInstruction.SetComputeUnitPrice,
+                ...parseSetComputeUnitPriceInstruction(instruction),
+            };
+        }
+        case ComputeBudgetInstruction.SetLoadedAccountsDataSizeLimit: {
+            return {
+                instructionType: ComputeBudgetInstruction.SetLoadedAccountsDataSizeLimit,
+                ...parseSetLoadedAccountsDataSizeLimitInstruction(instruction),
+            };
+        }
+        default:
+            throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, {
+                instructionType: instructionType as string,
+                programName: 'computeBudget',
+            });
+    }
+}
+
+export type ComputeBudgetPlugin = { instructions: ComputeBudgetPluginInstructions };
+
+export type ComputeBudgetPluginInstructions = {
+    requestUnits: (
+        input: RequestUnitsInput,
+    ) => ReturnType<typeof getRequestUnitsInstruction> & SelfPlanAndSendFunctions;
+    requestHeapFrame: (
+        input: RequestHeapFrameInput,
+    ) => ReturnType<typeof getRequestHeapFrameInstruction> & SelfPlanAndSendFunctions;
+    setComputeUnitLimit: (
+        input: SetComputeUnitLimitInput,
+    ) => ReturnType<typeof getSetComputeUnitLimitInstruction> & SelfPlanAndSendFunctions;
+    setComputeUnitPrice: (
+        input: SetComputeUnitPriceInput,
+    ) => ReturnType<typeof getSetComputeUnitPriceInstruction> & SelfPlanAndSendFunctions;
+    setLoadedAccountsDataSizeLimit: (
+        input: SetLoadedAccountsDataSizeLimitInput,
+    ) => ReturnType<typeof getSetLoadedAccountsDataSizeLimitInstruction> & SelfPlanAndSendFunctions;
+};
+
+export type ComputeBudgetPluginRequirements = ClientWithTransactionPlanning & ClientWithTransactionSending;
+
+export function computeBudgetProgram() {
+    return <T extends ComputeBudgetPluginRequirements>(
+        client: T,
+    ): Omit<T, 'computeBudget'> & { computeBudget: ComputeBudgetPlugin } => {
+        return extendClient(client, {
+            computeBudget: <ComputeBudgetPlugin>{
+                instructions: {
+                    requestUnits: input => addSelfPlanAndSendFunctions(client, getRequestUnitsInstruction(input)),
+                    requestHeapFrame: input =>
+                        addSelfPlanAndSendFunctions(client, getRequestHeapFrameInstruction(input)),
+                    setComputeUnitLimit: input =>
+                        addSelfPlanAndSendFunctions(client, getSetComputeUnitLimitInstruction(input)),
+                    setComputeUnitPrice: input =>
+                        addSelfPlanAndSendFunctions(client, getSetComputeUnitPriceInstruction(input)),
+                    setLoadedAccountsDataSizeLimit: input =>
+                        addSelfPlanAndSendFunctions(client, getSetLoadedAccountsDataSizeLimitInstruction(input)),
+                },
+            },
+        });
+    };
+}

package/src/generated/programs/index.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 './computeBudget';

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './generated';
+
+export * from './constants';
+export * from './estimateAndSetComputeLimit';
+export * from './estimateComputeLimit';
+export * from './introspect';
+export * from './setComputeLimit';
+export * from './setComputePrice';

package/src/introspect.ts

@@ -0,0 +1,75 @@
+import {
+    TransactionMessage,
+    getU32Decoder,
+    getU64Decoder,
+    Instruction,
+    MicroLamports,
+    ReadonlyUint8Array,
+} from '@solana/kit';
+
+import {
+    COMPUTE_BUDGET_PROGRAM_ADDRESS,
+    ComputeBudgetInstruction,
+    identifyComputeBudgetInstruction,
+    SetComputeUnitLimitInstruction,
+    SetComputeUnitPriceInstruction,
+} from './generated';
+
+/**
+ * Finds the index of the first `SetComputeUnitLimit` instruction in a transaction message
+ * and its set limit, if any.
+ */
+export function findSetComputeUnitLimitInstructionIndexAndUnits(
+    transactionMessage: TransactionMessage,
+): { index: number; units: number } | null {
+    const index = transactionMessage.instructions.findIndex(isSetComputeUnitLimitInstruction);
+    if (index < 0) {
+        return null;
+    }
+
+    const units = getU32Decoder().decode(transactionMessage.instructions[index].data as ReadonlyUint8Array, 1);
+
+    return { index, units };
+}
+
+/**
+ * Checks if the given instruction is a `SetComputeUnitLimit` instruction.
+ */
+function isSetComputeUnitLimitInstruction(instruction: Instruction): instruction is SetComputeUnitLimitInstruction {
+    return (
+        instruction.programAddress === COMPUTE_BUDGET_PROGRAM_ADDRESS &&
+        identifyComputeBudgetInstruction(instruction.data as Uint8Array) ===
+            ComputeBudgetInstruction.SetComputeUnitLimit
+    );
+}
+
+/**
+ * Finds the index of the first `SetComputeUnitPrice` instruction in a transaction message
+ * and its set micro-lamports, if any.
+ */
+export function findSetComputeUnitPriceInstructionIndexAndMicroLamports(
+    transactionMessage: TransactionMessage,
+): { index: number; microLamports: MicroLamports } | null {
+    const index = transactionMessage.instructions.findIndex(isSetComputeUnitPriceInstruction);
+    if (index < 0) {
+        return null;
+    }
+
+    const microLamports = getU64Decoder().decode(
+        transactionMessage.instructions[index].data as ReadonlyUint8Array,
+        1,
+    ) as MicroLamports;
+
+    return { index, microLamports };
+}
+
+/**
+ * Checks if the given instruction is a `SetComputeUnitPrice` instruction.
+ */
+function isSetComputeUnitPriceInstruction(instruction: Instruction): instruction is SetComputeUnitPriceInstruction {
+    return (
+        instruction.programAddress === COMPUTE_BUDGET_PROGRAM_ADDRESS &&
+        identifyComputeBudgetInstruction(instruction.data as Uint8Array) ===
+            ComputeBudgetInstruction.SetComputeUnitPrice
+    );
+}

package/src/setComputeLimit.ts

@@ -0,0 +1,76 @@
+import { appendTransactionMessageInstruction, TransactionMessage } from '@solana/kit';
+
+import { PROVISORY_COMPUTE_UNIT_LIMIT } from './constants';
+import { getSetComputeUnitLimitInstruction } from './generated';
+import { findSetComputeUnitLimitInstructionIndexAndUnits } from './introspect';
+
+/**
+ * Appends a `SetComputeUnitLimit` instruction with a provisory
+ * compute unit limit to a given transaction message
+ * if and only if it does not already have one.
+ *
+ * @example
+ * ```ts
+ * const transactionMessage = pipe(
+ *   createTransactionMessage({ version: 0 }),
+ *   fillProvisorySetComputeUnitLimitInstruction,
+ *   // ...
+ * );
+ * ```
+ */
+export function fillProvisorySetComputeUnitLimitInstruction<TTransactionMessage extends TransactionMessage>(
+    transactionMessage: TTransactionMessage,
+) {
+    return updateOrAppendSetComputeUnitLimitInstruction(
+        previousUnits => (previousUnits === null ? PROVISORY_COMPUTE_UNIT_LIMIT : previousUnits),
+        transactionMessage,
+    );
+}
+
+/**
+ * Updates the first `SetComputeUnitLimit` instruction in a transaction message
+ * with the given units, or appends a new instruction if none exists.
+ * A function of the current value can be provided instead of a static value.
+ *
+ * @param units - The new compute unit limit, or a function that takes the previous
+ *                compute unit limit and returns the new limit.
+ * @param transactionMessage - The transaction message to update.
+ *
+ * @example
+ * ```ts
+ * const updatedTransactionMessage = updateOrAppendSetComputeUnitLimitInstruction(
+ *   // E.g. Keep the current limit if it is set, otherwise set it to the maximum.
+ *   (currentUnits) => currentUnits === null ? MAX_COMPUTE_UNIT_LIMIT : currentUnits,
+ *   transactionMessage,
+ * );
+ * ```
+ */
+export function updateOrAppendSetComputeUnitLimitInstruction<TTransactionMessage extends TransactionMessage>(
+    units: number | ((previousUnits: number | null) => number),
+    transactionMessage: TTransactionMessage,
+): TTransactionMessage {
+    const getUnits = (previousUnits: number | null): number =>
+        typeof units === 'function' ? units(previousUnits) : units;
+    const instructionDetails = findSetComputeUnitLimitInstructionIndexAndUnits(transactionMessage);
+
+    if (!instructionDetails) {
+        return appendTransactionMessageInstruction(
+            getSetComputeUnitLimitInstruction({ units: getUnits(null) }),
+            transactionMessage,
+        ) as TTransactionMessage;
+    }
+
+    const { index, units: previousUnits } = instructionDetails;
+    const newUnits = getUnits(previousUnits);
+    if (newUnits === previousUnits) {
+        return transactionMessage;
+    }
+
+    const newInstruction = getSetComputeUnitLimitInstruction({ units: newUnits });
+    const newInstructions = [...transactionMessage.instructions];
+    newInstructions.splice(index, 1, newInstruction);
+    return Object.freeze({
+        ...transactionMessage,
+        instructions: newInstructions,
+    }) as TTransactionMessage;
+}

package/src/setComputePrice.ts

@@ -0,0 +1,78 @@
+import { appendTransactionMessageInstruction, TransactionMessage, MicroLamports } from '@solana/kit';
+
+import { getSetComputeUnitPriceInstruction } from './generated';
+import { findSetComputeUnitPriceInstructionIndexAndMicroLamports } from './introspect';
+
+/**
+ * Sets the compute unit price of a transaction message in micro-Lamports.
+ *
+ * @example
+ * ```ts
+ * const transactionMessage = pipe(
+ *   createTransactionMessage({ version: 0 }),
+ *   (m) => setTransactionMessageComputeUnitPrice(10_000, m),
+ *   // ...
+ * );
+ * ```
+ */
+export function setTransactionMessageComputeUnitPrice<TTransactionMessage extends TransactionMessage>(
+    microLamports: number | bigint,
+    transactionMessage: TTransactionMessage,
+) {
+    return appendTransactionMessageInstruction(
+        getSetComputeUnitPriceInstruction({ microLamports }),
+        transactionMessage,
+    );
+}
+
+/**
+ * Updates the first `SetComputeUnitPrice` instruction in a transaction message
+ * with the given micro-Lamports, or appends a new instruction if none exists.
+ * A function of the current value can be provided instead of a static value.
+ *
+ * @param microLamports - The new compute unit price, or a function that
+ *                        takes the previous price and returns the new one.
+ * @param transactionMessage - The transaction message to update.
+ *
+ * @example
+ * ```ts
+ * const updatedTransactionMessage = updateOrAppendSetComputeUnitPriceInstruction(
+ *   // E.g. double the current price or set it to 10_000 if it isn't set.
+ *   (currentPrice) => currentPrice === null ? 10_000 : currentPrice * 2,
+ *   transactionMessage,
+ * );
+ * ```
+ */
+export function updateOrAppendSetComputeUnitPriceInstruction<TTransactionMessage extends TransactionMessage>(
+    microLamports: MicroLamports | ((previousMicroLamports: MicroLamports | null) => MicroLamports),
+    transactionMessage: TTransactionMessage,
+): TTransactionMessage {
+    const getMicroLamports = (previousMicroLamports: MicroLamports | null): MicroLamports =>
+        typeof microLamports === 'function' ? microLamports(previousMicroLamports) : microLamports;
+    const instructionDetails = findSetComputeUnitPriceInstructionIndexAndMicroLamports(transactionMessage);
+
+    if (!instructionDetails) {
+        return appendTransactionMessageInstruction(
+            getSetComputeUnitPriceInstruction({
+                microLamports: getMicroLamports(null),
+            }),
+            transactionMessage,
+        ) as TTransactionMessage;
+    }
+
+    const { index, microLamports: previousMicroLamports } = instructionDetails;
+    const newMicroLamports = getMicroLamports(previousMicroLamports);
+    if (newMicroLamports === previousMicroLamports) {
+        return transactionMessage;
+    }
+
+    const newInstruction = getSetComputeUnitPriceInstruction({
+        microLamports: newMicroLamports,
+    });
+    const newInstructions = [...transactionMessage.instructions];
+    newInstructions.splice(index, 1, newInstruction);
+    return Object.freeze({
+        ...transactionMessage,
+        instructions: newInstructions,
+    }) as TTransactionMessage;
+}