@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/core/instructions/withdraw.ts

@@ -1,65 +0,0 @@
-import type {
-	AccountMeta,
-	PublicKey,
-	TransactionInstruction,
-} from '@solana/web3.js';
-import type { BN } from '../../isomorphic/anchor';
-import type { VelocityProgram } from '../../config';
-
-/**
- * Builds a `withdraw` instruction, transferring tokens from the protocol's
- * `spotMarketVault` to `userTokenAccount` and debiting (or borrowing against) `user`'s
- * spot position. Unlike deposit, `authority` must equal `user`'s own `authority` field
- * (and `userStats`'s) — delegates cannot withdraw.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.marketIndex - source spot market index.
- * @param args.amount - withdrawal amount, in the spot market's mint's native token precision.
- * @param args.reduceOnly - if true (or the market is reduce-only), caps the withdrawal to the user's current deposit balance so it can only reduce a deposit, never open/increase a borrow.
- * @param args.state - the global `State` PDA.
- * @param args.spotMarket - the source `SpotMarket` PDA.
- * @param args.spotMarketVault - the spot market's token vault PDA (transfer source).
- * @param args.velocitySigner - the program's PDA signer authority; must equal `state.signer` or the instruction throws (used as the CPI signer for the vault-to-user transfer).
- * @param args.user - the `User` account being debited; its `authority` must equal `args.authority`.
- * @param args.userStats - the withdrawing user's `UserStats` PDA; its `authority` must also equal `args.authority`.
- * @param args.userTokenAccount - destination token account; must share a mint with `spotMarketVault`.
- * @param args.authority - signer that must equal `user.authority` (and `userStats.authority`).
- * @param args.tokenProgram - the SPL Token or Token-2022 program owning the mint.
- * @param args.remainingAccounts - oracle/market `AccountMeta[]` for `marketIndex`, plus the withdrawn mint account, plus any Token-2022 transfer-hook accounts.
- * @returns the unsigned `withdraw` `TransactionInstruction`.
- */
-export async function buildWithdrawInstruction(args: {
-	program: VelocityProgram;
-	marketIndex: number;
-	amount: BN;
-	reduceOnly: boolean;
-	state: PublicKey;
-	spotMarket: PublicKey;
-	spotMarketVault: PublicKey;
-	velocitySigner: PublicKey;
-	user: PublicKey;
-	userStats: PublicKey;
-	userTokenAccount: PublicKey;
-	authority: PublicKey;
-	tokenProgram: PublicKey;
-	remainingAccounts: AccountMeta[];
-}): Promise<TransactionInstruction> {
-	return await (args.program.instruction as any).withdraw(
-		args.marketIndex,
-		args.amount,
-		args.reduceOnly,
-		{
-			accounts: {
-				state: args.state,
-				spotMarket: args.spotMarket,
-				spotMarketVault: args.spotMarketVault,
-				velocitySigner: args.velocitySigner,
-				user: args.user,
-				userStats: args.userStats,
-				userTokenAccount: args.userTokenAccount,
-				authority: args.authority,
-				tokenProgram: args.tokenProgram,
-			},
-			remainingAccounts: args.remainingAccounts,
-		}
-	);
-}

package/src/core/remainingAccounts.ts

