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

package/lib/accounts/pollingTokenAccountSubscriber.d.ts

@@ -5,7 +5,7 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './bulkAccountLoader';
-import { AccountInfo } from '@solana/spl-token';
+import { Account } from '@solana/spl-token';
 export declare class PollingTokenAccountSubscriber implements TokenAccountSubscriber {
     isSubscribed: boolean;
     program: Program;
@@ -14,13 +14,13 @@ export declare class PollingTokenAccountSubscriber implements TokenAccountSubscr
     accountLoader: BulkAccountLoader;
     callbackId?: string;
     errorCallbackId?: string;
-    tokenAccountAndSlot?: DataAndSlot<AccountInfo>;
+    tokenAccountAndSlot?: DataAndSlot<Account>;
     constructor(publicKey: PublicKey, accountLoader: BulkAccountLoader);
     subscribe(): Promise<boolean>;
     addToAccountLoader(): Promise<void>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
     assertIsSubscribed(): void;
-    getTokenAccountAndSlot(): DataAndSlot<AccountInfo>;
+    getTokenAccountAndSlot(): DataAndSlot<Account>;
     didSubscriptionSucceed(): boolean;
 }

package/lib/accounts/pollingTokenAccountSubscriber.js

@@ -34,7 +34,7 @@ class PollingTokenAccountSubscriber {
             return;
         }
         this.callbackId = await this.accountLoader.addAccount(this.publicKey, (buffer, slot) => {
-            const tokenAccount = (0, token_1.parseTokenAccount)(buffer);
+            const tokenAccount = (0, token_1.parseTokenAccount)(buffer, this.publicKey);
             this.tokenAccountAndSlot = { data: tokenAccount, slot };
             // @ts-ignore
             this.eventEmitter.emit('tokenAccountUpdate', tokenAccount);
@@ -47,7 +47,10 @@ class PollingTokenAccountSubscriber {
     async fetch() {
         await this.accountLoader.load();
         const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.publicKey);
-        this.tokenAccountAndSlot = { data: (0, token_1.parseTokenAccount)(buffer), slot };
+        this.tokenAccountAndSlot = {
+            data: (0, token_1.parseTokenAccount)(buffer, this.publicKey),
+            slot,
+        };
     }
     async unsubscribe() {
         if (!this.isSubscribed) {

package/lib/accounts/types.d.ts

@@ -4,7 +4,7 @@ import { SpotMarketAccount, PerpMarketAccount, OracleSource, StateAccount, UserA
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
-import { AccountInfo } from '@solana/spl-token';
+import { Account } from '@solana/spl-token';
 import { OracleInfo, OraclePriceData } from '..';
 export interface AccountSubscriber<T> {
     dataAndSlot?: DataAndSlot<T>;
@@ -57,7 +57,7 @@ export interface UserAccountSubscriber {
     getUserAccountAndSlot(): DataAndSlot<UserAccount>;
 }
 export interface TokenAccountEvents {
-    tokenAccountUpdate: (payload: AccountInfo) => void;
+    tokenAccountUpdate: (payload: Account) => void;
     update: void;
     error: (e: Error) => void;
 }
@@ -67,7 +67,7 @@ export interface TokenAccountSubscriber {
     subscribe(): Promise<boolean>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
-    getTokenAccountAndSlot(): DataAndSlot<AccountInfo>;
+    getTokenAccountAndSlot(): DataAndSlot<Account>;
 }
 export interface OracleEvents {
     oracleUpdate: (payload: OraclePriceData) => void;

package/lib/constants/spotMarkets.js

@@ -58,6 +58,16 @@ exports.MainnetSpotMarkets = [
         serumMarket: new web3_js_1.PublicKey('8BnEgHoWFysVcuFFX7QztDmzuH8r5ZFvyP3sYwn1XTh6'),
         phoenixMarket: new web3_js_1.PublicKey('4DoNfFBfF7UokCC2FQzriy7yHK6DY6NVdYpuekQ5pRgg'),
     },
+    {
+        symbol: 'mSOL',
+        marketIndex: 2,
+        oracle: new web3_js_1.PublicKey('E4v1BBgoso9s64TQvmyownAVJbhbEPGyzA3qn4n46qj9'),
+        oracleSource: __1.OracleSource.PYTH,
+        mint: new web3_js_1.PublicKey('mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So'),
+        precision: new __1.BN(10).pow(numericConstants_1.NINE),
+        precisionExp: numericConstants_1.NINE,
+        serumMarket: new web3_js_1.PublicKey('9Lyhks5bQQxb9EyyX55NtgKQzpM4WK7JCmeaWuQ5MoXD'),
+    },
 ];
 exports.SpotMarkets = {
     devnet: exports.DevnetSpotMarkets,

package/lib/dlob/DLOB.d.ts

@@ -1,5 +1,5 @@
 import { NodeList } from './NodeList';
-import { BN, DLOBNode, DLOBNodeType, DriftClient, MarketType, MarketTypeStr, OraclePriceData, Order, OrderActionRecord, OrderRecord, PerpMarketAccount, SlotSubscriber, SpotMarketAccount, StateAccount, TriggerOrderNode, UserMap } from '..';
+import { BN, DLOBNode, DLOBNodeType, DriftClient, MarketType, MarketTypeStr, OraclePriceData, Order, OrderActionRecord, OrderRecord, PerpMarketAccount, PositionDirection, SlotSubscriber, SpotMarketAccount, StateAccount, TriggerOrderNode, UserMap } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { DLOBOrders } from './DLOBOrders';
 import { L2OrderBook, L2OrderBookGenerator, L3OrderBook } from './orderBookLevels';
@@ -135,5 +135,24 @@ export declare class DLOB {
         slot: number;
         oraclePriceData: OraclePriceData;
     }): L3OrderBook;
+    private estimateFillExactBaseAmountInForSide;
+    /**
+     *
+     * @param param.marketIndex the index of the market
+     * @param param.marketType the type of the market
+     * @param param.baseAmount the base amount in to estimate
+     * @param param.orderDirection the direction of the trade
+     * @param param.slot current slot for estimating dlob node price
+     * @param param.oraclePriceData the oracle price data
+     * @returns the estimated quote amount filled: QUOTE_PRECISION
+     */
+    estimateFillWithExactBaseAmount({ marketIndex, marketType, baseAmount, orderDirection, slot, oraclePriceData, }: {
+        marketIndex: number;
+        marketType: MarketType;
+        baseAmount: BN;
+        orderDirection: PositionDirection;
+        slot: number;
+        oraclePriceData: OraclePriceData;
+    }): BN;
 }
 export {};

package/lib/dlob/DLOB.js

@@ -1023,5 +1023,44 @@ class DLOB {
             asks,
         };
     }
+    estimateFillExactBaseAmountInForSide(baseAmountIn, oraclePriceData, slot, dlobSide) {
+        let runningSumQuote = __1.ZERO;
+        let runningSumBase = __1.ZERO;
+        for (const side of dlobSide) {
+            const price = side.getPrice(oraclePriceData, slot); //side.order.quoteAssetAmount.div(side.order.baseAssetAmount);
+            const baseAmountRemaining = side.order.baseAssetAmount.sub(side.order.baseAssetAmountFilled);
+            if (runningSumBase.add(baseAmountRemaining).gt(baseAmountIn)) {
+                const remainingBase = baseAmountIn.sub(runningSumBase);
+                runningSumBase = runningSumBase.add(remainingBase);
+                runningSumQuote = runningSumQuote.add(remainingBase.mul(price));
+                break;
+            }
+            else {
+                runningSumBase = runningSumBase.add(baseAmountRemaining);
+                runningSumQuote = runningSumQuote.add(baseAmountRemaining.mul(price));
+            }
+        }
+        return runningSumQuote
+            .mul(__1.QUOTE_PRECISION)
+            .div(__1.BASE_PRECISION.mul(__1.PRICE_PRECISION));
+    }
+    /**
+     *
+     * @param param.marketIndex the index of the market
+     * @param param.marketType the type of the market
+     * @param param.baseAmount the base amount in to estimate
+     * @param param.orderDirection the direction of the trade
+     * @param param.slot current slot for estimating dlob node price
+     * @param param.oraclePriceData the oracle price data
+     * @returns the estimated quote amount filled: QUOTE_PRECISION
+     */
+    estimateFillWithExactBaseAmount({ marketIndex, marketType, baseAmount, orderDirection, slot, oraclePriceData, }) {
+        if ((0, __1.isVariant)(orderDirection, 'long')) {
+            return this.estimateFillExactBaseAmountInForSide(baseAmount, oraclePriceData, slot, this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData));
+        }
+        else if ((0, __1.isVariant)(orderDirection, 'short')) {
+            return this.estimateFillExactBaseAmountInForSide(baseAmount, oraclePriceData, slot, this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData));
+        }
+    }
 }
 exports.DLOB = DLOB;

package/lib/driftClient.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { AnchorProvider, BN, Program, ProgramAccount } from '@coral-xyz/anchor';
-import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo, MarketType, TxParams, SerumV3FulfillmentConfigAccount, ReferrerNameAccount, OrderTriggerCondition, PerpMarketExtendedInfo, UserStatsAccount, PhoenixV1FulfillmentConfigAccount, ModifyOrderPolicy } from './types';
+import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo, MarketType, TxParams, SerumV3FulfillmentConfigAccount, ReferrerNameAccount, OrderTriggerCondition, PerpMarketExtendedInfo, UserStatsAccount, PhoenixV1FulfillmentConfigAccount, ModifyOrderPolicy, SwapReduceOnly } from './types';
 import * as anchor from '@coral-xyz/anchor';
 import { Connection, PublicKey, TransactionSignature, ConfirmOptions, Transaction, TransactionInstruction, AccountMeta, Signer, AddressLookupTableAccount, TransactionVersion, VersionedTransaction } from '@solana/web3.js';
 import { TokenFaucet } from './tokenFaucet';
