@drift-labs/sdk-browser 2.104.0-beta.21

package/lib/node/decode/user.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeUser = void 0;
+const types_1 = require("../types");
+const web3_js_1 = require("@solana/web3.js");
+const __1 = require("../");
+const __2 = require("../");
+function readUnsignedBigInt64LE(buffer, offset) {
+    return new __1.BN(buffer.subarray(offset, offset + 8), 10, 'le');
+}
+function readSignedBigInt64LE(buffer, offset) {
+    const unsignedValue = new __1.BN(buffer.subarray(offset, offset + 8), 10, 'le');
+    if (unsignedValue.testn(63)) {
+        const inverted = unsignedValue.notn(64).addn(1);
+        return inverted.neg();
+    }
+    else {
+        return unsignedValue;
+    }
+}
+function decodeUser(buffer) {
+    let offset = 8;
+    const authority = new web3_js_1.PublicKey(buffer.slice(offset, offset + 32));
+    offset += 32;
+    const delegate = new web3_js_1.PublicKey(buffer.slice(offset, offset + 32));
+    offset += 32;
+    const name = [];
+    for (let i = 0; i < 32; i++) {
+        name.push(buffer.readUint8(offset + i));
+    }
+    offset += 32;
+    const spotPositions = [];
+    for (let i = 0; i < 8; i++) {
+        const scaledBalance = readUnsignedBigInt64LE(buffer, offset);
+        const openOrders = buffer.readUInt8(offset + 35);
+        if (scaledBalance.eq(__2.ZERO) && openOrders === 0) {
+            offset += 40;
+            continue;
+        }
+        offset += 8;
+        const openBids = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const openAsks = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const cumulativeDeposits = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const marketIndex = buffer.readUInt16LE(offset);
+        offset += 2;
+        const balanceTypeNum = buffer.readUInt8(offset);
+        let balanceType;
+        if (balanceTypeNum === 0) {
+            balanceType = types_1.SpotBalanceType.DEPOSIT;
+        }
+        else {
+            balanceType = types_1.SpotBalanceType.BORROW;
+        }
+        offset += 6;
+        spotPositions.push({
+            scaledBalance,
+            openBids,
+            openAsks,
+            cumulativeDeposits,
+            marketIndex,
+            balanceType,
+            openOrders,
+        });
+    }
+    const perpPositions = [];
+    for (let i = 0; i < 8; i++) {
+        const baseAssetAmount = readSignedBigInt64LE(buffer, offset + 8);
+        const quoteAssetAmount = readSignedBigInt64LE(buffer, offset + 16);
+        const lpShares = readUnsignedBigInt64LE(buffer, offset + 64);
+        const openOrders = buffer.readUInt8(offset + 94);
+        if (baseAssetAmount.eq(__2.ZERO) &&
+            openOrders === 0 &&
+            quoteAssetAmount.eq(__2.ZERO) &&
+            lpShares.eq(__2.ZERO)) {
+            offset += 96;
+            continue;
+        }
+        const lastCumulativeFundingRate = readSignedBigInt64LE(buffer, offset);
+        offset += 24;
+        const quoteBreakEvenAmount = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const quoteEntryAmount = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const openBids = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const openAsks = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const settledPnl = readSignedBigInt64LE(buffer, offset);
+        offset += 16;
+        const lastBaseAssetAmountPerLp = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const lastQuoteAssetAmountPerLp = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const remainderBaseAssetAmount = buffer.readInt32LE(offset);
+        offset += 4;
+        const marketIndex = buffer.readUInt16LE(offset);
+        offset += 3;
+        const perLpBase = buffer.readUInt8(offset);
+        offset += 1;
+        perpPositions.push({
+            lastCumulativeFundingRate,
+            baseAssetAmount,
+            quoteAssetAmount,
+            quoteBreakEvenAmount,
+            quoteEntryAmount,
+            openBids,
+            openAsks,
+            settledPnl,
+            lpShares,
+            lastBaseAssetAmountPerLp,
+            lastQuoteAssetAmountPerLp,
+            remainderBaseAssetAmount,
+            marketIndex,
+            openOrders,
+            perLpBase,
+        });
+    }
+    const orders = [];
+    for (let i = 0; i < 32; i++) {
+        // skip order if it's not open
+        if (buffer.readUint8(offset + 82) === 0) {
+            offset += 96;
+            continue;
+        }
+        const slot = readUnsignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const price = readUnsignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const baseAssetAmount = readUnsignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const baseAssetAmountFilled = readUnsignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const quoteAssetAmountFilled = readUnsignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const triggerPrice = readUnsignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const auctionStartPrice = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const auctionEndPrice = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const maxTs = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const oraclePriceOffset = buffer.readInt32LE(offset);
+        offset += 4;
+        const orderId = buffer.readUInt32LE(offset);
+        offset += 4;
+        const marketIndex = buffer.readUInt16LE(offset);
+        offset += 2;
+        const orderStatusNum = buffer.readUInt8(offset);
+        let status;
+        if (orderStatusNum === 0) {
+            status = types_1.OrderStatus.INIT;
+        }
+        else if (orderStatusNum === 1) {
+            status = types_1.OrderStatus.OPEN;
+        }
+        offset += 1;
+        const orderTypeNum = buffer.readUInt8(offset);
+        let orderType;
+        if (orderTypeNum === 0) {
+            orderType = types_1.OrderType.MARKET;
+        }
+        else if (orderTypeNum === 1) {
+            orderType = types_1.OrderType.LIMIT;
+        }
+        else if (orderTypeNum === 2) {
+            orderType = types_1.OrderType.TRIGGER_MARKET;
+        }
+        else if (orderTypeNum === 3) {
+            orderType = types_1.OrderType.TRIGGER_LIMIT;
+        }
+        else if (orderTypeNum === 4) {
+            orderType = types_1.OrderType.ORACLE;
+        }
+        offset += 1;
+        const marketTypeNum = buffer.readUInt8(offset);
+        let marketType;
+        if (marketTypeNum === 0) {
+            marketType = types_1.MarketType.SPOT;
+        }
+        else {
+            marketType = types_1.MarketType.PERP;
+        }
+        offset += 1;
+        const userOrderId = buffer.readUint8(offset);
+        offset += 1;
+        const existingPositionDirectionNum = buffer.readUInt8(offset);
+        let existingPositionDirection;
+        if (existingPositionDirectionNum === 0) {
+            existingPositionDirection = types_1.PositionDirection.LONG;
+        }
+        else {
+            existingPositionDirection = types_1.PositionDirection.SHORT;
+        }
+        offset += 1;
+        const positionDirectionNum = buffer.readUInt8(offset);
+        let direction;
+        if (positionDirectionNum === 0) {
+            direction = types_1.PositionDirection.LONG;
+        }
+        else {
+            direction = types_1.PositionDirection.SHORT;
+        }
+        offset += 1;
+        const reduceOnly = buffer.readUInt8(offset) === 1;
+        offset += 1;
+        const postOnly = buffer.readUInt8(offset) === 1;
+        offset += 1;
+        const immediateOrCancel = buffer.readUInt8(offset) === 1;
+        offset += 1;
+        const triggerConditionNum = buffer.readUInt8(offset);
+        let triggerCondition;
+        if (triggerConditionNum === 0) {
+            triggerCondition = types_1.OrderTriggerCondition.ABOVE;
+        }
+        else if (triggerConditionNum === 1) {
+            triggerCondition = types_1.OrderTriggerCondition.BELOW;
+        }
+        else if (triggerConditionNum === 2) {
+            triggerCondition = types_1.OrderTriggerCondition.TRIGGERED_ABOVE;
+        }
+        else if (triggerConditionNum === 3) {
+            triggerCondition = types_1.OrderTriggerCondition.TRIGGERED_BELOW;
+        }
+        offset += 1;
+        const auctionDuration = buffer.readUInt8(offset);
+        offset += 1;
+        offset += 3; // padding
+        orders.push({
+            slot,
+            price,
+            baseAssetAmount,
+            quoteAssetAmount: undefined,
+            baseAssetAmountFilled,
+            quoteAssetAmountFilled,
+            triggerPrice,
+            auctionStartPrice,
+            auctionEndPrice,
+            maxTs,
+            oraclePriceOffset,
+            orderId,
+            marketIndex,
+            status,
+            orderType,
+            marketType,
+            userOrderId,
+            existingPositionDirection,
+            direction,
+            reduceOnly,
+            postOnly,
+            immediateOrCancel,
+            triggerCondition,
+            auctionDuration,
+        });
+    }
+    const lastAddPerpLpSharesTs = readSignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const totalDeposits = readUnsignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const totalWithdraws = readUnsignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const totalSocialLoss = readUnsignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const settledPerpPnl = readSignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const cumulativeSpotFees = readSignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const cumulativePerpFunding = readSignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const liquidationMarginFreed = readUnsignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const lastActiveSlot = readUnsignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const nextOrderId = buffer.readUInt32LE(offset);
+    offset += 4;
+    const maxMarginRatio = buffer.readUInt32LE(offset);
+    offset += 4;
+    const nextLiquidationId = buffer.readUInt16LE(offset);
+    offset += 2;
+    const subAccountId = buffer.readUInt16LE(offset);
+    offset += 2;
+    const status = buffer.readUInt8(offset);
+    offset += 1;
+    const isMarginTradingEnabled = buffer.readUInt8(offset) === 1;
+    offset += 1;
+    const idle = buffer.readUInt8(offset) === 1;
+    offset += 1;
+    const openOrders = buffer.readUInt8(offset);
+    offset += 1;
+    const hasOpenOrder = buffer.readUInt8(offset) === 1;
+    offset += 1;
+    const openAuctions = buffer.readUInt8(offset);
+    offset += 1;
+    const hasOpenAuction = buffer.readUInt8(offset) === 1;
+    offset += 1;
+    let marginMode;
+    const marginModeNum = buffer.readUInt8(offset);
+    if (marginModeNum === 0) {
+        marginMode = __1.MarginMode.DEFAULT;
+    }
+    else {
+        marginMode = __1.MarginMode.HIGH_LEVERAGE;
+    }
+    offset += 1;
+    // @ts-ignore
+    return {
+        authority,
+        delegate,
+        name,
+        spotPositions,
+        perpPositions,
+        orders,
+        lastAddPerpLpSharesTs,
+        totalDeposits,
+        totalWithdraws,
+        totalSocialLoss,
+        settledPerpPnl,
+        cumulativeSpotFees,
+        cumulativePerpFunding,
+        liquidationMarginFreed,
+        lastActiveSlot,
+        nextOrderId,
+        maxMarginRatio,
+        nextLiquidationId,
+        subAccountId,
+        status,
+        isMarginTradingEnabled,
+        idle,
+        openOrders,
+        hasOpenOrder,
+        openAuctions,
+        hasOpenAuction,
+        marginMode,
+    };
+}
+exports.decodeUser = decodeUser;

