@drift-labs/sdk 0.1.19-master.2 → 0.1.21-master.4

package/lib/mockUSDCFaucet.d.ts

@@ -1,8 +1,9 @@
+/// <reference types="bn.js" />
 import * as anchor from '@project-serum/anchor';
 import { Program, Provider } from '@project-serum/anchor';
 import { AccountInfo } from '@solana/spl-token';
 import { ConfirmOptions, Connection, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
-import BN from 'bn.js';
+import { BN } from '.';
 import { IWallet } from './types';
 export declare class MockUSDCFaucet {
     connection: Connection;
@@ -33,4 +34,3 @@ export declare class MockUSDCFaucet {
         callback: (accountInfo: AccountInfo) => void;
     }): Promise<boolean>;
 }
-//# sourceMappingURL=mockUSDCFaucet.d.ts.map

package/lib/orderParams.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="bn.js" />
+import { OrderParams, OrderTriggerCondition, PositionDirection } from './types';
+import { BN } from '@project-serum/anchor';
+export declare function getLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
+export declare function getTriggerMarketOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
+export declare function getTriggerLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
+export declare function getMarketOrderParams(marketIndex: BN, direction: PositionDirection, quoteAssetAmount: BN, baseAssetAmount: BN, reduceOnly: boolean, price?: BN, discountToken?: boolean, referrer?: boolean): OrderParams;

package/lib/orderParams.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
+const types_1 = require("./types");
+const numericConstants_1 = require("./constants/numericConstants");
+function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
+    return {
+        orderType: types_1.OrderType.LIMIT,
+        userOrderId,
+        marketIndex,
+        direction,
+        quoteAssetAmount: numericConstants_1.ZERO,
+        baseAssetAmount,
+        price,
+        reduceOnly,
+        postOnly: false,
+        immediateOrCancel: false,
+        positionLimit: numericConstants_1.ZERO,
+        padding0: true,
+        padding1: numericConstants_1.ZERO,
+        optionalAccounts: {
+            discountToken,
+            referrer,
+        },
+        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
+        triggerPrice: numericConstants_1.ZERO,
+        oraclePriceOffset: numericConstants_1.ZERO,
+    };
+}
+exports.getLimitOrderParams = getLimitOrderParams;
+function getTriggerMarketOrderParams(marketIndex, direction, baseAssetAmount, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
+    return {
+        orderType: types_1.OrderType.TRIGGER_MARKET,
+        userOrderId,
+        marketIndex,
+        direction,
+        quoteAssetAmount: numericConstants_1.ZERO,
+        baseAssetAmount,
+        price: numericConstants_1.ZERO,
+        reduceOnly,
+        postOnly: false,
+        immediateOrCancel: false,
+        positionLimit: numericConstants_1.ZERO,
+        padding0: true,
+        padding1: numericConstants_1.ZERO,
+        optionalAccounts: {
+            discountToken,
+            referrer,
+        },
+        triggerCondition,
+        triggerPrice,
+        oraclePriceOffset: numericConstants_1.ZERO,
+    };
+}
+exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
+function getTriggerLimitOrderParams(marketIndex, direction, baseAssetAmount, price, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
+    return {
+        orderType: types_1.OrderType.TRIGGER_LIMIT,
+        userOrderId,
+        marketIndex,
+        direction,
+        quoteAssetAmount: numericConstants_1.ZERO,
+        baseAssetAmount,
+        price,
+        reduceOnly,
+        postOnly: false,
+        immediateOrCancel: false,
+        positionLimit: numericConstants_1.ZERO,
+        padding0: true,
+        padding1: numericConstants_1.ZERO,
+        optionalAccounts: {
+            discountToken,
+            referrer,
+        },
+        triggerCondition,
+        triggerPrice,
+        oraclePriceOffset: numericConstants_1.ZERO,
+    };
+}
+exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
+function getMarketOrderParams(marketIndex, direction, quoteAssetAmount, baseAssetAmount, reduceOnly, price = numericConstants_1.ZERO, discountToken = false, referrer = false) {
+    if (baseAssetAmount.eq(numericConstants_1.ZERO) && quoteAssetAmount.eq(numericConstants_1.ZERO)) {
+        throw Error('baseAssetAmount or quoteAssetAmount must be zero');
+    }
+    return {
+        orderType: types_1.OrderType.MARKET,
+        userOrderId: 0,
+        marketIndex,
+        direction,
+        quoteAssetAmount,
+        baseAssetAmount,
+        price,
+        reduceOnly,
+        postOnly: false,
+        immediateOrCancel: false,
+        positionLimit: numericConstants_1.ZERO,
+        padding0: true,
+        padding1: numericConstants_1.ZERO,
+        optionalAccounts: {
+            discountToken,
+            referrer,
+        },
+        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
+        triggerPrice: numericConstants_1.ZERO,
+        oraclePriceOffset: numericConstants_1.ZERO,
+    };
+}
+exports.getMarketOrderParams = getMarketOrderParams;

