@drift-labs/sdk 0.2.0-master.4 → 0.2.0-master.40

package/lib/types.js

@@ -1,23 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultOrderParams = exports.TradeSide = exports.isOneOfVariant = exports.isVariant = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.PositionDirection = exports.BankBalanceType = exports.SwapDirection = void 0;
+exports.DefaultOrderParams = exports.LiquidationType = exports.LPAction = exports.TradeSide = exports.getVariant = exports.isOneOfVariant = exports.isVariant = exports.SpotFulfillmentStatus = exports.SpotFulfillmentType = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.MarketType = exports.OrderType = exports.OracleSource = exports.DepositDirection = exports.PositionDirection = exports.SpotBalanceType = exports.SwapDirection = exports.AssetTier = exports.ContractTier = exports.ContractType = exports.MarketStatus = exports.ExchangeStatus = void 0;
 const _1 = require(".");
 // # Utility Types / Enums / Constants
+class ExchangeStatus {
+}
+exports.ExchangeStatus = ExchangeStatus;
+ExchangeStatus.ACTIVE = { active: {} };
+ExchangeStatus.FUNDINGPAUSED = { fundingPaused: {} };
+ExchangeStatus.AMMPAUSED = { ammPaused: {} };
+ExchangeStatus.FILLPAUSED = { fillPaused: {} };
+ExchangeStatus.LIQPAUSED = { liqPaused: {} };
+ExchangeStatus.WITHDRAWPAUSED = { withdrawPaused: {} };
+ExchangeStatus.PAUSED = { paused: {} };
+class MarketStatus {
+}
+exports.MarketStatus = MarketStatus;
+MarketStatus.INITIALIZED = { initialized: {} };
+MarketStatus.ACTIVE = { active: {} };
+MarketStatus.FUNDINGPAUSED = { fundingPaused: {} };
+MarketStatus.AMMPAUSED = { ammPaused: {} };
+MarketStatus.FILLPAUSED = { fillPaused: {} };
+MarketStatus.WITHDRAWPAUSED = { withdrawPaused: {} };
+MarketStatus.REDUCEONLY = { reduceOnly: {} };
+MarketStatus.SETTLEMENT = { settlement: {} };
+MarketStatus.DELISTED = { delisted: {} };
+class ContractType {
+}
+exports.ContractType = ContractType;
+ContractType.PERPETUAL = { perpetual: {} };
+ContractType.FUTURE = { future: {} };
+class ContractTier {
+}
+exports.ContractTier = ContractTier;
+ContractTier.A = { a: {} };
+ContractTier.B = { b: {} };
+ContractTier.C = { c: {} };
+ContractTier.SPECULATIVE = { speculative: {} };
+ContractTier.ISOLATED = { isolated: {} };
+class AssetTier {
+}
+exports.AssetTier = AssetTier;
+AssetTier.COLLATERAL = { collateral: {} };
+AssetTier.PROTECTED = { protected: {} };
+AssetTier.CROSS = { cross: {} };
+AssetTier.ISOLATED = { isolated: {} };
+AssetTier.UNLISTED = { unlisted: {} };
 class SwapDirection {
 }
 exports.SwapDirection = SwapDirection;
 SwapDirection.ADD = { add: {} };
 SwapDirection.REMOVE = { remove: {} };
-class BankBalanceType {
+class SpotBalanceType {
 }
-exports.BankBalanceType = BankBalanceType;
-BankBalanceType.DEPOSIT = { deposit: {} };
-BankBalanceType.BORROW = { borrow: {} };
+exports.SpotBalanceType = SpotBalanceType;
+SpotBalanceType.DEPOSIT = { deposit: {} };
+SpotBalanceType.BORROW = { borrow: {} };
 class PositionDirection {
 }
 exports.PositionDirection = PositionDirection;
 PositionDirection.LONG = { long: {} };
 PositionDirection.SHORT = { short: {} };
+class DepositDirection {
+}
+exports.DepositDirection = DepositDirection;
+DepositDirection.DEPOSIT = { deposit: {} };
+DepositDirection.WITHDRAW = { withdraw: {} };
 class OracleSource {
 }
 exports.OracleSource = OracleSource;
@@ -31,6 +79,11 @@ OrderType.LIMIT = { limit: {} };
 OrderType.TRIGGER_MARKET = { triggerMarket: {} };
 OrderType.TRIGGER_LIMIT = { triggerLimit: {} };
 OrderType.MARKET = { market: {} };
+class MarketType {
+}
+exports.MarketType = MarketType;
+MarketType.SPOT = { spot: {} };
+MarketType.PERP = { perp: {} };
 class OrderStatus {
 }
 exports.OrderStatus = OrderStatus;
@@ -56,20 +109,32 @@ class OrderActionExplanation {
 }
 exports.OrderActionExplanation = OrderActionExplanation;
 OrderActionExplanation.NONE = { none: {} };
-OrderActionExplanation.BREACHED_MARGIN_REQUIREMENT = {
-    breachedMarginRequirement: {},
-};
 OrderActionExplanation.ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
     oraclePriceBreachedLimitPrice: {},
 };
 OrderActionExplanation.MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
     marketOrderFilledToLimitPrice: {},
 };
