@send-fun/sdk 1.0.0

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

@@ -0,0 +1,218 @@
+/**
+ * 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,
+	getU16Decoder,
+	getU16Encoder,
+	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_STAKE_POSITION_DISCRIMINATOR: ReadonlyUint8Array =
+	new Uint8Array([123, 46, 248, 17, 240, 135, 201, 17]);
+
+export function getUserStakePositionDiscriminatorBytes(): ReadonlyUint8Array {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(
+		USER_STAKE_POSITION_DISCRIMINATOR,
+	);
+}
+
+export type UserStakePosition = {
+	discriminator: ReadonlyUint8Array;
+	version: number;
+	bump: number;
+	user: Address;
+	stakingMint: Address;
+	amount: bigint;
+	stakeVersion: number;
+	settledCount: number;
+	reserved: ReadonlyUint8Array;
+};
+
+export type UserStakePositionArgs = {
+	version: number;
+	bump: number;
+	user: Address;
+	stakingMint: Address;
+	amount: number | bigint;
+	stakeVersion: number;
+	settledCount: number;
+	reserved: ReadonlyUint8Array;
+};
+
+/** Gets the encoder for {@link UserStakePositionArgs} account data. */
+export function getUserStakePositionEncoder(): FixedSizeEncoder<UserStakePositionArgs> {
+	return transformEncoder(
+		getStructEncoder([
+			['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+			['version', getU8Encoder()],
+			['bump', getU8Encoder()],
+			['user', getAddressEncoder()],
+			['stakingMint', getAddressEncoder()],
+			['amount', getU64Encoder()],
+			['stakeVersion', getU32Encoder()],
+			['settledCount', getU16Encoder()],
+			['reserved', fixEncoderSize(getBytesEncoder(), 32)],
+		]),
+		(value) => ({
+			...value,
+			discriminator: USER_STAKE_POSITION_DISCRIMINATOR,
+		}),
+	);
+}
+
+/** Gets the decoder for {@link UserStakePosition} account data. */
+export function getUserStakePositionDecoder(): FixedSizeDecoder<UserStakePosition> {
+	return getStructDecoder([
+		['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+		['version', getU8Decoder()],
+		['bump', getU8Decoder()],
+		['user', getAddressDecoder()],
+		['stakingMint', getAddressDecoder()],
+		['amount', getU64Decoder()],
+		['stakeVersion', getU32Decoder()],
+		['settledCount', getU16Decoder()],
+		['reserved', fixDecoderSize(getBytesDecoder(), 32)],
+	]);
+}
+
+/** Gets the codec for {@link UserStakePosition} account data. */
+export function getUserStakePositionCodec(): FixedSizeCodec<
+	UserStakePositionArgs,
+	UserStakePosition
+> {
+	return combineCodec(
+		getUserStakePositionEncoder(),
+		getUserStakePositionDecoder(),
+	);
+}
+
+export function decodeUserStakePosition<TAddress extends string = string>(
+	encodedAccount: EncodedAccount<TAddress>,
+): Account<UserStakePosition, TAddress>;
+export function decodeUserStakePosition<TAddress extends string = string>(
+	encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<UserStakePosition, TAddress>;
+export function decodeUserStakePosition<TAddress extends string = string>(
+	encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+):
+	| Account<UserStakePosition, TAddress>
+	| MaybeAccount<UserStakePosition, TAddress> {
+	if (!('exists' in encodedAccount) || encodedAccount.exists) {
+		if (encodedAccount.programAddress !== SEND_NEXUS_PROGRAM_ADDRESS) {
+			const error = new Error(
+				`decodeUserStakePosition: account ${encodedAccount.address} is owned by ${encodedAccount.programAddress}, expected ${SEND_NEXUS_PROGRAM_ADDRESS}`,
+			);
+			error.name = 'AccountOwnerMismatchError';
+			throw error;
+		}
+		if (
+			!containsBytes(
+				encodedAccount.data,
+				USER_STAKE_POSITION_DISCRIMINATOR,
+				0,
+			)
+		) {
+			const error = new Error(
+				`decodeUserStakePosition: account ${encodedAccount.address} does not match the UserStakePosition discriminator`,
+			);
+			error.name = 'AccountDiscriminatorMismatchError';
+			throw error;
+		}
+	}
+	return decodeAccount(
+		encodedAccount as MaybeEncodedAccount<TAddress>,
+		getUserStakePositionDecoder(),
+	);
+}
+
+export async function fetchUserStakePosition<TAddress extends string = string>(
+	rpc: Parameters<typeof fetchEncodedAccount>[0],
+	address: Address<TAddress>,
+	config?: FetchAccountConfig,
+): Promise<Account<UserStakePosition, TAddress>> {
+	const maybeAccount = await fetchMaybeUserStakePosition(
+		rpc,
+		address,
+		config,
+	);
+	assertAccountExists(maybeAccount);
+	return maybeAccount;
+}
+
+export async function fetchMaybeUserStakePosition<
+	TAddress extends string = string,
+>(
+	rpc: Parameters<typeof fetchEncodedAccount>[0],
+	address: Address<TAddress>,
+	config?: FetchAccountConfig,
+): Promise<MaybeAccount<UserStakePosition, TAddress>> {
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeUserStakePosition(maybeAccount);
+}
+
+export async function fetchAllUserStakePosition(
+	rpc: Parameters<typeof fetchEncodedAccounts>[0],
+	addresses: Array<Address>,
+	config?: FetchAccountsConfig,
+): Promise<Account<UserStakePosition>[]> {
+	const maybeAccounts = await fetchAllMaybeUserStakePosition(
+		rpc,
+		addresses,
+		config,
+	);
+	assertAccountsExist(maybeAccounts);
+	return maybeAccounts;
+}
+
+export async function fetchAllMaybeUserStakePosition(
+	rpc: Parameters<typeof fetchEncodedAccounts>[0],
+	addresses: Array<Address>,
+	config?: FetchAccountsConfig,
+): Promise<MaybeAccount<UserStakePosition>[]> {
+	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+	return maybeAccounts.map((maybeAccount) =>
+		decodeUserStakePosition(maybeAccount),
+	);
+}
+
+export function getUserStakePositionSize(): number {
+	return 120;
+}

package/src/nexus/generated/constants/index.ts

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+
+export * from './sendNexus.js';

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

@@ -0,0 +1,13 @@
+/**
+ * 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 { address, type Address } from '@solana/kit';
+
+export const DEFAULT_PARTNER: Address = address(
+	'11111111111111111111111111111111',
+);

package/src/nexus/generated/errors/index.ts

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+
+export * from './sendNexus.js';

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

@@ -0,0 +1,229 @@
+/**
+ * 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 {
+	isProgramError,
+	type Address,
+	type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM,
+	type SolanaError,
+} from '@solana/kit';
+import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+
+/** InsufficientStake: Insufficient stake balance */
+export const SEND_NEXUS_ERROR__INSUFFICIENT_STAKE = 0x1770; // 6000
+/** InvalidRewardMint: Invalid reward mint */
+export const SEND_NEXUS_ERROR__INVALID_REWARD_MINT = 0x1771; // 6001
+/** InvalidVault: Invalid vault */
+export const SEND_NEXUS_ERROR__INVALID_VAULT = 0x1772; // 6002
+/** StakingAlreadyEnabled: Staking already enabled */
+export const SEND_NEXUS_ERROR__STAKING_ALREADY_ENABLED = 0x1775; // 6005
+/** StakingNotEnabled: Staking not enabled */
+export const SEND_NEXUS_ERROR__STAKING_NOT_ENABLED = 0x1776; // 6006
+/** InvalidStakingMint: Invalid staking mint */
+export const SEND_NEXUS_ERROR__INVALID_STAKING_MINT = 0x1777; // 6007
+/** InvalidRewardState: Invalid reward state */
+export const SEND_NEXUS_ERROR__INVALID_REWARD_STATE = 0x1778; // 6008
+/** InvalidMint: Invalid mint */
+export const SEND_NEXUS_ERROR__INVALID_MINT = 0x1779; // 6009
+/** InvalidDestination: Invalid destination account */
+export const SEND_NEXUS_ERROR__INVALID_DESTINATION = 0x177a; // 6010
+/** StakingMintAlreadyBound: Staking mint already bound */
+export const SEND_NEXUS_ERROR__STAKING_MINT_ALREADY_BOUND = 0x177b; // 6011
+/** InvalidFeePreset: Invalid fee configuration */
+export const SEND_NEXUS_ERROR__INVALID_FEE_PRESET = 0x177c; // 6012
+/** InvalidPresetIndex: Invalid preset index */
+export const SEND_NEXUS_ERROR__INVALID_PRESET_INDEX = 0x177d; // 6013
+/** MissingFeeSource: Must provide either fee_preset or custom fees */
+export const SEND_NEXUS_ERROR__MISSING_FEE_SOURCE = 0x177e; // 6014
+/** AmbiguousFeeSource: Cannot specify both fee_preset and custom_fees */
+export const SEND_NEXUS_ERROR__AMBIGUOUS_FEE_SOURCE = 0x177f; // 6015
+/** InvalidPartnerName: Partner name cannot be empty */
+export const SEND_NEXUS_ERROR__INVALID_PARTNER_NAME = 0x1780; // 6016
+/** PartnerNotOnPreset: Partner account does not use this preset */
+export const SEND_NEXUS_ERROR__PARTNER_NOT_ON_PRESET = 0x1781; // 6017
+/** InvalidPartnerNote: Invalid partner note */
+export const SEND_NEXUS_ERROR__INVALID_PARTNER_NOTE = 0x1782; // 6018
+/** InvalidPresetName: Invalid preset name */
+export const SEND_NEXUS_ERROR__INVALID_PRESET_NAME = 0x1783; // 6019
+/** TooManyAuthPlatforms: Too many auth platforms (max 255) */
+export const SEND_NEXUS_ERROR__TOO_MANY_AUTH_PLATFORMS = 0x1784; // 6020
+/** InvalidAuthPlatformIndex: Invalid auth platform index */
+export const SEND_NEXUS_ERROR__INVALID_AUTH_PLATFORM_INDEX = 0x1785; // 6021
+/** InvalidAuthPlatformName: Invalid auth platform name */
+export const SEND_NEXUS_ERROR__INVALID_AUTH_PLATFORM_NAME = 0x1786; // 6022
+/** DuplicateAuthPlatformName: Duplicate auth platform name */
+export const SEND_NEXUS_ERROR__DUPLICATE_AUTH_PLATFORM_NAME = 0x1787; // 6023
+/** InvalidAuthority: Invalid authority */
+export const SEND_NEXUS_ERROR__INVALID_AUTHORITY = 0x1788; // 6024
+/** ReservedPartner: Cannot add the default partner */
+export const SEND_NEXUS_ERROR__RESERVED_PARTNER = 0x1789; // 6025
+/** InvalidRewardAccrual: Invalid reward accrual */
+export const SEND_NEXUS_ERROR__INVALID_REWARD_ACCRUAL = 0x178a; // 6026
+/** RewardsNotSettled: Settle every reward mint before staking or unstaking - call settle for each registered mint */
+export const SEND_NEXUS_ERROR__REWARDS_NOT_SETTLED = 0x178b; // 6027
+/** InvalidUsdcPrice: USDC price must be non-zero - 0 means no price */
+export const SEND_NEXUS_ERROR__INVALID_USDC_PRICE = 0x178c; // 6028
+/** InvalidPlatformConfig: Platform config cannot be the default address */
+export const SEND_NEXUS_ERROR__INVALID_PLATFORM_CONFIG = 0x178d; // 6029
+/** InvalidPartnerConfig: Partner config address does not match its stored seeds */
+export const SEND_NEXUS_ERROR__INVALID_PARTNER_CONFIG = 0x178e; // 6030
+/** PresetPlatformMismatch: Fee preset belongs to a different platform */
+export const SEND_NEXUS_ERROR__PRESET_PLATFORM_MISMATCH = 0x178f; // 6031
+/** ProgramPaused: Program is paused */
+export const SEND_NEXUS_ERROR__PROGRAM_PAUSED = 0x1b58; // 7000
+/** Unauthorized: Unauthorized */
+export const SEND_NEXUS_ERROR__UNAUTHORIZED = 0x1b59; // 7001
+/** ArithmeticOverflow: Arithmetic overflow */
+export const SEND_NEXUS_ERROR__ARITHMETIC_OVERFLOW = 0x1b5a; // 7002
+/** InvalidPythAccount: Invalid Pyth price account */
+export const SEND_NEXUS_ERROR__INVALID_PYTH_ACCOUNT = 0x1b5b; // 7003
+/** InvalidPythFeed: Invalid Pyth feed ID */
+export const SEND_NEXUS_ERROR__INVALID_PYTH_FEED = 0x1b5c; // 7004
+/** InvalidSlug: Invalid slug: must be non-empty, <= max_len bytes, lowercase alphanumeric or underscore */
+export const SEND_NEXUS_ERROR__INVALID_SLUG = 0x1b5d; // 7005
+/** TextTooLong: Text too long */
+export const SEND_NEXUS_ERROR__TEXT_TOO_LONG = 0x1b5e; // 7006
+/** UserTokenAccountWrongProgram: User token account owned by the wrong token program */
+export const SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_PROGRAM = 0x1b5f; // 7007
+/** UserTokenAccountInvalid: User token account is not an initialized token account */
+export const SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_INVALID = 0x1b60; // 7008
+/** UserTokenAccountWrongMint: User token account mint does not match the trade */
+export const SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT = 0x1b61; // 7009
+/** UserTokenAccountWrongAuthority: User token account is not owned by the trading user */
+export const SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY = 0x1b62; // 7010
+/** NothingToClaim: Nothing to claim */
+export const SEND_NEXUS_ERROR__NOTHING_TO_CLAIM = 0x1b63; // 7011
+/** InvalidCreatorId: Creator identity is not a decodable wallet address */
+export const SEND_NEXUS_ERROR__INVALID_CREATOR_ID = 0x1b64; // 7012
+/** QuoteMintPriceUnset: Quote mint has no USDC price on its nexus reward state */
+export const SEND_NEXUS_ERROR__QUOTE_MINT_PRICE_UNSET = 0x1b65; // 7013
+/** TransferFeeNotSettleable: Token-2022 transfer fee schedule cannot settle the exact amount */
+export const SEND_NEXUS_ERROR__TRANSFER_FEE_NOT_SETTLEABLE = 0x1b66; // 7014
+/** InsufficientLiquidity: Insufficient liquidity */
+export const SEND_NEXUS_ERROR__INSUFFICIENT_LIQUIDITY = 0x1bbc; // 7100
+/** InvalidAmount: Invalid amount */
+export const SEND_NEXUS_ERROR__INVALID_AMOUNT = 0x1bbd; // 7101
+
+export type SendNexusError =
+	| typeof SEND_NEXUS_ERROR__AMBIGUOUS_FEE_SOURCE
+	| typeof SEND_NEXUS_ERROR__ARITHMETIC_OVERFLOW
+	| typeof SEND_NEXUS_ERROR__DUPLICATE_AUTH_PLATFORM_NAME
+	| typeof SEND_NEXUS_ERROR__INSUFFICIENT_LIQUIDITY
+	| typeof SEND_NEXUS_ERROR__INSUFFICIENT_STAKE
+	| typeof SEND_NEXUS_ERROR__INVALID_AMOUNT
+	| typeof SEND_NEXUS_ERROR__INVALID_AUTHORITY
+	| typeof SEND_NEXUS_ERROR__INVALID_AUTH_PLATFORM_INDEX
+	| typeof SEND_NEXUS_ERROR__INVALID_AUTH_PLATFORM_NAME
+	| typeof SEND_NEXUS_ERROR__INVALID_CREATOR_ID
+	| typeof SEND_NEXUS_ERROR__INVALID_DESTINATION
+	| typeof SEND_NEXUS_ERROR__INVALID_FEE_PRESET
+	| typeof SEND_NEXUS_ERROR__INVALID_MINT
+	| typeof SEND_NEXUS_ERROR__INVALID_PARTNER_CONFIG
+	| typeof SEND_NEXUS_ERROR__INVALID_PARTNER_NAME
+	| typeof SEND_NEXUS_ERROR__INVALID_PARTNER_NOTE
+	| typeof SEND_NEXUS_ERROR__INVALID_PLATFORM_CONFIG
+	| typeof SEND_NEXUS_ERROR__INVALID_PRESET_INDEX
+	| typeof SEND_NEXUS_ERROR__INVALID_PRESET_NAME
+	| typeof SEND_NEXUS_ERROR__INVALID_PYTH_ACCOUNT
+	| typeof SEND_NEXUS_ERROR__INVALID_PYTH_FEED
+	| typeof SEND_NEXUS_ERROR__INVALID_REWARD_ACCRUAL
+	| typeof SEND_NEXUS_ERROR__INVALID_REWARD_MINT
+	| typeof SEND_NEXUS_ERROR__INVALID_REWARD_STATE
+	| typeof SEND_NEXUS_ERROR__INVALID_SLUG
+	| typeof SEND_NEXUS_ERROR__INVALID_STAKING_MINT
+	| typeof SEND_NEXUS_ERROR__INVALID_USDC_PRICE
+	| typeof SEND_NEXUS_ERROR__INVALID_VAULT
+	| typeof SEND_NEXUS_ERROR__MISSING_FEE_SOURCE
+	| typeof SEND_NEXUS_ERROR__NOTHING_TO_CLAIM
+	| typeof SEND_NEXUS_ERROR__PARTNER_NOT_ON_PRESET
+	| typeof SEND_NEXUS_ERROR__PRESET_PLATFORM_MISMATCH
+	| typeof SEND_NEXUS_ERROR__PROGRAM_PAUSED
+	| typeof SEND_NEXUS_ERROR__QUOTE_MINT_PRICE_UNSET
+	| typeof SEND_NEXUS_ERROR__RESERVED_PARTNER
+	| typeof SEND_NEXUS_ERROR__REWARDS_NOT_SETTLED
+	| typeof SEND_NEXUS_ERROR__STAKING_ALREADY_ENABLED
+	| typeof SEND_NEXUS_ERROR__STAKING_MINT_ALREADY_BOUND
+	| typeof SEND_NEXUS_ERROR__STAKING_NOT_ENABLED
+	| typeof SEND_NEXUS_ERROR__TEXT_TOO_LONG
+	| typeof SEND_NEXUS_ERROR__TOO_MANY_AUTH_PLATFORMS
+	| typeof SEND_NEXUS_ERROR__TRANSFER_FEE_NOT_SETTLEABLE
+	| typeof SEND_NEXUS_ERROR__UNAUTHORIZED
+	| typeof SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_INVALID
+	| typeof SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY
+	| typeof SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT
+	| typeof SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_PROGRAM;
+
+export const sendNexusErrorMessages: Record<SendNexusError, string> = {
+	[SEND_NEXUS_ERROR__AMBIGUOUS_FEE_SOURCE]: `Cannot specify both fee_preset and custom_fees`,
+	[SEND_NEXUS_ERROR__ARITHMETIC_OVERFLOW]: `Arithmetic overflow`,
+	[SEND_NEXUS_ERROR__DUPLICATE_AUTH_PLATFORM_NAME]: `Duplicate auth platform name`,
+	[SEND_NEXUS_ERROR__INSUFFICIENT_LIQUIDITY]: `Insufficient liquidity`,
+	[SEND_NEXUS_ERROR__INSUFFICIENT_STAKE]: `Insufficient stake balance`,
+	[SEND_NEXUS_ERROR__INVALID_AMOUNT]: `Invalid amount`,
+	[SEND_NEXUS_ERROR__INVALID_AUTHORITY]: `Invalid authority`,
+	[SEND_NEXUS_ERROR__INVALID_AUTH_PLATFORM_INDEX]: `Invalid auth platform index`,
+	[SEND_NEXUS_ERROR__INVALID_AUTH_PLATFORM_NAME]: `Invalid auth platform name`,
+	[SEND_NEXUS_ERROR__INVALID_CREATOR_ID]: `Creator identity is not a decodable wallet address`,
+	[SEND_NEXUS_ERROR__INVALID_DESTINATION]: `Invalid destination account`,
+	[SEND_NEXUS_ERROR__INVALID_FEE_PRESET]: `Invalid fee configuration`,
+	[SEND_NEXUS_ERROR__INVALID_MINT]: `Invalid mint`,
+	[SEND_NEXUS_ERROR__INVALID_PARTNER_CONFIG]: `Partner config address does not match its stored seeds`,
+	[SEND_NEXUS_ERROR__INVALID_PARTNER_NAME]: `Partner name cannot be empty`,
+	[SEND_NEXUS_ERROR__INVALID_PARTNER_NOTE]: `Invalid partner note`,
+	[SEND_NEXUS_ERROR__INVALID_PLATFORM_CONFIG]: `Platform config cannot be the default address`,
+	[SEND_NEXUS_ERROR__INVALID_PRESET_INDEX]: `Invalid preset index`,
+	[SEND_NEXUS_ERROR__INVALID_PRESET_NAME]: `Invalid preset name`,
+	[SEND_NEXUS_ERROR__INVALID_PYTH_ACCOUNT]: `Invalid Pyth price account`,
+	[SEND_NEXUS_ERROR__INVALID_PYTH_FEED]: `Invalid Pyth feed ID`,
+	[SEND_NEXUS_ERROR__INVALID_REWARD_ACCRUAL]: `Invalid reward accrual`,
+	[SEND_NEXUS_ERROR__INVALID_REWARD_MINT]: `Invalid reward mint`,
+	[SEND_NEXUS_ERROR__INVALID_REWARD_STATE]: `Invalid reward state`,
+	[SEND_NEXUS_ERROR__INVALID_SLUG]: `Invalid slug: must be non-empty, <= max_len bytes, lowercase alphanumeric or underscore`,
+	[SEND_NEXUS_ERROR__INVALID_STAKING_MINT]: `Invalid staking mint`,
+	[SEND_NEXUS_ERROR__INVALID_USDC_PRICE]: `USDC price must be non-zero - 0 means no price`,
+	[SEND_NEXUS_ERROR__INVALID_VAULT]: `Invalid vault`,
+	[SEND_NEXUS_ERROR__MISSING_FEE_SOURCE]: `Must provide either fee_preset or custom fees`,
+	[SEND_NEXUS_ERROR__NOTHING_TO_CLAIM]: `Nothing to claim`,
+	[SEND_NEXUS_ERROR__PARTNER_NOT_ON_PRESET]: `Partner account does not use this preset`,
+	[SEND_NEXUS_ERROR__PRESET_PLATFORM_MISMATCH]: `Fee preset belongs to a different platform`,
+	[SEND_NEXUS_ERROR__PROGRAM_PAUSED]: `Program is paused`,
+	[SEND_NEXUS_ERROR__QUOTE_MINT_PRICE_UNSET]: `Quote mint has no USDC price on its nexus reward state`,
+	[SEND_NEXUS_ERROR__RESERVED_PARTNER]: `Cannot add the default partner`,
+	[SEND_NEXUS_ERROR__REWARDS_NOT_SETTLED]: `Settle every reward mint before staking or unstaking - call settle for each registered mint`,
+	[SEND_NEXUS_ERROR__STAKING_ALREADY_ENABLED]: `Staking already enabled`,
+	[SEND_NEXUS_ERROR__STAKING_MINT_ALREADY_BOUND]: `Staking mint already bound`,
+	[SEND_NEXUS_ERROR__STAKING_NOT_ENABLED]: `Staking not enabled`,
+	[SEND_NEXUS_ERROR__TEXT_TOO_LONG]: `Text too long`,
+	[SEND_NEXUS_ERROR__TOO_MANY_AUTH_PLATFORMS]: `Too many auth platforms (max 255)`,
+	[SEND_NEXUS_ERROR__TRANSFER_FEE_NOT_SETTLEABLE]: `Token-2022 transfer fee schedule cannot settle the exact amount`,
+	[SEND_NEXUS_ERROR__UNAUTHORIZED]: `Unauthorized`,
+	[SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_INVALID]: `User token account is not an initialized token account`,
+	[SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_AUTHORITY]: `User token account is not owned by the trading user`,
+	[SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_MINT]: `User token account mint does not match the trade`,
+	[SEND_NEXUS_ERROR__USER_TOKEN_ACCOUNT_WRONG_PROGRAM]: `User token account owned by the wrong token program`,
+} as const;
+
+export function getSendNexusErrorMessage(code: SendNexusError): string {
+	return sendNexusErrorMessages[code];
+}
+
+export function isSendNexusError<TProgramErrorCode extends SendNexusError>(
+	error: unknown,
+	transactionMessage: {
+		instructions: Record<number, { programAddress: Address }>;
+	},
+	code?: TProgramErrorCode,
+): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> &
+	Readonly<{ context: Readonly<{ code: TProgramErrorCode }> }> {
+	return isProgramError<TProgramErrorCode>(
+		error,
+		transactionMessage,
+		SEND_NEXUS_PROGRAM_ADDRESS,
+		code,
+	);
+}

package/src/nexus/generated/events/anchorEventCpiDiscriminator.framing.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 {
+	fixEncoderSize,
+	getBytesEncoder,
+	type ReadonlyUint8Array,
+} from '@solana/kit';
+
+/**
+ * Shared event-framing tag prepended to every CPI-framed event.
+ *
+ * `containsBytes(data, ANCHOR_EVENT_CPI_DISCRIMINATOR, 0)` checks whether data is a framed event
+ * at all — including event kinds unknown to this program.
+ */
+export const ANCHOR_EVENT_CPI_DISCRIMINATOR: ReadonlyUint8Array =
+	new Uint8Array([228, 69, 165, 46, 81, 203, 154, 29]);
+
+export function getAnchorEventCpiDiscriminatorBytes(): ReadonlyUint8Array {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(
+		ANCHOR_EVENT_CPI_DISCRIMINATOR,
+	);
+}

package/src/nexus/generated/events/claimEvent.ts

@@ -0,0 +1,106 @@
+/**
+ * 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,
+	fixEncoderSize,
+	getAddressDecoder,
+	getBytesEncoder,
+	getI64Decoder,
+	getStructDecoder,
+	getU64Decoder,
+	type Address,
+	type FixedSizeDecoder,
+	type ReadonlyUint8Array,
+} from '@solana/kit';
+import { SEND_NEXUS_PROGRAM_ADDRESS } from '../programs/index.js';
+import { ANCHOR_EVENT_CPI_DISCRIMINATOR } from './anchorEventCpiDiscriminator.framing.js';
+
+export const CLAIM_EVENT_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
+	93, 15, 70, 170, 48, 140, 212, 219,
+]);
+
+export function getClaimEventDiscriminatorBytes(): ReadonlyUint8Array {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(
+		CLAIM_EVENT_DISCRIMINATOR,
+	);
+}
+
+export type ClaimEvent = {
+	user: Address;
+	stakingConfig: Address;
+	rewardMint: Address;
+	amount: bigint;
+	timestamp: bigint;
+};
+
+let getClaimEventDecoderCache: FixedSizeDecoder<ClaimEvent> | undefined;
+
+export function getClaimEventDecoder(): FixedSizeDecoder<ClaimEvent> {
+	return (getClaimEventDecoderCache ??= getStructDecoder([
+		['user', getAddressDecoder()],
+		['stakingConfig', getAddressDecoder()],
+		['rewardMint', getAddressDecoder()],
+		['amount', getU64Decoder()],
+		['timestamp', getI64Decoder()],
+	]));
+}
+
+/**
+ * Checks whether the event data matches the framing and discriminator bytes of a
+ * {@link ClaimEvent}, without decoding. Never throws.
+ *
+ * Returns `false` unless `event.programAddress` is SEND_NEXUS_PROGRAM_ADDRESS.
+ * Raw bytes carry no emitter and SKIP that check.
+ *
+ * @see parseClaimEvent to decode the matching data
+ */
+export function isClaimEvent(
+	event:
+		| { data: ReadonlyUint8Array; programAddress: Address }
+		| ReadonlyUint8Array,
+): boolean {
+	if ('data' in event && event.programAddress !== SEND_NEXUS_PROGRAM_ADDRESS)
+		return false;
+	const data = 'data' in event ? event.data : event;
+	return (
+		containsBytes(data, ANCHOR_EVENT_CPI_DISCRIMINATOR, 0) &&
+		containsBytes(data, CLAIM_EVENT_DISCRIMINATOR, 8)
+	);
+}
+
+/**
+ * Parses raw event data as a {@link ClaimEvent}. Returns `null` on framing or discriminator
+ * mismatch; throws if the event matches but its body fails to decode.
+ *
+ * Returns `null` unless `event.programAddress` is SEND_NEXUS_PROGRAM_ADDRESS.
+ * Raw bytes carry no emitter and SKIP that check.
+ *
+ * @see isClaimEvent to check without decoding
+ * @see identifySendNexusEvent to identify any program event
+ * @see parseSendNexusEvent
+ */
+export function parseClaimEvent(
+	event:
+		| { data: ReadonlyUint8Array; programAddress: Address }
+		| ReadonlyUint8Array,
+): ClaimEvent | null {
+	const checkedEvent =
+		'data' in event
+			? { data: event.data, programAddress: event.programAddress }
+			: event;
+	if (!isClaimEvent(checkedEvent)) {
+		return null;
+	}
+	const data = 'data' in checkedEvent ? checkedEvent.data : checkedEvent;
+	return getClaimEventDecoder().decode(
+		data,
+		ANCHOR_EVENT_CPI_DISCRIMINATOR.length +
+			CLAIM_EVENT_DISCRIMINATOR.length,
+	);
+}

package/src/nexus/generated/events/index.ts

@@ -0,0 +1,13 @@
+/**
+ * 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
+ */
+
+export * from './anchorEventCpiDiscriminator.framing.js';
+export * from './claimEvent.js';
+export * from './sendNexus.events.js';
+export * from './stakeEvent.js';
+export * from './unstakeEvent.js';