@drift-labs/sdk 2.26.0-beta.1 → 2.26.0-beta.2

package/lib/dlob/DLOB.d.ts

@@ -1,8 +1,8 @@
 import { NodeList } from './NodeList';
-import { MarketType, BN, DriftClient, Order, SpotMarketAccount, PerpMarketAccount, OraclePriceData, SlotSubscriber, MarketTypeStr, StateAccount, UserMap, OrderRecord, OrderActionRecord } from '..';
+import { BN, DLOBNode, DLOBNodeType, DriftClient, MarketType, MarketTypeStr, OraclePriceData, Order, OrderActionRecord, OrderRecord, PerpMarketAccount, SlotSubscriber, SpotMarketAccount, StateAccount, TriggerOrderNode, UserMap } from '..';
 import { PublicKey } from '@solana/web3.js';
-import { DLOBNode, DLOBNodeType, TriggerOrderNode } from '..';
 import { DLOBOrders } from './DLOBOrders';
+import { L2OrderBook, L2OrderBookGenerator, L3OrderBook } from './orderBookLevels';
 export type MarketNodeLists = {
     restingLimit: {
         ask: NodeList<'restingLimit'>;
@@ -99,5 +99,41 @@ export declare class DLOB {
     printTopOfOrderLists(sdkConfig: any, driftClient: DriftClient, slotSubscriber: SlotSubscriber, marketIndex: number, marketType: MarketType): void;
     getDLOBOrders(): DLOBOrders;
     getNodeLists(): Generator<NodeList<DLOBNodeType>>;
+    /**
+     * Get an L2 view of the order book for a given market.
+     *
+     * @param marketIndex
+     * @param marketType
+     * @param slot
+     * @param oraclePriceData
+     * @param depth how many levels of the order book to return
+     * @param fallbackAsk best ask for fallback liquidity, only relevant for perps
+     * @param fallbackBid best bid for fallback liquidity, only relevant for perps
+     * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
+     */
+    getL2({ marketIndex, marketType, slot, oraclePriceData, depth, fallbackAsk, fallbackBid, fallbackL2Generators, }: {
+        marketIndex: number;
+        marketType: MarketType;
+        slot: number;
+        oraclePriceData: OraclePriceData;
+        depth: number;
+        fallbackAsk?: BN;
+        fallbackBid?: BN;
+        fallbackL2Generators?: L2OrderBookGenerator[];
+    }): L2OrderBook;
+    /**
+     * Get an L3 view of the order book for a given market. Does not include fallback liquidity sources
+     *
+     * @param marketIndex
+     * @param marketType
+     * @param slot
+     * @param oraclePriceData
+     */
+    getL3({ marketIndex, marketType, slot, oraclePriceData, }: {
+        marketIndex: number;
+        marketType: MarketType;
+        slot: number;
+        oraclePriceData: OraclePriceData;
+    }): L3OrderBook;
 }
 export {};

package/lib/dlob/DLOB.js

@@ -4,6 +4,7 @@ exports.DLOB = void 0;
 const NodeList_1 = require("./NodeList");
 const __1 = require("..");
 const exchangeStatus_1 = require("../math/exchangeStatus");
+const orderBookLevels_1 = require("./orderBookLevels");
 const SUPPORTED_ORDER_TYPES = [
     'market',
     'limit',
@@ -954,5 +955,73 @@ class DLOB {
             yield nodeLists.trigger.below;
         }
     }
+    /**
+     * Get an L2 view of the order book for a given market.
+     *
+     * @param marketIndex
+     * @param marketType
+     * @param slot
+     * @param oraclePriceData
+     * @param depth how many levels of the order book to return
+     * @param fallbackAsk best ask for fallback liquidity, only relevant for perps
+     * @param fallbackBid best bid for fallback liquidity, only relevant for perps
+     * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
+     */
+    getL2({ marketIndex, marketType, slot, oraclePriceData, depth, fallbackAsk, fallbackBid, fallbackL2Generators = [], }) {
+        const makerAskL2LevelGenerator = (0, orderBookLevels_1.getL2GeneratorFromDLOBNodes)(this.getMakerLimitAsks(marketIndex, slot, marketType, oraclePriceData, fallbackBid), oraclePriceData, slot);
+        const fallbackAskGenerators = fallbackL2Generators.map((fallbackL2Generator) => {
+            return fallbackL2Generator.getL2Asks();
+        });
+        const askL2LevelGenerator = (0, orderBookLevels_1.mergeL2LevelGenerators)([makerAskL2LevelGenerator, ...fallbackAskGenerators], (a, b) => {
+            return a.price.lt(b.price);
+        });
+        const asks = (0, orderBookLevels_1.createL2Levels)(askL2LevelGenerator, depth);
+        const makerBidGenerator = (0, orderBookLevels_1.getL2GeneratorFromDLOBNodes)(this.getMakerLimitBids(marketIndex, slot, marketType, oraclePriceData, fallbackAsk), oraclePriceData, slot);
+        const fallbackBidGenerators = fallbackL2Generators.map((fallbackOrders) => {
+            return fallbackOrders.getL2Bids();
+        });
+        const bidL2LevelGenerator = (0, orderBookLevels_1.mergeL2LevelGenerators)([makerBidGenerator, ...fallbackBidGenerators], (a, b) => {
+            return a.price.gt(b.price);
+        });
+        const bids = (0, orderBookLevels_1.createL2Levels)(bidL2LevelGenerator, depth);
+        return {
+            bids,
+            asks,
+        };
+    }
+    /**
+     * Get an L3 view of the order book for a given market. Does not include fallback liquidity sources
+     *
+     * @param marketIndex
+     * @param marketType
+     * @param slot
+     * @param oraclePriceData
+     */
+    getL3({ marketIndex, marketType, slot, oraclePriceData, }) {
+        const bids = [];
+        const asks = [];
+        const restingAsks = this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData);
+        for (const ask of restingAsks) {
+            asks.push({
+                price: ask.getPrice(oraclePriceData, slot),
+                size: ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled),
+                maker: ask.userAccount,
+                orderId: ask.order.orderId,
+            });
+        }
+        const restingBids = this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData);
+        for (const bid of restingBids) {
+            bids.push({
+                price: bid.getPrice(oraclePriceData, slot),
+                size: bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled),
+                maker: bid.userAccount,
+                orderId: bid.order.orderId,
+            });
+        }
+        return {
+            bids,
+            asks,
+        };
+    }
 }
 exports.DLOB = DLOB;

