@drift-labs/sdk 2.42.0-beta.6 → 2.42.0-beta.7

package/VERSION

@@ -1 +1 @@
-2.42.0-beta.6
+2.42.0-beta.7

package/lib/math/market.d.ts

@@ -26,7 +26,7 @@ export declare function calculateAskPrice(market: PerpMarketAccount, oraclePrice
 export declare function calculateNewMarketAfterTrade(baseAssetAmount: BN, direction: PositionDirection, market: PerpMarketAccount): PerpMarketAccount;
 export declare function calculateOracleReserveSpread(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
 export declare function calculateOracleSpread(price: BN, oraclePriceData: OraclePriceData): BN;
-export declare function calculateMarketMarginRatio(market: PerpMarketAccount, size: BN, marginCategory: MarginCategory): number;
+export declare function calculateMarketMarginRatio(market: PerpMarketAccount, size: BN, marginCategory: MarginCategory, customMarginRatio?: number): number;
 export declare function calculateUnrealizedAssetWeight(market: PerpMarketAccount, quoteSpotMarket: SpotMarketAccount, unrealizedPnl: BN, marginCategory: MarginCategory, oraclePriceData: OraclePriceData): BN;
 export declare function calculateMarketAvailablePNL(perpMarket: PerpMarketAccount, spotMarket: SpotMarketAccount): BN;
 export declare function calculateMarketMaxAvailableInsurance(perpMarket: PerpMarketAccount, spotMarket: SpotMarketAccount): BN;

package/lib/math/market.js

@@ -60,11 +60,12 @@ function calculateOracleSpread(price, oraclePriceData) {
     return price.sub(oraclePriceData.price);
 }
 exports.calculateOracleSpread = calculateOracleSpread;
-function calculateMarketMarginRatio(market, size, marginCategory) {
+function calculateMarketMarginRatio(market, size, marginCategory, customMarginRatio = 0) {
     let marginRatio;
     switch (marginCategory) {
         case 'Initial': {
-            marginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(market.marginRatioInitial), numericConstants_1.MARGIN_PRECISION).toNumber();
+            // use lowest leverage between max allowed and optional user custom max
+            marginRatio = Math.max((0, margin_1.calculateSizePremiumLiabilityWeight)(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(market.marginRatioInitial), numericConstants_1.MARGIN_PRECISION).toNumber(), customMarginRatio);
             break;
         }
         case 'Maintenance': {

package/lib/math/spotMarket.d.ts

@@ -1,4 +1,4 @@
 import { BN } from '@coral-xyz/anchor';
 import { MarginCategory, SpotBalanceType, SpotMarketAccount } from '../types';
 export declare function castNumberToSpotPrecision(value: number | BN, spotMarket: SpotMarketAccount): BN;
-export declare function calculateSpotMarketMarginRatio(market: SpotMarketAccount, oraclePrice: BN, marginCategory: MarginCategory, size: BN, balanceType: SpotBalanceType): number;
+export declare function calculateSpotMarketMarginRatio(market: SpotMarketAccount, oraclePrice: BN, marginCategory: MarginCategory, size: BN, balanceType: SpotBalanceType, customMarginRatio?: number): number;

package/lib/math/spotMarket.js

@@ -14,14 +14,20 @@ function castNumberToSpotPrecision(value, spotMarket) {
     }
 }
 exports.castNumberToSpotPrecision = castNumberToSpotPrecision;
-function calculateSpotMarketMarginRatio(market, oraclePrice, marginCategory, size, balanceType) {
+function calculateSpotMarketMarginRatio(market, oraclePrice, marginCategory, size, balanceType, customMarginRatio = 0) {
+    let marginRatio;
     if ((0, types_1.isVariant)(balanceType, 'deposit')) {
         const assetWeight = (0, spotBalance_1.calculateAssetWeight)(size, oraclePrice, market, marginCategory);
-        return numericConstants_1.MARGIN_PRECISION.sub(assetWeight).toNumber();
+        marginRatio = numericConstants_1.MARGIN_PRECISION.sub(assetWeight).toNumber();
     }
     else {
         const liabilityWeight = (0, spotBalance_1.calculateLiabilityWeight)(size, market, marginCategory);
-        return liabilityWeight.sub(numericConstants_1.MARGIN_PRECISION).toNumber();
+        marginRatio = liabilityWeight.sub(numericConstants_1.MARGIN_PRECISION).toNumber();
     }
+    if (marginCategory === 'Initial') {
+        // use lowest leverage between max allowed and optional user custom max
+        return Math.max(marginRatio, customMarginRatio);
+    }
+    return marginRatio;
 }
 exports.calculateSpotMarketMarginRatio = calculateSpotMarketMarginRatio;

package/lib/math/spotPosition.d.ts

@@ -10,9 +10,9 @@ export type OrderFillSimulation = {
     weightedTokenValue: BN;
     freeCollateralContribution: any;
 };
-export declare function getWorstCaseTokenAmounts(spotPosition: SpotPosition, spotMarketAccount: SpotMarketAccount, strictOraclePrice: StrictOraclePrice, marginCategory: MarginCategory): OrderFillSimulation;
-export declare function calculateWeightedTokenValue(tokenAmount: BN, tokenValue: BN, oraclePrice: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): {
+export declare function getWorstCaseTokenAmounts(spotPosition: SpotPosition, spotMarketAccount: SpotMarketAccount, strictOraclePrice: StrictOraclePrice, marginCategory: MarginCategory, customMarginRatio?: number): OrderFillSimulation;
+export declare function calculateWeightedTokenValue(tokenAmount: BN, tokenValue: BN, oraclePrice: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory, customMarginRatio?: number): {
     weight: BN;
     weightedTokenValue: BN;
 };
-export declare function simulateOrderFill(tokenAmount: BN, tokenValue: BN, openOrders: BN, strictOraclePrice: StrictOraclePrice, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): OrderFillSimulation;
+export declare function simulateOrderFill(tokenAmount: BN, tokenValue: BN, openOrders: BN, strictOraclePrice: StrictOraclePrice, spotMarket: SpotMarketAccount, marginCategory: MarginCategory, customMarginRatio?: number): OrderFillSimulation;

package/lib/math/spotPosition.js

@@ -2,16 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.simulateOrderFill = exports.calculateWeightedTokenValue = exports.getWorstCaseTokenAmounts = exports.isSpotPositionAvailable = void 0;
 const numericConstants_1 = require("../constants/numericConstants");
+const anchor_1 = require("@coral-xyz/anchor");
 const spotBalance_1 = require("./spotBalance");
 function isSpotPositionAvailable(position) {
     return position.scaledBalance.eq(numericConstants_1.ZERO) && position.openOrders === 0;
 }
 exports.isSpotPositionAvailable = isSpotPositionAvailable;
-function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory) {
+function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory, customMarginRatio) {
     const tokenAmount = (0, spotBalance_1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
     const tokenValue = (0, spotBalance_1.getStrictTokenValue)(tokenAmount, spotMarketAccount.decimals, strictOraclePrice);
     if (spotPosition.openBids.eq(numericConstants_1.ZERO) && spotPosition.openAsks.eq(numericConstants_1.ZERO)) {
-        const { weight, weightedTokenValue } = calculateWeightedTokenValue(tokenAmount, tokenValue, strictOraclePrice.current, spotMarketAccount, marginCategory);
+        const { weight, weightedTokenValue } = calculateWeightedTokenValue(tokenAmount, tokenValue, strictOraclePrice.current, spotMarketAccount, marginCategory, customMarginRatio);
         return {
             tokenAmount,
             ordersValue: numericConstants_1.ZERO,
@@ -21,8 +22,8 @@ function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, strictOracleP
             freeCollateralContribution: weightedTokenValue,
         };
     }
-    const bidsSimulation = simulateOrderFill(tokenAmount, tokenValue, spotPosition.openBids, strictOraclePrice, spotMarketAccount, marginCategory);
-    const asksSimulation = simulateOrderFill(tokenAmount, tokenValue, spotPosition.openAsks, strictOraclePrice, spotMarketAccount, marginCategory);
+    const bidsSimulation = simulateOrderFill(tokenAmount, tokenValue, spotPosition.openBids, strictOraclePrice, spotMarketAccount, marginCategory, customMarginRatio);
+    const asksSimulation = simulateOrderFill(tokenAmount, tokenValue, spotPosition.openAsks, strictOraclePrice, spotMarketAccount, marginCategory, customMarginRatio);
     if (asksSimulation.freeCollateralContribution.lt(bidsSimulation.freeCollateralContribution)) {
         return asksSimulation;
     }
@@ -31,7 +32,7 @@ function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, strictOracleP
     }
 }
 exports.getWorstCaseTokenAmounts = getWorstCaseTokenAmounts;
-function calculateWeightedTokenValue(tokenAmount, tokenValue, oraclePrice, spotMarket, marginCategory) {
+function calculateWeightedTokenValue(tokenAmount, tokenValue, oraclePrice, spotMarket, marginCategory, customMarginRatio) {
     let weight;
     if (tokenValue.gte(numericConstants_1.ZERO)) {
         weight = (0, spotBalance_1.calculateAssetWeight)(tokenAmount, oraclePrice, spotMarket, marginCategory);
@@ -39,6 +40,16 @@ function calculateWeightedTokenValue(tokenAmount, tokenValue, oraclePrice, spotM
     else {
         weight = (0, spotBalance_1.calculateLiabilityWeight)(tokenAmount.abs(), spotMarket, marginCategory);
     }
+    if (marginCategory === 'Initial' &&
+        customMarginRatio &&
+        spotMarket.marketIndex !== numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+        const userCustomAssetWeight = tokenValue.gte(numericConstants_1.ZERO)
+            ? anchor_1.BN.max(numericConstants_1.ZERO, numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION.subn(customMarginRatio))
+            : numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION.addn(customMarginRatio);
+        weight = tokenValue.gte(numericConstants_1.ZERO)
+            ? anchor_1.BN.min(weight, userCustomAssetWeight)
+            : anchor_1.BN.max(weight, userCustomAssetWeight);
+    }
     return {
         weight: weight,
         weightedTokenValue: tokenValue
@@ -47,13 +58,13 @@ function calculateWeightedTokenValue(tokenAmount, tokenValue, oraclePrice, spotM
     };
 }
 exports.calculateWeightedTokenValue = calculateWeightedTokenValue;
-function simulateOrderFill(tokenAmount, tokenValue, openOrders, strictOraclePrice, spotMarket, marginCategory) {
+function simulateOrderFill(tokenAmount, tokenValue, openOrders, strictOraclePrice, spotMarket, marginCategory, customMarginRatio) {
     const ordersValue = (0, spotBalance_1.getTokenValue)(openOrders.neg(), spotMarket.decimals, {
         price: strictOraclePrice.max(),
     });
     const tokenAmountAfterFill = tokenAmount.add(openOrders);
     const tokenValueAfterFill = tokenValue.add(ordersValue.neg());
-    const { weight, weightedTokenValue: weightedTokenValueAfterFill } = calculateWeightedTokenValue(tokenAmountAfterFill, tokenValueAfterFill, strictOraclePrice.current, spotMarket, marginCategory);
+    const { weight, weightedTokenValue: weightedTokenValueAfterFill } = calculateWeightedTokenValue(tokenAmountAfterFill, tokenValueAfterFill, strictOraclePrice.current, spotMarket, marginCategory, customMarginRatio);
     const freeCollateralContribution = weightedTokenValueAfterFill.add(ordersValue);
     return {
         tokenAmount: tokenAmountAfterFill,

package/lib/user.d.ts

@@ -187,7 +187,7 @@ export declare class User {
         spotAssetValue: BN;
         spotLiabilityValue: BN;
     }): BN;
-    getLeverageComponents(includeOpenOrders?: boolean): {
+    getLeverageComponents(includeOpenOrders?: boolean, marginCategory?: MarginCategory): {
         perpLiabilityValue: BN;
         perpPnl: BN;
         spotAssetValue: BN;

package/lib/user.js

@@ -411,7 +411,7 @@ class User {
         return this.getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex, freeCollateral, worstCaseBaseAssetAmount);
     }
     getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex, freeCollateral, baseAssetAmount) {
-        const marginRatio = (0, _1.calculateMarketMarginRatio)(this.driftClient.getPerpMarketAccount(marketIndex), baseAssetAmount, 'Initial');
+        const marginRatio = (0, _1.calculateMarketMarginRatio)(this.driftClient.getPerpMarketAccount(marketIndex), baseAssetAmount, 'Initial', this.getUserAccount().maxMarginRatio);
         return freeCollateral.mul(numericConstants_1.MARGIN_PRECISION).div(new _1.BN(marginRatio));
     }
     /**
@@ -577,7 +577,7 @@ class User {
                     continue;
                 }
             }
-            const { tokenAmount: worstCaseTokenAmount, ordersValue: worstCaseQuoteTokenAmount, } = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory !== null && marginCategory !== void 0 ? marginCategory : 'Initial');
+            const { tokenAmount: worstCaseTokenAmount, ordersValue: worstCaseQuoteTokenAmount, } = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory, this.getUserAccount().maxMarginRatio);
             if (worstCaseTokenAmount.gt(numericConstants_1.ZERO) && countForBase) {
                 const baseAssetValue = this.getSpotAssetValue(worstCaseTokenAmount, strictOraclePrice, spotMarketAccount, marginCategory);
                 totalAssetValue = totalAssetValue.add(baseAssetValue);
@@ -620,8 +620,9 @@ class User {
         let liabilityValue = (0, _1.getStrictTokenValue)(tokenAmount, spotMarketAccount.decimals, strictOraclePrice);
         if (marginCategory !== undefined) {
             let weight = (0, spotBalance_1.calculateLiabilityWeight)(tokenAmount, spotMarketAccount, marginCategory);
-            if (marginCategory === 'Initial') {
-                weight = _1.BN.max(weight, new _1.BN(this.getUserAccount().maxMarginRatio));
+            if (marginCategory === 'Initial' &&
+                spotMarketAccount.marketIndex !== numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+                weight = _1.BN.max(weight, numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION.addn(this.getUserAccount().maxMarginRatio));
             }
             if (liquidationBuffer !== undefined) {
                 weight = weight.add(liquidationBuffer);
@@ -639,7 +640,12 @@ class User {
     getSpotAssetValue(tokenAmount, strictOraclePrice, spotMarketAccount, marginCategory) {
         let assetValue = (0, _1.getStrictTokenValue)(tokenAmount, spotMarketAccount.decimals, strictOraclePrice);
         if (marginCategory !== undefined) {
-            const weight = (0, spotBalance_1.calculateAssetWeight)(tokenAmount, strictOraclePrice.current, spotMarketAccount, marginCategory);
+            let weight = (0, spotBalance_1.calculateAssetWeight)(tokenAmount, strictOraclePrice.current, spotMarketAccount, marginCategory);
+            if (marginCategory === 'Initial' &&
+                spotMarketAccount.marketIndex !== numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+                const userCustomAssetWeight = _1.BN.max(numericConstants_1.ZERO, numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION.subn(this.getUserAccount().maxMarginRatio));
+                weight = _1.BN.min(weight, userCustomAssetWeight);
+            }
             assetValue = assetValue.mul(weight).div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
         }
         return assetValue;
@@ -702,10 +708,7 @@ class User {
             .mul(valuationPrice)
             .div(numericConstants_1.BASE_PRECISION);
         if (marginCategory) {
-            let marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), marginCategory));
-            if (marginCategory === 'Initial') {
-                marginRatio = _1.BN.max(marginRatio, new _1.BN(this.getUserAccount().maxMarginRatio));
-            }
+            let marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), marginCategory, this.getUserAccount().maxMarginRatio));
             if (liquidationBuffer !== undefined) {
                 marginRatio = marginRatio.add(liquidationBuffer);
             }
@@ -834,10 +837,10 @@ class User {
         }
         return totalLiabilityValue.mul(numericConstants_1.TEN_THOUSAND).div(netAssetValue);
     }
-    getLeverageComponents(includeOpenOrders = true) {
-        const perpLiability = this.getTotalPerpPositionValue(undefined, undefined, includeOpenOrders);
-        const perpPnl = this.getUnrealizedPNL(true);
-        const { totalAssetValue: spotAssetValue, totalLiabilityValue: spotLiabilityValue, } = this.getSpotMarketAssetAndLiabilityValue(undefined, undefined, undefined, includeOpenOrders);
+    getLeverageComponents(includeOpenOrders = true, marginCategory = undefined) {
+        const perpLiability = this.getTotalPerpPositionValue(marginCategory, undefined, includeOpenOrders);
+        const perpPnl = this.getUnrealizedPNL(true, undefined, marginCategory);
+        const { totalAssetValue: spotAssetValue, totalLiabilityValue: spotLiabilityValue, } = this.getSpotMarketAssetAndLiabilityValue(undefined, marginCategory, undefined, includeOpenOrders);
         return {
             perpLiabilityValue: perpLiability,
             perpPnl,
@@ -889,7 +892,7 @@ class User {
         let rawMarginRatio;
         switch (marginCategory) {
             case 'Initial':
-                rawMarginRatio = market.marginRatioInitial;
+                rawMarginRatio = Math.max(market.marginRatioInitial, this.getUserAccount().maxMarginRatio);
                 break;
             case 'Maintenance':
                 rawMarginRatio = market.marginRatioMaintenance;
@@ -905,7 +908,7 @@ class User {
             .mul(numericConstants_1.PRICE_PRECISION)
             .div(marketPrice));
         // margin ratio incorporting upper bound on size
-        let marginRatio = (0, _1.calculateMarketMarginRatio)(market, maxSize, marginCategory);
+        let marginRatio = (0, _1.calculateMarketMarginRatio)(market, maxSize, marginCategory, this.getUserAccount().maxMarginRatio);
         // use more fesible size since imf factor activated
         let attempts = 0;
         while (marginRatio > rawMarginRatio + 1e-4 && attempts < 10) {
@@ -916,7 +919,7 @@ class User {
                 .mul(numericConstants_1.PRICE_PRECISION)
                 .div(marketPrice));
             // margin ratio incorporting more fesible target size
-            marginRatio = (0, _1.calculateMarketMarginRatio)(market, targetSize, marginCategory);
+            marginRatio = (0, _1.calculateMarketMarginRatio)(market, targetSize, marginCategory, this.getUserAccount().maxMarginRatio);
             attempts += 1;
         }
         // how much more liabilities can be opened w remaining free collateral
@@ -1277,19 +1280,19 @@ class User {
         let freeCollateral = this.getFreeCollateral();
         const marginRatio = (0, _1.calculateSpotMarketMarginRatio)(market, oraclePrice, 'Initial', numericConstants_1.ZERO, (0, types_1.isVariant)(direction, 'long')
             ? _1.SpotBalanceType.DEPOSIT
-            : _1.SpotBalanceType.BORROW);
+            : _1.SpotBalanceType.BORROW, this.getUserAccount().maxMarginRatio);
         let tradeAmount = numericConstants_1.ZERO;
         if (this.getUserAccount().isMarginTradingEnabled) {
             // if the user is buying/selling and already short/long, need to account for closing out short/long
             if ((0, types_1.isVariant)(direction, 'long') && currentSpotMarketNetValue.lt(numericConstants_1.ZERO)) {
                 tradeAmount = currentSpotMarketNetValue.abs();
-                const marginRatio = (0, _1.calculateSpotMarketMarginRatio)(market, oraclePrice, 'Initial', this.getTokenAmount(targetMarketIndex).abs(), _1.SpotBalanceType.BORROW);
+                const marginRatio = (0, _1.calculateSpotMarketMarginRatio)(market, oraclePrice, 'Initial', this.getTokenAmount(targetMarketIndex).abs(), _1.SpotBalanceType.BORROW, this.getUserAccount().maxMarginRatio);
                 freeCollateral = freeCollateral.add(tradeAmount.mul(new _1.BN(marginRatio)).div(numericConstants_1.MARGIN_PRECISION));
             }
             else if ((0, types_1.isVariant)(direction, 'short') &&
                 currentSpotMarketNetValue.gt(numericConstants_1.ZERO)) {
                 tradeAmount = currentSpotMarketNetValue;
-                const marginRatio = (0, _1.calculateSpotMarketMarginRatio)(market, oraclePrice, 'Initial', this.getTokenAmount(targetMarketIndex), _1.SpotBalanceType.DEPOSIT);
+                const marginRatio = (0, _1.calculateSpotMarketMarginRatio)(market, oraclePrice, 'Initial', this.getTokenAmount(targetMarketIndex), _1.SpotBalanceType.DEPOSIT, this.getUserAccount().maxMarginRatio);
                 freeCollateral = freeCollateral.add(tradeAmount.mul(new _1.BN(marginRatio)).div(numericConstants_1.MARGIN_PRECISION));
             }
             tradeAmount = tradeAmount.add(freeCollateral.mul(numericConstants_1.MARGIN_PRECISION).div(new _1.BN(marginRatio)));
@@ -1332,7 +1335,7 @@ class User {
         const outContributionInitial = this.calculateSpotPositionFreeCollateralContribution(outSpotPosition, outStrictOraclePrice);
         const { totalAssetValue: outTotalAssetValueInitial, totalLiabilityValue: outTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(outSpotPosition, outStrictOraclePrice);
         const initialContribution = inContributionInitial.add(outContributionInitial);
-        const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents();
+        const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents(undefined, 'Initial');
         if (!calculateSwap) {
             calculateSwap = (inSwap) => {
                 return inSwap
@@ -1440,14 +1443,14 @@ class User {
     calculateSpotPositionFreeCollateralContribution(spotPosition, strictOraclePrice) {
         const marginCategory = 'Initial';
         const spotMarketAccount = this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
-        const { freeCollateralContribution } = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory);
+        const { freeCollateralContribution } = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory, this.getUserAccount().maxMarginRatio);
         return freeCollateralContribution;
     }
     calculateSpotPositionLeverageContribution(spotPosition, strictOraclePrice) {
         let totalAssetValue = numericConstants_1.ZERO;
         let totalLiabilityValue = numericConstants_1.ZERO;
         const spotMarketAccount = this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
-        const { tokenValue, ordersValue } = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, strictOraclePrice, 'Initial');
+        const { tokenValue, ordersValue } = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, strictOraclePrice, 'Initial', this.getUserAccount().maxMarginRatio);
         if (tokenValue.gte(numericConstants_1.ZERO)) {
             totalAssetValue = tokenValue;
         }
@@ -1487,7 +1490,7 @@ class User {
             this.getEmptySpotPosition(outMarketIndex);
         const { totalAssetValue: inTotalAssetValueInitial, totalLiabilityValue: inTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(inSpotPosition, inStrictOraclePrice);
         const { totalAssetValue: outTotalAssetValueInitial, totalLiabilityValue: outTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(outSpotPosition, outStrictOraclePrice);
-        const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents();
+        const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents(undefined, 'Initial');
         const inPositionAfter = this.cloneAndUpdateSpotPosition(inSpotPosition, inAmount.abs().neg(), inMarket);
         const outPositionAfter = this.cloneAndUpdateSpotPosition(outSpotPosition, outAmount.abs(), outMarket);
         const { totalAssetValue: inTotalAssetValueAfter, totalLiabilityValue: inTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(inPositionAfter, inStrictOraclePrice);
@@ -1801,7 +1804,7 @@ class User {
             const oraclePriceData = this.driftClient.getOraclePriceDataAndSlot(perpMarket.amm.oracle).data;
             const oraclePrice = oraclePriceData.price;
             const worstCaseBaseAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition);
-            const marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(perpMarket, worstCaseBaseAmount.abs(), marginCategory));
+            const marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(perpMarket, worstCaseBaseAmount.abs(), marginCategory, this.getUserAccount().maxMarginRatio));
             const quoteSpotMarket = this.driftClient.getSpotMarketAccount(perpMarket.quoteSpotMarketIndex);
             const quoteOraclePriceData = this.driftClient.getOraclePriceDataAndSlot(quoteSpotMarket.oracle).data;
             const baseAssetValue = worstCaseBaseAmount
@@ -1861,7 +1864,7 @@ class User {
                 netQuoteValue = netQuoteValue.add(tokenAmount);
                 continue;
             }
-            const { tokenAmount: worstCaseTokenAmount, tokenValue: tokenValue, weight, weightedTokenValue: weightedTokenValue, ordersValue: ordersValue, } = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory);
+            const { tokenAmount: worstCaseTokenAmount, tokenValue: tokenValue, weight, weightedTokenValue: weightedTokenValue, ordersValue: ordersValue, } = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory, this.getUserAccount().maxMarginRatio);
             netQuoteValue = netQuoteValue.add(ordersValue);
             const baseAssetValue = tokenValue.abs();
             const weightedValue = weightedTokenValue.abs();
@@ -1888,7 +1891,7 @@ class User {
             const spotMarketAccount = this.driftClient.getQuoteSpotMarketAccount();
             const oraclePriceData = this.getOracleDataForSpotMarket(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
             const baseAssetValue = (0, _1.getTokenValue)(netQuoteValue, spotMarketAccount.decimals, oraclePriceData);
-            const { weight, weightedTokenValue } = (0, spotPosition_1.calculateWeightedTokenValue)(netQuoteValue, baseAssetValue, oraclePriceData.price, spotMarketAccount, marginCategory);
+            const { weight, weightedTokenValue } = (0, spotPosition_1.calculateWeightedTokenValue)(netQuoteValue, baseAssetValue, oraclePriceData.price, spotMarketAccount, marginCategory, this.getUserAccount().maxMarginRatio);
             if (netQuoteValue.lt(numericConstants_1.ZERO)) {
                 healthComponents.borrows.push({
                     marketIndex: spotMarketAccount.marketIndex,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.42.0-beta.6",
+	"version": "2.42.0-beta.7",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/math/market.ts

@@ -129,17 +129,22 @@ export function calculateOracleSpread(
 export function calculateMarketMarginRatio(
 	market: PerpMarketAccount,
 	size: BN,
-	marginCategory: MarginCategory
+	marginCategory: MarginCategory,
+	customMarginRatio = 0
 ): number {
 	let marginRatio;
 	switch (marginCategory) {
 		case 'Initial': {
-			marginRatio = calculateSizePremiumLiabilityWeight(
-				size,
-				new BN(market.imfFactor),
-				new BN(market.marginRatioInitial),
-				MARGIN_PRECISION
-			).toNumber();
+			// use lowest leverage between max allowed and optional user custom max
+			marginRatio = Math.max(
+				calculateSizePremiumLiabilityWeight(
+					size,
+					new BN(market.imfFactor),
+					new BN(market.marginRatioInitial),
+					MARGIN_PRECISION
+				).toNumber(),
+				customMarginRatio
+			);
 			break;
 		}
 		case 'Maintenance': {

package/src/math/spotMarket.ts

@@ -24,8 +24,11 @@ export function calculateSpotMarketMarginRatio(
 	oraclePrice: BN,
 	marginCategory: MarginCategory,
 	size: BN,
-	balanceType: SpotBalanceType
+	balanceType: SpotBalanceType,
+	customMarginRatio = 0
 ): number {
+	let marginRatio;
+
 	if (isVariant(balanceType, 'deposit')) {
 		const assetWeight = calculateAssetWeight(
 			size,
@@ -33,13 +36,20 @@ export function calculateSpotMarketMarginRatio(
 			market,
 			marginCategory
 		);
-		return MARGIN_PRECISION.sub(assetWeight).toNumber();
+		marginRatio = MARGIN_PRECISION.sub(assetWeight).toNumber();
 	} else {
 		const liabilityWeight = calculateLiabilityWeight(
 			size,
 			market,
 			marginCategory
 		);
-		return liabilityWeight.sub(MARGIN_PRECISION).toNumber();
+		marginRatio = liabilityWeight.sub(MARGIN_PRECISION).toNumber();
+	}
+
+	if (marginCategory === 'Initial') {
+		// use lowest leverage between max allowed and optional user custom max
+		return Math.max(marginRatio, customMarginRatio);
 	}
+
+	return marginRatio;
 }

package/src/math/spotPosition.ts

@@ -1,5 +1,6 @@
 import { MarginCategory, SpotMarketAccount, SpotPosition } from '../types';
 import {
+	QUOTE_SPOT_MARKET_INDEX,
 	SPOT_MARKET_WEIGHT_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
@@ -31,7 +32,8 @@ export function getWorstCaseTokenAmounts(
 	spotPosition: SpotPosition,
 	spotMarketAccount: SpotMarketAccount,
 	strictOraclePrice: StrictOraclePrice,
-	marginCategory: MarginCategory
+	marginCategory: MarginCategory,
+	customMarginRatio?: number
 ): OrderFillSimulation {
 	const tokenAmount = getSignedTokenAmount(
 		getTokenAmount(
@@ -54,7 +56,8 @@ export function getWorstCaseTokenAmounts(
 			tokenValue,
 			strictOraclePrice.current,
 			spotMarketAccount,
-			marginCategory
+			marginCategory,
+			customMarginRatio
 		);
 		return {
 			tokenAmount,
@@ -72,7 +75,8 @@ export function getWorstCaseTokenAmounts(
 		spotPosition.openBids,
 		strictOraclePrice,
 		spotMarketAccount,
-		marginCategory
+		marginCategory,
+		customMarginRatio
 	);
 	const asksSimulation = simulateOrderFill(
 		tokenAmount,
@@ -80,7 +84,8 @@ export function getWorstCaseTokenAmounts(
 		spotPosition.openAsks,
 		strictOraclePrice,
 		spotMarketAccount,
-		marginCategory
+		marginCategory,
+		customMarginRatio
 	);
 
 	if (
@@ -99,7 +104,8 @@ export function calculateWeightedTokenValue(
 	tokenValue: BN,
 	oraclePrice: BN,
 	spotMarket: SpotMarketAccount,
-	marginCategory: MarginCategory
+	marginCategory: MarginCategory,
+	customMarginRatio?: number
 ): { weight: BN; weightedTokenValue: BN } {
 	let weight: BN;
 	if (tokenValue.gte(ZERO)) {
@@ -117,6 +123,20 @@ export function calculateWeightedTokenValue(
 		);
 	}
 
+	if (
+		marginCategory === 'Initial' &&
+		customMarginRatio &&
+		spotMarket.marketIndex !== QUOTE_SPOT_MARKET_INDEX
+	) {
+		const userCustomAssetWeight = tokenValue.gte(ZERO)
+			? BN.max(ZERO, SPOT_MARKET_WEIGHT_PRECISION.subn(customMarginRatio))
+			: SPOT_MARKET_WEIGHT_PRECISION.addn(customMarginRatio);
+
+		weight = tokenValue.gte(ZERO)
+			? BN.min(weight, userCustomAssetWeight)
+			: BN.max(weight, userCustomAssetWeight);
+	}
+
 	return {
 		weight: weight,
 		weightedTokenValue: tokenValue
@@ -131,7 +151,8 @@ export function simulateOrderFill(
 	openOrders: BN,
 	strictOraclePrice: StrictOraclePrice,
 	spotMarket: SpotMarketAccount,
-	marginCategory: MarginCategory
+	marginCategory: MarginCategory,
+	customMarginRatio?: number
 ): OrderFillSimulation {
 	const ordersValue = getTokenValue(openOrders.neg(), spotMarket.decimals, {
 		price: strictOraclePrice.max(),
@@ -145,7 +166,8 @@ export function simulateOrderFill(
 			tokenValueAfterFill,
 			strictOraclePrice.current,
 			spotMarket,
-			marginCategory
+			marginCategory,
+			customMarginRatio
 		);
 
 	const freeCollateralContribution =

package/src/user.ts

@@ -78,7 +78,6 @@ import {
 	getWorstCaseTokenAmounts,
 	isSpotPositionAvailable,
 } from './math/spotPosition';
-
 import { calculateLiveOracleTwap } from './math/oracles';
 import { getPerpMarketTierNumber, getSpotMarketTierNumber } from './math/tiers';
 import { StrictOraclePrice } from './oracles/strictOraclePrice';
@@ -632,7 +631,8 @@ export class User {
 		const marginRatio = calculateMarketMarginRatio(
 			this.driftClient.getPerpMarketAccount(marketIndex),
 			baseAssetAmount,
-			'Initial'
+			'Initial',
+			this.getUserAccount().maxMarginRatio
 		);
 
 		return freeCollateral.mul(MARGIN_PRECISION).div(new BN(marginRatio));
@@ -968,7 +968,8 @@ export class User {
 				spotPosition,
 				spotMarketAccount,
 				strictOraclePrice,
-				marginCategory ?? 'Initial'
+				marginCategory,
+				this.getUserAccount().maxMarginRatio
 			);
 
 			if (worstCaseTokenAmount.gt(ZERO) && countForBase) {
@@ -1067,8 +1068,16 @@ export class User {
 				marginCategory
 			);
 
-			if (marginCategory === 'Initial') {
-				weight = BN.max(weight, new BN(this.getUserAccount().maxMarginRatio));
+			if (
+				marginCategory === 'Initial' &&
+				spotMarketAccount.marketIndex !== QUOTE_SPOT_MARKET_INDEX
+			) {
+				weight = BN.max(
+					weight,
+					SPOT_MARKET_WEIGHT_PRECISION.addn(
+						this.getUserAccount().maxMarginRatio
+					)
+				);
 			}
 
 			if (liquidationBuffer !== undefined) {
@@ -1114,13 +1123,26 @@ export class User {
 		);
 
 		if (marginCategory !== undefined) {
-			const weight = calculateAssetWeight(
+			let weight = calculateAssetWeight(
 				tokenAmount,
 				strictOraclePrice.current,
 				spotMarketAccount,
 				marginCategory
 			);
 
+			if (
+				marginCategory === 'Initial' &&
+				spotMarketAccount.marketIndex !== QUOTE_SPOT_MARKET_INDEX
+			) {
+				const userCustomAssetWeight = BN.max(
+					ZERO,
+					SPOT_MARKET_WEIGHT_PRECISION.subn(
+						this.getUserAccount().maxMarginRatio
+					)
+				);
+				weight = BN.min(weight, userCustomAssetWeight);
+			}
+
 			assetValue = assetValue.mul(weight).div(SPOT_MARKET_WEIGHT_PRECISION);
 		}
 
@@ -1254,17 +1276,11 @@ export class User {
 				calculateMarketMarginRatio(
 					market,
 					baseAssetAmount.abs(),
-					marginCategory
+					marginCategory,
+					this.getUserAccount().maxMarginRatio
 				)
 			);
 
-			if (marginCategory === 'Initial') {
-				marginRatio = BN.max(
-					marginRatio,
-					new BN(this.getUserAccount().maxMarginRatio)
-				);
-			}
-
 			if (liquidationBuffer !== undefined) {
 				marginRatio = marginRatio.add(liquidationBuffer);
 			}
@@ -1494,25 +1510,28 @@ export class User {
 		return totalLiabilityValue.mul(TEN_THOUSAND).div(netAssetValue);
 	}
 
-	getLeverageComponents(includeOpenOrders = true): {
+	getLeverageComponents(
+		includeOpenOrders = true,
+		marginCategory: MarginCategory = undefined
+	): {
 		perpLiabilityValue: BN;
 		perpPnl: BN;
 		spotAssetValue: BN;
 		spotLiabilityValue: BN;
 	} {
 		const perpLiability = this.getTotalPerpPositionValue(
-			undefined,
+			marginCategory,
 			undefined,
 			includeOpenOrders
 		);
-		const perpPnl = this.getUnrealizedPNL(true);
+		const perpPnl = this.getUnrealizedPNL(true, undefined, marginCategory);
 
 		const {
 			totalAssetValue: spotAssetValue,
 			totalLiabilityValue: spotLiabilityValue,
 		} = this.getSpotMarketAssetAndLiabilityValue(
 			undefined,
-			undefined,
+			marginCategory,
 			undefined,
 			includeOpenOrders
 		);
@@ -1599,7 +1618,10 @@ export class User {
 
 		switch (marginCategory) {
 			case 'Initial':
-				rawMarginRatio = market.marginRatioInitial;
+				rawMarginRatio = Math.max(
+					market.marginRatioInitial,
+					this.getUserAccount().maxMarginRatio
+				);
 				break;
 			case 'Maintenance':
 				rawMarginRatio = market.marginRatioMaintenance;
@@ -1623,7 +1645,8 @@ export class User {
 		let marginRatio = calculateMarketMarginRatio(
 			market,
 			maxSize,
-			marginCategory
+			marginCategory,
+			this.getUserAccount().maxMarginRatio
 		);
 
 		// use more fesible size since imf factor activated
@@ -1643,7 +1666,8 @@ export class User {
 			marginRatio = calculateMarketMarginRatio(
 				market,
 				targetSize,
-				marginCategory
+				marginCategory,
+				this.getUserAccount().maxMarginRatio
 			);
 			attempts += 1;
 		}
@@ -2177,6 +2201,7 @@ export class User {
 			: this.getPerpPositionValue(targetMarketIndex, oracleData);
 
 		let maxPositionSize = this.getPerpBuyingPower(targetMarketIndex, lpBuffer);
+
 		if (maxPositionSize.gte(ZERO)) {
 			if (oppositeSizeValueUSDC.eq(ZERO)) {
 				// case 1 : Regular trade where current total position less than max, and no opposite position to account for
@@ -2262,7 +2287,8 @@ export class User {
 			ZERO,
 			isVariant(direction, 'long')
 				? SpotBalanceType.DEPOSIT
-				: SpotBalanceType.BORROW
+				: SpotBalanceType.BORROW,
+			this.getUserAccount().maxMarginRatio
 		);
 
 		let tradeAmount = ZERO;
@@ -2275,7 +2301,8 @@ export class User {
 					oraclePrice,
 					'Initial',
 					this.getTokenAmount(targetMarketIndex).abs(),
-					SpotBalanceType.BORROW
+					SpotBalanceType.BORROW,
+					this.getUserAccount().maxMarginRatio
 				);
 				freeCollateral = freeCollateral.add(
 					tradeAmount.mul(new BN(marginRatio)).div(MARGIN_PRECISION)
@@ -2290,7 +2317,8 @@ export class User {
 					oraclePrice,
 					'Initial',
 					this.getTokenAmount(targetMarketIndex),
-					SpotBalanceType.DEPOSIT
+					SpotBalanceType.DEPOSIT,
+					this.getUserAccount().maxMarginRatio
 				);
 				freeCollateral = freeCollateral.add(
 					tradeAmount.mul(new BN(marginRatio)).div(MARGIN_PRECISION)
@@ -2384,7 +2412,7 @@ export class User {
 		);
 
 		const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } =
-			this.getLeverageComponents();
+			this.getLeverageComponents(undefined, 'Initial');
 
 		if (!calculateSwap) {
 			calculateSwap = (inSwap: BN) => {
@@ -2583,7 +2611,8 @@ export class User {
 			spotPosition,
 			spotMarketAccount,
 			strictOraclePrice,
-			marginCategory
+			marginCategory,
+			this.getUserAccount().maxMarginRatio
 		);
 
 		return freeCollateralContribution;
@@ -2606,7 +2635,8 @@ export class User {
 			spotPosition,
 			spotMarketAccount,
 			strictOraclePrice,
-			'Initial'
+			'Initial',
+			this.getUserAccount().maxMarginRatio
 		);
 
 		if (tokenValue.gte(ZERO)) {
@@ -2678,7 +2708,7 @@ export class User {
 		);
 
 		const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } =
-			this.getLeverageComponents();
+			this.getLeverageComponents(undefined, 'Initial');
 
 		const inPositionAfter = this.cloneAndUpdateSpotPosition(
 			inSpotPosition,
@@ -3225,7 +3255,8 @@ export class User {
 				calculateMarketMarginRatio(
 					perpMarket,
 					worstCaseBaseAmount.abs(),
-					marginCategory
+					marginCategory,
+					this.getUserAccount().maxMarginRatio
 				)
 			);
 
@@ -3349,7 +3380,8 @@ export class User {
 				spotPosition,
 				spotMarketAccount,
 				strictOraclePrice,
-				marginCategory
+				marginCategory,
+				this.getUserAccount().maxMarginRatio
 			);
 
 			netQuoteValue = netQuoteValue.add(ordersValue);
@@ -3393,7 +3425,8 @@ export class User {
 				baseAssetValue,
 				oraclePriceData.price,
 				spotMarketAccount,
-				marginCategory
+				marginCategory,
+				this.getUserAccount().maxMarginRatio
 			);
 
 			if (netQuoteValue.lt(ZERO)) {

package/tests/amm/test.ts

@@ -568,7 +568,8 @@ describe('AMM Tests', () => {
 		mockMarket1.amm.maxBaseAssetReserve = mockMarket1.amm.baseAssetReserve.add(
 			new BN(1234835)
 		);
-		mockMarket1.amm.minBaseAssetReserve = mockMarket1.amm.baseAssetReserve.sub(BASE_PRECISION);
+		mockMarket1.amm.minBaseAssetReserve =
+			mockMarket1.amm.baseAssetReserve.sub(BASE_PRECISION);
 		mockMarket1.amm.quoteAssetReserve = new BN(cc).mul(BASE_PRECISION);
 		mockMarket1.amm.pegMultiplier = new BN(18.32 * PEG_PRECISION.toNumber());
 		mockMarket1.amm.sqrtK = new BN(cc).mul(BASE_PRECISION);
@@ -790,14 +791,14 @@ describe('AMM Tests', () => {
 		assert(totalAskSize.sub(openAsks.abs()).lte(new BN(5))); // only tiny rounding errors
 	});
 
-
 	it('orderbook L2 gen (4 topOfBookQuoteAmounts, 10 numOrders, low bid liquidity)', async () => {
 		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
 
 		const mockMarket1: PerpMarketAccount = myMockPerpMarkets[0];
 		const cc = 38104569;
 		mockMarket1.amm.baseAssetReserve = new BN(cc).mul(BASE_PRECISION);
-		mockMarket1.amm.maxBaseAssetReserve = mockMarket1.amm.baseAssetReserve.add(BASE_PRECISION); // only 1 base
+		mockMarket1.amm.maxBaseAssetReserve =
+			mockMarket1.amm.baseAssetReserve.add(BASE_PRECISION); // only 1 base
 		mockMarket1.amm.minBaseAssetReserve = mockMarket1.amm.baseAssetReserve.div(
 			new BN(2)
 		);
@@ -873,14 +874,15 @@ describe('AMM Tests', () => {
 		assert(totalAskSize.sub(openAsks.abs()).lte(new BN(5))); // only tiny rounding errors
 	});
 
-
 	it('orderbook L2 gen (4 topOfBookQuoteAmounts, 10 numOrders, low ask liquidity)', async () => {
 		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
 
 		const mockMarket1: PerpMarketAccount = myMockPerpMarkets[0];
 		const cc = 38104569;
 		mockMarket1.amm.baseAssetReserve = new BN(cc).mul(BASE_PRECISION);
-		mockMarket1.amm.maxBaseAssetReserve = mockMarket1.amm.baseAssetReserve.add(BASE_PRECISION.mul(new BN(1000))); // 1000 base
+		mockMarket1.amm.maxBaseAssetReserve = mockMarket1.amm.baseAssetReserve.add(
+			BASE_PRECISION.mul(new BN(1000))
+		); // 1000 base
 		mockMarket1.amm.minBaseAssetReserve = mockMarket1.amm.baseAssetReserve.sub(
 			BASE_PRECISION.div(new BN(2))
 		); // only .5 base

package/tests/auctions/test.ts

@@ -1,9 +1,8 @@
-import {PRICE_PRECISION, BN, deriveOracleAuctionParams} from "../../src";
-import {assert} from "chai";
-import {PositionDirection} from "../../lib";
+import { PRICE_PRECISION, BN, deriveOracleAuctionParams } from '../../src';
+import { assert } from 'chai';
+import { PositionDirection } from '../../lib';
 
 describe('Auction Tests', () => {
-
 	it('deriveOracleAuctionParams', async () => {
 		let oraclePrice = new BN(100).mul(PRICE_PRECISION);
 		let auctionStartPrice = new BN(90).mul(PRICE_PRECISION);
@@ -18,9 +17,15 @@ describe('Auction Tests', () => {
 			limitPrice,
 		});
 
-		assert(oracleOrderParams.auctionStartPrice.eq(new BN(-10).mul(PRICE_PRECISION)));
-		assert(oracleOrderParams.auctionEndPrice.eq(new BN(10).mul(PRICE_PRECISION)));
-		assert(oracleOrderParams.oraclePriceOffset === 20 * PRICE_PRECISION.toNumber());
+		assert(
+			oracleOrderParams.auctionStartPrice.eq(new BN(-10).mul(PRICE_PRECISION))
+		);
+		assert(
+			oracleOrderParams.auctionEndPrice.eq(new BN(10).mul(PRICE_PRECISION))
+		);
+		assert(
+			oracleOrderParams.oraclePriceOffset === 20 * PRICE_PRECISION.toNumber()
+		);
 
 		oracleOrderParams = deriveOracleAuctionParams({
 			direction: PositionDirection.LONG,
@@ -47,9 +52,15 @@ describe('Auction Tests', () => {
 			limitPrice,
 		});
 
-		assert(oracleOrderParams.auctionStartPrice.eq(new BN(10).mul(PRICE_PRECISION)));
-		assert(oracleOrderParams.auctionEndPrice.eq(new BN(-10).mul(PRICE_PRECISION)));
-		assert(oracleOrderParams.oraclePriceOffset === -20 * PRICE_PRECISION.toNumber());
+		assert(
+			oracleOrderParams.auctionStartPrice.eq(new BN(10).mul(PRICE_PRECISION))
+		);
+		assert(
+			oracleOrderParams.auctionEndPrice.eq(new BN(-10).mul(PRICE_PRECISION))
+		);
+		assert(
+			oracleOrderParams.oraclePriceOffset === -20 * PRICE_PRECISION.toNumber()
+		);
 
 		oracleOrderParams = deriveOracleAuctionParams({
 			direction: PositionDirection.SHORT,
@@ -63,4 +74,4 @@ describe('Auction Tests', () => {
 		assert(oracleOrderParams.auctionEndPrice.eq(new BN(0)));
 		assert(oracleOrderParams.oraclePriceOffset === -1);
 	});
-});
+});

package/tests/dlob/helpers.ts

@@ -21,7 +21,9 @@ import {
 	OrderRecord,
 	ZERO,
 	ContractTier,
-	SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION
+	SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION,
+	SPOT_MARKET_WEIGHT_PRECISION,
+	PRICE_PRECISION,
 } from '../../src';
 
 export const mockPerpPosition: PerpPosition = {
@@ -263,7 +265,7 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 		status: MarketStatus.ACTIVE,
 		assetTier: AssetTier.COLLATERAL,
 		name: [],
-		maxTokenDeposits: new BN(1000000),
+		maxTokenDeposits: new BN(1000000 * QUOTE_PRECISION.toNumber()),
 		marketIndex: 0,
 		pubkey: PublicKey.default,
 		mint: DevnetSpotMarkets[0].mint,
@@ -300,10 +302,10 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 		lastInterestTs: new BN(0),
 		lastTwapTs: new BN(0),
 		oracle: PublicKey.default,
-		initialAssetWeight: 0,
-		maintenanceAssetWeight: 0,
-		initialLiabilityWeight: 0,
-		maintenanceLiabilityWeight: 0,
+		initialAssetWeight: SPOT_MARKET_WEIGHT_PRECISION.toNumber(),
+		maintenanceAssetWeight: SPOT_MARKET_WEIGHT_PRECISION.toNumber(),
+		initialLiabilityWeight: SPOT_MARKET_WEIGHT_PRECISION.toNumber(),
+		maintenanceLiabilityWeight: SPOT_MARKET_WEIGHT_PRECISION.toNumber(),
 		scaleInitialAssetWeightStart: new BN(0),
 		imfFactor: 0,
 		withdrawGuardThreshold: new BN(0),
@@ -325,18 +327,18 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 		flashLoanInitialTokenAmount: new BN(0),
 		oracleSource: OracleSource.PYTH,
 		historicalOracleData: {
-			lastOraclePrice: new BN(0),
+			lastOraclePrice: PRICE_PRECISION,
 			lastOracleConf: new BN(0),
 			lastOracleDelay: new BN(0),
-			lastOraclePriceTwap: new BN(0),
-			lastOraclePriceTwap5Min: new BN(0),
+			lastOraclePriceTwap: PRICE_PRECISION,
+			lastOraclePriceTwap5Min: PRICE_PRECISION,
 			lastOraclePriceTwapTs: new BN(0),
 		},
 		historicalIndexData: {
-			lastIndexBidPrice: new BN(0),
-			lastIndexAskPrice: new BN(0),
-			lastIndexPriceTwap: new BN(0),
-			lastIndexPriceTwap5Min: new BN(0),
+			lastIndexBidPrice: PRICE_PRECISION,
+			lastIndexAskPrice: PRICE_PRECISION,
+			lastIndexPriceTwap: PRICE_PRECISION,
+			lastIndexPriceTwap5Min: PRICE_PRECISION,
 			lastIndexPriceTwapTs: new BN(0),
 		},
 	},

package/tests/tx/priorityFeeCalculator.ts

@@ -74,4 +74,4 @@ describe('PriorityFeeCalculator', () => {
 			additionalFeeMicroLamports
 		);
 	});
-});
+});

package/tests/user/test.ts

@@ -16,11 +16,12 @@ import {
 	StrictOraclePrice,
 	LAMPORTS_PRECISION,
 	SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION,
-	SpotBalanceType
+	SpotBalanceType,
+	MARGIN_PRECISION,
 } from '../../src';
 import { MockUserMap, mockPerpMarkets, mockSpotMarkets } from '../dlob/helpers';
 import { assert } from '../../src/assert/assert';
-import {mockUserAccount} from './helpers';
+import { mockUserAccount } from './helpers';
 import * as _ from 'lodash';
 
 async function makeMockUser(
@@ -260,15 +261,16 @@ describe('User Tests', () => {
 			'spot cumulativeDepositInterest:',
 			mockSpotMarkets[0].cumulativeDepositInterest.toString()
 		);
-		assert(mockUser.getTokenAmount(0).eq(new BN('10000000000')));
-		assert(mockUser.getNetSpotMarketValue().eq(new BN('10000000000')));
+		const expectedAmount = new BN('10000000000');
+		assert(mockUser.getTokenAmount(0).eq(expectedAmount));
+		assert(mockUser.getNetSpotMarketValue().eq(expectedAmount));
 		assert(
 			mockUser
 				.getSpotMarketAssetAndLiabilityValue()
 				.totalLiabilityValue.eq(ZERO)
 		);
 
-		assert(mockUser.getFreeCollateral().eq(ZERO));
+		assert(mockUser.getFreeCollateral().gt(ZERO));
 		const upnl = mockUser.getUnrealizedPNL(true, 0, undefined, false);
 		console.log('upnl:', upnl.toString());
 		assert(upnl.eq(new BN('0'))); // $10
@@ -277,7 +279,7 @@ describe('User Tests', () => {
 		console.log(liqResult);
 		assert(liqResult.canBeLiquidated == false);
 		assert(liqResult.marginRequirement.eq(new BN('0'))); //10x maint leverage
-		assert(liqResult.totalCollateral.eq(ZERO));
+		assert(liqResult.totalCollateral.eq(expectedAmount));
 
 		console.log(mockUser.getHealth());
 		assert(mockUser.getHealth() == 100);
@@ -286,7 +288,9 @@ describe('User Tests', () => {
 			'getMaxLeverageForPerp:',
 			mockUser.getMaxLeverageForPerp(0).toString()
 		);
-		assert(mockUser.getMaxLeverageForPerp(0).eq(new BN('0')));
+		assert(mockUser.getMaxLeverageForPerp(0).eq(new BN('50000'))); // 5x
+		assert(mockUser.getMaxLeverageForPerp(0, 'Maintenance').eq(new BN('100000'))); // 10x
+
 	});
 
 	it('worst case token amount', async () => {
@@ -303,57 +307,200 @@ describe('User Tests', () => {
 
 		let spotPosition = Object.assign({}, myMockUserAccount.spotPositions[1], {
 			marketIndex: 1,
-			openBids: new BN(100).mul( LAMPORTS_PRECISION),
+			openBids: new BN(100).mul(LAMPORTS_PRECISION),
 		});
 
-		let worstCase = getWorstCaseTokenAmounts(spotPosition, solMarket, strictOraclePrice, 'Initial');
+		let worstCase = getWorstCaseTokenAmounts(
+			spotPosition,
+			solMarket,
+			strictOraclePrice,
+			'Initial'
+		);
 
-		assert(worstCase.tokenAmount.eq(new BN(100).mul( LAMPORTS_PRECISION))); // 100
+		assert(worstCase.tokenAmount.eq(new BN(100).mul(LAMPORTS_PRECISION))); // 100
 		assert(worstCase.tokenValue.eq(new BN(10000).mul(PRICE_PRECISION))); // $10k
 		assert(worstCase.weightedTokenValue.eq(new BN(8000).mul(PRICE_PRECISION))); // $8k
 		assert(worstCase.ordersValue.eq(new BN(-10000).mul(PRICE_PRECISION))); // -$10k
-		assert(worstCase.freeCollateralContribution.eq(new BN(-2000).mul(QUOTE_PRECISION))); // -$2k
+		assert(
+			worstCase.freeCollateralContribution.eq(
+				new BN(-2000).mul(QUOTE_PRECISION)
+			)
+		); // -$2k
 
 		spotPosition = Object.assign({}, myMockUserAccount.spotPositions[1], {
 			marketIndex: 1,
 			scaledBalance: new BN(100).mul(SPOT_MARKET_BALANCE_PRECISION),
-			openBids: new BN(100).mul( LAMPORTS_PRECISION),
+			openBids: new BN(100).mul(LAMPORTS_PRECISION),
 		});
 
-		worstCase = getWorstCaseTokenAmounts(spotPosition, solMarket, strictOraclePrice, 'Initial');
+		worstCase = getWorstCaseTokenAmounts(
+			spotPosition,
+			solMarket,
+			strictOraclePrice,
+			'Initial'
+		);
 
 		assert(worstCase.tokenAmount.eq(new BN(200).mul(LAMPORTS_PRECISION))); // 200
 		assert(worstCase.tokenValue.eq(new BN(20000).mul(PRICE_PRECISION))); // $20k
 		assert(worstCase.weightedTokenValue.eq(new BN(16000).mul(PRICE_PRECISION))); // $16k
 		assert(worstCase.ordersValue.eq(new BN(-10000).mul(PRICE_PRECISION))); // -$10k
-		assert(worstCase.freeCollateralContribution.eq(new BN(6000).mul(QUOTE_PRECISION))); // $6k
+		assert(
+			worstCase.freeCollateralContribution.eq(new BN(6000).mul(QUOTE_PRECISION))
+		); // $6k
 
 		spotPosition = Object.assign({}, myMockUserAccount.spotPositions[1], {
 			marketIndex: 1,
-			openAsks: new BN(-100).mul( LAMPORTS_PRECISION),
+			openAsks: new BN(-100).mul(LAMPORTS_PRECISION),
 		});
 
-		worstCase = getWorstCaseTokenAmounts(spotPosition, solMarket, strictOraclePrice, 'Initial');
+		worstCase = getWorstCaseTokenAmounts(
+			spotPosition,
+			solMarket,
+			strictOraclePrice,
+			'Initial'
+		);
 
-		assert(worstCase.tokenAmount.eq(new BN(-100).mul( LAMPORTS_PRECISION)));
+		assert(worstCase.tokenAmount.eq(new BN(-100).mul(LAMPORTS_PRECISION)));
 		assert(worstCase.tokenValue.eq(new BN(-10000).mul(PRICE_PRECISION))); // -$10k
-		assert(worstCase.weightedTokenValue.eq(new BN(-12000).mul(PRICE_PRECISION))); // -$12k
+		assert(
+			worstCase.weightedTokenValue.eq(new BN(-12000).mul(PRICE_PRECISION))
+		); // -$12k
 		assert(worstCase.ordersValue.eq(new BN(10000).mul(PRICE_PRECISION))); // $10k
-		assert(worstCase.freeCollateralContribution.eq(new BN(-2000).mul(QUOTE_PRECISION))); // -$2k
+		assert(
+			worstCase.freeCollateralContribution.eq(
+				new BN(-2000).mul(QUOTE_PRECISION)
+			)
+		); // -$2k
 
 		spotPosition = Object.assign({}, myMockUserAccount.spotPositions[1], {
 			marketIndex: 1,
 			balanceType: SpotBalanceType.BORROW,
 			scaledBalance: new BN(100).mul(SPOT_MARKET_BALANCE_PRECISION),
-			openAsks: new BN(-100).mul( LAMPORTS_PRECISION),
+			openAsks: new BN(-100).mul(LAMPORTS_PRECISION),
 		});
 
-		worstCase = getWorstCaseTokenAmounts(spotPosition, solMarket, strictOraclePrice, 'Initial');
+		worstCase = getWorstCaseTokenAmounts(
+			spotPosition,
+			solMarket,
+			strictOraclePrice,
+			'Initial'
+		);
 
-		assert(worstCase.tokenAmount.eq(new BN(-200).mul( LAMPORTS_PRECISION)));
+		assert(worstCase.tokenAmount.eq(new BN(-200).mul(LAMPORTS_PRECISION)));
 		assert(worstCase.tokenValue.eq(new BN(-20000).mul(PRICE_PRECISION))); // -$20k
-		assert(worstCase.weightedTokenValue.eq(new BN(-24000).mul(PRICE_PRECISION))); // -$24k
+		assert(
+			worstCase.weightedTokenValue.eq(new BN(-24000).mul(PRICE_PRECISION))
+		); // -$24k
 		assert(worstCase.ordersValue.eq(new BN(10000).mul(PRICE_PRECISION))); // $10k
-		assert(worstCase.freeCollateralContribution.eq(new BN(-14000).mul(QUOTE_PRECISION))); // -$2k
+		assert(
+			worstCase.freeCollateralContribution.eq(
+				new BN(-14000).mul(QUOTE_PRECISION)
+			)
+		); // -$2k
+	});
+
+
+	it('custom margin ratio (sol spot)', async() => {
+		const myMockUserAccount = _.cloneDeep(mockUserAccount);
+
+		const solMarket = Object.assign({}, _.cloneDeep(mockSpotMarkets[1]), {
+			initialAssetWeight: 8000,
+			initialLiabilityWeight: 12000,
+			cumulativeDepositInterest: SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION,
+			cumulativeBorrowInterest: SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION,
+		});
+
+		// $25
+		const strictOraclePrice = new StrictOraclePrice(PRICE_PRECISION.muln(25));
+
+		const spotPosition = Object.assign({}, myMockUserAccount.spotPositions[1], {
+			marketIndex: 1,
+			openBids: new BN(100).mul(LAMPORTS_PRECISION),
+		});
+
+		const worstCase = getWorstCaseTokenAmounts(
+			spotPosition,
+			solMarket,
+			strictOraclePrice,
+			'Initial',
+			myMockUserAccount.maxMarginRatio
+		);
+
+		console.log(worstCase);
+		assert(worstCase.weight.eq(new BN(8000))); 
+
+
+		myMockUserAccount.maxMarginRatio = MARGIN_PRECISION.toNumber(); // max 1x pls
+
+
+		const worstCaseAfter = getWorstCaseTokenAmounts(
+			spotPosition,
+			solMarket,
+			strictOraclePrice,
+			'Initial',
+			myMockUserAccount.maxMarginRatio
+		);
+
+		console.log(worstCaseAfter);
+		assert(worstCaseAfter.weight.eq(new BN(0))); // not allowed to increase exposure
+
+	});
+
+	it('custom margin ratio (sol perp)', async() => {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+		const myMockSpotMarkets = _.cloneDeep(mockSpotMarkets);
+		const myMockUserAccount = _.cloneDeep(mockUserAccount);
+		// myMockPerpMarkets[0].imfFactor = 550;
+		myMockPerpMarkets[0].marginRatioInitial = 2000; // 5x
+		myMockPerpMarkets[0].marginRatioMaintenance = 1000; // 10x
+
+		myMockSpotMarkets[0].initialAssetWeight = 1000;
+		myMockSpotMarkets[0].initialLiabilityWeight = 1000;
+
+		myMockUserAccount.spotPositions[0].scaledBalance = new BN(
+			10000 * SPOT_MARKET_BALANCE_PRECISION.toNumber()
+		); //10k
+
+		const mockUser: User = await makeMockUser(
+			myMockPerpMarkets,
+			myMockSpotMarkets,
+			myMockUserAccount,
+			[1, 1, 1, 1, 1, 1, 1, 1],
+			[1, 1, 1, 1, 1, 1, 1, 1]
+		);
+
+
+		assert(mockUser.getTokenAmount(0).eq(new BN('10000000000')));
+		assert(mockUser.getNetSpotMarketValue().eq(new BN('10000000000')));
+		assert(
+			mockUser
+				.getSpotMarketAssetAndLiabilityValue()
+				.totalLiabilityValue.eq(ZERO)
+		);
+
+		assert(mockUser.getFreeCollateral().gt(ZERO));
+
+		let iLev = mockUser.getMaxLeverageForPerp(0, 'Initial').toNumber();
+		let mLev = mockUser.getMaxLeverageForPerp(0, 'Maintenance').toNumber();
+		console.log(iLev, mLev);
+		assert(iLev == 5000);
+		assert(mLev == 10000);
+
+		myMockUserAccount.maxMarginRatio = MARGIN_PRECISION.div(new BN(2)).toNumber(); // 2x max pls
+
+		const mockUser2: User = await makeMockUser(
+			myMockPerpMarkets,
+			myMockSpotMarkets,
+			myMockUserAccount,
+			[1, 1, 1, 1, 1, 1, 1, 1],
+			[1, 1, 1, 1, 1, 1, 1, 1]
+		);
+		iLev = mockUser2.getMaxLeverageForPerp(0, 'Initial').toNumber();
+		mLev = mockUser2.getMaxLeverageForPerp(0, 'Maintenance').toNumber();
+		console.log(iLev, mLev);
+		
+		assert(iLev == 2000);
+		assert(mLev == 10000);
+
 	});
 });