+OrderActionExplanation.CANCELED_FOR_LIQUIDATION = {
+    canceledForLiquidation: {},
+};
+OrderActionExplanation.MARKET_ORDER_AUCTION_EXPIRED = {
+    marketOrderAuctionExpired: {},
+};
 class OrderTriggerCondition {
 }
 exports.OrderTriggerCondition = OrderTriggerCondition;
 OrderTriggerCondition.ABOVE = { above: {} };
 OrderTriggerCondition.BELOW = { below: {} };
+class SpotFulfillmentType {
+}
+exports.SpotFulfillmentType = SpotFulfillmentType;
+SpotFulfillmentType.SERUM_v3 = { serumV3: {} };
+class SpotFulfillmentStatus {
+}
+exports.SpotFulfillmentStatus = SpotFulfillmentStatus;
+SpotFulfillmentStatus.ENABLED = { enabled: {} };
+SpotFulfillmentStatus.DISABLED = { disabled: {} };
 function isVariant(object, type) {
     return object.hasOwnProperty(type);
 }
@@ -80,30 +145,56 @@ function isOneOfVariant(object, types) {
     }, false);
 }
 exports.isOneOfVariant = isOneOfVariant;
+function getVariant(object) {
+    return Object.keys(object)[0];
+}
+exports.getVariant = getVariant;
 var TradeSide;
 (function (TradeSide) {
     TradeSide[TradeSide["None"] = 0] = "None";
     TradeSide[TradeSide["Buy"] = 1] = "Buy";
     TradeSide[TradeSide["Sell"] = 2] = "Sell";
 })(TradeSide = exports.TradeSide || (exports.TradeSide = {}));
+class LPAction {
+}
+exports.LPAction = LPAction;
+LPAction.ADD_LIQUIDITY = { addLiquidity: {} };
+LPAction.REMOVE_LIQUIDITY = { removeLiquidity: {} };
+LPAction.SETTLE_LIQUIDITY = { settleLiquidity: {} };
+class LiquidationType {
+}
+exports.LiquidationType = LiquidationType;
+LiquidationType.LIQUIDATE_PERP = { liquidatePerp: {} };
+LiquidationType.LIQUIDATE_BORROW = { liquidateBorrow: {} };
+LiquidationType.LIQUIDATE_BORROW_FOR_PERP_PNL = {
+    liquidateBorrowForPerpPnl: {},
+};
+LiquidationType.LIQUIDATE_PERP_PNL_FOR_DEPOSIT = {
+    liquidatePerpPnlForDeposit: {},
+};
+LiquidationType.PERP_BANKRUPTCY = {
+    perpBankruptcy: {},
+};
+LiquidationType.BORROW_BANKRUPTCY = {
+    borrowBankruptcy: {},
+};
 exports.DefaultOrderParams = {
     orderType: OrderType.MARKET,
+    marketType: MarketType.PERP,
     userOrderId: 0,
     direction: PositionDirection.LONG,
     baseAssetAmount: _1.ZERO,
     price: _1.ZERO,
-    marketIndex: _1.ZERO,
+    marketIndex: 0,
     reduceOnly: false,
     postOnly: false,
     immediateOrCancel: false,
-    triggerPrice: _1.ZERO,
+    triggerPrice: null,
     triggerCondition: OrderTriggerCondition.ABOVE,
     positionLimit: _1.ZERO,
-    oraclePriceOffset: _1.ZERO,
-    padding0: _1.ZERO,
-    padding1: _1.ZERO,
-    optionalAccounts: {
-        discountToken: false,
-        referrer: false,
-    },
+    oraclePriceOffset: null,
+    auctionDuration: null,
+    maxTs: null,
+    auctionStartPrice: null,
+    auctionEndPrice: null,
 };

package/lib/user.d.ts

