@send-fun/sdk 1.0.0

package/src/dex/generated/types/poolStatus.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 PoolStatus {
+	Active,
+	Paused,
+}
+
+export type PoolStatusArgs = PoolStatus;
+
+export function getPoolStatusEncoder(): FixedSizeEncoder<PoolStatusArgs> {
+	return getEnumEncoder(PoolStatus);
+}
+
+export function getPoolStatusDecoder(): FixedSizeDecoder<PoolStatus> {
+	return getEnumDecoder(PoolStatus);
+}
+
+export function getPoolStatusCodec(): FixedSizeCodec<
+	PoolStatusArgs,
+	PoolStatus
+> {
+	return combineCodec(getPoolStatusEncoder(), getPoolStatusDecoder());
+}

package/src/dex/generated/types/tradeDirection.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 TradeDirection {
+	Buy,
+	Sell,
+}
+
+export type TradeDirectionArgs = TradeDirection;
+
+export function getTradeDirectionEncoder(): FixedSizeEncoder<TradeDirectionArgs> {
+	return getEnumEncoder(TradeDirection);
+}
+
+export function getTradeDirectionDecoder(): FixedSizeDecoder<TradeDirection> {
+	return getEnumDecoder(TradeDirection);
+}
+
+export function getTradeDirectionCodec(): FixedSizeCodec<
+	TradeDirectionArgs,
+	TradeDirection
+> {
+	return combineCodec(getTradeDirectionEncoder(), getTradeDirectionDecoder());
+}

package/src/dex/index.ts

@@ -0,0 +1,8 @@
+export * as accounts from './generated/accounts/index.js';
+export * as types from './generated/types/index.js';
+export * as errors from './generated/errors/index.js';
+export * as pda from './generated/pdas/index.js';
+export * as events from './generated/events/index.js';
+export * as instructions from './generated/instructions/index.js';
+export * as plugins from './generated/plugins/index.js';
+export * as trade from './trade.js';

package/src/dex/trade.ts

