@velocity-exchange/sdk 0.0.1

package/src/titan/titanClient.ts

@@ -0,0 +1,438 @@
+import {
+	Connection,
+	PublicKey,
+	TransactionMessage,
+	AddressLookupTableAccount,
+	TransactionInstruction,
+} from '@solana/web3.js';
+import { BN } from '../isomorphic/anchor';
+import { decode } from '@msgpack/msgpack';
+
+export enum SwapMode {
+	ExactIn = 'ExactIn',
+	ExactOut = 'ExactOut',
+}
+
+interface RoutePlanStep {
+	ammKey: Uint8Array;
+	label: string;
+	inputMint: Uint8Array;
+	outputMint: Uint8Array;
+	inAmount: number;
+	outAmount: number;
+	allocPpb: number;
+	feeMint?: Uint8Array;
+	feeAmount?: number;
+	contextSlot?: number;
+}
+
+interface PlatformFee {
+	amount: number;
+	fee_bps: number;
+}
+
+type Pubkey = Uint8Array;
+
+interface AccountMeta {
+	p: Pubkey;
+	s: boolean;
+	w: boolean;
+}
+
+interface Instruction {
+	p: Pubkey;
+	a: AccountMeta[];
+	d: Uint8Array;
+}
+
+interface SwapRoute {
+	inAmount: number;
+	outAmount: number;
+	slippageBps: number;
+	platformFee?: PlatformFee;
+	steps: RoutePlanStep[];
+	instructions: Instruction[];
+	addressLookupTables: Pubkey[];
+	contextSlot?: number;
+	timeTaken?: number;
+	expiresAtMs?: number;
+	expiresAfterSlot?: number;
+	computeUnits?: number;
+	computeUnitsSafe?: number;
+	transaction?: Uint8Array;
+	referenceId?: string;
+}
+
+interface SwapQuotes {
+	id: string;
+	inputMint: Uint8Array;
+	outputMint: Uint8Array;
+	swapMode: SwapMode;
+	amount: number;
+	quotes: { [key: string]: SwapRoute };
+}
+
+export interface QuoteResponse {
+	inputMint: string;
+	inAmount: string;
+	outputMint: string;
+	outAmount: string;
+	swapMode: SwapMode;
+	slippageBps: number;
+	platformFee?: { amount?: string; feeBps?: number };
+	routePlan: Array<{ swapInfo: any; percent: number }>;
+	contextSlot?: number;
+	timeTaken?: number;
+	error?: string;
+	errorCode?: string;
+}
+
+const TITAN_API_URL = 'https://api.titan.exchange';
+
+export class TitanClient {
+	authToken: string;
+	url: string;
+	connection: Connection;
+	proxyUrl?: string;
+	private lastQuoteData?: SwapQuotes;
+	private lastQuoteParams?: string;
+
+	constructor({
+		connection,
+		authToken,
+		url,
+		proxyUrl,
+	}: {
+		connection: Connection;
+		authToken: string;
+		url?: string;
+		proxyUrl?: string;
+	}) {
+		this.connection = connection;
+		this.authToken = authToken;
+		this.url = url ?? TITAN_API_URL;
+		this.proxyUrl = proxyUrl;
+	}
+
+	private buildParams({
+		inputMint,
+		outputMint,
+		amount,
+		userPublicKey,
+		maxAccounts,
+		slippageBps,
+		swapMode,
+		onlyDirectRoutes,
+		excludeDexes,
+		sizeConstraint,
+		accountsLimitWritable,
+	}: {
+		inputMint: PublicKey;
+		outputMint: PublicKey;
+		amount: BN;
+		userPublicKey: PublicKey;
+		maxAccounts?: number;
+		slippageBps?: number;
+		swapMode?: string | SwapMode;
+		onlyDirectRoutes?: boolean;
+		excludeDexes?: string[];
+		sizeConstraint?: number;
+		accountsLimitWritable?: number;
+	}): URLSearchParams {
+		// Normalize swapMode to enum value
+		const normalizedSwapMode =
+			swapMode === 'ExactOut' || swapMode === SwapMode.ExactOut
+				? SwapMode.ExactOut
+				: SwapMode.ExactIn;
+
+		return new URLSearchParams({
+			inputMint: inputMint.toString(),
+			outputMint: outputMint.toString(),
+			amount: amount.toString(),
+			userPublicKey: userPublicKey.toString(),
+			...(slippageBps && { slippageBps: slippageBps.toString() }),
+			...(swapMode && { swapMode: normalizedSwapMode.toString() }),
+			...(maxAccounts && { accountsLimitTotal: maxAccounts.toString() }),
+			...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
+			...(onlyDirectRoutes && {
+				onlyDirectRoutes: onlyDirectRoutes.toString(),
+			}),
+			...(sizeConstraint && { sizeConstraint: sizeConstraint.toString() }),
+			...(accountsLimitWritable && {
+				accountsLimitWritable: accountsLimitWritable.toString(),
+			}),
+		});
+	}
+
+	/**
+	 * Get routes for a swap
+	 */
+	public async getQuote({
+		inputMint,
+		outputMint,
+		amount,
+		userPublicKey,
+		maxAccounts = 50, // 50 is an estimated amount with buffer
+		slippageBps,
+		swapMode,
+		onlyDirectRoutes,
+		excludeDexes,
+		sizeConstraint,
+		accountsLimitWritable,
+	}: {
+		inputMint: PublicKey;
+		outputMint: PublicKey;
+		amount: BN;
+		userPublicKey: PublicKey;
+		maxAccounts?: number;
+		slippageBps?: number;
+		swapMode?: string;
+		onlyDirectRoutes?: boolean;
+		excludeDexes?: string[];
+		sizeConstraint?: number;
+		accountsLimitWritable?: number;
+	}): Promise<QuoteResponse> {
+		const params = this.buildParams({
+			inputMint,
+			outputMint,
+			amount,
+			userPublicKey,
+			maxAccounts,
+			slippageBps,
+			swapMode,
+			onlyDirectRoutes,
+			excludeDexes,
+			sizeConstraint,
+			accountsLimitWritable,
+		});
+
+		let response: Response;
+
+		if (this.proxyUrl) {
+			// Use proxy route - send parameters in request body
+			response = await fetch(this.proxyUrl, {
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+				},
+				body: JSON.stringify(Object.fromEntries(params.entries())),
+			});
+		} else {
+			// Direct request to Titan API
+			response = await fetch(
+				`${this.url}/api/v1/quote/swap?${params.toString()}`,
+				{
+					headers: {
+						Accept: 'application/vnd.msgpack',
+						'Accept-Encoding': 'gzip, deflate, br',
+						Authorization: `Bearer ${this.authToken}`,
+					},
+				}
+			);
+		}
+
+		if (!response.ok) {
+			throw new Error(
+				`Titan API error: ${response.status} ${response.statusText}`
+			);
+		}
+
+		const buffer = await response.arrayBuffer();
+		const data = decode(buffer) as SwapQuotes;
+
+		// Cache the quote data and parameters for later use in getSwap
+		this.lastQuoteData = data;
+		this.lastQuoteParams = params.toString();
+
+		// We are only querying for the best avaiable route so use that
+		const route = data.quotes[Object.keys(data.quotes)[0]];
+
+		if (!route) {
+			throw new Error('No routes available');
+		}
+
+		return {
+			inputMint: inputMint.toString(),
+			inAmount: amount.toString(),
+			outputMint: outputMint.toString(),
+			outAmount: route.outAmount.toString(),
+			swapMode: data.swapMode,
+			slippageBps: route.slippageBps,
+			platformFee: route.platformFee
+				? {
+						amount: route.platformFee.amount.toString(),
+						feeBps: route.platformFee.fee_bps,
+				  }
+				: undefined,
+			routePlan:
+				route.steps?.map((step: any) => ({
+					swapInfo: {
+						ammKey: new PublicKey(step.ammKey).toString(),
+						label: step.label,
+						inputMint: new PublicKey(step.inputMint).toString(),
+						outputMint: new PublicKey(step.outputMint).toString(),
+						inAmount: step.inAmount.toString(),
+						outAmount: step.outAmount.toString(),
+						feeAmount: step.feeAmount?.toString() || '0',
+						feeMint: step.feeMint ? new PublicKey(step.feeMint).toString() : '',
+					},
+					percent: 100,
+				})) || [],
+			contextSlot: route.contextSlot,
+			timeTaken: route.timeTaken,
+		};
+	}
+
+	/**
+	 * Get a swap transaction for quote
+	 */
+	public async getSwap({
+		userPublicKey,
+	}: {
+		inputMint?: PublicKey;
+		outputMint?: PublicKey;
+		amount?: BN;
+		userPublicKey: PublicKey;
+		maxAccounts?: number;
+		slippageBps?: number;
+		swapMode?: SwapMode;
+		onlyDirectRoutes?: boolean;
+		excludeDexes?: string[];
+		sizeConstraint?: number;
+		accountsLimitWritable?: number;
+	}): Promise<{
+		transactionMessage: TransactionMessage;
+		lookupTables: AddressLookupTableAccount[];
+	}> {
+		// Check if we have cached quote data that matches the current parameters
+		if (!this.lastQuoteData) {
+			throw new Error(
+				'No matching quote data found. Please get a fresh quote before attempting to swap.'
+			);
+		}
+
+		// Reuse the cached quote data
+		const data = this.lastQuoteData;
+
+		// We are only querying for the best avaiable route so use that
+		const route = data.quotes[Object.keys(data.quotes)[0]];
+
+		if (!route) {
+			throw new Error('No routes available');
+		}
+
+		if (route.instructions && route.instructions.length > 0) {
+			try {
+				const { transactionMessage, lookupTables } =
+					await this.getTransactionMessageAndLookupTables(route, userPublicKey);
+				return { transactionMessage, lookupTables };
+			} catch (err) {
+				throw new Error(
+					'Something went wrong with creating the Titan swap transaction. Please try again.'
+				);
+			} finally {
+				// Clear cached quote data after use
+				this.lastQuoteData = undefined;
+				this.lastQuoteParams = undefined;
+			}
+		}
+		throw new Error('No instructions provided in the route');
+	}
+
+	/**
+	 * Get the titan instructions from transaction by filtering out instructions to compute budget and associated token programs
+	 * @param transactionMessage the transaction message
+	 * @param inputMint the input mint
+	 * @param outputMint the output mint
+	 */
+	public getTitanInstructions({
+		transactionMessage,
+		inputMint,
+		outputMint,
+	}: {
+		transactionMessage: TransactionMessage;
+		inputMint: PublicKey;
+		outputMint: PublicKey;
+	}): TransactionInstruction[] {
+		// Filter out common system instructions that can be handled by VelocityClient
+		const filteredInstructions = transactionMessage.instructions.filter(
+			(instruction) => {
+				const programId = instruction.programId.toString();
+
+				// Filter out system programs
+				if (programId === 'ComputeBudget111111111111111111111111111111') {
+					return false;
+				}
+
+				if (programId === 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA') {
+					return false;
+				}
+
+				if (programId === '11111111111111111111111111111111') {
+					return false;
+				}
+
+				// Filter out Associated Token Account creation for input/output mints
+				if (programId === 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL') {
+					if (instruction.keys.length > 3) {
+						const mint = instruction.keys[3].pubkey;
+						if (mint.equals(inputMint) || mint.equals(outputMint)) {
+							return false;
+						}
+					}
+				}
+
+				return true;
+			}
+		);
+		return filteredInstructions;
+	}
+
+	private async getTransactionMessageAndLookupTables(
+		route: SwapRoute,
+		userPublicKey: PublicKey
+	): Promise<{
+		transactionMessage: TransactionMessage;
+		lookupTables: AddressLookupTableAccount[];
+	}> {
+		const solanaInstructions: TransactionInstruction[] = route.instructions.map(
+			(instruction) => ({
+				programId: new PublicKey(instruction.p),
+				keys: instruction.a.map((meta) => ({
+					pubkey: new PublicKey(meta.p),
+					isSigner: meta.s,
+					isWritable: meta.w,
+				})),
+				data: Buffer.from(instruction.d),
+			})
+		);
+
+		// Get recent blockhash
+		const { blockhash } = await this.connection.getLatestBlockhash();
+
+		// Build address lookup tables if provided
+		const addressLookupTables: AddressLookupTableAccount[] = [];
+		if (route.addressLookupTables && route.addressLookupTables.length > 0) {
+			for (const altPubkey of route.addressLookupTables) {
+				try {
+					const altAccount = await this.connection.getAddressLookupTable(
+						new PublicKey(altPubkey)
+					);
+					if (altAccount.value) {
+						addressLookupTables.push(altAccount.value);
+					}
+				} catch (err) {
+					console.warn(`Failed to fetch address lookup table:`, err);
+				}
+			}
+		}
+
+		const transactionMessage = new TransactionMessage({
+			payerKey: userPublicKey,
+			recentBlockhash: blockhash,
+			instructions: solanaInstructions,
+		});
+
+		return { transactionMessage, lookupTables: addressLookupTables };
+	}
+}

