Update documentation

Author: lorisleiva

clients/js/src/estimateAndSetComputeLimit.ts

@@ -32,12 +32,14 @@ type EstimateAndUpdateProvisoryComputeUnitLimitFactoryFunction = <
  *
  * @example
  * ```ts
- * const estimateComputeUnitLimit = estimateComputeUnitLimitFactory({ rpc });
- * const estimateAndUpdateProvisoryComputeUnitLimit =
- *   estimateAndUpdateProvisoryComputeUnitLimitFactory(estimateComputeUnitLimit);
- * const estimatedTransactionMessage =
- *   await estimateAndUpdateProvisoryComputeUnitLimit(transactionMessage)
+ * const estimateAndUpdateCUs = estimateAndUpdateProvisoryComputeUnitLimitFactory(
+ *     estimateComputeUnitLimitFactory({ rpc })
+ * );
+ *
+ * const transactionMessageWithCUs = await estimateAndUpdateCUs(transactionMessage);
  * ```
+ *
+ * @see {@link estimateAndUpdateProvisoryComputeUnitLimitFactory}
  */
 export function estimateAndUpdateProvisoryComputeUnitLimitFactory(
   estimateComputeUnitLimit: EstimateComputeUnitLimitFactoryFunction

clients/js/src/estimateComputeLimit.ts

@@ -41,13 +41,11 @@ import {
  * @example
  * ```ts
  * import { getSetComputeUnitLimitInstruction } from '@solana-program/compute-budget';
- * import { createSolanaRpc, getComputeUnitEstimateForTransactionMessageFactory, pipe } from '@solana/kit';
+ * import { createSolanaRpc, estimateComputeUnitLimitFactory, pipe } from '@solana/kit';
  *
  * // Create an estimator function.
  * const rpc = createSolanaRpc('http://127.0.0.1:8899');
- * const getComputeUnitEstimateForTransactionMessage = getComputeUnitEstimateForTransactionMessageFactory({
- *     rpc,
- * });
+ * const estimateComputeUnitLimit = estimateComputeUnitLimitFactory({ rpc });
  *
  * // Create your transaction message.
  * const transactionMessage = pipe(
@@ -57,11 +55,11 @@ import {
  *
  * // 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 computeUnitsEstimate = await getComputeUnitEstimateForTransactionMessage(transactionMessage);
+ * const estimatedUnits = await estimateComputeUnitLimit(transactionMessage);
  *
  * // Set the transaction message's compute unit budget.
  * const transactionMessageWithComputeUnitLimit = prependTransactionMessageInstruction(
- *     getSetComputeUnitLimitInstruction({ units: computeUnitsEstimate }),
+ *     getSetComputeUnitLimitInstruction({ units: estimatedUnits }),
  *     transactionMessage,
  * );
  * ```

clients/js/src/setComputeLimit.ts

@@ -10,6 +10,15 @@ import { getSetComputeUnitLimitInstructionIndexAndUnits } from './internal';
  * 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 BaseTransactionMessage,
@@ -24,10 +33,20 @@ export function fillProvisorySetComputeUnitLimitInstruction<
 /**
  * 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 BaseTransactionMessage,

clients/js/src/setComputePrice.ts

@@ -6,6 +6,18 @@ import {
 import { getSetComputeUnitPriceInstruction } from './generated';
 import { getSetComputeUnitPriceInstructionIndexAndMicroLamports } from './internal';
 
+/**
+ * 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 BaseTransactionMessage,
 >(microLamports: number | bigint, transactionMessage: TTransactionMessage) {
@@ -17,11 +29,21 @@ export function setTransactionMessageComputeUnitPrice<
 
 /**
  * Updates the first `SetComputeUnitPrice` instruction in a transaction message
- * with the given units, or appends a new instruction if none exists.
+ * 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 BaseTransactionMessage,