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

package/src/math/amm.js

@@ -1,369 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
-const anchor_1 = require("@project-serum/anchor");
-const numericConstants_1 = require("../constants/numericConstants");
-const types_1 = require("../types");
-const assert_1 = require("../assert/assert");
-const __1 = require("..");
-const repeg_1 = require("./repeg");
-function calculatePegFromTargetPrice(targetPrice, baseAssetReserve, quoteAssetReserve) {
-    return targetPrice
-        .mul(baseAssetReserve)
-        .div(quoteAssetReserve)
-        .add(numericConstants_1.PRICE_DIV_PEG.div(new anchor_1.BN(2)))
-        .div(numericConstants_1.PRICE_DIV_PEG);
-}
-exports.calculatePegFromTargetPrice = calculatePegFromTargetPrice;
-function calculateOptimalPegAndBudget(amm, oraclePriceData) {
-    const markPriceBefore = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
-    const targetPrice = oraclePriceData.price;
-    const newPeg = calculatePegFromTargetPrice(targetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
-    const prePegCost = repeg_1.calculateRepegCost(amm, newPeg);
-    const totalFeeLB = amm.totalExchangeFee.div(new anchor_1.BN(2));
-    const budget = anchor_1.BN.max(numericConstants_1.ZERO, amm.totalFeeMinusDistributions.sub(totalFeeLB));
-    if (budget.lt(prePegCost)) {
-        const maxPriceSpread = new anchor_1.BN(amm.maxSpread)
-            .mul(targetPrice)
-            .div(numericConstants_1.BID_ASK_SPREAD_PRECISION);
-        let newTargetPrice;
-        let newOptimalPeg;
-        let newBudget;
-        const targetPriceGap = markPriceBefore.sub(targetPrice);
-        if (targetPriceGap.abs().gt(maxPriceSpread)) {
-            const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
-            if (targetPriceGap.lt(new anchor_1.BN(0))) {
-                newTargetPrice = markPriceBefore.add(markAdj);
-            }
-            else {
-                newTargetPrice = markPriceBefore.sub(markAdj);
-            }
-            newOptimalPeg = calculatePegFromTargetPrice(newTargetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
-            newBudget = repeg_1.calculateRepegCost(amm, newOptimalPeg);
-            return [newTargetPrice, newOptimalPeg, newBudget, false];
-        }
-    }
-    return [targetPrice, newPeg, budget, true];
-}
-exports.calculateOptimalPegAndBudget = calculateOptimalPegAndBudget;
-function calculateNewAmm(amm, oraclePriceData) {
-    let pKNumer = new anchor_1.BN(1);
-    let pKDenom = new anchor_1.BN(1);
-    const [targetPrice, _newPeg, budget, checkLowerBound] = calculateOptimalPegAndBudget(amm, oraclePriceData);
-    let prePegCost = repeg_1.calculateRepegCost(amm, _newPeg);
-    let newPeg = _newPeg;
-    if (prePegCost.gt(budget) && checkLowerBound) {
-        [pKNumer, pKDenom] = [new anchor_1.BN(999), new anchor_1.BN(1000)];
-        const deficitMadeup = repeg_1.calculateAdjustKCost(amm, pKNumer, pKDenom);
-        assert_1.assert(deficitMadeup.lte(new anchor_1.BN(0)));
-        prePegCost = budget.add(deficitMadeup.abs());
-        const newAmm = Object.assign({}, amm);
-        newAmm.baseAssetReserve = newAmm.baseAssetReserve.mul(pKNumer).div(pKDenom);
-        newAmm.sqrtK = newAmm.sqrtK.mul(pKNumer).div(pKDenom);
-        const invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
-        newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
-        const directionToClose = amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
-            ? types_1.PositionDirection.SHORT
-            : types_1.PositionDirection.LONG;
-        const [newQuoteAssetReserve, _newBaseAssetReserve] = calculateAmmReservesAfterSwap(newAmm, 'base', amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
-        newAmm.terminalQuoteAssetReserve = newQuoteAssetReserve;
-        newPeg = repeg_1.calculateBudgetedPeg(newAmm, prePegCost, targetPrice);
-        prePegCost = repeg_1.calculateRepegCost(newAmm, newPeg);
-    }
-    return [prePegCost, pKNumer, pKDenom, newPeg];
-}
-exports.calculateNewAmm = calculateNewAmm;
-function calculateUpdatedAMM(amm, oraclePriceData) {
-    if (amm.curveUpdateIntensity == 0) {
-        return amm;
-    }
-    const newAmm = Object.assign({}, amm);
-    const [prepegCost, pKNumer, pKDenom, newPeg] = calculateNewAmm(amm, oraclePriceData);
-    newAmm.baseAssetReserve = newAmm.baseAssetReserve.mul(pKNumer).div(pKDenom);
-    newAmm.sqrtK = newAmm.sqrtK.mul(pKNumer).div(pKDenom);
-    const invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
-    newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
-    newAmm.pegMultiplier = newPeg;
-    const directionToClose = amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
-        ? types_1.PositionDirection.SHORT
-        : types_1.PositionDirection.LONG;
-    const [newQuoteAssetReserve, _newBaseAssetReserve] = calculateAmmReservesAfterSwap(newAmm, 'base', amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
-    newAmm.terminalQuoteAssetReserve = newQuoteAssetReserve;
-    newAmm.totalFeeMinusDistributions =
-        newAmm.totalFeeMinusDistributions.sub(prepegCost);
-    return newAmm;
-}
-exports.calculateUpdatedAMM = calculateUpdatedAMM;
-function calculateUpdatedAMMSpreadReserves(amm, direction, oraclePriceData) {
-    const newAmm = calculateUpdatedAMM(amm, oraclePriceData);
-    const dirReserves = calculateSpreadReserves(newAmm, direction, oraclePriceData);
-    const result = {
-        baseAssetReserve: dirReserves.baseAssetReserve,
-        quoteAssetReserve: dirReserves.quoteAssetReserve,
-        sqrtK: newAmm.sqrtK,
-        newPeg: newAmm.pegMultiplier,
-    };
-    return result;
-}
-exports.calculateUpdatedAMMSpreadReserves = calculateUpdatedAMMSpreadReserves;
-function calculateBidAskPrice(amm, oraclePriceData, withUpdate = true) {
-    let newAmm;
-    if (withUpdate) {
-        newAmm = calculateUpdatedAMM(amm, oraclePriceData);
-    }
-    else {
-        newAmm = amm;
-    }
-    const askReserves = calculateSpreadReserves(newAmm, types_1.PositionDirection.LONG, oraclePriceData);
-    const bidReserves = calculateSpreadReserves(newAmm, types_1.PositionDirection.SHORT, oraclePriceData);
-    const askPrice = calculatePrice(askReserves.baseAssetReserve, askReserves.quoteAssetReserve, newAmm.pegMultiplier);
-    const bidPrice = calculatePrice(bidReserves.baseAssetReserve, bidReserves.quoteAssetReserve, newAmm.pegMultiplier);
-    return [bidPrice, askPrice];
-}
-exports.calculateBidAskPrice = calculateBidAskPrice;
-/**
- * Calculates a price given an arbitrary base and quote amount (they must have the same precision)
- *
- * @param baseAssetReserves
- * @param quoteAssetReserves
- * @param pegMultiplier
- * @returns price : Precision MARK_PRICE_PRECISION
- */
-function calculatePrice(baseAssetReserves, quoteAssetReserves, pegMultiplier) {
-    if (baseAssetReserves.abs().lte(numericConstants_1.ZERO)) {
-        return new anchor_1.BN(0);
-    }
-    return quoteAssetReserves
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .mul(pegMultiplier)
-        .div(numericConstants_1.PEG_PRECISION)
-        .div(baseAssetReserves);
-}
-exports.calculatePrice = calculatePrice;
-/**
- * Calculates what the amm reserves would be after swapping a quote or base asset amount.
- *
- * @param amm
- * @param inputAssetType
- * @param swapAmount
- * @param swapDirection
- * @returns quoteAssetReserve and baseAssetReserve after swap. : Precision AMM_RESERVE_PRECISION
- */
-function calculateAmmReservesAfterSwap(amm, inputAssetType, swapAmount, swapDirection) {
-    assert_1.assert(swapAmount.gte(numericConstants_1.ZERO), 'swapAmount must be greater than 0');
-    let newQuoteAssetReserve;
-    let newBaseAssetReserve;
-    if (inputAssetType === 'quote') {
-        swapAmount = swapAmount
-            .mul(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
-            .div(amm.pegMultiplier);
-        [newQuoteAssetReserve, newBaseAssetReserve] = calculateSwapOutput(amm.quoteAssetReserve, swapAmount, swapDirection, amm.sqrtK.mul(amm.sqrtK));
-    }
-    else {
-        [newBaseAssetReserve, newQuoteAssetReserve] = calculateSwapOutput(amm.baseAssetReserve, swapAmount, swapDirection, amm.sqrtK.mul(amm.sqrtK));
-    }
-    return [newQuoteAssetReserve, newBaseAssetReserve];
-}
-exports.calculateAmmReservesAfterSwap = calculateAmmReservesAfterSwap;
-function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions) {
-    // inventory skew
-    const netBaseAssetValue = quoteAssetReserve
-        .sub(terminalQuoteAssetReserve)
-        .mul(pegMultiplier)
-        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-    const localBaseAssetValue = netBaseAssetAmount
-        .mul(markPrice)
-        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
-    const effectiveLeverage = localBaseAssetValue.sub(netBaseAssetValue).toNumber() /
-        (Math.max(0, totalFeeMinusDistributions.toNumber()) + 1) +
-        1 / numericConstants_1.QUOTE_PRECISION.toNumber();
-    return effectiveLeverage;
-}
-exports.calculateEffectiveLeverage = calculateEffectiveLeverage;
-function calculateMaxSpread(marginRatioInitial) {
-    const maxTargetSpread = new anchor_1.BN(marginRatioInitial)
-        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(numericConstants_1.MARGIN_PRECISION))
-        .toNumber();
-    return maxTargetSpread;
-}
-exports.calculateMaxSpread = calculateMaxSpread;
-function calculateSpreadBN(baseSpread, lastOracleMarkSpreadPct, lastOracleConfPct, maxSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions) {
-    let longSpread = baseSpread / 2;
-    let shortSpread = baseSpread / 2;
-    if (lastOracleMarkSpreadPct.gt(numericConstants_1.ZERO)) {
-        shortSpread = Math.max(shortSpread, lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber());
-    }
-    else if (lastOracleMarkSpreadPct.lt(numericConstants_1.ZERO)) {
-        longSpread = Math.max(longSpread, lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber());
-    }
-    const maxTargetSpread = maxSpread;
-    const MAX_INVENTORY_SKEW = 5;
-    const effectiveLeverage = calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions);
-    if (totalFeeMinusDistributions.gt(numericConstants_1.ZERO)) {
-        const spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
-        if (netBaseAssetAmount.gt(numericConstants_1.ZERO)) {
-            longSpread *= spreadScale;
-        }
-        else {
-            shortSpread *= spreadScale;
-        }
-    }
-    else {
-        longSpread *= MAX_INVENTORY_SKEW;
-        shortSpread *= MAX_INVENTORY_SKEW;
-    }
-    const totalSpread = longSpread + shortSpread;
-    if (totalSpread > maxTargetSpread) {
-        if (longSpread > shortSpread) {
-            longSpread = Math.min(longSpread, maxTargetSpread);
-            shortSpread = maxTargetSpread - longSpread;
-        }
-        else {
-            shortSpread = Math.min(shortSpread, maxTargetSpread);
-            longSpread = maxTargetSpread - shortSpread;
-        }
-    }
-    return [longSpread, shortSpread];
-}
-exports.calculateSpreadBN = calculateSpreadBN;
-function calculateSpread(amm, direction, oraclePriceData) {
-    if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
-        return amm.baseSpread / 2;
-    }
-    const markPrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
-    const targetPrice = (oraclePriceData === null || oraclePriceData === void 0 ? void 0 : oraclePriceData.price) || markPrice;
-    const confInterval = oraclePriceData.confidence || numericConstants_1.ZERO;
-    const targetMarkSpreadPct = markPrice
-        .sub(targetPrice)
-        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
-        .div(markPrice);
-    const confIntervalPct = confInterval
-        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
-        .div(markPrice);
-    const [longSpread, shortSpread] = calculateSpreadBN(amm.baseSpread, targetMarkSpreadPct, confIntervalPct, amm.maxSpread, amm.quoteAssetReserve, amm.terminalQuoteAssetReserve, amm.pegMultiplier, amm.netBaseAssetAmount, markPrice, amm.totalFeeMinusDistributions);
-    let spread;
-    if (types_1.isVariant(direction, 'long')) {
-        spread = longSpread;
-    }
-    else {
-        spread = shortSpread;
-    }
-    return spread;
-}
-exports.calculateSpread = calculateSpread;
-function calculateSpreadReserves(amm, direction, oraclePriceData) {
-    const spread = calculateSpread(amm, direction, oraclePriceData);
-    if (spread === 0) {
-        return {
-            baseAssetReserve: amm.baseAssetReserve,
-            quoteAssetReserve: amm.quoteAssetReserve,
-        };
-    }
-    const quoteAsserReserveDelta = amm.quoteAssetReserve.div(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(new anchor_1.BN(spread / 2)));
-    let quoteAssetReserve;
-    if (types_1.isVariant(direction, 'long')) {
-        quoteAssetReserve = amm.quoteAssetReserve.add(quoteAsserReserveDelta);
-    }
-    else {
-        quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAsserReserveDelta);
-    }
-    const baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
-    return {
-        baseAssetReserve,
-        quoteAssetReserve,
-    };
-}
-exports.calculateSpreadReserves = calculateSpreadReserves;
-/**
- * Helper function calculating constant product curve output. Agnostic to whether input asset is quote or base
- *
- * @param inputAssetReserve
- * @param swapAmount
- * @param swapDirection
- * @param invariant
- * @returns newInputAssetReserve and newOutputAssetReserve after swap. : Precision AMM_RESERVE_PRECISION
- */
-function calculateSwapOutput(inputAssetReserve, swapAmount, swapDirection, invariant) {
-    let newInputAssetReserve;
-    if (swapDirection === types_1.SwapDirection.ADD) {
-        newInputAssetReserve = inputAssetReserve.add(swapAmount);
-    }
-    else {
-        newInputAssetReserve = inputAssetReserve.sub(swapAmount);
-    }
-    const newOutputAssetReserve = invariant.div(newInputAssetReserve);
-    return [newInputAssetReserve, newOutputAssetReserve];
-}
-exports.calculateSwapOutput = calculateSwapOutput;
-/**
- * Translate long/shorting quote/base asset into amm operation
- *
- * @param inputAssetType
- * @param positionDirection
- */
-function getSwapDirection(inputAssetType, positionDirection) {
-    if (types_1.isVariant(positionDirection, 'long') && inputAssetType === 'base') {
-        return types_1.SwapDirection.REMOVE;
-    }
-    if (types_1.isVariant(positionDirection, 'short') && inputAssetType === 'quote') {
-        return types_1.SwapDirection.REMOVE;
-    }
-    return types_1.SwapDirection.ADD;
-}
-exports.getSwapDirection = getSwapDirection;
-/**
- * Helper function calculating terminal price of amm
- *
- * @param market
- * @returns cost : Precision MARK_PRICE_PRECISION
- */
-function calculateTerminalPrice(market) {
-    const directionToClose = market.amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
-        ? types_1.PositionDirection.SHORT
-        : types_1.PositionDirection.LONG;
-    const [newQuoteAssetReserve, newBaseAssetReserve] = calculateAmmReservesAfterSwap(market.amm, 'base', market.amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
-    const terminalPrice = newQuoteAssetReserve
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .mul(market.amm.pegMultiplier)
-        .div(numericConstants_1.PEG_PRECISION)
-        .div(newBaseAssetReserve);
-    return terminalPrice;
-}
-exports.calculateTerminalPrice = calculateTerminalPrice;
-function calculateMaxBaseAssetAmountToTrade(amm, limit_price, direction, oraclePriceData) {
-    const invariant = amm.sqrtK.mul(amm.sqrtK);
-    const newBaseAssetReserveSquared = invariant
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .mul(amm.pegMultiplier)
-        .div(limit_price)
-        .div(numericConstants_1.PEG_PRECISION);
-    const newBaseAssetReserve = __1.squareRootBN(newBaseAssetReserveSquared);
-    const baseAssetReserveBefore = calculateSpreadReserves(amm, direction, oraclePriceData).baseAssetReserve;
-    if (newBaseAssetReserve.gt(baseAssetReserveBefore)) {
-        return [
-            newBaseAssetReserve.sub(baseAssetReserveBefore),
-            types_1.PositionDirection.SHORT,
-        ];
-    }
-    else if (newBaseAssetReserve.lt(baseAssetReserveBefore)) {
-        return [
-            baseAssetReserveBefore.sub(newBaseAssetReserve),
-            types_1.PositionDirection.LONG,
-        ];
-    }
-    else {
-        console.log('tradeSize Too Small');
-        return [new anchor_1.BN(0), types_1.PositionDirection.LONG];
-    }
-}
-exports.calculateMaxBaseAssetAmountToTrade = calculateMaxBaseAssetAmountToTrade;
-function calculateQuoteAssetAmountSwapped(quoteAssetReserves, pegMultiplier, swapDirection) {
-    let quoteAssetAmount = quoteAssetReserves
-        .mul(pegMultiplier)
-        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-    if (types_1.isVariant(swapDirection, 'remove')) {
-        quoteAssetAmount = quoteAssetAmount.add(numericConstants_1.ONE);
-    }
-    return quoteAssetAmount;
-}
-exports.calculateQuoteAssetAmountSwapped = calculateQuoteAssetAmountSwapped;

package/src/orders.ts

@@ -1,91 +0,0 @@
-import { isVariant, MarketAccount, Order, PositionDirection } from './types';
-import { BN, standardizeBaseAssetAmount } from '.';
-import { ZERO } from './constants/numericConstants';
-import { calculateMaxBaseAssetAmountToTrade } from './math/amm';
-import { OraclePriceData } from '.';
-
-export function calculateBaseAssetAmountMarketCanExecute(
-	market: MarketAccount,
-	order: Order,
-	oraclePriceData?: OraclePriceData
-): BN {
-	if (isVariant(order.orderType, 'limit')) {
-		return calculateAmountToTradeForLimit(market, order, oraclePriceData);
-	} else if (isVariant(order.orderType, 'triggerLimit')) {
-		return calculateAmountToTradeForTriggerLimit(market, order);
-	} else if (isVariant(order.orderType, 'market')) {
-		return ZERO;
-	} else {
-		return calculateAmountToTradeForTriggerMarket(market, order);
-	}
-}
-
-export function calculateAmountToTradeForLimit(
-	market: MarketAccount,
-	order: Order,
-	oraclePriceData?: OraclePriceData
-): BN {
-	let limitPrice = order.price;
-	if (!order.oraclePriceOffset.eq(ZERO)) {
-		if (!oraclePriceData) {
-			throw Error(
-				'Cant calculate limit price for oracle offset oracle without OraclePriceData'
-			);
-		}
-		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-	}
-
-	const [maxAmountToTrade, direction] = 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 ZERO;
-	}
-
-	return baseAssetAmount.gt(order.baseAssetAmount)
-		? order.baseAssetAmount
-		: baseAssetAmount;
-}
-
-export function calculateAmountToTradeForTriggerLimit(
-	market: MarketAccount,
-	order: Order
-): BN {
-	if (!order.triggered) {
-		return ZERO;
-	}
-
-	return calculateAmountToTradeForLimit(market, order);
-}
-
-function isSameDirection(
-	firstDirection: PositionDirection,
-	secondDirection: PositionDirection
-): boolean {
-	return (
-		(isVariant(firstDirection, 'long') && isVariant(secondDirection, 'long')) ||
-		(isVariant(firstDirection, 'short') && isVariant(secondDirection, 'short'))
-	);
-}
-
-function calculateAmountToTradeForTriggerMarket(
-	market: MarketAccount,
-	order: Order
-): BN {
-	if (!order.triggered) {
-		return ZERO;
-	}
-
-	return order.baseAssetAmount;
-}

