@drift-labs/sdk 2.31.1-beta.2 → 2.31.1-beta.20

package/VERSION

@@ -1 +1 @@
-2.31.1-beta.2
+2.31.1-beta.20

package/lib/accounts/mockUserAccountSubscriber.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { DataAndSlot, UserAccountEvents, UserAccountSubscriber } from './types';
+import { PublicKey } from '@solana/web3.js';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { UserAccount } from '../types';
+export declare class MockUserAccountSubscriber implements UserAccountSubscriber {
+    isSubscribed: boolean;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+    userAccountPublicKey: PublicKey;
+    callbackId?: string;
+    errorCallbackId?: string;
+    user: DataAndSlot<UserAccount>;
+    constructor(userAccountPublicKey: PublicKey, data: UserAccount, slot: number);
+    subscribe(_userAccount?: UserAccount): Promise<boolean>;
+    addToAccountLoader(): Promise<void>;
+    fetch(): Promise<void>;
+    doesAccountExist(): boolean;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserAccountAndSlot(): DataAndSlot<UserAccount>;
+    updateData(userAccount: UserAccount, slot: number): void;
+}

package/lib/accounts/mockUserAccountSubscriber.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockUserAccountSubscriber = void 0;
+const events_1 = require("events");
+class MockUserAccountSubscriber {
+    constructor(userAccountPublicKey, data, slot) {
+        this.isSubscribed = true;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.userAccountPublicKey = userAccountPublicKey;
+        this.user = { data, slot };
+    }
+    async subscribe(_userAccount) {
+        return true;
+    }
+    async addToAccountLoader() { }
+    async fetch() { }
+    doesAccountExist() {
+        return this.user !== undefined;
+    }
+    async unsubscribe() { }
+    assertIsSubscribed() { }
+    getUserAccountAndSlot() {
+        return this.user;
+    }
+    updateData(userAccount, slot) {
+        this.user = { data: userAccount, slot };
+        this.eventEmitter.emit('userAccountUpdate', userAccount);
+        this.eventEmitter.emit('update');
+    }
+}
+exports.MockUserAccountSubscriber = MockUserAccountSubscriber;

package/lib/constants/perpMarkets.js

@@ -124,6 +124,16 @@ exports.DevnetPerpMarkets = [
         launchTs: 1683125906000,
         oracleSource: __1.OracleSource.PYTH,
     },
