@send-fun/sdk 1.0.0

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

@@ -0,0 +1,209 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+	assertAccountExists,
+	assertAccountsExist,
+	combineCodec,
+	containsBytes,
+	decodeAccount,
+	fetchEncodedAccount,
+	fetchEncodedAccounts,
+	fixDecoderSize,
+	fixEncoderSize,
+	getAddressDecoder,
+	getAddressEncoder,
+	getBytesDecoder,
+	getBytesEncoder,
+	getI64Decoder,
+	getI64Encoder,
+	getStructDecoder,
+	getStructEncoder,
+	getU64Decoder,
+	getU64Encoder,
+	getU8Decoder,
+	getU8Encoder,
+	transformEncoder,
+	type Account,
+	type Address,
+	type EncodedAccount,
+	type FetchAccountConfig,
+	type FetchAccountsConfig,
+	type FixedSizeCodec,
+	type FixedSizeDecoder,
+	type FixedSizeEncoder,
+	type MaybeAccount,
+	type MaybeEncodedAccount,
+	type ReadonlyUint8Array,
+} from '@solana/kit';
+import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+
+export const REWARD_STATE_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
+	86, 245, 149, 170, 90, 108, 31, 251,
+]);
+
+export function getRewardStateDiscriminatorBytes(): ReadonlyUint8Array {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(
+		REWARD_STATE_DISCRIMINATOR,
+	);
+}
+
+export type RewardState = {
+	discriminator: ReadonlyUint8Array;
+	version: number;
+	bump: number;
+	stakingConfig: Address;
+	rewardMint: Address;
+	vault: Address;
+	totalClaimed: bigint;
+	usdcPrice: bigint;
+	usdcPriceUpdatedAt: bigint;
+	isStablecoin: number;
+	disabled: number;
+	reserved: ReadonlyUint8Array;
+};
+
+export type RewardStateArgs = {
+	version: number;
+	bump: number;
+	stakingConfig: Address;
+	rewardMint: Address;
+	vault: Address;
+	totalClaimed: number | bigint;
+	usdcPrice: number | bigint;
+	usdcPriceUpdatedAt: number | bigint;
+	isStablecoin: number;
+	disabled: number;
+	reserved: ReadonlyUint8Array;
+};
+
+/** Gets the encoder for {@link RewardStateArgs} account data. */
+export function getRewardStateEncoder(): FixedSizeEncoder<RewardStateArgs> {
+	return transformEncoder(
+		getStructEncoder([
+			['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+			['version', getU8Encoder()],
+			['bump', getU8Encoder()],
+			['stakingConfig', getAddressEncoder()],
+			['rewardMint', getAddressEncoder()],
+			['vault', getAddressEncoder()],
+			['totalClaimed', getU64Encoder()],
+			['usdcPrice', getU64Encoder()],
+			['usdcPriceUpdatedAt', getI64Encoder()],
+			['isStablecoin', getU8Encoder()],
+			['disabled', getU8Encoder()],
+			['reserved', fixEncoderSize(getBytesEncoder(), 64)],
+		]),
+		(value) => ({ ...value, discriminator: REWARD_STATE_DISCRIMINATOR }),
+	);
+}
+
+/** Gets the decoder for {@link RewardState} account data. */
+export function getRewardStateDecoder(): FixedSizeDecoder<RewardState> {
+	return getStructDecoder([
+		['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+		['version', getU8Decoder()],
+		['bump', getU8Decoder()],
+		['stakingConfig', getAddressDecoder()],
+		['rewardMint', getAddressDecoder()],
+		['vault', getAddressDecoder()],
+		['totalClaimed', getU64Decoder()],
+		['usdcPrice', getU64Decoder()],
+		['usdcPriceUpdatedAt', getI64Decoder()],
+		['isStablecoin', getU8Decoder()],
+		['disabled', getU8Decoder()],
+		['reserved', fixDecoderSize(getBytesDecoder(), 64)],
+	]);
+}
+
+/** Gets the codec for {@link RewardState} account data. */
+export function getRewardStateCodec(): FixedSizeCodec<
+	RewardStateArgs,
+	RewardState
+> {
+	return combineCodec(getRewardStateEncoder(), getRewardStateDecoder());
+}
+
+export function decodeRewardState<TAddress extends string = string>(
+	encodedAccount: EncodedAccount<TAddress>,
+): Account<RewardState, TAddress>;
+export function decodeRewardState<TAddress extends string = string>(
+	encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<RewardState, TAddress>;
+export function decodeRewardState<TAddress extends string = string>(
+	encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<RewardState, TAddress> | MaybeAccount<RewardState, TAddress> {
+	if (!('exists' in encodedAccount) || encodedAccount.exists) {
+		if (encodedAccount.programAddress !== SEND_NEXUS_PROGRAM_ADDRESS) {
+			const error = new Error(
+				`decodeRewardState: account ${encodedAccount.address} is owned by ${encodedAccount.programAddress}, expected ${SEND_NEXUS_PROGRAM_ADDRESS}`,
+			);
+			error.name = 'AccountOwnerMismatchError';
+			throw error;
+		}
+		if (
+			!containsBytes(encodedAccount.data, REWARD_STATE_DISCRIMINATOR, 0)
+		) {
+			const error = new Error(
+				`decodeRewardState: account ${encodedAccount.address} does not match the RewardState discriminator`,
+			);
+			error.name = 'AccountDiscriminatorMismatchError';
+			throw error;
+		}
+	}
+	return decodeAccount(
+		encodedAccount as MaybeEncodedAccount<TAddress>,
+		getRewardStateDecoder(),
+	);
+}
+
+export async function fetchRewardState<TAddress extends string = string>(
+	rpc: Parameters<typeof fetchEncodedAccount>[0],
+	address: Address<TAddress>,
+	config?: FetchAccountConfig,
+): Promise<Account<RewardState, TAddress>> {
+	const maybeAccount = await fetchMaybeRewardState(rpc, address, config);
+	assertAccountExists(maybeAccount);
+	return maybeAccount;
+}
+
+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);
+}
+
+export async function fetchAllRewardState(
+	rpc: Parameters<typeof fetchEncodedAccounts>[0],
+	addresses: Array<Address>,
+	config?: FetchAccountsConfig,
+): Promise<Account<RewardState>[]> {
+	const maybeAccounts = await fetchAllMaybeRewardState(
+		rpc,
+		addresses,
+		config,
+	);
+	assertAccountsExist(maybeAccounts);
+	return maybeAccounts;
+}
+
+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));
+}
+
+export function getRewardStateSize(): number {
+	return 196;
+}

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

