@drift-labs/sdk 0.2.0-master.0 → 0.2.0-master.3

package/lib/math/amm.js

@@ -1,25 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = void 0;
+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 calculateNewAmm(amm, oraclePriceData) {
-    let pKNumer = new anchor_1.BN(1);
-    let pKDenom = new anchor_1.BN(1);
+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;
-    let newPeg = targetPrice
-        .mul(amm.baseAssetReserve)
-        .div(amm.quoteAssetReserve)
-        .add(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.PEG_PRECISION).div(new anchor_1.BN(2)))
-        .div(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.PEG_PRECISION));
-    let prePegCost = (0, repeg_1.calculateRepegCost)(amm, newPeg);
+    const newPeg = calculatePegFromTargetPrice(targetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
+    const prePegCost = (0, 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 (prePegCost.gt(budget)) {
+    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 = (0, 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 = (0, 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 = (0, repeg_1.calculateAdjustKCost)(amm, pKNumer, pKDenom);
         (0, assert_1.assert)(deficitMadeup.lte(new anchor_1.BN(0)));
@@ -73,8 +106,14 @@ function calculateUpdatedAMMSpreadReserves(amm, direction, oraclePriceData) {
     return result;
 }
 exports.calculateUpdatedAMMSpreadReserves = calculateUpdatedAMMSpreadReserves;
-function calculateBidAskPrice(amm, oraclePriceData) {
-    const newAmm = calculateUpdatedAMM(amm, oraclePriceData);
+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);
@@ -126,6 +165,67 @@ function calculateAmmReservesAfterSwap(amm, inputAssetType, swapAmount, swapDire
     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) {
     let spread = amm.baseSpread / 2;
     if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
@@ -133,14 +233,18 @@ function calculateSpread(amm, direction, oraclePriceData) {
     }
     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);
     // oracle retreat
     if (((0, types_1.isVariant)(direction, 'long') && targetMarkSpreadPct.lt(numericConstants_1.ZERO)) ||
         ((0, types_1.isVariant)(direction, 'short') && targetMarkSpreadPct.gt(numericConstants_1.ZERO))) {
-        spread = Math.max(spread, targetMarkSpreadPct.abs().toNumber());
+        spread = Math.max(spread, targetMarkSpreadPct.abs().toNumber() + confIntervalPct.abs().toNumber());
     }
     // inventory skew
     const MAX_INVENTORY_SKEW = 5;
@@ -161,9 +265,16 @@ function calculateSpread(amm, direction, oraclePriceData) {
         if (amm.totalFeeMinusDistributions.gt(numericConstants_1.ZERO)) {
             effectiveLeverage =
                 localPnl.sub(netPnl).toNumber() /
-                    amm.totalFeeMinusDistributions.toNumber();
+                    (amm.totalFeeMinusDistributions.toNumber() + 1);
+        }
+        let spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+        const maxTargetSpread = numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber() / 50; // 2%
+        // cap the scale to attempt to only scale up to maxTargetSpread
+        // always let the oracle retreat methods go through 100%
+        if (spreadScale * spread > maxTargetSpread) {
+            spreadScale = Math.max(1.05, maxTargetSpread / spread);
         }
-        spread *= Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+        spread *= spreadScale;
     }
     return spread;
 }

package/lib/math/orders.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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");
 function isOrderRiskIncreasing(user, order) {
     if ((0, types_1.isVariant)(order.status, 'init')) {
@@ -81,18 +80,9 @@ exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
 function getLimitPrice(order, 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);
-        }
-        else {
-            limitPrice = floatingPrice;
-        }
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
     }
-    else if ((0, types_1.isVariant)(order.orderType, 'market') ||
-        (0, types_1.isVariant)(order.orderType, 'triggerMarket')) {
+    else if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
         limitPrice = (0, auction_1.getAuctionPrice)(order, slot);
     }
     else {

package/lib/math/repeg.js

@@ -107,7 +107,7 @@ function calculateBudgetedPeg(amm, cost, targetPrice) {
     const targetPeg = targetPrice
         .mul(amm.baseAssetReserve)
         .div(amm.quoteAssetReserve)
-        .div(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.PEG_PRECISION));
+        .div(numericConstants_1.PRICE_DIV_PEG);
     const k = amm.sqrtK.mul(amm.sqrtK);
     const x = amm.baseAssetReserve;
     const y = amm.quoteAssetReserve;

package/lib/orders.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="bn.js" />
 import { MarketAccount, Order, UserAccount, UserPosition } from './types';
-import { BN, ClearingHouseUser } from '.';
+import { BN } from '.';
 import { OraclePriceData } from '.';
 export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: MarketAccount, order: Order): [UserAccount, UserPosition, MarketAccount] | null;
 export declare function calculateBaseAssetAmountMarketCanExecute(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
 export declare function calculateAmountToTradeForLimit(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
 export declare function calculateAmountToTradeForTriggerLimit(market: MarketAccount, order: Order): BN;
-export declare function calculateBaseAssetAmountUserCanExecute(market: MarketAccount, order: Order, user: ClearingHouseUser, oraclePriceData?: OraclePriceData): BN;

package/lib/orders.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateBaseAssetAmountUserCanExecute = exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
+exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
 const types_1 = require("./types");
 const _1 = require(".");
 const market_1 = require("./math/market");
@@ -88,7 +88,6 @@ function calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData
         return calculateAmountToTradeForTriggerLimit(market, order);
     }
     else if ((0, types_1.isVariant)(order.orderType, 'market')) {
-        // should never be a market order queued
         return numericConstants_1.ZERO;
     }
     else {
@@ -102,15 +101,7 @@ function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
         if (!oraclePriceData) {
             throw Error('Cant calculate limit price for oracle offset oracle without OraclePriceData');
         }
-        const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-        if (order.postOnly) {
-            limitPrice = (0, types_1.isVariant)(order.direction, 'long')
-                ? _1.BN.min(order.price, floatingPrice)
-                : _1.BN.max(order.price, floatingPrice);
-        }
-        else {
-            limitPrice = floatingPrice;
-        }
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
     }
     const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction);
     const baseAssetAmount = (0, _1.standardizeBaseAssetAmount)(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
@@ -125,11 +116,8 @@ function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
 }
 exports.calculateAmountToTradeForLimit = calculateAmountToTradeForLimit;
 function calculateAmountToTradeForTriggerLimit(market, order) {
-    if (order.baseAssetAmountFilled.eq(numericConstants_1.ZERO)) {
-        const baseAssetAmount = calculateAmountToTradeForTriggerMarket(market, order);
-        if (baseAssetAmount.eq(numericConstants_1.ZERO)) {
-            return numericConstants_1.ZERO;
-        }
+    if (!order.triggered) {
+        return numericConstants_1.ZERO;
     }
     return calculateAmountToTradeForLimit(market, order);
 }
@@ -139,75 +127,8 @@ function isSameDirection(firstDirection, secondDirection) {
         ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
 }
 function calculateAmountToTradeForTriggerMarket(market, order) {
-    return isTriggerConditionSatisfied(market, order)
-        ? order.baseAssetAmount
-        : numericConstants_1.ZERO;
-}
-function isTriggerConditionSatisfied(market, order, oraclePriceData) {
-    const markPrice = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
-    if ((0, types_1.isVariant)(order.triggerCondition, 'above')) {
-        return markPrice.gt(order.triggerPrice);
-    }
-    else {
-        return markPrice.lt(order.triggerPrice);
-    }
-}
-function calculateBaseAssetAmountUserCanExecute(market, order, user, oraclePriceData) {
-    const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
-    const freeCollateral = user.getFreeCollateral();
-    let quoteAssetAmount;
-    if ((0, _1.isOrderRiskIncreasingInSameDirection)(user, order)) {
-        quoteAssetAmount = freeCollateral.mul(maxLeverage).div(_1.TEN_THOUSAND);
-    }
-    else {
-        const position = user.getUserPosition(order.marketIndex) ||
-            user.getEmptyPosition(order.marketIndex);
-        const positionValue = (0, _1.calculateBaseAssetValue)(market, position, oraclePriceData);
-        quoteAssetAmount = freeCollateral
-            .mul(maxLeverage)
-            .div(_1.TEN_THOUSAND)
-            .add(positionValue.mul(numericConstants_1.TWO));
-    }
-    if (quoteAssetAmount.lte(numericConstants_1.ZERO)) {
+    if (!order.triggered) {
         return numericConstants_1.ZERO;
     }
-    const swapDirection = (0, types_1.isVariant)(order.direction, 'long')
-        ? types_1.SwapDirection.ADD
-        : types_1.SwapDirection.REMOVE;
-    const useSpread = !order.postOnly;
-    let amm;
-    if (useSpread) {
-        const { baseAssetReserve, quoteAssetReserve } = (0, _1.calculateSpreadReserves)(market.amm, order.direction, oraclePriceData);
-        amm = {
-            baseAssetReserve,
-            quoteAssetReserve,
-            sqrtK: market.amm.sqrtK,
-            pegMultiplier: market.amm.pegMultiplier,
-        };
-    }
-    else {
-        amm = market.amm;
-    }
-    const baseAssetReservesBefore = amm.baseAssetReserve;
-    const [_, baseAssetReservesAfter] = (0, _1.calculateAmmReservesAfterSwap)(amm, 'quote', quoteAssetAmount, swapDirection);
-    let baseAssetAmount = baseAssetReservesBefore
-        .sub(baseAssetReservesAfter)
-        .abs();
-    if (order.reduceOnly) {
-        const position = user.getUserPosition(order.marketIndex) ||
-            user.getEmptyPosition(order.marketIndex);
-        if ((0, types_1.isVariant)(order.direction, 'long') &&
-            position.baseAssetAmount.gte(numericConstants_1.ZERO)) {
-            baseAssetAmount = numericConstants_1.ZERO;
-        }
-        else if ((0, types_1.isVariant)(order.direction, 'short') &&
-            position.baseAssetAmount.lte(numericConstants_1.ZERO)) {
-            baseAssetAmount = numericConstants_1.ZERO;
-        }
-        else {
-            _1.BN.min(baseAssetAmount, position.baseAssetAmount.abs());
-        }
-    }
-    return baseAssetAmount;
+    return order.baseAssetAmount;
 }
-exports.calculateBaseAssetAmountUserCanExecute = calculateBaseAssetAmountUserCanExecute;

package/lib/types.d.ts

@@ -88,6 +88,9 @@ export declare class OrderAction {
     static readonly FILL: {
         fill: {};
     };
+    static readonly TRIGGER: {
+        trigger: {};
+    };
 }
 export declare class OrderTriggerCondition {
     static readonly ABOVE: {
@@ -304,6 +307,7 @@ export declare type AMM = {
     lastAskPriceTwap: BN;
     longSpread: BN;
     shortSpread: BN;
+    maxSpread: number;
 };
 export declare type UserPosition = {
     baseAssetAmount: BN;
@@ -356,6 +360,7 @@ export declare type Order = {
     reduceOnly: boolean;
     triggerPrice: BN;
     triggerCondition: OrderTriggerCondition;
+    triggered: boolean;
     discountTier: OrderDiscountTier;
     existingPositionDirection: PositionDirection;
     referrer: PublicKey;

package/lib/types.js

@@ -50,6 +50,7 @@ OrderAction.PLACE = { place: {} };
 OrderAction.CANCEL = { cancel: {} };
 OrderAction.EXPIRE = { expire: {} };
 OrderAction.FILL = { fill: {} };
+OrderAction.TRIGGER = { trigger: {} };
 class OrderTriggerCondition {
 }
 exports.OrderTriggerCondition = OrderTriggerCondition;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.2.0-master.0",
+	"version": "0.2.0-master.3",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -30,7 +30,7 @@
 	},
 	"dependencies": {
 		"@project-serum/anchor": "0.24.2",
-		"@pythnetwork/client": "^2.5.1",
+		"@pythnetwork/client": "2.5.1",
 		"@solana/spl-token": "^0.1.6",
 		"@solana/web3.js": "1.41.0",
 		"@switchboard-xyz/switchboard-v2": "^0.0.67",

package/src/admin.ts

@@ -444,6 +444,19 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
+	public async updateMarketMaxSpread(
+		marketIndex: BN,
+		maxSpread: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMarketMaxSpread(maxSpread, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
+			},
+		});
+	}
+
 	public async updatePartialLiquidationClosePercentage(
 		numerator: BN,
 		denominator: BN