@@ -1,320 +0,0 @@
-import { PublicKey, type AccountMeta } from '@solana/web3.js';
-import { isVariant } from '../types';
-import { QUOTE_SPOT_MARKET_INDEX, ZERO } from '../constants/numericConstants';
-import { isSpotPositionAvailable } from '../math/spotPosition';
-import { positionIsAvailable } from '../math/position';
-import type {
-	UserAccount,
-	SpotMarketAccount,
-	PerpMarketAccount,
-} from '../types';
-
-/**
- * Per-call inputs to `getRemainingAccounts`, describing which markets and users' open
- * positions must be represented in the built `remainingAccounts` list.
- */
-export type RemainingAccountParams = {
-	/** Every open (non-available) spot/perp position across these accounts is included — this is how a `User`'s own margined positions get their market + oracle accounts passed to an instruction. */
-	userAccounts: UserAccount[];
-	/** Perp market indexes to include as writable (plus their oracle and quote spot market), in addition to whatever `userAccounts`' positions already require. */
-	writablePerpMarketIndexes?: number[];
-	/** Spot market indexes to include as writable (plus their oracle), in addition to whatever `userAccounts`' positions already require. */
-	writableSpotMarketIndexes?: number[];
-	/** Perp market index(es) to include as read-only (plus their oracle and quote spot market) — typically the market(s) an instruction is acting on. */
-	readablePerpMarketIndex?: number | number[];
-	/** Spot market indexes to include as read-only (plus their oracle). */
-	readableSpotMarketIndexes?: number[];
-	/** If true, also re-includes any market still tracked in `ctx.perpMarketLastSlotCache` / `ctx.spotMarketLastSlotCache` whose cached slot is newer than the resolved user's last-active slot — a cache-invalidation guard so a market touched by a very recent instruction doesn't get dropped from the very next one before its state can be considered "seen" by the user account. Stale cache entries (slot ≤ the user's last-active slot) are evicted as a side effect. */
-	useMarketLastSlotCache?: boolean;
-};
-
-/**
- * Caller-supplied hooks and mutable state `getRemainingAccounts` needs to resolve market
- * accounts and apply cache-invalidation logic without depending on a subscribed
- * `VelocityClient`. All fields are read (and the `Map`/`Set` fields also mutated in
- * place — entries may be added or evicted) by `getRemainingAccounts`; the caller owns
- * their lifetime and should typically persist them across calls for the caches to be
- * useful.
- */
-export type RemainingAccountsContext = {
-	/** Resolves a perp market index to its loaded `PerpMarketAccount` (including `pubkey`, `oracle`, `oracleSource`, `quoteSpotMarketIndex`). Should throw or the caller should ensure the market is loaded before calling. */
-	getPerpMarketAccount: (marketIndex: number) => PerpMarketAccount;
-	/** Resolves a spot market index to its loaded `SpotMarketAccount` (including `pubkey` and `oracle`). */
-	getSpotMarketAccount: (marketIndex: number) => SpotMarketAccount;
-
-	/** Resolves a user's most recent on-chain-active slot, used to decide whether cached markets from `perpMarketLastSlotCache`/`spotMarketLastSlotCache` are still relevant. Returns `undefined` if the user account isn't known/loaded, in which case cache entries are treated as stale and dropped. */
-	getUserAccountAndSlot: (
-		subAccountId: number | undefined,
-		authority: PublicKey
-	) => { slot: number } | undefined;
-
-	/** Sub-account id used (together with `authority`) to look up the acting user when `params.userAccounts` is empty and `useMarketLastSlotCache` is set. */
-	activeSubAccountId: number | undefined;
-	/** Wallet authority used (together with `activeSubAccountId`) for the same lookup. */
-	authority: PublicKey;
-
-	/** Mutable cache of perp market index → last slot it was touched at; consulted (and pruned) only when `params.useMarketLastSlotCache` is true. Owned by the caller. */
-	perpMarketLastSlotCache: Map<number, number>;
-	/** Mutable cache of spot market index → last slot it was touched at; consulted (and pruned) only when `params.useMarketLastSlotCache` is true. Owned by the caller. */
-	spotMarketLastSlotCache: Map<number, number>;
-	/** Perp market indexes that must always be included as read-only, regardless of `params` (e.g. markets forced in by other in-flight instructions in the same transaction). Owned by the caller. */
-	mustIncludePerpMarketIndexes: Set<number>;
-	/** Spot market indexes that must always be included as read-only, regardless of `params`. Owned by the caller. */
-	mustIncludeSpotMarketIndexes: Set<number>;
-};
-
-/**
- * Builds the ordered `remainingAccounts: AccountMeta[]` that Velocity trading/keeper
- * instructions require — one `AccountMeta` per oracle, then per spot market, then per
- * perp market, deduplicated by pubkey/index. This is the pure, subscription-free
- * equivalent of `VelocityClient`'s internal remaining-accounts builder: pass it whatever
- * markets/positions are relevant and it derives the same account set an instruction
- * builder (`buildDepositInstruction`, `buildPlacePerpOrderInstruction`, etc.) expects in
- * its `remainingAccounts` argument.
- *
- * Every open position on `params.userAccounts` contributes its market (+ oracle); open
- * spot positions with resting orders (`openAsks`/`openBids` non-zero) also pull in the
- * quote spot market so margin can be computed against it. `params.writable*`/`readable*`
- * indexes are added on top, and an oracle is marked writable only for a perp market on a
- * `prelaunch` oracle source being written to (needed so the prelaunch oracle CPI can
- * update its own account).
- *
- * @param ctx - resolver hooks and caller-owned mutable caches (see `RemainingAccountsContext`).
- * @param params - which markets/positions to include for this call (see `RemainingAccountParams`).
- * @returns the deduplicated `AccountMeta[]`, ordered oracles → spot markets → perp markets.
- */
-export function getRemainingAccounts(
-	ctx: RemainingAccountsContext,
-	params: RemainingAccountParams
-): AccountMeta[] {
-	const { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap } =
-		getRemainingAccountMapsForUsers(ctx, params.userAccounts);
-
-	if (params.useMarketLastSlotCache) {
-		const lastUserSlot = ctx.getUserAccountAndSlot(
-			params.userAccounts.length > 0
-				? params.userAccounts[0].subAccountId
-				: ctx.activeSubAccountId,
-			params.userAccounts.length > 0
-				? params.userAccounts[0].authority
-				: ctx.authority
-		)?.slot;
-
-		for (const [marketIndex, slot] of ctx.perpMarketLastSlotCache.entries()) {
-			if (lastUserSlot !== undefined && slot > lastUserSlot) {
-				addPerpMarketToRemainingAccountMaps(
-					ctx,
-					marketIndex,
-					false,
-					oracleAccountMap,
-					spotMarketAccountMap,
-					perpMarketAccountMap
-				);
-			} else {
-				ctx.perpMarketLastSlotCache.delete(marketIndex);
-			}
-		}
-
-		for (const [marketIndex, slot] of ctx.spotMarketLastSlotCache.entries()) {
-			if (lastUserSlot !== undefined && slot > lastUserSlot) {
-				addSpotMarketToRemainingAccountMaps(
-					ctx,
-					marketIndex,
-					false,
-					oracleAccountMap,
-					spotMarketAccountMap
-				);
-			} else {
-				ctx.spotMarketLastSlotCache.delete(marketIndex);
-			}
-		}
-	}
-
-	if (params.readablePerpMarketIndex !== undefined) {
-		const readablePerpMarketIndexes = Array.isArray(
-			params.readablePerpMarketIndex
-		)
-			? params.readablePerpMarketIndex
-			: [params.readablePerpMarketIndex];
-		for (const marketIndex of readablePerpMarketIndexes) {
-			addPerpMarketToRemainingAccountMaps(
-				ctx,
-				marketIndex,
-				false,
-				oracleAccountMap,
-				spotMarketAccountMap,
-				perpMarketAccountMap
-			);
-		}
-	}
-
-	for (const perpMarketIndex of ctx.mustIncludePerpMarketIndexes.values()) {
-		addPerpMarketToRemainingAccountMaps(
-			ctx,
-			perpMarketIndex,
-			false,
-			oracleAccountMap,
-			spotMarketAccountMap,
-			perpMarketAccountMap
-		);
-	}
-
-	if (params.readableSpotMarketIndexes !== undefined) {
-		for (const readableSpotMarketIndex of params.readableSpotMarketIndexes) {
-			addSpotMarketToRemainingAccountMaps(
-				ctx,
-				readableSpotMarketIndex,
-				false,
-				oracleAccountMap,
-				spotMarketAccountMap
-			);
-		}
-	}
-
-	for (const spotMarketIndex of ctx.mustIncludeSpotMarketIndexes.values()) {
-		addSpotMarketToRemainingAccountMaps(
-			ctx,
-			spotMarketIndex,
-			false,
-			oracleAccountMap,
-			spotMarketAccountMap
-		);
-	}
-
-	if (params.writablePerpMarketIndexes !== undefined) {
-		for (const writablePerpMarketIndex of params.writablePerpMarketIndexes) {
-			addPerpMarketToRemainingAccountMaps(
-				ctx,
-				writablePerpMarketIndex,
-				true,
-				oracleAccountMap,
-				spotMarketAccountMap,
-				perpMarketAccountMap
-			);
-		}
-	}
-
-	if (params.writableSpotMarketIndexes !== undefined) {
-		for (const writableSpotMarketIndex of params.writableSpotMarketIndexes) {
-			addSpotMarketToRemainingAccountMaps(
-				ctx,
-				writableSpotMarketIndex,
-				true,
-				oracleAccountMap,
-				spotMarketAccountMap
-			);
-		}
-	}
-
-	return [
-		...oracleAccountMap.values(),
-		...spotMarketAccountMap.values(),
-		...perpMarketAccountMap.values(),
-	];
-}
-
-function addPerpMarketToRemainingAccountMaps(
-	ctx: RemainingAccountsContext,
-	marketIndex: number,
-	writable: boolean,
-	oracleAccountMap: Map<string, AccountMeta>,
-	spotMarketAccountMap: Map<number, AccountMeta>,
-	perpMarketAccountMap: Map<number, AccountMeta>
-): void {
-	const perpMarketAccount = ctx.getPerpMarketAccount(marketIndex);
-	perpMarketAccountMap.set(marketIndex, {
-		pubkey: perpMarketAccount.pubkey,
-		isSigner: false,
-		isWritable: writable,
-	});
-	const oracleWritable =
-		writable && isVariant(perpMarketAccount.oracleSource, 'prelaunch');
-	oracleAccountMap.set(perpMarketAccount.oracle.toString(), {
-		pubkey: perpMarketAccount.oracle,
-		isSigner: false,
-		isWritable: oracleWritable,
-	});
-	addSpotMarketToRemainingAccountMaps(
-		ctx,
-		perpMarketAccount.quoteSpotMarketIndex,
-		false,
-		oracleAccountMap,
-		spotMarketAccountMap
-	);
-}
-
-function addSpotMarketToRemainingAccountMaps(
-	ctx: RemainingAccountsContext,
-	marketIndex: number,
-	writable: boolean,
-	oracleAccountMap: Map<string, AccountMeta>,
-	spotMarketAccountMap: Map<number, AccountMeta>
-): void {
-	const spotMarketAccount = ctx.getSpotMarketAccount(marketIndex);
-	spotMarketAccountMap.set(spotMarketAccount.marketIndex, {
-		pubkey: spotMarketAccount.pubkey,
-		isSigner: false,
-		isWritable: writable,
-	});
-	if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-		oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-			pubkey: spotMarketAccount.oracle,
-			isSigner: false,
-			isWritable: false,
-		});
-	}
-}
-
-function getRemainingAccountMapsForUsers(
-	ctx: RemainingAccountsContext,
-	userAccounts: UserAccount[]
-): {
-	oracleAccountMap: Map<string, AccountMeta>;
-	spotMarketAccountMap: Map<number, AccountMeta>;
-	perpMarketAccountMap: Map<number, AccountMeta>;
-} {
-	const oracleAccountMap = new Map<string, AccountMeta>();
-	const spotMarketAccountMap = new Map<number, AccountMeta>();
-	const perpMarketAccountMap = new Map<number, AccountMeta>();
-
-	for (const userAccount of userAccounts) {
-		for (const spotPosition of userAccount.spotPositions) {
-			if (!isSpotPositionAvailable(spotPosition)) {
-				addSpotMarketToRemainingAccountMaps(
-					ctx,
-					spotPosition.marketIndex,
-					false,
-					oracleAccountMap,
-					spotMarketAccountMap
-				);
-
-				if (
-					!spotPosition.openAsks.eq(ZERO) ||
-					!spotPosition.openBids.eq(ZERO)
-				) {
-					addSpotMarketToRemainingAccountMaps(
-						ctx,
-						QUOTE_SPOT_MARKET_INDEX,
-						false,
-						oracleAccountMap,
-						spotMarketAccountMap
-					);
-				}
-			}
-		}
-		for (const position of userAccount.perpPositions) {
-			if (!positionIsAvailable(position)) {
-				addPerpMarketToRemainingAccountMaps(
-					ctx,
-					position.marketIndex,
-					false,
-					oracleAccountMap,
-					spotMarketAccountMap,
-					perpMarketAccountMap
-				);
-			}
-		}
-	}
-
-	return { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap };
-}