package/lib/orders.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="bn.js" />
+import { Market, Order, UserAccount, UserPosition } from './types';
+import { BN } from '.';
+export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: Market, order: Order): [UserAccount, UserPosition, Market] | null;
+export declare function calculateAmountToTradeForLimit(market: Market, order: Order): BN;
+export declare function calculateAmountToTradeForTriggerLimit(market: Market, order: Order): BN;

package/lib/orders.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateNewStateAfterOrder = void 0;
+const types_1 = require("./types");
+const market_1 = require("./math/market");
+const numericConstants_1 = require("./constants/numericConstants");
+const amm_1 = require("./math/amm");
+const position_1 = require("./math/position");
+function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
+    if (types_1.isVariant(order.status, 'init')) {
+        return null;
+    }
+    const baseAssetAmountToTrade = calculateAmountToTrade(market, order);
+    if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
+        return null;
+    }
+    const userAccountAfter = Object.assign({}, userAccount);
+    const userPositionAfter = Object.assign({}, userPosition);
+    const currentPositionDirection = position_1.positionCurrentDirection(userPosition);
+    const increasePosition = userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) ||
+        isSameDirection(order.direction, currentPositionDirection);
+    if (increasePosition) {
+        const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
+        const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(market, marketAfter);
+        userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
+        userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(quoteAssetAmountSwapped);
+        return [userAccountAfter, userPositionAfter, marketAfter];
+    }
+    else {
+        const reversePosition = baseAssetAmountToTrade.gt(userPosition.baseAssetAmount.abs());
+        if (reversePosition) {
+            const intermediateMarket = market_1.calculateNewMarketAfterTrade(userPosition.baseAssetAmount, position_1.findDirectionToClose(userPosition), market);
+            const { quoteAssetAmountSwapped: baseAssetValue } = calculateAmountSwapped(market, intermediateMarket);
+            let pnl;
+            if (types_1.isVariant(currentPositionDirection, 'long')) {
+                pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
+            }
+            else {
+                pnl = userPosition.quoteAssetAmount.sub(baseAssetValue);
+            }
+            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
+            const baseAssetAmountLeft = baseAssetAmountToTrade.sub(userPosition.baseAssetAmount.abs());
+            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountLeft, order.direction, intermediateMarket);
+            const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(intermediateMarket, marketAfter);
+            userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
+            userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
+            return [userAccountAfter, userPositionAfter, marketAfter];
+        }
+        else {
+            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
+            const { quoteAssetAmountSwapped: baseAssetValue, baseAssetAmountSwapped, } = calculateAmountSwapped(market, marketAfter);
+            const costBasisRealized = userPosition.quoteAssetAmount
+                .mul(baseAssetAmountSwapped.abs())
+                .div(userPosition.baseAssetAmount.abs());
+            let pnl;
+            if (types_1.isVariant(currentPositionDirection, 'long')) {
+                pnl = baseAssetValue.sub(costBasisRealized);
+            }
+            else {
+                pnl = costBasisRealized.sub(baseAssetValue);
+            }
+            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
+            userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
+            userPositionAfter.quoteAssetAmount =
+                userPositionAfter.quoteAssetAmount.sub(costBasisRealized);
+            return [userAccountAfter, userPositionAfter, marketAfter];
+        }
+    }
+}
+exports.calculateNewStateAfterOrder = calculateNewStateAfterOrder;
+function calculateAmountSwapped(marketBefore, marketAfter) {
+    return {
+        quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
+            .sub(marketAfter.amm.quoteAssetReserve)
+            .abs()
+            .mul(marketBefore.amm.pegMultiplier)
+            .div(numericConstants_1.PEG_PRECISION)
+            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO),
+        baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(marketAfter.amm.baseAssetReserve),
+    };
+}
+function calculateAmountToTrade(market, order) {
+    if (types_1.isVariant(order.orderType, 'limit')) {
+        return calculateAmountToTradeForLimit(market, order);
+    }
+    else if (types_1.isVariant(order.orderType, 'triggerLimit')) {
+        return calculateAmountToTradeForTriggerLimit(market, order);
+    }
+    else if (types_1.isVariant(order.orderType, 'market')) {
+        // should never be a market order queued
+        return numericConstants_1.ZERO;
+    }
+    else {
+        return calculateAmountToTradeForTriggerMarket(market, order);
+    }
+}
+function calculateAmountToTradeForLimit(market, order) {
+    const [maxAmountToTrade, direction] = amm_1.calculateMaxBaseAssetAmountToTrade(market.amm, order.price);
+    // Check that directions are the same
+    const sameDirection = isSameDirection(direction, order.direction);
+    if (!sameDirection) {
+        return numericConstants_1.ZERO;
+    }
+    return maxAmountToTrade.gt(order.baseAssetAmount)
+        ? order.baseAssetAmount
+        : maxAmountToTrade;
+}
+exports.calculateAmountToTradeForLimit = calculateAmountToTradeForLimit;
+function calculateAmountToTradeForTriggerLimit(market, order) {
+    if (order.baseAssetAmountFilled.eq(numericConstants_1.ZERO)) {
+        const baseAssetAmount = calculateAmountToTradeForTriggerMarket(market, order);
+        if (baseAssetAmount.eq(numericConstants_1.ZERO)) {
+            return numericConstants_1.ZERO;
+        }
+    }
+    return calculateAmountToTradeForLimit(market, order);
+}
+exports.calculateAmountToTradeForTriggerLimit = calculateAmountToTradeForTriggerLimit;
+function isSameDirection(firstDirection, secondDirection) {
+    return ((types_1.isVariant(firstDirection, 'long') && types_1.isVariant(secondDirection, 'long')) ||
+        (types_1.isVariant(firstDirection, 'short') && types_1.isVariant(secondDirection, 'short')));
+}
+function calculateAmountToTradeForTriggerMarket(market, order) {
+    return isTriggerConditionSatisfied(market, order)
+        ? order.baseAssetAmount
+        : numericConstants_1.ZERO;
+}
+function isTriggerConditionSatisfied(market, order) {
+    const markPrice = market_1.calculateMarkPrice(market);
+    if (types_1.isVariant(order.triggerCondition, 'above')) {
+        return markPrice.gt(order.triggerPrice);
+    }
+    else {
+        return markPrice.lt(order.triggerPrice);
+    }
+}