+    {
+        fullName: 'RNDR',
+        category: ['Infra'],
+        symbol: 'RNDR-PERP',
+        baseAssetSymbol: 'RNDR',
+        marketIndex: 12,
+        oracle: new web3_js_1.PublicKey('C2QvUPBiU3fViSyqA4nZgGyYqLgYf9PRpd8B8oLoo48w'),
+        launchTs: 1683125906000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
 ];
 exports.MainnetPerpMarkets = [
     {
@@ -246,6 +256,16 @@ exports.MainnetPerpMarkets = [
         launchTs: 1683125906000,
         oracleSource: __1.OracleSource.PYTH,
     },
+    {
+        fullName: 'RNDR',
+        category: ['Infra'],
+        symbol: 'RNDR-PERP',
+        baseAssetSymbol: 'RNDR',
+        marketIndex: 12,
+        oracle: new web3_js_1.PublicKey('CYGfrBJB9HgLf9iZyN4aH5HvUAi2htQ4MjPxeXMf4Egn'),
+        launchTs: 1683125906000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
 ];
 exports.PerpMarkets = {
     devnet: exports.DevnetPerpMarkets,

package/lib/dlob/orderBookLevels.js

@@ -92,7 +92,7 @@ function getVammL2Generator({ marketAccount, oraclePriceData, numOrders, now, })
         pegMultiplier: updatedAmm.pegMultiplier,
     };
     const getL2Bids = function* () {
-        while (numBids < numOrders) {
+        while (numBids < numOrders && baseSize.gt(__1.ZERO)) {
             const [afterSwapQuoteReserves, afterSwapBaseReserves] = (0, __1.calculateAmmReservesAfterSwap)(bidAmm, 'base', baseSize, __1.SwapDirection.ADD);
             const quoteSwapped = (0, __1.calculateQuoteAssetAmountSwapped)(bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), bidAmm.pegMultiplier, __1.SwapDirection.ADD);
             const price = quoteSwapped.mul(__1.BASE_PRECISION).div(baseSize);
@@ -115,7 +115,7 @@ function getVammL2Generator({ marketAccount, oraclePriceData, numOrders, now, })
         pegMultiplier: updatedAmm.pegMultiplier,
     };
     const getL2Asks = function* () {
-        while (numAsks < numOrders) {
+        while (numAsks < numOrders && askSize.gt(__1.ZERO)) {
             const [afterSwapQuoteReserves, afterSwapBaseReserves] = (0, __1.calculateAmmReservesAfterSwap)(askAmm, 'base', askSize, __1.SwapDirection.REMOVE);
             const quoteSwapped = (0, __1.calculateQuoteAssetAmountSwapped)(askAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), askAmm.pegMultiplier, __1.SwapDirection.REMOVE);
             const price = quoteSwapped.mul(__1.BASE_PRECISION).div(askSize);

package/lib/driftClient.d.ts

@@ -14,11 +14,12 @@ import { User } from './user';
 import { UserSubscriptionConfig } from './userConfig';
 import { UserStats } from './userStats';
 import { JupiterClient, Route, SwapMode } from './jupiter/jupiterClient';
+import { UserStatsSubscriptionConfig } from './userStatsConfig';
 type RemainingAccountParams = {
     userAccounts: UserAccount[];
     writablePerpMarketIndexes?: number[];
     writableSpotMarketIndexes?: number[];
-    readablePerpMarketIndex?: number;
+    readablePerpMarketIndex?: number | number[];
     readableSpotMarketIndexes?: number[];
     useMarketLastSlotCache?: boolean;
 };
@@ -36,12 +37,15 @@ export declare class DriftClient {
     userStats?: UserStats;
     activeSubAccountId: number;
     userAccountSubscriptionConfig: UserSubscriptionConfig;
+    userStatsAccountSubscriptionConfig: UserStatsSubscriptionConfig;
     accountSubscriber: DriftClientAccountSubscriber;
     eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
     _isSubscribed: boolean;
     txSender: TxSender;
     perpMarketLastSlotCache: Map<number, number>;
     spotMarketLastSlotCache: Map<number, number>;
+    mustIncludePerpMarketIndexes: Set<number>;
+    mustIncludeSpotMarketIndexes: Set<number>;
     authority: PublicKey;
     marketLookupTable: PublicKey;
     lookupTableAccount: AddressLookupTableAccount;
@@ -49,6 +53,7 @@ export declare class DriftClient {
     authoritySubAccountMap?: Map<string, number[]>;
     skipLoadUsers?: boolean;
     txVersion: TransactionVersion;
+    txParams: TxParams;
     get isSubscribed(): boolean;
     set isSubscribed(val: boolean);
     constructor(config: DriftClientConfig);
@@ -111,6 +116,7 @@ export declare class DriftClient {
     initializeReferrerName(name: string): Promise<TransactionSignature>;
     updateUserName(name: string, subAccountId?: number): Promise<TransactionSignature>;
     updateUserCustomMarginRatio(marginRatio: number, subAccountId?: number): Promise<TransactionSignature>;
+    getUpdateUserMarginTradingEnabledIx(marginTradingEnabled: boolean, subAccountId?: number, userAccountPublicKey?: PublicKey): Promise<TransactionInstruction>;
     updateUserMarginTradingEnabled(marginTradingEnabled: boolean, subAccountId?: number): Promise<TransactionSignature>;
     updateUserDelegate(delegate: PublicKey, subAccountId?: number): Promise<TransactionSignature>;
     fetchAllUserAccounts(includeIdle?: boolean): Promise<ProgramAccount<UserAccount>[]>;
@@ -121,6 +127,7 @@ export declare class DriftClient {
     getReferrerNameAccountsForAuthority(authority: PublicKey): Promise<ReferrerNameAccount[]>;
     deleteUser(subAccountId?: number, txParams?: TxParams): Promise<TransactionSignature>;
     getUser(subAccountId?: number, authority?: PublicKey): User;
+    hasUser(subAccountId?: number, authority?: PublicKey): boolean;
     getUsers(): User[];
     getUserStats(): UserStats;
     fetchReferrerNameAccount(name: string): Promise<ReferrerNameAccount | undefined>;
@@ -158,7 +165,20 @@ export declare class DriftClient {
      * @param amount
      */
     convertToPricePrecision(amount: BN | number): BN;
+    /**
+     * Each drift instruction must include perp and sport market accounts in the ix remaining accounts.
+     * Use this function to force a subset of markets to be included in the remaining accounts for every ix
+     *
+     * @param perpMarketIndexes
+     * @param spotMarketIndexes
+     */
+    mustIncludeMarketsInIx({ perpMarketIndexes, spotMarketIndexes, }: {
+        perpMarketIndexes: number[];
+        spotMarketIndexes: number[];
+    }): void;
     getRemainingAccounts(params: RemainingAccountParams): AccountMeta[];
+    addPerpMarketToRemainingAccountMaps(marketIndex: number, writable: boolean, oracleAccountMap: Map<string, AccountMeta>, spotMarketAccountMap: Map<number, AccountMeta>, perpMarketAccountMap: Map<number, AccountMeta>): void;
+    addSpotMarketToRemainingAccountMaps(marketIndex: number, writable: boolean, oracleAccountMap: Map<string, AccountMeta>, spotMarketAccountMap: Map<number, AccountMeta>): void;
     getRemainingAccountMapsForUsers(userAccounts: UserAccount[]): {
         oracleAccountMap: Map<string, AccountMeta>;
         spotMarketAccountMap: Map<number, AccountMeta>;
@@ -185,10 +205,14 @@ export declare class DriftClient {
     deposit(amount: BN, marketIndex: number, associatedTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean): Promise<TransactionSignature>;
     getDepositInstruction(amount: BN, marketIndex: number, userTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean, userInitialized?: boolean): Promise<TransactionInstruction>;
     private checkIfAccountExists;
-    private getWrappedSolAccountCreationIxs;
+    getWrappedSolAccountCreationIxs(amount: BN, includeRent?: boolean): Promise<{
+        ixs: anchor.web3.TransactionInstruction[];
+        signers: Signer[];
+        pubkey: PublicKey;
+    }>;
     getAssociatedTokenAccountCreationIx(tokenMintAddress: PublicKey, associatedTokenAddress: PublicKey): anchor.web3.TransactionInstruction;
     /**
-     * Creates the Clearing House User account for a user, and deposits some initial collateral
+     * Creates the User account for a user, and deposits some initial collateral
      * @param amount
      * @param userTokenAccount
      * @param marketIndex
@@ -228,6 +252,7 @@ export declare class DriftClient {
     getRemovePerpLpSharesIx(marketIndex: number, sharesToBurn?: BN): Promise<TransactionInstruction>;
     addPerpLpShares(amount: BN, marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     getAddPerpLpSharesIx(amount: BN, marketIndex: number): Promise<TransactionInstruction>;
+    getQuoteValuePerLpShare(marketIndex: number): BN;
     /**
      * @deprecated use {@link placePerpOrder} or {@link placeAndTakePerpOrder} instead
      */
@@ -266,6 +291,8 @@ export declare class DriftClient {
         marketIndex?: number;
         direction?: PositionDirection;
     }, placeOrderParams: OrderParams[], txParams?: TxParams): Promise<TransactionSignature>;
+    placeOrders(params: OrderParams[], txParams?: TxParams): Promise<TransactionSignature>;
+    getPlaceOrdersIx(params: OrderParams[]): Promise<TransactionInstruction>;
     fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
     getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     getRevertFillIx(): Promise<TransactionInstruction>;
@@ -301,6 +328,22 @@ export declare class DriftClient {
         reduceOnly?: SwapReduceOnly;
         txParams?: TxParams;
     }): Promise<TransactionSignature>;
+    getJupiterSwapIx({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, userAccountPublicKey, }: {
+        jupiterClient: JupiterClient;
+        outMarketIndex: number;
+        inMarketIndex: number;
+        outAssociatedTokenAccount?: PublicKey;
+        inAssociatedTokenAccount?: PublicKey;
+        amount: BN;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        route?: Route;
+        reduceOnly?: SwapReduceOnly;
+        userAccountPublicKey?: PublicKey;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        lookupTables: AddressLookupTableAccount[];
+    }>;
     /**
      * Get the drift begin_swap and end_swap instructions
      *
@@ -310,8 +353,10 @@ export declare class DriftClient {
      * @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
+     * @param reduceOnly
+     * @param userAccountPublicKey optional, specify a custom userAccountPublicKey to use instead of getting the current user account; can be helpful if the account is being created within the current tx
      */
-    getSwapIx({ outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, }: {
+    getSwapIx({ outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, userAccountPublicKey, }: {
         outMarketIndex: number;
         inMarketIndex: number;
         amountIn: BN;
@@ -319,10 +364,18 @@ export declare class DriftClient {
         outTokenAccount: PublicKey;
         limitPrice?: BN;
         reduceOnly?: SwapReduceOnly;
+        userAccountPublicKey?: PublicKey;
     }): Promise<{
         beginSwapIx: TransactionInstruction;
         endSwapIx: TransactionInstruction;
     }>;
+    stakeForMSOL({ amount }: {
+        amount: BN;
+    }): Promise<TxSigAndSlot>;
+    getStakeForMSOLIx({ amount, userAccountPublicKey, }: {
+        amount: BN;
+        userAccountPublicKey?: PublicKey;
+    }): Promise<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>;