@drift-labs/sdk 0.2.0-master.2 → 0.2.0-master.20

package/lib/math/oracles.js

@@ -1,19 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOracleValid = void 0;
+exports.isOracleTooDivergent = exports.isOracleValid = void 0;
 const numericConstants_1 = require("../constants/numericConstants");
 const index_1 = require("../index");
 function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
-    const isOraclePriceNonPositive = oraclePriceData.price.lt(numericConstants_1.ZERO);
+    const isOraclePriceNonPositive = oraclePriceData.price.lte(numericConstants_1.ZERO);
     const isOraclePriceTooVolatile = oraclePriceData.price
         .div(index_1.BN.max(numericConstants_1.ONE, amm.lastOraclePriceTwap))
         .gt(oracleGuardRails.validity.tooVolatileRatio) ||
         amm.lastOraclePriceTwap
             .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.price))
             .gt(oracleGuardRails.validity.tooVolatileRatio);
-    const isConfidenceTooLarge = oraclePriceData.price
-        .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.confidence))
-        .lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+    const isConfidenceTooLarge = new index_1.BN(amm.baseSpread)
+        .add(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.confidence))
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(oraclePriceData.price)
+        .gt(new index_1.BN(amm.maxSpread));
     const oracleIsStale = oraclePriceData.slot
         .sub(new index_1.BN(slot))
         .gt(oracleGuardRails.validity.slotsBeforeStale);
@@ -24,3 +26,21 @@ function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
         isConfidenceTooLarge);
 }
 exports.isOracleValid = isOracleValid;
+function isOracleTooDivergent(amm, oraclePriceData, oracleGuardRails, now) {
+    const sinceLastUpdate = now.sub(amm.lastOraclePriceTwapTs);
+    const sinceStart = index_1.BN.max(numericConstants_1.ZERO, new index_1.BN(60 * 5).sub(sinceLastUpdate));
+    const oracleTwap5min = amm.lastOraclePriceTwap5min
+        .mul(sinceStart)
+        .add(oraclePriceData.price)
+        .mul(sinceLastUpdate)
+        .div(sinceStart.add(sinceLastUpdate));
+    const oracleSpread = oracleTwap5min.sub(oraclePriceData.price);
+    const oracleSpreadPct = oracleSpread
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(oracleTwap5min);
+    const tooDivergent = oracleSpreadPct
+        .abs()
+        .gte(numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(oracleGuardRails.priceDivergence.markOracleDivergenceNumerator).div(oracleGuardRails.priceDivergence.markOracleDivergenceDenominator));
+    return tooDivergent;
+}
+exports.isOracleTooDivergent = isOracleTooDivergent;

package/lib/math/orders.d.ts

@@ -1,10 +1,13 @@
 /// <reference types="bn.js" />
 import { ClearingHouseUser } from '../clearingHouseUser';
-import { Order } from '../types';
+import { MarketAccount, Order } from '../types';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
 export declare function isOrderRiskIncreasing(user: ClearingHouseUser, order: Order): boolean;
 export declare function isOrderRiskIncreasingInSameDirection(user: ClearingHouseUser, order: Order): boolean;
 export declare function isOrderReduceOnly(user: ClearingHouseUser, order: Order): boolean;
 export declare function standardizeBaseAssetAmount(baseAssetAmount: BN, stepSize: BN): BN;
