Markets, Oracles, and Positions

These are the most common read-path helpers you’ll use to power bots, dashboards, and risk logic.

Market accounts


const marketIndex = 0;
const spotMarket = driftClient.getSpotMarketAccount(marketIndex);
console.log(spotMarket?.marketIndex);

Method DriftClient.getSpotMarketAccountReference ↗

Parameters:

Name	Type	Default
`marketIndex`	`number`

Returns:

SpotMarketAccount | undefined


const marketIndex = 0;
const perpMarket = driftClient.getPerpMarketAccount(marketIndex);
console.log(perpMarket?.marketIndex);

Method DriftClient.getPerpMarketAccountReference ↗

Parameters:

Name	Type	Default
`marketIndex`	`number`

Returns:

PerpMarketAccount | undefined


const spotMarkets = driftClient.getSpotMarketAccounts();
console.log(spotMarkets.length);

Method DriftClient.getSpotMarketAccountsReference ↗

Parameters:

This function does not accept any parameters.

Returns:

SpotMarketAccount[]


const perpMarkets = driftClient.getPerpMarketAccounts();
console.log(perpMarkets.length);

Method DriftClient.getPerpMarketAccountsReference ↗

Parameters:

This function does not accept any parameters.

Returns:

PerpMarketAccount[]

Oracle price


const marketIndex = 0;
const oracle = driftClient.getOracleDataForPerpMarket(marketIndex);
console.log(oracle.price.toString());

Method DriftClient.getOracleDataForPerpMarketReference ↗

Parameters:

Name	Type	Default
`marketIndex`	`number`

Returns:

OraclePriceData


const marketIndex = 0;
const oracle = driftClient.getOracleDataForSpotMarket(marketIndex);
console.log(oracle.price.toString());

Method DriftClient.getOracleDataForSpotMarketReference ↗

Parameters:

Name	Type	Default
`marketIndex`	`number`

Returns:

OraclePriceData


const marketIndex = 0;
const oracle = driftClient.getMMOracleDataForPerpMarket(marketIndex);
console.log(oracle.price.toString());

Method DriftClient.getMMOracleDataForPerpMarketReference ↗

Parameters:

Name	Type	Default
`marketIndex`	`number`

Returns:

MMOraclePriceData

Positions and balances


const spotPosition = driftClient.getSpotPosition(0);
console.log(spotPosition);

Method DriftClient.getSpotPositionReference ↗

Parameters:

Name	Type	Default
`marketIndex`	`number`
`subAccountId`	`number`

Returns:

SpotPosition | undefined


const perpPosition = driftClient.getPerpPosition(0);
console.log(perpPosition);

Method DriftClient.getPerpPositionReference ↗

TypeScript docs unavailable for getPerpPosition.

Protocol state


const state = driftClient.getStateAccount();
console.log(state);

Method DriftClient.getStateAccountReference ↗

Parameters:

This function does not accept any parameters.

Returns:

StateAccount

Orderbook & DLOB (local)


import { OrderSubscriber } from "@drift-labs/sdk";

Class OrderSubscriberReference ↗

Name	Type	Default
`driftClient`	`DriftClient`
`usersAccounts`	`Map<string, { slot: number; userAccount: UserAccount; }>`
`subscription`	`PollingSubscription \| WebsocketSubscription \| grpcSubscription`
`commitment`	`Commitment`
`eventEmitter`	`StrictEventEmitter<EventEmitter, OrderSubscriberEvents>`
`fetchPromise`	`Promise<void>`
`fetchPromiseResolver`	`() => void`
`mostRecentSlot`	`number`
`decodeFn`	`(name: string, data: Buffer) => UserAccount`
`decodeData`	`boolean`
`fetchAllNonIdleUsers`	`boolean`
`subscribe`	`() => Promise<void>`
`fetch`	`() => Promise<void>`
`tryUpdateUserAccount`	`(key: string, dataType: "raw" \| "decoded" \| "buffer", data: UserAccount \| Buffer \| string[], slot: number) => void`
`createDLOB`	`(protectedMakerParamsMap?: ProtectMakerParamsMap \| undefined) => DLOB` Creates a new DLOB for the order subscriber to fill. This will allow a caller to extend the DLOB Subscriber with a custom DLOB type.
`getDLOB`	`(slot: number, protectedMakerParamsMap?: ProtectMakerParamsMap \| undefined) => Promise<DLOB>`
`getSlot`	`() => number`
`addPubkey`	`(userAccountPublicKey: PublicKey) => Promise<void>`
`mustGetUserAccount`	`(key: string) => Promise<UserAccount>`
`unsubscribe`	`() => Promise<void>`


