@drift-labs/sdk 0.2.0-master.1 → 0.2.0-master.4

package/lib/types.d.ts

@@ -88,6 +88,23 @@ export declare class OrderAction {
     static readonly FILL: {
         fill: {};
     };
+    static readonly TRIGGER: {
+        trigger: {};
+    };
+}
+export declare class OrderActionExplanation {
+    static readonly NONE: {
+        none: {};
+    };
+    static readonly BREACHED_MARGIN_REQUIREMENT: {
+        breachedMarginRequirement: {};
+    };
+    static readonly ORACLE_PRICE_BREACHED_LIMIT_PRICE: {
+        oraclePriceBreachedLimitPrice: {};
+    };
+    static readonly MARKET_ORDER_FILLED_TO_LIMIT_PRICE: {
+        marketOrderFilledToLimitPrice: {};
+    };
 }
 export declare class OrderTriggerCondition {
     static readonly ABOVE: {
@@ -182,7 +199,10 @@ export declare type OrderRecord = {
     maker: PublicKey;
     takerOrder: Order;
     makerOrder: Order;
+    takerUnsettledPnl: BN;
+    makerUnsettledPnl: BN;
     action: OrderAction;
+    actionExplanation: OrderActionExplanation;
     filler: PublicKey;
     fillRecordId: BN;
     marketIndex: BN;
@@ -274,6 +294,8 @@ export declare type AMM = {
     lastMarkPriceTwapTs: BN;
     lastOraclePriceTwap: BN;
     lastOraclePriceTwapTs: BN;
+    lastOracleMarkSpreadPct: BN;
+    lastOracleConfPct: BN;
     oracle: PublicKey;
     oracleSource: OracleSource;
     fundingPeriod: BN;
@@ -288,6 +310,8 @@ export declare type AMM = {
     totalFee: BN;
     minimumQuoteAssetTradeSize: BN;
     baseAssetAmountStepSize: BN;
+    maxBaseAssetAmountRatio: number;
+    maxSlippageRatio: number;
     lastOraclePrice: BN;
     baseSpread: number;
     curveUpdateIntensity: number;
@@ -304,6 +328,7 @@ export declare type AMM = {
     lastAskPriceTwap: BN;
     longSpread: BN;
     shortSpread: BN;
+    maxSpread: number;
 };
 export declare type UserPosition = {
     baseAssetAmount: BN;
@@ -356,6 +381,7 @@ export declare type Order = {
     reduceOnly: boolean;
     triggerPrice: BN;
     triggerCondition: OrderTriggerCondition;
+    triggered: boolean;
     discountTier: OrderDiscountTier;
     existingPositionDirection: PositionDirection;
     referrer: PublicKey;
@@ -370,7 +396,6 @@ export declare type OrderParams = {
     orderType: OrderType;
     userOrderId: number;
     direction: PositionDirection;
-    quoteAssetAmount: BN;
     baseAssetAmount: BN;
     price: BN;
     marketIndex: BN;
@@ -388,6 +413,42 @@ export declare type OrderParams = {
         referrer: boolean;
     };
 };
+export declare type NecessaryOrderParams = {
+    orderType: OrderType;
+    marketIndex: BN;
+    baseAssetAmount: BN;
+    direction: PositionDirection;
+};
+export declare type OptionalOrderParams = {
+    [Property in keyof OrderParams]?: OrderParams[Property];
+} & NecessaryOrderParams;
+export declare const DefaultOrderParams: {
+    orderType: {
+        market: {};
+    };
+    userOrderId: number;
+    direction: {
+        long: {};
+    };
+    baseAssetAmount: BN;
+    price: BN;
+    marketIndex: BN;
+    reduceOnly: boolean;
+    postOnly: boolean;
+    immediateOrCancel: boolean;
+    triggerPrice: BN;
+    triggerCondition: {
+        above: {};
+    };
+    positionLimit: BN;
+    oraclePriceOffset: BN;
+    padding0: BN;
+    padding1: BN;
+    optionalAccounts: {
+        discountToken: boolean;
+        referrer: boolean;
+    };
+};
 export declare type MakerInfo = {
     maker: PublicKey;
     order: Order;

package/lib/types.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TradeSide = exports.isOneOfVariant = exports.isVariant = exports.OrderTriggerCondition = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.PositionDirection = exports.BankBalanceType = exports.SwapDirection = void 0;
+exports.DefaultOrderParams = exports.TradeSide = exports.isOneOfVariant = exports.isVariant = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.PositionDirection = exports.BankBalanceType = exports.SwapDirection = void 0;
+const _1 = require(".");
 // # Utility Types / Enums / Constants
 class SwapDirection {
 }
@@ -50,6 +51,20 @@ 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;
@@ -71,3 +86,24 @@ var TradeSide;
     TradeSide[TradeSide["Buy"] = 1] = "Buy";
     TradeSide[TradeSide["Sell"] = 2] = "Sell";
 })(TradeSide = exports.TradeSide || (exports.TradeSide = {}));
+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,
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.2.0-master.1",
+	"version": "0.2.0-master.4",
 	"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.3",
 		"@solana/spl-token": "^0.1.6",
 		"@solana/web3.js": "1.41.0",
 		"@switchboard-xyz/switchboard-v2": "^0.0.67",
@@ -39,10 +39,10 @@
 	},
 	"devDependencies": {
 		"@types/chai": "^4.3.1",
+		"@types/jest": "^28.1.3",
 		"@types/mocha": "^9.1.1",
 		"@typescript-eslint/eslint-plugin": "^4.28.0",
 		"@typescript-eslint/parser": "^4.28.0",
-		"@types/jest": "^28.1.3",
 		"chai": "^4.3.6",
 		"eslint": "^7.29.0",
 		"eslint-config-prettier": "^8.3.0",

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
@@ -662,17 +675,48 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async updateOrderAuctionTime(
-		time: BN | number
+	public async updateAuctionDuration(
+		minDuration: BN | number,
+		maxDuration: BN | number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateAuctionDuration(
+			typeof minDuration === 'number' ? minDuration : minDuration.toNumber(),
+			typeof maxDuration === 'number' ? maxDuration : maxDuration.toNumber(),
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+				},
+			}
+		);
+	}
+
+	public async updateMaxBaseAssetAmountRatio(
+		marketIndex: BN,
+		maxBaseAssetAmountRatio: number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateOrderAuctionTime(
-			typeof time === 'number' ? time : time.toNumber,
+		return await this.program.rpc.updateMaxBaseAssetAmountRatio(
+			maxBaseAssetAmountRatio,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
+					market: this.getMarketAccount(marketIndex).pubkey,
 				},
 			}
 		);
 	}
+
+	public async updateMaxSlippageRatio(
+		marketIndex: BN,
+		maxSlippageRatio: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: this.getMarketAccount(marketIndex).pubkey,
+			},
+		});
+	}
 }

