@send-fun/sdk 1.1.0 → 1.2.0

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

@@ -38,6 +38,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 
 export const ALT_REGISTRY_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
 	184, 237, 52, 250, 77, 8, 59, 74,
@@ -97,9 +98,25 @@ export function getAltRegistryCodec(): FixedSizeCodec<
 	return combineCodec(getAltRegistryEncoder(), getAltRegistryDecoder());
 }
 
+/**
+ * Decodes a `AltRegistry` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeAltRegistry}, 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 decodeAltRegistry<TAddress extends string = string>(
 	encodedAccount: EncodedAccount<TAddress>,
 ): Account<AltRegistry, TAddress>;
+/**
+ * Decodes a `AltRegistry` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeAltRegistry}, 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 decodeAltRegistry<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<AltRegistry, TAddress>;
@@ -130,6 +147,7 @@ export function decodeAltRegistry<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `AltRegistry` account, throwing when it does not exist or only holds lamports. */
 export async function fetchAltRegistry<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -140,15 +158,25 @@ export async function fetchAltRegistry<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybeAltRegistry<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<AltRegistry, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeAltRegistry(maybeAccount);
+	return decodeAltRegistry(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `AltRegistry` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllAltRegistry(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -163,13 +191,24 @@ export async function fetchAllAltRegistry(
 	return maybeAccounts;
 }
 
+/**
+ * Fetches `AltRegistry` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeAltRegistry} throws for a lamports-only account instead.
+ */
 export async function fetchAllMaybeAltRegistry(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
 	config?: FetchAccountsConfig,
 ): Promise<MaybeAccount<AltRegistry>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
-	return maybeAccounts.map((maybeAccount) => decodeAltRegistry(maybeAccount));
+	return maybeAccounts.map((maybeAccount) =>
+		decodeAltRegistry(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
+	);
 }
 
 export function getAltRegistrySize(): number {

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

@@ -38,6 +38,7 @@ import {
 	type ReadonlyUint8Array,
 } from '@solana/kit';
 import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+import { accountIsCreated } from '../shared/index.js';
 
 export const CREATOR_FEE_CONFIG_DISCRIMINATOR: ReadonlyUint8Array =
 	new Uint8Array([160, 88, 34, 74, 215, 196, 130, 32]);
@@ -110,9 +111,25 @@ export function getCreatorFeeConfigCodec(): FixedSizeCodec<
 	);
 }
 
+/**
+ * Decodes a `CreatorFeeConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeCreatorFeeConfig}, 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 decodeCreatorFeeConfig<TAddress extends string = string>(
 	encodedAccount: EncodedAccount<TAddress>,
 ): Account<CreatorFeeConfig, TAddress>;
+/**
+ * Decodes a `CreatorFeeConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeCreatorFeeConfig}, 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 decodeCreatorFeeConfig<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<CreatorFeeConfig, TAddress>;
@@ -149,6 +166,7 @@ export function decodeCreatorFeeConfig<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `CreatorFeeConfig` account, throwing when it does not exist or only holds lamports. */
 export async function fetchCreatorFeeConfig<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -159,6 +177,11 @@ export async function fetchCreatorFeeConfig<TAddress extends string = string>(
 	return maybeAccount;
 }
 
+/**
+ * Fetches a `CreatorFeeConfig` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeCreatorFeeConfig} throws for a lamports-only account instead.
+ */
 export async function fetchMaybeCreatorFeeConfig<
 	TAddress extends string = string,
 >(
@@ -167,9 +190,14 @@ export async function fetchMaybeCreatorFeeConfig<
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<CreatorFeeConfig, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeCreatorFeeConfig(maybeAccount);
+	return decodeCreatorFeeConfig(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `CreatorFeeConfig` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllCreatorFeeConfig(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -184,6 +212,11 @@ export async function fetchAllCreatorFeeConfig(
 	return maybeAccounts;
 }
 
+/**
+ * Fetches `CreatorFeeConfig` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeCreatorFeeConfig} throws for a lamports-only account instead.
+ */
 export async function fetchAllMaybeCreatorFeeConfig(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -191,7 +224,11 @@ export async function fetchAllMaybeCreatorFeeConfig(
 ): Promise<MaybeAccount<CreatorFeeConfig>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
 	return maybeAccounts.map((maybeAccount) =>
-		decodeCreatorFeeConfig(maybeAccount),
+		decodeCreatorFeeConfig(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
 	);
 }
 

package/src/nexus/generated/accounts/feePreset.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';
 import {
 	getDexFeesDecoder,
 	getDexFeesEncoder,
@@ -126,9 +127,25 @@ export function getFeePresetCodec(): Codec<FeePresetArgs, FeePreset> {
 	return combineCodec(getFeePresetEncoder(), getFeePresetDecoder());
 }
 
+/**
+ * Decodes a `FeePreset` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeFeePreset}, 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 decodeFeePreset<TAddress extends string = string>(
 	encodedAccount: EncodedAccount<TAddress>,
 ): Account<FeePreset, TAddress>;
+/**
+ * Decodes a `FeePreset` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeFeePreset}, 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 decodeFeePreset<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<FeePreset, TAddress>;
@@ -157,6 +174,7 @@ export function decodeFeePreset<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `FeePreset` account, throwing when it does not exist or only holds lamports. */
 export async function fetchFeePreset<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -167,15 +185,25 @@ export async function fetchFeePreset<TAddress extends string = string>(
 	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.
+ */
 export async function fetchMaybeFeePreset<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<FeePreset, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeFeePreset(maybeAccount);
+	return decodeFeePreset(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `FeePreset` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllFeePreset(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -186,11 +214,22 @@ export async function fetchAllFeePreset(
 	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.
+ */
 export async function fetchAllMaybeFeePreset(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
 	config?: FetchAccountsConfig,
 ): Promise<MaybeAccount<FeePreset>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
-	return maybeAccounts.map((maybeAccount) => decodeFeePreset(maybeAccount));
+	return maybeAccounts.map((maybeAccount) =>
+		decodeFeePreset(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
+	);
 }

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

@@ -40,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 {
 	getAuthPlatformEntryDecoder,
 	getAuthPlatformEntryEncoder,
@@ -110,9 +111,25 @@ export function getGlobalConfigCodec(): Codec<GlobalConfigArgs, GlobalConfig> {
 	return combineCodec(getGlobalConfigEncoder(), getGlobalConfigDecoder());
 }
 
+/**
+ * Decodes a `GlobalConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeGlobalConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodeGlobalConfig<TAddress extends string = string>(
 	encodedAccount: EncodedAccount<TAddress>,
 ): Account<GlobalConfig, TAddress>;
+/**
+ * Decodes a `GlobalConfig` account, throwing when another program owns it or its discriminator
+ * does not match.
+ *
+ * Unlike {@link fetchMaybeGlobalConfig}, this throws for an address that only holds lamports rather
+ * than returning the non-existing variant: an account passed as existing must never come back as that
+ * variant typed as an `Account`. Apply {@link accountIsCreated} first to accounts fetched another way.
+ */
 export function decodeGlobalConfig<TAddress extends string = string>(
 	encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<GlobalConfig, TAddress>;
@@ -143,6 +160,7 @@ export function decodeGlobalConfig<TAddress extends string = string>(
 	);
 }
 
+/** Fetches a `GlobalConfig` account, throwing when it does not exist or only holds lamports. */
 export async function fetchGlobalConfig<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
@@ -153,15 +171,25 @@ export async function fetchGlobalConfig<TAddress extends string = string>(
 	return maybeAccount;
 }
 
+/**
+ * Fetches a `GlobalConfig` account, or the non-existing variant when the address holds no
+ * account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeGlobalConfig} throws for a lamports-only account instead.
+ */
 export async function fetchMaybeGlobalConfig<TAddress extends string = string>(
 	rpc: Parameters<typeof fetchEncodedAccount>[0],
 	address: Address<TAddress>,
 	config?: FetchAccountConfig,
 ): Promise<MaybeAccount<GlobalConfig, TAddress>> {
 	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeGlobalConfig(maybeAccount);
+	return decodeGlobalConfig(
+		accountIsCreated(maybeAccount)
+			? maybeAccount
+			: { address, exists: false },
+	);
 }
 
+/** Fetches `GlobalConfig` accounts, throwing when any does not exist or only holds lamports. */
 export async function fetchAllGlobalConfig(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -176,6 +204,11 @@ export async function fetchAllGlobalConfig(
 	return maybeAccounts;
 }
 
+/**
+ * Fetches `GlobalConfig` accounts, with the non-existing variant for each address that holds
+ * no account or only lamports (see {@link accountIsCreated}).
+ * {@link decodeGlobalConfig} throws for a lamports-only account instead.
+ */
 export async function fetchAllMaybeGlobalConfig(
 	rpc: Parameters<typeof fetchEncodedAccounts>[0],
 	addresses: Array<Address>,
@@ -183,6 +216,10 @@ export async function fetchAllMaybeGlobalConfig(
 ): Promise<MaybeAccount<GlobalConfig>[]> {
 	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
 	return maybeAccounts.map((maybeAccount) =>
-		decodeGlobalConfig(maybeAccount),
+		decodeGlobalConfig(
+			accountIsCreated(maybeAccount)
+				? maybeAccount
+				: { address: maybeAccount.address, exists: false },
+		),
 	);
 }

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

@@ -38,6 +38,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,
@@ -127,9 +128,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 +177,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 +188,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 +221,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,7 +233,11 @@ 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 },
+		),
 	);
 }
 

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 {