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

package/src/factory/clearingHouse.ts

@@ -10,6 +10,7 @@ import { DefaultTxSender } from '../tx/defaultTxSender';
 import { ClearingHouseAccountSubscriber } from '../accounts/types';
 import { PollingClearingHouseAccountSubscriber } from '../accounts/pollingClearingHouseAccountSubscriber';
 import { Admin } from '../admin';
+import { RetryTxSender } from '../tx/retryTxSender';
 
 export type ClearingHouseConfigType = 'websocket' | 'polling' | 'custom';
 
@@ -19,7 +20,7 @@ type BaseClearingHouseConfig = {
 	wallet: IWallet;
 	programID: PublicKey;
 	opts?: ConfirmOptions;
-	txSender?: TxSender;
+	txSenderConfig?: TxSenderConfig;
 };
 
 type WebSocketClearingHouseConfiguration = BaseClearingHouseConfig;
@@ -32,12 +33,28 @@ type ClearingHouseConfig =
 	| PollingClearingHouseConfiguration
 	| WebSocketClearingHouseConfiguration;
 
+export type TxSenderType = 'default' | 'retry';
+
+type BaseTxSenderConfig = {
+	type: TxSenderType;
+};
+
+type DefaultTxSenderConfig = BaseTxSenderConfig;
+
+type RetryTxSenderConfig = BaseTxSenderConfig & {
+	timeout?: number;
+	retrySleep?: number;
+	additionalConnections?: Connection[];
+};
+
+type TxSenderConfig = DefaultTxSenderConfig | RetryTxSenderConfig;
+
 export function getWebSocketClearingHouseConfig(
 	connection: Connection,
 	wallet: IWallet,
 	programID: PublicKey,
 	opts: ConfirmOptions = Provider.defaultOptions(),
-	txSender?: TxSender
+	txSenderConfig?: TxSenderConfig
 ): WebSocketClearingHouseConfiguration {
 	return {
 		type: 'websocket',
@@ -45,7 +62,7 @@ export function getWebSocketClearingHouseConfig(
 		wallet,
 		programID,
 		opts,
-		txSender,
+		txSenderConfig,
 	};
 }
 
@@ -55,7 +72,7 @@ export function getPollingClearingHouseConfig(
 	programID: PublicKey,
 	accountLoader: BulkAccountLoader,
 	opts: ConfirmOptions = Provider.defaultOptions(),
-	txSender?: TxSender
+	txSenderConfig?: TxSenderConfig
 ): PollingClearingHouseConfiguration {
 	return {
 		type: 'polling',
@@ -64,7 +81,7 @@ export function getPollingClearingHouseConfig(
 		programID,
 		accountLoader,
 		opts,
-		txSender,
+		txSenderConfig,
 	};
 }
 
@@ -85,7 +102,19 @@ export function getClearingHouse(config: ClearingHouseConfig): ClearingHouse {
 		);
 	}
 
-	const txSender = config.txSender || new DefaultTxSender(provider);
+	let txSender: TxSender;
+	if (config.txSenderConfig?.type === 'retry') {
+		const txSenderConfig = config.txSenderConfig as RetryTxSenderConfig;
+		txSender = new RetryTxSender(
+			provider,
+			txSenderConfig.timeout,
+			txSenderConfig.retrySleep,
+			txSenderConfig.additionalConnections
+		);
+	} else {
+		txSender = new DefaultTxSender(provider);
+	}
+
 	return new ClearingHouse(
 		config.connection,
 		config.wallet,
@@ -113,7 +142,18 @@ export function getAdmin(config: ClearingHouseConfig): Admin {
 		);
 	}
 
-	const txSender = config.txSender || new DefaultTxSender(provider);
+	let txSender: TxSender;
+	if (config.txSenderConfig?.type === 'retry') {
+		const txSenderConfig = config.txSenderConfig as RetryTxSenderConfig;
+		txSender = new RetryTxSender(
+			provider,
+			txSenderConfig.timeout,
+			txSenderConfig.retrySleep,
+			txSenderConfig.additionalConnections
+		);
+	} else {
+		txSender = new DefaultTxSender(provider);
+	}
 	return new Admin(
 		config.connection,
 		config.wallet,

package/src/idl/clearing_house.json

@@ -1482,32 +1482,6 @@
         }
       ]
     },
