@send-fun/sdk 1.1.0 → 2.0.0

package/src/nexus/generated/accounts/partnerConfig.ts

@@ -22,6 +22,8 @@ import {
 	getBytesEncoder,
 	getStructDecoder,
 	getStructEncoder,
+	getU16Decoder,
+	getU16Encoder,
 	getU8Decoder,
 	getU8Encoder,
 	transformEncoder,
@@ -38,6 +40,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 import {
 	getDexFeesDecoder,
 	getDexFeesEncoder,
@@ -69,6 +72,7 @@ export type PartnerConfig = {
 	launchpad: LaunchpadFees;
 	dex: DexFees;
 	platformConfig: Address;
+	allowedCreatorFeeModes: number;
 	reserved: ReadonlyUint8Array;
 };
 
@@ -81,6 +85,7 @@ export type PartnerConfigArgs = {
 	launchpad: LaunchpadFeesArgs;
 	dex: DexFeesArgs;
 	platformConfig: Address;
+	allowedCreatorFeeModes: number;
 	reserved: ReadonlyUint8Array;
 };
 
@@ -97,7 +102,8 @@ export function getPartnerConfigEncoder(): FixedSizeEncoder<PartnerConfigArgs> {
 			['launchpad', getLaunchpadFeesEncoder()],
 			['dex', getDexFeesEncoder()],
 			['platformConfig', getAddressEncoder()],
-			['reserved', fixEncoderSize(getBytesEncoder(), 32)],
+			['allowedCreatorFeeModes', getU16Encoder()],
+			['reserved', fixEncoderSize(getBytesEncoder(), 256)],
 		]),
 		(value) => ({ ...value, discriminator: PARTNER_CONFIG_DISCRIMINATOR }),
 	);
@@ -115,7 +121,8 @@ export function getPartnerConfigDecoder(): FixedSizeDecoder<PartnerConfig> {
 		['launchpad', getLaunchpadFeesDecoder()],
 		['dex', getDexFeesDecoder()],
 		['platformConfig', getAddressDecoder()],
-		['reserved', fixDecoderSize(getBytesDecoder(), 32)],
+		['allowedCreatorFeeModes', getU16Decoder()],
+		['reserved', fixDecoderSize(getBytesDecoder(), 256)],
 	]);
 }
 
@@ -127,9 +134,25 @@ export function getPartnerConfigCodec(): FixedSizeCodec<
 	return combineCodec(getPartnerConfigEncoder(), getPartnerConfigDecoder());
 }
 
+/**
+ * Decodes a `PartnerConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybePartnerConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodePartnerConfig<TAddress extends string = string>(
 	encodedAccount: EncodedAccount<TAddress>,
 ): Account<PartnerConfig, TAddress>;
+/**
+ * Decodes a `PartnerConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybePartnerConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodePartnerConfig<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<PartnerConfig, TAddress>;
@@ -160,6 +183,7 @@ export function decodePartnerConfig<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `PartnerConfig` account, throwing when it does not exist or only holds lamports. */
 export async function fetchPartnerConfig<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -170,15 +194,25 @@ export async function fetchPartnerConfig<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybePartnerConfig<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<PartnerConfig, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodePartnerConfig(maybeAccount);