import { DLOBSubscriber } from "@drift-labs/sdk";

Class DLOBSubscriberReference ↗

Name	Type	Default
`driftClient`	`DriftClient`
`dlobSource`	`DLOBSource`
`slotSource`	`SlotSource`
`updateFrequency`	`number`
`intervalId`	`Timeout`
`dlob`	`DLOB`
`eventEmitter`	`StrictEventEmitter<EventEmitter, DLOBSubscriberEvents>`
`protectedMakerView`	`boolean`
`subscribe`	`() => Promise<void>`
`getProtectedMakerParamsMap`	`() => ProtectMakerParamsMap \| undefined`
`updateDLOB`	`() => Promise<void>`
`getDLOB`	`() => DLOB`
`getL2`	`({ marketName, marketIndex, marketType, depth, includeVamm, numVammOrders, fallbackL2Generators, latestSlot, }: { marketName?: string; marketIndex?: number; marketType?: MarketType; depth?: number; includeVamm?: boolean; numVammOrders?: number; fallbackL2Generators?: L2OrderBookGenerator[]; latestSlot?: any; }) => L...` Get the L2 order book for a given market.
`getL3`	`({ marketName, marketIndex, marketType, }: { marketName?: string; marketIndex?: number; marketType?: MarketType; }) => L3OrderBook` Get the L3 order book for a given market.
`unsubscribe`	`() => Promise<void>`


import { SlotSubscriber } from "@drift-labs/sdk";

Class SlotSubscriberReference ↗

Name	Type	Default
`connection`	`any`
`currentSlot`	`number`
`subscriptionId`	`number`
`eventEmitter`	`StrictEventEmitter<EventEmitter, SlotSubscriberEvents>`
`timeoutId`	`Timeout`
`resubTimeoutMs`	`number`
`isUnsubscribing`	`boolean`
`receivingData`	`boolean`
`subscribe`	`() => Promise<void>`
`updateCurrentSlot`	`any`
`setTimeout`	`any`
`getSlot`	`() => number`
`unsubscribe`	`(onResub?: boolean \| undefined) => Promise<void>`


const slotSubscriber = new SlotSubscriber(connection);
await slotSubscriber.subscribe();
 
const orderSubscriber = new OrderSubscriber({
  driftClient,
  subscriptionConfig: { type: "websocket" },
  fastDecode: true,
  decodeData: true,
});
await orderSubscriber.subscribe();
 
const dlobSubscriber = new DLOBSubscriber({
  driftClient,
  dlobSource: orderSubscriber,
  slotSource: slotSubscriber,
  updateFrequency: 1000,
});
await dlobSubscriber.subscribe();


import { DLOB } from "@drift-labs/sdk";

Class DLOBReference ↗

