@send-fun/sdk 1.1.0 → 2.0.0

package/src/transfer-fee.ts

@@ -1,5 +1,5 @@
-// Hand-parsed so consumers don't inherit `@solana-program/token-2022`. The programs
-// price every leg on what lands after the mint's cut; a quote without it fails slippage.
+// Parses Token-2022 mint data by hand. The SDK does not depend on
+// `@solana-program/token-2022`.
 
 import {
 	getAddressDecoder,
@@ -20,8 +20,8 @@ import { fetchInChunks } from './utils/chunk.js';
 
 const MINT_BASE_LENGTH = 82;
 
-// Token-2022 pads the base mint to the 165-byte token-account length so the two
-// never share a prefix, then stamps the type byte; TLV entries follow it.
+// Token-2022 pads the base mint to 165 bytes, the token-account length. The
+// account-type byte follows, then the TLV entries.
 const ACCOUNT_TYPE_OFFSET = 165;
 
 const ACCOUNT_TYPE_MINT = 1;
@@ -58,7 +58,7 @@ export interface TransferFeeEntry {
 }
 
 export interface TransferFeeConfig {
-	/** `undefined` when the authority is unset: the schedule is frozen forever. */
+	/** `undefined` if the config has no authority. Then the schedule cannot change. */
 	readonly authority: Address | undefined;
 	readonly older: TransferFeeEntry;
 	readonly newer: TransferFeeEntry;
@@ -80,13 +80,14 @@ function readEntry(view: DataView, start: number): TransferFeeEntry {
 	};
 }
 
-/** `owner` is the account's program. `undefined` means no fee extension; anything
- *  unparseable throws `RangeError` rather than pricing a charging mint free. */
+/** Decodes the `TransferFeeConfig` extension of a mint. `owner` is the program that owns the account.
+ *  Returns `undefined` if the mint has no such extension. Throws `RangeError` if `owner` is not a
+ *  token program or `data` is not a valid mint. */
 export function decodeTransferFeeConfig(
 	data: Uint8Array,
 	owner: Address,
 ): TransferFeeConfig | undefined {
-	// Classic SPL can never gain an extension, so this result is permanent.
+	// Classic SPL mints have no extensions.
 	if (owner === TOKEN_PROGRAM_ADDRESS) return undefined;
 	if (owner !== TOKEN_2022_PROGRAM_ADDRESS) {
 		throw new RangeError(
@@ -94,14 +95,14 @@ export function decodeTransferFeeConfig(
 		);
 	}
 
-	// Token-2022 leaves a mint with no extensions unpadded at 82 bytes.
+	// A Token-2022 mint with no extensions is 82 bytes.
 	if (data.length === MINT_BASE_LENGTH) return undefined;
 	if (data.length < TLV_START) {
 		throw new RangeError(
 			`decodeTransferFeeConfig: a Token-2022 mint holds ${data.length} bytes, expected ${MINT_BASE_LENGTH} or at least ${TLV_START}`,
 		);
 	}
-	// Token accounts share this TLV layout with different extension types.
+	// Token accounts use the same TLV layout.
 	if (data[ACCOUNT_TYPE_OFFSET] !== ACCOUNT_TYPE_MINT) {
 		throw new RangeError(
 			`decodeTransferFeeConfig: account type ${data[ACCOUNT_TYPE_OFFSET]} is not a mint`,
@@ -112,7 +113,7 @@ export function decodeTransferFeeConfig(
 
 	let offset = TLV_START;
 	while (offset < data.length) {
-		// Too short for a type, or a zero type: trailing slack, as SPL reads it.
+		// SPL reads a tail too short for a type, or a zero type, as the end of the list.
 		if (offset + TLV_TYPE > data.length) return undefined;
 		const extensionType = view.getUint16(offset, true);
 		if (extensionType === UNINITIALIZED_TYPE) return undefined;
@@ -133,7 +134,7 @@ export function decodeTransferFeeConfig(
 		}
 
 		if (extensionType === TRANSFER_FEE_CONFIG_TYPE) {
-			// Exactly 108 or throw: the extension never writes a wider config.
+			// The extension is always 108 bytes.
 			if (length !== TRANSFER_FEE_CONFIG_LENGTH) {
 				throw new RangeError(
 					`decodeTransferFeeConfig: TransferFeeConfig holds ${length} bytes, expected ${TRANSFER_FEE_CONFIG_LENGTH}`,
@@ -152,7 +153,7 @@ export function decodeTransferFeeConfig(
 	return undefined;
 }
 
-/** Mirrors SPL `get_epoch_fee`: the newer entry is live from its own epoch on. */
+/** Returns the fee for `epoch`, as SPL `get_epoch_fee` does. The newer entry applies from its own epoch on. */
 export function transferFeeAtEpoch(
 	config: TransferFeeConfig,
 	epoch: bigint,
@@ -170,8 +171,8 @@ export function mintFeeAtEpoch(
 	return config === undefined ? undefined : transferFeeAtEpoch(config, epoch);
 }
 
-// Omit the config, never `{ commitment: undefined }`: Kit strips the falsy key and
-// the server's `finalized` wins, where an absent key gets the client's default.
+// Omit the config, not `{ commitment: undefined }`. Kit deletes an undefined key, so the
+// server default `finalized` applies. With no config, the client default applies.
 function currentEpoch(
 	rpc: Rpc<GetEpochInfoApi>,
 	commitment: Commitment | undefined,
@@ -182,8 +183,9 @@ function currentEpoch(
 		.then((info) => info.epoch);
 }
 
-/** A missing account throws, never reads as fee-free. Valid only for `epoch`, which defaults to
- *  the cluster's (a second call). */
+/** Reads the transfer fee of each mint for `epoch`. The result is valid only for that epoch.
+ *  `epoch` defaults to the current cluster epoch, read with `getEpochInfo`. A mint without a
+ *  transfer fee maps to `undefined`. Throws if a mint account is missing or does not decode. */
 export async function fetchMintFees(
 	rpc: Rpc<GetMultipleAccountsApi & GetEpochInfoApi>,
 	mints: readonly Address[],

package/src/utils/chunk.ts

@@ -3,7 +3,7 @@ import type { Address } from '@solana/kit';
 /** RPCs reject a `getMultipleAccounts` call past this many addresses. */
 const MAX_ACCOUNTS_PER_REQUEST = 100;
 
-/** Splits a multi-account read into 100-address calls; results follow `addresses` order. */
+/** Calls `read` once per 100 addresses. Results follow `addresses` order. */
 export async function fetchInChunks<T>(
 	addresses: readonly Address[],
 	read: (chunk: Address[]) => Promise<readonly T[]>,

package/src/utils/index.ts

@@ -1,8 +1,5 @@
-export {
-	creatorHashFromId,
-	decodeCreatorId,
-	encodeCreatorId,
-} from './creator-hash.js';
+// The three programs generate the same function.
+export { accountIsCreated } from '../nexus/generated/shared/index.js';
 export { fetchQuoteMintInfo, fetchQuoteMintInfos } from './mint-info.js';
 export type { QuoteMintInfo } from './mint-info.js';
 export type { PartnerInput } from './partner.js';

package/src/utils/mint-info.ts

@@ -1,5 +1,4 @@
-// Read off the mint, never tabulated: a stale `tokenProgram` derives an ATA the
-// transfer cannot reach.
+// Reads the token program from the mint account. Do not hard-code it.
 import {
 	getBase64Encoder,
 	type Address,
@@ -15,14 +14,14 @@ import {
 } from '../constants.js';
 import { fetchInChunks } from './chunk.js';
 
-// Both token programs share the base mint: 36-byte `COption<Pubkey>` authority,
+// Both token programs use the same base mint: 36-byte `COption<Pubkey>` authority,
 // u64 supply, then decimals.
 const MINT_BASE_LENGTH = 82;
 const MINT_DECIMALS_OFFSET = 44;
 
 export interface QuoteMintInfo {
 	mint: Address;
-	/** Immutable: safe to cache. */
+	/** Cannot change after the mint is created. */
 	decimals: number;
 	/** The account's owner: `TOKEN_PROGRAM_ADDRESS` or `TOKEN_2022_PROGRAM_ADDRESS`. */
 	tokenProgram: Address;
@@ -41,7 +40,7 @@ function decodeMintInfo(
 			`fetchQuoteMintInfo: ${mint} is owned by ${owner}, which is not a token program`,
 		);
 	}
-	// A floor, not an equality: Token-2022 mints with extensions run longer.
+	// A minimum: Token-2022 mints with extensions are longer.
 	if (data.length < MINT_BASE_LENGTH) {
 		throw new Error(
 			`fetchQuoteMintInfo: ${mint} holds ${data.length} bytes, too short for a mint`,
@@ -50,7 +49,8 @@ function decodeMintInfo(
 	return { mint, decimals: data[MINT_DECIMALS_OFFSET], tokenProgram: owner };
 }
 
-/** Throws when the mint does not exist or is not owned by a token program. */
+/** Reads the decimals and token program of `mint`. Throws if the account does not exist, a token
+ *  program does not own it, or it is too short for a mint. */
 export async function fetchQuoteMintInfo(
 	rpc: Rpc<GetAccountInfoApi>,
 	mint: Address,
@@ -71,7 +71,8 @@ export async function fetchQuoteMintInfo(
 	return decodeMintInfo(mint, data, value.owner);
 }
 
-/** One round trip per 100 mints; results follow `mints` order. */
+/** Reads the decimals and token program of each mint. Results follow `mints` order. Throws as
+ *  {@link fetchQuoteMintInfo} does. */
 export async function fetchQuoteMintInfos(
 	rpc: Rpc<GetMultipleAccountsApi>,
 	mints: readonly Address[],

package/src/utils/partner.ts

@@ -1,5 +1,5 @@
 import type { TransactionSigner } from '@solana/kit';
 import type { DEFAULT_PARTNER } from '../constants.js';
 
-/** Non-default partners must sign; only `DEFAULT_PARTNER` is valid as a bare address. */
+/** A partner signer, or `DEFAULT_PARTNER` as a bare address. Any other partner must sign. */
 export type PartnerInput = TransactionSigner | typeof DEFAULT_PARTNER;

package/src/utils/pda.ts

@@ -7,7 +7,7 @@ import {
 
 const addressEncoder = getAddressEncoder();
 
-/** Seed order is [wallet, tokenProgram, mint], not the parameter order. */
+/** Derives the associated token account of `wallet` for `mint` under `tokenProgram`. */
 export async function findAssociatedTokenPda(
 	wallet: Address,
 	mint: Address,

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

@@ -1,200 +0,0 @@
-/**
- * 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,
-	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 CREATOR_FEE_CONFIG_DISCRIMINATOR: ReadonlyUint8Array =
-	new Uint8Array([160, 88, 34, 74, 215, 196, 130, 32]);
-
-export function getCreatorFeeConfigDiscriminatorBytes(): ReadonlyUint8Array {
-	return fixEncoderSize(getBytesEncoder(), 8).encode(
-		CREATOR_FEE_CONFIG_DISCRIMINATOR,
-	);
-}
-
-export type CreatorFeeConfig = {
-	discriminator: ReadonlyUint8Array;
-	version: number;
-	bump: number;
-	platformIndex: number;
-	platformId: ReadonlyUint8Array;
-	quoteMint: Address;
-	reserved: ReadonlyUint8Array;
-};
-
-export type CreatorFeeConfigArgs = {
-	version: number;
-	bump: number;
-	platformIndex: number;
-	platformId: ReadonlyUint8Array;
-	quoteMint: Address;
-	reserved: ReadonlyUint8Array;
-};
-
-/** Gets the encoder for {@link CreatorFeeConfigArgs} account data. */
-export function getCreatorFeeConfigEncoder(): FixedSizeEncoder<CreatorFeeConfigArgs> {
-	return transformEncoder(
-		getStructEncoder([
-			['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
-			['version', getU8Encoder()],
-			['bump', getU8Encoder()],
-			['platformIndex', getU8Encoder()],
-			['platformId', fixEncoderSize(getBytesEncoder(), 44)],
-			['quoteMint', getAddressEncoder()],
-			['reserved', fixEncoderSize(getBytesEncoder(), 64)],
-		]),
-		(value) => ({
-			...value,
-			discriminator: CREATOR_FEE_CONFIG_DISCRIMINATOR,
-		}),
-	);
-}
-
-/** Gets the decoder for {@link CreatorFeeConfig} account data. */
-export function getCreatorFeeConfigDecoder(): FixedSizeDecoder<CreatorFeeConfig> {
-	return getStructDecoder([
-		['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
-		['version', getU8Decoder()],
-		['bump', getU8Decoder()],
-		['platformIndex', getU8Decoder()],
-		['platformId', fixDecoderSize(getBytesDecoder(), 44)],
-		['quoteMint', getAddressDecoder()],
-		['reserved', fixDecoderSize(getBytesDecoder(), 64)],
-	]);
-}
-
-/** Gets the codec for {@link CreatorFeeConfig} account data. */
-export function getCreatorFeeConfigCodec(): FixedSizeCodec<
-	CreatorFeeConfigArgs,
-	CreatorFeeConfig
-> {
-	return combineCodec(
-		getCreatorFeeConfigEncoder(),
-		getCreatorFeeConfigDecoder(),
-	);
-}
-
-export function decodeCreatorFeeConfig<TAddress extends string = string>(
-	encodedAccount: EncodedAccount<TAddress>,
-): Account<CreatorFeeConfig, TAddress>;
-export function decodeCreatorFeeConfig<TAddress extends string = string>(
-	encodedAccount: MaybeEncodedAccount<TAddress>,
-): MaybeAccount<CreatorFeeConfig, TAddress>;
-export function decodeCreatorFeeConfig<TAddress extends string = string>(
-	encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
-):
-	| Account<CreatorFeeConfig, TAddress>
-	| MaybeAccount<CreatorFeeConfig, TAddress> {
-	if (!('exists' in encodedAccount) || encodedAccount.exists) {
-		if (encodedAccount.programAddress !== SEND_NEXUS_PROGRAM_ADDRESS) {
-			const error = new Error(
-				`decodeCreatorFeeConfig: account ${encodedAccount.address} is owned by ${encodedAccount.programAddress}, expected ${SEND_NEXUS_PROGRAM_ADDRESS}`,
-			);
-			error.name = 'AccountOwnerMismatchError';
-			throw error;
-		}
-		if (
-			!containsBytes(
-				encodedAccount.data,
-				CREATOR_FEE_CONFIG_DISCRIMINATOR,
-				0,
-			)
-		) {
-			const error = new Error(
-				`decodeCreatorFeeConfig: account ${encodedAccount.address} does not match the CreatorFeeConfig discriminator`,
-			);
-			error.name = 'AccountDiscriminatorMismatchError';
-			throw error;
-		}
-	}
-	return decodeAccount(
-		encodedAccount as MaybeEncodedAccount<TAddress>,
-		getCreatorFeeConfigDecoder(),
-	);
-}
-
-export async function fetchCreatorFeeConfig<TAddress extends string = string>(
-	rpc: Parameters<typeof fetchEncodedAccount>[0],
-	address: Address<TAddress>,
-	config?: FetchAccountConfig,
-): Promise<Account<CreatorFeeConfig, TAddress>> {
-	const maybeAccount = await fetchMaybeCreatorFeeConfig(rpc, address, config);
-	assertAccountExists(maybeAccount);
-	return maybeAccount;
-}
-
-export async function fetchMaybeCreatorFeeConfig<
-	TAddress extends string = string,
->(
-	rpc: Parameters<typeof fetchEncodedAccount>[0],
-	address: Address<TAddress>,
-	config?: FetchAccountConfig,
-): Promise<MaybeAccount<CreatorFeeConfig, TAddress>> {
-	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-	return decodeCreatorFeeConfig(maybeAccount);
-}
-
-export async function fetchAllCreatorFeeConfig(
-	rpc: Parameters<typeof fetchEncodedAccounts>[0],
-	addresses: Array<Address>,
-	config?: FetchAccountsConfig,
-): Promise<Account<CreatorFeeConfig>[]> {
-	const maybeAccounts = await fetchAllMaybeCreatorFeeConfig(
-		rpc,
-		addresses,
-		config,
-	);
-	assertAccountsExist(maybeAccounts);
-	return maybeAccounts;
-}
-
-export async function fetchAllMaybeCreatorFeeConfig(
-	rpc: Parameters<typeof fetchEncodedAccounts>[0],
-	addresses: Array<Address>,
-	config?: FetchAccountsConfig,
-): Promise<MaybeAccount<CreatorFeeConfig>[]> {
-	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
-	return maybeAccounts.map((maybeAccount) =>
-		decodeCreatorFeeConfig(maybeAccount),
-	);
-}
-
-export function getCreatorFeeConfigSize(): number {
-	return 151;
-}

package/src/nexus/generated/types/callerType.ts

@@ -1,38 +0,0 @@
-/**
- * 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 {
-	combineCodec,
-	getEnumDecoder,
-	getEnumEncoder,
-	type FixedSizeCodec,
-	type FixedSizeDecoder,
-	type FixedSizeEncoder,
-} from '@solana/kit';
-
-export enum CallerType {
-	PlatformBondingCurve,
-	PlatformPool,
-}
-
-export type CallerTypeArgs = CallerType;
-
-export function getCallerTypeEncoder(): FixedSizeEncoder<CallerTypeArgs> {
-	return getEnumEncoder(CallerType);
-}
-
-export function getCallerTypeDecoder(): FixedSizeDecoder<CallerType> {
-	return getEnumDecoder(CallerType);
-}
-
-export function getCallerTypeCodec(): FixedSizeCodec<
-	CallerTypeArgs,
-	CallerType
-> {
-	return combineCodec(getCallerTypeEncoder(), getCallerTypeDecoder());
-}

package/src/utils/creator-hash.ts

@@ -1,57 +0,0 @@
-import { getAddressDecoder } from '@solana/kit';
-import type { Address, ReadonlyUint8Array } from '@solana/kit';
-
-const MAX_CREATOR_PLATFORM_LEN = 32;
-
-/** SHA-256 of the LE-u32-length-prefixed platform and id. Frozen: it seeds live PDAs. */
-export async function creatorHashFromId(
-	creatorPlatform: string,
-	creatorId: string,
-): Promise<Address> {
-	const encoder = new TextEncoder();
-	const platformBuf = encoder.encode(creatorPlatform);
-	const idBuf = encoder.encode(creatorId);
-
-	if (platformBuf.length > MAX_CREATOR_PLATFORM_LEN) {
-		throw new RangeError(
-			`creatorPlatform exceeds ${MAX_CREATOR_PLATFORM_LEN} bytes (got ${platformBuf.length})`,
-		);
-	}
-	const platformLength = new Uint8Array(4);
-	new DataView(platformLength.buffer).setUint32(0, platformBuf.length, true);
-	const idLength = new Uint8Array(4);
-	new DataView(idLength.buffer).setUint32(0, idBuf.length, true);
-
-	const buf = new Uint8Array(4 + platformBuf.length + 4 + idBuf.length);
-	buf.set(platformLength, 0);
-	buf.set(platformBuf, 4);
-	buf.set(idLength, 4 + platformBuf.length);
-	buf.set(idBuf, 4 + platformBuf.length + 4);
-
-	const hash = new Uint8Array(await crypto.subtle.digest('SHA-256', buf));
-
-	const addressDecoder = getAddressDecoder();
-	return addressDecoder.decode(hash);
-}
-
-/** NUL-pads `text` to `length` bytes, the on-chain `CreatorFeeConfig.platformId` form; throws RangeError if longer. */
-export function encodeCreatorId(text: string, length: number): Uint8Array {
-	const bytes = new TextEncoder().encode(text);
-	if (bytes.length > length) {
-		throw new RangeError(
-			`text exceeds ${length} bytes (got ${bytes.length})`,
-		);
-	}
-	const out = new Uint8Array(length);
-	out.set(bytes, 0);
-	return out;
-}
-
-/** Strips NUL padding. Pass this, never the padded array, to {@link creatorHashFromId}: the hash is length-prefixed. */
-export function decodeCreatorId(bytes: ReadonlyUint8Array): string {
-	let end = bytes.length;
-	while (end > 0 && bytes[end - 1] === 0) {
-		end -= 1;
-	}
-	return new TextDecoder().decode(bytes.slice(0, end));
-}