+	return decodePartnerConfig(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `PartnerConfig` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllPartnerConfig(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -193,6 +227,11 @@ export async function fetchAllPartnerConfig(
 	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.
+ */
 export async function fetchAllMaybePartnerConfig(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -200,10 +239,14 @@ export async function fetchAllMaybePartnerConfig(
 ): Promise<MaybeAccount<PartnerConfig>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
 	return maybeAccounts.map((maybeAccount) =>
-		decodePartnerConfig(maybeAccount),
+		decodePartnerConfig(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
 	);
 }
 
 export function getPartnerConfigSize(): number {
-	return 173;
+	return 399;
 }

package/src/nexus/generated/accounts/partnerMetadata.ts

@@ -46,6 +46,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 
 export const PARTNER_METADATA_DISCRIMINATOR: ReadonlyUint8Array =
 	new Uint8Array([68, 68, 130, 19, 16, 209, 98, 156]);
@@ -130,9 +131,25 @@ export function getPartnerMetadataCodec(): Codec<
 	);
 }
 
+/**
+ * Decodes a `PartnerMetadata` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybePartnerMetadata}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodePartnerMetadata<TAddress extends string = string>(
 	encodedAccount: EncodedAccount<TAddress>,
 ): Account<PartnerMetadata, TAddress>;
+/**
+ * Decodes a `PartnerMetadata` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybePartnerMetadata}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodePartnerMetadata<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<PartnerMetadata, TAddress>;
@@ -169,6 +186,7 @@ export function decodePartnerMetadata<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `PartnerMetadata` account, throwing when it does not exist or only holds lamports. */
 export async function fetchPartnerMetadata<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -179,6 +197,11 @@ export async function fetchPartnerMetadata<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybePartnerMetadata<
 	TAddress extends string = string,
 >(
@@ -187,9 +210,14 @@ export async function fetchMaybePartnerMetadata<
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<PartnerMetadata, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodePartnerMetadata(maybeAccount);
+	return decodePartnerMetadata(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `PartnerMetadata` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllPartnerMetadata(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -204,6 +232,11 @@ export async function fetchAllPartnerMetadata(
 	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.
+ */
 export async function fetchAllMaybePartnerMetadata(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -211,6 +244,10 @@ export async function fetchAllMaybePartnerMetadata(
 ): Promise<MaybeAccount<PartnerMetadata>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
 	return maybeAccounts.map((maybeAccount) =>
-		decodePartnerMetadata(maybeAccount),
+		decodePartnerMetadata(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
 	);
 }

package/src/nexus/generated/accounts/rewardState.ts

@@ -42,6 +42,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 
 export const REWARD_STATE_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
 	86, 245, 149, 170, 90, 108, 31, 251,
@@ -129,9 +130,25 @@ export function getRewardStateCodec(): FixedSizeCodec<
 	return combineCodec(getRewardStateEncoder(), getRewardStateDecoder());
 }
 
+/**
+ * Decodes a `RewardState` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeRewardState}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodeRewardState<TAddress extends string = string>(
 	encodedAccount: EncodedAccount<TAddress>,
 ): Account<RewardState, TAddress>;
+/**
+ * Decodes a `RewardState` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeRewardState}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodeRewardState<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<RewardState, TAddress>;
@@ -162,6 +179,7 @@ export function decodeRewardState<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `RewardState` account, throwing when it does not exist or only holds lamports. */
 export async function fetchRewardState<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -172,15 +190,25 @@ export async function fetchRewardState<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybeRewardState<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<RewardState, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeRewardState(maybeAccount);
+	return decodeRewardState(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `RewardState` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllRewardState(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -195,13 +223,24 @@ export async function fetchAllRewardState(
 	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.
+ */
 export async function fetchAllMaybeRewardState(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
 	config?: FetchAccountsConfig,
 ): Promise<MaybeAccount<RewardState>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
-	return maybeAccounts.map((maybeAccount) => decodeRewardState(maybeAccount));
+	return maybeAccounts.map((maybeAccount) =>
+		decodeRewardState(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
+	);
 }
 
 export function getRewardStateSize(): number {

package/src/nexus/generated/accounts/sendNexus.accounts.ts

@@ -13,7 +13,6 @@ import {
 } from '@solana/kit';
 import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
 import { ALT_REGISTRY_DISCRIMINATOR } from './altRegistry.js';
-import { CREATOR_FEE_CONFIG_DISCRIMINATOR } from './creatorFeeConfig.js';
 import { FEE_PRESET_DISCRIMINATOR } from './feePreset.js';
 import { GLOBAL_CONFIG_DISCRIMINATOR } from './globalConfig.js';
 import { PARTNER_CONFIG_DISCRIMINATOR } from './partnerConfig.js';
@@ -26,7 +25,6 @@ import { USER_STAKE_POSITION_DISCRIMINATOR } from './userStakePosition.js';
 /** Account kinds of the sendNexus program. */
 export type SendNexusAccountType =
 	| 'altRegistry'
-	| 'creatorFeeConfig'
 	| 'feePreset'
 	| 'globalConfig'
 	| 'partnerConfig'
@@ -54,9 +52,6 @@ export function identifySendNexusAccount(
 	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';
 	}

package/src/nexus/generated/accounts/stakingConfig.ts

@@ -44,6 +44,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 
 export const STAKING_CONFIG_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
 	45, 134, 252, 82, 37, 57, 84, 25,
@@ -115,9 +116,25 @@ export function getStakingConfigCodec(): FixedSizeCodec<
 	return combineCodec(getStakingConfigEncoder(), getStakingConfigDecoder());
 }
 
+/**
+ * Decodes a `StakingConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeStakingConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodeStakingConfig<TAddress extends string = string>(
 	encodedAccount: EncodedAccount<TAddress>,
 ): Account<StakingConfig, TAddress>;
+/**
+ * Decodes a `StakingConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeStakingConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodeStakingConfig<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<StakingConfig, TAddress>;
@@ -148,6 +165,7 @@ export function decodeStakingConfig<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `StakingConfig` account, throwing when it does not exist or only holds lamports. */
 export async function fetchStakingConfig<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -158,15 +176,25 @@ export async function fetchStakingConfig<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybeStakingConfig<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<StakingConfig, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeStakingConfig(maybeAccount);
+	return decodeStakingConfig(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `StakingConfig` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllStakingConfig(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -181,6 +209,11 @@ export async function fetchAllStakingConfig(
 	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.
+ */
 export async function fetchAllMaybeStakingConfig(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -188,7 +221,11 @@ export async function fetchAllMaybeStakingConfig(
 ): Promise<MaybeAccount<StakingConfig>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
 	return maybeAccounts.map((maybeAccount) =>
-		decodeStakingConfig(maybeAccount),
+		decodeStakingConfig(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
 	);
 }
 

package/src/nexus/generated/accounts/userRewardDebt.ts

@@ -44,6 +44,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 
 export const USER_REWARD_DEBT_DISCRIMINATOR: ReadonlyUint8Array =
 	new Uint8Array([92, 166, 184, 23, 127, 201, 251, 148]);
@@ -98,7 +99,7 @@ export function getUserRewardDebtEncoder(): FixedSizeEncoder<UserRewardDebtArgs>
 			['amountSnapshot', getU64Encoder()],
 			['settledVersion', getU32Encoder()],
 			['owed', getU64Encoder()],
-			['reserved', fixEncoderSize(getBytesEncoder(), 32)],
+			['reserved', fixEncoderSize(getBytesEncoder(), 64)],
 		]),
 		(value) => ({
 			...value,
@@ -121,7 +122,7 @@ export function getUserRewardDebtDecoder(): FixedSizeDecoder<UserRewardDebt> {
 		['amountSnapshot', getU64Decoder()],
 		['settledVersion', getU32Decoder()],
 		['owed', getU64Decoder()],
-		['reserved', fixDecoderSize(getBytesDecoder(), 32)],
+		['reserved', fixDecoderSize(getBytesDecoder(), 64)],
 	]);
 }
 
@@ -133,9 +134,25 @@ export function getUserRewardDebtCodec(): FixedSizeCodec<
 	return combineCodec(getUserRewardDebtEncoder(), getUserRewardDebtDecoder());
 }
 
+/**
+ * Decodes a `UserRewardDebt` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeUserRewardDebt}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodeUserRewardDebt<TAddress extends string = string>(
 	encodedAccount: EncodedAccount<TAddress>,
 ): Account<UserRewardDebt, TAddress>;
+/**
+ * Decodes a `UserRewardDebt` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeUserRewardDebt}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodeUserRewardDebt<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<UserRewardDebt, TAddress>;
@@ -170,6 +187,7 @@ export function decodeUserRewardDebt<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `UserRewardDebt` account, throwing when it does not exist or only holds lamports. */
 export async function fetchUserRewardDebt<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -180,6 +198,11 @@ export async function fetchUserRewardDebt<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybeUserRewardDebt<
 	TAddress extends string = string,
 >(
@@ -188,9 +211,14 @@ export async function fetchMaybeUserRewardDebt<
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<UserRewardDebt, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeUserRewardDebt(maybeAccount);
+	return decodeUserRewardDebt(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `UserRewardDebt` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllUserRewardDebt(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -205,6 +233,11 @@ export async function fetchAllUserRewardDebt(
 	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.
+ */
 export async function fetchAllMaybeUserRewardDebt(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -212,10 +245,14 @@ export async function fetchAllMaybeUserRewardDebt(
 ): Promise<MaybeAccount<UserRewardDebt>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
 	return maybeAccounts.map((maybeAccount) =>
-		decodeUserRewardDebt(maybeAccount),
+		decodeUserRewardDebt(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
 	);
 }
 
 export function getUserRewardDebtSize(): number {
-	return 182;
+	return 214;
 }

package/src/nexus/generated/accounts/userStakePosition.ts

@@ -44,6 +44,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 
 export const USER_STAKE_POSITION_DISCRIMINATOR: ReadonlyUint8Array =
 	new Uint8Array([123, 46, 248, 17, 240, 135, 201, 17]);
@@ -89,7 +90,7 @@ export function getUserStakePositionEncoder(): FixedSizeEncoder<UserStakePositio
 			['amount', getU64Encoder()],
 			['stakeVersion', getU32Encoder()],
 			['settledCount', getU16Encoder()],
-			['reserved', fixEncoderSize(getBytesEncoder(), 32)],
+			['reserved', fixEncoderSize(getBytesEncoder(), 128)],
 		]),
 		(value) => ({
 			...value,
@@ -109,7 +110,7 @@ export function getUserStakePositionDecoder(): FixedSizeDecoder<UserStakePositio
 		['amount', getU64Decoder()],
 		['stakeVersion', getU32Decoder()],
 		['settledCount', getU16Decoder()],
-		['reserved', fixDecoderSize(getBytesDecoder(), 32)],
+		['reserved', fixDecoderSize(getBytesDecoder(), 128)],
 	]);
 }
 
@@ -124,9 +125,25 @@ export function getUserStakePositionCodec(): FixedSizeCodec<
 	);
 }
 
+/**
+ * Decodes a `UserStakePosition` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeUserStakePosition}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodeUserStakePosition<TAddress extends string = string>(
 	encodedAccount: EncodedAccount<TAddress>,
 ): Account<UserStakePosition, TAddress>;
+/**
+ * Decodes a `UserStakePosition` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeUserStakePosition}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodeUserStakePosition<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<UserStakePosition, TAddress>;
@@ -163,6 +180,7 @@ export function decodeUserStakePosition<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `UserStakePosition` account, throwing when it does not exist or only holds lamports. */
 export async function fetchUserStakePosition<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -177,6 +195,11 @@ export async function fetchUserStakePosition<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybeUserStakePosition<
 	TAddress extends string = string,
 >(
@@ -185,9 +208,14 @@ export async function fetchMaybeUserStakePosition<
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<UserStakePosition, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeUserStakePosition(maybeAccount);
+	return decodeUserStakePosition(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `UserStakePosition` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllUserStakePosition(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -202,6 +230,11 @@ export async function fetchAllUserStakePosition(
 	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.
+ */
 export async function fetchAllMaybeUserStakePosition(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -209,10 +242,14 @@ export async function fetchAllMaybeUserStakePosition(
 ): Promise<MaybeAccount<UserStakePosition>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
 	return maybeAccounts.map((maybeAccount) =>
-		decodeUserStakePosition(maybeAccount),
+		decodeUserStakePosition(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
 	);
 }
 
 export function getUserStakePositionSize(): number {
-	return 120;
+	return 216;
 }