package/src/core/signedMsg.ts

@@ -1,109 +0,0 @@
-import { sha256 } from '@noble/hashes/sha256';
-import type {
-	SignedMsgOrderParamsDelegateMessage,
-	SignedMsgOrderParamsMessage,
-} from '../types';
-
-/**
- * Minimal shape of an Anchor `program.coder.types` needed to (de)serialize the
- * `signedMsgOrderParamsMessage` / `signedMsgOrderParamsDelegateMessage` IDL types —
- * lets these helpers accept a plain coder without depending on a full `Program`.
- */
-export type AnchorTypesCoder = {
-	encode: (typeName: string, value: any) => Buffer;
-	decode: (typeName: string, buffer: Buffer) => any;
-};
-
-/**
- * Borsh-encodes a Swift signed-order message envelope: an 8-byte Anchor type
- * discriminator (`sha256("global:SignedMsgOrderParamsMessage" | "...Delegate...")[0..8]`)
- * followed by the Borsh-serialized message body. This is the exact byte layout the
- * taker/delegate signs off-chain and the Swift server / `placeAndMakeSignedMsgPerpOrder`
- * verifies and decodes on submission.
- *
- * `maxMarginRatio`/`isolatedPositionDeposit` default to `null` when omitted, and
- * `builderIdx`/`builderFeeTenthBps` default to `null` when omitted — both for
- * Borsh-Option compatibility with the IDL type, which requires the fields be present.
- *
- * @param args.coderTypes - an Anchor types coder (or `AnchorTypesCoder`) that knows the `signedMsgOrderParamsMessage`/`signedMsgOrderParamsDelegateMessage` IDL types.
- * @param args.orderParamsMessage - the order params message to encode; a plain `SignedMsgOrderParamsMessage` or, if `delegateSigner` is true, a `SignedMsgOrderParamsDelegateMessage`.
- * @param args.delegateSigner - whether this message is signed by a delegate rather than the account owner; selects both the discriminator and the IDL type used to encode the body. Defaults to `false`.
- * @returns the discriminator-prefixed Borsh buffer, ready to be signed and submitted.
- */
-export function encodeSignedMsgOrderParamsMessage(args: {
-	coderTypes: AnchorTypesCoder;
-	orderParamsMessage:
-		| SignedMsgOrderParamsMessage
-		| SignedMsgOrderParamsDelegateMessage;
-	delegateSigner?: boolean;
-}): Buffer {
-	const { coderTypes, delegateSigner } = args;
-	const orderParamsMessage: any = { ...args.orderParamsMessage };
-
-	if (orderParamsMessage.maxMarginRatio === undefined) {
-		orderParamsMessage.maxMarginRatio = null;
-	}
-	if (orderParamsMessage.isolatedPositionDeposit === undefined) {
-		orderParamsMessage.isolatedPositionDeposit = null;
-	}
-
-	const anchorIxName = delegateSigner
-		? 'global' + ':' + 'SignedMsgOrderParamsDelegateMessage'
-		: 'global' + ':' + 'SignedMsgOrderParamsMessage';
-	const prefix = Buffer.from(sha256(anchorIxName).slice(0, 8));
-
-	const withBuilderDefaults = {
-		...orderParamsMessage,
-		builderIdx:
-			orderParamsMessage.builderIdx !== undefined
-				? orderParamsMessage.builderIdx
-				: null,
-		builderFeeTenthBps:
-			orderParamsMessage.builderFeeTenthBps !== undefined
-				? orderParamsMessage.builderFeeTenthBps
-				: null,
-	};
-
-	const body = delegateSigner
-		? coderTypes.encode(
-				'signedMsgOrderParamsDelegateMessage',
-				withBuilderDefaults as SignedMsgOrderParamsDelegateMessage
-		  )
-		: coderTypes.encode(
-				'signedMsgOrderParamsMessage',
-				withBuilderDefaults as SignedMsgOrderParamsMessage
-		  );
-
-	return Buffer.concat([prefix, body]);
-}
-
-/**
- * Decodes a Swift signed-order message envelope produced by
- * `encodeSignedMsgOrderParamsMessage`: strips the leading 8-byte discriminator and
- * Borsh-deserializes the remainder as either `signedMsgOrderParamsMessage` or
- * `signedMsgOrderParamsDelegateMessage`.
- *
- * Zero-pads the buffer with 128 extra bytes before decoding, so a message encoded by an
- * older/smaller IDL (missing newer optional fields) still deserializes instead of
- * throwing on a short read. This only works because new fields are `Option`s — if the
- * current IDL's type were ever more than 128 bytes larger than the incoming message,
- * decoding would still fail.
- *
- * @param args.coderTypes - an Anchor types coder (or `AnchorTypesCoder`) that knows the `signedMsgOrderParamsMessage`/`signedMsgOrderParamsDelegateMessage` IDL types.
- * @param args.encodedMessage - the discriminator-prefixed buffer to decode (as produced by `encodeSignedMsgOrderParamsMessage`).
- * @param args.delegateSigner - whether to decode as a `SignedMsgOrderParamsDelegateMessage` rather than `SignedMsgOrderParamsMessage`. Must match how the message was encoded. Defaults to `false`.
- * @returns the decoded `SignedMsgOrderParamsMessage` or `SignedMsgOrderParamsDelegateMessage`.
- */
-export function decodeSignedMsgOrderParamsMessage(args: {
-	coderTypes: AnchorTypesCoder;
-	encodedMessage: Buffer;
-	delegateSigner?: boolean;
-}): SignedMsgOrderParamsMessage | SignedMsgOrderParamsDelegateMessage {
-	const decodeStr = args.delegateSigner
-		? 'signedMsgOrderParamsDelegateMessage'
-		: 'signedMsgOrderParamsMessage';
-	return args.coderTypes.decode(
-		decodeStr,
-		Buffer.concat([args.encodedMessage.slice(8), Buffer.alloc(128)])
-	);
-}