Name	Type	Default
`openOrders`	`Map<MarketTypeStr, Set<string>>`
`orderLists`	`Map<MarketTypeStr, Map<number, MarketNodeLists>>`
`maxSlotForRestingLimitOrders`	`number`
`initialized`	`boolean`
`protectedMakerParamsMap`	`ProtectMakerParamsMap`
`init`	`any`
`clear`	`() => void`
`initFromUserMap`	`(userMap: UserMap, slot: number) => Promise<boolean>` initializes a new DLOB instance
`insertOrder`	`(order: Order, userAccount: string, slot: number, isUserProtectedMaker: boolean, baseAssetAmount: BN, onInsert?: OrderBookCallback \| undefined) => void`
`insertSignedMsgOrder`	`(order: Order, userAccount: string, isUserProtectedMaker: boolean, baseAssetAmount?: any, onInsert?: OrderBookCallback \| undefined) => void`
`addOrderList`	`(marketType: MarketTypeStr, marketIndex: number) => void`
`delete`	`(order: Order, userAccount: PublicKey, slot: number, isUserProtectedMaker: boolean, onDelete?: OrderBookCallback \| undefined) => void`
`getListForOnChainOrder`	`(order: Order, slot: number, isProtectedMaker: boolean) => NodeList<any> \| undefined`
`updateRestingLimitOrders`	`(slot: number) => void`
`updateRestingLimitOrdersForMarketType`	`(slot: number, marketTypeStr: MarketTypeStr) => void`
`getOrder`	`(orderId: number, userAccount: PublicKey) => Order \| undefined`
`findNodesToFill`	`<T extends MarketType>(marketIndex: number, fallbackBid: any, fallbackAsk: any, slot: number, ts: number, marketType: T, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData, stateAccount: StateAccount, marketAccount: T extends { ...; } ? SpotMarketAccount : PerpMarketAccount) => NodeT...`
`getMakerRebate`	`(marketType: MarketType, stateAccount: StateAccount, marketAccount: SpotMarketAccount \| PerpMarketAccount) => { ...; }`
`mergeNodesToFill`	`(restingLimitOrderNodesToFill: NodeToFill[], takingOrderNodesToFill: NodeToFill[]) => NodeToFill[]`
`findRestingLimitOrderNodesToFill`	`<T extends MarketType>(marketIndex: number, slot: number, marketType: T, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData, isAmmPaused: boolean, stateAccount: StateAccount, marketAccount: T extends { ...; } ? SpotMarketAccount : PerpMarketAccount, makerRebateNumerator: number, make...`
`findTakingNodesToFill`	`<T extends MarketType>(marketIndex: number, slot: number, marketType: T, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData, isAmmPaused: boolean, state: StateAccount, marketAccount: T extends { ...; } ? SpotMarketAccount : PerpMarketAccount, fallbackAsk: any, fallbackBid?: any) => N...`
`findTakingNodesCrossingMakerNodes`	`<T extends MarketType>(marketIndex: number, slot: number, marketType: T, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData, takerNodeGenerator: Generator<...>, makerNodeGeneratorFn: (marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: T extends { ...; } ? Ora...`
`findNodesCrossingFallbackLiquidity`	`<T extends MarketType>(marketType: T, slot: number, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData, nodeGenerator: Generator<DLOBNode, any, any>, doesCross: (nodePrice: any) => boolean, state: StateAccount, marketAccount: T extends { ...; } ? SpotMarketAccount : PerpMarketAccount...`
`findExpiredNodesToFill`	`(marketIndex: number, ts: number, marketType: MarketType, slot?: any) => NodeToFill[]`
`findUnfillableReduceOnlyOrdersToCancel`	`(marketIndex: number, marketType: MarketType, stepSize: BN) => NodeToFill[]`
`getTakingBids`	`<T extends MarketType>(marketIndex: number, marketType: T, slot: number, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData, filterFcn?: DLOBFilterFcn \| undefined) => Generator<...>`
`getTakingAsks`	`<T extends MarketType>(marketIndex: number, marketType: T, slot: number, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData, filterFcn?: DLOBFilterFcn \| undefined) => Generator<...>`
`signedMsgGenerator`	`(signedMsgOrderList: NodeList<"signedMsg">, filter: (x: DLOBNode) => boolean) => Generator<DLOBNode, any, any>`
`getBestNode`	`<T extends MarketTypeStr>(generatorList: Generator<DLOBNode, any, any>[], oraclePriceData: T extends "spot" ? OraclePriceData : MMOraclePriceData, slot: number, compareFcn: (bestDLOBNode: DLOBNode, currentDLOBNode: DLOBNode, slot: number, oraclePriceData: T extends "spot" ? OraclePriceData : MMOraclePriceData) => bo...`
`getRestingLimitAsks`	`<T extends MarketType>(marketIndex: number, slot: number, marketType: T, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData, filterFcn?: DLOBFilterFcn \| undefined) => Generator<...>`
`getRestingLimitBids`	`<T extends MarketType>(marketIndex: number, slot: number, marketType: T, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData, filterFcn?: DLOBFilterFcn \| undefined) => Generator<...>`
`getAsks`	`<T extends MarketType>(marketIndex: number, _fallbackAsk: any, slot: number, marketType: T, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData, filterFcn?: DLOBFilterFcn \| undefined) => Generator<...>` This will look at both the taking and resting limit asks
`getBids`	`<T extends MarketType>(marketIndex: number, _fallbackBid: any, slot: number, marketType: T, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData, filterFcn?: DLOBFilterFcn \| undefined) => Generator<...>` This will look at both the taking and resting limit bids
`findCrossingRestingLimitOrders`	`<T extends MarketType>(marketIndex: number, slot: number, marketType: T, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData) => NodeToFill[]`
`determineMakerAndTaker`	`(askNode: DLOBNode, bidNode: DLOBNode) => { takerNode: DLOBNode; makerNode: DLOBNode; } \| undefined`
`getBestAsk`	`<T extends MarketType>(marketIndex: number, slot: number, marketType: T, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData) => any`
`getBestBid`	`<T extends MarketType>(marketIndex: number, slot: number, marketType: T, oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData) => any`
`getStopLosses`	`(marketIndex: number, marketType: MarketType, direction: PositionDirection) => Generator<DLOBNode, any, any>`
`getStopLossMarkets`	`(marketIndex: number, marketType: MarketType, direction: PositionDirection) => Generator<DLOBNode, any, any>`
`getStopLossLimits`	`(marketIndex: number, marketType: MarketType, direction: PositionDirection) => Generator<DLOBNode, any, any>`
`getTakeProfits`	`(marketIndex: number, marketType: MarketType, direction: PositionDirection) => Generator<DLOBNode, any, any>`
`getTakeProfitMarkets`	`(marketIndex: number, marketType: MarketType, direction: PositionDirection) => Generator<DLOBNode, any, any>`
`getTakeProfitLimits`	`(marketIndex: number, marketType: MarketType, direction: PositionDirection) => Generator<DLOBNode, any, any>`
`findNodesToTrigger`	`(marketIndex: number, slot: number, triggerPrice: BN, marketType: MarketType, stateAccount: StateAccount) => NodeToTrigger[]`
`printTop`	`(driftClient: DriftClient, slotSubscriber: SlotSubscriber, marketIndex: number, marketType: MarketType) => void`
`getDLOBOrders`	`() => DLOBOrders`
`getNodeLists`	`() => Generator<NodeList<DLOBNodeType>, any, any>`
`getL2`	`<T extends MarketType>({ marketIndex, marketType, slot, oraclePriceData, depth, fallbackL2Generators, }: { marketIndex: number; marketType: T; slot: number; oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData; depth: number; fallbackL2Generators?: L2OrderBookGenerator[]; }) => L2Order...` Get an L2 view of the order book for a given market.
`getL3`	`<T extends MarketType>({ marketIndex, marketType, slot, oraclePriceData, }: { marketIndex: number; marketType: T; slot: number; oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData; }) => L3OrderBook` Get an L3 view of the order book for a given market. Does not include fallback liquidity sources
`estimateFillExactBaseAmountInForSide`	`any`
`estimateFillWithExactBaseAmount`	`<T extends MarketType>({ marketIndex, marketType, baseAmount, orderDirection, slot, oraclePriceData, }: { marketIndex: number; marketType: T; baseAmount: BN; orderDirection: PositionDirection; slot: number; oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData; }) => BN`
`getBestMakers`	`<T extends MarketType>({ marketIndex, marketType, direction, slot, oraclePriceData, numMakers, }: { marketIndex: number; marketType: T; direction: PositionDirection; slot: number; oraclePriceData: T extends { spot: unknown; } ? OraclePriceData : MMOraclePriceData; numMakers: number; }) => PublicKey[]`


