@send-fun/sdk 1.1.0 → 1.2.0

package/dist/index.mjs

@@ -18,22 +18,55 @@ var constants_exports = /* @__PURE__ */ __exportAll({
 	SEND_DEX_PROGRAM_ADDRESS: () => SEND_DEX_PROGRAM_ADDRESS,
 	SEND_LAUNCHPAD_PROGRAM_ADDRESS: () => SEND_LAUNCHPAD_PROGRAM_ADDRESS,
 	SEND_NEXUS_PROGRAM_ADDRESS: () => SEND_NEXUS_PROGRAM_ADDRESS,
-	SYSTEM_PROGRAM_ADDRESS: () => SYSTEM_PROGRAM_ADDRESS,
+	SYSTEM_PROGRAM_ADDRESS: () => SYSTEM_PROGRAM_ADDRESS$3,
 	TOKEN_2022_PROGRAM_ADDRESS: () => TOKEN_2022_PROGRAM_ADDRESS,
 	TOKEN_DECIMALS: () => 6,
 	TOKEN_PROGRAM_ADDRESS: () => TOKEN_PROGRAM_ADDRESS,
 	USDC_MINT: () => USDC_MINT,
 	WSOL_MINT: () => WSOL_MINT
 });
-const SYSTEM_PROGRAM_ADDRESS = address("11111111111111111111111111111111");
+const SYSTEM_PROGRAM_ADDRESS$3 = address("11111111111111111111111111111111");
 const TOKEN_PROGRAM_ADDRESS = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
 const TOKEN_2022_PROGRAM_ADDRESS = address("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
 const ASSOCIATED_TOKEN_PROGRAM_ADDRESS = address("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
 const WSOL_MINT = address("So11111111111111111111111111111111111111112");
 const USDC_MINT = address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
-const DEFAULT_PARTNER = SYSTEM_PROGRAM_ADDRESS;
+const DEFAULT_PARTNER = SYSTEM_PROGRAM_ADDRESS$3;
 const PYTH_SOL_USD_PRICE_ACCOUNT = address("7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE");
 //#endregion
+//#region src/dex/generated/shared/index.ts
+/** The System Program, which owns every address nobody has created an account at yet. */
+const SYSTEM_PROGRAM_ADDRESS$2 = "11111111111111111111111111111111";
+/**
+* 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 },
+* );
+* ```
+*/
+function accountIsCreated$2(account) {
+	const maybeAccount = account;
+	if ("exists" in maybeAccount && !maybeAccount.exists) return false;
+	return !(maybeAccount.programAddress === SYSTEM_PROGRAM_ADDRESS$2 && maybeAccount.data.length === 0);
+}
+//#endregion
 //#region src/dex/generated/accounts/globalConfig.ts
 /**
 * This code was AUTOGENERATED using the Codama library.
@@ -101,21 +134,40 @@ function decodeGlobalConfig$2(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getGlobalConfigDecoder$2());
 }
+/** Fetches a `GlobalConfig` account, throwing when it does not exist or only holds lamports. */
 async function fetchGlobalConfig$2(rpc, address, config) {
 	const maybeAccount = await fetchMaybeGlobalConfig$2(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeGlobalConfig$2(rpc, address, config) {
-	return decodeGlobalConfig$2(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeGlobalConfig$2(accountIsCreated$2(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `GlobalConfig` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllGlobalConfig$2(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeGlobalConfig$2(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeGlobalConfig$2(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeGlobalConfig$2(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeGlobalConfig$2(accountIsCreated$2(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getGlobalConfigSize$1() {
 	return 139;
@@ -276,21 +328,40 @@ function decodePool(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getPoolDecoder());
 }
+/** Fetches a `Pool` account, throwing when it does not exist or only holds lamports. */
 async function fetchPool(rpc, address, config) {
 	const maybeAccount = await fetchMaybePool(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybePool(rpc, address, config) {
-	return decodePool(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodePool(accountIsCreated$2(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `Pool` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllPool(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybePool(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybePool(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodePool(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodePool(accountIsCreated$2(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getPoolSize() {
 	return 389;
@@ -363,21 +434,40 @@ function decodeRewardAccrual$1(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getRewardAccrualDecoder$1());
 }
+/** Fetches a `RewardAccrual` account, throwing when it does not exist or only holds lamports. */
 async function fetchRewardAccrual$1(rpc, address, config) {
 	const maybeAccount = await fetchMaybeRewardAccrual$1(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeRewardAccrual$1(rpc, address, config) {
-	return decodeRewardAccrual$1(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeRewardAccrual$1(accountIsCreated$2(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `RewardAccrual` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllRewardAccrual$1(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeRewardAccrual$1(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeRewardAccrual$1(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeRewardAccrual$1(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeRewardAccrual$1(accountIsCreated$2(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getRewardAccrualSize$1() {
 	return 130;
@@ -3437,12 +3527,11 @@ var amm_exports = /* @__PURE__ */ __exportAll({
 });
 const BPS_DIVISOR = 10000n;
 const U64_MAX = 18446744073709551615n;
-/** Each call mirrors a `u64::try_from` in the Rust twin; drop one and an oversized leg fails in the encoder. */
 function assertU64(label, value) {
 	if (value > U64_MAX) throw new RangeError(`${label}: overflows u64`);
 	return value;
 }
-/** 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. */
 var TransferFeeNotSettleableError = class extends RangeError {
 	amount;
 	mintFee;
@@ -3457,7 +3546,8 @@ function assertMintFee(fee) {
 	assertBps("MintFee", "bps", fee.bps);
 	if (fee.maximumFee < 0n || fee.maximumFee > U64_MAX) throw new RangeError("MintFee: maximumFee must fit a u64");
 }
-/** 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. */
 function feeOn(amount, fee) {
 	if (fee === void 0) return 0n;
 	assertMintFee(fee);
@@ -3465,11 +3555,11 @@ function feeOn(amount, fee) {
 	const raw = ceilDiv(amount * BigInt(fee.bps), BPS_DIVISOR);
 	return raw < fee.maximumFee ? raw : fee.maximumFee;
 }
-/** 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. */
 function amountAfterFee(amount, fee) {
 	return amount - feeOn(amount, fee);
 }
-/** Line-for-line mirror of SPL's `TransferFee::calculate_pre_fee_amount`; `undefined` when no u64 answer exists. */
+/** Matches SPL `TransferFee::calculate_pre_fee_amount`. `undefined` if the result does not fit a u64. */
 function preFeeAmount(amount, fee) {
 	const bps = BigInt(fee.bps);
 	if (bps === 0n) return amount;
@@ -3485,7 +3575,8 @@ function preFeeAmount(amount, fee) {
 	}
 	return rawPreFee > U64_MAX ? void 0 : rawPreFee;
 }
-/** 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. */
 function grossUp(amount, fee) {
 	if (fee === void 0) return amount;
 	assertMintFee(fee);
@@ -3508,7 +3599,8 @@ function sqrtBigInt(value) {
 	}
 	return x;
 }
-/** 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. */
 function calculateOutput(reserveIn, reserveOut, amountIn) {
 	if (reserveIn === 0n || reserveOut === 0n) throw new RangeError("calculateOutput: insufficient liquidity");
 	if (amountIn === 0n) throw new RangeError("calculateOutput: invalid amount");
@@ -3518,7 +3610,8 @@ function calculateOutput(reserveIn, reserveOut, amountIn) {
 	if (amountOut === 0n) throw new RangeError("calculateOutput: insufficient liquidity");
 	return assertU64("calculateOutput", amountOut);
 }
-/** 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. */
 function calculateInputForOutput(reserveIn, reserveOut, amountOut) {
 	if (reserveIn === 0n || reserveOut === 0n) throw new RangeError("calculateInputForOutput: insufficient liquidity");
 	if (amountOut === 0n || amountOut >= reserveOut) throw new RangeError("calculateInputForOutput: invalid amount");
@@ -3581,7 +3674,9 @@ function buyQuote(legs, quoteTransferFee, baseFee) {
 		quoteFromUser: legs.quoteAmount
 	};
 }
-/** 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. */
 function buyExactOut$2(params) {
 	assertBps("buyExactOut", "feeBps", params.feeBps);
 	if (params.baseAmountOut === 0n) throw new RangeError("buyExactOut: invalid amount");
@@ -3594,7 +3689,8 @@ function buyExactOut$2(params) {
 		quoteAmount: quoteFromUser
 	}, quoteFromUser - legs.quoteAmount, params.baseFee);
 }
-/** 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. */
 function buyExactIn$2(params) {
 	assertBps("buyExactIn", "feeBps", params.feeBps);
 	if (params.quoteAmountIn === 0n) throw new RangeError("buyExactIn: invalid amount");
@@ -3613,7 +3709,7 @@ function buyExactIn$2(params) {
 		quoteAmount: quoteFromUser
 	}, quoteFromUser - capped.quoteAmount, params.baseFee);
 }
-/** Guard with `calculateSlippageDown(quoteToUser, bps)`, not `quoteAmount`. */
+/** Quotes a sell of `baseAmountIn`. Guard with `calculateSlippageDown(quoteToUser, bps)`, not `quoteAmount`. */
 function sellExactIn$2(params) {
 	assertBps("sellExactIn", "feeBps", params.feeBps);
 	if (params.baseAmountIn === 0n) throw new RangeError("sellExactIn: invalid amount");
@@ -3631,7 +3727,8 @@ function sellExactIn$2(params) {
 		quoteToUser: legs.quoteAmount - quoteTransferFee
 	};
 }
-/** 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. */
 function sellExactOut$2(params) {
 	assertBps("sellExactOut", "feeBps", params.feeBps);
 	if (params.quoteAmountOut === 0n) throw new RangeError("sellExactOut: invalid amount");
@@ -3656,17 +3753,17 @@ function calculateSlippageDown(amount, slippageBps) {
 	assertBps("calculateSlippageDown", "slippageBps", slippageBps);
 	return assertU64("calculateSlippageDown", floorDiv(amount * (BPS_DIVISOR - BigInt(slippageBps)), BPS_DIVISOR));
 }
-/** Floors, as the program's `isqrt` does. */
+/** Returns `sqrt(quoteAmount * baseAmount)`, rounded down. */
 function calculateInitialLp(quoteAmount, baseAmount) {
 	return sqrtBigInt(quoteAmount * baseAmount);
 }
-/** Floating-point quote per base, for display only. */
+/** Returns the price of one base token in quote tokens, as a float. For display only. */
 function calculatePrice(params) {
 	const { quoteReserves, baseReserves, quoteDecimals, baseDecimals } = params;
 	if (baseReserves === 0n) return 0;
 	return Number(quoteReserves) / Number(baseReserves) * 10 ** (baseDecimals - quoteDecimals);
 }
-/** Market cap in raw quote-token units. */
+/** Returns the market cap in raw quote units. */
 function calculateMarketCap(params) {
 	const { quoteReserves, baseReserves, baseSupply } = params;
 	if (baseReserves === 0n) return 0n;
@@ -3684,7 +3781,7 @@ var trade_exports$1 = /* @__PURE__ */ __exportAll({
 	sellExactIn: () => sellExactIn$1,
 	sellExactOut: () => sellExactOut$1
 });
-/** `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. */
 async function buyExactOut$1(params) {
 	const quote = buyExactOut$2({
 		reserveQuote: params.quoteReserves,
@@ -3742,7 +3839,7 @@ async function sellExactIn$1(params) {
 		quote
 	};
 }
-/** `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. */
 async function sellExactOut$1(params) {
 	const quote = sellExactOut$2({
 		reserveQuote: params.quoteReserves,
@@ -3816,6 +3913,39 @@ var dex_exports = /* @__PURE__ */ __exportAll({
 	types: () => types_exports$2
 });
 //#endregion
+//#region src/launchpad/generated/shared/index.ts
+/** The System Program, which owns every address nobody has created an account at yet. */
+const SYSTEM_PROGRAM_ADDRESS$1 = "11111111111111111111111111111111";
+/**
+* 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 },
+* );
+* ```
+*/
+function accountIsCreated$1(account) {
+	const maybeAccount = account;
+	if ("exists" in maybeAccount && !maybeAccount.exists) return false;
+	return !(maybeAccount.programAddress === SYSTEM_PROGRAM_ADDRESS$1 && maybeAccount.data.length === 0);
+}
+//#endregion
 //#region src/launchpad/generated/types/bondingCurveStatus.ts
 /**
 * This code was AUTOGENERATED using the Codama library.
@@ -3981,21 +4111,40 @@ function decodeBondingCurve(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getBondingCurveDecoder());
 }
+/** Fetches a `BondingCurve` account, throwing when it does not exist or only holds lamports. */
 async function fetchBondingCurve(rpc, address, config) {
 	const maybeAccount = await fetchMaybeBondingCurve(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeBondingCurve(rpc, address, config) {
-	return decodeBondingCurve(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeBondingCurve(accountIsCreated$1(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `BondingCurve` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllBondingCurve(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeBondingCurve(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeBondingCurve(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeBondingCurve(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeBondingCurve(accountIsCreated$1(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getBondingCurveSize() {
 	return 421;
@@ -4078,21 +4227,40 @@ function decodeGlobalConfig$1(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getGlobalConfigDecoder$1());
 }
+/** Fetches a `GlobalConfig` account, throwing when it does not exist or only holds lamports. */
 async function fetchGlobalConfig$1(rpc, address, config) {
 	const maybeAccount = await fetchMaybeGlobalConfig$1(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeGlobalConfig$1(rpc, address, config) {
-	return decodeGlobalConfig$1(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeGlobalConfig$1(accountIsCreated$1(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `GlobalConfig` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllGlobalConfig$1(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeGlobalConfig$1(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeGlobalConfig$1(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeGlobalConfig$1(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeGlobalConfig$1(accountIsCreated$1(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getGlobalConfigSize() {
 	return 179;
@@ -4165,21 +4333,40 @@ function decodeRewardAccrual(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getRewardAccrualDecoder());
 }
+/** Fetches a `RewardAccrual` account, throwing when it does not exist or only holds lamports. */
 async function fetchRewardAccrual(rpc, address, config) {
 	const maybeAccount = await fetchMaybeRewardAccrual(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeRewardAccrual(rpc, address, config) {
-	return decodeRewardAccrual(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeRewardAccrual(accountIsCreated$1(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `RewardAccrual` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllRewardAccrual(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeRewardAccrual(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeRewardAccrual(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeRewardAccrual(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeRewardAccrual(accountIsCreated$1(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getRewardAccrualSize() {
 	return 130;
@@ -4503,7 +4690,8 @@ var pdas_exports$1 = /* @__PURE__ */ __exportAll({
 //#endregion
 //#region src/utils/creator-hash.ts
 const MAX_CREATOR_PLATFORM_LEN = 32;
-/** 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. */
 async function creatorHashFromId(creatorPlatform, creatorId) {
 	const encoder = new TextEncoder();
 	const platformBuf = encoder.encode(creatorPlatform);
@@ -4521,7 +4709,8 @@ async function creatorHashFromId(creatorPlatform, creatorId) {
 	const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", buf));
 	return getAddressDecoder().decode(hash);
 }
-/** 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. */
 function encodeCreatorId(text, length) {
 	const bytes = new TextEncoder().encode(text);
 	if (bytes.length > length) throw new RangeError(`text exceeds ${length} bytes (got ${bytes.length})`);
@@ -4529,7 +4718,8 @@ function encodeCreatorId(text, length) {
 	out.set(bytes, 0);
 	return out;
 }
-/** 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}. */
 function decodeCreatorId(bytes) {
 	let end = bytes.length;
 	while (end > 0 && bytes[end - 1] === 0) end -= 1;
@@ -6475,7 +6665,8 @@ var trade_exports = /* @__PURE__ */ __exportAll({
 	sellExactIn: () => sellExactIn,
 	sellExactOut: () => sellExactOut
 });
-/** `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`. */
 async function buyExactOut(params) {
 	const quote = buyExactOut$2({
 		reserveQuote: params.virtualQuoteReserves,
@@ -6535,7 +6726,7 @@ async function sellExactIn(params) {
 		quote
 	};
 }
-/** `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. */
 async function sellExactOut(params) {
 	const quote = sellExactOut$2({
 		reserveQuote: params.virtualQuoteReserves,
@@ -6583,7 +6774,7 @@ async function buildSellExactOutInstruction(params) {
 		maxAmountIn: params.maxAmountIn
 	});
 }
-/** 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. */
 function calculateBondingCurveProgress(params) {
 	const { realBaseReserves, initialRealBase } = params;
 	if (initialRealBase === 0n) return 100;
@@ -8518,7 +8709,7 @@ var plugins_exports$1 = /* @__PURE__ */ __exportAll({ sendLaunchpadProgram: () =
 //#endregion
 //#region src/utils/pda.ts
 const addressEncoder = getAddressEncoder();
-/** Seed order is [wallet, tokenProgram, mint], not the parameter order. */
+/** Derives the associated token account of `wallet` for `mint` under `tokenProgram`. */
 async function findAssociatedTokenPda(wallet, mint, tokenProgram = TOKEN_PROGRAM_ADDRESS) {
 	return await getProgramDerivedAddress({
 		programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
@@ -8574,7 +8765,8 @@ var launchpad_exports = /* @__PURE__ */ __exportAll({
 //#endregion
 //#region src/math/fee-decay.ts
 var fee_decay_exports = /* @__PURE__ */ __exportAll({ calculateFeeDecayPremium: () => 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`. */
 function calculateFeeDecayPremium(params) {
 	const { currentTimestamp, createdAtTimestamp, decaySeconds, decayStartBps, standardFeeBps } = params;
 	if (decaySeconds === 0) return 0n;
@@ -8595,7 +8787,9 @@ function calculateFeeDecayPremium(params) {
 //#endregion
 //#region src/math/fees.ts
 var fees_exports = /* @__PURE__ */ __exportAll({ splitFeeAmount: () => splitFeeAmount });
-/** 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`. */
 function splitFeeAmount(args) {
 	const { feeAmount } = args;
 	const protocolBps = toBps(args.protocolBps, "protocolBps");
@@ -8641,6 +8835,39 @@ var math_exports = /* @__PURE__ */ __exportAll({
 	fees: () => fees_exports
 });
 //#endregion
+//#region src/nexus/generated/shared/index.ts
+/** The System Program, which owns every address nobody has created an account at yet. */
+const SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
+/**
+* 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 },
+* );
+* ```
+*/
+function accountIsCreated(account) {
+	const maybeAccount = account;
+	if ("exists" in maybeAccount && !maybeAccount.exists) return false;
+	return !(maybeAccount.programAddress === SYSTEM_PROGRAM_ADDRESS && maybeAccount.data.length === 0);
+}
+//#endregion
 //#region src/nexus/generated/accounts/altRegistry.ts
 /**
 * This code was AUTOGENERATED using the Codama library.
@@ -8704,21 +8931,40 @@ function decodeAltRegistry(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getAltRegistryDecoder());
 }
+/** Fetches a `AltRegistry` account, throwing when it does not exist or only holds lamports. */
 async function fetchAltRegistry(rpc, address, config) {
 	const maybeAccount = await fetchMaybeAltRegistry(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeAltRegistry(rpc, address, config) {
-	return decodeAltRegistry(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeAltRegistry(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `AltRegistry` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllAltRegistry(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeAltRegistry(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeAltRegistry(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeAltRegistry(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeAltRegistry(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getAltRegistrySize() {
 	return 74;
@@ -8791,21 +9037,40 @@ function decodeCreatorFeeConfig(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getCreatorFeeConfigDecoder());
 }
+/** Fetches a `CreatorFeeConfig` account, throwing when it does not exist or only holds lamports. */
 async function fetchCreatorFeeConfig(rpc, address, config) {
 	const maybeAccount = await fetchMaybeCreatorFeeConfig(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeCreatorFeeConfig(rpc, address, config) {
-	return decodeCreatorFeeConfig(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeCreatorFeeConfig(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `CreatorFeeConfig` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllCreatorFeeConfig(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeCreatorFeeConfig(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeCreatorFeeConfig(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeCreatorFeeConfig(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeCreatorFeeConfig(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getCreatorFeeConfigSize() {
 	return 151;
@@ -9033,21 +9298,40 @@ function decodeFeePreset(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getFeePresetDecoder());
 }
+/** Fetches a `FeePreset` account, throwing when it does not exist or only holds lamports. */
 async function fetchFeePreset(rpc, address, config) {
 	const maybeAccount = await fetchMaybeFeePreset(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeFeePreset(rpc, address, config) {
-	return decodeFeePreset(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeFeePreset(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `FeePreset` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllFeePreset(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeFeePreset(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeFeePreset(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeFeePreset(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeFeePreset(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 //#endregion
 //#region src/nexus/generated/accounts/globalConfig.ts
@@ -9117,21 +9401,40 @@ function decodeGlobalConfig(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getGlobalConfigDecoder());
 }
+/** Fetches a `GlobalConfig` account, throwing when it does not exist or only holds lamports. */
 async function fetchGlobalConfig(rpc, address, config) {
 	const maybeAccount = await fetchMaybeGlobalConfig(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeGlobalConfig(rpc, address, config) {
-	return decodeGlobalConfig(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeGlobalConfig(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `GlobalConfig` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllGlobalConfig(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeGlobalConfig(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeGlobalConfig(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeGlobalConfig(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeGlobalConfig(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 //#endregion
 //#region src/nexus/generated/accounts/partnerConfig.ts
@@ -9207,21 +9510,40 @@ function decodePartnerConfig(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getPartnerConfigDecoder());
 }
+/** Fetches a `PartnerConfig` account, throwing when it does not exist or only holds lamports. */
 async function fetchPartnerConfig(rpc, address, config) {
 	const maybeAccount = await fetchMaybePartnerConfig(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybePartnerConfig(rpc, address, config) {
-	return decodePartnerConfig(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodePartnerConfig(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `PartnerConfig` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllPartnerConfig(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybePartnerConfig(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybePartnerConfig(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodePartnerConfig(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodePartnerConfig(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getPartnerConfigSize() {
 	return 173;
@@ -9300,21 +9622,40 @@ function decodePartnerMetadata(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getPartnerMetadataDecoder());
 }
+/** Fetches a `PartnerMetadata` account, throwing when it does not exist or only holds lamports. */
 async function fetchPartnerMetadata(rpc, address, config) {
 	const maybeAccount = await fetchMaybePartnerMetadata(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybePartnerMetadata(rpc, address, config) {
-	return decodePartnerMetadata(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodePartnerMetadata(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `PartnerMetadata` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllPartnerMetadata(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybePartnerMetadata(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybePartnerMetadata(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodePartnerMetadata(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodePartnerMetadata(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 //#endregion
 //#region src/nexus/generated/accounts/rewardState.ts
@@ -9394,21 +9735,40 @@ function decodeRewardState(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getRewardStateDecoder());
 }
+/** Fetches a `RewardState` account, throwing when it does not exist or only holds lamports. */
 async function fetchRewardState(rpc, address, config) {
 	const maybeAccount = await fetchMaybeRewardState(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeRewardState(rpc, address, config) {
-	return decodeRewardState(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeRewardState(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `RewardState` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllRewardState(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeRewardState(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeRewardState(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeRewardState(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeRewardState(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getRewardStateSize() {
 	return 196;
@@ -9483,21 +9843,40 @@ function decodeStakingConfig(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getStakingConfigDecoder());
 }
+/** Fetches a `StakingConfig` account, throwing when it does not exist or only holds lamports. */
 async function fetchStakingConfig(rpc, address, config) {
 	const maybeAccount = await fetchMaybeStakingConfig(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeStakingConfig(rpc, address, config) {
-	return decodeStakingConfig(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeStakingConfig(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `StakingConfig` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllStakingConfig(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeStakingConfig(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeStakingConfig(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeStakingConfig(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeStakingConfig(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getStakingConfigSize() {
 	return 117;
@@ -9580,21 +9959,40 @@ function decodeUserRewardDebt(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getUserRewardDebtDecoder());
 }
+/** Fetches a `UserRewardDebt` account, throwing when it does not exist or only holds lamports. */
 async function fetchUserRewardDebt(rpc, address, config) {
 	const maybeAccount = await fetchMaybeUserRewardDebt(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeUserRewardDebt(rpc, address, config) {
-	return decodeUserRewardDebt(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeUserRewardDebt(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `UserRewardDebt` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllUserRewardDebt(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeUserRewardDebt(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeUserRewardDebt(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeUserRewardDebt(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeUserRewardDebt(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getUserRewardDebtSize() {
 	return 182;
@@ -9671,21 +10069,40 @@ function decodeUserStakePosition(encodedAccount) {
 	}
 	return decodeAccount(encodedAccount, getUserStakePositionDecoder());
 }
+/** Fetches a `UserStakePosition` account, throwing when it does not exist or only holds lamports. */
 async function fetchUserStakePosition(rpc, address, config) {
 	const maybeAccount = await fetchMaybeUserStakePosition(rpc, address, config);
 	assertAccountExists(maybeAccount);
 	return maybeAccount;
 }
+/**
+* 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.
+*/
 async function fetchMaybeUserStakePosition(rpc, address, config) {
-	return decodeUserStakePosition(await fetchEncodedAccount(rpc, address, config));
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeUserStakePosition(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address,
+		exists: false
+	});
 }
+/** Fetches `UserStakePosition` accounts, throwing when any does not exist or only holds lamports. */
 async function fetchAllUserStakePosition(rpc, addresses, config) {
 	const maybeAccounts = await fetchAllMaybeUserStakePosition(rpc, addresses, config);
 	assertAccountsExist(maybeAccounts);
 	return maybeAccounts;
 }
+/**
+* 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.
+*/
 async function fetchAllMaybeUserStakePosition(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeUserStakePosition(maybeAccount));
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeUserStakePosition(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
+	}));
 }
 function getUserStakePositionSize() {
 	return 120;
@@ -12261,7 +12678,8 @@ var fee_helpers_exports = /* @__PURE__ */ __exportAll({
 	effectiveFeeBps: () => effectiveFeeBps,
 	fetchPartnerFees: () => 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. */
 async function fetchPartnerFees(rpc, partner, platformConfig) {
 	const [partnerPda] = await findPartnerConfigPda({
 		partner,
@@ -12271,8 +12689,9 @@ async function fetchPartnerFees(rpc, partner, platformConfig) {
 	if (!maybeAccount.exists) throw new Error(`No fee config for partner ${partner} on platform ${platformConfig}`);
 	return maybeAccount.data;
 }
-/** 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. */
 function effectiveFeeBps(schedule, createdAt, now) {
 	const standardFeeBps = schedule.protocolFeeBps + schedule.creatorFeeBps + ("lpFeeBps" in schedule ? schedule.lpFeeBps : 0);
 	const premium = calculateFeeDecayPremium({
@@ -12288,7 +12707,7 @@ function effectiveFeeBps(schedule, createdAt, now) {
 //#region src/utils/chunk.ts
 /** RPCs reject a `getMultipleAccounts` call past this many addresses. */
 const MAX_ACCOUNTS_PER_REQUEST = 100;
-/** Splits a multi-account read into 100-address calls; results follow `addresses` order. */
+/** Calls `read` once per 100 addresses. Results follow `addresses` order. */
 async function fetchInChunks(addresses, read) {
 	const chunks = [];
 	for (let start = 0; start < addresses.length; start += MAX_ACCOUNTS_PER_REQUEST) chunks.push(addresses.slice(start, start + MAX_ACCOUNTS_PER_REQUEST));
@@ -12323,9 +12742,8 @@ function compareAddresses(a, b) {
 	if (a > b) return 1;
 	return 0;
 }
-/** 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`. */
 async function getRewardMints(rpc) {
 	const [stakingConfig] = findStakingConfigPda();
 	const [accounts, config] = await Promise.all([rpc.getProgramAccounts(SEND_NEXUS_PROGRAM_ADDRESS, {
@@ -12355,7 +12773,8 @@ async function resolveRewardMints(rpc, rewardMints) {
 	if (!hasProgramAccounts(rpc)) throw new Error("This RPC has no getProgramAccounts, so the reward registry cannot be read from chain. Pass rewardMints explicitly.");
 	return await getRewardMints(rpc);
 }
-/** 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`. */
 async function buildSettleInstructions(source, params) {
 	const rewardMints = isRewardMintList(source) ? source : await resolveRewardMints(source, void 0);
 	return Promise.all(rewardMints.map((rewardMint) => getSettleInstructionAsync({
@@ -12376,10 +12795,11 @@ async function fetchMissingUserRewardDebts(rpc, user, stakingMint, knownRewardMi
 		return addr;
 	})), (chunk) => fetchEncodedAccounts(rpc, chunk));
 	const missingMints = [];
-	for (const [index, rewardMint] of rewardMints.entries()) if (!encodedAccounts[index].exists) missingMints.push(rewardMint);
+	for (const [index, rewardMint] of rewardMints.entries()) if (!accountIsCreated(encodedAccounts[index])) missingMints.push(rewardMint);
 	return missingMints;
 }
-/** 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. */
 async function buildStakingPreflightInstructions(rpc, params) {
 	const rewardMints = await resolveRewardMints(rpc, params.rewardMints);
 	const missingMints = await fetchMissingUserRewardDebts(rpc, params.user, params.stakingMint, rewardMints);
@@ -12392,13 +12812,14 @@ async function buildStakingPreflightInstructions(rpc, params) {
 	const settleIxs = await buildSettleInstructions(rewardMints, params);
 	return [...createIxs, ...settleIxs];
 }
-/** True once `stake` and `unstake` will pass the `settledCount == rewardCount` gate. */
+/** Returns true if `stake` and `unstake` pass the `settledCount == rewardCount` check. */
 async function isFullySettled(rpc, user, stakingMint) {
 	const [config, position] = await Promise.all([fetchStakingConfigData(rpc), fetchUserStakePositionData(rpc, user, stakingMint)]);
 	if (position === null) return config.rewardCount === 0;
 	return position.settledCount === config.rewardCount;
 }
-/** 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. */
 async function buildStakeInstruction(params) {
 	return getStakeInstructionAsync({
 		user: params.user,
@@ -12407,8 +12828,9 @@ async function buildStakeInstruction(params) {
 		amount: params.amount
 	});
 }
-/** 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. */
 async function buildUnstakeInstruction(params) {
 	return getUnstakeInstructionAsync({
 		user: params.user,
@@ -12417,8 +12839,8 @@ async function buildUnstakeInstruction(params) {
 		amount: params.amount
 	});
 }
-/** 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`. */
 async function buildClaimRewardsInstructions(rpc, params) {
 	const [stakingConfigAddr] = findStakingConfigPda();
 	const rewardMints = await resolveRewardMints(rpc, params.rewardMints);
@@ -12446,13 +12868,13 @@ async function buildClaimRewardsInstructions(rpc, params) {
 	const payer = params.payer ?? params.user;
 	return (await Promise.all(rewardMints.map(async (rewardMint, index) => {
 		const encodedRewardState = fetched[index];
-		if (!encodedRewardState.exists) throw new Error(`RewardState not found for mint ${rewardMint}`);
+		if (!accountIsCreated(encodedRewardState)) throw new Error(`RewardState not found for mint ${rewardMint}`);
 		const { vault } = rewardStateDecoder.decode(encodedRewardState.data);
 		const encodedMint = fetched[rewardMints.length + index];
 		const tokenProgram = encodedMint.exists ? encodedMint.programAddress : void 0;
 		const [destination] = await findAssociatedTokenPda(params.user.address, rewardMint, tokenProgram);
 		const instructions = [];
-		if (!fetched[rewardMints.length * 2 + index].exists) instructions.push(await getCreateUserRewardDebtInstructionAsync({
+		if (!accountIsCreated(fetched[rewardMints.length * 2 + index])) instructions.push(await getCreateUserRewardDebtInstructionAsync({
 			user: params.user.address,
 			payer,
 			stakingMint: params.stakingMint,
@@ -12470,7 +12892,8 @@ async function buildClaimRewardsInstructions(rpc, params) {
 		return instructions;
 	}))).flat();
 }
-/** 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. */
 async function buildWithdrawFeesAccounts(rpc, params) {
 	const [stakingConfigAddr] = findStakingConfigPda();
 	const tokenProgram = params.tokenProgram ?? (await rpc.getAccountInfo(params.rewardMint, { encoding: "base64" }).send()).value?.owner;
@@ -12503,19 +12926,19 @@ async function fetchUserStakePositionData(rpc, user, stakingMint) {
 	const maybePosition = await fetchMaybeUserStakePosition(rpc, positionAddr);
 	return maybePosition.exists ? maybePosition.data : 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. */
 function isStakingMintBound(stakingMint) {
-	return stakingMint !== SYSTEM_PROGRAM_ADDRESS;
+	return stakingMint !== SYSTEM_PROGRAM_ADDRESS$3;
 }
-/** 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. */
 async function fetchSendMint(rpc) {
 	const { stakingMint } = await fetchStakingConfigData(rpc);
 	if (!isStakingMintBound(stakingMint)) throw new Error("Staking mint not yet bound -- nexus not fully initialized");
 	return stakingMint;
 }
-/** 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. */
 async function fetchPendingRewards(rpc, user, stakingMint, knownRewardMints) {
 	const rewardMints = await resolveRewardMints(rpc, knownRewardMints);
 	if (rewardMints.length === 0) return [];
@@ -12556,15 +12979,15 @@ async function fetchPendingRewards(rpc, user, stakingMint, knownRewardMints) {
 	return pdas.map(({ rewardMint }, index) => {
 		const base = index * 3;
 		const encodedDebt = encodedAccounts[base];
-		const debt = encodedDebt.exists ? userRewardDebtDecoder.decode(encodedDebt.data) : {
+		const debt = accountIsCreated(encodedDebt) ? userRewardDebtDecoder.decode(encodedDebt.data) : {
 			owed: 0n,
 			accSnapshot: 0n,
 			amountSnapshot: stakeAmount
 		};
 		const encodedLaunchpadAccrual = encodedAccounts[base + 1];
-		const launchpadAcc = encodedLaunchpadAccrual.exists ? rewardAccrualDecoder.decode(encodedLaunchpadAccrual.data).accPerToken : 0n;
+		const launchpadAcc = accountIsCreated(encodedLaunchpadAccrual) ? rewardAccrualDecoder.decode(encodedLaunchpadAccrual.data).accPerToken : 0n;
 		const encodedDexAccrual = encodedAccounts[base + 2];
-		const dexAcc = encodedDexAccrual.exists ? rewardAccrualDecoder.decode(encodedDexAccrual.data).accPerToken : 0n;
+		const dexAcc = accountIsCreated(encodedDexAccrual) ? rewardAccrualDecoder.decode(encodedDexAccrual.data).accPerToken : 0n;
 		const basis = debt.amountSnapshot < stakeAmount ? debt.amountSnapshot : stakeAmount;
 		const combined = launchpadAcc + dexAcc;
 		const accrued = basis * (combined > debt.accSnapshot ? combined - debt.accSnapshot : 0n) / PRECISION;
@@ -12593,9 +13016,9 @@ var platform_exports = /* @__PURE__ */ __exportAll({
 	PLATFORM_SEED: () => PLATFORM_SEED,
 	findPlatformAddress: () => 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. */
 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. */
 async function findPlatformAddress(name) {
 	return await getProgramDerivedAddress({
 		programAddress: SEND_NEXUS_PROGRAM_ADDRESS,
@@ -12637,8 +13060,9 @@ function readEntry(view, start) {
 		basisPoints: view.getUint16(start + FEE_BASIS_POINTS, true)
 	};
 }
-/** `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. */
 function decodeTransferFeeConfig(data, owner) {
 	if (owner === TOKEN_PROGRAM_ADDRESS) return void 0;
 	if (owner !== TOKEN_2022_PROGRAM_ADDRESS) throw new RangeError(`decodeTransferFeeConfig: ${owner} is not a token program`);
@@ -12667,7 +13091,7 @@ function decodeTransferFeeConfig(data, owner) {
 		offset = next;
 	}
 }
-/** 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. */
 function transferFeeAtEpoch(config, epoch) {
 	const entry = epoch >= config.newer.epoch ? config.newer : config.older;
 	return {
@@ -12682,8 +13106,9 @@ function mintFeeAtEpoch(data, owner, epoch) {
 function currentEpoch(rpc, commitment) {
 	return rpc.getEpochInfo(commitment === void 0 ? void 0 : { commitment }).send().then((info) => info.epoch);
 }
-/** 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. */
 async function fetchMintFees(rpc, mints, options) {
 	const commitment = options?.commitment;
 	const [epoch, accounts] = await Promise.all([options?.epoch ?? currentEpoch(rpc, commitment), fetchInChunks(mints, (chunk) => rpc.getMultipleAccounts(chunk, commitment === void 0 ? { encoding: "base64" } : {
@@ -12712,7 +13137,8 @@ function decodeMintInfo(mint, data, owner) {
 		tokenProgram: owner
 	};
 }
-/** 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. */
 async function fetchQuoteMintInfo(rpc, mint, commitment) {
 	const { value } = await rpc.getAccountInfo(mint, commitment === void 0 ? { encoding: "base64" } : {
 		commitment,
@@ -12721,7 +13147,8 @@ async function fetchQuoteMintInfo(rpc, mint, commitment) {
 	if (!value) throw new Error(`fetchQuoteMintInfo: no account at ${mint}`);
 	return decodeMintInfo(mint, new Uint8Array(getBase64Encoder().encode(value.data[0])), value.owner);
 }
-/** 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. */
 async function fetchQuoteMintInfos(rpc, mints, commitment) {
 	if (mints.length === 0) return [];
 	const value = await fetchInChunks(mints, (chunk) => rpc.getMultipleAccounts(chunk, commitment === void 0 ? { encoding: "base64" } : {
@@ -12738,6 +13165,7 @@ async function fetchQuoteMintInfos(rpc, mints, commitment) {
 //#endregion
 //#region src/utils/index.ts
 var utils_exports = /* @__PURE__ */ __exportAll({
+	accountIsCreated: () => accountIsCreated,
 	creatorHashFromId: () => creatorHashFromId,
 	decodeCreatorId: () => decodeCreatorId,
 	encodeCreatorId: () => encodeCreatorId,