package/src/types.js

@@ -1,125 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultOrderParams = exports.LiquidationType = exports.TradeSide = exports.isOneOfVariant = exports.isVariant = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.DepositDirection = exports.PositionDirection = exports.BankBalanceType = exports.SwapDirection = void 0;
-const _1 = require(".");
-// # Utility Types / Enums / Constants
-class SwapDirection {
-}
-exports.SwapDirection = SwapDirection;
-SwapDirection.ADD = { add: {} };
-SwapDirection.REMOVE = { remove: {} };
-class BankBalanceType {
-}
-exports.BankBalanceType = BankBalanceType;
-BankBalanceType.DEPOSIT = { deposit: {} };
-BankBalanceType.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;
-OracleSource.PYTH = { pyth: {} };
-OracleSource.SWITCHBOARD = { switchboard: {} };
-OracleSource.QUOTE_ASSET = { quoteAsset: {} };
-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.EXPIRE = { expire: {} };
-OrderAction.FILL = { fill: {} };
-OrderAction.TRIGGER = { trigger: {} };
-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: {},
-};
-class OrderTriggerCondition {
-}
-exports.OrderTriggerCondition = OrderTriggerCondition;
-OrderTriggerCondition.ABOVE = { above: {} };
-OrderTriggerCondition.BELOW = { below: {} };
-function isVariant(object, type) {
-    return object.hasOwnProperty(type);
-}
-exports.isVariant = isVariant;
-function isOneOfVariant(object, types) {
-    return types.reduce((result, type) => {
-        return result || object.hasOwnProperty(type);
-    }, false);
-}
-exports.isOneOfVariant = isOneOfVariant;
-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 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: {},
-};
-exports.DefaultOrderParams = {
-    orderType: OrderType.MARKET,
-    userOrderId: 0,
-    direction: PositionDirection.LONG,
-    baseAssetAmount: _1.ZERO,
-    price: _1.ZERO,
-    marketIndex: _1.ZERO,
-    reduceOnly: false,
-    postOnly: false,
-    immediateOrCancel: false,
-    triggerPrice: _1.ZERO,
-    triggerCondition: OrderTriggerCondition.ABOVE,
-    positionLimit: _1.ZERO,
-    oraclePriceOffset: _1.ZERO,
-    padding0: _1.ZERO,
-    padding1: _1.ZERO,
-    optionalAccounts: {
-        discountToken: false,
-        referrer: false,
-    },
-};