@send-fun/sdk 1.0.1 → 1.2.0

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 {

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]);
@@ -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,7 +245,11 @@ 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 },
+		),
 	);
 }
 

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]);
@@ -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,7 +242,11 @@ 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 },
+		),
 	);
 }
 

package/src/nexus/generated/index.ts

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

package/src/nexus/generated/instructions/claim.ts

@@ -41,7 +41,7 @@ import {
 	getAccountMetaFactory,
 	getAddressFromResolvedInstructionAccount,
 	type ResolvedInstructionAccount,
-} from '@solana/program-client-core';
+} from '@solana/kit/program-client-core';
 import {
 	EVENT_AUTHORITY_PDA_ADDRESS,
 	findRewardStatePda,

package/src/nexus/generated/instructions/createUserRewardDebt.ts

@@ -38,7 +38,7 @@ import {
 	getAccountMetaFactory,
 	getAddressFromResolvedInstructionAccount,
 	type ResolvedInstructionAccount,
-} from '@solana/program-client-core';
+} from '@solana/kit/program-client-core';
 import {
 	findRewardStatePda,
 	findUserRewardDebtPda,