package/lib/node/dlob/DLOB.d.ts

@@ -0,0 +1,186 @@
+/// <reference types="bn.js" />
+import { NodeList } from './NodeList';
+import { BN, DLOBNode, DLOBNodeType, DriftClient, MarketType, MarketTypeStr, OraclePriceData, Order, PerpMarketAccount, PositionDirection, SlotSubscriber, SpotMarketAccount, StateAccount, TriggerOrderNode, UserMap } from '..';
+import { PublicKey } from '@solana/web3.js';
+import { L2OrderBook, L2OrderBookGenerator, L3OrderBook } from './orderBookLevels';
+export type DLOBOrder = {
+    user: PublicKey;
+    order: Order;
+};
+export type DLOBOrders = DLOBOrder[];
+export type MarketNodeLists = {
+    restingLimit: {
+        ask: NodeList<'restingLimit'>;
+        bid: NodeList<'restingLimit'>;
+    };
+    floatingLimit: {
+        ask: NodeList<'floatingLimit'>;
+        bid: NodeList<'floatingLimit'>;
+    };
+    takingLimit: {
+        ask: NodeList<'takingLimit'>;
+        bid: NodeList<'takingLimit'>;
+    };
+    market: {
+        ask: NodeList<'market'>;
+        bid: NodeList<'market'>;
+    };
+    trigger: {
+        above: NodeList<'trigger'>;
+        below: NodeList<'trigger'>;
+    };
+    swift: {
+        ask: NodeList<'swift'>;
+        bid: NodeList<'swift'>;
+    };
+};
+type OrderBookCallback = () => void;
+/**
+ *  Receives a DLOBNode and is expected to return true if the node should
+ *  be taken into account when generating, or false otherwise.
+ *
+ * Currently used in functions that rely on getBestNode
+ */
+export type DLOBFilterFcn = (node: DLOBNode) => boolean;
+export type NodeToFill = {
+    node: DLOBNode;
+    makerNodes: DLOBNode[];
+};
+export type NodeToTrigger = {
+    node: TriggerOrderNode;
+};
+export declare class DLOB {
+    openOrders: Map<MarketTypeStr, Set<string>>;
+    orderLists: Map<MarketTypeStr, Map<number, MarketNodeLists>>;
+    maxSlotForRestingLimitOrders: number;
+    initialized: boolean;
+    constructor();
+    private init;
+    clear(): void;
+    /**
+     * initializes a new DLOB instance
+     *
+     * @returns a promise that resolves when the DLOB is initialized
+     */
+    initFromUserMap(userMap: UserMap, slot: number): Promise<boolean>;
+    insertOrder(order: Order, userAccount: string, slot: number, isUserProtectedMaker: boolean, onInsert?: OrderBookCallback): void;
+    insertSwiftOrder(order: Order, userAccount: string, isUserProtectedMaker: boolean, onInsert?: OrderBookCallback): void;
+    addOrderList(marketType: MarketTypeStr, marketIndex: number): void;
+    getListForOnChainOrder(order: Order, slot: number): NodeList<any> | undefined;
+    updateRestingLimitOrders(slot: number): void;
+    updateRestingLimitOrdersForMarketType(slot: number, marketTypeStr: MarketTypeStr): void;
+    getOrder(orderId: number, userAccount: PublicKey): Order | undefined;
+    findNodesToFill(marketIndex: number, fallbackBid: BN | undefined, fallbackAsk: BN | undefined, slot: number, ts: number, marketType: MarketType, oraclePriceData: OraclePriceData, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): NodeToFill[];
+    getMakerRebate(marketType: MarketType, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): {
+        makerRebateNumerator: number;
+        makerRebateDenominator: number;
+    };
+    mergeNodesToFill(restingLimitOrderNodesToFill: NodeToFill[], takingOrderNodesToFill: NodeToFill[]): NodeToFill[];
+    findRestingLimitOrderNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, makerRebateNumerator: number, makerRebateDenominator: number, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
+    findTakingNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, fallbackAsk: BN | undefined, fallbackBid?: BN | undefined): NodeToFill[];
+    findTakingNodesCrossingMakerNodes(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, takerNodeGenerator: Generator<DLOBNode>, makerNodeGeneratorFn: (marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData) => Generator<DLOBNode>, doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean): NodeToFill[];
+    findNodesCrossingFallbackLiquidity(marketType: MarketType, slot: number, oraclePriceData: OraclePriceData, nodeGenerator: Generator<DLOBNode>, doesCross: (nodePrice: BN | undefined) => boolean, minAuctionDuration: number): NodeToFill[];
+    findExpiredNodesToFill(marketIndex: number, ts: number, marketType: MarketType, slot?: BN): NodeToFill[];
+    getTakingBids(marketIndex: number, marketType: MarketType, slot: number, oraclePriceData: OraclePriceData, filterFcn?: DLOBFilterFcn): Generator<DLOBNode>;
+    getTakingAsks(marketIndex: number, marketType: MarketType, slot: number, oraclePriceData: OraclePriceData, filterFcn?: DLOBFilterFcn): Generator<DLOBNode>;
+    protected getBestNode(generatorList: Array<Generator<DLOBNode>>, oraclePriceData: OraclePriceData, slot: number, compareFcn: (bestDLOBNode: DLOBNode, currentDLOBNode: DLOBNode, slot: number, oraclePriceData: OraclePriceData) => boolean, filterFcn?: DLOBFilterFcn): Generator<DLOBNode>;
+    getRestingLimitAsks(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, filterFcn?: DLOBFilterFcn): Generator<DLOBNode>;
+    getRestingLimitBids(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, filterFcn?: DLOBFilterFcn): Generator<DLOBNode>;
+    /**
+     * This will look at both the taking and resting limit asks
+     * @param marketIndex
+     * @param fallbackAsk
+     * @param slot
+     * @param marketType
+     * @param oraclePriceData
+     * @param filterFcn
+     */
+    getAsks(marketIndex: number, _fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, filterFcn?: DLOBFilterFcn): Generator<DLOBNode>;
+    /**
+     * This will look at both the taking and resting limit bids
+     * @param marketIndex
+     * @param fallbackBid
+     * @param slot
+     * @param marketType
+     * @param oraclePriceData
+     * @param filterFcn
+     */
+    getBids(marketIndex: number, _fallbackBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, filterFcn?: DLOBFilterFcn): Generator<DLOBNode>;
+    findCrossingRestingLimitOrders(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
+    determineMakerAndTaker(askNode: DLOBNode, bidNode: DLOBNode): {
+        takerNode: DLOBNode;
+        makerNode: DLOBNode;
+    } | undefined;
+    getBestAsk(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN | undefined;
+    getBestBid(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN | undefined;
+    getStopLosses(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
+    getStopLossMarkets(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
+    getStopLossLimits(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
+    getTakeProfits(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
+    getTakeProfitMarkets(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
+    getTakeProfitLimits(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
+    findNodesToTrigger(marketIndex: number, slot: number, oraclePrice: BN, marketType: MarketType, stateAccount: StateAccount): NodeToTrigger[];
+    printTop(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 fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
+     */
+    getL2({ marketIndex, marketType, slot, oraclePriceData, depth, fallbackL2Generators, }: {
+        marketIndex: number;
+        marketType: MarketType;
+        slot: number;
+        oraclePriceData: OraclePriceData;
+        depth: number;
+        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;
+    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;
+    getBestMakers({ marketIndex, marketType, direction, slot, oraclePriceData, numMakers, }: {
+        marketIndex: number;
+        marketType: MarketType;
+        direction: PositionDirection;
+        slot: number;
+        oraclePriceData: OraclePriceData;
+        numMakers: number;
+    }): PublicKey[];
+}
+export {};