-export declare function getLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number): BN;
+export declare function getLimitPrice(order: Order, market: MarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
+export declare function isFillableByVAMM(order: Order, market: MarketAccount, oraclePriceData: OraclePriceData, slot: number): boolean;
+export declare function calculateBaseAssetAmountForAmmToFulfill(order: Order, market: MarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
+export declare function calculateBaseAssetAmountToFillUpToLimitPrice(order: Order, market: MarketAccount, limitPrice: BN, oraclePriceData: OraclePriceData): BN;

package/lib/math/orders.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
+exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
 const types_1 = require("../types");
 const numericConstants_1 = require("../constants/numericConstants");
 const anchor_1 = require("@project-serum/anchor");
 const auction_1 = require("./auction");
+const market_1 = require("./market");
+const amm_1 = require("./amm");
 function isOrderRiskIncreasing(user, order) {
     if ((0, types_1.isVariant)(order.status, 'init')) {
         return false;
@@ -78,26 +80,65 @@ function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
     return baseAssetAmount.sub(remainder);
 }
 exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
-function getLimitPrice(order, oraclePriceData, slot) {
+function getLimitPrice(order, market, oraclePriceData, slot) {
     let limitPrice;
     if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
-        const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-        if (order.postOnly) {
-            limitPrice = (0, types_1.isVariant)(order.direction, 'long')
-                ? anchor_1.BN.min(order.price, floatingPrice)
-                : anchor_1.BN.max(order.price, floatingPrice);
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+    }
+    else if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
+        if ((0, auction_1.isAuctionComplete)(order, slot)) {
+            limitPrice = (0, auction_1.getAuctionPrice)(order, slot);
+        }
+        else if (!order.price.eq(numericConstants_1.ZERO)) {
+            limitPrice = order.price;
+        }
+        else if ((0, types_1.isVariant)(order.direction, 'long')) {
+            const askPrice = (0, market_1.calculateAskPrice)(market, oraclePriceData);
+            const delta = askPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
+            limitPrice = askPrice.add(delta);
         }
         else {
-            limitPrice = floatingPrice;
+            const bidPrice = (0, market_1.calculateBidPrice)(market, oraclePriceData);
+            const delta = bidPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
+            limitPrice = bidPrice.sub(delta);
         }
     }
-    else if ((0, types_1.isVariant)(order.orderType, 'market') ||
-        (0, types_1.isVariant)(order.orderType, 'triggerMarket')) {
-        limitPrice = (0, auction_1.getAuctionPrice)(order, slot);
-    }
     else {
         limitPrice = order.price;
     }
     return limitPrice;
 }
 exports.getLimitPrice = getLimitPrice;
+function isFillableByVAMM(order, market, oraclePriceData, slot) {
+    return ((0, auction_1.isAuctionComplete)(order, slot) &&
+        !calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).eq(numericConstants_1.ZERO));
+}
+exports.isFillableByVAMM = isFillableByVAMM;
+function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot) {
+    if ((0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']) &&
+        order.triggered === false) {
+        return numericConstants_1.ZERO;
+    }
+    const limitPrice = getLimitPrice(order, market, oraclePriceData, slot);
+    const baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, market, limitPrice, oraclePriceData);
+    const maxBaseAssetAmount = (0, amm_1.calculateMaxBaseAssetAmountFillable)(market.amm, order.direction);
+    return anchor_1.BN.min(maxBaseAssetAmount, baseAssetAmount);
+}
+exports.calculateBaseAssetAmountForAmmToFulfill = calculateBaseAssetAmountForAmmToFulfill;
+function calculateBaseAssetAmountToFillUpToLimitPrice(order, market, limitPrice, oraclePriceData) {
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction, oraclePriceData);
+    const baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
+    // Check that directions are the same
+    const sameDirection = isSameDirection(direction, order.direction);
+    if (!sameDirection) {
+        return numericConstants_1.ZERO;
+    }
+    return baseAssetAmount.gt(order.baseAssetAmount)
+        ? order.baseAssetAmount
+        : baseAssetAmount;
+}
+exports.calculateBaseAssetAmountToFillUpToLimitPrice = calculateBaseAssetAmountToFillUpToLimitPrice;
+function isSameDirection(firstDirection, secondDirection) {
+    return (((0, types_1.isVariant)(firstDirection, 'long') && (0, types_1.isVariant)(secondDirection, 'long')) ||
+        ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
+}

package/lib/math/position.d.ts

@@ -17,9 +17,11 @@ export declare function calculateBaseAssetValue(market: MarketAccount, userPosit
  * @param market
  * @param marketPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 export declare function calculatePositionPNL(market: MarketAccount, marketPosition: UserPosition, withFunding: boolean, oraclePriceData: OraclePriceData): BN;
+export declare function calculateUnsettledPnl(market: MarketAccount, marketPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
 /**
  *
  * @param market
@@ -34,6 +36,12 @@ export declare function positionIsAvailable(position: UserPosition): boolean;
  * @returns Precision: MARK_PRICE_PRECISION (10^10)
  */
 export declare function calculateEntryPrice(userPosition: UserPosition): BN;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+export declare function calculateCostBasis(userPosition: UserPosition): BN;
 export declare function findDirectionToClose(userPosition: UserPosition): PositionDirection;
 export declare function positionCurrentDirection(userPosition: UserPosition): PositionDirection;
 export declare function isEmptyPosition(userPosition: UserPosition): boolean;

package/lib/math/position.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateCostBasis = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculateUnsettledPnl = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
 const __1 = require("../");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
+const margin_1 = require("./margin");
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -53,20 +54,20 @@ exports.calculateBaseAssetValue = calculateBaseAssetValue;
  * @param market
  * @param marketPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 function calculatePositionPNL(market, marketPosition, withFunding = false, oraclePriceData) {
     if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-        return numericConstants_1.ZERO;
-    }
-    const baseAssetValue = calculateBaseAssetValue(market, marketPosition, oraclePriceData);
-    let pnl;
-    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
-        pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
-    }
-    else {
-        pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue);
+        return marketPosition.quoteAssetAmount;
     }
+    const baseAssetValue = (0, margin_1.calculateMarginBaseAssetValue)(market, marketPosition, oraclePriceData);
+    const baseAssetValueSign = marketPosition.baseAssetAmount.isNeg()
+        ? new __1.BN(-1)
+        : new __1.BN(1);
+    let pnl = baseAssetValue
+        .mul(baseAssetValueSign)
+        .add(marketPosition.quoteAssetAmount);
     if (withFunding) {
         const fundingRatePnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
         pnl = pnl.add(fundingRatePnL);
@@ -74,6 +75,19 @@ function calculatePositionPNL(market, marketPosition, withFunding = false, oracl
     return pnl;
 }
 exports.calculatePositionPNL = calculatePositionPNL;
+function calculateUnsettledPnl(market, marketPosition, oraclePriceData) {
+    const unrealizedPnl = calculatePositionPNL(market, marketPosition, true, oraclePriceData);
+    let unsettledPnl = unrealizedPnl;
+    if (unrealizedPnl.gt(numericConstants_1.ZERO)) {
+        const fundingPnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        const maxPositivePnl = __1.BN.max(marketPosition.quoteAssetAmount
+            .sub(marketPosition.quoteEntryAmount)
+            .add(fundingPnL), numericConstants_1.ZERO);
+        unsettledPnl = __1.BN.min(maxPositivePnl, unrealizedPnl);
+    }
+    return unsettledPnl;
+}
+exports.calculateUnsettledPnl = calculateUnsettledPnl;
 /**
  *
  * @param market
@@ -101,7 +115,10 @@ function calculatePositionFundingPNL(market, marketPosition) {
 }
 exports.calculatePositionFundingPNL = calculatePositionFundingPNL;
 function positionIsAvailable(position) {
-    return position.baseAssetAmount.eq(numericConstants_1.ZERO) && position.openOrders.eq(numericConstants_1.ZERO);
+    return (position.baseAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.openOrders.eq(numericConstants_1.ZERO) &&
+        position.quoteAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.lpShares.eq(numericConstants_1.ZERO));
 }
 exports.positionIsAvailable = positionIsAvailable;
 /**
@@ -113,13 +130,29 @@ function calculateEntryPrice(userPosition) {
     if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
-    return userPosition.quoteAssetAmount
+    return userPosition.quoteEntryAmount
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(userPosition.baseAssetAmount)
         .abs();
 }
 exports.calculateEntryPrice = calculateEntryPrice;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+function calculateCostBasis(userPosition) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteAssetAmount
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(userPosition.baseAssetAmount)
+        .abs();
+}
+exports.calculateCostBasis = calculateCostBasis;
 function findDirectionToClose(userPosition) {
     return userPosition.baseAssetAmount.gt(numericConstants_1.ZERO)
         ? types_1.PositionDirection.SHORT

package/lib/math/trade.d.ts

@@ -33,7 +33,7 @@ export declare function calculateTradeSlippage(direction: PositionDirection, amo
  * 	| 'acquiredBase' =>  positive/negative change in user's base : BN AMM_RESERVE_PRECISION
  * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
  */
-export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: MarketAccount, inputAssetType: AssetType, oraclePriceData: OraclePriceData, useSpread?: boolean): [BN, BN];
+export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: MarketAccount, inputAssetType: AssetType, oraclePriceData: OraclePriceData, useSpread?: boolean): [BN, BN, BN];
 /**
  * calculateTargetPriceTrade
  * simple function for finding arbitraging trades

package/lib/math/trade.js

@@ -43,15 +43,11 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
     }
-    const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread);
-    const swapDirection = (0, types_2.isVariant)(direction, 'long')
-        ? types_1.SwapDirection.REMOVE
-        : types_1.SwapDirection.ADD;
-    const quoteAssetAmountAcquired = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), market.amm.pegMultiplier, swapDirection);
-    const entryPrice = quoteAssetAmountAcquired
+    const [acquiredBaseReserve, acquiredQuoteReserve, acquiredQuoteAssetAmount] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread);
+    const entryPrice = acquiredQuoteAssetAmount
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .div(acquiredBase.abs());
+        .div(acquiredBaseReserve.abs());
     let amm;
     if (useSpread && market.amm.baseSpread > 0) {
         const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
@@ -65,7 +61,7 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
     else {
         amm = market.amm;
     }
-    const newPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve.sub(acquiredBase), amm.quoteAssetReserve.sub(acquiredQuote), amm.pegMultiplier);
+    const newPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve.sub(acquiredBaseReserve), amm.quoteAssetReserve.sub(acquiredQuoteReserve), amm.pegMultiplier);
     if (direction == types_1.PositionDirection.SHORT) {
         (0, assert_1.assert)(newPrice.lte(oldPrice));
     }
@@ -98,7 +94,7 @@ exports.calculateTradeSlippage = calculateTradeSlippage;
  */
 function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType = 'quote', oraclePriceData, useSpread = true) {
     if (amount.eq(numericConstants_1.ZERO)) {
-        return [numericConstants_1.ZERO, numericConstants_1.ZERO];
+        return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
     }
     const swapDirection = (0, amm_1.getSwapDirection)(inputAssetType, direction);
     let amm;
@@ -117,7 +113,8 @@ function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType
     const [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, inputAssetType, amount, swapDirection);
     const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
     const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-    return [acquiredBase, acquiredQuote];
+    const acquiredQuoteAssetAmount = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
+    return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
 }
 exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
 /**

package/lib/orderParams.d.ts

@@ -1,7 +1,16 @@
 /// <reference types="bn.js" />
-import { OrderParams, OrderTriggerCondition, PositionDirection } from './types';
+import { OptionalOrderParams, OrderTriggerCondition } 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, postOnly?: boolean, oraclePriceOffset?: BN, immediateOrCancel?: boolean): 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;
+export declare function getLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+    price: BN;
+}): OptionalOrderParams;
+export declare function getTriggerMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+    triggerCondition: OrderTriggerCondition;
+    triggerPrice: BN;
+}): OptionalOrderParams;
+export declare function getTriggerLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+    triggerCondition: OrderTriggerCondition;
+    triggerPrice: BN;
+    price: BN;
+}): OptionalOrderParams;
+export declare function getMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType'>): OptionalOrderParams;

package/lib/orderParams.js

@@ -2,107 +2,19 @@
 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, postOnly = false, oraclePriceOffset = numericConstants_1.ZERO, immediateOrCancel = false) {
-    return {
-        orderType: types_1.OrderType.LIMIT,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly,
-        immediateOrCancel,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
-        triggerPrice: numericConstants_1.ZERO,
-        oraclePriceOffset,
-    };
+function getLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.LIMIT });
 }
 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,
-    };
+function getTriggerMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_MARKET });
 }
 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,
-    };
+function getTriggerLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_LIMIT });
 }
 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,
-    };
+function getMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.MARKET });
 }
 exports.getMarketOrderParams = getMarketOrderParams;

package/lib/slot/SlotSubscriber.d.ts

@@ -1,9 +1,16 @@
+/// <reference types="node" />
 import { Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
 declare type SlotSubscriberConfig = {};
+export interface SlotSubscriberEvents {
+    newSlot: (newSlot: number) => void;
+}
 export declare class SlotSubscriber {
     private connection;
     currentSlot: number;
     subscriptionId: number;
+    eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
     constructor(connection: Connection, _config?: SlotSubscriberConfig);
     subscribe(): Promise<void>;
     getSlot(): number;

package/lib/slot/SlotSubscriber.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SlotSubscriber = void 0;
+const events_1 = require("events");
 class SlotSubscriber {
     constructor(connection, _config) {
         this.connection = connection;
+        this.eventEmitter = new events_1.EventEmitter();
     }
     async subscribe() {
         this.currentSlot = await this.connection.getSlot('confirmed');
         this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
             this.currentSlot = slotInfo.slot;
+            this.eventEmitter.emit('newSlot', slotInfo.slot);
         });
     }
     getSlot() {

package/lib/{mockUSDCFaucet.d.ts → tokenFaucet.d.ts}

@@ -5,22 +5,25 @@ import { AccountInfo } from '@solana/spl-token';
 import { ConfirmOptions, Connection, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
 import { BN } from '.';
 import { IWallet } from './types';
-export declare class MockUSDCFaucet {
+export declare class TokenFaucet {
     connection: Connection;
     wallet: IWallet;
     program: Program;
     provider: AnchorProvider;
+    mint: PublicKey;
     opts?: ConfirmOptions;
-    constructor(connection: Connection, wallet: IWallet, programId: PublicKey, opts?: ConfirmOptions);
-    getMockUSDCFaucetStatePublicKeyAndNonce(): Promise<[
+    constructor(connection: Connection, wallet: IWallet, programId: PublicKey, mint: PublicKey, opts?: ConfirmOptions);
+    getFaucetConfigPublicKeyAndNonce(): Promise<[
         PublicKey,
         number
     ]>;
-    mockUSDCFaucetStatePublicKey?: PublicKey;
-    getMockUSDCFaucetStatePublicKey(): Promise<PublicKey>;
+    getMintAuthority(): Promise<PublicKey>;
+    getFaucetConfigPublicKey(): Promise<PublicKey>;
     initialize(): Promise<TransactionSignature>;
     fetchState(): Promise<any>;
+    private mintToUserIx;
     mintToUser(userTokenAccount: PublicKey, amount: BN): Promise<TransactionSignature>;
+    transferMintAuthority(): Promise<TransactionSignature>;
     createAssociatedTokenAccountAndMintTo(userPublicKey: PublicKey, amount: BN): Promise<[PublicKey, TransactionSignature]>;
     createAssociatedTokenAccountAndMintToInstructions(userPublicKey: PublicKey, amount: BN): Promise<[PublicKey, TransactionInstruction, TransactionInstruction]>;
     getAssosciatedMockUSDMintAddress(props: {