@@ -13,6 +13,7 @@ import { DriftClientConfig } from './driftClientConfig';
 import { User } from './user';
 import { UserSubscriptionConfig } from './userConfig';
 import { UserStats } from './userStats';
+import { JupiterClient, Route, SwapMode } from './jupiter/jupiterClient';
 type RemainingAccountParams = {
     userAccounts: UserAccount[];
     writablePerpMarketIndexes?: number[];
@@ -171,6 +172,7 @@ export declare class DriftClient {
      * @param useNative
      */
     getAssociatedTokenAccount(marketIndex: number, useNative?: boolean): Promise<PublicKey>;
+    createAssociatedTokenAccountIdempotentInstruction(account: PublicKey, payer: PublicKey, owner: PublicKey, mint: PublicKey): TransactionInstruction;
     /**
      * Deposit funds into the given spot market
      *
@@ -274,6 +276,53 @@ export declare class DriftClient {
     addSpotFulfillmentAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig?: SerumV3FulfillmentConfigAccount | PhoenixV1FulfillmentConfigAccount): void;
     addSerumRemainingAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig: SerumV3FulfillmentConfigAccount): void;
     addPhoenixRemainingAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig: PhoenixV1FulfillmentConfigAccount): void;
+    /**
+     * 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 route the jupiter route to use for the swap
+     * @param txParams
+     */
+    swap({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, txParams, }: {
+        jupiterClient: JupiterClient;
+        outMarketIndex: number;
+        inMarketIndex: number;
+        outAssociatedTokenAccount?: PublicKey;
+        inAssociatedTokenAccount?: PublicKey;
+        amount: BN;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        route?: Route;
+        reduceOnly?: SwapReduceOnly;
+        txParams?: TxParams;
+    }): Promise<TransactionSignature>;
+    /**
+     * 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
+     */
+    getSwapIx({ outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, }: {
+        outMarketIndex: number;
+        inMarketIndex: number;
+        amountIn: BN;
+        inTokenAccount: PublicKey;
+        outTokenAccount: PublicKey;
+        limitPrice?: BN;
+        reduceOnly?: SwapReduceOnly;
+    }): Promise<{
+        beginSwapIx: TransactionInstruction;
+        endSwapIx: TransactionInstruction;
+    }>;
     triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order, txParams?: TxParams): Promise<TransactionSignature>;
     getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
     forceCancelOrders(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams): Promise<TransactionSignature>;
@@ -485,6 +534,6 @@ export declare class DriftClient {
         marketType: MarketType;
     } | undefined;
     sendTransaction(tx: Transaction | VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
-    buildTransaction(instructions: TransactionInstruction | TransactionInstruction[], txParams?: TxParams): Promise<Transaction | VersionedTransaction>;
+    buildTransaction(instructions: TransactionInstruction | TransactionInstruction[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[]): Promise<Transaction | VersionedTransaction>;
 }
 export {};

package/lib/driftClient.js

@@ -411,7 +411,7 @@ class DriftClient {
         }
         const state = this.getStateAccount();
         if (!state.whitelistMint.equals(web3_js_1.PublicKey.default)) {
-            const associatedTokenPublicKey = await spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.whitelistMint, this.wallet.publicKey);
+            const associatedTokenPublicKey = await (0, spl_token_1.getAssociatedTokenAddress)(state.whitelistMint, this.wallet.publicKey);
             remainingAccounts.push({
                 pubkey: associatedTokenPublicKey,
                 isWritable: false,
@@ -955,7 +955,25 @@ class DriftClient {
             return this.wallet.publicKey;
         }
         const mint = spotMarket.mint;
-        return await spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, mint, this.wallet.publicKey);
+        return await (0, spl_token_1.getAssociatedTokenAddress)(mint, this.wallet.publicKey);
+    }
+    createAssociatedTokenAccountIdempotentInstruction(account, payer, owner, mint) {
+        return new web3_js_1.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: anchor.web3.SystemProgram.programId,
+                    isSigner: false,
+                    isWritable: false,
+                },
+                { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            ],
+            programId: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            data: Buffer.from([0x1]),
+        });
     }
     /**
      * Deposit funds into the given spot market
@@ -988,7 +1006,7 @@ class DriftClient {
         tx.add(depositCollateralIx);
         // Close the wrapped sol account at the end of the transaction
         if (createWSOLTokenAccount) {
-            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, associatedTokenAccount, signerAuthority, signerAuthority, []));
+            tx.add((0, spl_token_1.createCloseAccountInstruction)(associatedTokenAccount, signerAuthority, signerAuthority, []));
         }
         const { txSig, slot } = await this.sendTransaction(tx, additionalSigners, this.opts);
         this.spotMarketLastSlotCache.set(marketIndex, slot);
@@ -1054,13 +1072,12 @@ class DriftClient {
             space: 165,
             programId: spl_token_1.TOKEN_PROGRAM_ID,
         }));
-        result.ixs.push(spl_token_1.Token.createInitAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, spotMarkets_1.WRAPPED_SOL_MINT, wrappedSolAccount.publicKey, authority));
+        result.ixs.push((0, spl_token_1.createInitializeAccountInstruction)(wrappedSolAccount.publicKey, spotMarkets_1.WRAPPED_SOL_MINT, authority));
         result.signers.push(wrappedSolAccount);
         return result;
     }
     getAssociatedTokenAccountCreationIx(tokenMintAddress, associatedTokenAddress) {
-        const createAssociatedAccountIx = spl_token_1.Token.createAssociatedTokenAccountInstruction(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, tokenMintAddress, associatedTokenAddress, this.wallet.publicKey, this.wallet.publicKey);
-        return createAssociatedAccountIx;
+        return (0, spl_token_1.createAssociatedTokenAccountInstruction)(this.wallet.publicKey, associatedTokenAddress, this.wallet.publicKey, tokenMintAddress);
     }
     /**
      * Creates the Clearing House User account for a user, and deposits some initial collateral
@@ -1108,7 +1125,7 @@ class DriftClient {
         tx.add(initializeUserAccountIx).add(depositCollateralIx);
         // Close the wrapped sol account at the end of the transaction
         if (createWSOLTokenAccount) {
-            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, userTokenAccount, authority, authority, []));
+            tx.add((0, spl_token_1.createCloseAccountInstruction)(userTokenAccount, authority, authority, []));
         }
         const { txSig, slot } = await this.sendTransaction(tx, additionalSigners, this.opts);
         this.spotMarketLastSlotCache.set(marketIndex, slot);
@@ -1166,7 +1183,7 @@ class DriftClient {
         tx.add(withdrawCollateral);
         // Close the wrapped sol account at the end of the transaction
         if (createWSOLTokenAccount) {
-            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, associatedTokenAddress, authority, authority, []));
+            tx.add((0, spl_token_1.createCloseAccountInstruction)(associatedTokenAddress, authority, authority, []));
         }
         const { txSig, slot } = await this.sendTransaction(tx, additionalSigners, this.opts);
         this.spotMarketLastSlotCache.set(marketIndex, slot);
@@ -1947,6 +1964,134 @@ class DriftClient {
             isSigner: false,
         });
     }
+    /**
+     * 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 route the jupiter route to use for the swap
+     * @param txParams
+     */
+    async swap({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, txParams, }) {
+        const outMarket = this.getSpotMarketAccount(outMarketIndex);
+        const inMarket = this.getSpotMarketAccount(inMarketIndex);
+        if (!route) {
+            const routes = await jupiterClient.getRoutes({
+                inputMint: inMarket.mint,
+                outputMint: outMarket.mint,
+                amount,
+                slippageBps,
+                swapMode,
+            });
+            if (!routes || routes.length === 0) {
+                throw new Error('No jupiter routes found');
+            }
+            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, false);
+            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, false);
+            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,
+            reduceOnly,
+        });
+        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
+     */
+    async getSwapIx({ outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, }) {
+        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: spl_token_1.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 && limitPrice !== void 0 ? limitPrice : null, reduceOnly !== null && reduceOnly !== void 0 ? reduceOnly : null, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.authority,
+                outSpotMarketVault: outSpotMarket.vault,
+                inSpotMarketVault: inSpotMarket.vault,
+                inTokenAccount,
+                outTokenAccount,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                driftSigner: this.getStateAccount().signer,
+                instructions: anchor.web3.SYSVAR_INSTRUCTIONS_PUBKEY,
+            },
+            remainingAccounts,
+        });
+        return { beginSwapIx, endSwapIx };
+    }
     async triggerOrder(userAccountPublicKey, user, order, txParams) {
         const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getTriggerOrderIx(userAccountPublicKey, user, order), txParams), [], this.opts);
         return txSig;