package/src/clearingHouse.ts

@@ -11,6 +11,9 @@ import {
 	BankAccount,
 	UserBankBalance,
 	MakerInfo,
+	OptionalOrderParams,
+	DefaultOrderParams,
+	OrderType,
 } from './types';
 import * as anchor from '@project-serum/anchor';
 import clearingHouseIDL from './idl/clearing_house.json';
@@ -52,7 +55,6 @@ import { WebSocketClearingHouseAccountSubscriber } from './accounts/webSocketCle
 import { RetryTxSender } from './tx/retryTxSender';
 import { ClearingHouseUser } from './clearingHouseUser';
 import { ClearingHouseUserAccountSubscriptionConfig } from './clearingHouseUserConfig';
-import { getMarketOrderParams } from './orderParams';
 import { getMarketsBanksAndOraclesForSubscription } from './config';
 
 /**
@@ -798,20 +800,17 @@ export class ClearingHouse {
 		marketIndex: BN,
 		limitPrice?: BN
 	): Promise<TransactionSignature> {
-		return await this.placeAndTake(
-			getMarketOrderParams(
-				marketIndex,
-				direction,
-				ZERO,
-				amount,
-				false,
-				limitPrice
-			)
-		);
+		return await this.placeAndTake({
+			orderType: OrderType.MARKET,
+			marketIndex,
+			direction,
+			baseAssetAmount: amount,
+			price: limitPrice,
+		});
 	}
 
 	public async placeOrder(
-		orderParams: OrderParams
+		orderParams: OptionalOrderParams
 	): Promise<TransactionSignature> {
 		const { txSig, slot } = await this.txSender.send(
 			wrapInTx(await this.getPlaceOrderIx(orderParams)),
@@ -822,14 +821,16 @@ export class ClearingHouse {
 		return txSig;
 	}
 
+	getOrderParams(optionalOrderParams: OptionalOrderParams): OrderParams {
+		return Object.assign({}, DefaultOrderParams, optionalOrderParams);
+	}
+
 	public async getPlaceOrderIx(
-		orderParams: OrderParams
+		orderParams: OptionalOrderParams
 	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams);
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		const priceOracle = this.getMarketAccount(orderParams.marketIndex).amm
-			.oracle;
-
 		const remainingAccounts = this.getRemainingAccounts({
 			writableMarketIndex: orderParams.marketIndex,
 		});
@@ -839,38 +840,11 @@ export class ClearingHouse {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
-				oracle: priceOracle,
 			},
 			remainingAccounts,
 		});
 	}
 
-	public async expireOrders(
-		userAccountPublicKey: PublicKey
-	): Promise<TransactionSignature> {
-		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getExpireOrdersIx(userAccountPublicKey)),
-			[],
-			this.opts
-		);
-		return txSig;
-	}
-
-	public async getExpireOrdersIx(
-		userAccountPublicKey: PublicKey
-	): Promise<TransactionInstruction> {
-		const fillerPublicKey = await this.getUserAccountPublicKey();
-
-		return await this.program.instruction.expireOrders({
-			accounts: {
-				state: await this.getStatePublicKey(),
-				filler: fillerPublicKey,
-				user: userAccountPublicKey,
-				authority: this.wallet.publicKey,
-			},
-		});
-	}
-
 	public async updateAMMs(marketIndexes: BN[]): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(await this.getUpdateAMMsIx(marketIndexes)),
@@ -914,7 +888,7 @@ export class ClearingHouse {
 		});
 	}
 
-	public async cancelOrder(orderId: BN): Promise<TransactionSignature> {
+	public async cancelOrder(orderId?: BN): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(await this.getCancelOrderIx(orderId)),
 			[],
@@ -923,20 +897,16 @@ export class ClearingHouse {
 		return txSig;
 	}
 
-	public async getCancelOrderIx(orderId: BN): Promise<TransactionInstruction> {
+	public async getCancelOrderIx(orderId?: BN): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		const order = this.getOrder(orderId);
-		const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
-
 		const remainingAccounts = this.getRemainingAccounts({});
 
-		return await this.program.instruction.cancelOrder(orderId, {
+		return await this.program.instruction.cancelOrder(orderId ?? null, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
-				oracle,
 			},
 			remainingAccounts,
 		});
@@ -974,36 +944,90 @@ export class ClearingHouse {
 		});
 	}
 
-	public async cancelAllOrders(
-		bestEffort?: boolean
+	public async fillOrder(
+		userAccountPublicKey: PublicKey,
+		user: UserAccount,
+		order?: Order,
+		makerInfo?: MakerInfo
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getCancelAllOrdersIx(bestEffort)),
+			wrapInTx(
+				await this.getFillOrderIx(userAccountPublicKey, user, order, makerInfo)
+			),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getCancelAllOrdersIx(
-		bestEffort?: boolean
+	public async getFillOrderIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		order: Order,
+		makerInfo?: MakerInfo
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const fillerPublicKey = await this.getUserAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccounts({});
+		const marketIndex = order.marketIndex;
+		const marketAccount = this.getMarketAccount(marketIndex);
 
-		for (const order of this.getUserAccount().orders) {
-			const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
-			remainingAccounts.push({
-				pubkey: oracle,
+		const bankAccountInfos = [
+			{
+				pubkey: this.getQuoteAssetBankAccount().pubkey,
+				isSigner: false,
+				isWritable: true,
+			},
+		];
+		const marketAccountInfos = [
+			{
+				pubkey: marketAccount.pubkey,
+				isWritable: true,
+				isSigner: false,
+			},
+		];
+		const oracleAccountInfos = [
+			{
+				pubkey: marketAccount.amm.oracle,
 				isWritable: false,
 				isSigner: false,
+			},
+		];
+		for (const position of userAccount.positions) {
+			if (
+				!positionIsAvailable(position) &&
+				!position.marketIndex.eq(order.marketIndex)
+			) {
+				const market = this.getMarketAccount(position.marketIndex);
+				marketAccountInfos.push({
+					pubkey: market.pubkey,
+					isWritable: true,
+					isSigner: false,
+				});
+				oracleAccountInfos.push({
+					pubkey: market.amm.oracle,
+					isWritable: false,
+					isSigner: false,
+				});
+			}
+		}
+		const remainingAccounts = oracleAccountInfos.concat(
+			bankAccountInfos.concat(marketAccountInfos)
+		);
+
+		if (makerInfo) {
+			remainingAccounts.push({
+				pubkey: makerInfo.maker,
+				isWritable: true,
+				isSigner: false,
 			});
 		}
 
-		return await this.program.instruction.cancelAllOrders(bestEffort, {
+		const orderId = order.orderId;
+		const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
+		return await this.program.instruction.fillOrder(orderId, makerOrderId, {
 			accounts: {
 				state: await this.getStatePublicKey(),
+				filler: fillerPublicKey,
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
 			},
@@ -1011,85 +1035,28 @@ export class ClearingHouse {
 		});
 	}
 
-	public async cancelOrdersByMarketAndSide(
-		bestEffort?: boolean,
-		marketIndexOnly?: BN,
-		directionOnly?: PositionDirection
-	): Promise<TransactionSignature> {
-		const { txSig } = await this.txSender.send(
-			wrapInTx(
-				await this.getCancelOrdersByMarketAndSideIx(
-					bestEffort,
-					marketIndexOnly,
-					directionOnly
-				)
-			),
-			[],
-			this.opts
-		);
-		return txSig;
-	}
-
-	public async getCancelOrdersByMarketAndSideIx(
-		bestEffort?: boolean,
-		marketIndexOnly?: BN,
-		directionOnly?: PositionDirection
-	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-
-		const remainingAccounts = this.getRemainingAccounts({});
-
-		for (const order of this.getUserAccount().orders) {
-			const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
-			remainingAccounts.push({
-				pubkey: oracle,
-				isWritable: false,
-				isSigner: false,
-			});
-		}
-
-		return await this.program.instruction.cancelOrdersByMarketAndSide(
-			bestEffort,
-			marketIndexOnly,
-			directionOnly,
-			{
-				accounts: {
-					state: await this.getStatePublicKey(),
-					user: userAccountPublicKey,
-					authority: this.wallet.publicKey,
-				},
-				remainingAccounts,
-			}
-		);
-	}
-
-	public async fillOrder(
+	public async triggerOrder(
 		userAccountPublicKey: PublicKey,
 		user: UserAccount,
-		order: Order,
-		makerInfo?: MakerInfo
+		order: Order
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(
-				await this.getFillOrderIx(userAccountPublicKey, user, order, makerInfo)
-			),
+			wrapInTx(await this.getTriggerOrderIx(userAccountPublicKey, user, order)),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getFillOrderIx(
+	public async getTriggerOrderIx(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
-		order: Order,
-		makerInfo?: MakerInfo
+		order: Order
 	): Promise<TransactionInstruction> {
 		const fillerPublicKey = await this.getUserAccountPublicKey();
 
 		const marketIndex = order.marketIndex;
 		const marketAccount = this.getMarketAccount(marketIndex);
-		const oracle = marketAccount.amm.oracle;
 
 		const bankAccountInfos = [
 			{
@@ -1134,30 +1101,20 @@ export class ClearingHouse {
 			bankAccountInfos.concat(marketAccountInfos)
 		);
 
-		if (makerInfo) {
-			remainingAccounts.push({
-				pubkey: makerInfo.maker,
-				isWritable: true,
-				isSigner: false,
-			});
-		}
-
 		const orderId = order.orderId;
-		const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
-		return await this.program.instruction.fillOrder(orderId, makerOrderId, {
+		return await this.program.instruction.triggerOrder(orderId, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				filler: fillerPublicKey,
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
-				oracle: oracle,
 			},
 			remainingAccounts,
 		});
 	}
 
 	public async placeAndTake(
-		orderParams: OrderParams,
+		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo
 	): Promise<TransactionSignature> {
 		const { txSig, slot } = await this.txSender.send(
@@ -1170,14 +1127,12 @@ export class ClearingHouse {
 	}
 
 	public async getPlaceAndTakeIx(
-		orderParams: OrderParams,
+		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo
 	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams);
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		const priceOracle = this.getMarketAccount(orderParams.marketIndex).amm
-			.oracle;
-
 		const remainingAccounts = this.getRemainingAccounts({
 			writableMarketIndex: orderParams.marketIndex,
 			writableBankIndex: QUOTE_ASSET_BANK_INDEX,
@@ -1201,7 +1156,6 @@ export class ClearingHouse {
 					state: await this.getStatePublicKey(),
 					user: userAccountPublicKey,
 					authority: this.wallet.publicKey,
-					oracle: priceOracle,
 				},
 				remainingAccounts,
 			}
@@ -1219,16 +1173,13 @@ export class ClearingHouse {
 			throw Error(`No position in market ${marketIndex.toString()}`);
 		}
 
-		return await this.placeAndTake(
-			getMarketOrderParams(
-				marketIndex,
-				findDirectionToClose(userPosition),
-				ZERO,
-				userPosition.baseAssetAmount,
-				true,
-				undefined
-			)
-		);
+		return await this.placeAndTake({
+			orderType: OrderType.MARKET,
+			marketIndex,
+			direction: findDirectionToClose(userPosition),
+			baseAssetAmount: userPosition.baseAssetAmount,
+			reduceOnly: true,
+		});
 	}
 
 	public async settlePNLs(

package/src/config.ts

@@ -28,7 +28,7 @@ export const configs: { [key in DriftEnv]: DriftConfig } = {
 	devnet: {
 		ENV: 'devnet',
 		PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-		CLEARING_HOUSE_PROGRAM_ID: 'GCuH76fb1rXc7bjFXNcnNvWSekLgzpsnMbc1Ng4FsGSs',
+		CLEARING_HOUSE_PROGRAM_ID: '9jwr5nC2f9yAraXrg4UzHXmCX3vi9FQkjD6p9e8bRqNa',
 		USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
 		MARKETS: DevnetMarkets,
 		BANKS: DevnetBanks,

package/src/constants/numericConstants.ts

@@ -43,6 +43,7 @@ export const BASE_PRECISION_EXP = AMM_RESERVE_PRECISION_EXP;
 
 export const AMM_TO_QUOTE_PRECISION_RATIO =
 	AMM_RESERVE_PRECISION.div(QUOTE_PRECISION); // 10^7
+export const PRICE_DIV_PEG = MARK_PRICE_PRECISION.div(PEG_PRECISION); //10^7
 export const PRICE_TO_QUOTE_PRECISION =
 	MARK_PRICE_PRECISION.div(QUOTE_PRECISION);
 export const AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO =