@send-fun/sdk 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@send-fun/sdk",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Kit-native TypeScript SDK for send.fun",
   "keywords": [
     "dex",

package/src/dex/generated/accounts/globalConfig.ts

@@ -40,6 +40,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_DEX_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 
 export const GLOBAL_CONFIG_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
 	149, 8, 156, 202, 160, 252, 176, 217,
@@ -107,9 +108,25 @@ export function getGlobalConfigCodec(): FixedSizeCodec<
 	return combineCodec(getGlobalConfigEncoder(), getGlobalConfigDecoder());
 }
 
+/**
+ * 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.
+ */
 export 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.
+ */
 export function decodeGlobalConfig<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<GlobalConfig, TAddress>;
@@ -140,6 +157,7 @@ export function decodeGlobalConfig<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `GlobalConfig` account, throwing when it does not exist or only holds lamports. */
 export async function fetchGlobalConfig<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -150,15 +168,25 @@ export async function fetchGlobalConfig<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybeGlobalConfig<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<GlobalConfig, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeGlobalConfig(maybeAccount);
+	return decodeGlobalConfig(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `GlobalConfig` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllGlobalConfig(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -173,6 +201,11 @@ export async function fetchAllGlobalConfig(
 	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.
+ */
 export async function fetchAllMaybeGlobalConfig(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -180,7 +213,11 @@ export async function fetchAllMaybeGlobalConfig(
 ): Promise<MaybeAccount<GlobalConfig>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
 	return maybeAccounts.map((maybeAccount) =>
-		decodeGlobalConfig(maybeAccount),
+		decodeGlobalConfig(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
 	);
 }
 

package/src/dex/generated/accounts/pool.ts

@@ -42,6 +42,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_DEX_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 import {
 	getPoolStatusDecoder,
 	getPoolStatusEncoder,
@@ -170,9 +171,25 @@ export function getPoolCodec(): FixedSizeCodec<PoolArgs, Pool> {
 	return combineCodec(getPoolEncoder(), getPoolDecoder());
 }
 
+/**
+ * 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.
+ */
 export 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.
+ */
 export function decodePool<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<Pool, TAddress>;
@@ -201,6 +218,7 @@ export function decodePool<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `Pool` account, throwing when it does not exist or only holds lamports. */
 export async function fetchPool<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -211,15 +229,25 @@ export async function fetchPool<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybePool<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<Pool, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodePool(maybeAccount);
+	return decodePool(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `Pool` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllPool(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -230,13 +258,24 @@ export async function fetchAllPool(
 	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.
+ */
 export async function fetchAllMaybePool(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
 	config?: FetchAccountsConfig,
 ): Promise<MaybeAccount<Pool>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
-	return maybeAccounts.map((maybeAccount) => decodePool(maybeAccount));
+	return maybeAccounts.map((maybeAccount) =>
+		decodePool(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
+	);
 }
 
 export function getPoolSize(): number {

package/src/dex/generated/accounts/rewardAccrual.ts

@@ -42,6 +42,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_DEX_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 
 export const REWARD_ACCRUAL_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
 	158, 244, 116, 30, 227, 132, 105, 182,
@@ -109,9 +110,25 @@ export function getRewardAccrualCodec(): FixedSizeCodec<
 	return combineCodec(getRewardAccrualEncoder(), getRewardAccrualDecoder());
 }
 
+/**
+ * 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.
+ */
 export 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.
+ */
 export function decodeRewardAccrual<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<RewardAccrual, TAddress>;
@@ -142,6 +159,7 @@ export function decodeRewardAccrual<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `RewardAccrual` account, throwing when it does not exist or only holds lamports. */
 export async function fetchRewardAccrual<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -152,15 +170,25 @@ export async function fetchRewardAccrual<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybeRewardAccrual<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<RewardAccrual, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeRewardAccrual(maybeAccount);
+	return decodeRewardAccrual(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `RewardAccrual` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllRewardAccrual(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -175,6 +203,11 @@ export async function fetchAllRewardAccrual(
 	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.
+ */
 export async function fetchAllMaybeRewardAccrual(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -182,7 +215,11 @@ export async function fetchAllMaybeRewardAccrual(
 ): Promise<MaybeAccount<RewardAccrual>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
 	return maybeAccounts.map((maybeAccount) =>
-		decodeRewardAccrual(maybeAccount),
+		decodeRewardAccrual(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
 	);
 }
 

package/src/dex/generated/index.ts

@@ -13,4 +13,5 @@ export * from './instructions/index.js';
 export * from './pdas/index.js';
 export * from './plugins/index.js';
 export * from './programs/index.js';
+export * from './shared/index.js';
 export * from './types/index.js';

package/src/dex/generated/shared/index.ts

@@ -0,0 +1,52 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import type { Address, EncodedAccount, MaybeEncodedAccount } from '@solana/kit';
+
+/** The System Program, which owns every address nobody has created an account at yet. */
+const SYSTEM_PROGRAM_ADDRESS =
+	'11111111111111111111111111111111' as 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 },
+ * );
+ * ```
+ */
+export function accountIsCreated<
+	TAccount extends EncodedAccount | MaybeEncodedAccount,
+>(
+	account: TAccount,
+): account is Exclude<TAccount, { readonly exists: false }> & {
+	readonly uncreated?: never;
+} {
+	const maybeAccount: EncodedAccount | MaybeEncodedAccount = account;
+	if ('exists' in maybeAccount && !maybeAccount.exists) return false;
+	return !(
+		maybeAccount.programAddress === SYSTEM_PROGRAM_ADDRESS &&
+		maybeAccount.data.length === 0
+	);
+}

package/src/dex/trade.ts

@@ -19,7 +19,7 @@ export 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} */
@@ -36,16 +36,15 @@ export 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. */
 export async function buyExactOut(
 	params: DexTradeParams & { baseAmountOut: bigint },
 ): Promise<{ instruction: Instruction; quote: BuyQuote }> {
@@ -57,7 +56,7 @@ export async function buyExactOut(
 		quoteFee: params.quoteFee,
 		baseFee: params.baseFee,
 	});
-	// The cap is measured on the gross the buyer sends, quote transfer fee included.
+	// The program checks `maxAmountIn` against the gross the buyer sends, quote transfer fee included.
 	const maxQuoteIn = amm.calculateSlippageUp(
 		quote.quoteFromUser,
 		params.slippageBps,
@@ -83,7 +82,7 @@ export async function buyExactIn(
 		quoteFee: params.quoteFee,
 		baseFee: params.baseFee,
 	});
-	// The floor is measured on the buyer's credit, not the vault's debit.
+	// The program checks `minAmountOut` against what the buyer receives, not the vault's debit.
 	const minBaseOut = amm.calculateSlippageDown(
 		quote.baseToUser,
 		params.slippageBps,
@@ -109,7 +108,7 @@ export async function sellExactIn(
 		quoteFee: params.quoteFee,
 		baseFee: params.baseFee,
 	});
-	// The floor is measured on the seller's credit, not what leaves the vault.
+	// The program checks `minAmountOut` against what the seller receives, not the vault's debit.
 	const minQuoteOut = amm.calculateSlippageDown(
 		quote.quoteToUser,
 		params.slippageBps,
@@ -124,7 +123,7 @@ export async function sellExactIn(
 	};
 }
 
-/** `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. */
 export async function sellExactOut(
 	params: DexTradeParams & { quoteAmountOut: bigint },
 ): Promise<{ instruction: Instruction; quote: SellQuote }> {
@@ -136,7 +135,7 @@ export async function sellExactOut(
 		quoteFee: params.quoteFee,
 		baseFee: params.baseFee,
 	});
-	// The cap is measured on the gross the seller sends, base transfer fee included.
+	// The program checks `maxAmountIn` against the gross the seller sends, base transfer fee included.
 	const maxBaseIn = amm.calculateSlippageUp(
 		quote.baseFromUser,
 		params.slippageBps,
@@ -204,7 +203,7 @@ function resolveSharedAccounts(params: DexInstructionParams) {
 		partner: params.partner,
 		platformConfig: params.platformConfig,
 		quoteTokenProgram: params.quoteTokenProgram,
-		// Left undefined so the generated client derives the ATA itself.
+		// When omitted, the generated client derives the ATA.
 		...(params.userQuoteAccount !== undefined && {
 			userQuoteAccount: params.userQuoteAccount,
 		}),

package/src/launchpad/create.ts

@@ -15,8 +15,8 @@ export 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;
@@ -30,11 +30,11 @@ export 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;
 }
 
@@ -55,7 +55,7 @@ async function buildCreateTokenInstructionWithHash(
 		creatorHash,
 		quoteMint: params.quoteMint,
 	});
-	// The creation fee is native SOL from `user`; the client derives the WSOL staking vault.
+	// `user` pays the creation fee in native SOL. The generated client fills in the WSOL staking vault.
 	return getCreateTokenInstructionAsync({
 		user: params.user,
 		payer: params.payer ?? params.user,
@@ -98,7 +98,7 @@ export async function buildCreateAndBuyInstructions(
 			virtualQuoteReserves: params.initialVirtualQuoteReserves,
 			virtualBaseReserves: params.initialVirtualBaseReserves,
 			realBaseReserves: params.initialRealBaseReserves,
-			// The curve was just stamped with this same key.
+			// `create_token` sets the curve's `platformConfig` to this key.
 			platformConfig: params.platformConfig,
 			feeBps: params.feeBps,
 			slippageBps: params.slippageBps,

package/src/launchpad/generated/accounts/bondingCurve.ts

@@ -42,6 +42,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_LAUNCHPAD_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 import {
 	getBondingCurveStatusDecoder,
 	getBondingCurveStatusEncoder,
@@ -191,9 +192,25 @@ export function getBondingCurveCodec(): FixedSizeCodec<
 	return combineCodec(getBondingCurveEncoder(), getBondingCurveDecoder());
 }
 
+/**
+ * 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.
+ */
 export 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.
+ */
 export function decodeBondingCurve<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<BondingCurve, TAddress>;
@@ -224,6 +241,7 @@ export function decodeBondingCurve<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `BondingCurve` account, throwing when it does not exist or only holds lamports. */
 export async function fetchBondingCurve<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -234,15 +252,25 @@ export async function fetchBondingCurve<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybeBondingCurve<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<BondingCurve, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeBondingCurve(maybeAccount);
+	return decodeBondingCurve(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `BondingCurve` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllBondingCurve(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -257,6 +285,11 @@ export async function fetchAllBondingCurve(
 	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.
+ */
 export async function fetchAllMaybeBondingCurve(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -264,7 +297,11 @@ export async function fetchAllMaybeBondingCurve(
 ): Promise<MaybeAccount<BondingCurve>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
 	return maybeAccounts.map((maybeAccount) =>
-		decodeBondingCurve(maybeAccount),
+		decodeBondingCurve(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
 	);
 }
 

package/src/launchpad/generated/accounts/globalConfig.ts

@@ -42,6 +42,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_LAUNCHPAD_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 
 export const GLOBAL_CONFIG_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
 	149, 8, 156, 202, 160, 252, 176, 217,
@@ -129,9 +130,25 @@ export function getGlobalConfigCodec(): FixedSizeCodec<
 	return combineCodec(getGlobalConfigEncoder(), getGlobalConfigDecoder());
 }
 
+/**
+ * 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.
+ */
 export 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.
+ */
 export function decodeGlobalConfig<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<GlobalConfig, TAddress>;
@@ -162,6 +179,7 @@ export function decodeGlobalConfig<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `GlobalConfig` account, throwing when it does not exist or only holds lamports. */
 export async function fetchGlobalConfig<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -172,15 +190,25 @@ export async function fetchGlobalConfig<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybeGlobalConfig<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<GlobalConfig, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeGlobalConfig(maybeAccount);
+	return decodeGlobalConfig(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `GlobalConfig` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllGlobalConfig(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -195,6 +223,11 @@ export async function fetchAllGlobalConfig(
 	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.
+ */
 export async function fetchAllMaybeGlobalConfig(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -202,7 +235,11 @@ export async function fetchAllMaybeGlobalConfig(
 ): Promise<MaybeAccount<GlobalConfig>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
 	return maybeAccounts.map((maybeAccount) =>
-		decodeGlobalConfig(maybeAccount),
+		decodeGlobalConfig(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
 	);
 }