@send-fun/sdk 1.0.1 → 1.2.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { Account, AccountMeta, AccountSignerMeta, Address, ClientWithPayer, ClientWithRpc, ClientWithTransactionPlanning, ClientWithTransactionSending, Codec, Commitment, Decoder, EncodedAccount, Encoder, ExtendedClient, FetchAccountConfig, FetchAccountsConfig, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder, GetAccountInfoApi, GetEpochInfoApi, GetMultipleAccountsApi, GetProgramAccountsApi, Instruction, InstructionWithAccounts, InstructionWithData, MaybeAccount, MaybeEncodedAccount, ProgramDerivedAddress, ReadonlyAccount, ReadonlySignerAccount, ReadonlyUint8Array, Rpc, SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM, SolanaError, TransactionSigner, WritableAccount, WritableSignerAccount, fetchEncodedAccount, fetchEncodedAccounts } from "@solana/kit";
-import { SelfFetchFunctions, SelfPlanAndSendFunctions } from "@solana/program-client-core";
+import { SelfFetchFunctions, SelfPlanAndSendFunctions } from "@solana/kit/program-client-core";
 //#region src/dex/generated/programs/sendDex.d.ts
 declare const SEND_DEX_PROGRAM_ADDRESS: Address<"84qj5FPZZdXkQy8mfowyg6RBZ3XKuTds6XS4ZYT1sfDX">;
 //#endregion
@@ -47,11 +47,39 @@ declare function getGlobalConfigEncoder$2(): FixedSizeEncoder<GlobalConfigArgs$2
 declare function getGlobalConfigDecoder$2(): FixedSizeDecoder<GlobalConfig$2>;
 /** Gets the codec for {@link GlobalConfig} account data. */
 declare function getGlobalConfigCodec$2(): FixedSizeCodec<GlobalConfigArgs$2, GlobalConfig$2>;
+/**
+ * Decodes a `GlobalConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeGlobalConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeGlobalConfig$2<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<GlobalConfig$2, TAddress>;
+/**
+ * Decodes a `GlobalConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeGlobalConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeGlobalConfig$2<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<GlobalConfig$2, TAddress>;
+/** Fetches a `GlobalConfig` account, throwing when it does not exist or only holds lamports. */
 declare function fetchGlobalConfig$2<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<GlobalConfig$2, TAddress>>;
+/**
+ * Fetches a `GlobalConfig` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeGlobalConfig} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeGlobalConfig$2<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<GlobalConfig$2, TAddress>>;
+/** Fetches `GlobalConfig` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllGlobalConfig$2(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<GlobalConfig$2>[]>;
+/**
+ * Fetches `GlobalConfig` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeGlobalConfig} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeGlobalConfig$2(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<GlobalConfig$2>[]>;
 declare function getGlobalConfigSize$1(): number;
 //#endregion
@@ -134,11 +162,39 @@ declare function getPoolEncoder(): FixedSizeEncoder<PoolArgs>;
 declare function getPoolDecoder(): FixedSizeDecoder<Pool>;
 /** Gets the codec for {@link Pool} account data. */
 declare function getPoolCodec(): FixedSizeCodec<PoolArgs, Pool>;
+/**
+ * Decodes a `Pool` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybePool}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodePool<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Pool, TAddress>;
+/**
+ * Decodes a `Pool` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybePool}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodePool<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Pool, TAddress>;
+/** Fetches a `Pool` account, throwing when it does not exist or only holds lamports. */
 declare function fetchPool<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<Pool, TAddress>>;
+/**
+ * Fetches a `Pool` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodePool} throws for a lamports-only account instead.
+ */
 declare function fetchMaybePool<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<Pool, TAddress>>;
+/** Fetches `Pool` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllPool(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<Pool>[]>;
+/**
+ * Fetches `Pool` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodePool} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybePool(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<Pool>[]>;
 declare function getPoolSize(): number;
 //#endregion
@@ -168,11 +224,39 @@ declare function getRewardAccrualEncoder$1(): FixedSizeEncoder<RewardAccrualArgs
 declare function getRewardAccrualDecoder$1(): FixedSizeDecoder<RewardAccrual$1>;
 /** Gets the codec for {@link RewardAccrual} account data. */
 declare function getRewardAccrualCodec$1(): FixedSizeCodec<RewardAccrualArgs$1, RewardAccrual$1>;
+/**
+ * Decodes a `RewardAccrual` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeRewardAccrual}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeRewardAccrual$1<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<RewardAccrual$1, TAddress>;
+/**
+ * Decodes a `RewardAccrual` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeRewardAccrual}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeRewardAccrual$1<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<RewardAccrual$1, TAddress>;
+/** Fetches a `RewardAccrual` account, throwing when it does not exist or only holds lamports. */
 declare function fetchRewardAccrual$1<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<RewardAccrual$1, TAddress>>;
+/**
+ * Fetches a `RewardAccrual` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeRewardAccrual} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeRewardAccrual$1<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<RewardAccrual$1, TAddress>>;
+/** Fetches `RewardAccrual` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllRewardAccrual$1(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<RewardAccrual$1>[]>;
+/**
+ * Fetches `RewardAccrual` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeRewardAccrual} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeRewardAccrual$1(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<RewardAccrual$1>[]>;
 declare function getRewardAccrualSize$1(): number;
 //#endregion
@@ -1214,27 +1298,29 @@ declare namespace index_d_exports$19 {
 declare namespace amm_d_exports {
   export { BuyQuote, MintFee, SellQuote, TradeQuote, TransferFeeNotSettleableError, amountAfterFee, buyExactIn$2 as buyExactIn, buyExactOut$2 as buyExactOut, calculateInitialLp, calculateInputForOutput, calculateMarketCap, calculateOutput, calculatePrice, calculateSlippageDown, calculateSlippageUp, feeOn, grossUp, sellExactIn$2 as sellExactIn, sellExactOut$2 as sellExactOut };
 }
-/** Token-2022 `TransferFeeConfig` for the epoch the trade lands in; a stale one misprices the trade. */
+/** A Token-2022 transfer fee for one epoch. Use the fee for the epoch the trade lands in. */
 interface MintFee {
   /** 0 to 10_000. */
   bps: number;
-  /** Cap on the withheld amount, in the mint's raw units. */
+  /** Maximum fee per transfer, in the mint's raw units. */
   maximumFee: bigint;
 }
-/** No transfer lands exactly the requested amount; approximating one hands the program a bound it rejects. */
+/** Thrown when no transfer delivers exactly `amount` after the transfer fee. */
 declare class TransferFeeNotSettleableError extends RangeError {
   readonly amount: bigint;
   readonly mintFee: MintFee;
   constructor(amount: bigint, mintFee: MintFee);
 }
-/** Rounds up, then caps (SPL's order); swapping them lets a split booking over-credit. */
+/** Returns the transfer fee on `amount`. Rounds up, then caps at `maximumFee`, in SPL's order.
+ *  Returns 0 without `fee`. Throws `RangeError` if `fee` is out of range. */
 declare function feeOn(amount: bigint, fee?: MintFee): bigint;
-/** What lands when `amount` is sent; use `grossUp` to land an exact amount. */
+/** Returns what the recipient receives when `amount` is sent. `grossUp` is the inverse. */
 declare function amountAfterFee(amount: bigint, fee?: MintFee): bigint;