@@ -2707,7 +2852,7 @@ class DriftClient {
         const addFundsIx = await this.getAddInsuranceFundStakeIx(marketIndex, amount, tokenAccount);
         tx.add(addFundsIx);
         if (createWSOLTokenAccount) {
-            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, tokenAccount, this.wallet.publicKey, this.wallet.publicKey, []));
+            tx.add((0, spl_token_1.createCloseAccountInstruction)(tokenAccount, this.wallet.publicKey, this.wallet.publicKey, []));
         }
         const { txSig } = await this.sendTransaction(tx, additionalSigners, this.opts);
         return txSig;
@@ -2797,7 +2942,7 @@ class DriftClient {
         tx.add(removeStakeIx);
         // Close the wrapped sol account at the end of the transaction
         if (createWSOLTokenAccount) {
-            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, tokenAccount, this.wallet.publicKey, this.wallet.publicKey, []));
+            tx.add((0, spl_token_1.createCloseAccountInstruction)(tokenAccount, this.wallet.publicKey, this.wallet.publicKey, []));
         }
         const { txSig } = await this.sendTransaction(tx, additionalSigners, this.opts);
         return txSig;
@@ -2895,7 +3040,7 @@ class DriftClient {
             return this.txSender.sendVersionedTransaction(tx, additionalSigners, opts);
         }
     }