@@ -0,0 +1,226 @@
+/// <reference types="node" />
+/// <reference types="bn.js" />
+import { PublicKey } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { DriftClient } from './driftClient';
+import { MarginCategory, Order, UserAccount, PerpPosition, SpotPosition } from './types';
+import { UserAccountSubscriber, UserAccountEvents, DataAndSlot } from './accounts/types';
+import { PositionDirection, BN, SpotMarketAccount } from '.';
+import { OraclePriceData } from './oracles/types';
+import { UserConfig } from './userConfig';
+export declare class User {
+    driftClient: DriftClient;
+    userAccountPublicKey: PublicKey;
+    accountSubscriber: UserAccountSubscriber;
+    _isSubscribed: boolean;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+    get isSubscribed(): boolean;
+    set isSubscribed(val: boolean);
+    constructor(config: UserConfig);
+    /**
+     * Subscribe to User state accounts
+     * @returns SusbcriptionSuccess result
+     */
+    subscribe(): Promise<boolean>;
+    /**
+     *	Forces the accountSubscriber to fetch account updates from rpc
+     */
+    fetchAccounts(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    getUserAccount(): UserAccount;
+    getUserAccountAndSlot(): DataAndSlot<UserAccount> | undefined;
+    /**
+     * Gets the user's current position for a given perp market. If the user has no position returns undefined
+     * @param marketIndex
+     * @returns userPerpPosition
+     */
+    getPerpPosition(marketIndex: number): PerpPosition | undefined;
+    /**
+     * Gets the user's current position for a given spot market. If the user has no position returns undefined
+     * @param marketIndex
+     * @returns userSpotPosition
+     */
+    getSpotPosition(marketIndex: number): SpotPosition | undefined;
+    getEmptyPosition(marketIndex: number): PerpPosition;
+    getClonedPosition(position: PerpPosition): PerpPosition;
+    /**
+     * @param orderId
+     * @returns Order
+     */
+    getOrder(orderId: number): Order | undefined;
+    /**
+     * @param userOrderId
+     * @returns Order
+     */
+    getOrderByUserOrderId(userOrderId: number): Order | undefined;
+    getUserAccountPublicKey(): PublicKey;
+    exists(): Promise<boolean>;
+    /**
+     * calculates the total open bids/asks in a perp market (including lps)
+     * @returns : open bids
+     * @returns : open asks
+     */
+    getPerpBidAsks(marketIndex: number): [BN, BN];
+    /**
+     * calculates the open bids and asks for an lp
+     * @returns : lp open bids
+     * @returns : lp open asks
+     */
+    getLPBidAsks(marketIndex: number): [BN, BN];
+    /**
+     * calculates the market position if the lp position was settled
+     * @returns : the settled userPosition
+     * @returns : the dust base asset amount (ie, < stepsize)
+     * @returns : pnl from settle
+     */
+    getSettledLPPosition(marketIndex: number): [PerpPosition, BN, BN];
+    /**
+     * calculates Buying Power = FC * MAX_LEVERAGE
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getBuyingPower(marketIndex: number): BN;
+    /**
+     * calculates Free Collateral = Total collateral - initial margin requirement
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getFreeCollateral(): BN;
+    /**
+     * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
+     */
+    getMarginRequirement(marginCategory: MarginCategory, liquidationBuffer?: BN): BN;
+    /**
+     * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
+     */
+    getInitialMarginRequirement(): BN;
+    /**
+     * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
+     */
+    getMaintenanceMarginRequirement(liquidationBuffer?: BN): BN;
+    /**
+     * calculates unrealized position price pnl
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getUnrealizedPNL(withFunding?: boolean, marketIndex?: number, withWeightMarginCategory?: MarginCategory): BN;
+    /**
+     * calculates unrealized funding payment pnl
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getUnrealizedFundingPNL(marketIndex?: number): BN;
+    getSpotMarketLiabilityValue(marketIndex?: number, marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean): BN;
+    getSpotLiabilityValue(tokenAmount: BN, oraclePriceData: OraclePriceData, spotMarketAccount: SpotMarketAccount, marginCategory?: MarginCategory, liquidationBuffer?: BN): BN;
+    getSpotMarketAssetValue(marketIndex?: number, marginCategory?: MarginCategory, includeOpenOrders?: boolean): BN;
+    getSpotAssetValue(tokenAmount: BN, oraclePriceData: OraclePriceData, spotMarketAccount: SpotMarketAccount, marginCategory?: MarginCategory): BN;
+    getNetSpotMarketValue(withWeightMarginCategory?: MarginCategory): BN;
+    /**
+     * calculates TotalCollateral: collateral + unrealized pnl
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getTotalCollateral(marginCategory?: MarginCategory): BN;
+    /**
+     * calculates sum of position value across all positions in margin system
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getTotalPerpPositionValue(marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean): BN;
+    /**
+     * calculates position value in margin system
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getPerpPositionValue(marketIndex: number, oraclePriceData: OraclePriceData): BN;
+    getPositionSide(currentPosition: Pick<PerpPosition, 'baseAssetAmount'>): PositionDirection | undefined;
+    /**
+     * calculates average exit price (optionally for closing up to 100% of position)
+     * @returns : Precision PRICE_PRECISION
+     */
+    getPositionEstimatedExitPriceAndPnl(position: PerpPosition, amountToClose?: BN, useAMMClose?: boolean): [BN, BN];
+    /**
+     * calculates current user leverage across all positions
+     * @returns : Precision TEN_THOUSAND
+     */
+    getLeverage(): BN;
+    getTotalLiabilityValue(): BN;
+    getTotalAssetValue(): BN;
+    /**
+     * calculates max allowable leverage exceeding hitting requirement category
+     * @params category {Initial, Maintenance}
+     * @returns : Precision TEN_THOUSAND
+     */
+    getMaxLeverage(marketIndex: number, category?: MarginCategory): BN;
+    /**
+     * calculates margin ratio: total collateral / |total position value|
+     * @returns : Precision TEN_THOUSAND
+     */
+    getMarginRatio(): BN;
+    canBeLiquidated(): boolean;
+    /**
+     * Checks if any user position cumulative funding differs from respective market cumulative funding
+     * @returns
+     */
+    needsToSettleFundingPayment(): boolean;
+    /**
+     * Calculate the liquidation price of a position, with optional parameter to calculate the liquidation price after a trade
+     * @param PerpPosition
+     * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
+     * @param partial
+     * @returns Precision : PRICE_PRECISION
+     */
+    liquidationPrice(perpPosition: Pick<PerpPosition, 'marketIndex'>, positionBaseSizeChange?: BN): BN;
+    /**
+     * Calculates the estimated liquidation price for a position after closing a quote amount of the position.
+     * @param positionMarketIndex
+     * @param closeQuoteAmount
+     * @returns : Precision PRICE_PRECISION
+     */
+    liquidationPriceAfterClose(positionMarketIndex: number, closeQuoteAmount: BN): BN;
+    /**
+     * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
+     *
+     * To Calculate Max Quote Available:
+     *
+     * Case 1: SameSide
+     * 	=> Remaining quote to get to maxLeverage
+     *
+     * Case 2: NOT SameSide && currentLeverage <= maxLeverage
+     * 	=> Current opposite position x2 + remaining to get to maxLeverage
+     *
+     * Case 3: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition > maxLeverage
+     * 	=> strictly reduce current position size
+     *
+     * Case 4: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition < maxLeverage
+     * 	=> current position + remaining to get to maxLeverage
+     *
+     * @param targetMarketIndex
+     * @param tradeSide
+     * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
+     */
+    getMaxTradeSizeUSDC(targetMarketIndex: number, tradeSide: PositionDirection): BN;
+    /**
+     * Returns the leverage ratio for the account after adding (or subtracting) the given quote size to the given position
+     * @param targetMarketIndex
+     * @param positionMarketIndex
+     * @param tradeQuoteAmount
+     * @returns leverageRatio : Precision TEN_THOUSAND
+     */
+    accountLeverageRatioAfterTrade(targetMarketIndex: number, tradeQuoteAmount: BN, tradeSide: PositionDirection, includeOpenOrders?: boolean): BN;
+    /**
+     * Calculates how much fee will be taken for a given sized trade
+     * @param quoteAmount
+     * @returns feeForQuote : Precision QUOTE_PRECISION
+     */
+    calculateFeeForQuoteAmount(quoteAmount: BN): BN;
+    /**
+     * Calculates a user's max withdrawal amounts for a spot market. If reduceOnly is true,
+     * it will return the max withdrawal amount without opening a liability for the user
+     * @param marketIndex
+     * @returns withdrawalLimit : Precision is the token precision for the chosen SpotMarket
+     */
+    getWithdrawalLimit(marketIndex: number, reduceOnly?: boolean): BN;
+    /**
+     * Get the total position value, excluding any position coming from the given target market
+     * @param marketToIgnore
+     * @returns positionValue : Precision QUOTE_PRECISION
+     */
+    private getTotalPerpPositionValueExcludingMarket;
+    private getOracleDataForPerpMarket;
+    private getOracleDataForSpotMarket;
+}