package/lib/pythClient.d.ts

@@ -5,4 +5,3 @@ export declare class PythClient {
     constructor(connection: Connection);
     getPriceData(pricePublicKey: PublicKey): Promise<PriceData>;
 }
-//# sourceMappingURL=pythClient.d.ts.map

package/lib/pythClient.js

@@ -18,7 +18,7 @@ class PythClient {
     getPriceData(pricePublicKey) {
         return __awaiter(this, void 0, void 0, function* () {
             const account = yield this.connection.getAccountInfo(pricePublicKey);
-            return (0, client_1.parsePriceData)(account.data);
+            return client_1.parsePriceData(account.data);
         });
     }
 }

package/lib/token/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { AccountInfo } from '@solana/spl-token';
+export declare function parseTokenAccount(data: Buffer): AccountInfo;

package/lib/token/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokenAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+function parseTokenAccount(data) {
+    const accountInfo = spl_token_1.AccountLayout.decode(data);
+    accountInfo.mint = new web3_js_1.PublicKey(accountInfo.mint);
+    accountInfo.owner = new web3_js_1.PublicKey(accountInfo.owner);
+    accountInfo.amount = spl_token_1.u64.fromBuffer(accountInfo.amount);
+    if (accountInfo.delegateOption === 0) {
+        accountInfo.delegate = null;
+        // eslint-disable-next-line new-cap
+        accountInfo.delegatedAmount = new spl_token_1.u64(0);
+    }
+    else {
+        accountInfo.delegate = new web3_js_1.PublicKey(accountInfo.delegate);
+        accountInfo.delegatedAmount = spl_token_1.u64.fromBuffer(accountInfo.delegatedAmount);
+    }
+    accountInfo.isInitialized = accountInfo.state !== 0;
+    accountInfo.isFrozen = accountInfo.state === 2;
+    if (accountInfo.isNativeOption === 1) {
+        accountInfo.rentExemptReserve = spl_token_1.u64.fromBuffer(accountInfo.isNative);
+        accountInfo.isNative = true;
+    }
+    else {
+        accountInfo.rentExemptReserve = null;
+        accountInfo.isNative = false;
+    }
+    if (accountInfo.closeAuthorityOption === 0) {
+        accountInfo.closeAuthority = null;
+    }
+    else {
+        accountInfo.closeAuthority = new web3_js_1.PublicKey(accountInfo.closeAuthority);
+    }
+    return accountInfo;
+}
+exports.parseTokenAccount = parseTokenAccount;