-/** What must be sent for exactly `amount` to land; throws {@link TransferFeeNotSettleableError} if none does. */
+/** Returns the amount to send so that exactly `amount` arrives. Returns `amount` without `fee`.
+ *  Throws {@link TransferFeeNotSettleableError} if no such amount exists. */
 declare function grossUp(amount: bigint, fee?: MintFee): bigint;
-/** `baseAmount`/`quoteAmount` are the user's transfers, as in on-chain `TradeResult`. Read the net
- *  fields on {@link BuyQuote}/{@link SellQuote}; re-deriving them drifts from the program by a rounding step. */
+/** `baseAmount` and `quoteAmount` are the user's transfers.
+ *  Read the net amounts from the fields of {@link BuyQuote} and {@link SellQuote}. Do not calculate them again. */
 interface TradeQuote {
   /** Base sent: vault to user on a buy, user to vault on a sell. */
   baseAmount: bigint;
@@ -1246,24 +1332,26 @@ interface TradeQuote {
   quoteTransferFee: bigint;
 }
 interface BuyQuote extends TradeQuote {
-  /** Priced on the quote reaching the vault. */
+  /** Priced on the quote that reaches the vault. */
   fee: bigint;
-  /** Base credited to the buyer, after the base mint's cut. */
+  /** Base the buyer receives, after the base mint's transfer fee. */
   baseToUser: bigint;
   /** Equals `quoteAmount`. */
   quoteFromUser: bigint;
 }
 interface SellQuote extends TradeQuote {
-  /** Priced on the quote leaving the vault. */
+  /** Priced on the AMM's quote output, before this fee. */
   fee: bigint;
   /** Equals `baseAmount`. */
   baseFromUser: bigint;
-  /** Quote credited to the seller, after the quote mint's cut. */
+  /** Quote the seller receives, after the quote mint's transfer fee. */
   quoteToUser: bigint;
 }
-/** Output rounds down (the new reserve rounds up), so `k` never shrinks. */
+/** Returns the constant-product output for `amountIn`, rounded down. Throws `RangeError` on a zero
+ *  reserve, a zero `amountIn`, a zero output, or an output past u64. */
 declare function calculateOutput(reserveIn: bigint, reserveOut: bigint, amountIn: bigint): bigint;
-/** Required input rounds up so the user pays enough. */
+/** Returns the input needed for `amountOut`, rounded up. Throws `RangeError` on a zero reserve, a zero
+ *  `amountOut`, an `amountOut` not below `reserveOut`, or an input past u64. */
 declare function calculateInputForOutput(reserveIn: bigint, reserveOut: bigint, amountOut: bigint): bigint;
 interface BaseQuoteParams {
   reserveQuote: bigint;
@@ -1272,38 +1360,42 @@ interface BaseQuoteParams {
   quoteFee?: MintFee;
   baseFee?: MintFee;
 }
-/** Launchpad only: `bondingCurve.realBaseReserves`. A DEX pool has no cap. */
+/** `baseReserveCap` is `bondingCurve.realBaseReserves`. A DEX pool has no cap. */
 interface BaseReserveCap {
   baseReserveCap?: bigint;
 }
-/** Guard with `calculateSlippageUp(quoteAmount, bps)`; it already carries the quote mint's cut. */
+/** Quotes a buy where the buyer receives `baseAmountOut`. With `baseReserveCap`, the vault sends at
+ *  most the cap. Guard with `calculateSlippageUp(quoteAmount, bps)`. `quoteAmount` includes the quote
+ *  mint's transfer fee. */
 declare function buyExactOut$2(params: BaseQuoteParams & BaseReserveCap & {
   baseAmountOut: bigint;
 }): BuyQuote;
-/** Guard with `calculateSlippageDown(baseToUser, bps)`, not `baseAmount`: the program bounds what the buyer nets. */
+/** Quotes a buy that spends `quoteAmountIn`. Guard with `calculateSlippageDown(baseToUser, bps)`, not
+ *  `baseAmount`. The program checks the minimum against what the buyer receives. */
 declare function buyExactIn$2(params: BaseQuoteParams & BaseReserveCap & {
   quoteAmountIn: bigint;
 }): BuyQuote;
-/** Guard with `calculateSlippageDown(quoteToUser, bps)`, not `quoteAmount`. */
+/** Quotes a sell of `baseAmountIn`. Guard with `calculateSlippageDown(quoteToUser, bps)`, not `quoteAmount`. */
 declare function sellExactIn$2(params: BaseQuoteParams & {
   baseAmountIn: bigint;
 }): SellQuote;
-/** Guard with `calculateSlippageUp(baseFromUser, bps)`, which already carries the base mint's cut. */
+/** Quotes a sell where the seller receives `quoteAmountOut`. Guard with
+ *  `calculateSlippageUp(baseFromUser, bps)`. `baseFromUser` includes the base mint's transfer fee. */
 declare function sellExactOut$2(params: BaseQuoteParams & {
   quoteAmountOut: bigint;
 }): SellQuote;
 declare function calculateSlippageUp(amount: bigint, slippageBps: number): bigint;
 declare function calculateSlippageDown(amount: bigint, slippageBps: number): bigint;
-/** Floors, as the program's `isqrt` does. */
+/** Returns `sqrt(quoteAmount * baseAmount)`, rounded down. */
 declare function calculateInitialLp(quoteAmount: bigint, baseAmount: bigint): bigint;
-/** Floating-point quote per base, for display only. */
+/** Returns the price of one base token in quote tokens, as a float. For display only. */
 declare function calculatePrice(params: {
   quoteReserves: bigint;
   baseReserves: bigint;
   quoteDecimals: number;
   baseDecimals: number;
 }): number;
-/** Market cap in raw quote-token units. */
+/** Returns the market cap in raw quote units. */
 declare function calculateMarketCap(params: {
   quoteReserves: bigint;
   baseReserves: bigint;
@@ -1311,7 +1403,7 @@ declare function calculateMarketCap(params: {
 }): bigint;
 //#endregion
 //#region src/utils/partner.d.ts
-/** Non-default partners must sign; only `DEFAULT_PARTNER` is valid as a bare address. */
+/** A partner signer, or `DEFAULT_PARTNER` as a bare address. Any other partner must sign. */
 type PartnerInput = TransactionSigner | typeof DEFAULT_PARTNER;
 declare namespace trade_d_exports$1 {
   export { DexInstructionParams, DexTradeParams, buildBuyExactInInstruction$1 as buildBuyExactInInstruction, buildBuyExactOutInstruction$1 as buildBuyExactOutInstruction, buildSellExactInInstruction$1 as buildSellExactInInstruction, buildSellExactOutInstruction$1 as buildSellExactOutInstruction, buyExactIn$1 as buyExactIn, buyExactOut$1 as buyExactOut, sellExactIn$1 as sellExactIn, sellExactOut$1 as sellExactOut };
@@ -1328,7 +1420,7 @@ interface DexTradeParams {
   partner: PartnerInput;
   platformConfig: Address;
   quoteTokenProgram: Address;
-  /** Token-2022 schedule for the epoch the trade lands in; stale or missing skews the slippage bounds. */
+  /** The quote mint's transfer fee for the epoch the trade lands in. A missing or old fee gives wrong slippage bounds. */
   quoteFee?: MintFee;
   baseFee?: MintFee;
   /** {@inheritDoc DexInstructionParams.userQuoteAccount} */
@@ -1344,15 +1436,14 @@ interface DexInstructionParams {
   partner: PartnerInput;
   platformConfig: Address;
   quoteTokenProgram: Address;
-  /** Any user-owned quote-mint account. Defaults to the ATA, created mid-trade
-   *  if missing (payer funds rent), which only rescues a sell. For WSOL,
-   *  a throwaway `createAccountWithSeed` account is cheaper. */
+  /** Any quote-mint token account that `user` owns. Defaults to the user's ATA.
+   *  The program creates a missing ATA, and `payer` pays the rent. */
   userQuoteAccount?: Address;
-  /** Any user-owned base-mint account. Defaults to the ATA, created mid-trade
-   *  if missing (payer funds rent), which only rescues a buy. */
+  /** Any base-mint token account that `user` owns. Defaults to the user's ATA.
+   *  The program creates a missing ATA, and `payer` pays the rent. */
   userBaseAccount?: Address;
 }
-/** `baseAmountOut` is net to the buyer: the program reads `amount` as `base_to_user`. */
+/** `baseAmountOut` is the base the buyer receives, after the base mint's transfer fee. */
 declare function buyExactOut$1(params: DexTradeParams & {
   baseAmountOut: bigint;
 }): Promise<{
@@ -1371,7 +1462,7 @@ declare function sellExactIn$1(params: DexTradeParams & {
   instruction: Instruction;
   quote: SellQuote;
 }>;
-/** `quoteAmountOut` is net to the seller: the program reads `amount` as `quote_to_user`. */
+/** `quoteAmountOut` is the quote the seller receives, after the quote mint's transfer fee. */
 declare function sellExactOut$1(params: DexTradeParams & {
   quoteAmountOut: bigint;
 }): Promise<{
@@ -1487,11 +1578,39 @@ declare function getBondingCurveEncoder(): FixedSizeEncoder<BondingCurveArgs>;
 declare function getBondingCurveDecoder(): FixedSizeDecoder<BondingCurve>;
 /** Gets the codec for {@link BondingCurve} account data. */
 declare function getBondingCurveCodec(): FixedSizeCodec<BondingCurveArgs, BondingCurve>;
+/**
+ * Decodes a `BondingCurve` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeBondingCurve}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeBondingCurve<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<BondingCurve, TAddress>;
+/**
+ * Decodes a `BondingCurve` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeBondingCurve}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeBondingCurve<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<BondingCurve, TAddress>;
+/** Fetches a `BondingCurve` account, throwing when it does not exist or only holds lamports. */
 declare function fetchBondingCurve<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<BondingCurve, TAddress>>;
+/**
+ * Fetches a `BondingCurve` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeBondingCurve} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeBondingCurve<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<BondingCurve, TAddress>>;
+/** Fetches `BondingCurve` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllBondingCurve(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<BondingCurve>[]>;
+/**
+ * Fetches `BondingCurve` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeBondingCurve} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeBondingCurve(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<BondingCurve>[]>;
 declare function getBondingCurveSize(): number;
 //#endregion
@@ -1531,11 +1650,39 @@ declare function getGlobalConfigEncoder$1(): FixedSizeEncoder<GlobalConfigArgs$1
 declare function getGlobalConfigDecoder$1(): FixedSizeDecoder<GlobalConfig$1>;
 /** Gets the codec for {@link GlobalConfig} account data. */
 declare function getGlobalConfigCodec$1(): FixedSizeCodec<GlobalConfigArgs$1, GlobalConfig$1>;
+/**
+ * Decodes a `GlobalConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeGlobalConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeGlobalConfig$1<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<GlobalConfig$1, TAddress>;
+/**
+ * Decodes a `GlobalConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeGlobalConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeGlobalConfig$1<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<GlobalConfig$1, TAddress>;
+/** Fetches a `GlobalConfig` account, throwing when it does not exist or only holds lamports. */
 declare function fetchGlobalConfig$1<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<GlobalConfig$1, TAddress>>;
+/**
+ * Fetches a `GlobalConfig` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeGlobalConfig} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeGlobalConfig$1<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<GlobalConfig$1, TAddress>>;
+/** Fetches `GlobalConfig` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllGlobalConfig$1(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<GlobalConfig$1>[]>;
+/**
+ * Fetches `GlobalConfig` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeGlobalConfig} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeGlobalConfig$1(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<GlobalConfig$1>[]>;
 declare function getGlobalConfigSize(): number;
 //#endregion
@@ -1565,11 +1712,39 @@ declare function getRewardAccrualEncoder(): FixedSizeEncoder<RewardAccrualArgs>;
 declare function getRewardAccrualDecoder(): FixedSizeDecoder<RewardAccrual>;
 /** Gets the codec for {@link RewardAccrual} account data. */
 declare function getRewardAccrualCodec(): FixedSizeCodec<RewardAccrualArgs, RewardAccrual>;
+/**
+ * Decodes a `RewardAccrual` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeRewardAccrual}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeRewardAccrual<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<RewardAccrual, TAddress>;
+/**
+ * Decodes a `RewardAccrual` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeRewardAccrual}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeRewardAccrual<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<RewardAccrual, TAddress>;
+/** Fetches a `RewardAccrual` account, throwing when it does not exist or only holds lamports. */
 declare function fetchRewardAccrual<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<RewardAccrual, TAddress>>;
+/**
+ * Fetches a `RewardAccrual` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeRewardAccrual} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeRewardAccrual<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<RewardAccrual, TAddress>>;
+/** Fetches `RewardAccrual` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllRewardAccrual(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<RewardAccrual>[]>;
+/**
+ * Fetches `RewardAccrual` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeRewardAccrual} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeRewardAccrual(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<RewardAccrual>[]>;
 declare function getRewardAccrualSize(): number;
 //#endregion
@@ -1714,8 +1889,8 @@ interface CreateTokenParams {
   name: string;
   symbol: string;
   uri: string;
-  /** An enabled nexus auth platform (e.g. "wallet"), max 32 bytes; hashed with
-   *  `creatorId` into the creator fee identity. Unrelated to `platformConfig`. */
+  /** An enabled nexus auth platform, for example "wallet", of at most 32 bytes. It is hashed
+   *  with `creatorId` into the creator fee identity. It is not `platformConfig`. */
   creatorPlatform: string;
   creatorId: string;
   partner: PartnerInput;
@@ -1728,11 +1903,11 @@ interface CreateAndBuyParams extends CreateTokenParams {
   slippageBps: number;
   initialVirtualQuoteReserves: bigint;
   initialVirtualBaseReserves: bigint;
-  /** `globalConfig.initialRealBaseReserves`: caps the appended buy. */
+  /** `globalConfig.initialRealBaseReserves`. Caps the buy. */
   initialRealBaseReserves: bigint;
-  /** Quote mint's Token-2022 schedule for the launch epoch; without it `minAmountOut`
-   *  ignores the mint's cut, and a cut above `slippageBps` can revert the buy. No
-   *  `baseFee`: this transaction creates the base mint without the extension. */
+  /** The quote mint's transfer fee for the epoch the launch lands in. Without it, `minAmountOut`
+   *  ignores the mint's cut, and a cut above `slippageBps` can make the buy fail. The new base
+   *  mint has no transfer fee. */
   quoteFee?: MintFee;
 }
 declare function buildCreateTokenInstruction(params: CreateTokenParams): Promise<Instruction>;
@@ -2901,7 +3076,7 @@ interface MigrateParams {
   caller: TransactionSigner;
   baseMint: Address;
   quoteMint: Address;
-  /** `bondingCurve.creatorFeeConfig`; `migrate` rejects any other address. */
+  /** `bondingCurve.creatorFeeConfig`. `migrate` rejects any other address. */
   creatorFeeConfig: Address;
   quoteTokenProgram: Address;
 }
@@ -2921,7 +3096,7 @@ interface LaunchpadTradeParams {
   partner: PartnerInput;
   platformConfig: Address;
   quoteTokenProgram: Address;
-  /** Token-2022 schedule for the epoch the trade lands in; stale or missing skews the slippage bounds. */
+  /** The quote mint's transfer fee for the epoch the trade lands in. A missing or old fee gives wrong slippage bounds. */
   quoteFee?: MintFee;
   baseFee?: MintFee;
   /** {@inheritDoc LaunchpadInstructionParams.userQuoteAccount} */
@@ -2940,15 +3115,15 @@ interface LaunchpadInstructionParams {
   partner: PartnerInput;
   platformConfig: Address;
   quoteTokenProgram: Address;
-  /** Any user-owned quote-mint account. Defaults to the ATA, created mid-trade
-   *  if missing (payer funds rent), which only rescues a sell. For WSOL,
-   *  a throwaway `createAccountWithSeed` account is cheaper. */
+  /** Any quote-mint token account that `user` owns. Defaults to the user's ATA.
+   *  The program creates a missing ATA, and `payer` pays the rent. */
   userQuoteAccount?: Address;
-  /** Any user-owned base-mint account. Defaults to the ATA, created mid-trade
-   *  if missing (payer funds rent), which only rescues a buy. */
+  /** Any base-mint token account that `user` owns. Defaults to the user's ATA.
+   *  The program creates a missing ATA, and `payer` pays the rent. */
   userBaseAccount?: Address;
 }
-/** `baseAmountOut` is net to the buyer: the program reads `amount` as `base_to_user`. */
+/** `baseAmountOut` is the base the buyer receives, after the base mint's transfer fee.
+ *  The buy is capped at the curve's supply left. Read the result from `quote.baseToUser`. */
 declare function buyExactOut(params: LaunchpadBuyParams & {
   baseAmountOut: bigint;
 }): Promise<{
@@ -2967,7 +3142,7 @@ declare function sellExactIn(params: LaunchpadTradeParams & {
   instruction: Instruction;
   quote: SellQuote;
 }>;
-/** `quoteAmountOut` is net to the seller: the program reads `amount` as `quote_to_user`. */
+/** `quoteAmountOut` is the quote the seller receives, after the quote mint's transfer fee. */
 declare function sellExactOut(params: LaunchpadTradeParams & {
   quoteAmountOut: bigint;
 }): Promise<{
@@ -2990,7 +3165,7 @@ declare function buildSellExactOutInstruction(params: LaunchpadInstructionParams
   amountOut: bigint;
   maxAmountIn: bigint;
 }): Promise<Instruction>;
-/** Percent of the curve's real base sold (0-100); 100 is the migration threshold. */
+/** Returns the percent of the curve's real base sold, from 0 to 100. At 100 the curve can migrate. */
 declare function calculateBondingCurveProgress(params: {
   realBaseReserves: bigint;
   initialRealBase: bigint;
@@ -3001,7 +3176,8 @@ declare namespace index_d_exports$1 {
 declare namespace fee_decay_d_exports {
   export { calculateFeeDecayPremium };
 }
-/** Premium in bps, rounded up. */
+/** Returns the fee decay premium in bps, rounded up. The premium falls quadratically from
+ *  `decayStartBps - standardFeeBps` at creation to 0 after `decaySeconds`. */
 declare function calculateFeeDecayPremium(params: {
   currentTimestamp: bigint;
   createdAtTimestamp: bigint;
@@ -3023,10 +3199,12 @@ interface FeeSplit {
   protocol: bigint;
   lp: bigint;
   creator: bigint;
-  /** Decay share already included in `protocol`, not a separate payout. */
+  /** The decay premium share. `protocol` includes it. It is not a separate payout. */
   sniper: bigint;
 }
-/** LP/creator round down; protocol absorbs the decay premium and all remainders. */
+/** Splits `feeAmount` into protocol, LP and creator shares. LP and creator round down. Protocol gets
+ *  the decay premium and all remainders. Throws `RangeError` on a negative or non-integer input,
+ *  a zero total bps, or `protocolBps + lpBps` above `baseTotalBps`. */
 declare function splitFeeAmount(args: FeeSplitArgs): FeeSplit;
 declare namespace index_d_exports$2 {
   export { amm_d_exports as amm, fee_decay_d_exports as feeDecay, fees_d_exports as fees };
@@ -3054,11 +3232,39 @@ declare function getAltRegistryEncoder(): FixedSizeEncoder<AltRegistryArgs>;
 declare function getAltRegistryDecoder(): FixedSizeDecoder<AltRegistry>;
 /** Gets the codec for {@link AltRegistry} account data. */
 declare function getAltRegistryCodec(): FixedSizeCodec<AltRegistryArgs, AltRegistry>;
+/**
+ * Decodes a `AltRegistry` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeAltRegistry}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeAltRegistry<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<AltRegistry, TAddress>;
+/**
+ * Decodes a `AltRegistry` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeAltRegistry}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeAltRegistry<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<AltRegistry, TAddress>;
+/** Fetches a `AltRegistry` account, throwing when it does not exist or only holds lamports. */
 declare function fetchAltRegistry<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<AltRegistry, TAddress>>;
+/**
+ * Fetches a `AltRegistry` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeAltRegistry} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeAltRegistry<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<AltRegistry, TAddress>>;
+/** Fetches `AltRegistry` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllAltRegistry(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<AltRegistry>[]>;
+/**
+ * Fetches `AltRegistry` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeAltRegistry} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeAltRegistry(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<AltRegistry>[]>;
 declare function getAltRegistrySize(): number;
 //#endregion
@@ -3088,11 +3294,39 @@ declare function getCreatorFeeConfigEncoder(): FixedSizeEncoder<CreatorFeeConfig
 declare function getCreatorFeeConfigDecoder(): FixedSizeDecoder<CreatorFeeConfig>;
 /** Gets the codec for {@link CreatorFeeConfig} account data. */
 declare function getCreatorFeeConfigCodec(): FixedSizeCodec<CreatorFeeConfigArgs, CreatorFeeConfig>;
+/**
+ * Decodes a `CreatorFeeConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeCreatorFeeConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeCreatorFeeConfig<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<CreatorFeeConfig, TAddress>;
+/**
+ * Decodes a `CreatorFeeConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeCreatorFeeConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeCreatorFeeConfig<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<CreatorFeeConfig, TAddress>;
+/** Fetches a `CreatorFeeConfig` account, throwing when it does not exist or only holds lamports. */
 declare function fetchCreatorFeeConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<CreatorFeeConfig, TAddress>>;
+/**
+ * Fetches a `CreatorFeeConfig` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeCreatorFeeConfig} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeCreatorFeeConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<CreatorFeeConfig, TAddress>>;
+/** Fetches `CreatorFeeConfig` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllCreatorFeeConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<CreatorFeeConfig>[]>;
+/**
+ * Fetches `CreatorFeeConfig` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeCreatorFeeConfig} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeCreatorFeeConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<CreatorFeeConfig>[]>;
 declare function getCreatorFeeConfigSize(): number;
 //#endregion
@@ -3206,11 +3440,39 @@ declare function getFeePresetEncoder(): Encoder<FeePresetArgs>;
 declare function getFeePresetDecoder(): Decoder<FeePreset>;
 /** Gets the codec for {@link FeePreset} account data. */
 declare function getFeePresetCodec(): Codec<FeePresetArgs, FeePreset>;
+/**
+ * Decodes a `FeePreset` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeFeePreset}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeFeePreset<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<FeePreset, TAddress>;
+/**
+ * Decodes a `FeePreset` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeFeePreset}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeFeePreset<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<FeePreset, TAddress>;
+/** Fetches a `FeePreset` account, throwing when it does not exist or only holds lamports. */
 declare function fetchFeePreset<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<FeePreset, TAddress>>;
+/**
+ * Fetches a `FeePreset` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeFeePreset} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeFeePreset<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<FeePreset, TAddress>>;
+/** Fetches `FeePreset` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllFeePreset(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<FeePreset>[]>;
+/**
+ * Fetches `FeePreset` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeFeePreset} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeFeePreset(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<FeePreset>[]>;
 //#endregion
 //#region src/nexus/generated/accounts/globalConfig.d.ts
@@ -3239,11 +3501,39 @@ declare function getGlobalConfigEncoder(): Encoder<GlobalConfigArgs>;
 declare function getGlobalConfigDecoder(): Decoder<GlobalConfig>;
 /** Gets the codec for {@link GlobalConfig} account data. */
 declare function getGlobalConfigCodec(): Codec<GlobalConfigArgs, GlobalConfig>;
+/**
+ * Decodes a `GlobalConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeGlobalConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeGlobalConfig<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<GlobalConfig, TAddress>;
+/**
+ * Decodes a `GlobalConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeGlobalConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeGlobalConfig<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<GlobalConfig, TAddress>;
+/** Fetches a `GlobalConfig` account, throwing when it does not exist or only holds lamports. */
 declare function fetchGlobalConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<GlobalConfig, TAddress>>;
+/**
+ * Fetches a `GlobalConfig` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeGlobalConfig} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeGlobalConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<GlobalConfig, TAddress>>;
+/** Fetches `GlobalConfig` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllGlobalConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<GlobalConfig>[]>;
+/**
+ * Fetches `GlobalConfig` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeGlobalConfig} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeGlobalConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<GlobalConfig>[]>;
 //#endregion
 //#region src/nexus/generated/accounts/partnerConfig.d.ts
@@ -3278,11 +3568,39 @@ declare function getPartnerConfigEncoder(): FixedSizeEncoder<PartnerConfigArgs>;
 declare function getPartnerConfigDecoder(): FixedSizeDecoder<PartnerConfig>;
 /** Gets the codec for {@link PartnerConfig} account data. */
 declare function getPartnerConfigCodec(): FixedSizeCodec<PartnerConfigArgs, PartnerConfig>;
+/**
+ * Decodes a `PartnerConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybePartnerConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodePartnerConfig<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<PartnerConfig, TAddress>;
+/**
+ * Decodes a `PartnerConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybePartnerConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodePartnerConfig<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<PartnerConfig, TAddress>;
+/** Fetches a `PartnerConfig` account, throwing when it does not exist or only holds lamports. */
 declare function fetchPartnerConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<PartnerConfig, TAddress>>;
+/**
+ * Fetches a `PartnerConfig` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodePartnerConfig} throws for a lamports-only account instead.
+ */
 declare function fetchMaybePartnerConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<PartnerConfig, TAddress>>;
+/** Fetches `PartnerConfig` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllPartnerConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<PartnerConfig>[]>;
+/**
+ * Fetches `PartnerConfig` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodePartnerConfig} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybePartnerConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<PartnerConfig>[]>;
 declare function getPartnerConfigSize(): number;
 //#endregion
@@ -3318,11 +3636,39 @@ declare function getPartnerMetadataEncoder(): Encoder<PartnerMetadataArgs>;
 declare function getPartnerMetadataDecoder(): Decoder<PartnerMetadata>;
 /** Gets the codec for {@link PartnerMetadata} account data. */
 declare function getPartnerMetadataCodec(): Codec<PartnerMetadataArgs, PartnerMetadata>;
+/**
+ * Decodes a `PartnerMetadata` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybePartnerMetadata}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodePartnerMetadata<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<PartnerMetadata, TAddress>;
+/**
+ * Decodes a `PartnerMetadata` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybePartnerMetadata}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodePartnerMetadata<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<PartnerMetadata, TAddress>;
+/** Fetches a `PartnerMetadata` account, throwing when it does not exist or only holds lamports. */
 declare function fetchPartnerMetadata<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<PartnerMetadata, TAddress>>;
+/**
+ * Fetches a `PartnerMetadata` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodePartnerMetadata} throws for a lamports-only account instead.
+ */
 declare function fetchMaybePartnerMetadata<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<PartnerMetadata, TAddress>>;
+/** Fetches `PartnerMetadata` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllPartnerMetadata(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<PartnerMetadata>[]>;
+/**
+ * Fetches `PartnerMetadata` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodePartnerMetadata} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybePartnerMetadata(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<PartnerMetadata>[]>;
 //#endregion
 //#region src/nexus/generated/accounts/rewardState.d.ts
@@ -3361,11 +3707,39 @@ declare function getRewardStateEncoder(): FixedSizeEncoder<RewardStateArgs>;
 declare function getRewardStateDecoder(): FixedSizeDecoder<RewardState>;
 /** Gets the codec for {@link RewardState} account data. */
 declare function getRewardStateCodec(): FixedSizeCodec<RewardStateArgs, RewardState>;
+/**
+ * Decodes a `RewardState` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeRewardState}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeRewardState<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<RewardState, TAddress>;
+/**
+ * Decodes a `RewardState` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeRewardState}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeRewardState<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<RewardState, TAddress>;
+/** Fetches a `RewardState` account, throwing when it does not exist or only holds lamports. */
 declare function fetchRewardState<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<RewardState, TAddress>>;
+/**
+ * Fetches a `RewardState` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeRewardState} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeRewardState<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<RewardState, TAddress>>;
+/** Fetches `RewardState` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllRewardState(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<RewardState>[]>;
+/**
+ * Fetches `RewardState` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeRewardState} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeRewardState(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<RewardState>[]>;
 declare function getRewardStateSize(): number;
 //#endregion
@@ -3409,11 +3783,39 @@ declare function getStakingConfigEncoder(): FixedSizeEncoder<StakingConfigArgs>;
 declare function getStakingConfigDecoder(): FixedSizeDecoder<StakingConfig>;
 /** Gets the codec for {@link StakingConfig} account data. */
 declare function getStakingConfigCodec(): FixedSizeCodec<StakingConfigArgs, StakingConfig>;
+/**
+ * Decodes a `StakingConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeStakingConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeStakingConfig<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<StakingConfig, TAddress>;
+/**
+ * Decodes a `StakingConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeStakingConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeStakingConfig<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<StakingConfig, TAddress>;
+/** Fetches a `StakingConfig` account, throwing when it does not exist or only holds lamports. */
 declare function fetchStakingConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<StakingConfig, TAddress>>;
+/**
+ * Fetches a `StakingConfig` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeStakingConfig} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeStakingConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<StakingConfig, TAddress>>;
+/** Fetches `StakingConfig` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllStakingConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<StakingConfig>[]>;
+/**
+ * Fetches `StakingConfig` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeStakingConfig} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeStakingConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<StakingConfig>[]>;
 declare function getStakingConfigSize(): number;
 //#endregion
@@ -3453,11 +3855,39 @@ declare function getUserRewardDebtEncoder(): FixedSizeEncoder<UserRewardDebtArgs
 declare function getUserRewardDebtDecoder(): FixedSizeDecoder<UserRewardDebt>;
 /** Gets the codec for {@link UserRewardDebt} account data. */
 declare function getUserRewardDebtCodec(): FixedSizeCodec<UserRewardDebtArgs, UserRewardDebt>;
+/**
+ * Decodes a `UserRewardDebt` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeUserRewardDebt}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeUserRewardDebt<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<UserRewardDebt, TAddress>;
+/**
+ * Decodes a `UserRewardDebt` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeUserRewardDebt}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeUserRewardDebt<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<UserRewardDebt, TAddress>;
+/** Fetches a `UserRewardDebt` account, throwing when it does not exist or only holds lamports. */
 declare function fetchUserRewardDebt<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<UserRewardDebt, TAddress>>;
+/**
+ * Fetches a `UserRewardDebt` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeUserRewardDebt} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeUserRewardDebt<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<UserRewardDebt, TAddress>>;
+/** Fetches `UserRewardDebt` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllUserRewardDebt(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<UserRewardDebt>[]>;
+/**
+ * Fetches `UserRewardDebt` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeUserRewardDebt} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeUserRewardDebt(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<UserRewardDebt>[]>;
 declare function getUserRewardDebtSize(): number;
 //#endregion
@@ -3491,11 +3921,39 @@ declare function getUserStakePositionEncoder(): FixedSizeEncoder<UserStakePositi
 declare function getUserStakePositionDecoder(): FixedSizeDecoder<UserStakePosition>;
 /** Gets the codec for {@link UserStakePosition} account data. */
 declare function getUserStakePositionCodec(): FixedSizeCodec<UserStakePositionArgs, UserStakePosition>;
+/**
+ * Decodes a `UserStakePosition` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeUserStakePosition}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeUserStakePosition<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<UserStakePosition, TAddress>;
+/**
+ * Decodes a `UserStakePosition` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeUserStakePosition}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 declare function decodeUserStakePosition<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<UserStakePosition, TAddress>;
+/** Fetches a `UserStakePosition` account, throwing when it does not exist or only holds lamports. */
 declare function fetchUserStakePosition<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<UserStakePosition, TAddress>>;
+/**
+ * Fetches a `UserStakePosition` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeUserStakePosition} throws for a lamports-only account instead.
+ */
 declare function fetchMaybeUserStakePosition<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<UserStakePosition, TAddress>>;
+/** Fetches `UserStakePosition` accounts, throwing when any does not exist or only holds lamports. */
 declare function fetchAllUserStakePosition(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<UserStakePosition>[]>;
+/**
+ * Fetches `UserStakePosition` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeUserStakePosition} throws for a lamports-only account instead.
+ */
 declare function fetchAllMaybeUserStakePosition(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<UserStakePosition>[]>;
 declare function getUserStakePositionSize(): number;
 declare namespace index_d_exports$10 {
@@ -4245,40 +4703,43 @@ declare namespace index_d_exports$5 {
 declare namespace fee_helpers_d_exports {
   export { effectiveFeeBps, fetchPartnerFees };
 }
-/** Throws if the pair is unregistered. Take `platformConfig` from the market being priced: a partner's fees differ per platform. */
+/** Fetches the `PartnerConfig` of `partner` on `platformConfig`. Throws if it does not exist.
+ *  Use the `platformConfig` of the market you price. A partner's fees differ per platform. */
 declare function fetchPartnerFees(rpc: Rpc<GetAccountInfoApi>, partner: Address, platformConfig: Address): Promise<PartnerConfig>;
-/** The `feeBps` a trade pays: the standard rate plus the decay premium from the market's
- *  `createdAt`. Pass `fees.launchpad` for a curve, `fees.dex` for a pool; times in unix seconds. */
+/** Returns the `feeBps` a trade pays: the standard rate plus the decay premium. `schedule` is the
+ *  `PartnerConfig`'s `launchpad` for a curve or `dex` for a pool. `createdAt` is the curve's or
+ *  pool's `createdAt`. Both times are in unix seconds. */
 declare function effectiveFeeBps(schedule: LaunchpadFees | DexFees, createdAt: bigint, now: bigint): number;
 declare namespace staking_d_exports {
   export { ClaimRewardsParams, PendingReward, PrepareStakingParams, RewardMintRpc, RewardMintSource, SettleParams, StakeParams, UnstakeParams, WithdrawFeesAccounts, buildClaimRewardsInstructions, buildSettleInstructions, buildStakeInstruction, buildStakingPreflightInstructions, buildUnstakeInstruction, buildWithdrawFeesAccounts, fetchMissingUserRewardDebts, fetchPendingRewards, fetchSendMint, fetchStakingConfigData, fetchUserStakePositionData, getRewardMints, isFullySettled, isStakingMintBound };
 }
-/** `getProgramAccounts` is optional: many providers restrict it and LiteSVM lacks it, so pass `rewardMints` there. */
+/** An RPC with `getAccountInfo` and, optionally, `getProgramAccounts`. Without `getProgramAccounts`, pass `rewardMints`. */
 type RewardMintRpc = Rpc<GetAccountInfoApi> & Partial<Rpc<GetProgramAccountsApi>>;
-/** Registered reward mints, sorted by address. Includes disabled mints: their accrued balance is
- *  still owed and the settle gate still counts them. Throws when the sweep disagrees with
- *  `StakingConfig.rewardCount` rather than settle a short list. */
+/** Returns every registered reward mint, disabled mints included, sorted by address.
+ *  Throws if the count differs from `StakingConfig.rewardCount`. */
 declare function getRewardMints(rpc: Rpc<GetAccountInfoApi> & Rpc<GetProgramAccountsApi>): Promise<readonly Address[]>;
 type RewardMintSource = readonly Address[] | RewardMintRpc;
 interface SettleParams {
-  /** `settle` is permissionless: the user does not sign. */
+  /** Does not sign. `settle` is permissionless. */
   user: Address;
   payer: TransactionSigner;
   stakingMint: Address;
 }
-/** One idempotent `settle` per mint; a partial mint list leaves `stake` and `unstake` failing `RewardsNotSettled`. */
+/** Builds one `settle` per reward mint. `source` is the mint list, or an RPC to read it from.
+ *  `settle` is idempotent. With a partial list, `stake` and `unstake` fail with `RewardsNotSettled`. */
 declare function buildSettleInstructions(source: RewardMintSource, params: SettleParams): Promise<Instruction[]>;
 declare function fetchMissingUserRewardDebts(rpc: RewardMintRpc & Rpc<GetMultipleAccountsApi>, user: Address, stakingMint: Address, knownRewardMints?: readonly Address[]): Promise<Address[]>;
 interface PrepareStakingParams {
   user: Address;
   payer: TransactionSigner;
   stakingMint: Address;
-  /** Must be the full registry when supplied; a subset leaves `stake` and `unstake` blocked. */
+  /** If given, must hold every registered mint. With a subset, `stake` and `unstake` fail. */
   rewardMints?: readonly Address[];
 }
-/** Opens missing `UserRewardDebt`s, then settles every mint; the user never signs, so the stake or unstake after is one wallet prompt. */
+/** Builds a `create_user_reward_debt` for each missing `UserRewardDebt`, then a `settle` for every
+ *  reward mint. The user does not sign these instructions. */
 declare function buildStakingPreflightInstructions(rpc: RewardMintRpc & Rpc<GetMultipleAccountsApi>, params: PrepareStakingParams): Promise<Instruction[]>;
-/** True once `stake` and `unstake` will pass the `settledCount == rewardCount` gate. */
+/** Returns true if `stake` and `unstake` pass the `settledCount == rewardCount` check. */
 declare function isFullySettled(rpc: Rpc<GetAccountInfoApi>, user: Address, stakingMint: Address): Promise<boolean>;
 interface StakeParams {
   user: TransactionSigner;
@@ -4286,7 +4747,8 @@ interface StakeParams {
   stakingMint: Address;
   amount: bigint;
 }
-/** Fails `RewardsNotSettled` until every mint is settled at the current `stakeVersion`; run `buildStakingPreflightInstructions` first. */
+/** The instruction fails with `RewardsNotSettled` until every mint is settled at the current
+ *  `stakeVersion`. Run `buildStakingPreflightInstructions` first. */
 declare function buildStakeInstruction(params: StakeParams): Promise<Instruction>;
 interface UnstakeParams {
   user: TransactionSigner;
@@ -4294,18 +4756,19 @@ interface UnstakeParams {
   stakingMint: Address;
   amount: bigint;
 }
-/** Settle immediately before via `buildStakingPreflightInstructions`: the gate passes on a stale settle,
- *  and the window since it is then paid at the post-unstake amount, forfeiting accrual. */
+/** Run `buildStakingPreflightInstructions` immediately before. The check also passes on an older
+ *  settle. Rewards since that settle then accrue on the smaller post-unstake amount, and the
+ *  difference is lost. */
 declare function buildUnstakeInstruction(params: UnstakeParams): Promise<Instruction>;
 interface ClaimRewardsParams {
   user: TransactionSigner;
   payer?: TransactionSigner;
   stakingMint: Address;
-  /** Defaults to every registered mint; each claim settles its own mint, so a subset needs no preflight. */
+  /** Defaults to every registered mint. A subset needs no preflight: each `claim` settles its own mint. */
   rewardMints?: readonly Address[];
 }
-/** One `claim` per mint, preceded by `create_user_reward_debt` where the debt is missing:
- *  `Claim` requires the account to exist, so one missing debt fails the whole transaction. */
+/** Builds one `claim` per reward mint. A `create_user_reward_debt` comes before each `claim` whose
+ *  `UserRewardDebt` is missing: `claim` fails without it. Throws if a mint has no `RewardState`. */
 declare function buildClaimRewardsInstructions(rpc: RewardMintRpc & Rpc<GetMultipleAccountsApi>, params: ClaimRewardsParams): Promise<Instruction[]>;
 interface WithdrawFeesAccounts {
   rewardState: Address;
@@ -4314,28 +4777,29 @@ interface WithdrawFeesAccounts {
   destinationTokenAccount: Address;
   tokenProgram: Address;
 }
-/** Accounts for one mint's `withdraw_fees`; call once per mint. */
+/** Returns the accounts of `withdraw_fees` for one reward mint. Without `tokenProgram`, reads it
+ *  from the mint account. Throws if that account does not exist. */
 declare function buildWithdrawFeesAccounts(rpc: Rpc<GetAccountInfoApi>, params: {
   rewardMint: Address;
-  /** Wallet, not token account: its ATA is derived. */
+  /** A wallet, not a token account. The SDK derives its ATA. */
   destination: Address;
   tokenProgram?: Address;
 }): Promise<WithdrawFeesAccounts>;
 declare function fetchStakingConfigData(rpc: Rpc<GetAccountInfoApi>): Promise<StakingConfig>;
 declare function fetchUserStakePositionData(rpc: Rpc<GetAccountInfoApi>, user: Address, stakingMint: Address): Promise<UserStakePosition | null>;
-/** Unbound reads as `Pubkey::default()` (the system program address), which `bind_staking_mint`
- *  can never store: it requires a token mint. */
+/** Returns false for the system program address, the value of an unbound staking mint. */
 declare function isStakingMintBound(stakingMint: Address): boolean;
-/** The staking mint is immutable once bound, so this result is safe to cache. */
+/** Returns the staking mint. Throws if no staking mint is bound. A bound staking mint cannot change. */
 declare function fetchSendMint(rpc: Rpc<GetAccountInfoApi>): Promise<Address>;
 interface PendingReward {
   rewardMint: Address;
-  /** Base units of `rewardMint` debited at the vault (matches `ClaimEvent.amount`); a
-   *  `TransferFeeConfig` mint delivers less -- net it with `transferFee.fetchMintFees`. */
+  /** Amount the vault sends, in raw units of `rewardMint`. Equals `ClaimEvent.amount`. A mint with a
+   *  transfer fee delivers less. Get the fee with `transferFee.fetchMintFees`. */
   pending: bigint;
 }
-/** One entry per reward mint, in `knownRewardMints` order, else sorted by address. Each amount is in
- *  its own mint's base units, so never sum them, and is the vault's debit, not the claimant's credit. */
+/** Returns one entry per reward mint, in `knownRewardMints` order, else sorted by address. Each amount
+ *  is in the raw units of its own mint. Do not add them together. Each amount is what the vault sends,
+ *  before the mint's transfer fee. */
 declare function fetchPendingRewards(rpc: RewardMintRpc & Rpc<GetMultipleAccountsApi>, user: Address, stakingMint: Address, knownRewardMints?: readonly Address[]): Promise<PendingReward[]>;
 declare namespace index_d_exports$3 {
   export { index_d_exports$10 as accounts, index_d_exports$8 as errors, index_d_exports$9 as events, fee_helpers_d_exports as feeHelpers, index_d_exports$7 as instructions, index_d_exports$6 as pda, index_d_exports$5 as plugins, staking_d_exports as staking, index_d_exports$11 as types };
@@ -4343,9 +4807,9 @@ declare namespace index_d_exports$3 {
 declare namespace platform_d_exports {
   export { PLATFORM_SEED, findPlatformAddress };
 }
-/** A platform is only a key, with no on-chain account; it is a PDA so a platform account can later `init` at it. */
+/** Seed of the platform PDA. A platform has no on-chain account. */
 declare const PLATFORM_SEED = "platform";
-/** The name is the platform's identity: renaming one orphans every market and partner config under the old key. */
+/** Derives the platform key for `name` under the nexus program. Each name gives a different platform. */
 declare function findPlatformAddress(name: string): Promise<ProgramDerivedAddress>;
 declare namespace transfer_fee_d_exports {
   export { TransferFeeConfig, TransferFeeEntry, decodeTransferFeeConfig, fetchMintFees, mintFeeAtEpoch, transferFeeAtEpoch };
@@ -4356,50 +4820,88 @@ interface TransferFeeEntry {
   readonly basisPoints: number;
 }
 interface TransferFeeConfig {
-  /** `undefined` when the authority is unset: the schedule is frozen forever. */
+  /** `undefined` if the config has no authority. Then the schedule cannot change. */
   readonly authority: Address | undefined;
   readonly older: TransferFeeEntry;
   readonly newer: TransferFeeEntry;
 }
-/** `owner` is the account's program. `undefined` means no fee extension; anything
- *  unparseable throws `RangeError` rather than pricing a charging mint free. */
+/** Decodes the `TransferFeeConfig` extension of a mint. `owner` is the program that owns the account.
+ *  Returns `undefined` if the mint has no such extension. Throws `RangeError` if `owner` is not a
+ *  token program or `data` is not a valid mint. */
 declare function decodeTransferFeeConfig(data: Uint8Array, owner: Address): TransferFeeConfig | undefined;
-/** Mirrors SPL `get_epoch_fee`: the newer entry is live from its own epoch on. */
+/** Returns the fee for `epoch`, as SPL `get_epoch_fee` does. The newer entry applies from its own epoch on. */
 declare function transferFeeAtEpoch(config: TransferFeeConfig, epoch: bigint): MintFee;
 declare function mintFeeAtEpoch(data: Uint8Array, owner: Address, epoch: bigint): MintFee | undefined;
-/** A missing account throws, never reads as fee-free. Valid only for `epoch`, which defaults to
- *  the cluster's (a second call). */
+/** Reads the transfer fee of each mint for `epoch`. The result is valid only for that epoch.
+ *  `epoch` defaults to the current cluster epoch, read with `getEpochInfo`. A mint without a
+ *  transfer fee maps to `undefined`. Throws if a mint account is missing or does not decode. */
 declare function fetchMintFees(rpc: Rpc<GetMultipleAccountsApi & GetEpochInfoApi>, mints: readonly Address[], options?: {
   epoch?: bigint;
   commitment?: Commitment;
 }): Promise<Map<Address, MintFee | undefined>>;
 //#endregion
+//#region src/nexus/generated/shared/index.d.ts
+/**
+ * Whether an encoded account was created on-chain, rather than merely sent lamports.
+ *
+ * Anyone can send lamports to an address before its account is created, which leaves it on-chain,
+ * owned by the System Program, with no data. This returns `false` for that shape, as it does for an
+ * account that does not exist. Any other existing account counts as created, whoever owns it; the
+ * `decode*` functions still check the owner.
+ *
+ * The generated `fetchMaybe*` and `fetchAllMaybe*` helpers apply this rule themselves. Apply it to
+ * accounts you fetch or receive another way (subscriptions, batch loaders, caches) before passing
+ * them to a `decode*` function, which throws for a lamports-only account: an account passed to it as
+ * existing must never come back as the non-existing variant typed as an `Account`.
+ *
+ * Only a `true` result narrows the type. A lamports-only account is still `exists: true` at runtime,
+ * so a `false` result leaves the type unchanged instead of narrowing it to the non-existing variant.
+ * The `uncreated` property in the narrowed type is never present; it exists only to prevent that.
+ *
+ * @example
+ * ```ts
+ * const maybeAccount = decodeMyAccount(
+ *   accountIsCreated(encodedAccount) ? encodedAccount : { address: encodedAccount.address, exists: false },
+ * );
+ * ```
+ */
+declare function accountIsCreated<TAccount extends EncodedAccount | MaybeEncodedAccount>(account: TAccount): account is Exclude<TAccount, {
+  readonly exists: false;
+}> & {
+  readonly uncreated?: never;
+};
+//#endregion
 //#region src/utils/creator-hash.d.ts
-/** SHA-256 of the LE-u32-length-prefixed platform and id. Frozen: it seeds live PDAs. */
+/** Returns the SHA-256 of `creatorPlatform` and `creatorId`, each prefixed with its byte length as a
+ *  little-endian u32. Throws `RangeError` if `creatorPlatform` is more than 32 bytes. */
 declare function creatorHashFromId(creatorPlatform: string, creatorId: string): Promise<Address>;
-/** NUL-pads `text` to `length` bytes, the on-chain `CreatorFeeConfig.platformId` form; throws RangeError if longer. */
+/** Pads `text` with NUL bytes to `length` bytes, the form of `CreatorFeeConfig.platformId`.
+ *  Throws `RangeError` if `text` is longer. */
 declare function encodeCreatorId(text: string, length: number): Uint8Array;
-/** Strips NUL padding. Pass this, never the padded array, to {@link creatorHashFromId}: the hash is length-prefixed. */
+/** Removes the trailing NUL bytes and decodes the rest as UTF-8. Pass the result, not the padded
+ *  bytes, to {@link creatorHashFromId}. */
 declare function decodeCreatorId(bytes: ReadonlyUint8Array): string;
 //#endregion
 //#region src/utils/mint-info.d.ts
 interface QuoteMintInfo {
   mint: Address;
-  /** Immutable: safe to cache. */
+  /** Cannot change after the mint is created. */
   decimals: number;
   /** The account's owner: `TOKEN_PROGRAM_ADDRESS` or `TOKEN_2022_PROGRAM_ADDRESS`. */
   tokenProgram: Address;
 }
-/** Throws when the mint does not exist or is not owned by a token program. */
+/** Reads the decimals and token program of `mint`. Throws if the account does not exist, a token
+ *  program does not own it, or it is too short for a mint. */
 declare function fetchQuoteMintInfo(rpc: Rpc<GetAccountInfoApi>, mint: Address, commitment?: Commitment): Promise<QuoteMintInfo>;
-/** One round trip per 100 mints; results follow `mints` order. */
+/** Reads the decimals and token program of each mint. Results follow `mints` order. Throws as
+ *  {@link fetchQuoteMintInfo} does. */
 declare function fetchQuoteMintInfos(rpc: Rpc<GetMultipleAccountsApi>, mints: readonly Address[], commitment?: Commitment): Promise<QuoteMintInfo[]>;
 //#endregion
 //#region src/utils/pda.d.ts
-/** Seed order is [wallet, tokenProgram, mint], not the parameter order. */
+/** Derives the associated token account of `wallet` for `mint` under `tokenProgram`. */
 declare function findAssociatedTokenPda(wallet: Address, mint: Address, tokenProgram?: Address): Promise<ProgramDerivedAddress>;
 declare namespace index_d_exports$4 {
-  export { PartnerInput, QuoteMintInfo, creatorHashFromId, decodeCreatorId, encodeCreatorId, fetchQuoteMintInfo, fetchQuoteMintInfos, findAssociatedTokenPda };
+  export { PartnerInput, QuoteMintInfo, accountIsCreated, creatorHashFromId, decodeCreatorId, encodeCreatorId, fetchQuoteMintInfo, fetchQuoteMintInfos, findAssociatedTokenPda };
 }
 //#endregion
 export { constants_d_exports as constants, index_d_exports as dex, index_d_exports$1 as launchpad, index_d_exports$2 as math, index_d_exports$3 as nexus, platform_d_exports as platform, transfer_fee_d_exports as transferFee, index_d_exports$4 as utils };