-    {
-      "name": "deleteUser",
-      "accounts": [
-        {
-          "name": "user",
-          "isMut": true,
-          "isSigner": false
-        },
-        {
-          "name": "userPositions",
-          "isMut": true,
-          "isSigner": false
-        },
-        {
-          "name": "userOrders",
-          "isMut": true,
-          "isSigner": false
-        },
-        {
-          "name": "authority",
-          "isMut": false,
-          "isSigner": true
-        }
-      ],
-      "args": []
-    },
     {
       "name": "settleFundingPayment",
       "accounts": [
@@ -3292,8 +3266,8 @@
             "type": "u128"
           },
           {
-            "name": "netRevenueSinceLastFunding",
-            "type": "i64"
+            "name": "padding1",
+            "type": "u64"
           },
           {
             "name": "padding2",
@@ -4300,11 +4274,6 @@
       "code": 6060,
       "name": "CantExpireOrders",
       "msg": "CantExpireOrders"
-    },
-    {
-      "code": 6061,
-      "name": "InvalidRepegPriceImpact",
-      "msg": "AMM repeg mark price impact vs oracle too large"
     }
   ]
 }

package/src/index.ts

@@ -29,7 +29,6 @@ export * from './math/position';
 export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';
-export * from './math/repeg';
 export * from './orders';
 export * from './orderParams';
 export * from './wallet';

package/src/math/amm.ts

@@ -4,7 +4,11 @@ import {
 	MARK_PRICE_PRECISION,
 	PEG_PRECISION,
 	ZERO,
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	QUOTE_PRECISION,
+	AMM_RESERVE_PRECISION,
 } from '../constants/numericConstants';