import { UserMap } from "@drift-labs/sdk";

Class UserMapReference ↗

Name	Type	Default
`userMap`	`any`
`driftClient`	`DriftClient`
`eventEmitter`	`StrictEventEmitter<EventEmitter, UserEvents>`
`connection`	`any`
`commitment`	`any`
`includeIdle`	`any`
`filterByPoolId`	`any`
`additionalFilters`	`any`
`disableSyncOnTotalAccountsChange`	`any`
`lastNumberOfSubAccounts`	`any`
`subscription`	`any`
`stateAccountUpdateCallback`	`any`
`decode`	`any`
`mostRecentSlot`	`any`
`syncConfig`	`any`
`syncPromise`	`any`
`syncPromiseResolver`	`any`
`throwOnFailedSync`	`any`
`subscribe`	`() => Promise<void>`
`addPubkey`	`(userAccountPublicKey: PublicKey, userAccount?: UserAccount \| undefined, slot?: number \| undefined, accountSubscription?: UserSubscriptionConfig \| undefined) => Promise<...>`
`has`	`(key: string) => boolean`
`get`	`(key: string) => User \| undefined` gets the User for a particular userAccountPublicKey, if no User exists, undefined is returned
`getWithSlot`	`(key: string) => DataAndSlot<User> \| undefined`
`mustGet`	`(key: string, accountSubscription?: UserSubscriptionConfig \| undefined) => Promise<User>` gets the User for a particular userAccountPublicKey, if no User exists, new one is created
`mustGetWithSlot`	`(key: string, accountSubscription?: UserSubscriptionConfig \| undefined) => Promise<DataAndSlot<User>>`
`mustGetUserAccount`	`(key: string) => Promise<UserAccount>`
`getUserAuthority`	`(key: string) => PublicKey \| undefined` gets the Authority for a particular userAccountPublicKey, if no User exists, undefined is returned
`getDLOB`	`(slot: number, protectedMakerParamsMap?: ProtectMakerParamsMap \| undefined) => Promise<DLOB>` implements the DLOBSource interface create a DLOB from all the subscribed users
`updateWithOrderRecord`	`(record: OrderRecord) => Promise<void>`
`updateWithEventRecord`	`(record: any) => Promise<void>`
`values`	`() => IterableIterator<User>`
`valuesWithSlot`	`() => IterableIterator<DataAndSlot<User>>`
`entries`	`() => IterableIterator<[string, User]>`
`entriesWithSlot`	`() => IterableIterator<[string, DataAndSlot<User>]>`
`size`	`() => number`
`getUniqueAuthorities`	`(filterCriteria?: UserAccountFilterCriteria \| undefined) => PublicKey[]` Returns a unique list of authorities for all users in the UserMap that meet the filter criteria
`sync`	`() => Promise<void>`
`getFilters`	`any`
`defaultSync`	`any` Syncs the UserMap using the default sync method (single getProgramAccounts call with filters). This method may fail when drift has too many users. (nodejs response size limits)
`paginatedSync`	`any` Syncs the UserMap using the paginated sync method (multiple getMultipleAccounts calls with filters). This method is more reliable when drift has many users.
`unsubscribe`	`() => Promise<void>`
`updateUserAccount`	`(key: string, userAccount: UserAccount, slot: number) => Promise<void>`
`updateLatestSlot`	`(slot: number) => void`
`getSlot`	`() => number`