package/lib/tx/defaultTxSender.d.ts

@@ -6,4 +6,3 @@ export declare class DefaultTxSender implements TxSender {
     constructor(provider: Provider);
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TransactionSignature>;
 }
-//# sourceMappingURL=defaultTxSender.d.ts.map

package/lib/tx/types.d.ts

@@ -2,4 +2,3 @@ import { ConfirmOptions, Signer, Transaction, TransactionSignature } from '@sola
 export interface TxSender {
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TransactionSignature>;
 }
-//# sourceMappingURL=types.d.ts.map

package/lib/tx/utils.d.ts

@@ -1,3 +1,2 @@
 import { Transaction, TransactionInstruction } from '@solana/web3.js';
 export declare function wrapInTx(instruction: TransactionInstruction): Transaction;
-//# sourceMappingURL=utils.d.ts.map

package/lib/types.d.ts

@@ -1,5 +1,6 @@
+/// <reference types="bn.js" />
 import { PublicKey, Transaction } from '@solana/web3.js';
-import BN from 'bn.js';
+import { BN } from '.';
 export declare class SwapDirection {
     static readonly ADD: {
         add: {};
@@ -24,6 +25,65 @@ export declare class OracleSource {
         switchboard: {};
     };
 }
+export declare class OrderType {
+    static readonly LIMIT: {
+        limit: {};
+    };
+    static readonly TRIGGER_MARKET: {
+        triggerMarket: {};
+    };
+    static readonly TRIGGER_LIMIT: {
+        triggerLimit: {};
+    };
+    static readonly MARKET: {
+        market: {};
+    };
+}
+export declare class OrderStatus {
+    static readonly INIT: {
+        init: {};
+    };
+    static readonly OPEN: {
+        open: {};
+    };
+}
+export declare class OrderDiscountTier {
+    static readonly NONE: {
+        none: {};
+    };
+    static readonly FIRST: {
+        first: {};
+    };
+    static readonly SECOND: {
+        second: {};
+    };
+    static readonly THIRD: {
+        third: {};
+    };
+    static readonly FOURTH: {
+        fourth: {};
+    };
+}
+export declare class OrderAction {
+    static readonly PLACE: {
+        place: {};
+    };
+    static readonly CANCEL: {
+        cancel: {};
+    };
+    static readonly FILL: {
+        fill: {};
+    };
+}
+export declare class OrderTriggerCondition {
+    static readonly ABOVE: {
+        above: {};
+    };
+    static readonly BELOW: {
+        below: {};
+    };
+}
+export declare function isVariant(object: unknown, type: string): boolean;
 export declare enum TradeSide {
     None = 0,
     Buy = 1,
@@ -54,6 +114,11 @@ export declare type LiquidationHistoryAccount = {
     head: BN;
     liquidationRecords: LiquidationRecord[];
 };
+export declare type OrderHistoryAccount = {
+    head: BN;
+    lastOrderId: BN;
+    orderRecords: OrderRecord[];
+};
 export declare type DepositRecord = {
     ts: BN;
     recordId: BN;
@@ -147,6 +212,20 @@ export declare type LiquidationRecord = {
     unrealizedPnl: BN;
     marginRatio: BN;
 };
+export declare type OrderRecord = {
+    ts: BN;
+    recordId: BN;
+    order: Order;
+    user: PublicKey;
+    authority: PublicKey;
+    action: OrderAction;
+    filler: PublicKey;
+    baseAssetAmountFilled: BN;
+    quoteAssetAmountFilled: BN;
+    fee: BN;
+    fillerReward: BN;
+    tradeRecordId: BN;
+};
 export declare type StateAccount = {
     admin: PublicKey;
     fundingPaused: boolean;
@@ -184,8 +263,14 @@ export declare type StateAccount = {
     discountMint: PublicKey;
     oracleGuardRails: OracleGuardRails;
     maxDeposit: BN;
+    orderState: PublicKey;
     extendedCurveHistory: PublicKey;
 };
+export declare type OrderStateAccount = {
+    orderHistory: PublicKey;
+    orderFillerRewardStructure: OrderFillerRewardStructure;
+    minOrderQuoteAssetAmount: BN;
+};
 export declare type MarketsAccount = {
     accountIndex: BN;
     markets: Market[];
@@ -220,7 +305,8 @@ export declare type AMM = {
     totalFeeMinusDistributions: BN;
     totalFeeWithdrawn: BN;
     totalFee: BN;
-    minimumTradeSize: BN;
+    minimumQuoteAssetTradeSize: BN;
+    minimumBaseAssetTradeSize: BN;
     lastOraclePrice: BN;
 };
 export declare type UserPosition = {
@@ -228,6 +314,7 @@ export declare type UserPosition = {
     lastCumulativeFundingRate: BN;
     marketIndex: BN;
     quoteAssetAmount: BN;
+    openOrders: BN;
 };
 export declare type UserPositionsAccount = {
     positions: UserPosition[];
@@ -239,6 +326,59 @@ export declare type UserAccount = {
     cumulativeDeposits: BN;
     positions: PublicKey;
     totalFeePaid: BN;
+    totalTokenDiscount: BN;
+    totalReferralReward: BN;
+    totalRefereeDiscount: BN;
+};
+export declare type UserOrdersAccount = {
+    orders: Order[];
+    user: PublicKey;
+};
+export declare type Order = {
+    status: OrderStatus;
+    orderType: OrderType;
+    ts: BN;
+    orderId: BN;
+    userOrderId: number;
+    marketIndex: BN;
+    price: BN;
+    userBaseAssetAmount: BN;
+    baseAssetAmount: BN;
+    baseAssetAmountFilled: BN;
+    quoteAssetAmount: BN;
+    quoteAssetAmountFilled: BN;
+    fee: BN;
+    direction: PositionDirection;
+    reduceOnly: boolean;
+    triggerPrice: BN;
+    triggerCondition: OrderTriggerCondition;
+    discountTier: OrderDiscountTier;
+    referrer: PublicKey;
+    postOnly: boolean;
+    immediateOrCancel: boolean;
+    oraclePriceOffset: BN;
+};
+export declare type OrderParams = {
+    orderType: OrderType;
+    userOrderId: number;
+    direction: PositionDirection;
+    quoteAssetAmount: BN;
+    baseAssetAmount: BN;
+    price: BN;
+    marketIndex: BN;
+    reduceOnly: boolean;
+    postOnly: boolean;
+    immediateOrCancel: boolean;
+    triggerPrice: BN;
+    triggerCondition: OrderTriggerCondition;
+    positionLimit: BN;
+    oraclePriceOffset: BN;
+    padding0: boolean;
+    padding1: BN;
+    optionalAccounts: {
+        discountToken: boolean;
+        referrer: boolean;
+    };
 };
 export interface IWallet {
     signTransaction(tx: Transaction): Promise<Transaction>;
@@ -289,4 +429,8 @@ export declare type OracleGuardRails = {
     };
     useForLiquidations: boolean;
 };
-//# sourceMappingURL=types.d.ts.map
+export declare type OrderFillerRewardStructure = {
+    rewardNumerator: BN;
+    rewardDenominator: BN;
+    timeBasedRewardLowerBound: BN;
+};

package/lib/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TradeSide = exports.OracleSource = exports.PositionDirection = exports.SwapDirection = void 0;
+exports.TradeSide = exports.isVariant = exports.OrderTriggerCondition = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.PositionDirection = exports.SwapDirection = void 0;
 // # Utility Types / Enums / Constants
 class SwapDirection {
 }
@@ -17,6 +17,41 @@ class OracleSource {
 exports.OracleSource = OracleSource;
 OracleSource.PYTH = { pyth: {} };
 OracleSource.SWITCHBOARD = { switchboard: {} };
+class OrderType {
+}
+exports.OrderType = OrderType;
+OrderType.LIMIT = { limit: {} };
+OrderType.TRIGGER_MARKET = { triggerMarket: {} };
+OrderType.TRIGGER_LIMIT = { triggerLimit: {} };
+OrderType.MARKET = { market: {} };
+class OrderStatus {
+}
+exports.OrderStatus = OrderStatus;
+OrderStatus.INIT = { init: {} };
+OrderStatus.OPEN = { open: {} };
+class OrderDiscountTier {
+}
+exports.OrderDiscountTier = OrderDiscountTier;
+OrderDiscountTier.NONE = { none: {} };
+OrderDiscountTier.FIRST = { first: {} };
+OrderDiscountTier.SECOND = { second: {} };
+OrderDiscountTier.THIRD = { third: {} };
+OrderDiscountTier.FOURTH = { fourth: {} };
+class OrderAction {
+}
+exports.OrderAction = OrderAction;
+OrderAction.PLACE = { place: {} };
+OrderAction.CANCEL = { cancel: {} };
+OrderAction.FILL = { fill: {} };
+class OrderTriggerCondition {
+}
+exports.OrderTriggerCondition = OrderTriggerCondition;
+OrderTriggerCondition.ABOVE = { above: {} };
+OrderTriggerCondition.BELOW = { below: {} };
+function isVariant(object, type) {
+    return object.hasOwnProperty(type);
+}
+exports.isVariant = isVariant;
 var TradeSide;
 (function (TradeSide) {
     TradeSide[TradeSide["None"] = 0] = "None";

package/lib/util/computeUnits.d.ts

@@ -1,3 +1,2 @@
 import { Connection, Finality, PublicKey } from '@solana/web3.js';
 export declare function findComputeUnitConsumption(programId: PublicKey, connection: Connection, txSignature: string, commitment?: Finality): Promise<number[]>;
-//# sourceMappingURL=computeUnits.d.ts.map

package/lib/util/tps.d.ts

@@ -1,3 +1,2 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 export declare function estimateTps(programId: PublicKey, connection: Connection, failed: boolean): Promise<number>;
-//# sourceMappingURL=tps.d.ts.map

package/lib/wallet.d.ts

@@ -7,4 +7,3 @@ export declare class Wallet implements IWallet {
     signAllTransactions(txs: Transaction[]): Promise<Transaction[]>;
     get publicKey(): PublicKey;
 }
-//# sourceMappingURL=wallet.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.19-master.2",
+	"version": "0.1.21-master.4",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -10,6 +10,7 @@
 		"url": "git@github.com:drift-labs/protocol-v1.git"
 	},
 	"scripts": {
+		"lint": "eslint './**/*.{ts,tsx}' --quiet",
 		"build": "yarn clean && tsc",
 		"clean": "rm -rf lib",
 		"patch-and-pub": "npm version patch --force && npm publish"
@@ -31,8 +32,15 @@
 		"@pythnetwork/client": "^2.5.1",
 		"@solana/spl-token": "^0.1.6",
 		"@solana/web3.js": "^1.22.0",
-		"@types/bn.js": "^5.1.0",
-		"strict-event-emitter-types": "^2.0.0"
+		"strict-event-emitter-types": "^2.0.0",
+		"uuid": "^8.3.2"
+	},
+	"devDependencies": {
+		"@typescript-eslint/eslint-plugin": "^4.28.0",
+		"@typescript-eslint/parser": "^4.28.0",
+		"eslint": "^7.29.0",
+		"eslint-config-prettier": "^8.3.0",
+		"eslint-plugin-prettier": "^3.4.0"
 	},
 	"description": "SDK for Drift Protocol v1",
 	"engines": {