@send-fun/sdk 1.1.0 → 2.0.0

package/src/dex/generated/instructions/claimCreatorFees.ts

@@ -42,7 +42,11 @@ import {
 	getAddressFromResolvedInstructionAccount,
 	type ResolvedInstructionAccount,
 } from '@solana/kit/program-client-core';
-import { EVENT_AUTHORITY_PDA_ADDRESS, findPoolPda } from '../pdas/index.js';
+import {
+	EVENT_AUTHORITY_PDA_ADDRESS,
+	findCreatorFeeConfigPda,
+	findPoolPda,
+} from '../pdas/index.js';
 import { SEND_DEX_PROGRAM_ADDRESS } from '../programs/index.js';
 
 export const CLAIM_CREATOR_FEES_DISCRIMINATOR: ReadonlyUint8Array =
@@ -93,7 +97,7 @@ export type ClaimCreatorFeesInstruction<
 				? WritableAccount<TAccountPool>
 				: TAccountPool,
 			TAccountCreatorFeeConfig extends string
-				? ReadonlyAccount<TAccountCreatorFeeConfig>
+				? WritableAccount<TAccountCreatorFeeConfig>
 				: TAccountCreatorFeeConfig,
 			TAccountNexusGlobalConfig extends string
 				? ReadonlyAccount<TAccountNexusGlobalConfig>
@@ -181,7 +185,7 @@ export type ClaimCreatorFeesAsyncInput<
 	claimer: TransactionSigner<TAccountClaimer>;
 	payer: TransactionSigner<TAccountPayer>;
 	pool?: Address<TAccountPool>;
-	creatorFeeConfig: Address<TAccountCreatorFeeConfig>;
+	creatorFeeConfig?: Address<TAccountCreatorFeeConfig>;
 	baseMint: Address<TAccountBaseMint>;
 	quoteMint: Address<TAccountQuoteMint>;
 	quoteVault?: Address<TAccountQuoteVault>;
@@ -244,7 +248,7 @@ export async function getClaimCreatorFeesInstructionAsync<
 		pool: { value: input.pool ?? null, isWritable: true },
 		creatorFeeConfig: {
 			value: input.creatorFeeConfig ?? null,
-			isWritable: false,
+			isWritable: true,
 		},
 		nexusGlobalConfig: { value: null, isWritable: false },
 		baseMint: { value: input.baseMint ?? null, isWritable: false },
@@ -282,6 +286,18 @@ export async function getClaimCreatorFeesInstructionAsync<
 			),
 		});
 	}
