@send-fun/sdk 1.1.0 → 2.0.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;
@@ -212,7 +264,7 @@ function getPoolEncoder() {
 		["quoteMint", getAddressEncoder()],
 		["quoteDecimals", getU8Encoder()],
 		["coinCreator", getAddressEncoder()],
-		["creatorFeeConfig", getAddressEncoder()],
+		["padding0", getArrayEncoder(getU64Encoder(), { size: 4 })],
 		["baseVault", getAddressEncoder()],
 		["quoteVault", getAddressEncoder()],
 		["lpMint", getAddressEncoder()],
@@ -224,7 +276,9 @@ function getPoolEncoder() {
 		["protocolOwed", getU64Encoder()],
 		["creatorOwed", getU64Encoder()],
 		["platformConfig", getAddressEncoder()],
-		["reserved", fixEncoderSize(getBytesEncoder(), 64)]
+		["creatorFeeMode", getU8Encoder()],
+		["creatorFeeBps", getU16Encoder()],
+		["reserved", fixEncoderSize(getBytesEncoder(), 256)]
 	]), (value) => ({
 		...value,
 		discriminator: POOL_DISCRIMINATOR
@@ -242,7 +296,7 @@ function getPoolDecoder() {
 		["quoteMint", getAddressDecoder()],
 		["quoteDecimals", getU8Decoder()],
 		["coinCreator", getAddressDecoder()],
-		["creatorFeeConfig", getAddressDecoder()],
+		["padding0", getArrayDecoder(getU64Decoder(), { size: 4 })],
 		["baseVault", getAddressDecoder()],
 		["quoteVault", getAddressDecoder()],
 		["lpMint", getAddressDecoder()],
@@ -254,7 +308,9 @@ function getPoolDecoder() {
 		["protocolOwed", getU64Decoder()],
 		["creatorOwed", getU64Decoder()],
 		["platformConfig", getAddressDecoder()],
-		["reserved", fixDecoderSize(getBytesDecoder(), 64)]
+		["creatorFeeMode", getU8Decoder()],
+		["creatorFeeBps", getU16Decoder()],
+		["reserved", fixDecoderSize(getBytesDecoder(), 256)]
 	]);
 }
 /** Gets the codec for {@link Pool} account data. */
@@ -276,24 +332,43 @@ 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;
+	return 584;
 }
 //#endregion
 //#region src/dex/generated/accounts/rewardAccrual.ts
@@ -363,21 +438,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;
@@ -472,8 +566,8 @@ const SEND_DEX_ERROR__INVALID_POOL_BALANCE = 6008;
 const SEND_DEX_ERROR__INSUFFICIENT_POOL_BALANCE = 6009;
 /** InvalidAuthority: Invalid authority */
 const SEND_DEX_ERROR__INVALID_AUTHORITY = 6010;
-/** InvalidCreatorHash: creator_hash does not match (creator_platform, creator_id) */
-const SEND_DEX_ERROR__INVALID_CREATOR_HASH = 6011;
+/** InvalidCoinCreator: Invalid coin creator */
+const SEND_DEX_ERROR__INVALID_COIN_CREATOR = 6011;
 /** InvalidPlatformConfig: Platform config cannot be the default address */
 const SEND_DEX_ERROR__INVALID_PLATFORM_CONFIG = 6012;
 /** ProgramPaused: Program is paused */
@@ -500,26 +594,31 @@ const SEND_DEX_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT = 7009;
 const SEND_DEX_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY = 7010;
 /** NothingToClaim: Nothing to claim */
 const SEND_DEX_ERROR__NOTHING_TO_CLAIM = 7011;
-/** InvalidCreatorId: Creator identity is not a decodable wallet address */
-const SEND_DEX_ERROR__INVALID_CREATOR_ID = 7012;
+/** Unused7012: Unused */
+const SEND_DEX_ERROR__UNUSED7012 = 7012;
 /** QuoteMintPriceUnset: Quote mint has no USDC price on its nexus reward state */
 const SEND_DEX_ERROR__QUOTE_MINT_PRICE_UNSET = 7013;
 /** TransferFeeNotSettleable: Token-2022 transfer fee schedule cannot settle the exact amount */
 const SEND_DEX_ERROR__TRANSFER_FEE_NOT_SETTLEABLE = 7014;