@@ -0,0 +1,85 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+	containsBytes,
+	type Address,
+	type ReadonlyUint8Array,
+} 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';
+import { PARTNER_METADATA_DISCRIMINATOR } from './partnerMetadata.js';
+import { REWARD_STATE_DISCRIMINATOR } from './rewardState.js';
+import { STAKING_CONFIG_DISCRIMINATOR } from './stakingConfig.js';
+import { USER_REWARD_DEBT_DISCRIMINATOR } from './userRewardDebt.js';
+import { USER_STAKE_POSITION_DISCRIMINATOR } from './userStakePosition.js';
+
+/** Account kinds of the sendNexus program. */
+export type SendNexusAccountType =
+	| 'altRegistry'
+	| 'creatorFeeConfig'
+	| 'feePreset'
+	| 'globalConfig'
+	| 'partnerConfig'
+	| 'partnerMetadata'
+	| 'rewardState'
+	| 'stakingConfig'
+	| 'userRewardDebt'
+	| 'userStakePosition';
+
+/**
+ * Identifies sendNexus account data by its discriminators.
+ * Returns `null` when the account belongs to another program or the data matches no known account.
+ */
+export function identifySendNexusAccount(
+	account:
+		| { data: ReadonlyUint8Array; programAddress: Address }
+		| ReadonlyUint8Array,
+): SendNexusAccountType | null {
+	if (
+		'data' in account &&
+		account.programAddress !== SEND_NEXUS_PROGRAM_ADDRESS
+	)
+		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';
+	}
+	if (containsBytes(data, PARTNER_METADATA_DISCRIMINATOR, 0)) {
+		return 'partnerMetadata';
+	}
+	if (containsBytes(data, REWARD_STATE_DISCRIMINATOR, 0)) {
+		return 'rewardState';
+	}
+	if (containsBytes(data, STAKING_CONFIG_DISCRIMINATOR, 0)) {
+		return 'stakingConfig';
+	}
+	if (containsBytes(data, USER_REWARD_DEBT_DISCRIMINATOR, 0)) {
+		return 'userRewardDebt';
+	}
+	if (containsBytes(data, USER_STAKE_POSITION_DISCRIMINATOR, 0)) {
+		return 'userStakePosition';
+	}
+	return null;
+}

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