+import { calculateBaseAssetValue } from './position';
 import {
 	AMM,
 	PositionDirection,
@@ -13,7 +17,12 @@ import {
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
-import { squareRootBN } from '..';
+import {
+	calculatePositionPNL,
+	calculateMarkPrice,
+	convertToNumber,
+	squareRootBN,
+} from '..';
 
 /**
  * Calculates a price given an arbitrary base and quote amount (they must have the same precision)
@@ -130,6 +139,125 @@ export function getSwapDirection(
 	return SwapDirection.ADD;
 }
 
+/**
+ * Helper function calculating adjust k cost
+ * @param market
+ * @param marketIndex
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateAdjustKCost(
+	market: Market,
+	marketIndex: BN,
+	numerator: BN,
+	denomenator: BN
+): BN {
+	const netUserPosition = {
+		baseAssetAmount: market.baseAssetAmount,
+		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+		marketIndex: new BN(marketIndex),
+		quoteAssetAmount: new BN(0),
+		openOrders: new BN(0),
+	};
+
+	const currentValue = calculateBaseAssetValue(market, netUserPosition);
+
+	const marketNewK = Object.assign({}, market);
+	marketNewK.amm = Object.assign({}, market.amm);
+
+	marketNewK.amm.baseAssetReserve = market.amm.baseAssetReserve
+		.mul(numerator)
+		.div(denomenator);
+	marketNewK.amm.quoteAssetReserve = market.amm.quoteAssetReserve
+		.mul(numerator)
+		.div(denomenator);
+	marketNewK.amm.sqrtK = market.amm.sqrtK.mul(numerator).div(denomenator);
+
+	netUserPosition.quoteAssetAmount = currentValue;
+
+	const cost = calculatePositionPNL(marketNewK, netUserPosition);
+
+	const p = PEG_PRECISION.mul(numerator).div(denomenator);
+	const x = market.amm.baseAssetReserve;
+	const y = market.amm.quoteAssetReserve;
+	const delta = market.baseAssetAmount;
+	const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+
+	const numer1 = PEG_PRECISION.sub(p).mul(y).div(PEG_PRECISION);
+	const numer20 = k
+		.mul(p)
+		.mul(p)
+		.div(PEG_PRECISION)
+		.div(PEG_PRECISION)
+		.div(x.mul(p).div(PEG_PRECISION).add(delta));
+	const numer21 = k.div(x.add(delta));
+
+	const formulaCost = numer21
+		.sub(numer20)
+		.sub(numer1)
+		.mul(market.amm.pegMultiplier)
+		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+	console.log(convertToNumber(formulaCost, QUOTE_PRECISION));
+
+	// p.div(p.mul(x).add(delta)).sub()
+
+	return cost;
+}
+
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param market
+ * @param marketIndex
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateRepegCost(
+	market: Market,
+	marketIndex: BN,
+	newPeg: BN
+): BN {
+	const netUserPosition = {
+		baseAssetAmount: market.baseAssetAmount,
+		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+		marketIndex: new BN(marketIndex),
+		quoteAssetAmount: new BN(0),
+		openOrders: new BN(0),
+	};
+
+	const currentValue = calculateBaseAssetValue(market, netUserPosition);
+	netUserPosition.quoteAssetAmount = currentValue;
+	const prevMarketPrice = calculateMarkPrice(market);
+	const marketNewPeg = Object.assign({}, market);
+	marketNewPeg.amm = Object.assign({}, market.amm);
+
+	// const marketNewPeg = JSON.parse(JSON.stringify(market));
+	marketNewPeg.amm.pegMultiplier = newPeg;
+
+	console.log(
+		'Price moves from',
+		convertToNumber(prevMarketPrice),
+		'to',
+		convertToNumber(calculateMarkPrice(marketNewPeg))
+	);
+
+	const cost = calculatePositionPNL(marketNewPeg, netUserPosition);
+
+	const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+	const newQuoteAssetReserve = k.div(
+		market.amm.baseAssetReserve.add(netUserPosition.baseAssetAmount)
+	);
+	const deltaQuoteAssetReserves = newQuoteAssetReserve.sub(
+		market.amm.quoteAssetReserve
+	);
+	const cost2 = deltaQuoteAssetReserves
+		.mul(market.amm.pegMultiplier.sub(newPeg))
+		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+	console.log(convertToNumber(cost2, QUOTE_PRECISION));
+	return cost;
+}
+
 /**
  * Helper function calculating terminal price of amm
  *
@@ -187,3 +315,86 @@ export function calculateMaxBaseAssetAmountToTrade(
 		return [new BN(0), PositionDirection.LONG];
 	}
 }
+
+export function calculateBudgetedK(market: Market, cost: BN): [BN, BN] {
+	// wolframalpha.com
+	// (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+	// p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+
+	// todo: assumes k = x * y
+	// otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+
+	// const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+	const x = market.amm.baseAssetReserve;
+	const y = market.amm.quoteAssetReserve;
+
+	const d = market.baseAssetAmount;
+	const Q = market.amm.pegMultiplier;
+
+	const C = cost.mul(new BN(-1));
+
+	const numer1 = y.mul(d).mul(Q).div(AMM_RESERVE_PRECISION).div(PEG_PRECISION);
+	const numer2 = C.mul(x.add(d)).div(QUOTE_PRECISION);
+	const denom1 = C.mul(x)
+		.mul(x.add(d))
+		.div(AMM_RESERVE_PRECISION)
+		.div(QUOTE_PRECISION);
+	const denom2 = y
+		.mul(d)
+		.mul(d)
+		.mul(Q)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_RESERVE_PRECISION)
+		.div(PEG_PRECISION);
+
+	const numerator = d
+		.mul(numer1.add(numer2))
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO);
+	const denominator = denom1
+		.add(denom2)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO);
+	console.log(numerator, denominator);
+	// const p = (numerator).div(denominator);
+
+	// const formulaCost = (numer21.sub(numer20).sub(numer1)).mul(market.amm.pegMultiplier).div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+	// console.log(convertToNumber(formulaCost, QUOTE_PRECISION))
+
+	return [numerator, denominator];
+}
+
+export function calculateBudgetedPeg(market: Market, cost: BN): BN {
+	// wolframalpha.com
+	// (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+	// p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+
+	// todo: assumes k = x * y
+	// otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+
+	const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+	const x = market.amm.baseAssetReserve;
+	const y = market.amm.quoteAssetReserve;
+
+	const d = market.baseAssetAmount;
+	const Q = market.amm.pegMultiplier;
+
+	const C = cost.mul(new BN(-1));
+
+	const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
+	const deltaPegMultiplier = C.mul(MARK_PRICE_PRECISION)
+		.div(deltaQuoteAssetReserves.div(AMM_TO_QUOTE_PRECISION_RATIO))
+		.mul(PEG_PRECISION)
+		.div(QUOTE_PRECISION);
+	console.log(
+		Q.toNumber(),
+		'change by',
+		deltaPegMultiplier.toNumber() / MARK_PRICE_PRECISION.toNumber()
+	);
+	const newPeg = Q.sub(
+		deltaPegMultiplier.mul(PEG_PRECISION).div(MARK_PRICE_PRECISION)
+	);
+
+	return newPeg;
+}

package/src/util/promiseTimeout.ts

@@ -0,0 +1,14 @@
+export function promiseTimeout<T>(
+	promise: Promise<T>,
+	timeoutMs: number
+): Promise<T | null> {
+	let timeoutId: ReturnType<typeof setTimeout>;
+	const timeoutPromise: Promise<null> = new Promise((resolve) => {
+		timeoutId = setTimeout(() => resolve(null), timeoutMs);
+	});
+
+	return Promise.race([promise, timeoutPromise]).then((result: T | null) => {
+		clearTimeout(timeoutId);
+		return result;
+	});
+}

package/lib/math/repeg.d.ts

@@ -1,32 +0,0 @@
-/// <reference types="bn.js" />
-import { BN } from '@project-serum/anchor';
-import { Market } from '../types';
-/**
- * Helper function calculating adjust k cost
- * @param market
- * @param marketIndex
- * @param numerator
- * @param denomenator
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-export declare function calculateAdjustKCost(market: Market, marketIndex: BN, numerator: BN, denomenator: BN): BN;
-/**
- * Helper function calculating adjust pegMultiplier (repeg) cost
- *
- * @param market
- * @param marketIndex
- * @param newPeg
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-export declare function calculateRepegCost(market: Market, marketIndex: BN, newPeg: BN): BN;
-/**
- * Helper function calculating adjust pegMultiplier (repeg) cost
- *
- * @param market
- * @param marketIndex
- * @param newPeg
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-export declare function calculateReserveRebalanceCost(market: Market, marketIndex: BN): BN;
-export declare function calculateBudgetedK(market: Market, cost: BN): [BN, BN];
-export declare function calculateBudgetedPeg(market: Market, cost: BN): BN;

package/lib/math/repeg.js

@@ -1,178 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateBudgetedPeg = exports.calculateBudgetedK = exports.calculateReserveRebalanceCost = exports.calculateRepegCost = exports.calculateAdjustKCost = void 0;
-const anchor_1 = require("@project-serum/anchor");
-const numericConstants_1 = require("../constants/numericConstants");
-const position_1 = require("./position");
-const amm_1 = require("./amm");
-const __1 = require("..");
-/**
- * Helper function calculating adjust k cost
- * @param market
- * @param marketIndex
- * @param numerator
- * @param denomenator
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-function calculateAdjustKCost(market, marketIndex, numerator, denomenator) {
-    const netUserPosition = {
-        baseAssetAmount: market.baseAssetAmount,
-        lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
-        marketIndex: new anchor_1.BN(marketIndex),
-        quoteAssetAmount: numericConstants_1.ZERO,
-        openOrders: numericConstants_1.ZERO,
-    };
-    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
-    const marketNewK = Object.assign({}, market);
-    marketNewK.amm = Object.assign({}, market.amm);
-    marketNewK.amm.baseAssetReserve = market.amm.baseAssetReserve
-        .mul(numerator)
-        .div(denomenator);
-    marketNewK.amm.quoteAssetReserve = market.amm.quoteAssetReserve
-        .mul(numerator)
-        .div(denomenator);
-    marketNewK.amm.sqrtK = market.amm.sqrtK.mul(numerator).div(denomenator);
-    netUserPosition.quoteAssetAmount = currentValue;
-    const cost = (0, __1.calculatePositionPNL)(marketNewK, netUserPosition);
-    return cost;
-}
-exports.calculateAdjustKCost = calculateAdjustKCost;
-/**
- * Helper function calculating adjust pegMultiplier (repeg) cost
- *
- * @param market
- * @param marketIndex
- * @param newPeg
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-function calculateRepegCost(market, marketIndex, newPeg) {
-    const netUserPosition = {
-        baseAssetAmount: market.baseAssetAmount,
-        lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
-        marketIndex: new anchor_1.BN(marketIndex),
-        quoteAssetAmount: new anchor_1.BN(0),
-        openOrders: numericConstants_1.ZERO,
-    };
-    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
-    netUserPosition.quoteAssetAmount = currentValue;
-    const prevMarketPrice = (0, __1.calculateMarkPrice)(market);
-    const marketNewPeg = Object.assign({}, market);
-    marketNewPeg.amm = Object.assign({}, market.amm);
-    // const marketNewPeg = JSON.parse(JSON.stringify(market));
-    marketNewPeg.amm.pegMultiplier = newPeg;
-    console.log('Price moves from', (0, __1.convertToNumber)(prevMarketPrice), 'to', (0, __1.convertToNumber)((0, __1.calculateMarkPrice)(marketNewPeg)));
-    const cost = (0, __1.calculatePositionPNL)(marketNewPeg, netUserPosition);
-    return cost;
-}
-exports.calculateRepegCost = calculateRepegCost;
-/**
- * Helper function calculating adjust pegMultiplier (repeg) cost
- *
- * @param market
- * @param marketIndex
- * @param newPeg
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-function calculateReserveRebalanceCost(market, marketIndex) {
-    const netUserPosition = {
-        baseAssetAmount: market.baseAssetAmount,
-        lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
-        marketIndex: new anchor_1.BN(marketIndex),
-        quoteAssetAmount: new anchor_1.BN(0),
-        openOrders: numericConstants_1.ZERO,
-    };
-    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
-    netUserPosition.quoteAssetAmount = currentValue;
-    const prevMarketPrice = (0, __1.calculateMarkPrice)(market);
-    const marketNewPeg = Object.assign({}, market);
-    marketNewPeg.amm = Object.assign({}, market.amm);
-    // const marketNewPeg = JSON.parse(JSON.stringify(market));
-    const newPeg = (0, amm_1.calculateTerminalPrice)(market)
-        .mul(numericConstants_1.PEG_PRECISION)
-        .div(numericConstants_1.MARK_PRICE_PRECISION);
-    // const newPeg = prevMarketPrice.mul(PEG_PRECISION).div(MARK_PRICE_PRECISION);
-    const newBaseReserve = market.amm.baseAssetReserve.add(market.baseAssetAmount);
-    const newQuoteReserve = market.amm.sqrtK
-        .mul(market.amm.sqrtK)
-        .div(newBaseReserve);
-    console.log('current reserves on close, quote:', (0, __1.convertToNumber)(newQuoteReserve, numericConstants_1.AMM_RESERVE_PRECISION), 'base:', (0, __1.convertToNumber)(newBaseReserve, numericConstants_1.AMM_RESERVE_PRECISION));
-    let newSqrtK;
-    if (newPeg.lt(market.amm.pegMultiplier)) {
-        newSqrtK = newBaseReserve;
-    }
-    else {
-        newSqrtK = newQuoteReserve;
-    }
-    marketNewPeg.amm.baseAssetReserve = newSqrtK.sub(market.baseAssetAmount); // newSqrtK.sub(market.baseAssetAmount);
-    marketNewPeg.amm.quoteAssetReserve = newSqrtK
-        .mul(newSqrtK)
-        .div(marketNewPeg.amm.baseAssetReserve);
-    marketNewPeg.amm.sqrtK = newSqrtK;
-    marketNewPeg.amm.pegMultiplier = newPeg;
-    console.log('Price moves from', (0, __1.convertToNumber)(prevMarketPrice), 'to', (0, __1.convertToNumber)((0, __1.calculateMarkPrice)(marketNewPeg)));
-    const cost = (0, __1.calculatePositionPNL)(marketNewPeg, netUserPosition);
-    return cost;
-}
-exports.calculateReserveRebalanceCost = calculateReserveRebalanceCost;
-function calculateBudgetedK(market, cost) {
-    // wolframalpha.com
-    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
-    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
-    // todo: assumes k = x * y
-    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
-    // const k = market.amm.sqrtK.mul(market.amm.sqrtK);
-    const x = market.amm.baseAssetReserve;
-    const y = market.amm.quoteAssetReserve;
-    const d = market.baseAssetAmount;
-    const Q = market.amm.pegMultiplier;
-    const C = cost.mul(new anchor_1.BN(-1));
-    const numer1 = y.mul(d).mul(Q).div(numericConstants_1.AMM_RESERVE_PRECISION).div(numericConstants_1.PEG_PRECISION);
-    const numer2 = C.mul(x.add(d)).div(numericConstants_1.QUOTE_PRECISION);
-    const denom1 = C.mul(x)
-        .mul(x.add(d))
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.QUOTE_PRECISION);
-    const denom2 = y
-        .mul(d)
-        .mul(d)
-        .mul(Q)
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.PEG_PRECISION);
-    const numerator = d
-        .mul(numer1.add(numer2))
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
-    const denominator = denom1
-        .add(denom2)
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
-    console.log(numerator, denominator);
-    // const p = (numerator).div(denominator);
-    // const formulaCost = (numer21.sub(numer20).sub(numer1)).mul(market.amm.pegMultiplier).div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
-    // console.log(convertToNumber(formulaCost, QUOTE_PRECISION))
-    return [numerator, denominator];
-}
-exports.calculateBudgetedK = calculateBudgetedK;
-function calculateBudgetedPeg(market, cost) {
-    // wolframalpha.com
-    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
-    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
-    // todo: assumes k = x * y
-    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
-    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
-    const x = market.amm.baseAssetReserve;
-    const y = market.amm.quoteAssetReserve;
-    const d = market.baseAssetAmount;
-    const Q = market.amm.pegMultiplier;
-    const C = cost.mul(new anchor_1.BN(-1));
-    const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
-    const deltaPegMultiplier = C.mul(numericConstants_1.MARK_PRICE_PRECISION).div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO));
-    // .mul(PEG_PRECISION)
-    // .div(QUOTE_PRECISION);
-    console.log(Q.toNumber(), 'change by', deltaPegMultiplier.toNumber() / numericConstants_1.MARK_PRICE_PRECISION.toNumber());
-    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.MARK_PRICE_PRECISION));
-    return newPeg;
-}
-exports.calculateBudgetedPeg = calculateBudgetedPeg;