package/src/decode/customCoder.ts

@@ -1,148 +0,0 @@
-import { Buffer } from 'buffer';
-import {
-	Idl,
-	BorshAccountsCoder,
-	BorshEventCoder,
-	BorshInstructionCoder,
-	BorshCoder,
-} from '../isomorphic/anchor';
-
-/**
- * Drop-in replacement for Anchor's `BorshCoder` that swaps in `CustomBorshAccountsCoder` for
- * account (de)serialization while delegating instruction/event/type coding to the stock Anchor
- * coder. Use this as the `coder` passed to `new Program(idl, provider, coder)` wherever an
- * account may be re-encoded (e.g. test fixtures), since the stock coder's `encode()` can
- * under-allocate its buffer for large accounts (see `CustomBorshAccountsCoder.encode`).
- */
-export class CustomBorshCoder<
-	A extends string = string,
-	_T extends string = string,
-> {
-	readonly idl: Idl;
-
-	/**
-	 * Instruction coder.
-	 */
-	readonly instruction: BorshInstructionCoder;
-
-	/**
-	 * Account coder.
-	 */
-	readonly accounts: CustomBorshAccountsCoder<A>;
-
-	/**
-	 * Coder for events.
-	 */
-	readonly events: BorshEventCoder;
-
-	/**
-	 * Coder for user-defined types.
-	 */
-	readonly types: any;
-
-	constructor(idl: Idl) {
-		const baseCoder = new BorshCoder(idl);
-		this.instruction = baseCoder.instruction as BorshInstructionCoder;
-		this.accounts = new CustomBorshAccountsCoder(idl);
-		this.events = baseCoder.events as BorshEventCoder;
-		this.types = baseCoder.types;
-		this.idl = idl;
-	}
-}
-
-/**
- * Custom accounts coder that wraps BorshAccountsCoder to fix encode buffer sizing.
- */
-export class CustomBorshAccountsCoder<A extends string = string> {
-	private baseCoder: BorshAccountsCoder<A>;
-	private idl: Idl;
-
-	public constructor(idl: Idl) {
-		this.baseCoder = new BorshAccountsCoder<A>(idl);
-		this.idl = idl;
-	}
-
-	/**
-	 * Encodes an account struct to its on-chain byte representation (8-byte discriminator +
-	 * Borsh-serialized fields). Unlike Anchor's stock `BorshAccountsCoder.encode` — which
-	 * allocates a hardcoded 1000-byte scratch buffer and silently truncates/corrupts any account
-	 * larger than that (e.g. `User` at ~4.5KB, `PerpMarket`) — this computes the buffer size from
-	 * the IDL layout via `this.baseCoder.size(accountName)` (floored at 1000 bytes for small
-	 * accounts) so large accounts encode correctly.
-	 * @param accountName - IDL account type name (e.g. `"User"`, `"PerpMarket"`).
-	 * @param account - The decoded account value to serialize.
-	 * @returns The encoded account bytes, discriminator included.
-	 * @throws Error if `accountName` is not present in the IDL's account layouts.
-	 */
-	public async encode<T = any>(accountName: A, account: T): Promise<Buffer> {
-		const layout = (this.baseCoder as any)['accountLayouts'].get(accountName);
-		if (!layout) {
-			throw new Error(`Unknown account: ${accountName}`);
-		}
-
-		// Fix: compute proper buffer size instead of the hardcoded 1000 bytes
-		const size = this.baseCoder.size(accountName);
-		const buffer = Buffer.alloc(Math.max(size, 1000));
-		const len = layout.layout.encode(account, buffer);
-		const accountData = buffer.slice(0, len);
-		const discriminator = Buffer.from(layout.discriminator);
-		return Buffer.concat([discriminator, accountData]);
-	}
-
-	// Delegate all other methods to the base coder
-	/** Decodes and validates an account's discriminator, delegating to Anchor's `BorshAccountsCoder.decode`. */
-	public decode<T = any>(accountName: A, data: Buffer): T {
-		return this.baseCoder.decode(accountName, data);
-	}
-
-	/** Decodes an account by inspecting its discriminator to determine its type, delegating to Anchor's `BorshAccountsCoder.decodeAny`. */
-	public decodeAny<T = any>(data: Buffer): T {
-		return this.baseCoder.decodeAny(data);
-	}
-
-	/** Decodes an account without discriminator validation, delegating to Anchor's `BorshAccountsCoder.decodeUnchecked`. */
-	public decodeUnchecked<T = any>(accountName: A, ix: Buffer): T {
-		return this.baseCoder.decodeUnchecked(accountName, ix);
-	}
-
-	/** Builds a memcmp filter for `accountName`'s discriminator (optionally with `appendData`), delegating to Anchor's `BorshAccountsCoder.memcmp`. */
-	public memcmp(accountName: A, appendData?: Buffer): any {
-		return this.baseCoder.memcmp(accountName, appendData);
-	}
-
-	/** Returns the fixed on-chain byte size (including discriminator) of `accountName`, delegating to Anchor's `BorshAccountsCoder.size`. */
-	public size(accountName: A | string): number {
-		return this.baseCoder.size(accountName as A);
-	}
-
-	/**
-	 * Returns the 8-byte account discriminator for `accountName`, read from the IDL-derived
-	 * account layout (Anchor 0.32+ derives discriminators from the IDL rather than a static
-	 * `sha256("account:Name")` hash). This is the instance-scoped counterpart to the throwing
-	 * static `accountDiscriminator` stub.
-	 * @param accountName - IDL account type name (e.g. `"User"`, `"PerpMarket"`).
-	 * @throws Error if `accountName` is not present in the IDL's account layouts.
-	 */
-	public accountDiscriminator(accountName: A): Buffer {
-		const layout = (this.baseCoder as any)['accountLayouts'].get(accountName);
-		if (!layout) {
-			throw new Error(`Unknown account: ${accountName}`);
-		}
-		return Buffer.from(layout.discriminator);
-	}
-
-	/**
-	 * Always throws. Anchor 0.32+ derives account discriminators from the IDL rather than a
-	 * static `sha256("account:Name")` hash, so no *static* method can compute one without an
-	 * IDL instance — this stub exists only to satisfy code written against Anchor's older static
-	 * `BorshAccountsCoder.accountDiscriminator(name)` API.
-	 * @param _name - Unused.
-	 * @throws Error always; use the instance-scoped `accountDiscriminator` on a coder built from an IDL instead.
-	 */
-	public static accountDiscriminator(_name: string): Buffer {
-		// Delegate to an instance method since anchor 0.32 uses IDL discriminators
-		throw new Error(
-			'accountDiscriminator requires an instance; use coder.accountDiscriminator(name)'
-		);
-	}
-}