@@ -0,0 +1,197 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+	assertAccountExists,
+	assertAccountsExist,
+	combineCodec,
+	containsBytes,
+	decodeAccount,
+	fetchEncodedAccount,
+	fetchEncodedAccounts,
+	fixDecoderSize,
+	fixEncoderSize,
+	getAddressDecoder,
+	getAddressEncoder,
+	getBooleanDecoder,
+	getBooleanEncoder,
+	getBytesDecoder,
+	getBytesEncoder,
+	getStructDecoder,
+	getStructEncoder,
+	getU16Decoder,
+	getU16Encoder,
+	getU64Decoder,
+	getU64Encoder,
+	getU8Decoder,
+	getU8Encoder,
+	transformEncoder,
+	type Account,
+	type Address,
+	type EncodedAccount,
+	type FetchAccountConfig,
+	type FetchAccountsConfig,
+	type FixedSizeCodec,
+	type FixedSizeDecoder,
+	type FixedSizeEncoder,
+	type MaybeAccount,
+	type MaybeEncodedAccount,
+	type ReadonlyUint8Array,
+} from '@solana/kit';
+import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+
+export const STAKING_CONFIG_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
+	45, 134, 252, 82, 37, 57, 84, 25,
+]);
+
+export function getStakingConfigDiscriminatorBytes(): ReadonlyUint8Array {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(
+		STAKING_CONFIG_DISCRIMINATOR,
+	);
+}
+
+export type StakingConfig = {
+	discriminator: ReadonlyUint8Array;
+	version: number;
+	bump: number;
+	stakingMint: Address;
+	totalStaked: bigint;
+	stakingEnabled: boolean;
+	rewardCount: number;
+	reserved: ReadonlyUint8Array;
+};
+
+export type StakingConfigArgs = {
+	version: number;
+	bump: number;
+	stakingMint: Address;
+	totalStaked: number | bigint;
+	stakingEnabled: boolean;
+	rewardCount: number;
+	reserved: ReadonlyUint8Array;
+};
+
+/** Gets the encoder for {@link StakingConfigArgs} account data. */
+export function getStakingConfigEncoder(): FixedSizeEncoder<StakingConfigArgs> {
+	return transformEncoder(
+		getStructEncoder([
+			['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+			['version', getU8Encoder()],
+			['bump', getU8Encoder()],
+			['stakingMint', getAddressEncoder()],
+			['totalStaked', getU64Encoder()],
+			['stakingEnabled', getBooleanEncoder()],
+			['rewardCount', getU16Encoder()],
+			['reserved', fixEncoderSize(getBytesEncoder(), 64)],
+		]),
+		(value) => ({ ...value, discriminator: STAKING_CONFIG_DISCRIMINATOR }),
+	);
+}
+
+/** Gets the decoder for {@link StakingConfig} account data. */
+export function getStakingConfigDecoder(): FixedSizeDecoder<StakingConfig> {
+	return getStructDecoder([
+		['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+		['version', getU8Decoder()],
+		['bump', getU8Decoder()],
+		['stakingMint', getAddressDecoder()],
+		['totalStaked', getU64Decoder()],
+		['stakingEnabled', getBooleanDecoder()],
+		['rewardCount', getU16Decoder()],
+		['reserved', fixDecoderSize(getBytesDecoder(), 64)],
+	]);
+}
+
+/** Gets the codec for {@link StakingConfig} account data. */
+export function getStakingConfigCodec(): FixedSizeCodec<
+	StakingConfigArgs,
+	StakingConfig
+> {
+	return combineCodec(getStakingConfigEncoder(), getStakingConfigDecoder());
+}
+
+export function decodeStakingConfig<TAddress extends string = string>(
+	encodedAccount: EncodedAccount<TAddress>,
+): Account<StakingConfig, TAddress>;
+export function decodeStakingConfig<TAddress extends string = string>(
+	encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<StakingConfig, TAddress>;
+export function decodeStakingConfig<TAddress extends string = string>(
+	encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<StakingConfig, TAddress> | MaybeAccount<StakingConfig, TAddress> {
+	if (!('exists' in encodedAccount) || encodedAccount.exists) {
+		if (encodedAccount.programAddress !== SEND_NEXUS_PROGRAM_ADDRESS) {
+			const error = new Error(
+				`decodeStakingConfig: account ${encodedAccount.address} is owned by ${encodedAccount.programAddress}, expected ${SEND_NEXUS_PROGRAM_ADDRESS}`,
+			);
+			error.name = 'AccountOwnerMismatchError';
+			throw error;
+		}
+		if (
+			!containsBytes(encodedAccount.data, STAKING_CONFIG_DISCRIMINATOR, 0)
+		) {
+			const error = new Error(
+				`decodeStakingConfig: account ${encodedAccount.address} does not match the StakingConfig discriminator`,
+			);
+			error.name = 'AccountDiscriminatorMismatchError';
+			throw error;
+		}
+	}
+	return decodeAccount(
+		encodedAccount as MaybeEncodedAccount<TAddress>,
+		getStakingConfigDecoder(),
+	);
+}
+
+export async function fetchStakingConfig<TAddress extends string = string>(
+	rpc: Parameters<typeof fetchEncodedAccount>[0],
+	address: Address<TAddress>,
+	config?: FetchAccountConfig,
+): Promise<Account<StakingConfig, TAddress>> {
+	const maybeAccount = await fetchMaybeStakingConfig(rpc, address, config);
+	assertAccountExists(maybeAccount);
+	return maybeAccount;
+}
+
+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);
+}
+
+export async function fetchAllStakingConfig(
+	rpc: Parameters<typeof fetchEncodedAccounts>[0],
+	addresses: Array<Address>,
+	config?: FetchAccountsConfig,
+): Promise<Account<StakingConfig>[]> {
+	const maybeAccounts = await fetchAllMaybeStakingConfig(
+		rpc,
+		addresses,
+		config,
+	);
+	assertAccountsExist(maybeAccounts);
+	return maybeAccounts;
+}
+
+export async function fetchAllMaybeStakingConfig(
+	rpc: Parameters<typeof fetchEncodedAccounts>[0],
+	addresses: Array<Address>,
+	config?: FetchAccountsConfig,
+): Promise<MaybeAccount<StakingConfig>[]> {
+	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+	return maybeAccounts.map((maybeAccount) =>
+		decodeStakingConfig(maybeAccount),
+	);
+}
+
+export function getStakingConfigSize(): number {
+	return 117;
+}

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

@@ -0,0 +1,221 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+	assertAccountExists,
+	assertAccountsExist,
+	combineCodec,
+	containsBytes,
+	decodeAccount,
+	fetchEncodedAccount,
+	fetchEncodedAccounts,
+	fixDecoderSize,
+	fixEncoderSize,
+	getAddressDecoder,
+	getAddressEncoder,
+	getBytesDecoder,
+	getBytesEncoder,
+	getStructDecoder,
+	getStructEncoder,
+	getU128Decoder,
+	getU128Encoder,
+	getU32Decoder,
+	getU32Encoder,
+	getU64Decoder,
+	getU64Encoder,
+	getU8Decoder,
+	getU8Encoder,
+	transformEncoder,
+	type Account,
+	type Address,
+	type EncodedAccount,
+	type FetchAccountConfig,
+	type FetchAccountsConfig,
+	type FixedSizeCodec,
+	type FixedSizeDecoder,
+	type FixedSizeEncoder,
+	type MaybeAccount,
+	type MaybeEncodedAccount,
+	type ReadonlyUint8Array,
+} from '@solana/kit';
+import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+
+export const USER_REWARD_DEBT_DISCRIMINATOR: ReadonlyUint8Array =
+	new Uint8Array([92, 166, 184, 23, 127, 201, 251, 148]);
+
+export function getUserRewardDebtDiscriminatorBytes(): ReadonlyUint8Array {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(
+		USER_REWARD_DEBT_DISCRIMINATOR,
+	);
+}
+
+export type UserRewardDebt = {
+	discriminator: ReadonlyUint8Array;
+	version: number;
+	bump: number;
+	user: Address;
+	stakingMint: Address;
+	rewardMint: Address;
+	accSnapshot: bigint;
+	claimed: bigint;
+	amountSnapshot: bigint;
+	settledVersion: number;
+	owed: bigint;
+	reserved: ReadonlyUint8Array;
+};
+
+export type UserRewardDebtArgs = {
+	version: number;
+	bump: number;
+	user: Address;
+	stakingMint: Address;
+	rewardMint: Address;
+	accSnapshot: number | bigint;
+	claimed: number | bigint;
+	amountSnapshot: number | bigint;
+	settledVersion: number;
+	owed: number | bigint;
+	reserved: ReadonlyUint8Array;
+};
+
+/** Gets the encoder for {@link UserRewardDebtArgs} account data. */
+export function getUserRewardDebtEncoder(): FixedSizeEncoder<UserRewardDebtArgs> {
+	return transformEncoder(
+		getStructEncoder([
+			['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+			['version', getU8Encoder()],
+			['bump', getU8Encoder()],
+			['user', getAddressEncoder()],
+			['stakingMint', getAddressEncoder()],
+			['rewardMint', getAddressEncoder()],
+			['accSnapshot', getU128Encoder()],
+			['claimed', getU64Encoder()],
+			['amountSnapshot', getU64Encoder()],
+			['settledVersion', getU32Encoder()],
+			['owed', getU64Encoder()],
+			['reserved', fixEncoderSize(getBytesEncoder(), 32)],
+		]),
+		(value) => ({
+			...value,
+			discriminator: USER_REWARD_DEBT_DISCRIMINATOR,
+		}),
+	);
+}
+
+/** Gets the decoder for {@link UserRewardDebt} account data. */
+export function getUserRewardDebtDecoder(): FixedSizeDecoder<UserRewardDebt> {
+	return getStructDecoder([
+		['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+		['version', getU8Decoder()],
+		['bump', getU8Decoder()],
+		['user', getAddressDecoder()],
+		['stakingMint', getAddressDecoder()],
+		['rewardMint', getAddressDecoder()],
+		['accSnapshot', getU128Decoder()],
+		['claimed', getU64Decoder()],
+		['amountSnapshot', getU64Decoder()],
+		['settledVersion', getU32Decoder()],
+		['owed', getU64Decoder()],
+		['reserved', fixDecoderSize(getBytesDecoder(), 32)],
+	]);
+}
+
+/** Gets the codec for {@link UserRewardDebt} account data. */
+export function getUserRewardDebtCodec(): FixedSizeCodec<
+	UserRewardDebtArgs,
+	UserRewardDebt
+> {
+	return combineCodec(getUserRewardDebtEncoder(), getUserRewardDebtDecoder());
+}
+
+export function decodeUserRewardDebt<TAddress extends string = string>(
+	encodedAccount: EncodedAccount<TAddress>,
+): Account<UserRewardDebt, TAddress>;
+export function decodeUserRewardDebt<TAddress extends string = string>(
+	encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<UserRewardDebt, TAddress>;
+export function decodeUserRewardDebt<TAddress extends string = string>(
+	encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<UserRewardDebt, TAddress> | MaybeAccount<UserRewardDebt, TAddress> {
+	if (!('exists' in encodedAccount) || encodedAccount.exists) {
+		if (encodedAccount.programAddress !== SEND_NEXUS_PROGRAM_ADDRESS) {
+			const error = new Error(
+				`decodeUserRewardDebt: account ${encodedAccount.address} is owned by ${encodedAccount.programAddress}, expected ${SEND_NEXUS_PROGRAM_ADDRESS}`,
+			);
+			error.name = 'AccountOwnerMismatchError';
+			throw error;
+		}
+		if (
+			!containsBytes(
+				encodedAccount.data,
+				USER_REWARD_DEBT_DISCRIMINATOR,
+				0,
+			)
+		) {
+			const error = new Error(
+				`decodeUserRewardDebt: account ${encodedAccount.address} does not match the UserRewardDebt discriminator`,
+			);
+			error.name = 'AccountDiscriminatorMismatchError';
+			throw error;
+		}
+	}
+	return decodeAccount(
+		encodedAccount as MaybeEncodedAccount<TAddress>,
+		getUserRewardDebtDecoder(),
+	);
+}
+
+export async function fetchUserRewardDebt<TAddress extends string = string>(
+	rpc: Parameters<typeof fetchEncodedAccount>[0],
+	address: Address<TAddress>,
+	config?: FetchAccountConfig,
+): Promise<Account<UserRewardDebt, TAddress>> {
+	const maybeAccount = await fetchMaybeUserRewardDebt(rpc, address, config);
+	assertAccountExists(maybeAccount);
+	return maybeAccount;
+}
+
+export async function fetchMaybeUserRewardDebt<
+	TAddress extends string = string,
+>(
+	rpc: Parameters<typeof fetchEncodedAccount>[0],
+	address: Address<TAddress>,
+	config?: FetchAccountConfig,
+): Promise<MaybeAccount<UserRewardDebt, TAddress>> {
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeUserRewardDebt(maybeAccount);
+}
+
+export async function fetchAllUserRewardDebt(
+	rpc: Parameters<typeof fetchEncodedAccounts>[0],
+	addresses: Array<Address>,
+	config?: FetchAccountsConfig,
+): Promise<Account<UserRewardDebt>[]> {
+	const maybeAccounts = await fetchAllMaybeUserRewardDebt(
+		rpc,
+		addresses,
+		config,
+	);
+	assertAccountsExist(maybeAccounts);
+	return maybeAccounts;
+}
+
+export async function fetchAllMaybeUserRewardDebt(
+	rpc: Parameters<typeof fetchEncodedAccounts>[0],
+	addresses: Array<Address>,
+	config?: FetchAccountsConfig,
+): Promise<MaybeAccount<UserRewardDebt>[]> {
+	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+	return maybeAccounts.map((maybeAccount) =>
+		decodeUserRewardDebt(maybeAccount),
+	);
+}
+
+export function getUserRewardDebtSize(): number {
+	return 182;
+}