package/src/token/index.ts

@@ -0,0 +1,13 @@
+import { Account, TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
+import { PublicKey, AccountInfo } from '@solana/web3.js';
+
+export function parseTokenAccount(data: Buffer, pubkey: PublicKey): Account {
+	// mock AccountInfo so unpackAccount can be used
+	const accountInfo: AccountInfo<Buffer> = {
+		data,
+		owner: TOKEN_PROGRAM_ID,
+		executable: false,
+		lamports: 0,
+	};
+	return unpackAccount(pubkey, accountInfo, TOKEN_PROGRAM_ID);
+}

package/src/tokenFaucet.ts

@@ -0,0 +1,274 @@
+import * as anchor from './isomorphic/anchor29';
+import { AnchorProvider, Idl, Program } from './isomorphic/anchor29';
+import {
+	TOKEN_PROGRAM_ID,
+	Account,
+	createAssociatedTokenAccountInstruction,
+	getAssociatedTokenAddress,
+	getAccount,
+} from '@solana/spl-token';
+import {
+	ConfirmOptions,
+	Connection,
+	PublicKey,
+	SYSVAR_RENT_PUBKEY,
+	Transaction,
+	TransactionInstruction,
+	TransactionSignature,
+} from '@solana/web3.js';
+import tokenFaucet from './idl/token_faucet.json';
+import { IWallet } from './types';
+import { BankrunContextWrapper } from './bankrun/bankrunConnection';
+import { DEFAULT_CONFIRMATION_OPTS } from './config';
+import { BN } from './isomorphic/anchor';
+
+export class TokenFaucet {
+	context?: BankrunContextWrapper;
+	connection: Connection;
+	wallet: IWallet;
+	public program: Program;
+	provider: AnchorProvider;
+	mint: PublicKey;
+	opts?: ConfirmOptions;
+
+	public constructor(
+		connection: Connection,
+		wallet: IWallet,
+		programId: PublicKey,
+		mint: PublicKey,
+		opts?: ConfirmOptions,
+		context?: BankrunContextWrapper
+	) {
+		this.connection = connection;
+		this.context = context;
+		this.wallet = wallet;
+		this.opts = opts || DEFAULT_CONFIRMATION_OPTS;
+		// @ts-ignore
+		const provider = new AnchorProvider(
+			context ? context.connection.toConnection() : this.connection,
+			// @ts-ignore
+			wallet,
+			this.opts
+		);
+		this.provider = provider;
+		this.program = new Program(
+			tokenFaucet as unknown as Idl,
+			programId,
+			provider
+		);
+		this.mint = mint;
+	}
+
+	public async getFaucetConfigPublicKeyAndNonce(): Promise<
+		[PublicKey, number]
+	> {
+		return anchor.web3.PublicKey.findProgramAddress(
+			[
+				Buffer.from(anchor.utils.bytes.utf8.encode('faucet_config')),
+				this.mint.toBuffer(),
+			],
+			this.program.programId
+		);
+	}
+
+	public async getMintAuthority(): Promise<PublicKey> {
+		return (
+			await anchor.web3.PublicKey.findProgramAddress(
+				[
+					Buffer.from(anchor.utils.bytes.utf8.encode('mint_authority')),
+					this.mint.toBuffer(),
+				],
+				this.program.programId
+			)
+		)[0];
+	}
+
+	public async getFaucetConfigPublicKey(): Promise<PublicKey> {
+		return (await this.getFaucetConfigPublicKeyAndNonce())[0];
+	}
+
+	public async initialize(): Promise<TransactionSignature> {
+		const [faucetConfigPublicKey] =
+			await this.getFaucetConfigPublicKeyAndNonce();
+		const ix = this.program.instruction.initialize({
+			accounts: {
+				faucetConfig: faucetConfigPublicKey,
+				admin: this.wallet.publicKey,
+				mintAccount: this.mint,
+				rent: SYSVAR_RENT_PUBKEY,
+				systemProgram: anchor.web3.SystemProgram.programId,
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+		});
+		const tx = new Transaction().add(ix);
+		const txSig = await this.context.sendTransaction(tx);
+		return txSig;
+	}
+
+	public async fetchState(): Promise<any> {
+		return await (this.program.account as any).faucetConfig.fetch(
+			await this.getFaucetConfigPublicKey()
+		);
+	}
+
+	private async mintToUserIx(userTokenAccount: PublicKey, amount: BN) {
+		return this.program.instruction.mintToUser(amount, {
+			accounts: {
+				faucetConfig: await this.getFaucetConfigPublicKey(),
+				mintAccount: this.mint,
+				userTokenAccount,
+				mintAuthority: await this.getMintAuthority(),
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+		});
+	}
+
+	public async mintToUser(
+		userTokenAccount: PublicKey,
+		amount: BN
+	): Promise<TransactionSignature> {
+		const mintIx = await this.mintToUserIx(userTokenAccount, amount);
+
+		const tx = new Transaction().add(mintIx);
+
+		if (this.context) {
+			return await this.context.sendTransaction(tx);
+		} else {
+			return await this.program.provider.sendAndConfirm(tx, [], this.opts);
+		}
+	}
+
+	public async transferMintAuthority(): Promise<TransactionSignature> {
+		if (this.context) {
+			const ix = this.program.instruction.transferMintAuthority({
+				accounts: {
+					faucetConfig: await this.getFaucetConfigPublicKey(),
+					mintAccount: this.mint,
+					mintAuthority: await this.getMintAuthority(),
+					tokenProgram: TOKEN_PROGRAM_ID,
+					admin: this.wallet.publicKey,
+				},
+			});
+			const tx = new Transaction().add(ix);
+			const txSig = await this.context.sendTransaction(tx);
+			return txSig;
+		}
+
+		return await this.program.rpc.transferMintAuthority({
+			accounts: {
+				faucetConfig: await this.getFaucetConfigPublicKey(),
+				mintAccount: this.mint,
+				mintAuthority: await this.getMintAuthority(),
+				tokenProgram: TOKEN_PROGRAM_ID,
+				admin: this.wallet.publicKey,
+			},
+		});
+	}
+
+	public async createAssociatedTokenAccountAndMintTo(
+		userPublicKey: PublicKey,
+		amount: BN
+	): Promise<[PublicKey, TransactionSignature]> {
+		const tx = new Transaction();
+
+		const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] =
+			await this.createAssociatedTokenAccountAndMintToInstructions(
+				userPublicKey,
+				amount
+			);
+
+		let associatedTokenAccountExists = false;
+
+		try {
+			const assosciatedTokenAccount =
+				await this.context.connection.getAccountInfo(associatedTokenPublicKey);
+
+			associatedTokenAccountExists = !!assosciatedTokenAccount;
+		} catch (e) {
+			// token account doesn't exist
+			associatedTokenAccountExists = false;
+		}
+
+		const skipAccountCreation = associatedTokenAccountExists;
+
+		if (!skipAccountCreation) tx.add(createAssociatedAccountIx);
+
+		tx.add(mintToTx);
+
+		let txSig;
+		if (this.context) {
+			txSig = await this.context.sendTransaction(tx);
+		} else {
+			txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
+		}
+
+		return [associatedTokenPublicKey, txSig];
+	}
+
+	public async createAssociatedTokenAccountAndMintToInstructions(
+		userPublicKey: PublicKey,
+		amount: BN
+	): Promise<[PublicKey, TransactionInstruction, TransactionInstruction]> {
+		const state: any = await this.fetchState();
+
+		const associateTokenPublicKey = await this.getAssosciatedMockUSDMintAddress(
+			{ userPubKey: userPublicKey }
+		);
+
+		const createAssociatedAccountIx = createAssociatedTokenAccountInstruction(
+			this.wallet.publicKey,
+			associateTokenPublicKey,
+			userPublicKey,
+			state.mint
+		);
+
+		const mintToIx = await this.mintToUserIx(associateTokenPublicKey, amount);
+
+		return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
+	}
+
+	public async getAssosciatedMockUSDMintAddress(props: {
+		userPubKey: PublicKey;
+	}): Promise<anchor.web3.PublicKey> {
+		const state: any = await this.fetchState();
+
+		return getAssociatedTokenAddress(state.mint, props.userPubKey);
+	}
+
+	public async getTokenAccountInfo(props: {
+		userPubKey: PublicKey;
+	}): Promise<Account> {
+		const associatedKey = await this.getAssosciatedMockUSDMintAddress(props);
+		if (this.context) {
+			return await this.context.connection.getTokenAccount(associatedKey);
+		}
+		return await getAccount(this.connection, associatedKey);
+	}
+
+	public async subscribeToTokenAccount(props: {
+		userPubKey: PublicKey;
+		callback: (accountInfo: Account) => void;
+	}): Promise<boolean> {
+		try {
+			const tokenAccountKey = await this.getAssosciatedMockUSDMintAddress(
+				props
+			);
+
+			props.callback(await this.getTokenAccountInfo(props));
+
+			// Couldn't find a way to do it using anchor framework subscription — fall back to onAccountChange.
+			this.context.connection.onAccountChange(
+				tokenAccountKey,
+				async (
+					_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */
+				) => {
+					props.callback(await this.getTokenAccountInfo(props));
+				}
+			);
+
+			return true;
+		} catch (e) {
+			return false;
+		}
+	}
+}