@drift-labs/sdk 2.30.0-beta.0 → 2.30.0-beta.1

package/lib/jupiter/jupiterClient.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JupiterClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+class JupiterClient {
+    constructor({ connection }) {
+        this.url = 'https://quote-api.jup.ag/v4';
+        this.lookupTableCahce = new Map();
+        this.connection = connection;
+    }
+    /**
+     * Get routes for a swap
+     * @param inputMint the mint of the input token
+     * @param outputMint the mint of the output token
+     * @param amount the amount of the input token
+     * @param slippageBps the slippage tolerance in basis points
+     * @param swapMode the swap mode (ExactIn or ExactOut)
+     */
+    async getRoutes({ inputMint, outputMint, amount, slippageBps = 50, swapMode = 'ExactIn', }) {
+        const params = new URLSearchParams({
+            inputMint: inputMint.toString(),
+            outputMint: outputMint.toString(),
+            amount: amount.toString(),
+            slippageBps: slippageBps.toString(),
+            swapMode,
+        }).toString();
+        const { data: routes } = await (await (0, node_fetch_1.default)(`https://quote-api.jup.ag/v4/quote?${params}`)).json();
+        return routes;
+    }
+    /**
+     * Get a swap transaction for a route
+     * @param route the route to perform swap
+     * @param userPublicKey the user's wallet public key
+     * @param slippageBps the slippage tolerance in basis points
+     */
+    async getSwapTransaction({ route, userPublicKey, slippageBps = 50, }) {
+        const resp = await (await (0, node_fetch_1.default)(`${this.url}/swap`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                route,
+                userPublicKey,
+                slippageBps,
+            }),
+        })).json();
+        const { swapTransaction } = resp;
+        const swapTransactionBuf = Buffer.from(swapTransaction, 'base64');
+        return web3_js_1.VersionedTransaction.deserialize(swapTransactionBuf);
+    }
+    /**
+     * Get the transaction message and lookup tables for a transaction
+     * @param transaction
+     */
+    async getTransactionMessageAndLookupTables({ transaction, }) {
+        const message = transaction.message;
+        const lookupTables = (await Promise.all(message.addressTableLookups.map(async (lookup) => {
+            return await this.getLookupTable(lookup.accountKey);
+        }))).filter((lookup) => lookup);
+        const transactionMessage = web3_js_1.TransactionMessage.decompile(message);
+        return {
+            transactionMessage,
+            lookupTables,
+        };
+    }
+    async getLookupTable(accountKey) {
+        if (this.lookupTableCahce.has(accountKey.toString())) {
+            return this.lookupTableCahce.get(accountKey.toString());
+        }
+        return (await this.connection.getAddressLookupTable(accountKey)).value;
+    }
+    /**
+     * Get the jupiter 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
+     */
+    getJupiterInstructions({ transactionMessage, inputMint, outputMint, }) {
+        return transactionMessage.instructions.filter((instruction) => {
+            if (instruction.programId.toString() ===
+                'ComputeBudget111111111111111111111111111111') {
+                return false;
+            }
+            if (instruction.programId.toString() ===
+                'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA') {
+                return false;
+            }
+            if (instruction.programId.toString() ===
+                'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL') {
+                const mint = instruction.keys[3].pubkey;
+                if (mint.equals(inputMint) || mint.equals(outputMint)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+}
+exports.JupiterClient = JupiterClient;

package/lib/types.d.ts

@@ -584,6 +584,17 @@ export type OrderActionRecord = {
     makerOrderCumulativeQuoteAssetAmountFilled: BN | null;
     oraclePrice: BN;
 };
+export type SwapRecord = {
+    ts: number;
+    user: PublicKey;
+    amountOut: BN;
+    amountIn: BN;
+    outMarketIndex: number;
+    inMarketIndex: number;
+    outOraclePrice: BN;
+    inOraclePrice: BN;
+    fee: BN;
+};
 export type StateAccount = {
     admin: PublicKey;
     exchangeStatus: number;
@@ -711,6 +722,9 @@ export type SpotMarketAccount = {
     nextFillRecordId: BN;
     spotFeePool: PoolBalance;
     totalSpotFee: BN;
+    totalSwapFee: BN;
+    flashLoanAmount: BN;
+    flashLoanInitialTokenAmount: BN;
     ordersEnabled: boolean;
 };
 export type PoolBalance = {
@@ -851,6 +865,7 @@ export type UserAccount = {
     totalWithdraws: BN;
     totalSocialLoss: BN;
     cumulativePerpFunding: BN;
+    cumulativeSpotFees: BN;
     liquidationMarginFreed: BN;
     lastActiveSlot: BN;
     isMarginTradingEnabled: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.30.0-beta.0",
+	"version": "2.30.0-beta.1",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/assert/assert.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+function assert(condition, error) {
+    if (!condition) {
+        throw new Error(error || 'Unspecified AssertionError');
+    }
+}
+exports.assert = assert;

package/src/driftClient.ts

@@ -113,6 +113,7 @@ import { isSpotPositionAvailable } from './math/spotPosition';
 import { calculateMarketMaxAvailableInsurance } from './math/market';
 import { fetchUserStatsAccount } from './accounts/fetch';
 import { castNumberToSpotPrecision } from './math/spotMarket';
+import { JupiterClient } from './jupiter/jupiterClient';
 
 type RemainingAccountParams = {
 	userAccounts: UserAccount[];
@@ -1496,6 +1497,30 @@ export class DriftClient {
 		);
 	}
 
+	public async createAssociatedTokenAccountIdempotentInstruction(
+		account: PublicKey,
+		payer: PublicKey,
+		owner: PublicKey,
+		mint: PublicKey
+	): Promise<TransactionInstruction> {
+		return new TransactionInstruction({
+			keys: [
+				{ pubkey: payer, isSigner: true, isWritable: true },
+				{ pubkey: account, isSigner: false, isWritable: true },
+				{ pubkey: owner, isSigner: false, isWritable: false },
+				{ pubkey: mint, isSigner: false, isWritable: false },
+				{
+					pubkey: SystemProgram.programId,
+					isSigner: false,
+					isWritable: false,
+				},
+				{ pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+			],
+			programId: ASSOCIATED_TOKEN_PROGRAM_ID,
+			data: Buffer.from([0x1]),
+		});
+	}
+
 	/**
 	 * Deposit funds into the given spot market
 	 *
@@ -3266,6 +3291,223 @@ export class DriftClient {
 		});
 	}
 
+	/**
+	 * Swap tokens in drift account using jupiter
+	 * @param jupiterClient jupiter client to find routes and jupiter instructions
+	 * @param outMarketIndex the market index of the token you're buying
+	 * @param inMarketIndex the market index of the token you're selling
+	 * @param outAssociatedTokenAccount the token account to receive the token being sold on jupiter
+	 * @param inAssociatedTokenAccount the token account to
+	 * @param amount the amount of the token to sell
+	 * @param slippageBps the max slippage passed to jupiter api
+	 * @param txParams
+	 */
+	public async swap({
+		jupiterClient,
+		outMarketIndex,
+		inMarketIndex,
+		outAssociatedTokenAccount,
+		inAssociatedTokenAccount,
+		amount,
+		slippageBps,
+		txParams,
+	}: {
+		jupiterClient: JupiterClient;
+		outMarketIndex: number;
+		inMarketIndex: number;
+		outAssociatedTokenAccount: PublicKey;
+		inAssociatedTokenAccount: PublicKey;
+		amount: BN;
+		slippageBps: number;
+		txParams?: TxParams;
+	}): Promise<TransactionSignature> {
+		const outMarket = this.getSpotMarketAccount(outMarketIndex);
+		const inMarket = this.getSpotMarketAccount(inMarketIndex);
+
+		const routes = await jupiterClient.getRoutes({
+			inputMint: inMarket.mint,
+			outputMint: outMarket.mint,
+			amount,
+			slippageBps,
+		});
+
+		if (!routes || routes.length === 0) {
+			throw new Error('No jupiter routes found');
+		}
+
+		const route = routes[0];
+		const transaction = await jupiterClient.getSwapTransaction({
+			route,
+			userPublicKey: this.provider.wallet.publicKey,
+			slippageBps,
+		});
+
+		const { transactionMessage, lookupTables } =
+			await jupiterClient.getTransactionMessageAndLookupTables({
+				transaction,
+			});
+
+		const jupiterInstructions = jupiterClient.getJupiterInstructions({
+			transactionMessage,
+			inputMint: inMarket.mint,
+			outputMint: outMarket.mint,
+		});
+
+		const preInstructions = [];
+		if (!outAssociatedTokenAccount) {
+			outAssociatedTokenAccount = await this.getAssociatedTokenAccount(
+				outMarket.marketIndex
+			);
+
+			const accountInfo = await this.connection.getAccountInfo(
+				outAssociatedTokenAccount
+			);
+			if (!accountInfo) {
+				preInstructions.push(
+					this.createAssociatedTokenAccountIdempotentInstruction(
+						outAssociatedTokenAccount,
+						this.provider.wallet.publicKey,
+						this.provider.wallet.publicKey,
+						outMarket.mint
+					)
+				);
+			}
+		}
+
+		if (!inAssociatedTokenAccount) {
+			inAssociatedTokenAccount = await this.getAssociatedTokenAccount(
+				inMarket.marketIndex
+			);
+
+			const accountInfo = await this.connection.getAccountInfo(
+				inAssociatedTokenAccount
+			);
+			if (!accountInfo) {
+				preInstructions.push(
+					this.createAssociatedTokenAccountIdempotentInstruction(
+						inAssociatedTokenAccount,
+						this.provider.wallet.publicKey,
+						this.provider.wallet.publicKey,
+						inMarket.mint
+					)
+				);
+			}
+		}
+
+		const { beginSwapIx, endSwapIx } = await this.getSwapIx({
+			outMarketIndex,
+			inMarketIndex,
+			amountIn: amount,
+			inTokenAccount: inAssociatedTokenAccount,
+			outTokenAccount: outAssociatedTokenAccount,
+		});
+
+		const instructions = [
+			...preInstructions,
+			beginSwapIx,
+			...jupiterInstructions,
+			endSwapIx,
+		];
+
+		const tx = await this.buildTransaction(
+			instructions,
+			txParams,
+			0,
+			lookupTables
+		);
+
+		const { txSig, slot } = await this.sendTransaction(tx);
+		this.spotMarketLastSlotCache.set(outMarketIndex, slot);
+		this.spotMarketLastSlotCache.set(inMarketIndex, slot);
+
+		return txSig;
+	}
+
+	/**
+	 * Get the drift begin_swap and end_swap instructions
+	 *
+	 * @param outMarketIndex the market index of the token you're buying
+	 * @param inMarketIndex the market index of the token you're selling
+	 * @param amountIn the amount of the token to sell
+	 * @param inTokenAccount the token account to move the tokens being sold
+	 * @param outTokenAccount the token account to receive the tokens being bought
+	 * @param limitPrice the limit price of the swap
+	 */
+	public async getSwapIx({
+		outMarketIndex,
+		inMarketIndex,
+		amountIn,
+		inTokenAccount,
+		outTokenAccount,
+		limitPrice,
+	}: {
+		outMarketIndex: number;
+		inMarketIndex: number;
+		amountIn: BN;
+		inTokenAccount: PublicKey;
+		outTokenAccount: PublicKey;
+		limitPrice?: BN;
+	}): Promise<{
+		beginSwapIx: TransactionInstruction;
+		endSwapIx: TransactionInstruction;
+	}> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			writableSpotMarketIndexes: [outMarketIndex, inMarketIndex],
+		});
+
+		const outSpotMarket = this.getSpotMarketAccount(outMarketIndex);
+		const inSpotMarket = this.getSpotMarketAccount(inMarketIndex);
+
+		const beginSwapIx = await this.program.instruction.beginSwap(
+			inMarketIndex,
+			outMarketIndex,
+			amountIn,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user: userAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
+					authority: this.authority,
+					outSpotMarketVault: outSpotMarket.vault,
+					inSpotMarketVault: inSpotMarket.vault,
+					inTokenAccount,
+					outTokenAccount,
+					tokenProgram: TOKEN_PROGRAM_ID,
+					driftSigner: this.getStateAccount().signer,
+					instructions: anchor.web3.SYSVAR_INSTRUCTIONS_PUBKEY,
+				},
+				remainingAccounts,
+			}
+		);
+
+		const endSwapIx = await this.program.instruction.endSwap(
+			inMarketIndex,
+			outMarketIndex,
+			limitPrice ?? null,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user: userAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
+					authority: this.authority,
+					outSpotMarketVault: outSpotMarket.vault,
+					inSpotMarketVault: inSpotMarket.vault,
+					inTokenAccount,
+					outTokenAccount,
+					tokenProgram: TOKEN_PROGRAM_ID,
+					driftSigner: this.getStateAccount().signer,
+					instructions: anchor.web3.SYSVAR_INSTRUCTIONS_PUBKEY,
+				},
+				remainingAccounts,
+			}
+		);
+
+		return { beginSwapIx, endSwapIx };
+	}
+
 	public async triggerOrder(
 		userAccountPublicKey: PublicKey,
 		user: UserAccount,
@@ -5094,7 +5336,9 @@ export class DriftClient {
 
 	async buildTransaction(
 		instructions: TransactionInstruction | TransactionInstruction[],
-		txParams?: TxParams
+		txParams?: TxParams,
+		txVersion?: TransactionVersion,
+		lookupTables?: AddressLookupTableAccount[]
 	): Promise<Transaction | VersionedTransaction> {
 		const allIx = [];
 		const computeUnits = txParams?.computeUnits ?? 600_000;
@@ -5124,6 +5368,9 @@ export class DriftClient {
 			return new Transaction().add(...allIx);
 		} else {
 			const marketLookupTable = await this.fetchMarketLookupTableAccount();
+			lookupTables = lookupTables
+				? [...lookupTables, marketLookupTable]
+				: [marketLookupTable];
 			const message = new TransactionMessage({
 				payerKey: this.provider.wallet.publicKey,
 				recentBlockhash: (
@@ -5132,7 +5379,7 @@ export class DriftClient {
 					)
 				).blockhash,
 				instructions: allIx,
-			}).compileToV0Message([marketLookupTable]);
+			}).compileToV0Message(lookupTables);
 
 			return new VersionedTransaction(message);
 		}

package/src/events/types.ts

@@ -13,6 +13,7 @@ import {
 	SpotInterestRecord,
 	InsuranceFundStakeRecord,
 	CurveRecord,
+	SwapRecord,
 } from '../index';
 
 export type EventSubscriptionOptions = {
@@ -43,6 +44,7 @@ export const DefaultEventSubscriptionOptions: EventSubscriptionOptions = {
 		'SpotInterestRecord',
 		'InsuranceFundStakeRecord',
 		'CurveRecord',
+		'SwapRecord',
 	],
 	maxEventsPerType: 4096,
 	orderBy: 'blockchain',
@@ -83,6 +85,7 @@ export type EventMap = {
 	SpotInterestRecord: Event<SpotInterestRecord>;
 	InsuranceFundStakeRecord: Event<InsuranceFundStakeRecord>;
 	CurveRecord: Event<CurveRecord>;
+	SwapRecord: Event<SwapRecord>;
 };
 
 export type EventType = keyof EventMap;
@@ -100,7 +103,8 @@ export type DriftEvent =
 	| Event<InsuranceFundRecord>
 	| Event<SpotInterestRecord>
 	| Event<InsuranceFundStakeRecord>
-	| Event<CurveRecord>;
+	| Event<CurveRecord>
+	| Event<SwapRecord>;
 
 export interface EventSubscriberEvents {
 	newEvent: (event: WrappedEvent<EventType>) => void;