-    async buildTransaction(instructions, txParams) {
+    async buildTransaction(instructions, txParams, txVersion, lookupTables) {
         var _a, _b;
         const allIx = [];
         const computeUnits = (_a = txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits) !== null && _a !== void 0 ? _a : 600000;
@@ -2916,16 +3061,20 @@ class DriftClient {
         else {
             allIx.push(instructions);
         }
-        if (this.txVersion === 'legacy') {
+        txVersion = txVersion !== null && txVersion !== void 0 ? txVersion : this.txVersion;
+        if (txVersion === 'legacy') {
             return new web3_js_1.Transaction().add(...allIx);
         }
         else {
             const marketLookupTable = await this.fetchMarketLookupTableAccount();
+            lookupTables = lookupTables
+                ? [...lookupTables, marketLookupTable]
+                : [marketLookupTable];
             const message = new web3_js_1.TransactionMessage({
                 payerKey: this.provider.wallet.publicKey,
                 recentBlockhash: (await this.provider.connection.getRecentBlockhash(this.opts.preflightCommitment)).blockhash,
                 instructions: allIx,
-            }).compileToV0Message([marketLookupTable]);
+            }).compileToV0Message(lookupTables);
             return new web3_js_1.VersionedTransaction(message);
         }
     }

package/lib/events/types.d.ts

@@ -1,5 +1,5 @@
 import { Commitment, TransactionSignature } from '@solana/web3.js';
-import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, NewUserRecord, OrderActionRecord, OrderRecord, SettlePnlRecord, LPRecord, InsuranceFundRecord, SpotInterestRecord, InsuranceFundStakeRecord, CurveRecord } from '../index';
+import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, NewUserRecord, OrderActionRecord, OrderRecord, SettlePnlRecord, LPRecord, InsuranceFundRecord, SpotInterestRecord, InsuranceFundStakeRecord, CurveRecord, SwapRecord } from '../index';
 export type EventSubscriptionOptions = {
     eventTypes?: EventType[];
     maxEventsPerType?: number;
@@ -35,9 +35,10 @@ export type EventMap = {
     SpotInterestRecord: Event<SpotInterestRecord>;
     InsuranceFundStakeRecord: Event<InsuranceFundStakeRecord>;
     CurveRecord: Event<CurveRecord>;
+    SwapRecord: Event<SwapRecord>;
 };
 export type EventType = keyof EventMap;
-export type DriftEvent = Event<DepositRecord> | Event<FundingPaymentRecord> | Event<LiquidationRecord> | Event<FundingRateRecord> | Event<OrderRecord> | Event<OrderActionRecord> | Event<SettlePnlRecord> | Event<NewUserRecord> | Event<LPRecord> | Event<InsuranceFundRecord> | Event<SpotInterestRecord> | Event<InsuranceFundStakeRecord> | Event<CurveRecord>;
+export type DriftEvent = Event<DepositRecord> | Event<FundingPaymentRecord> | Event<LiquidationRecord> | Event<FundingRateRecord> | Event<OrderRecord> | Event<OrderActionRecord> | Event<SettlePnlRecord> | Event<NewUserRecord> | Event<LPRecord> | Event<InsuranceFundRecord> | Event<SpotInterestRecord> | Event<InsuranceFundStakeRecord> | Event<CurveRecord> | Event<SwapRecord>;
 export interface EventSubscriberEvents {
     newEvent: (event: WrappedEvent<EventType>) => void;
 }

package/lib/events/types.js

@@ -16,6 +16,7 @@ exports.DefaultEventSubscriptionOptions = {
         'SpotInterestRecord',
         'InsuranceFundStakeRecord',
         'CurveRecord',
+        'SwapRecord',
     ],
     maxEventsPerType: 4096,
     orderBy: 'blockchain',

package/lib/examples/makeTradeExample.js

@@ -8,7 +8,7 @@ const web3_js_1 = require("@solana/web3.js");
 const __2 = require("..");
 const spotMarkets_1 = require("../constants/spotMarkets");
 const getTokenAddress = (mintAddress, userPubKey) => {
-    return spl_token_1.Token.getAssociatedTokenAddress(new web3_js_1.PublicKey(`ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL`), spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
+    return (0, spl_token_1.getAssociatedTokenAddress)(new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
 };
 exports.getTokenAddress = getTokenAddress;
 const env = 'devnet';