package/lib/dlob/DLOBApiClient.js

@@ -16,7 +16,7 @@ class DLOBApiClient {
     async getDLOB(slot) {
         const r = await (0, node_fetch_1.default)(this.url);
         if (!r.ok) {
-            throw new Error(`Failed to fetch DLOB from ${this.url}`);
+            throw new Error(`Failed to fetch DLOB from ${this.url}. Status: ${r.status}, ${r.statusText}`);
         }
         const resp = await r.json();
         const responseSlot = resp['slot'];

package/lib/dlob/DLOBSubscriber.d.ts

@@ -4,7 +4,11 @@ import { DLOB } from './DLOB';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { DLOBSource, DLOBSubscriberEvents, DLOBSubscriptionConfig, SlotSource } from './types';
+import { DriftClient } from '../driftClient';
+import { MarketType } from '../types';
+import { L2OrderBook, L2OrderBookGenerator, L3OrderBook } from './orderBookLevels';
 export declare class DLOBSubscriber {
+    driftClient: DriftClient;
     dlobSource: DLOBSource;
     slotSource: SlotSource;
     updateFrequency: number;
@@ -15,5 +19,35 @@ export declare class DLOBSubscriber {
     subscribe(): Promise<void>;
     updateDLOB(): Promise<void>;
     getDLOB(): DLOB;
+    /**
+     * Get the L2 order book for a given market.
+     *
+     * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+     * @param marketIndex
+     * @param marketType
+     * @param depth Number of orders to include in the order book. Defaults to 10.
+     * @param includeVamm Whether to include the VAMM orders in the order book. Defaults to false. If true, creates vAMM generator {@link getVammL2Generator} and adds it to fallbackL2Generators.
+     * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
+     */
+    getL2({ marketName, marketIndex, marketType, depth, includeVamm, fallbackL2Generators, }: {
+        marketName?: string;
+        marketIndex?: number;
+        marketType?: MarketType;
+        depth?: number;
+        includeVamm?: boolean;
+        fallbackL2Generators?: L2OrderBookGenerator[];
+    }): L2OrderBook;
+    /**
+     * Get the L3 order book for a given market.
+     *
+     * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+     * @param marketIndex
+     * @param marketType
+     */
+    getL3({ marketName, marketIndex, marketType, }: {
+        marketName?: string;
+        marketIndex?: number;
+        marketType?: MarketType;
+    }): L3OrderBook;
     unsubscribe(): Promise<void>;
 }

package/lib/dlob/DLOBSubscriber.js

@@ -3,9 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DLOBSubscriber = void 0;
 const DLOB_1 = require("./DLOB");
 const events_1 = require("events");
+const types_1 = require("../types");
+const orderBookLevels_1 = require("./orderBookLevels");
+const market_1 = require("../math/market");
 class DLOBSubscriber {
     constructor(config) {
         this.dlob = new DLOB_1.DLOB();
+        this.driftClient = config.driftClient;
         this.dlobSource = config.dlobSource;
         this.slotSource = config.slotSource;
         this.updateFrequency = config.updateFrequency;
@@ -32,6 +36,102 @@ class DLOBSubscriber {
     getDLOB() {
         return this.dlob;
     }
+    /**
+     * Get the L2 order book for a given market.
+     *
+     * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+     * @param marketIndex
+     * @param marketType
+     * @param depth Number of orders to include in the order book. Defaults to 10.
+     * @param includeVamm Whether to include the VAMM orders in the order book. Defaults to false. If true, creates vAMM generator {@link getVammL2Generator} and adds it to fallbackL2Generators.
+     * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
+     */
+    getL2({ marketName, marketIndex, marketType, depth = 10, includeVamm = false, fallbackL2Generators = [], }) {
+        if (marketName) {
+            const derivedMarketInfo = this.driftClient.getMarketIndexAndType(marketName);
+            if (!derivedMarketInfo) {
+                throw new Error(`Market ${marketName} not found`);
+            }
+            marketIndex = derivedMarketInfo.marketIndex;
+            marketType = derivedMarketInfo.marketType;
+        }
+        else {
+            if (marketIndex === undefined || marketType === undefined) {
+                throw new Error('Either marketName or marketIndex and marketType must be provided');
+            }
+        }
+        let oraclePriceData;
+        let fallbackBid;
+        let fallbackAsk;
+        const isPerp = (0, types_1.isVariant)(marketType, 'perp');
+        if (isPerp) {
+            const perpMarketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
+            oraclePriceData = this.driftClient.getOraclePriceDataAndSlot(perpMarketAccount.amm.oracle);
+            fallbackBid = (0, market_1.calculateBidPrice)(perpMarketAccount, oraclePriceData);
+            fallbackAsk = (0, market_1.calculateAskPrice)(perpMarketAccount, oraclePriceData);
+        }
+        else {
+            oraclePriceData =
+                this.driftClient.getOracleDataForSpotMarket(marketIndex);
+        }
+        if (isPerp && includeVamm) {
+            fallbackL2Generators = [
+                (0, orderBookLevels_1.getVammL2Generator)({
+                    marketAccount: this.driftClient.getPerpMarketAccount(marketIndex),
+                    oraclePriceData,
+                    numOrders: depth,
+                }),
+            ];
+        }
+        return this.dlob.getL2({
+            marketIndex,
+            marketType,
+            depth,
+            oraclePriceData,
+            slot: this.slotSource.getSlot(),
+            fallbackBid,
+            fallbackAsk,
+            fallbackL2Generators: fallbackL2Generators,
+        });
+    }
+    /**
+     * Get the L3 order book for a given market.
+     *
+     * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+     * @param marketIndex
+     * @param marketType
+     */
+    getL3({ marketName, marketIndex, marketType, }) {
+        if (marketName) {
+            const derivedMarketInfo = this.driftClient.getMarketIndexAndType(marketName);
+            if (!derivedMarketInfo) {
+                throw new Error(`Market ${marketName} not found`);
+            }
+            marketIndex = derivedMarketInfo.marketIndex;
+            marketType = derivedMarketInfo.marketType;
+        }
+        else {
+            if (marketIndex === undefined || marketType === undefined) {
+                throw new Error('Either marketName or marketIndex and marketType must be provided');
+            }
+        }
+        let oraclePriceData;
+        const isPerp = (0, types_1.isVariant)(marketType, 'perp');
+        if (isPerp) {
+            oraclePriceData =
+                this.driftClient.getOracleDataForPerpMarket(marketIndex);
+        }
+        else {
+            oraclePriceData =
+                this.driftClient.getOracleDataForSpotMarket(marketIndex);
+        }
+        return this.dlob.getL3({
+            marketIndex,
+            marketType,
+            oraclePriceData,
+            slot: this.slotSource.getSlot(),
+        });
+    }
     async unsubscribe() {
         if (this.intervalId) {
             clearInterval(this.intervalId);

package/lib/dlob/orderBookLevels.d.ts

@@ -0,0 +1,44 @@
+import { BN, DLOBNode, OraclePriceData, PerpMarketAccount } from '..';
+import { PublicKey } from '@solana/web3.js';
+type liquiditySource = 'serum' | 'vamm' | 'dlob';
+export type L2Level = {
+    price: BN;
+    size: BN;
+    sources: {
+        [key in liquiditySource]?: BN;
+    };
+};
+export type L2OrderBook = {
+    asks: L2Level[];
+    bids: L2Level[];
+};
+export interface L2OrderBookGenerator {
+    getL2Asks(): Generator<L2Level>;
+    getL2Bids(): Generator<L2Level>;
+}
+export type L3Level = {
+    price: BN;
+    size: BN;
+    maker: PublicKey;
+    orderId: number;
+};
+export type L3OrderBook = {
+    asks: L3Level[];
+    bids: L3Level[];
+};
+/**
+ * Get an {@link Generator<L2Level>} generator from a {@link Generator<DLOBNode>}
+ * @param dlobNodes e.g. {@link DLOB#getMakerLimitAsks} or {@link DLOB#getMakerLimitBids}
+ * @param oraclePriceData
+ * @param slot
+ */
+export declare function getL2GeneratorFromDLOBNodes(dlobNodes: Generator<DLOBNode>, oraclePriceData: OraclePriceData, slot: number): Generator<L2Level>;
+export declare function mergeL2LevelGenerators(l2LevelGenerators: Generator<L2Level>[], compare: (a: L2Level, b: L2Level) => boolean): Generator<L2Level>;
+export declare function createL2Levels(generator: Generator<L2Level>, depth: number): L2Level[];
+export declare function getVammL2Generator({ marketAccount, oraclePriceData, numOrders, now, }: {
+    marketAccount: PerpMarketAccount;
+    oraclePriceData: OraclePriceData;
+    numOrders: number;
+    now?: BN;
+}): L2OrderBookGenerator;
+export {};

package/lib/dlob/orderBookLevels.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVammL2Generator = exports.createL2Levels = exports.mergeL2LevelGenerators = exports.getL2GeneratorFromDLOBNodes = void 0;
+const __1 = require("..");
+/**
+ * Get an {@link Generator<L2Level>} generator from a {@link Generator<DLOBNode>}
+ * @param dlobNodes e.g. {@link DLOB#getMakerLimitAsks} or {@link DLOB#getMakerLimitBids}
+ * @param oraclePriceData
+ * @param slot
+ */
+function* getL2GeneratorFromDLOBNodes(dlobNodes, oraclePriceData, slot) {
+    for (const dlobNode of dlobNodes) {
+        const size = dlobNode.order.baseAssetAmount.sub(dlobNode.order.baseAssetAmountFilled);
+        yield {
+            size,
+            price: dlobNode.getPrice(oraclePriceData, slot),
+            sources: {
+                dlob: size,
+            },
+        };
+    }
+}
+exports.getL2GeneratorFromDLOBNodes = getL2GeneratorFromDLOBNodes;
+function* mergeL2LevelGenerators(l2LevelGenerators, compare) {
+    const generators = l2LevelGenerators.map((generator) => {
+        return {
+            generator,
+            next: generator.next(),
+        };
+    });
+    let next;
+    do {
+        next = generators.reduce((best, next) => {
+            if (next.next.done) {
+                return best;
+            }
+            if (!best) {
+                return next;
+            }
+            if (compare(next.next.value, best.next.value)) {
+                return next;
+            }
+            else {
+                return best;
+            }
+        }, undefined);
+        if (next) {
+            yield next.next.value;
+            next.next = next.generator.next();
+        }
+    } while (next !== undefined);
+}
+exports.mergeL2LevelGenerators = mergeL2LevelGenerators;
+function createL2Levels(generator, depth) {
+    const levels = [];
+    for (const level of generator) {
+        const price = level.price;
+        const size = level.size;
+        if (levels.length > 0 && levels[levels.length - 1].price.eq(price)) {
+            const currentLevel = levels[levels.length - 1];
+            currentLevel.size.add(size);
+            for (const [source, size] of Object.entries(level.sources)) {
+                if (currentLevel.sources[source]) {
+                    currentLevel.sources[source] = currentLevel.sources[source].add(size);
+                }
+                else {
+                    currentLevel.sources[source] = size;
+                }
+            }
+        }
+        else if (levels.length === depth) {
+            break;
+        }
+        else {
+            levels.push(level);
+        }
+    }
+    return levels;
+}
+exports.createL2Levels = createL2Levels;
+function getVammL2Generator({ marketAccount, oraclePriceData, numOrders, now, }) {
+    const updatedAmm = (0, __1.calculateUpdatedAMM)(marketAccount.amm, oraclePriceData);
+    const [openBids, openAsks] = (0, __1.calculateMarketOpenBidAsk)(updatedAmm.baseAssetReserve, updatedAmm.minBaseAssetReserve, updatedAmm.maxBaseAssetReserve, updatedAmm.orderStepSize);
+    now = now !== null && now !== void 0 ? now : new __1.BN(Date.now() / 1000);
+    const [bidReserves, askReserves] = (0, __1.calculateSpreadReserves)(updatedAmm, oraclePriceData, now);
+    let numBids = 0;
+    const baseSize = openBids.div(new __1.BN(numOrders));
+    const bidAmm = {
+        baseAssetReserve: bidReserves.baseAssetReserve,
+        quoteAssetReserve: bidReserves.quoteAssetReserve,
+        sqrtK: updatedAmm.sqrtK,
+        pegMultiplier: updatedAmm.pegMultiplier,
+    };
+    const getL2Bids = function* () {
+        while (numBids < numOrders) {
+            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);
+            bidAmm.baseAssetReserve = afterSwapBaseReserves;
+            bidAmm.quoteAssetReserve = afterSwapQuoteReserves;
+            yield {
+                price,
+                size: baseSize,
+                sources: { vamm: baseSize },
+            };
+            numBids++;
+        }
+    };
+    let numAsks = 0;
+    const askSize = openAsks.abs().div(new __1.BN(numOrders));
+    const askAmm = {
+        baseAssetReserve: askReserves.baseAssetReserve,
+        quoteAssetReserve: askReserves.quoteAssetReserve,
+        sqrtK: updatedAmm.sqrtK,
+        pegMultiplier: updatedAmm.pegMultiplier,
+    };
+    const getL2Asks = function* () {
+        while (numAsks < numOrders) {
+            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);
+            askAmm.baseAssetReserve = afterSwapBaseReserves;
+            askAmm.quoteAssetReserve = afterSwapQuoteReserves;
+            yield {
+                price,
+                size: askSize,
+                sources: { vamm: baseSize },
+            };
+            numAsks++;
+        }
+    };
+    return {
+        getL2Bids,
+        getL2Asks,
+    };
+}
+exports.getVammL2Generator = getVammL2Generator;

package/lib/dlob/types.d.ts

@@ -1,5 +1,7 @@
 import { DLOB } from './DLOB';
+import { DriftClient } from '../driftClient';
 export type DLOBSubscriptionConfig = {
+    driftClient: DriftClient;
     dlobSource: DLOBSource;
     slotSource: SlotSource;
     updateFrequency: number;

package/lib/driftClient.d.ts

@@ -31,9 +31,10 @@ export declare class DriftClient {
     program: Program;
     provider: AnchorProvider;
     opts?: ConfirmOptions;
-    users: Map<number, User>;
+    users: Map<string, User>;
     userStats?: UserStats;
     activeSubAccountId: number;
+    activeAuthority: PublicKey;
     userAccountSubscriptionConfig: UserSubscriptionConfig;
     accountSubscriber: DriftClientAccountSubscriber;
     eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
@@ -44,11 +45,14 @@ export declare class DriftClient {
     authority: PublicKey;
     marketLookupTable: PublicKey;
     lookupTableAccount: AddressLookupTableAccount;
+    includeDelegates?: boolean;
+    authoritySubaccountMap?: Map<string, number[]>;
+    skipLoadUsers?: boolean;
     get isSubscribed(): boolean;
     set isSubscribed(val: boolean);
     constructor(config: DriftClientConfig);
-    createUsers(subAccountIds: number[], accountSubscriptionConfig: UserSubscriptionConfig): void;
-    createUser(subAccountId: number, accountSubscriptionConfig: UserSubscriptionConfig): User;
+    getUserMapKey(subAccountId: number, authority: PublicKey): string;
+    createUser(subAccountId: number, accountSubscriptionConfig: UserSubscriptionConfig, authority?: PublicKey): User;
     subscribe(): Promise<boolean>;
     subscribeUsers(): Promise<boolean>[];
     /**
@@ -90,11 +94,15 @@ export declare class DriftClient {
      * @param newWallet
      * @param subAccountIds
      * @param activeSubAccountId
+     * @param includeDelegates
      */
-    updateWallet(newWallet: IWallet, subAccountIds?: number[], activeSubAccountId?: number): Promise<void>;
-    switchActiveUser(subAccountId: number): void;
-    addUser(subAccountId: number): Promise<void>;
-    addAllUsers(): Promise<void>;
+    updateWallet(newWallet: IWallet, subAccountIds?: number[], activeSubAccountId?: number, includeDelegates?: boolean, authoritySubaccountMap?: Map<string, number[]>): Promise<boolean>;
+    switchActiveUser(subAccountId: number, authority?: PublicKey): void;
+    addUser(subAccountId: number, authority?: PublicKey): Promise<boolean>;
+    /**
+     * Adds and subscribes to users based on params set by the constructor or by updateWallet.
+     */
+    addAndSubscribeToUsers(): Promise<boolean>;
     initializeUserAccount(subAccountId?: number, name?: string, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
     getInitializeUserInstructions(subAccountId?: number, name?: string, referrerInfo?: ReferrerInfo): Promise<[PublicKey, TransactionInstruction]>;
     getInitializeUserStatsIx(): Promise<TransactionInstruction>;
@@ -110,14 +118,14 @@ export declare class DriftClient {
     getReferredUserStatsAccountsByReferrer(referrer: PublicKey): Promise<UserStatsAccount[]>;
     getReferrerNameAccountsForAuthority(authority: PublicKey): Promise<ReferrerNameAccount[]>;
     deleteUser(subAccountId?: number, txParams?: TxParams): Promise<TransactionSignature>;
-    getUser(subAccountId?: number): User;
+    getUser(subAccountId?: number, authority?: PublicKey): User;
     getUsers(): User[];
     getUserStats(): UserStats;
     fetchReferrerNameAccount(name: string): Promise<ReferrerNameAccount | undefined>;
     userStatsAccountPublicKey: PublicKey;
     getUserStatsAccountPublicKey(): PublicKey;
-    getUserAccountPublicKey(): Promise<PublicKey>;
-    getUserAccount(subAccountId?: number): UserAccount | undefined;
+    getUserAccountPublicKey(subAccountId?: number, authority?: PublicKey): Promise<PublicKey>;
+    getUserAccount(subAccountId?: number, authority?: PublicKey): UserAccount | undefined;
     /**
      * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
      * @param subAccountId
@@ -373,6 +381,16 @@ export declare class DriftClient {
     resolvePerpPnlDeficit(spotMarketIndex: number, perpMarketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     getResolvePerpPnlDeficitIx(spotMarketIndex: number, perpMarketIndex: number): Promise<TransactionInstruction>;
     getPerpMarketExtendedInfo(marketIndex: number): PerpMarketExtendedInfo;
+    /**
+     * Returns the market index and type for a given market name
+     * E.g. "SOL-PERP" -> { marketIndex: 0, marketType: MarketType.PERP }
+     *
+     * @param name
+     */
+    getMarketIndexAndType(name: string): {
+        marketIndex: number;
+        marketType: MarketType;
+    } | undefined;
     sendTransaction(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
 }
 export {};