+/** CreatorFeeTooHigh: Creator fee exceeds the partner's maximum */
+const SEND_DEX_ERROR__CREATOR_FEE_TOO_HIGH = 7015;
+/** CreatorFeeModeNotAllowed: Creator fee mode is not allowed by the partner config */
+const SEND_DEX_ERROR__CREATOR_FEE_MODE_NOT_ALLOWED = 7016;
 /** InsufficientLiquidity: Insufficient liquidity */
 const SEND_DEX_ERROR__INSUFFICIENT_LIQUIDITY = 7100;
 /** InvalidAmount: Invalid amount */
 const SEND_DEX_ERROR__INVALID_AMOUNT = 7101;
 const sendDexErrorMessages = {
 	[SEND_DEX_ERROR__ARITHMETIC_OVERFLOW]: `Arithmetic overflow`,
+	[SEND_DEX_ERROR__CREATOR_FEE_MODE_NOT_ALLOWED]: `Creator fee mode is not allowed by the partner config`,
+	[SEND_DEX_ERROR__CREATOR_FEE_TOO_HIGH]: `Creator fee exceeds the partner's maximum`,
 	[SEND_DEX_ERROR__INSUFFICIENT_BALANCE]: `Insufficient balance in source account`,
 	[SEND_DEX_ERROR__INSUFFICIENT_LIQUIDITY]: `Insufficient liquidity`,
 	[SEND_DEX_ERROR__INSUFFICIENT_POOL_BALANCE]: `Insufficient pool balance`,
 	[SEND_DEX_ERROR__INVALID_AMOUNT]: `Invalid amount`,
 	[SEND_DEX_ERROR__INVALID_AUTHORITY]: `Invalid authority`,
 	[SEND_DEX_ERROR__INVALID_BASE_MINT]: `Invalid base mint`,
-	[SEND_DEX_ERROR__INVALID_CREATOR_HASH]: `creator_hash does not match (creator_platform, creator_id)`,
-	[SEND_DEX_ERROR__INVALID_CREATOR_ID]: `Creator identity is not a decodable wallet address`,
+	[SEND_DEX_ERROR__INVALID_COIN_CREATOR]: `Invalid coin creator`,
 	[SEND_DEX_ERROR__INVALID_DEPOSIT]: `Invalid deposit`,
 	[SEND_DEX_ERROR__INVALID_PLATFORM_CONFIG]: `Platform config cannot be the default address`,
 	[SEND_DEX_ERROR__INVALID_POOL_BALANCE]: `Invalid pool balance`,
@@ -537,6 +636,7 @@ const sendDexErrorMessages = {
 	[SEND_DEX_ERROR__TEXT_TOO_LONG]: `Text too long`,
 	[SEND_DEX_ERROR__TRANSFER_FEE_NOT_SETTLEABLE]: `Token-2022 transfer fee schedule cannot settle the exact amount`,
 	[SEND_DEX_ERROR__UNAUTHORIZED]: `Unauthorized`,
+	[SEND_DEX_ERROR__UNUSED7012]: `Unused`,
 	[SEND_DEX_ERROR__USER_TOKEN_ACCOUNT_INVALID]: `User token account is not an initialized token account`,
 	[SEND_DEX_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY]: `User token account is not owned by the trading user`,
 	[SEND_DEX_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT]: `User token account mint does not match the trade`,
@@ -552,14 +652,15 @@ function isSendDexError(error, transactionMessage, code) {
 //#region src/dex/generated/errors/index.ts
 var errors_exports$2 = /* @__PURE__ */ __exportAll({
 	SEND_DEX_ERROR__ARITHMETIC_OVERFLOW: () => SEND_DEX_ERROR__ARITHMETIC_OVERFLOW,
+	SEND_DEX_ERROR__CREATOR_FEE_MODE_NOT_ALLOWED: () => SEND_DEX_ERROR__CREATOR_FEE_MODE_NOT_ALLOWED,
+	SEND_DEX_ERROR__CREATOR_FEE_TOO_HIGH: () => SEND_DEX_ERROR__CREATOR_FEE_TOO_HIGH,
 	SEND_DEX_ERROR__INSUFFICIENT_BALANCE: () => SEND_DEX_ERROR__INSUFFICIENT_BALANCE,
 	SEND_DEX_ERROR__INSUFFICIENT_LIQUIDITY: () => SEND_DEX_ERROR__INSUFFICIENT_LIQUIDITY,
 	SEND_DEX_ERROR__INSUFFICIENT_POOL_BALANCE: () => SEND_DEX_ERROR__INSUFFICIENT_POOL_BALANCE,
 	SEND_DEX_ERROR__INVALID_AMOUNT: () => SEND_DEX_ERROR__INVALID_AMOUNT,
 	SEND_DEX_ERROR__INVALID_AUTHORITY: () => SEND_DEX_ERROR__INVALID_AUTHORITY,
 	SEND_DEX_ERROR__INVALID_BASE_MINT: () => SEND_DEX_ERROR__INVALID_BASE_MINT,
-	SEND_DEX_ERROR__INVALID_CREATOR_HASH: () => SEND_DEX_ERROR__INVALID_CREATOR_HASH,
-	SEND_DEX_ERROR__INVALID_CREATOR_ID: () => SEND_DEX_ERROR__INVALID_CREATOR_ID,
+	SEND_DEX_ERROR__INVALID_COIN_CREATOR: () => SEND_DEX_ERROR__INVALID_COIN_CREATOR,
 	SEND_DEX_ERROR__INVALID_DEPOSIT: () => SEND_DEX_ERROR__INVALID_DEPOSIT,
 	SEND_DEX_ERROR__INVALID_PLATFORM_CONFIG: () => SEND_DEX_ERROR__INVALID_PLATFORM_CONFIG,
 	SEND_DEX_ERROR__INVALID_POOL_BALANCE: () => SEND_DEX_ERROR__INVALID_POOL_BALANCE,
@@ -577,6 +678,7 @@ var errors_exports$2 = /* @__PURE__ */ __exportAll({
 	SEND_DEX_ERROR__TEXT_TOO_LONG: () => SEND_DEX_ERROR__TEXT_TOO_LONG,
 	SEND_DEX_ERROR__TRANSFER_FEE_NOT_SETTLEABLE: () => SEND_DEX_ERROR__TRANSFER_FEE_NOT_SETTLEABLE,
 	SEND_DEX_ERROR__UNAUTHORIZED: () => SEND_DEX_ERROR__UNAUTHORIZED,
+	SEND_DEX_ERROR__UNUSED7012: () => SEND_DEX_ERROR__UNUSED7012,
 	SEND_DEX_ERROR__USER_TOKEN_ACCOUNT_INVALID: () => SEND_DEX_ERROR__USER_TOKEN_ACCOUNT_INVALID,
 	SEND_DEX_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY: () => SEND_DEX_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY,
 	SEND_DEX_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT: () => SEND_DEX_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT,
@@ -586,6 +688,44 @@ var errors_exports$2 = /* @__PURE__ */ __exportAll({
 	sendDexErrorMessages: () => sendDexErrorMessages
 });
 //#endregion
+//#region src/dex/generated/pdas/creatorFeeConfig.ts
+/**
+* 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
+*/
+async function findCreatorFeeConfigPda$1(seeds) {
+	return await getProgramDerivedAddress({
+		programAddress: SEND_DEX_PROGRAM_ADDRESS,
+		seeds: [
+			getBytesEncoder().encode(new Uint8Array([
+				99,
+				114,
+				101,
+				97,
+				116,
+				111,
+				114,
+				95,
+				102,
+				101,
+				101,
+				95,
+				99,
+				111,
+				110,
+				102,
+				105,
+				103
+			])),
+			getAddressEncoder().encode(seeds.baseMint),
+			getAddressEncoder().encode(seeds.quoteMint)
+		]
+	});
+}
+//#endregion
 //#region src/dex/generated/pdas/eventAuthority.ts
 const EVENT_AUTHORITY_PDA_ADDRESS$2 = "4pTDYKRFdmxTQYFceGZkzPGd3kb8ShMA9n6XKRaPZn8t";
 function findEventAuthorityPda$2() {
@@ -690,6 +830,7 @@ var pdas_exports$2 = /* @__PURE__ */ __exportAll({
 	EVENT_AUTHORITY_PDA_ADDRESS: () => EVENT_AUTHORITY_PDA_ADDRESS$2,
 	GLOBAL_CONFIG_PDA_ADDRESS: () => GLOBAL_CONFIG_PDA_ADDRESS$2,
 	WSOL_REWARD_ACCRUAL_PDA_ADDRESS: () => WSOL_REWARD_ACCRUAL_PDA_ADDRESS$1,
+	findCreatorFeeConfigPda: () => findCreatorFeeConfigPda$1,
 	findEventAuthorityPda: () => findEventAuthorityPda$2,
 	findGlobalConfigPda: () => findGlobalConfigPda$2,
 	findLpMintPda: () => findLpMintPda,
@@ -755,7 +896,7 @@ function getCreatorClaimEventDecoder$1() {
 		["quoteMint", getAddressDecoder()],
 		["platformConfig", getAddressDecoder()],
 		["coinCreator", getAddressDecoder()],
-		["creatorFeeConfig", getAddressDecoder()],
+		["padding0", getArrayDecoder(getU64Decoder(), { size: 4 })],
 		["claimer", getAddressDecoder()],
 		["destinationOwner", getAddressDecoder()],
 		["amount", getU64Decoder()],
@@ -898,7 +1039,7 @@ function getPoolCreateEventDecoder() {
 		["quoteMint", getAddressDecoder()],
 		["quoteDecimals", getU8Decoder()],
 		["coinCreator", getAddressDecoder()],
-		["creatorFeeConfig", getAddressDecoder()],
+		["padding0", getArrayDecoder(getU64Decoder(), { size: 4 })],
 		["platformConfig", getAddressDecoder()],
 		["baseVault", getAddressDecoder()],
 		["quoteVault", getAddressDecoder()],
@@ -906,7 +1047,9 @@ function getPoolCreateEventDecoder() {
 		["lpMinted", getU64Decoder()],
 		["baseReserves", getU64Decoder()],
 		["quoteReserves", getU64Decoder()],
-		["timestamp", getI64Decoder()]
+		["timestamp", getI64Decoder()],
+		["creatorFeeMode", getU8Decoder()],
+		["creatorFeeBps", getU16Decoder()]
 	]);
 }
 /**
@@ -1043,9 +1186,7 @@ function getTokenCreateEventDecoder$1() {
 		["quoteMint", getAddressDecoder()],
 		["quoteDecimals", getU8Decoder()],
 		["coinCreator", getAddressDecoder()],
-		["creatorPlatform", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
-		["creatorId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
-		["creatorFeeConfig", getAddressDecoder()],
+		["padding0", getArrayDecoder(getU64Decoder(), { size: 5 })],
 		["platformConfig", getAddressDecoder()],
 		["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
 		["symbol", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
@@ -1055,7 +1196,9 @@ function getTokenCreateEventDecoder$1() {
 		["creationFee", getU64Decoder()],
 		["baseReserves", getU64Decoder()],
 		["quoteReserves", getU64Decoder()],
-		["timestamp", getI64Decoder()]
+		["timestamp", getI64Decoder()],
+		["creatorFeeMode", getU8Decoder()],
+		["creatorFeeBps", getU16Decoder()]
 	]);
 }
 /**
@@ -1122,7 +1265,7 @@ function getTradeEventDecoder$1() {
 		["quoteMint", getAddressDecoder()],
 		["user", getAddressDecoder()],
 		["coinCreator", getAddressDecoder()],
-		["creatorFeeConfig", getAddressDecoder()],
+		["padding0", getArrayDecoder(getU64Decoder(), { size: 4 })],
 		["platformConfig", getAddressDecoder()],
 		["baseAmount", getU64Decoder()],
 		["quoteAmountGross", getU64Decoder()],
@@ -1137,7 +1280,9 @@ function getTradeEventDecoder$1() {
 		["quoteTransferFee", getU64Decoder()],
 		["baseReserves", getU64Decoder()],
 		["quoteReserves", getU64Decoder()],
-		["timestamp", getI64Decoder()]
+		["timestamp", getI64Decoder()],
+		["creatorFeeMode", getU8Decoder()],
+		["creatorFeeBps", getU16Decoder()]
 	]);
 }
 /**
@@ -2016,7 +2161,7 @@ async function getClaimCreatorFeesInstructionAsync$1(input) {
 		},
 		creatorFeeConfig: {
 			value: input.creatorFeeConfig ?? null,
-			isWritable: false
+			isWritable: true
 		},
 		nexusGlobalConfig: {
 			value: null,
@@ -2067,6 +2212,10 @@ async function getClaimCreatorFeesInstructionAsync$1(input) {
 		baseMint: getAddressFromResolvedInstructionAccount("baseMint", accounts.baseMint.value),
 		quoteMint: getAddressFromResolvedInstructionAccount("quoteMint", accounts.quoteMint.value)
 	});
+	if (!accounts.creatorFeeConfig.value) accounts.creatorFeeConfig.value = await findCreatorFeeConfigPda$1({
+		baseMint: getAddressFromResolvedInstructionAccount("baseMint", accounts.baseMint.value),
+		quoteMint: getAddressFromResolvedInstructionAccount("quoteMint", accounts.quoteMint.value)
+	});
 	if (!accounts.nexusGlobalConfig.value) accounts.nexusGlobalConfig.value = "3bycfBeRULfXYqcg3DmiYFBjv6mMVidMuqKdFZJTGdNr";
 	if (!accounts.quoteVault.value) accounts.quoteVault.value = await getProgramDerivedAddress({
 		programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
@@ -2128,7 +2277,7 @@ function getClaimCreatorFeesInstruction$1(input) {
 		},
 		creatorFeeConfig: {
 			value: input.creatorFeeConfig ?? null,
-			isWritable: false
+			isWritable: true
 		},
 		nexusGlobalConfig: {
 			value: null,
@@ -3391,6 +3540,7 @@ function sendDexProgram() {
 			pdas: {
 				pool: findPoolPda,
 				eventAuthority: findEventAuthorityPda$2,
+				creatorFeeConfig: findCreatorFeeConfigPda$1,
 				rewardAccrual: findRewardAccrualPda$1,
 				globalConfig: findGlobalConfigPda$2,
 				lpMint: findLpMintPda,
@@ -3437,12 +3587,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 +3606,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 +3615,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 +3635,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 +3659,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 +3670,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 +3734,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 +3749,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 +3769,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 +3787,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 +3813,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 +3841,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 +3899,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 +3973,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.
@@ -3913,7 +4103,7 @@ function getBondingCurveEncoder() {
 		["quoteMint", getAddressEncoder()],
 		["quoteDecimals", getU8Encoder()],
 		["coinCreator", getAddressEncoder()],
-		["creatorFeeConfig", getAddressEncoder()],
+		["padding0", getArrayEncoder(getU64Encoder(), { size: 4 })],
 		["partner", getAddressEncoder()],
 		["baseVault", getAddressEncoder()],
 		["quoteVault", getAddressEncoder()],
@@ -3925,7 +4115,10 @@ function getBondingCurveEncoder() {
 		["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
@@ -3947,7 +4140,7 @@ function getBondingCurveDecoder() {
 		["quoteMint", getAddressDecoder()],
 		["quoteDecimals", getU8Decoder()],
 		["coinCreator", getAddressDecoder()],
-		["creatorFeeConfig", getAddressDecoder()],
+		["padding0", getArrayDecoder(getU64Decoder(), { size: 4 })],
 		["partner", getAddressDecoder()],
 		["baseVault", getAddressDecoder()],
 		["quoteVault", getAddressDecoder()],
@@ -3959,7 +4152,10 @@ function getBondingCurveDecoder() {
 		["protocolOwed", getU64Decoder()],
 		["creatorOwed", getU64Decoder()],
 		["platformConfig", getAddressDecoder()],
-		["reserved", fixDecoderSize(getBytesDecoder(), 64)]
+		["creatorFeeMode", getU8Decoder()],
+		["creatorFeeBps", getU16Decoder()],
+		["dexCreatorFeeBps", getU16Decoder()],
+		["reserved", fixDecoderSize(getBytesDecoder(), 256)]
 	]);
 }
 /** Gets the codec for {@link BondingCurve} account data. */
@@ -3981,24 +4177,43 @@ 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;
+	return 618;
 }
 //#endregion
 //#region src/launchpad/generated/accounts/globalConfig.ts
@@ -4078,21 +4293,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 +4399,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;
@@ -4308,12 +4561,16 @@ const SEND_LAUNCHPAD_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT = 7009;
 const SEND_LAUNCHPAD_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY = 7010;
 /** NothingToClaim: Nothing to claim */
 const SEND_LAUNCHPAD_ERROR__NOTHING_TO_CLAIM = 7011;
-/** InvalidCreatorId: Creator identity is not a decodable wallet address */
-const SEND_LAUNCHPAD_ERROR__INVALID_CREATOR_ID = 7012;
+/** Unused7012: Unused */
+const SEND_LAUNCHPAD_ERROR__UNUSED7012 = 7012;
 /** QuoteMintPriceUnset: Quote mint has no USDC price on its nexus reward state */
 const SEND_LAUNCHPAD_ERROR__QUOTE_MINT_PRICE_UNSET = 7013;
 /** TransferFeeNotSettleable: Token-2022 transfer fee schedule cannot settle the exact amount */
 const SEND_LAUNCHPAD_ERROR__TRANSFER_FEE_NOT_SETTLEABLE = 7014;
+/** CreatorFeeTooHigh: Creator fee exceeds the partner's maximum */
+const SEND_LAUNCHPAD_ERROR__CREATOR_FEE_TOO_HIGH = 7015;
+/** CreatorFeeModeNotAllowed: Creator fee mode is not allowed by the partner config */
+const SEND_LAUNCHPAD_ERROR__CREATOR_FEE_MODE_NOT_ALLOWED = 7016;
 /** InsufficientLiquidity: Insufficient liquidity */
 const SEND_LAUNCHPAD_ERROR__INSUFFICIENT_LIQUIDITY = 7100;
 /** InvalidAmount: Invalid amount */
@@ -4323,6 +4580,8 @@ const sendLaunchpadErrorMessages = {
 	[SEND_LAUNCHPAD_ERROR__ARITHMETIC_OVERFLOW]: `Arithmetic overflow`,
 	[SEND_LAUNCHPAD_ERROR__BASE_MINT_NOT_FOUND]: `Base mint not found`,
 	[SEND_LAUNCHPAD_ERROR__BLOCKED_BY_HELD_SUPPLY]: `Blocked by held supply`,
+	[SEND_LAUNCHPAD_ERROR__CREATOR_FEE_MODE_NOT_ALLOWED]: `Creator fee mode is not allowed by the partner config`,
+	[SEND_LAUNCHPAD_ERROR__CREATOR_FEE_TOO_HIGH]: `Creator fee exceeds the partner's maximum`,
 	[SEND_LAUNCHPAD_ERROR__CURVE_IS_LIVE]: `Curve is live`,
 	[SEND_LAUNCHPAD_ERROR__INSUFFICIENT_BALANCE]: `Insufficient balance in source account`,
 	[SEND_LAUNCHPAD_ERROR__INSUFFICIENT_LIQUIDITY]: `Insufficient liquidity`,
@@ -4330,7 +4589,6 @@ const sendLaunchpadErrorMessages = {
 	[SEND_LAUNCHPAD_ERROR__INVALID_AUTHORITY]: `Invalid authority`,
 	[SEND_LAUNCHPAD_ERROR__INVALID_BASE_MINT]: `Invalid base mint`,
 	[SEND_LAUNCHPAD_ERROR__INVALID_COIN_CREATOR]: `Invalid coin creator`,
-	[SEND_LAUNCHPAD_ERROR__INVALID_CREATOR_ID]: `Creator identity is not a decodable wallet address`,
 	[SEND_LAUNCHPAD_ERROR__INVALID_PYTH_ACCOUNT]: `Invalid Pyth price account`,
 	[SEND_LAUNCHPAD_ERROR__INVALID_PYTH_FEED]: `Invalid Pyth feed ID`,
 	[SEND_LAUNCHPAD_ERROR__INVALID_QUOTE_MINT]: `Invalid quote mint`,
@@ -4348,6 +4606,7 @@ const sendLaunchpadErrorMessages = {
 	[SEND_LAUNCHPAD_ERROR__TOKEN_CREATION_DISABLED]: `Token creation is disabled`,
 	[SEND_LAUNCHPAD_ERROR__TRANSFER_FEE_NOT_SETTLEABLE]: `Token-2022 transfer fee schedule cannot settle the exact amount`,
 	[SEND_LAUNCHPAD_ERROR__UNAUTHORIZED]: `Unauthorized`,
+	[SEND_LAUNCHPAD_ERROR__UNUSED7012]: `Unused`,
 	[SEND_LAUNCHPAD_ERROR__USER_TOKEN_ACCOUNT_INVALID]: `User token account is not an initialized token account`,
 	[SEND_LAUNCHPAD_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY]: `User token account is not owned by the trading user`,
 	[SEND_LAUNCHPAD_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT]: `User token account mint does not match the trade`,
@@ -4366,6 +4625,8 @@ var errors_exports$1 = /* @__PURE__ */ __exportAll({
 	SEND_LAUNCHPAD_ERROR__ARITHMETIC_OVERFLOW: () => SEND_LAUNCHPAD_ERROR__ARITHMETIC_OVERFLOW,
 	SEND_LAUNCHPAD_ERROR__BASE_MINT_NOT_FOUND: () => SEND_LAUNCHPAD_ERROR__BASE_MINT_NOT_FOUND,
 	SEND_LAUNCHPAD_ERROR__BLOCKED_BY_HELD_SUPPLY: () => SEND_LAUNCHPAD_ERROR__BLOCKED_BY_HELD_SUPPLY,
+	SEND_LAUNCHPAD_ERROR__CREATOR_FEE_MODE_NOT_ALLOWED: () => SEND_LAUNCHPAD_ERROR__CREATOR_FEE_MODE_NOT_ALLOWED,
+	SEND_LAUNCHPAD_ERROR__CREATOR_FEE_TOO_HIGH: () => SEND_LAUNCHPAD_ERROR__CREATOR_FEE_TOO_HIGH,
 	SEND_LAUNCHPAD_ERROR__CURVE_IS_LIVE: () => SEND_LAUNCHPAD_ERROR__CURVE_IS_LIVE,
 	SEND_LAUNCHPAD_ERROR__INSUFFICIENT_BALANCE: () => SEND_LAUNCHPAD_ERROR__INSUFFICIENT_BALANCE,
 	SEND_LAUNCHPAD_ERROR__INSUFFICIENT_LIQUIDITY: () => SEND_LAUNCHPAD_ERROR__INSUFFICIENT_LIQUIDITY,
@@ -4373,7 +4634,6 @@ var errors_exports$1 = /* @__PURE__ */ __exportAll({
 	SEND_LAUNCHPAD_ERROR__INVALID_AUTHORITY: () => SEND_LAUNCHPAD_ERROR__INVALID_AUTHORITY,
 	SEND_LAUNCHPAD_ERROR__INVALID_BASE_MINT: () => SEND_LAUNCHPAD_ERROR__INVALID_BASE_MINT,
 	SEND_LAUNCHPAD_ERROR__INVALID_COIN_CREATOR: () => SEND_LAUNCHPAD_ERROR__INVALID_COIN_CREATOR,
-	SEND_LAUNCHPAD_ERROR__INVALID_CREATOR_ID: () => SEND_LAUNCHPAD_ERROR__INVALID_CREATOR_ID,
 	SEND_LAUNCHPAD_ERROR__INVALID_PYTH_ACCOUNT: () => SEND_LAUNCHPAD_ERROR__INVALID_PYTH_ACCOUNT,
 	SEND_LAUNCHPAD_ERROR__INVALID_PYTH_FEED: () => SEND_LAUNCHPAD_ERROR__INVALID_PYTH_FEED,
 	SEND_LAUNCHPAD_ERROR__INVALID_QUOTE_MINT: () => SEND_LAUNCHPAD_ERROR__INVALID_QUOTE_MINT,
@@ -4391,6 +4651,7 @@ var errors_exports$1 = /* @__PURE__ */ __exportAll({
 	SEND_LAUNCHPAD_ERROR__TOKEN_CREATION_DISABLED: () => SEND_LAUNCHPAD_ERROR__TOKEN_CREATION_DISABLED,
 	SEND_LAUNCHPAD_ERROR__TRANSFER_FEE_NOT_SETTLEABLE: () => SEND_LAUNCHPAD_ERROR__TRANSFER_FEE_NOT_SETTLEABLE,
 	SEND_LAUNCHPAD_ERROR__UNAUTHORIZED: () => SEND_LAUNCHPAD_ERROR__UNAUTHORIZED,
+	SEND_LAUNCHPAD_ERROR__UNUSED7012: () => SEND_LAUNCHPAD_ERROR__UNUSED7012,
 	SEND_LAUNCHPAD_ERROR__USER_TOKEN_ACCOUNT_INVALID: () => SEND_LAUNCHPAD_ERROR__USER_TOKEN_ACCOUNT_INVALID,
 	SEND_LAUNCHPAD_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY: () => SEND_LAUNCHPAD_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY,
 	SEND_LAUNCHPAD_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT: () => SEND_LAUNCHPAD_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT,
@@ -4433,6 +4694,44 @@ async function findBondingCurvePda(seeds) {
 	});
 }
 //#endregion
+//#region src/launchpad/generated/pdas/creatorFeeConfig.ts
+/**
+* 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
+*/
+async function findCreatorFeeConfigPda(seeds) {
+	return await getProgramDerivedAddress({
+		programAddress: SEND_LAUNCHPAD_PROGRAM_ADDRESS,
+		seeds: [
+			getBytesEncoder().encode(new Uint8Array([
+				99,
+				114,
+				101,
+				97,
+				116,
+				111,
+				114,
+				95,
+				102,
+				101,
+				101,
+				95,
+				99,
+				111,
+				110,
+				102,
+				105,
+				103
+			])),
+			getAddressEncoder().encode(seeds.baseMint),
+			getAddressEncoder().encode(seeds.quoteMint)
+		]
+	});
+}
+//#endregion
 //#region src/launchpad/generated/pdas/eventAuthority.ts
 const EVENT_AUTHORITY_PDA_ADDRESS$1 = "FJVebqCthxH6JM8vvkJb7yRYA7Emsib1C1vu4ZePSP3T";
 function findEventAuthorityPda$1() {
@@ -4494,6 +4793,7 @@ var pdas_exports$1 = /* @__PURE__ */ __exportAll({
 	MIGRATION_AUTHORITY_PDA_ADDRESS: () => MIGRATION_AUTHORITY_PDA_ADDRESS,
 	WSOL_REWARD_ACCRUAL_PDA_ADDRESS: () => WSOL_REWARD_ACCRUAL_PDA_ADDRESS,
 	findBondingCurvePda: () => findBondingCurvePda,
+	findCreatorFeeConfigPda: () => findCreatorFeeConfigPda,
 	findEventAuthorityPda: () => findEventAuthorityPda$1,
 	findGlobalConfigPda: () => findGlobalConfigPda$1,
 	findMigrationAuthorityPda: () => findMigrationAuthorityPda,
@@ -4501,80 +4801,6 @@ var pdas_exports$1 = /* @__PURE__ */ __exportAll({
 	findWsolRewardAccrualPda: () => findWsolRewardAccrualPda
 });
 //#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. */
-async function creatorHashFromId(creatorPlatform, creatorId) {
-	const encoder = new TextEncoder();
-	const platformBuf = encoder.encode(creatorPlatform);
-	const idBuf = encoder.encode(creatorId);
-	if (platformBuf.length > MAX_CREATOR_PLATFORM_LEN) throw new RangeError(`creatorPlatform exceeds ${MAX_CREATOR_PLATFORM_LEN} bytes (got ${platformBuf.length})`);
-	const platformLength = /* @__PURE__ */ new Uint8Array(4);
-	new DataView(platformLength.buffer).setUint32(0, platformBuf.length, true);
-	const idLength = /* @__PURE__ */ new Uint8Array(4);
-	new DataView(idLength.buffer).setUint32(0, idBuf.length, true);
-	const buf = new Uint8Array(4 + platformBuf.length + 4 + idBuf.length);
-	buf.set(platformLength, 0);
-	buf.set(platformBuf, 4);
-	buf.set(idLength, 4 + platformBuf.length);
-	buf.set(idBuf, 4 + platformBuf.length + 4);
-	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. */
-function encodeCreatorId(text, length) {
-	const bytes = new TextEncoder().encode(text);
-	if (bytes.length > length) throw new RangeError(`text exceeds ${length} bytes (got ${bytes.length})`);
-	const out = new Uint8Array(length);
-	out.set(bytes, 0);
-	return out;
-}
-/** Strips NUL padding. Pass this, never the padded array, to {@link creatorHashFromId}: the hash is length-prefixed. */
-function decodeCreatorId(bytes) {
-	let end = bytes.length;
-	while (end > 0 && bytes[end - 1] === 0) end -= 1;
-	return new TextDecoder().decode(bytes.slice(0, end));
-}
-//#endregion
-//#region src/nexus/generated/pdas/creatorFeeConfig.ts
-/**
-* 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
-*/
-async function findCreatorFeeConfigPda(seeds) {
-	return await getProgramDerivedAddress({
-		programAddress: SEND_NEXUS_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
-			])),
-			getAddressEncoder().encode(seeds.creatorHash),
-			getAddressEncoder().encode(seeds.quoteMint)
-		]
-	});
-}
-//#endregion
 //#region src/launchpad/generated/instructions/createToken.ts
 /**
 * This code was AUTOGENERATED using the Codama library.
@@ -4600,12 +4826,12 @@ function getCreateTokenInstructionDataEncoder() {
 	return transformEncoder(getStructEncoder([
 		["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
 		["platformConfig", getAddressEncoder()],
-		["creatorPlatform", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
-		["creatorId", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
-		["creatorHash", getAddressEncoder()],
 		["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
 		["symbol", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
-		["uri", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+		["uri", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+		["creatorFeeMode", getU8Encoder()],
+		["creatorFeeBps", getU16Encoder()],
+		["dexCreatorFeeBps", getU16Encoder()]
 	]), (value) => ({
 		...value,
 		discriminator: CREATE_TOKEN_DISCRIMINATOR
@@ -4615,12 +4841,12 @@ function getCreateTokenInstructionDataDecoder() {
 	return getStructDecoder([
 		["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
 		["platformConfig", getAddressDecoder()],
-		["creatorPlatform", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
-		["creatorId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
-		["creatorHash", getAddressDecoder()],
 		["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
 		["symbol", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
-		["uri", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+		["uri", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+		["creatorFeeMode", getU8Decoder()],
+		["creatorFeeBps", getU16Decoder()],
+		["dexCreatorFeeBps", getU16Decoder()]
 	]);
 }
 function getCreateTokenInstructionDataCodec() {
@@ -4764,33 +4990,9 @@ async function getCreateTokenInstructionAsync(input) {
 			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("quoteMint", accounts.quoteMint.value))
 		]
 	});
-	if (!accounts.creatorFeeConfig.value) accounts.creatorFeeConfig.value = await getProgramDerivedAddress({
-		programAddress: "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX",
-		seeds: [
-			getBytesEncoder().encode(new Uint8Array([
-				99,
-				114,
-				101,
-				97,
-				116,
-				111,
-				114,
-				95,
-				102,
-				101,
-				101,
-				95,
-				98,
-				97,
-				108,
-				97,
-				110,
-				99,
-				101
-			])),
-			getAddressEncoder().encode(getNonNullResolvedInstructionInput("creatorHash", args.creatorHash)),
-			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("quoteMint", accounts.quoteMint.value))
-		]
+	if (!accounts.creatorFeeConfig.value) accounts.creatorFeeConfig.value = await findCreatorFeeConfigPda({
+		baseMint: getAddressFromResolvedInstructionAccount("baseMint", accounts.baseMint.value),
+		quoteMint: getAddressFromResolvedInstructionAccount("quoteMint", accounts.quoteMint.value)
 	});
 	if (!accounts.nexusProgram.value) accounts.nexusProgram.value = "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX";
 	if (!accounts.nexusGlobalConfig.value) accounts.nexusGlobalConfig.value = "3bycfBeRULfXYqcg3DmiYFBjv6mMVidMuqKdFZJTGdNr";
@@ -6475,7 +6677,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 +6738,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 +6786,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;
@@ -6610,33 +6813,25 @@ var create_exports = /* @__PURE__ */ __exportAll({
 	buildCreateTokenInstruction: () => buildCreateTokenInstruction
 });
 async function buildCreateTokenInstruction(params) {
-	return buildCreateTokenInstructionWithHash(params, await creatorHashFromId(params.creatorPlatform, params.creatorId));
-}
-async function buildCreateTokenInstructionWithHash(params, creatorHash) {
-	const [creatorFeeConfig] = await findCreatorFeeConfigPda({
-		creatorHash,
-		quoteMint: params.quoteMint
-	});
 	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
+		uri: params.uri,
+		creatorFeeMode: params.creatorFeeMode,
+		creatorFeeBps: params.creatorFeeBps,
+		dexCreatorFeeBps: params.dexCreatorFeeBps
 	});
 }
 async function buildCreateAndBuyInstructions(params) {
-	const instructions = [await buildCreateTokenInstructionWithHash(params, await creatorHashFromId(params.creatorPlatform, params.creatorId))];
+	const instructions = [await buildCreateTokenInstruction(params)];
 	let quote;
 	if (params.buyQuoteAmount > 0n) {
 		const buyResult = await buyExactIn({
@@ -6720,7 +6915,7 @@ function getCompleteEventDecoder() {
 		["baseMint", getAddressDecoder()],
 		["quoteMint", getAddressDecoder()],
 		["coinCreator", getAddressDecoder()],
-		["creatorFeeConfig", getAddressDecoder()],
+		["padding0", getArrayDecoder(getU64Decoder(), { size: 4 })],
 		["platformConfig", getAddressDecoder()],
 		["curvePartner", getAddressDecoder()],
 		["isPartner", getBooleanDecoder()],
@@ -6792,7 +6987,7 @@ function getCreatorClaimEventDecoder() {
 		["quoteMint", getAddressDecoder()],
 		["platformConfig", getAddressDecoder()],
 		["coinCreator", getAddressDecoder()],
-		["creatorFeeConfig", getAddressDecoder()],
+		["padding0", getArrayDecoder(getU64Decoder(), { size: 4 })],
 		["claimer", getAddressDecoder()],
 		["destinationOwner", getAddressDecoder()],
 		["amount", getU64Decoder()],
@@ -6864,7 +7059,7 @@ function getMigrateEventDecoder() {
 		["quoteMint", getAddressDecoder()],
 		["pool", getAddressDecoder()],
 		["coinCreator", getAddressDecoder()],
-		["creatorFeeConfig", getAddressDecoder()],
+		["padding0", getArrayDecoder(getU64Decoder(), { size: 4 })],
 		["platformConfig", getAddressDecoder()],
 		["baseAmount", getU64Decoder()],
 		["quoteAmount", getU64Decoder()],
@@ -7077,9 +7272,7 @@ function getTokenCreateEventDecoder() {
 		["quoteMint", getAddressDecoder()],
 		["quoteDecimals", getU8Decoder()],
 		["coinCreator", getAddressDecoder()],
-		["creatorPlatform", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
-		["creatorId", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
-		["creatorFeeConfig", getAddressDecoder()],
+		["padding0", getArrayDecoder(getU64Decoder(), { size: 5 })],
 		["platformConfig", getAddressDecoder()],
 		["name", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
 		["symbol", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
@@ -7091,7 +7284,10 @@ function getTokenCreateEventDecoder() {
 		["virtualQuoteReserves", getU64Decoder()],
 		["realBaseReserves", getU64Decoder()],
 		["realQuoteReserves", getU64Decoder()],
-		["timestamp", getI64Decoder()]
+		["timestamp", getI64Decoder()],
+		["creatorFeeMode", getU8Decoder()],
+		["creatorFeeBps", getU16Decoder()],
+		["dexCreatorFeeBps", getU16Decoder()]
 	]);
 }
 /**
@@ -7158,7 +7354,7 @@ function getTradeEventDecoder() {
 		["quoteMint", getAddressDecoder()],
 		["user", getAddressDecoder()],
 		["coinCreator", getAddressDecoder()],
-		["creatorFeeConfig", getAddressDecoder()],
+		["padding0", getArrayDecoder(getU64Decoder(), { size: 4 })],
 		["platformConfig", getAddressDecoder()],
 		["baseAmount", getU64Decoder()],
 		["quoteAmountGross", getU64Decoder()],
@@ -7174,7 +7370,9 @@ function getTradeEventDecoder() {
 		["virtualQuoteReserves", getU64Decoder()],
 		["realBaseReserves", getU64Decoder()],
 		["realQuoteReserves", getU64Decoder()],
-		["timestamp", getI64Decoder()]
+		["timestamp", getI64Decoder()],
+		["creatorFeeMode", getU8Decoder()],
+		["creatorFeeBps", getU16Decoder()]
 	]);
 }
 /**
@@ -7381,7 +7579,7 @@ async function getClaimCreatorFeesInstructionAsync(input) {
 		},
 		creatorFeeConfig: {
 			value: input.creatorFeeConfig ?? null,
-			isWritable: false
+			isWritable: true
 		},
 		nexusGlobalConfig: {
 			value: null,
@@ -7432,6 +7630,10 @@ async function getClaimCreatorFeesInstructionAsync(input) {
 		baseMint: getAddressFromResolvedInstructionAccount("baseMint", accounts.baseMint.value),
 		quoteMint: getAddressFromResolvedInstructionAccount("quoteMint", accounts.quoteMint.value)
 	});
+	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";
 	if (!accounts.quoteVault.value) accounts.quoteVault.value = await getProgramDerivedAddress({
 		programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
@@ -7493,7 +7695,7 @@ function getClaimCreatorFeesInstruction(input) {
 		},
 		creatorFeeConfig: {
 			value: input.creatorFeeConfig ?? null,
-			isWritable: false
+			isWritable: true
 		},
 		nexusGlobalConfig: {
 			value: null,
@@ -7975,7 +8177,7 @@ async function getMigrateInstructionAsync(input) {
 		},
 		creatorFeeConfig: {
 			value: input.creatorFeeConfig ?? null,
-			isWritable: false
+			isWritable: true
 		},
 		baseTokenProgram: {
 			value: null,
@@ -8000,6 +8202,10 @@ async function getMigrateInstructionAsync(input) {
 		program: {
 			value: null,
 			isWritable: false
+		},
+		dexCreatorFeeConfig: {
+			value: input.dexCreatorFeeConfig ?? null,
+			isWritable: true
 		}
 	};
 	if (!accounts.bondingCurve.value) accounts.bondingCurve.value = await findBondingCurvePda({
@@ -8055,11 +8261,42 @@ async function getMigrateInstructionAsync(input) {
 	});
 	if (!accounts.dexEventAuthority.value) accounts.dexEventAuthority.value = "4pTDYKRFdmxTQYFceGZkzPGd3kb8ShMA9n6XKRaPZn8t";
 	if (!accounts.nexusProgram.value) accounts.nexusProgram.value = "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX";
+	if (!accounts.creatorFeeConfig.value) accounts.creatorFeeConfig.value = await findCreatorFeeConfigPda({
+		baseMint: getAddressFromResolvedInstructionAccount("baseMint", accounts.baseMint.value),
+		quoteMint: getAddressFromResolvedInstructionAccount("quoteMint", accounts.quoteMint.value)
+	});
 	if (!accounts.baseTokenProgram.value) accounts.baseTokenProgram.value = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
 	if (!accounts.associatedTokenProgram.value) accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
 	if (!accounts.systemProgram.value) accounts.systemProgram.value = "11111111111111111111111111111111";
 	if (!accounts.eventAuthority.value) accounts.eventAuthority.value = EVENT_AUTHORITY_PDA_ADDRESS$1;
 	if (!accounts.program.value) accounts.program.value = "5R1uFyEE4oxqkm7hJDqHq6gXaLVF9dxeF3LF4yz1sfLP";
+	if (!accounts.dexCreatorFeeConfig.value) accounts.dexCreatorFeeConfig.value = await getProgramDerivedAddress({
+		programAddress: "84qj5FPZZdXkQy8mfowyg6RBZ3XKuTds6XS4ZYT1sfDX",
+		seeds: [
+			getBytesEncoder().encode(new Uint8Array([
+				99,
+				114,
+				101,
+				97,
+				116,
+				111,
+				114,
+				95,
+				102,
+				101,
+				101,
+				95,
+				99,
+				111,
+				110,
+				102,
+				105,
+				103
+			])),
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("baseMint", accounts.baseMint.value)),
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("quoteMint", accounts.quoteMint.value))
+		]
+	});
 	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
 	return Object.freeze({
 		accounts: [
@@ -8084,7 +8321,8 @@ async function getMigrateInstructionAsync(input) {
 			getAccountMeta("associatedTokenProgram", accounts.associatedTokenProgram),
 			getAccountMeta("systemProgram", accounts.systemProgram),
 			getAccountMeta("eventAuthority", accounts.eventAuthority),
-			getAccountMeta("program", accounts.program)
+			getAccountMeta("program", accounts.program),
+			getAccountMeta("dexCreatorFeeConfig", accounts.dexCreatorFeeConfig)
 		],
 		data: getMigrateInstructionDataEncoder().encode({}),
 		programAddress
@@ -8155,7 +8393,7 @@ function getMigrateInstruction(input) {
 		},
 		creatorFeeConfig: {
 			value: input.creatorFeeConfig ?? null,
-			isWritable: false
+			isWritable: true
 		},
 		baseTokenProgram: {
 			value: null,
@@ -8180,6 +8418,10 @@ function getMigrateInstruction(input) {
 		program: {
 			value: null,
 			isWritable: false
+		},
+		dexCreatorFeeConfig: {
+			value: input.dexCreatorFeeConfig ?? null,
+			isWritable: true
 		}
 	};
 	if (!accounts.dexProgram.value) accounts.dexProgram.value = "84qj5FPZZdXkQy8mfowyg6RBZ3XKuTds6XS4ZYT1sfDX";
@@ -8215,7 +8457,8 @@ function getMigrateInstruction(input) {
 			getAccountMeta("associatedTokenProgram", accounts.associatedTokenProgram),
 			getAccountMeta("systemProgram", accounts.systemProgram),
 			getAccountMeta("eventAuthority", accounts.eventAuthority),
-			getAccountMeta("program", accounts.program)
+			getAccountMeta("program", accounts.program),
+			getAccountMeta("dexCreatorFeeConfig", accounts.dexCreatorFeeConfig)
 		],
 		data: getMigrateInstructionDataEncoder().encode({}),
 		programAddress
@@ -8228,9 +8471,9 @@ function parseMigrateInstruction(instruction) {
 		error.name = "InstructionDiscriminatorMismatchError";
 		throw error;
 	}
-	if (instruction.accounts.length < 22) throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+	if (instruction.accounts.length < 23) throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
 		actualAccountMetas: instruction.accounts.length,
-		expectedAccountMetas: 22
+		expectedAccountMetas: 23
 	});
 	let accountIndex = 0;
 	const getNextAccount = () => {
@@ -8262,7 +8505,8 @@ function parseMigrateInstruction(instruction) {
 			associatedTokenProgram: getNextAccount(),
 			systemProgram: getNextAccount(),
 			eventAuthority: getNextAccount(),
-			program: getNextAccount()
+			program: getNextAccount(),
+			dexCreatorFeeConfig: getNextAccount()
 		},
 		data: getMigrateInstructionDataDecoder().decode(instruction.data)
 	};
@@ -8501,6 +8745,7 @@ function sendLaunchpadProgram() {
 			pdas: {
 				bondingCurve: findBondingCurvePda,
 				eventAuthority: findEventAuthorityPda$1,
+				creatorFeeConfig: findCreatorFeeConfigPda,
 				rewardAccrual: findRewardAccrualPda,
 				globalConfig: findGlobalConfigPda$1,
 				wsolRewardAccrual: findWsolRewardAccrualPda,
@@ -8518,7 +8763,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,
@@ -8534,13 +8779,20 @@ async function findAssociatedTokenPda(wallet, mint, tokenProgram = TOKEN_PROGRAM
 var migrate_exports = /* @__PURE__ */ __exportAll({ buildMigrateInstruction: () => buildMigrateInstruction });
 async function buildMigrateInstruction(params) {
 	const { quoteTokenProgram } = params;
-	const [[pool], [lpMint]] = await Promise.all([findPoolPda({
-		baseMint: params.baseMint,
-		quoteMint: params.quoteMint
-	}), findLpMintPda({
-		baseMint: params.baseMint,
-		quoteMint: params.quoteMint
-	})]);
+	const [[pool], [lpMint], [dexCreatorFeeConfig]] = await Promise.all([
+		findPoolPda({
+			baseMint: params.baseMint,
+			quoteMint: params.quoteMint
+		}),
+		findLpMintPda({
+			baseMint: params.baseMint,
+			quoteMint: params.quoteMint
+		}),
+		findCreatorFeeConfigPda$1({
+			baseMint: params.baseMint,
+			quoteMint: params.quoteMint
+		})
+	]);
 	const [[poolBaseVault], [poolQuoteVault], [poolLpAccount]] = await Promise.all([
 		findAssociatedTokenPda(pool, params.baseMint, TOKEN_2022_PROGRAM_ADDRESS),
 		findAssociatedTokenPda(pool, params.quoteMint, quoteTokenProgram),
@@ -8550,7 +8802,7 @@ async function buildMigrateInstruction(params) {
 		caller: params.caller,
 		baseMint: params.baseMint,
 		quoteMint: params.quoteMint,
-		creatorFeeConfig: params.creatorFeeConfig,
+		dexCreatorFeeConfig,
 		poolBaseVault,
 		poolQuoteVault,
 		poolLpAccount,
@@ -8574,7 +8826,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 +8848,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 +8896,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,111 +8992,43 @@ 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;
 }
-async function fetchAllMaybeAltRegistry(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeAltRegistry(maybeAccount));
-}
-function getAltRegistrySize() {
-	return 74;
-}
-//#endregion
-//#region src/nexus/generated/accounts/creatorFeeConfig.ts
 /**
-* 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
+* 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.
 */
-const CREATOR_FEE_CONFIG_DISCRIMINATOR = new Uint8Array([
-	160,
-	88,
-	34,
-	74,
-	215,
-	196,
-	130,
-	32
-]);
-function getCreatorFeeConfigDiscriminatorBytes() {
-	return fixEncoderSize(getBytesEncoder(), 8).encode(CREATOR_FEE_CONFIG_DISCRIMINATOR);
-}
-/** Gets the encoder for {@link CreatorFeeConfigArgs} account data. */
-function getCreatorFeeConfigEncoder() {
-	return transformEncoder(getStructEncoder([
-		["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
-		["version", getU8Encoder()],
-		["bump", getU8Encoder()],
-		["platformIndex", getU8Encoder()],
-		["platformId", fixEncoderSize(getBytesEncoder(), 44)],
-		["quoteMint", getAddressEncoder()],
-		["reserved", fixEncoderSize(getBytesEncoder(), 64)]
-	]), (value) => ({
-		...value,
-		discriminator: CREATOR_FEE_CONFIG_DISCRIMINATOR
+async function fetchAllMaybeAltRegistry(rpc, addresses, config) {
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeAltRegistry(accountIsCreated(maybeAccount) ? maybeAccount : {
+		address: maybeAccount.address,
+		exists: false
 	}));
 }
-/** Gets the decoder for {@link CreatorFeeConfig} account data. */
-function getCreatorFeeConfigDecoder() {
-	return getStructDecoder([
-		["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
-		["version", getU8Decoder()],
-		["bump", getU8Decoder()],
-		["platformIndex", getU8Decoder()],
-		["platformId", fixDecoderSize(getBytesDecoder(), 44)],
-		["quoteMint", getAddressDecoder()],
-		["reserved", fixDecoderSize(getBytesDecoder(), 64)]
-	]);
-}
-/** Gets the codec for {@link CreatorFeeConfig} account data. */
-function getCreatorFeeConfigCodec() {
-	return combineCodec(getCreatorFeeConfigEncoder(), getCreatorFeeConfigDecoder());
-}
-function decodeCreatorFeeConfig(encodedAccount) {
-	if (!("exists" in encodedAccount) || encodedAccount.exists) {
-		if (encodedAccount.programAddress !== "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX") {
-			const error = /* @__PURE__ */ new Error(`decodeCreatorFeeConfig: account ${encodedAccount.address} is owned by ${encodedAccount.programAddress}, expected ${SEND_NEXUS_PROGRAM_ADDRESS}`);
-			error.name = "AccountOwnerMismatchError";
-			throw error;
-		}
-		if (!containsBytes(encodedAccount.data, CREATOR_FEE_CONFIG_DISCRIMINATOR, 0)) {
-			const error = /* @__PURE__ */ new Error(`decodeCreatorFeeConfig: account ${encodedAccount.address} does not match the CreatorFeeConfig discriminator`);
-			error.name = "AccountDiscriminatorMismatchError";
-			throw error;
-		}
-	}
-	return decodeAccount(encodedAccount, getCreatorFeeConfigDecoder());
-}
-async function fetchCreatorFeeConfig(rpc, address, config) {
-	const maybeAccount = await fetchMaybeCreatorFeeConfig(rpc, address, config);
-	assertAccountExists(maybeAccount);
-	return maybeAccount;
-}
-async function fetchMaybeCreatorFeeConfig(rpc, address, config) {
-	return decodeCreatorFeeConfig(await fetchEncodedAccount(rpc, address, config));
-}
-async function fetchAllCreatorFeeConfig(rpc, addresses, config) {
-	const maybeAccounts = await fetchAllMaybeCreatorFeeConfig(rpc, addresses, config);
-	assertAccountsExist(maybeAccounts);
-	return maybeAccounts;
-}
-async function fetchAllMaybeCreatorFeeConfig(rpc, addresses, config) {
-	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeCreatorFeeConfig(maybeAccount));
-}
-function getCreatorFeeConfigSize() {
-	return 151;
+function getAltRegistrySize() {
+	return 74;
 }
 //#endregion
 //#region src/nexus/generated/types/authPlatformEntry.ts
@@ -8829,29 +9049,6 @@ function getAuthPlatformEntryCodec() {
 	return combineCodec(getAuthPlatformEntryEncoder(), getAuthPlatformEntryDecoder());
 }
 //#endregion
-//#region src/nexus/generated/types/callerType.ts
-/**
-* 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
-*/
-let CallerType = /* @__PURE__ */ function(CallerType) {
-	CallerType[CallerType["PlatformBondingCurve"] = 0] = "PlatformBondingCurve";
-	CallerType[CallerType["PlatformPool"] = 1] = "PlatformPool";
-	return CallerType;
-}({});
-function getCallerTypeEncoder() {
-	return getEnumEncoder(CallerType);
-}
-function getCallerTypeDecoder() {
-	return getEnumDecoder(CallerType);
-}
-function getCallerTypeCodec() {
-	return combineCodec(getCallerTypeEncoder(), getCallerTypeDecoder());
-}
-//#endregion
 //#region src/nexus/generated/types/dexFees.ts
 /**
 * This code was AUTOGENERATED using the Codama library.
@@ -8865,7 +9062,7 @@ function getDexFeesEncoder() {
 		["creationFeeCents", getU64Encoder()],
 		["protocolFeeBps", getU16Encoder()],
 		["lpFeeBps", getU16Encoder()],
-		["creatorFeeBps", getU16Encoder()],
+		["maxCreatorFeeBps", getU16Encoder()],
 		["feeDecaySeconds", getU16Encoder()],
 		["feeDecayStartBps", getU16Encoder()]
 	]);
@@ -8875,7 +9072,7 @@ function getDexFeesDecoder() {
 		["creationFeeCents", getU64Decoder()],
 		["protocolFeeBps", getU16Decoder()],
 		["lpFeeBps", getU16Decoder()],
-		["creatorFeeBps", getU16Decoder()],
+		["maxCreatorFeeBps", getU16Decoder()],
 		["feeDecaySeconds", getU16Decoder()],
 		["feeDecayStartBps", getU16Decoder()]
 	]);
@@ -8924,7 +9121,7 @@ function getLaunchpadFeesEncoder() {
 	return getStructEncoder([
 		["creationFeeCents", getU64Encoder()],
 		["protocolFeeBps", getU16Encoder()],
-		["creatorFeeBps", getU16Encoder()],
+		["maxCreatorFeeBps", getU16Encoder()],
 		["feeDecaySeconds", getU16Encoder()],
 		["feeDecayStartBps", getU16Encoder()]
 	]);
@@ -8933,7 +9130,7 @@ function getLaunchpadFeesDecoder() {
 	return getStructDecoder([
 		["creationFeeCents", getU64Decoder()],
 		["protocolFeeBps", getU16Decoder()],
-		["creatorFeeBps", getU16Decoder()],
+		["maxCreatorFeeBps", getU16Decoder()],
 		["feeDecaySeconds", getU16Decoder()],
 		["feeDecayStartBps", getU16Decoder()]
 	]);
@@ -8944,13 +9141,9 @@ function getLaunchpadFeesCodec() {
 //#endregion
 //#region src/nexus/generated/types/index.ts
 var types_exports = /* @__PURE__ */ __exportAll({
-	CallerType: () => CallerType,
 	getAuthPlatformEntryCodec: () => getAuthPlatformEntryCodec,
 	getAuthPlatformEntryDecoder: () => getAuthPlatformEntryDecoder,
 	getAuthPlatformEntryEncoder: () => getAuthPlatformEntryEncoder,
-	getCallerTypeCodec: () => getCallerTypeCodec,
-	getCallerTypeDecoder: () => getCallerTypeDecoder,
-	getCallerTypeEncoder: () => getCallerTypeEncoder,
 	getDexFeesCodec: () => getDexFeesCodec,
 	getDexFeesDecoder: () => getDexFeesDecoder,
 	getDexFeesEncoder: () => getDexFeesEncoder,
@@ -8994,7 +9187,7 @@ function getFeePresetEncoder() {
 		["launchpad", getLaunchpadFeesEncoder()],
 		["dex", getDexFeesEncoder()],
 		["platformConfig", getAddressEncoder()],
-		["reserved", fixEncoderSize(getBytesEncoder(), 32)]
+		["reserved", fixEncoderSize(getBytesEncoder(), 64)]
 	]), (value) => ({
 		...value,
 		discriminator: FEE_PRESET_DISCRIMINATOR
@@ -9011,7 +9204,7 @@ function getFeePresetDecoder() {
 		["launchpad", getLaunchpadFeesDecoder()],
 		["dex", getDexFeesDecoder()],
 		["platformConfig", getAddressDecoder()],
-		["reserved", fixDecoderSize(getBytesDecoder(), 32)]
+		["reserved", fixDecoderSize(getBytesDecoder(), 64)]
 	]);
 }
 /** Gets the codec for {@link FeePreset} account data. */
@@ -9033,21 +9226,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 +9329,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
@@ -9167,7 +9398,8 @@ function getPartnerConfigEncoder() {
 		["launchpad", getLaunchpadFeesEncoder()],
 		["dex", getDexFeesEncoder()],
 		["platformConfig", getAddressEncoder()],
-		["reserved", fixEncoderSize(getBytesEncoder(), 32)]
+		["allowedCreatorFeeModes", getU16Encoder()],
+		["reserved", fixEncoderSize(getBytesEncoder(), 256)]
 	]), (value) => ({
 		...value,
 		discriminator: PARTNER_CONFIG_DISCRIMINATOR
@@ -9185,7 +9417,8 @@ function getPartnerConfigDecoder() {
 		["launchpad", getLaunchpadFeesDecoder()],
 		["dex", getDexFeesDecoder()],
 		["platformConfig", getAddressDecoder()],
-		["reserved", fixDecoderSize(getBytesDecoder(), 32)]
+		["allowedCreatorFeeModes", getU16Decoder()],
+		["reserved", fixDecoderSize(getBytesDecoder(), 256)]
 	]);
 }
 /** Gets the codec for {@link PartnerConfig} account data. */
@@ -9207,24 +9440,43 @@ 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;
+	return 399;
 }
 //#endregion
 //#region src/nexus/generated/accounts/partnerMetadata.ts
@@ -9300,21 +9552,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 +9665,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 +9773,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;
@@ -9538,7 +9847,7 @@ function getUserRewardDebtEncoder() {
 		["amountSnapshot", getU64Encoder()],
 		["settledVersion", getU32Encoder()],
 		["owed", getU64Encoder()],
-		["reserved", fixEncoderSize(getBytesEncoder(), 32)]
+		["reserved", fixEncoderSize(getBytesEncoder(), 64)]
 	]), (value) => ({
 		...value,
 		discriminator: USER_REWARD_DEBT_DISCRIMINATOR
@@ -9558,7 +9867,7 @@ function getUserRewardDebtDecoder() {
 		["amountSnapshot", getU64Decoder()],
 		["settledVersion", getU32Decoder()],
 		["owed", getU64Decoder()],
-		["reserved", fixDecoderSize(getBytesDecoder(), 32)]
+		["reserved", fixDecoderSize(getBytesDecoder(), 64)]
 	]);
 }
 /** Gets the codec for {@link UserRewardDebt} account data. */
@@ -9580,24 +9889,43 @@ 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;
+	return 214;
 }
 //#endregion
 //#region src/nexus/generated/accounts/userStakePosition.ts
@@ -9632,7 +9960,7 @@ function getUserStakePositionEncoder() {
 		["amount", getU64Encoder()],
 		["stakeVersion", getU32Encoder()],
 		["settledCount", getU16Encoder()],
-		["reserved", fixEncoderSize(getBytesEncoder(), 32)]
+		["reserved", fixEncoderSize(getBytesEncoder(), 128)]
 	]), (value) => ({
 		...value,
 		discriminator: USER_STAKE_POSITION_DISCRIMINATOR
@@ -9649,7 +9977,7 @@ function getUserStakePositionDecoder() {
 		["amount", getU64Decoder()],
 		["stakeVersion", getU32Decoder()],
 		["settledCount", getU16Decoder()],
-		["reserved", fixDecoderSize(getBytesDecoder(), 32)]
+		["reserved", fixDecoderSize(getBytesDecoder(), 128)]
 	]);
 }
 /** Gets the codec for {@link UserStakePosition} account data. */
@@ -9671,24 +9999,43 @@ 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;
+	return 216;
 }
 //#endregion
 //#region src/nexus/generated/accounts/sendNexus.accounts.ts
@@ -9707,7 +10054,6 @@ function identifySendNexusAccount(account) {
 	if ("data" in account && account.programAddress !== "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX") return null;
 	const data = "data" in account ? account.data : account;
 	if (containsBytes(data, ALT_REGISTRY_DISCRIMINATOR, 0)) return "altRegistry";
-	if (containsBytes(data, CREATOR_FEE_CONFIG_DISCRIMINATOR, 0)) return "creatorFeeConfig";
 	if (containsBytes(data, FEE_PRESET_DISCRIMINATOR, 0)) return "feePreset";
 	if (containsBytes(data, GLOBAL_CONFIG_DISCRIMINATOR, 0)) return "globalConfig";
 	if (containsBytes(data, PARTNER_CONFIG_DISCRIMINATOR, 0)) return "partnerConfig";
@@ -9722,7 +10068,6 @@ function identifySendNexusAccount(account) {
 //#region src/nexus/generated/accounts/index.ts
 var accounts_exports = /* @__PURE__ */ __exportAll({
 	ALT_REGISTRY_DISCRIMINATOR: () => ALT_REGISTRY_DISCRIMINATOR,
-	CREATOR_FEE_CONFIG_DISCRIMINATOR: () => CREATOR_FEE_CONFIG_DISCRIMINATOR,
 	FEE_PRESET_DISCRIMINATOR: () => FEE_PRESET_DISCRIMINATOR,
 	GLOBAL_CONFIG_DISCRIMINATOR: () => GLOBAL_CONFIG_DISCRIMINATOR,
 	PARTNER_CONFIG_DISCRIMINATOR: () => PARTNER_CONFIG_DISCRIMINATOR,
@@ -9732,7 +10077,6 @@ var accounts_exports = /* @__PURE__ */ __exportAll({
 	USER_REWARD_DEBT_DISCRIMINATOR: () => USER_REWARD_DEBT_DISCRIMINATOR,
 	USER_STAKE_POSITION_DISCRIMINATOR: () => USER_STAKE_POSITION_DISCRIMINATOR,
 	decodeAltRegistry: () => decodeAltRegistry,
-	decodeCreatorFeeConfig: () => decodeCreatorFeeConfig,
 	decodeFeePreset: () => decodeFeePreset,
 	decodeGlobalConfig: () => decodeGlobalConfig,
 	decodePartnerConfig: () => decodePartnerConfig,
@@ -9742,11 +10086,9 @@ var accounts_exports = /* @__PURE__ */ __exportAll({
 	decodeUserRewardDebt: () => decodeUserRewardDebt,
 	decodeUserStakePosition: () => decodeUserStakePosition,
 	fetchAllAltRegistry: () => fetchAllAltRegistry,
-	fetchAllCreatorFeeConfig: () => fetchAllCreatorFeeConfig,
 	fetchAllFeePreset: () => fetchAllFeePreset,
 	fetchAllGlobalConfig: () => fetchAllGlobalConfig,
 	fetchAllMaybeAltRegistry: () => fetchAllMaybeAltRegistry,
-	fetchAllMaybeCreatorFeeConfig: () => fetchAllMaybeCreatorFeeConfig,
 	fetchAllMaybeFeePreset: () => fetchAllMaybeFeePreset,
 	fetchAllMaybeGlobalConfig: () => fetchAllMaybeGlobalConfig,
 	fetchAllMaybePartnerConfig: () => fetchAllMaybePartnerConfig,
@@ -9762,11 +10104,9 @@ var accounts_exports = /* @__PURE__ */ __exportAll({
 	fetchAllUserRewardDebt: () => fetchAllUserRewardDebt,
 	fetchAllUserStakePosition: () => fetchAllUserStakePosition,
 	fetchAltRegistry: () => fetchAltRegistry,
-	fetchCreatorFeeConfig: () => fetchCreatorFeeConfig,
 	fetchFeePreset: () => fetchFeePreset,
 	fetchGlobalConfig: () => fetchGlobalConfig,
 	fetchMaybeAltRegistry: () => fetchMaybeAltRegistry,
-	fetchMaybeCreatorFeeConfig: () => fetchMaybeCreatorFeeConfig,
 	fetchMaybeFeePreset: () => fetchMaybeFeePreset,
 	fetchMaybeGlobalConfig: () => fetchMaybeGlobalConfig,
 	fetchMaybePartnerConfig: () => fetchMaybePartnerConfig,
@@ -9786,11 +10126,6 @@ var accounts_exports = /* @__PURE__ */ __exportAll({
 	getAltRegistryDiscriminatorBytes: () => getAltRegistryDiscriminatorBytes,
 	getAltRegistryEncoder: () => getAltRegistryEncoder,
 	getAltRegistrySize: () => getAltRegistrySize,
-	getCreatorFeeConfigCodec: () => getCreatorFeeConfigCodec,
-	getCreatorFeeConfigDecoder: () => getCreatorFeeConfigDecoder,
-	getCreatorFeeConfigDiscriminatorBytes: () => getCreatorFeeConfigDiscriminatorBytes,
-	getCreatorFeeConfigEncoder: () => getCreatorFeeConfigEncoder,
-	getCreatorFeeConfigSize: () => getCreatorFeeConfigSize,
 	getFeePresetCodec: () => getFeePresetCodec,
 	getFeePresetDecoder: () => getFeePresetDecoder,
 	getFeePresetDiscriminatorBytes: () => getFeePresetDiscriminatorBytes,
@@ -10228,12 +10563,16 @@ const SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT = 7009;
 const SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY = 7010;
 /** NothingToClaim: Nothing to claim */
 const SEND_NEXUS_ERROR__NOTHING_TO_CLAIM = 7011;
-/** InvalidCreatorId: Creator identity is not a decodable wallet address */
-const SEND_NEXUS_ERROR__INVALID_CREATOR_ID = 7012;
+/** Unused7012: Unused */
+const SEND_NEXUS_ERROR__UNUSED7012 = 7012;
 /** QuoteMintPriceUnset: Quote mint has no USDC price on its nexus reward state */
 const SEND_NEXUS_ERROR__QUOTE_MINT_PRICE_UNSET = 7013;
 /** TransferFeeNotSettleable: Token-2022 transfer fee schedule cannot settle the exact amount */
 const SEND_NEXUS_ERROR__TRANSFER_FEE_NOT_SETTLEABLE = 7014;
+/** CreatorFeeTooHigh: Creator fee exceeds the partner's maximum */
+const SEND_NEXUS_ERROR__CREATOR_FEE_TOO_HIGH = 7015;
+/** CreatorFeeModeNotAllowed: Creator fee mode is not allowed by the partner config */
+const SEND_NEXUS_ERROR__CREATOR_FEE_MODE_NOT_ALLOWED = 7016;
 /** InsufficientLiquidity: Insufficient liquidity */
 const SEND_NEXUS_ERROR__INSUFFICIENT_LIQUIDITY = 7100;
 /** InvalidAmount: Invalid amount */
@@ -10241,6 +10580,8 @@ const SEND_NEXUS_ERROR__INVALID_AMOUNT = 7101;
 const sendNexusErrorMessages = {
 	[SEND_NEXUS_ERROR__AMBIGUOUS_FEE_SOURCE]: `Cannot specify both fee_preset and custom_fees`,
 	[SEND_NEXUS_ERROR__ARITHMETIC_OVERFLOW]: `Arithmetic overflow`,
+	[SEND_NEXUS_ERROR__CREATOR_FEE_MODE_NOT_ALLOWED]: `Creator fee mode is not allowed by the partner config`,
+	[SEND_NEXUS_ERROR__CREATOR_FEE_TOO_HIGH]: `Creator fee exceeds the partner's maximum`,
 	[SEND_NEXUS_ERROR__DUPLICATE_AUTH_PLATFORM_NAME]: `Duplicate auth platform name`,
 	[SEND_NEXUS_ERROR__INSUFFICIENT_LIQUIDITY]: `Insufficient liquidity`,
 	[SEND_NEXUS_ERROR__INSUFFICIENT_STAKE]: `Insufficient stake balance`,
@@ -10248,7 +10589,6 @@ const sendNexusErrorMessages = {
 	[SEND_NEXUS_ERROR__INVALID_AUTHORITY]: `Invalid authority`,
 	[SEND_NEXUS_ERROR__INVALID_AUTH_PLATFORM_INDEX]: `Invalid auth platform index`,
 	[SEND_NEXUS_ERROR__INVALID_AUTH_PLATFORM_NAME]: `Invalid auth platform name`,
-	[SEND_NEXUS_ERROR__INVALID_CREATOR_ID]: `Creator identity is not a decodable wallet address`,
 	[SEND_NEXUS_ERROR__INVALID_DESTINATION]: `Invalid destination account`,
 	[SEND_NEXUS_ERROR__INVALID_FEE_PRESET]: `Invalid fee configuration`,
 	[SEND_NEXUS_ERROR__INVALID_MINT]: `Invalid mint`,
@@ -10282,6 +10622,7 @@ const sendNexusErrorMessages = {
 	[SEND_NEXUS_ERROR__TOO_MANY_AUTH_PLATFORMS]: `Too many auth platforms (max 255)`,
 	[SEND_NEXUS_ERROR__TRANSFER_FEE_NOT_SETTLEABLE]: `Token-2022 transfer fee schedule cannot settle the exact amount`,
 	[SEND_NEXUS_ERROR__UNAUTHORIZED]: `Unauthorized`,
+	[SEND_NEXUS_ERROR__UNUSED7012]: `Unused`,
 	[SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_INVALID]: `User token account is not an initialized token account`,
 	[SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY]: `User token account is not owned by the trading user`,
 	[SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT]: `User token account mint does not match the trade`,
@@ -10298,6 +10639,8 @@ function isSendNexusError(error, transactionMessage, code) {
 var errors_exports = /* @__PURE__ */ __exportAll({
 	SEND_NEXUS_ERROR__AMBIGUOUS_FEE_SOURCE: () => SEND_NEXUS_ERROR__AMBIGUOUS_FEE_SOURCE,
 	SEND_NEXUS_ERROR__ARITHMETIC_OVERFLOW: () => SEND_NEXUS_ERROR__ARITHMETIC_OVERFLOW,
+	SEND_NEXUS_ERROR__CREATOR_FEE_MODE_NOT_ALLOWED: () => SEND_NEXUS_ERROR__CREATOR_FEE_MODE_NOT_ALLOWED,
+	SEND_NEXUS_ERROR__CREATOR_FEE_TOO_HIGH: () => SEND_NEXUS_ERROR__CREATOR_FEE_TOO_HIGH,
 	SEND_NEXUS_ERROR__DUPLICATE_AUTH_PLATFORM_NAME: () => SEND_NEXUS_ERROR__DUPLICATE_AUTH_PLATFORM_NAME,
 	SEND_NEXUS_ERROR__INSUFFICIENT_LIQUIDITY: () => SEND_NEXUS_ERROR__INSUFFICIENT_LIQUIDITY,
 	SEND_NEXUS_ERROR__INSUFFICIENT_STAKE: () => SEND_NEXUS_ERROR__INSUFFICIENT_STAKE,
@@ -10305,7 +10648,6 @@ var errors_exports = /* @__PURE__ */ __exportAll({
 	SEND_NEXUS_ERROR__INVALID_AUTHORITY: () => SEND_NEXUS_ERROR__INVALID_AUTHORITY,
 	SEND_NEXUS_ERROR__INVALID_AUTH_PLATFORM_INDEX: () => SEND_NEXUS_ERROR__INVALID_AUTH_PLATFORM_INDEX,
 	SEND_NEXUS_ERROR__INVALID_AUTH_PLATFORM_NAME: () => SEND_NEXUS_ERROR__INVALID_AUTH_PLATFORM_NAME,
-	SEND_NEXUS_ERROR__INVALID_CREATOR_ID: () => SEND_NEXUS_ERROR__INVALID_CREATOR_ID,
 	SEND_NEXUS_ERROR__INVALID_DESTINATION: () => SEND_NEXUS_ERROR__INVALID_DESTINATION,
 	SEND_NEXUS_ERROR__INVALID_FEE_PRESET: () => SEND_NEXUS_ERROR__INVALID_FEE_PRESET,
 	SEND_NEXUS_ERROR__INVALID_MINT: () => SEND_NEXUS_ERROR__INVALID_MINT,
@@ -10339,6 +10681,7 @@ var errors_exports = /* @__PURE__ */ __exportAll({
 	SEND_NEXUS_ERROR__TOO_MANY_AUTH_PLATFORMS: () => SEND_NEXUS_ERROR__TOO_MANY_AUTH_PLATFORMS,
 	SEND_NEXUS_ERROR__TRANSFER_FEE_NOT_SETTLEABLE: () => SEND_NEXUS_ERROR__TRANSFER_FEE_NOT_SETTLEABLE,
 	SEND_NEXUS_ERROR__UNAUTHORIZED: () => SEND_NEXUS_ERROR__UNAUTHORIZED,
+	SEND_NEXUS_ERROR__UNUSED7012: () => SEND_NEXUS_ERROR__UNUSED7012,
 	SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_INVALID: () => SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_INVALID,
 	SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY: () => SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY,
 	SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT: () => SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT,
@@ -10725,7 +11068,6 @@ var pdas_exports = /* @__PURE__ */ __exportAll({
 	GLOBAL_CONFIG_PDA_ADDRESS: () => GLOBAL_CONFIG_PDA_ADDRESS,
 	STAKING_CONFIG_PDA_ADDRESS: () => STAKING_CONFIG_PDA_ADDRESS,
 	findAltRegistryPda: () => findAltRegistryPda,
-	findCreatorFeeConfigPda: () => findCreatorFeeConfigPda,
 	findDefaultFeePresetPda: () => findDefaultFeePresetPda,
 	findDefaultPartnerMetadataPda: () => findDefaultPartnerMetadataPda,
 	findDefaultPartnerPda: () => findDefaultPartnerPda,
@@ -12139,13 +12481,6 @@ function sendNexusProgram() {
 					fetchAllMaybe: (addresses, config) => fetchAllMaybeAltRegistry(client.rpc, addresses, config),
 					fetchMaybe: (address, config) => fetchMaybeAltRegistry(client.rpc, address, config)
 				}),
-				creatorFeeConfig: Object.freeze({
-					...getCreatorFeeConfigCodec(),
-					fetch: (address, config) => fetchCreatorFeeConfig(client.rpc, address, config),
-					fetchAll: (addresses, config) => fetchAllCreatorFeeConfig(client.rpc, addresses, config),
-					fetchAllMaybe: (addresses, config) => fetchAllMaybeCreatorFeeConfig(client.rpc, addresses, config),
-					fetchMaybe: (address, config) => fetchMaybeCreatorFeeConfig(client.rpc, address, config)
-				}),
 				feePreset: Object.freeze({
 					...getFeePresetCodec(),
 					fetch: (address, config) => fetchFeePreset(client.rpc, address, config),
@@ -12243,7 +12578,6 @@ function sendNexusProgram() {
 				userStakePosition: findUserStakePositionPda,
 				userRewardDebt: findUserRewardDebtPda,
 				eventAuthority: findEventAuthorityPda,
-				creatorFeeConfig: findCreatorFeeConfigPda,
 				altRegistry: findAltRegistryPda
 			},
 			identifyAccount: identifySendNexusAccount,
@@ -12261,7 +12595,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,10 +12606,13 @@ 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. */
-function effectiveFeeBps(schedule, createdAt, now) {
-	const standardFeeBps = schedule.protocolFeeBps + schedule.creatorFeeBps + ("lpFeeBps" in schedule ? schedule.lpFeeBps : 0);
+/** Returns the `feeBps` a trade pays: the standard rate plus the decay premium. The standard rate
+*  is the protocol and LP rates of `schedule` plus `creatorFeeBps`. `schedule` is the
+*  `PartnerConfig`'s `launchpad` for a curve or `dex` for a pool. `creatorFeeBps` and `createdAt`
+*  are the curve's or pool's. `schedule.maxCreatorFeeBps` has no effect. `createdAt` and `now`
+*  are in unix seconds. */
+function effectiveFeeBps(schedule, createdAt, now, creatorFeeBps) {
+	const standardFeeBps = schedule.protocolFeeBps + ("lpFeeBps" in schedule ? schedule.lpFeeBps : 0) + creatorFeeBps;
 	const premium = calculateFeeDecayPremium({
 		currentTimestamp: now,
 		createdAtTimestamp: createdAt,
@@ -12288,7 +12626,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 +12661,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 +12692,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 +12714,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 +12731,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 +12747,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 +12758,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 +12787,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 +12811,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 +12845,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 +12898,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 +12935,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 +12979,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 +13010,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 +13025,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 +13056,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 +13066,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,9 +13084,7 @@ async function fetchQuoteMintInfos(rpc, mints, commitment) {
 //#endregion
 //#region src/utils/index.ts
 var utils_exports = /* @__PURE__ */ __exportAll({
-	creatorHashFromId: () => creatorHashFromId,
-	decodeCreatorId: () => decodeCreatorId,
-	encodeCreatorId: () => encodeCreatorId,
+	accountIsCreated: () => accountIsCreated,
 	fetchQuoteMintInfo: () => fetchQuoteMintInfo,
 	fetchQuoteMintInfos: () => fetchQuoteMintInfos,
 	findAssociatedTokenPda: () => findAssociatedTokenPda