@@ -0,0 +1,215 @@
+import type { Address, Instruction, TransactionSigner } from '@solana/kit';
+import type { BuyQuote, MintFee, SellQuote } from '../math/amm.js';
+import * as amm from '../math/amm.js';
+import type { PartnerInput } from '../utils/partner.js';
+import { getBuyExactInInstructionAsync } from './generated/instructions/buyExactIn.js';
+import { getBuyExactOutInstructionAsync } from './generated/instructions/buyExactOut.js';
+import { getSellExactInInstructionAsync } from './generated/instructions/sellExactIn.js';
+import { getSellExactOutInstructionAsync } from './generated/instructions/sellExactOut.js';
+
+export interface DexTradeParams {
+	user: TransactionSigner;
+	payer?: TransactionSigner;
+	baseMint: Address;
+	quoteMint: Address;
+	baseReserves: bigint;
+	quoteReserves: bigint;
+	feeBps: number;
+	slippageBps: number;
+	partner: PartnerInput;
+	platformConfig: Address;
+	quoteTokenProgram: Address;
+	/** Token-2022 schedule for the epoch the trade lands in; stale or missing skews the slippage bounds. */
+	quoteFee?: MintFee;
+	baseFee?: MintFee;
+	/** {@inheritDoc DexInstructionParams.userQuoteAccount} */
+	userQuoteAccount?: Address;
+	/** {@inheritDoc DexInstructionParams.userBaseAccount} */
+	userBaseAccount?: Address;
+}
+
+export interface DexInstructionParams {
+	user: TransactionSigner;
+	payer?: TransactionSigner;
+	baseMint: Address;
+	quoteMint: Address;
+	partner: PartnerInput;
+	platformConfig: Address;
+	quoteTokenProgram: Address;
+	/** Any user-owned quote-mint account. Defaults to the ATA, created mid-trade
+	 *  if missing (payer funds rent), which only rescues a sell. For WSOL,
+	 *  a throwaway `createAccountWithSeed` account is cheaper. */
+	userQuoteAccount?: Address;
+	/** Any user-owned base-mint account. Defaults to the ATA, created mid-trade
+	 *  if missing (payer funds rent), which only rescues a buy. */
+	userBaseAccount?: Address;
+}
+
+/** `baseAmountOut` is net to the buyer: the program reads `amount` as `base_to_user`. */
+export async function buyExactOut(
+	params: DexTradeParams & { baseAmountOut: bigint },
+): Promise<{ instruction: Instruction; quote: BuyQuote }> {
+	const quote = amm.buyExactOut({
+		reserveQuote: params.quoteReserves,
+		reserveBase: params.baseReserves,
+		baseAmountOut: params.baseAmountOut,
+		feeBps: params.feeBps,
+		quoteFee: params.quoteFee,
+		baseFee: params.baseFee,
+	});
+	// The cap is measured on the gross the buyer sends, quote transfer fee included.
+	const maxQuoteIn = amm.calculateSlippageUp(
+		quote.quoteFromUser,
+		params.slippageBps,
+	);
+	return {
+		instruction: await buildBuyExactOutInstruction({
+			...params,
+			amountOut: params.baseAmountOut,
+			maxAmountIn: maxQuoteIn,
+		}),
+		quote,
+	};
+}
+
+export async function buyExactIn(
+	params: DexTradeParams & { quoteAmountIn: bigint },
+): Promise<{ instruction: Instruction; quote: BuyQuote }> {
+	const quote = amm.buyExactIn({
+		reserveQuote: params.quoteReserves,
+		reserveBase: params.baseReserves,
+		quoteAmountIn: params.quoteAmountIn,
+		feeBps: params.feeBps,
+		quoteFee: params.quoteFee,
+		baseFee: params.baseFee,
+	});
+	// The floor is measured on the buyer's credit, not the vault's debit.
+	const minBaseOut = amm.calculateSlippageDown(
+		quote.baseToUser,
+		params.slippageBps,
+	);
+	return {
+		instruction: await buildBuyExactInInstruction({
+			...params,
+			amountIn: params.quoteAmountIn,
+			minAmountOut: minBaseOut,
+		}),
+		quote,
+	};
+}
+
+export async function sellExactIn(
+	params: DexTradeParams & { baseAmountIn: bigint },
+): Promise<{ instruction: Instruction; quote: SellQuote }> {
+	const quote = amm.sellExactIn({
+		reserveQuote: params.quoteReserves,
+		reserveBase: params.baseReserves,
+		baseAmountIn: params.baseAmountIn,
+		feeBps: params.feeBps,
+		quoteFee: params.quoteFee,
+		baseFee: params.baseFee,
+	});
+	// The floor is measured on the seller's credit, not what leaves the vault.
+	const minQuoteOut = amm.calculateSlippageDown(
+		quote.quoteToUser,
+		params.slippageBps,
+	);
+	return {
+		instruction: await buildSellExactInInstruction({
+			...params,
+			amountIn: params.baseAmountIn,
+			minAmountOut: minQuoteOut,
+		}),
+		quote,
+	};
+}
+
+/** `quoteAmountOut` is net to the seller: the program reads `amount` as `quote_to_user`. */
+export async function sellExactOut(
+	params: DexTradeParams & { quoteAmountOut: bigint },
+): Promise<{ instruction: Instruction; quote: SellQuote }> {
+	const quote = amm.sellExactOut({
+		reserveQuote: params.quoteReserves,
+		reserveBase: params.baseReserves,
+		quoteAmountOut: params.quoteAmountOut,
+		feeBps: params.feeBps,
+		quoteFee: params.quoteFee,
+		baseFee: params.baseFee,
+	});
+	// The cap is measured on the gross the seller sends, base transfer fee included.
+	const maxBaseIn = amm.calculateSlippageUp(
+		quote.baseFromUser,
+		params.slippageBps,
+	);
+	return {
+		instruction: await buildSellExactOutInstruction({
+			...params,
+			amountOut: params.quoteAmountOut,
+			maxAmountIn: maxBaseIn,
+		}),
+		quote,
+	};
+}
+
+export async function buildBuyExactInInstruction(
+	params: DexInstructionParams & { amountIn: bigint; minAmountOut: bigint },
+): Promise<Instruction> {
+	const shared = resolveSharedAccounts(params);
+	return getBuyExactInInstructionAsync({
+		...shared,
+		amountIn: params.amountIn,
+		minAmountOut: params.minAmountOut,
+	});
+}
+
+export async function buildBuyExactOutInstruction(
+	params: DexInstructionParams & { amountOut: bigint; maxAmountIn: bigint },
+): Promise<Instruction> {
+	const shared = resolveSharedAccounts(params);
+	return getBuyExactOutInstructionAsync({
+		...shared,
+		amountOut: params.amountOut,
+		maxAmountIn: params.maxAmountIn,
+	});
+}
+
+export async function buildSellExactInInstruction(
+	params: DexInstructionParams & { amountIn: bigint; minAmountOut: bigint },
+): Promise<Instruction> {
+	const shared = resolveSharedAccounts(params);
+	return getSellExactInInstructionAsync({
+		...shared,
+		amountIn: params.amountIn,
+		minAmountOut: params.minAmountOut,
+	});
+}
+
+export async function buildSellExactOutInstruction(
+	params: DexInstructionParams & { amountOut: bigint; maxAmountIn: bigint },
+): Promise<Instruction> {
+	const shared = resolveSharedAccounts(params);
+	return getSellExactOutInstructionAsync({
+		...shared,
+		amountOut: params.amountOut,
+		maxAmountIn: params.maxAmountIn,
+	});
+}
+
+function resolveSharedAccounts(params: DexInstructionParams) {
+	return {
+		user: params.user,
+		payer: params.payer ?? params.user,
+		baseMint: params.baseMint,
+		quoteMint: params.quoteMint,
+		partner: params.partner,
+		platformConfig: params.platformConfig,
+		quoteTokenProgram: params.quoteTokenProgram,
+		// Left undefined so the generated client derives the ATA itself.
+		...(params.userQuoteAccount !== undefined && {
+			userQuoteAccount: params.userQuoteAccount,
+		}),
+		...(params.userBaseAccount !== undefined && {
+			userBaseAccount: params.userBaseAccount,
+		}),
+	};
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * as constants from './constants.js';
+export * as dex from './dex/index.js';
+export * as launchpad from './launchpad/index.js';
+export * as math from './math/index.js';
+export * as nexus from './nexus/index.js';
+export * as platform from './platform.js';
+export * as transferFee from './transfer-fee.js';
+export * as utils from './utils/index.js';

package/src/launchpad/create.ts

@@ -0,0 +1,116 @@
+import type { Address, Instruction, TransactionSigner } from '@solana/kit';
+import type { MintFee, TradeQuote } from '../math/amm.js';
+import type { PartnerInput } from '../utils/partner.js';
+import { creatorHashFromId } from '../utils/creator-hash.js';
+import { findCreatorFeeConfigPda } from '../nexus/generated/pdas/creatorFeeConfig.js';
+import { getCreateTokenInstructionAsync } from './generated/instructions/createToken.js';
+import { buyExactIn } from './trade.js';
+
+export interface CreateTokenParams {
+	user: TransactionSigner;
+	payer?: TransactionSigner;
+	coinCreator: Address;
+	baseMint: TransactionSigner;
+	quoteMint: Address;
+	name: string;
+	symbol: string;
+	uri: string;
+	/** An enabled nexus auth platform (e.g. "wallet"), max 32 bytes; hashed with
+	 *  `creatorId` into the creator fee identity. Unrelated to `platformConfig`. */
+	creatorPlatform: string;
+	creatorId: string;
+	partner: PartnerInput;
+	platformConfig: Address;
+	quoteTokenProgram: Address;
+}
+
+export interface CreateAndBuyParams extends CreateTokenParams {
+	buyQuoteAmount: bigint;
+	feeBps: number;
+	slippageBps: number;
+	initialVirtualQuoteReserves: bigint;
+	initialVirtualBaseReserves: bigint;
+	/** `globalConfig.initialRealBaseReserves`: caps the appended buy. */
+	initialRealBaseReserves: bigint;
+	/** Quote mint's Token-2022 schedule for the launch epoch; without it `minAmountOut`
+	 *  ignores the mint's cut, and a cut above `slippageBps` can revert the buy. No
+	 *  `baseFee`: this transaction creates the base mint without the extension. */
+	quoteFee?: MintFee;
+}
+
+export async function buildCreateTokenInstruction(
+	params: CreateTokenParams,
+): Promise<Instruction> {
+	return buildCreateTokenInstructionWithHash(
+		params,
+		await creatorHashFromId(params.creatorPlatform, params.creatorId),
+	);
+}
+
+async function buildCreateTokenInstructionWithHash(
+	params: CreateTokenParams,
+	creatorHash: Address,
+): Promise<Instruction> {
+	const [creatorFeeConfig] = await findCreatorFeeConfigPda({
+		creatorHash,
+		quoteMint: params.quoteMint,
+	});
+	// The creation fee is native SOL from `user`; the client derives the WSOL staking vault.
+	return getCreateTokenInstructionAsync({
+		user: params.user,
+		payer: params.payer ?? params.user,
+		coinCreator: params.coinCreator,
+		baseMint: params.baseMint,
+		quoteMint: params.quoteMint,
+		creatorFeeConfig,
+		partner: params.partner,
+		platformConfig: params.platformConfig,
+		quoteTokenProgram: params.quoteTokenProgram,
+		creatorPlatform: params.creatorPlatform,
+		creatorId: params.creatorId,
+		creatorHash,
+		name: params.name,
+		symbol: params.symbol,
+		uri: params.uri,
+	});
+}
+
+export async function buildCreateAndBuyInstructions(
+	params: CreateAndBuyParams,
+): Promise<{ instructions: Instruction[]; quote?: TradeQuote }> {
+	const creatorHash = await creatorHashFromId(
+		params.creatorPlatform,
+		params.creatorId,
+	);
+	const createIx = await buildCreateTokenInstructionWithHash(
+		params,
+		creatorHash,
+	);
+	const instructions: Instruction[] = [createIx];
+	let quote: TradeQuote | undefined;
+
+	if (params.buyQuoteAmount > 0n) {
+		const buyResult = await buyExactIn({
+			user: params.user,
+			payer: params.payer,
+			baseMint: params.baseMint.address,
+			quoteMint: params.quoteMint,
+			virtualQuoteReserves: params.initialVirtualQuoteReserves,
+			virtualBaseReserves: params.initialVirtualBaseReserves,
+			realBaseReserves: params.initialRealBaseReserves,
+			// The curve was just stamped with this same key.
+			platformConfig: params.platformConfig,
+			feeBps: params.feeBps,
+			slippageBps: params.slippageBps,
+			partner: params.partner,
+			quoteFee: params.quoteFee,
+			quoteTokenProgram: params.quoteTokenProgram,
+			quoteAmountIn: params.buyQuoteAmount,
+		});
+
+		instructions.push(buyResult.instruction);
+		quote = buyResult.quote;
+	}
+
+	return { instructions, quote };
+}

package/src/launchpad/generated/accounts/bondingCurve.ts

@@ -0,0 +1,273 @@
+/**
+ * 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_LAUNCHPAD_PROGRAM_ADDRESS } from '../programs/index.js';
+import {
+	getBondingCurveStatusDecoder,
+	getBondingCurveStatusEncoder,
+	type BondingCurveStatus,
+	type BondingCurveStatusArgs,
+} from '../types/index.js';
+
+export const BONDING_CURVE_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
+	23, 183, 248, 55, 96, 216, 172, 96,
+]);
+
+export function getBondingCurveDiscriminatorBytes(): ReadonlyUint8Array {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(
+		BONDING_CURVE_DISCRIMINATOR,
+	);
+}
+
+export type BondingCurve = {
+	discriminator: ReadonlyUint8Array;
+	version: number;
+	bump: number;
+	status: BondingCurveStatus;
+	baseMint: Address;
+	baseDecimals: number;
+	baseSupply: bigint;
+	initialVirtualBase: bigint;
+	initialVirtualQuote: bigint;
+	initialRealBase: bigint;
+	quoteMint: Address;
+	quoteDecimals: number;
+	coinCreator: Address;
+	creatorFeeConfig: Address;
+	partner: Address;
+	baseVault: Address;
+	quoteVault: Address;
+	virtualBaseReserves: bigint;
+	virtualQuoteReserves: bigint;
+	realBaseReserves: bigint;
+	realQuoteReserves: bigint;
+	createdAt: bigint;
+	protocolOwed: bigint;
+	creatorOwed: bigint;
+	platformConfig: Address;
+	reserved: ReadonlyUint8Array;
+};
+
+export type BondingCurveArgs = {
+	version: number;
+	bump: number;
+	status: BondingCurveStatusArgs;
+	baseMint: Address;
+	baseDecimals: number;
+	baseSupply: number | bigint;
+	initialVirtualBase: number | bigint;
+	initialVirtualQuote: number | bigint;
+	initialRealBase: number | bigint;
+	quoteMint: Address;
+	quoteDecimals: number;
+	coinCreator: Address;
+	creatorFeeConfig: Address;
+	partner: Address;
+	baseVault: Address;
+	quoteVault: Address;
+	virtualBaseReserves: number | bigint;
+	virtualQuoteReserves: number | bigint;
+	realBaseReserves: number | bigint;
+	realQuoteReserves: number | bigint;
+	createdAt: number | bigint;
+	protocolOwed: number | bigint;
+	creatorOwed: number | bigint;
+	platformConfig: Address;
+	reserved: ReadonlyUint8Array;
+};
+
+/** Gets the encoder for {@link BondingCurveArgs} account data. */
+export function getBondingCurveEncoder(): FixedSizeEncoder<BondingCurveArgs> {
+	return transformEncoder(
+		getStructEncoder([
+			['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+			['version', getU8Encoder()],
+			['bump', getU8Encoder()],
+			['status', getBondingCurveStatusEncoder()],
+			['baseMint', getAddressEncoder()],
+			['baseDecimals', getU8Encoder()],
+			['baseSupply', getU64Encoder()],
+			['initialVirtualBase', getU64Encoder()],
+			['initialVirtualQuote', getU64Encoder()],
+			['initialRealBase', getU64Encoder()],
+			['quoteMint', getAddressEncoder()],
+			['quoteDecimals', getU8Encoder()],
+			['coinCreator', getAddressEncoder()],
+			['creatorFeeConfig', getAddressEncoder()],
+			['partner', getAddressEncoder()],
+			['baseVault', getAddressEncoder()],
+			['quoteVault', getAddressEncoder()],
+			['virtualBaseReserves', getU64Encoder()],
+			['virtualQuoteReserves', getU64Encoder()],
+			['realBaseReserves', getU64Encoder()],
+			['realQuoteReserves', getU64Encoder()],
+			['createdAt', getI64Encoder()],
+			['protocolOwed', getU64Encoder()],
+			['creatorOwed', getU64Encoder()],
+			['platformConfig', getAddressEncoder()],
+			['reserved', fixEncoderSize(getBytesEncoder(), 64)],
+		]),
+		(value) => ({ ...value, discriminator: BONDING_CURVE_DISCRIMINATOR }),
+	);
+}
+
+/** Gets the decoder for {@link BondingCurve} account data. */
+export function getBondingCurveDecoder(): FixedSizeDecoder<BondingCurve> {
+	return getStructDecoder([
+		['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+		['version', getU8Decoder()],
+		['bump', getU8Decoder()],
+		['status', getBondingCurveStatusDecoder()],
+		['baseMint', getAddressDecoder()],
+		['baseDecimals', getU8Decoder()],
+		['baseSupply', getU64Decoder()],
+		['initialVirtualBase', getU64Decoder()],
+		['initialVirtualQuote', getU64Decoder()],
+		['initialRealBase', getU64Decoder()],
+		['quoteMint', getAddressDecoder()],
+		['quoteDecimals', getU8Decoder()],
+		['coinCreator', getAddressDecoder()],
+		['creatorFeeConfig', getAddressDecoder()],
+		['partner', getAddressDecoder()],
+		['baseVault', getAddressDecoder()],
+		['quoteVault', getAddressDecoder()],
+		['virtualBaseReserves', getU64Decoder()],
+		['virtualQuoteReserves', getU64Decoder()],
+		['realBaseReserves', getU64Decoder()],
+		['realQuoteReserves', getU64Decoder()],
+		['createdAt', getI64Decoder()],
+		['protocolOwed', getU64Decoder()],
+		['creatorOwed', getU64Decoder()],
+		['platformConfig', getAddressDecoder()],
+		['reserved', fixDecoderSize(getBytesDecoder(), 64)],
+	]);
+}
+
+/** Gets the codec for {@link BondingCurve} account data. */
+export function getBondingCurveCodec(): FixedSizeCodec<
+	BondingCurveArgs,
+	BondingCurve
+> {
+	return combineCodec(getBondingCurveEncoder(), getBondingCurveDecoder());
+}
+
+export function decodeBondingCurve<TAddress extends string = string>(
+	encodedAccount: EncodedAccount<TAddress>,
+): Account<BondingCurve, TAddress>;
+export function decodeBondingCurve<TAddress extends string = string>(
+	encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<BondingCurve, TAddress>;
+export function decodeBondingCurve<TAddress extends string = string>(
+	encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<BondingCurve, TAddress> | MaybeAccount<BondingCurve, TAddress> {
+	if (!('exists' in encodedAccount) || encodedAccount.exists) {
+		if (encodedAccount.programAddress !== SEND_LAUNCHPAD_PROGRAM_ADDRESS) {
+			const error = new Error(
+				`decodeBondingCurve: account ${encodedAccount.address} is owned by ${encodedAccount.programAddress}, expected ${SEND_LAUNCHPAD_PROGRAM_ADDRESS}`,
+			);
+			error.name = 'AccountOwnerMismatchError';
+			throw error;
+		}
+		if (
+			!containsBytes(encodedAccount.data, BONDING_CURVE_DISCRIMINATOR, 0)
+		) {
+			const error = new Error(
+				`decodeBondingCurve: account ${encodedAccount.address} does not match the BondingCurve discriminator`,
+			);
+			error.name = 'AccountDiscriminatorMismatchError';
+			throw error;
+		}
+	}
+	return decodeAccount(
+		encodedAccount as MaybeEncodedAccount<TAddress>,
+		getBondingCurveDecoder(),
+	);
+}
+
+export async function fetchBondingCurve<TAddress extends string = string>(
+	rpc: Parameters<typeof fetchEncodedAccount>[0],
+	address: Address<TAddress>,
+	config?: FetchAccountConfig,
+): Promise<Account<BondingCurve, TAddress>> {
+	const maybeAccount = await fetchMaybeBondingCurve(rpc, address, config);
+	assertAccountExists(maybeAccount);
+	return maybeAccount;
+}
+
+export async function fetchMaybeBondingCurve<TAddress extends string = string>(
+	rpc: Parameters<typeof fetchEncodedAccount>[0],
+	address: Address<TAddress>,
+	config?: FetchAccountConfig,
+): Promise<MaybeAccount<BondingCurve, TAddress>> {
+	const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+	return decodeBondingCurve(maybeAccount);
+}
+
+export async function fetchAllBondingCurve(
+	rpc: Parameters<typeof fetchEncodedAccounts>[0],
+	addresses: Array<Address>,
+	config?: FetchAccountsConfig,
+): Promise<Account<BondingCurve>[]> {
+	const maybeAccounts = await fetchAllMaybeBondingCurve(
+		rpc,
+		addresses,
+		config,
+	);
+	assertAccountsExist(maybeAccounts);
+	return maybeAccounts;
+}
+
+export async function fetchAllMaybeBondingCurve(
+	rpc: Parameters<typeof fetchEncodedAccounts>[0],
+	addresses: Array<Address>,
+	config?: FetchAccountsConfig,
+): Promise<MaybeAccount<BondingCurve>[]> {
+	const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+	return maybeAccounts.map((maybeAccount) =>
+		decodeBondingCurve(maybeAccount),
+	);
+}
+
+export function getBondingCurveSize(): number {
+	return 421;
+}