+	if (!accounts.creatorFeeConfig.value) {
+		accounts.creatorFeeConfig.value = await findCreatorFeeConfigPda({
+			baseMint: getAddressFromResolvedInstructionAccount(
+				'baseMint',
+				accounts.baseMint.value,
+			),
+			quoteMint: getAddressFromResolvedInstructionAccount(
+				'quoteMint',
+				accounts.quoteMint.value,
+			),
+		});
+	}
 	if (!accounts.nexusGlobalConfig.value) {
 		accounts.nexusGlobalConfig.value =
 			'3bycfBeRULfXYqcg3DmiYFBjv6mMVidMuqKdFZJTGdNr' as Address<'3bycfBeRULfXYqcg3DmiYFBjv6mMVidMuqKdFZJTGdNr'>;
@@ -474,7 +490,7 @@ export function getClaimCreatorFeesInstruction<
 		pool: { value: input.pool ?? null, isWritable: true },
 		creatorFeeConfig: {
 			value: input.creatorFeeConfig ?? null,
-			isWritable: false,
+			isWritable: true,
 		},
 		nexusGlobalConfig: { value: null, isWritable: false },
 		baseMint: { value: input.baseMint ?? null, isWritable: false },

package/src/{nexus → dex}/generated/pdas/creatorFeeConfig.ts

@@ -13,10 +13,10 @@ import {
 	type Address,
 	type ProgramDerivedAddress,
 } from '@solana/kit';
-import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+import { SEND_DEX_PROGRAM_ADDRESS } from '../programs/index.js';
 
 export type CreatorFeeConfigSeeds = {
-	creatorHash: Address;
+	baseMint: Address;
 	quoteMint: Address;
 };
 
@@ -24,15 +24,15 @@ export async function findCreatorFeeConfigPda(
 	seeds: CreatorFeeConfigSeeds,
 ): Promise<ProgramDerivedAddress> {
 	return await getProgramDerivedAddress({
-		programAddress: SEND_NEXUS_PROGRAM_ADDRESS,
+		programAddress: SEND_DEX_PROGRAM_ADDRESS,
 		seeds: [
 			getBytesEncoder().encode(
 				new Uint8Array([
-					99, 114, 101, 97, 116, 111, 114, 95, 102, 101, 101, 95, 98,
-					97, 108, 97, 110, 99, 101,
+					99, 114, 101, 97, 116, 111, 114, 95, 102, 101, 101, 95, 99,
+					111, 110, 102, 105, 103,
 				]),
 			),
-			getAddressEncoder().encode(seeds.creatorHash),
+			getAddressEncoder().encode(seeds.baseMint),
 			getAddressEncoder().encode(seeds.quoteMint),
 		],
 	});

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

@@ -6,6 +6,7 @@
  * @see https://github.com/codama-idl/codama
  */
 
+export * from './creatorFeeConfig.js';
 export * from './eventAuthority.js';
 export * from './globalConfig.js';
 export * from './lpMint.js';

package/src/dex/generated/plugins/sendDex.ts

@@ -70,6 +70,7 @@ import {
 	type SellExactOutAsyncInput,
 } from '../instructions/index.js';
 import {
+	findCreatorFeeConfigPda,
 	findEventAuthorityPda,
 	findGlobalConfigPda,
 	findLpMintPda,
@@ -135,6 +136,7 @@ export type SendDexPluginInstructions = {
 export type SendDexPluginPdas = {
 	pool: typeof findPoolPda;
 	eventAuthority: typeof findEventAuthorityPda;
+	creatorFeeConfig: typeof findCreatorFeeConfigPda;
 	rewardAccrual: typeof findRewardAccrualPda;
 	globalConfig: typeof findGlobalConfigPda;
 	lpMint: typeof findLpMintPda;
@@ -266,6 +268,7 @@ export function sendDexProgram() {
 				pdas: {
 					pool: findPoolPda,
 					eventAuthority: findEventAuthorityPda,
+					creatorFeeConfig: findCreatorFeeConfigPda,
 					rewardAccrual: findRewardAccrualPda,
 					globalConfig: findGlobalConfigPda,
 					lpMint: findLpMintPda,

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

@@ -1,27 +1,26 @@
 import type { Address, Instruction, TransactionSigner } from '@solana/kit';
 import type { MintFee, TradeQuote } from '../math/amm.js';
 import type { PartnerInput } from '../utils/partner.js';
-import { creatorHashFromId } from '../utils/creator-hash.js';
-import { findCreatorFeeConfigPda } from '../nexus/generated/pdas/creatorFeeConfig.js';
 import { getCreateTokenInstructionAsync } from './generated/instructions/createToken.js';
 import { buyExactIn } from './trade.js';
 
 export interface CreateTokenParams {
 	user: TransactionSigner;
 	payer?: TransactionSigner;
+	/** The wallet that claims the creator fees. */
 	coinCreator: Address;
 	baseMint: TransactionSigner;
 	quoteMint: Address;
 	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`. */
-	creatorPlatform: string;
-	creatorId: string;
 	partner: PartnerInput;
 	platformConfig: Address;
 	quoteTokenProgram: Address;
+	creatorFeeMode: number;
+	creatorFeeBps: number;
+	/** The creator fee of the pool after migration, in bps. */
+	dexCreatorFeeBps: number;
 }
 
 export interface CreateAndBuyParams extends CreateTokenParams {
@@ -30,62 +29,39 @@ 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;
 }
 
 export async function buildCreateTokenInstruction(
 	params: CreateTokenParams,
 ): Promise<Instruction> {
-	return buildCreateTokenInstructionWithHash(
-		params,
-		await creatorHashFromId(params.creatorPlatform, params.creatorId),
-	);
-}
-
-async function buildCreateTokenInstructionWithHash(
-	params: CreateTokenParams,
-	creatorHash: Address,
-): Promise<Instruction> {
-	const [creatorFeeConfig] = await findCreatorFeeConfigPda({
-		creatorHash,
-		quoteMint: params.quoteMint,
-	});
-	// The creation fee is native SOL from `user`; the client derives the WSOL staking vault.
 	return getCreateTokenInstructionAsync({
 		user: params.user,
 		payer: params.payer ?? params.user,
 		coinCreator: params.coinCreator,
 		baseMint: params.baseMint,
 		quoteMint: params.quoteMint,
-		creatorFeeConfig,
 		partner: params.partner,
 		platformConfig: params.platformConfig,
 		quoteTokenProgram: params.quoteTokenProgram,
-		creatorPlatform: params.creatorPlatform,
-		creatorId: params.creatorId,
-		creatorHash,
 		name: params.name,
 		symbol: params.symbol,
 		uri: params.uri,
+		creatorFeeMode: params.creatorFeeMode,
+		creatorFeeBps: params.creatorFeeBps,
+		dexCreatorFeeBps: params.dexCreatorFeeBps,
 	});
 }
 
 export async function buildCreateAndBuyInstructions(
 	params: CreateAndBuyParams,
 ): Promise<{ instructions: Instruction[]; quote?: TradeQuote }> {
-	const creatorHash = await creatorHashFromId(
-		params.creatorPlatform,
-		params.creatorId,
-	);
-	const createIx = await buildCreateTokenInstructionWithHash(
-		params,
-		creatorHash,
-	);
+	const createIx = await buildCreateTokenInstruction(params);
 	const instructions: Instruction[] = [createIx];
 	let quote: TradeQuote | undefined;
 
@@ -98,7 +74,6 @@ export async function buildCreateAndBuyInstructions(
 			virtualQuoteReserves: params.initialVirtualQuoteReserves,
 			virtualBaseReserves: params.initialVirtualBaseReserves,
 			realBaseReserves: params.initialRealBaseReserves,
-			// The curve was just stamped with this same key.
 			platformConfig: params.platformConfig,
 			feeBps: params.feeBps,
 			slippageBps: params.slippageBps,

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

@@ -18,12 +18,16 @@ import {
 	fixEncoderSize,
 	getAddressDecoder,
 	getAddressEncoder,
+	getArrayDecoder,
+	getArrayEncoder,
 	getBytesDecoder,
 	getBytesEncoder,
 	getI64Decoder,
 	getI64Encoder,
 	getStructDecoder,
 	getStructEncoder,
+	getU16Decoder,
+	getU16Encoder,
 	getU64Decoder,
 	getU64Encoder,
 	getU8Decoder,
@@ -42,6 +46,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,
@@ -73,7 +78,7 @@ export type BondingCurve = {
 	quoteMint: Address;
 	quoteDecimals: number;
 	coinCreator: Address;
-	creatorFeeConfig: Address;
+	padding0: Array<bigint>;
 	partner: Address;
 	baseVault: Address;
 	quoteVault: Address;
@@ -85,6 +90,9 @@ export type BondingCurve = {
 	protocolOwed: bigint;
 	creatorOwed: bigint;
 	platformConfig: Address;
+	creatorFeeMode: number;
+	creatorFeeBps: number;
+	dexCreatorFeeBps: number;
 	reserved: ReadonlyUint8Array;
 };
 
@@ -101,7 +109,7 @@ export type BondingCurveArgs = {
 	quoteMint: Address;
 	quoteDecimals: number;
 	coinCreator: Address;
-	creatorFeeConfig: Address;
+	padding0: Array<number | bigint>;
 	partner: Address;
 	baseVault: Address;
 	quoteVault: Address;
@@ -113,6 +121,9 @@ export type BondingCurveArgs = {
 	protocolOwed: number | bigint;
 	creatorOwed: number | bigint;
 	platformConfig: Address;
+	creatorFeeMode: number;
+	creatorFeeBps: number;
+	dexCreatorFeeBps: number;
 	reserved: ReadonlyUint8Array;
 };
 
@@ -133,7 +144,7 @@ export function getBondingCurveEncoder(): FixedSizeEncoder<BondingCurveArgs> {
 			['quoteMint', getAddressEncoder()],
 			['quoteDecimals', getU8Encoder()],
 			['coinCreator', getAddressEncoder()],
-			['creatorFeeConfig', getAddressEncoder()],
+			['padding0', getArrayEncoder(getU64Encoder(), { size: 4 })],
 			['partner', getAddressEncoder()],
 			['baseVault', getAddressEncoder()],
 			['quoteVault', getAddressEncoder()],
@@ -145,7 +156,10 @@ export function getBondingCurveEncoder(): FixedSizeEncoder<BondingCurveArgs> {
 			['protocolOwed', getU64Encoder()],
 			['creatorOwed', getU64Encoder()],
 			['platformConfig', getAddressEncoder()],
-			['reserved', fixEncoderSize(getBytesEncoder(), 64)],
+			['creatorFeeMode', getU8Encoder()],
+			['creatorFeeBps', getU16Encoder()],
+			['dexCreatorFeeBps', getU16Encoder()],
+			['reserved', fixEncoderSize(getBytesEncoder(), 256)],
 		]),
 		(value) => ({ ...value, discriminator: BONDING_CURVE_DISCRIMINATOR }),
 	);
@@ -167,7 +181,7 @@ export function getBondingCurveDecoder(): FixedSizeDecoder<BondingCurve> {
 		['quoteMint', getAddressDecoder()],
 		['quoteDecimals', getU8Decoder()],
 		['coinCreator', getAddressDecoder()],
-		['creatorFeeConfig', getAddressDecoder()],
+		['padding0', getArrayDecoder(getU64Decoder(), { size: 4 })],
 		['partner', getAddressDecoder()],
 		['baseVault', getAddressDecoder()],
 		['quoteVault', getAddressDecoder()],
@@ -179,7 +193,10 @@ export function getBondingCurveDecoder(): FixedSizeDecoder<BondingCurve> {
 		['protocolOwed', getU64Decoder()],
 		['creatorOwed', getU64Decoder()],
 		['platformConfig', getAddressDecoder()],
-		['reserved', fixDecoderSize(getBytesDecoder(), 64)],
+		['creatorFeeMode', getU8Decoder()],
+		['creatorFeeBps', getU16Decoder()],
+		['dexCreatorFeeBps', getU16Decoder()],
+		['reserved', fixDecoderSize(getBytesDecoder(), 256)],
 	]);
 }
 
@@ -191,9 +208,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 +257,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 +268,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 +301,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,10 +313,14 @@ 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 },
+		),
 	);
 }
 
 export function getBondingCurveSize(): number {
-	return 421;
+	return 618;
 }

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 },
+		),
 	);
 }