@drift-labs/sdk 0.1.21-master.3 → 0.1.23-master.0

package/lib/accounts/bulkUserSubscription.js

@@ -16,8 +16,46 @@ exports.bulkPollingUserSubscribe = void 0;
  */
 function bulkPollingUserSubscribe(users, accountLoader) {
     return __awaiter(this, void 0, void 0, function* () {
+        if (users.length === 0) {
+            yield accountLoader.load();
+            return;
+        }
+        // Fetch all the accounts first
+        const program = users[0].clearingHouse.program;
+        let userProgramAccounts;
+        let orderProgramAccounts;
+        yield Promise.all([
+            (() => __awaiter(this, void 0, void 0, function* () {
+                userProgramAccounts = yield program.account.user.all();
+            }))(),
+            (() => __awaiter(this, void 0, void 0, function* () {
+                orderProgramAccounts = yield program.account.userOrders.all();
+            }))(),
+        ]);
+        // Create a map of the authority to keys
+        const authorityToKeys = new Map();
+        const userToAuthority = new Map();
+        for (const userProgramAccount of userProgramAccounts) {
+            const userAccountPublicKey = userProgramAccount.publicKey;
+            const userAccount = userProgramAccount.account;
+            authorityToKeys.set(userAccount.authority.toString(), {
+                user: userAccountPublicKey,
+                userPositions: userAccount.positions,
+                userOrders: undefined,
+            });
+            userToAuthority.set(userAccountPublicKey.toString(), userAccount.authority.toString());
+        }
+        for (const orderProgramAccount of orderProgramAccounts) {
+            const userOrderAccountPublicKey = orderProgramAccount.publicKey;
+            const userOrderAccount = orderProgramAccount.account;
+            const authority = userToAuthority.get(userOrderAccount.user.toString());
+            const userPublicKeys = authorityToKeys.get(authority);
+            userPublicKeys.userOrders = userOrderAccountPublicKey;
+        }
         yield Promise.all(users.map((user) => {
-            return user.accountSubscriber.addToAccountLoader();
+            // Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
+            const userPublicKeys = authorityToKeys.get(user.authority.toString());
+            return user.accountSubscriber.addToAccountLoader(userPublicKeys);
         }));
         yield accountLoader.load();
         yield Promise.all(users.map((user) => __awaiter(this, void 0, void 0, function* () {

package/lib/accounts/pollingUserAccountSubscriber.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { AccountToPoll, UserAccountEvents, UserAccountSubscriber } from './types';
+import { AccountToPoll, UserAccountEvents, UserAccountSubscriber, UserPublicKeys } from './types';
 import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
@@ -21,7 +21,7 @@ export declare class PollingUserAccountSubscriber implements UserAccountSubscrib
     type: ClearingHouseConfigType;
     constructor(program: Program, authority: PublicKey, accountLoader: BulkAccountLoader);
     subscribe(): Promise<boolean>;
-    addToAccountLoader(): Promise<void>;
+    addToAccountLoader(userPublicKeys?: UserPublicKeys): Promise<void>;
     fetchIfUnloaded(): Promise<void>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;

package/lib/accounts/pollingUserAccountSubscriber.js

@@ -36,34 +36,55 @@ class PollingUserAccountSubscriber {
             return true;
         });
     }
-    addToAccountLoader() {
+    addToAccountLoader(userPublicKeys) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.accountsToPoll.size > 0) {
                 return;
             }
-            const userPublicKey = yield addresses_1.getUserAccountPublicKey(this.program.programId, this.authority);
-            const userAccount = (yield this.program.account.user.fetch(userPublicKey));
-            this.accountsToPoll.set(userPublicKey.toString(), {
-                key: 'user',
-                publicKey: userPublicKey,
-                eventType: 'userAccountData',
-            });
-            this.accountsToPoll.set(userAccount.positions.toString(), {
-                key: 'userPositions',
-                publicKey: userAccount.positions,
-                eventType: 'userPositionsData',
-            });
-            const userOrdersPublicKey = yield addresses_1.getUserOrdersAccountPublicKey(this.program.programId, userPublicKey);
-            const userOrdersExist = (yield this.program.provider.connection.getParsedAccountInfo(userOrdersPublicKey)).value !== null;
-            if (userOrdersExist) {
+            if (!userPublicKeys) {
+                const userPublicKey = yield addresses_1.getUserAccountPublicKey(this.program.programId, this.authority);
+                const userAccount = (yield this.program.account.user.fetch(userPublicKey));
+                this.accountsToPoll.set(userPublicKey.toString(), {
+                    key: 'user',
+                    publicKey: userPublicKey,
+                    eventType: 'userAccountData',
+                });
+                this.accountsToPoll.set(userAccount.positions.toString(), {
+                    key: 'userPositions',
+                    publicKey: userAccount.positions,
+                    eventType: 'userPositionsData',
+                });
+                const userOrdersPublicKey = yield addresses_1.getUserOrdersAccountPublicKey(this.program.programId, userPublicKey);
                 this.accountsToPoll.set(userOrdersPublicKey.toString(), {
                     key: 'userOrders',
                     publicKey: userOrdersPublicKey,
                     eventType: 'userOrdersData',
                 });
             }
+            else {
+                this.accountsToPoll.set(userPublicKeys.user.toString(), {
+                    key: 'user',
+                    publicKey: userPublicKeys.user,
+                    eventType: 'userAccountData',
+                });
+                this.accountsToPoll.set(userPublicKeys.userPositions.toString(), {
+                    key: 'userPositions',
+                    publicKey: userPublicKeys.userPositions,
+                    eventType: 'userPositionsData',
+                });
+                if (userPublicKeys.userOrders) {
+                    this.accountsToPoll.set(userPublicKeys.userOrders.toString(), {
+                        key: 'userOrders',
+                        publicKey: userPublicKeys.userOrders,
+                        eventType: 'userOrdersData',
+                    });
+                }
+            }
             for (const [_, accountToPoll] of this.accountsToPoll) {
                 accountToPoll.callbackId = this.accountLoader.addAccount(accountToPoll.publicKey, (buffer) => {
+                    if (!buffer) {
+                        return;
+                    }
                     const account = this.program.account[accountToPoll.key].coder.accounts.decode(utils_1.capitalize(accountToPoll.key), buffer);
                     this[accountToPoll.key] = account;
                     // @ts-ignore

package/lib/accounts/types.d.ts

@@ -48,6 +48,11 @@ export interface ClearingHouseAccountSubscriber {
     getOrderHistoryAccount(): OrderHistoryAccount;
     type: ClearingHouseConfigType;
 }
+export declare type UserPublicKeys = {
+    user: PublicKey;
+    userPositions: PublicKey;
+    userOrders: PublicKey | undefined;
+};
 export interface UserAccountEvents {
     userAccountData: (payload: UserAccount) => void;
     userPositionsData: (payload: UserPositionsAccount) => void;

package/lib/clearingHouseUser.d.ts

@@ -146,7 +146,22 @@ export declare class ClearingHouseUser {
     liquidationPriceAfterClose(positionMarketIndex: BN, closeQuoteAmount: BN): BN;
     /**
      * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
-     * @param marketIndex
+     *
+     * To Calculate Max Quote Available:
+     *
+     * Case 1: SameSide
+     * 	=> Remaining quote to get to maxLeverage
+     *
+     * Case 2: NOT SameSide && currentLeverage <= maxLeverage
+     * 	=> Current opposite position x2 + remaining to get to maxLeverage
+     *
+     * Case 3: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition > maxLeverage
+     * 	=> strictly reduce current position size
+     *
+     * Case 4: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition < maxLeverage
+     * 	=> current position + remaining to get to maxLeverage
+     *
+     * @param targetMarketIndex
      * @param tradeSide
      * @param userMaxLeverageSetting - leverage : Precision TEN_THOUSAND
      * @returns tradeSizeAllowed : Precision QUOTE_PRECISION

package/lib/clearingHouseUser.js

@@ -513,32 +513,42 @@ class ClearingHouseUser {
     }
     /**
      * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
-     * @param marketIndex
+     *
+     * To Calculate Max Quote Available:
+     *
+     * Case 1: SameSide
+     * 	=> Remaining quote to get to maxLeverage
+     *
+     * Case 2: NOT SameSide && currentLeverage <= maxLeverage
+     * 	=> Current opposite position x2 + remaining to get to maxLeverage
+     *
+     * Case 3: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition > maxLeverage
+     * 	=> strictly reduce current position size
+     *
+     * Case 4: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition < maxLeverage
+     * 	=> current position + remaining to get to maxLeverage
+     *
+     * @param targetMarketIndex
      * @param tradeSide
      * @param userMaxLeverageSetting - leverage : Precision TEN_THOUSAND
      * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
      */
     getMaxTradeSizeUSDC(targetMarketIndex, tradeSide, userMaxLeverageSetting) {
-        // inline function which get's the current position size on the opposite side of the target trade
-        const getOppositePositionValueUSDC = () => {
-            if (!currentPosition)
-                return numericConstants_1.ZERO;
-            const side = tradeSide === _1.PositionDirection.SHORT ? 'short' : 'long';
-            if (side === 'long' && (currentPosition === null || currentPosition === void 0 ? void 0 : currentPosition.baseAssetAmount.isNeg())) {
-                return this.getPositionValue(targetMarketIndex);
-            }
-            else if (side === 'short' &&
-                !(currentPosition === null || currentPosition === void 0 ? void 0 : currentPosition.baseAssetAmount.isNeg())) {
-                return this.getPositionValue(targetMarketIndex);
-            }
-            return numericConstants_1.ZERO;
-        };
         const currentPosition = this.getUserPosition(targetMarketIndex) ||
             this.getEmptyPosition(targetMarketIndex);
+        const targetSide = tradeSide === _1.PositionDirection.SHORT ? 'short' : 'long';
+        const currentPositionSide = (currentPosition === null || currentPosition === void 0 ? void 0 : currentPosition.baseAssetAmount.isNeg())
+            ? 'short'
+            : 'long';
+        const targettingSameSide = !currentPosition
+            ? true
+            : targetSide === currentPositionSide;
+        // add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
+        const oppositeSizeValueUSDC = targettingSameSide
+            ? numericConstants_1.ZERO
+            : this.getPositionValue(targetMarketIndex);
         // get current leverage
         const currentLeverage = this.getLeverage();
-        // remaining leverage
-        // let remainingLeverage = userMaxLeverageSetting;
         const remainingLeverage = _1.BN.max(userMaxLeverageSetting.sub(currentLeverage), numericConstants_1.ZERO);
         // get total collateral
         const totalCollateral = this.getTotalCollateral();
@@ -546,9 +556,43 @@ class ClearingHouseUser {
         let maxPositionSize = remainingLeverage
             .mul(totalCollateral)
             .div(numericConstants_1.TEN_THOUSAND);
-        // add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
-        const oppositeSizeValueUSDC = getOppositePositionValueUSDC();
-        maxPositionSize = maxPositionSize.add(oppositeSizeValueUSDC.mul(new _1.BN(2)));
+        if (userMaxLeverageSetting.sub(currentLeverage).gte(numericConstants_1.ZERO)) {
+            if (oppositeSizeValueUSDC.eq(numericConstants_1.ZERO)) {
+                // case 1 : Regular trade where current total position less than max, and no opposite position to account for
+                // do nothing
+            }
+            else {
+                // case 2 : trade where current total position less than max, but need to account for flipping the current position over to the other side
+                maxPositionSize = maxPositionSize.add(oppositeSizeValueUSDC.mul(new _1.BN(2)));
+            }
+        }
+        else {
+            // current leverage is greater than max leverage - can only reduce position size
+            if (!targettingSameSide) {
+                const currentPositionQuoteSize = this.getPositionValue(targetMarketIndex);
+                const currentTotalQuoteSize = currentLeverage
+                    .mul(totalCollateral)
+                    .div(numericConstants_1.TEN_THOUSAND);
+                const otherPositionsTotalQuoteSize = currentTotalQuoteSize.sub(currentPositionQuoteSize);
+                const quoteValueOfMaxLeverage = userMaxLeverageSetting
+                    .mul(totalCollateral)
+                    .div(numericConstants_1.TEN_THOUSAND);
+                if (otherPositionsTotalQuoteSize
+                    .sub(currentPositionQuoteSize)
+                    .gte(quoteValueOfMaxLeverage)) {
+                    // case 3: Can only reduce the current position because it will still be greater than max leverage
+                    maxPositionSize = currentPositionQuoteSize;
+                }
+                else {
+                    // case 4: Can reduce the position, and then take extra remaining quote to get to max leverage
+                    const allowedQuoteSizeAfterClosingCurrentPosition = quoteValueOfMaxLeverage.sub(otherPositionsTotalQuoteSize);
+                    maxPositionSize = currentPositionQuoteSize.add(allowedQuoteSizeAfterClosingCurrentPosition);
+                }
+            }
+            else {
+                // do nothing if targetting same side
+            }
+        }
         // subtract oneMillionth of maxPositionSize
         // => to avoid rounding errors when taking max leverage
         const oneMilli = maxPositionSize.div(numericConstants_1.QUOTE_PRECISION);
@@ -577,12 +621,18 @@ class ClearingHouseUser {
             .add(tradeQuoteAmount)
             .abs();
         const totalPositionAfterTradeExcludingTargetMarket = this.getTotalPositionValueExcludingMarket(targetMarketIndex);
-        const newLeverage = currentMarketPositionAfterTrade
-            .add(totalPositionAfterTradeExcludingTargetMarket)
-            .abs()
-            .mul(numericConstants_1.TEN_THOUSAND)
-            .div(this.getTotalCollateral());
-        return newLeverage;
+        const totalCollateral = this.getTotalCollateral();
+        if (totalCollateral.gt(numericConstants_1.ZERO)) {
+            const newLeverage = currentMarketPositionAfterTrade
+                .add(totalPositionAfterTradeExcludingTargetMarket)
+                .abs()
+                .mul(numericConstants_1.TEN_THOUSAND)
+                .div(totalCollateral);
+            return newLeverage;
+        }
+        else {
+            return new _1.BN(0);
+        }
     }
     /**
      * Calculates how much fee will be taken for a given sized trade
@@ -605,8 +655,7 @@ class ClearingHouseUser {
             this.getEmptyPosition(marketToIgnore);
         let currentMarketPositionValueUSDC = numericConstants_1.ZERO;
         if (currentMarketPosition) {
-            const market = this.clearingHouse.getMarket(currentMarketPosition.marketIndex);
-            currentMarketPositionValueUSDC = _1.calculateBaseAssetValue(market, currentMarketPosition);
+            currentMarketPositionValueUSDC = this.getPositionValue(marketToIgnore);
         }
         return this.getTotalPositionValue().sub(currentMarketPositionValueUSDC);
     }

package/lib/idl/clearing_house.json

@@ -2435,7 +2435,7 @@
                                 {
                                     "defined": "Order"
                                 },
-                                20
+                                32
                             ]
                         }
                     }

package/lib/math/amm.d.ts

@@ -64,3 +64,5 @@ export declare function calculateRepegCost(market: Market, marketIndex: BN, newP
  */
 export declare function calculateTerminalPrice(market: Market): BN;
 export declare function calculateMaxBaseAssetAmountToTrade(amm: AMM, limit_price: BN): [BN, PositionDirection];
+export declare function calculateBudgetedK(market: Market, cost: BN): [BN, BN];
+export declare function calculateBudgetedPeg(market: Market, cost: BN): BN;

package/lib/math/amm.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.calculateRepegCost = exports.calculateAdjustKCost = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = void 0;
+exports.calculateBudgetedPeg = exports.calculateBudgetedK = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.calculateRepegCost = exports.calculateAdjustKCost = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 const position_1 = require("./position");
@@ -116,6 +116,26 @@ function calculateAdjustKCost(market, marketIndex, numerator, denomenator) {
     marketNewK.amm.sqrtK = market.amm.sqrtK.mul(numerator).div(denomenator);
     netUserPosition.quoteAssetAmount = currentValue;
     const cost = __1.calculatePositionPNL(marketNewK, netUserPosition);
+    const p = numericConstants_1.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 = numericConstants_1.PEG_PRECISION.sub(p).mul(y).div(numericConstants_1.PEG_PRECISION);
+    const numer20 = k
+        .mul(p)
+        .mul(p)
+        .div(numericConstants_1.PEG_PRECISION)
+        .div(numericConstants_1.PEG_PRECISION)
+        .div(x.mul(p).div(numericConstants_1.PEG_PRECISION).add(delta));
+    const numer21 = k.div(x.add(delta));
+    const formulaCost = numer21
+        .sub(numer20)
+        .sub(numer1)
+        .mul(market.amm.pegMultiplier)
+        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    console.log(__1.convertToNumber(formulaCost, numericConstants_1.QUOTE_PRECISION));
+    // p.div(p.mul(x).add(delta)).sub()
     return cost;
 }
 exports.calculateAdjustKCost = calculateAdjustKCost;
@@ -144,6 +164,13 @@ function calculateRepegCost(market, marketIndex, newPeg) {
     marketNewPeg.amm.pegMultiplier = newPeg;
     console.log('Price moves from', __1.convertToNumber(prevMarketPrice), 'to', __1.convertToNumber(__1.calculateMarkPrice(marketNewPeg)));
     const cost = __1.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(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    console.log(__1.convertToNumber(cost2, numericConstants_1.QUOTE_PRECISION));
     return cost;
 }
 exports.calculateRepegCost = calculateRepegCost;
@@ -192,3 +219,66 @@ function calculateMaxBaseAssetAmountToTrade(amm, limit_price) {
     }
 }
 exports.calculateMaxBaseAssetAmountToTrade = calculateMaxBaseAssetAmountToTrade;
+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(numericConstants_1.PEG_PRECISION)
+        .div(numericConstants_1.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;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.21-master.3",
+	"version": "0.1.23-master.0",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/bulkUserSubscription.ts

@@ -1,6 +1,9 @@
 import { ClearingHouseUser } from '../clearingHouseUser';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { PollingUserAccountSubscriber } from './pollingUserAccountSubscriber';
+import { UserAccount, UserOrdersAccount } from '../types';
+import { UserPublicKeys } from './types';
+import { ProgramAccount } from '@project-serum/anchor';
 
 /**
  * @param users
@@ -10,11 +13,58 @@ export async function bulkPollingUserSubscribe(
 	users: ClearingHouseUser[],
 	accountLoader: BulkAccountLoader
 ): Promise<void> {
+	if (users.length === 0) {
+		await accountLoader.load();
+		return;
+	}
+
+	// Fetch all the accounts first
+	const program = users[0].clearingHouse.program;
+	let userProgramAccounts: ProgramAccount[];
+	let orderProgramAccounts: ProgramAccount[];
+	await Promise.all([
+		(async () => {
+			userProgramAccounts = await program.account.user.all();
+		})(),
+		(async () => {
+			orderProgramAccounts = await program.account.userOrders.all();
+		})(),
+	]);
+
+	// Create a map of the authority to keys
+	const authorityToKeys = new Map<string, UserPublicKeys>();
+	const userToAuthority = new Map<string, string>();
+	for (const userProgramAccount of userProgramAccounts) {
+		const userAccountPublicKey = userProgramAccount.publicKey;
+		const userAccount = userProgramAccount.account as UserAccount;
+
+		authorityToKeys.set(userAccount.authority.toString(), {
+			user: userAccountPublicKey,
+			userPositions: userAccount.positions,
+			userOrders: undefined,
+		});
+
+		userToAuthority.set(
+			userAccountPublicKey.toString(),
+			userAccount.authority.toString()
+		);
+	}
+	for (const orderProgramAccount of orderProgramAccounts) {
+		const userOrderAccountPublicKey = orderProgramAccount.publicKey;
+		const userOrderAccount = orderProgramAccount.account as UserOrdersAccount;
+
+		const authority = userToAuthority.get(userOrderAccount.user.toString());
+		const userPublicKeys = authorityToKeys.get(authority);
+		userPublicKeys.userOrders = userOrderAccountPublicKey;
+	}
+
 	await Promise.all(
 		users.map((user) => {
+			// Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
+			const userPublicKeys = authorityToKeys.get(user.authority.toString());
 			return (
 				user.accountSubscriber as PollingUserAccountSubscriber
-			).addToAccountLoader();
+			).addToAccountLoader(userPublicKeys);
 		})
 	);
 

package/src/accounts/pollingUserAccountSubscriber.ts

@@ -3,6 +3,7 @@ import {
 	NotSubscribedError,
 	UserAccountEvents,
 	UserAccountSubscriber,
+	UserPublicKeys,
 } from './types';
 import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
@@ -58,55 +59,73 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 		return true;
 	}
 
-	async addToAccountLoader(): Promise<void> {
+	async addToAccountLoader(userPublicKeys?: UserPublicKeys): Promise<void> {
 		if (this.accountsToPoll.size > 0) {
 			return;
 		}
 
-		const userPublicKey = await getUserAccountPublicKey(
-			this.program.programId,
-			this.authority
-		);
+		if (!userPublicKeys) {
+			const userPublicKey = await getUserAccountPublicKey(
+				this.program.programId,
+				this.authority
+			);
 
-		const userAccount = (await this.program.account.user.fetch(
-			userPublicKey
-		)) as UserAccount;
+			const userAccount = (await this.program.account.user.fetch(
+				userPublicKey
+			)) as UserAccount;
 
-		this.accountsToPoll.set(userPublicKey.toString(), {
-			key: 'user',
-			publicKey: userPublicKey,
-			eventType: 'userAccountData',
-		});
+			this.accountsToPoll.set(userPublicKey.toString(), {
+				key: 'user',
+				publicKey: userPublicKey,
+				eventType: 'userAccountData',
+			});
 
-		this.accountsToPoll.set(userAccount.positions.toString(), {
-			key: 'userPositions',
-			publicKey: userAccount.positions,
-			eventType: 'userPositionsData',
-		});
+			this.accountsToPoll.set(userAccount.positions.toString(), {
+				key: 'userPositions',
+				publicKey: userAccount.positions,
+				eventType: 'userPositionsData',
+			});
+
+			const userOrdersPublicKey = await getUserOrdersAccountPublicKey(
+				this.program.programId,
+				userPublicKey
+			);
 
-		const userOrdersPublicKey = await getUserOrdersAccountPublicKey(
-			this.program.programId,
-			userPublicKey
-		);
-
-		const userOrdersExist =
-			(
-				await this.program.provider.connection.getParsedAccountInfo(
-					userOrdersPublicKey
-				)
-			).value !== null;
-		if (userOrdersExist) {
 			this.accountsToPoll.set(userOrdersPublicKey.toString(), {
 				key: 'userOrders',
 				publicKey: userOrdersPublicKey,
 				eventType: 'userOrdersData',
 			});
+		} else {
+			this.accountsToPoll.set(userPublicKeys.user.toString(), {
+				key: 'user',
+				publicKey: userPublicKeys.user,
+				eventType: 'userAccountData',
+			});
+
+			this.accountsToPoll.set(userPublicKeys.userPositions.toString(), {
+				key: 'userPositions',
+				publicKey: userPublicKeys.userPositions,
+				eventType: 'userPositionsData',
+			});
+
+			if (userPublicKeys.userOrders) {
+				this.accountsToPoll.set(userPublicKeys.userOrders.toString(), {
+					key: 'userOrders',
+					publicKey: userPublicKeys.userOrders,
+					eventType: 'userOrdersData',
+				});
+			}
 		}
 
 		for (const [_, accountToPoll] of this.accountsToPoll) {
 			accountToPoll.callbackId = this.accountLoader.addAccount(
 				accountToPoll.publicKey,
 				(buffer) => {
+					if (!buffer) {
+						return;
+					}
+
 					const account = this.program.account[
 						accountToPoll.key
 					].coder.accounts.decode(capitalize(accountToPoll.key), buffer);

package/src/accounts/types.ts

@@ -82,6 +82,12 @@ export interface ClearingHouseAccountSubscriber {
 	type: ClearingHouseConfigType;
 }
 
+export type UserPublicKeys = {
+	user: PublicKey;
+	userPositions: PublicKey;
+	userOrders: PublicKey | undefined;
+};
+
 export interface UserAccountEvents {
 	userAccountData: (payload: UserAccount) => void;
 	userPositionsData: (payload: UserPositionsAccount) => void;

package/src/clearingHouseUser.ts

@@ -733,7 +733,22 @@ export class ClearingHouseUser {
 
 	/**
 	 * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
-	 * @param marketIndex
+	 *
+	 * To Calculate Max Quote Available:
+	 *
+	 * Case 1: SameSide
+	 * 	=> Remaining quote to get to maxLeverage
+	 *
+	 * Case 2: NOT SameSide && currentLeverage <= maxLeverage
+	 * 	=> Current opposite position x2 + remaining to get to maxLeverage
+	 *
+	 * Case 3: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition > maxLeverage
+	 * 	=> strictly reduce current position size
+	 *
+	 * Case 4: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition < maxLeverage
+	 * 	=> current position + remaining to get to maxLeverage
+	 *
+	 * @param targetMarketIndex
 	 * @param tradeSide
 	 * @param userMaxLeverageSetting - leverage : Precision TEN_THOUSAND
 	 * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
@@ -743,34 +758,28 @@ export class ClearingHouseUser {
 		tradeSide: PositionDirection,
 		userMaxLeverageSetting: BN
 	): BN {
-		// inline function which get's the current position size on the opposite side of the target trade
-		const getOppositePositionValueUSDC = () => {
-			if (!currentPosition) return ZERO;
+		const currentPosition =
+			this.getUserPosition(targetMarketIndex) ||
+			this.getEmptyPosition(targetMarketIndex);
 
-			const side = tradeSide === PositionDirection.SHORT ? 'short' : 'long';
+		const targetSide = tradeSide === PositionDirection.SHORT ? 'short' : 'long';
 
-			if (side === 'long' && currentPosition?.baseAssetAmount.isNeg()) {
-				return this.getPositionValue(targetMarketIndex);
-			} else if (
-				side === 'short' &&
-				!currentPosition?.baseAssetAmount.isNeg()
-			) {
-				return this.getPositionValue(targetMarketIndex);
-			}
+		const currentPositionSide = currentPosition?.baseAssetAmount.isNeg()
+			? 'short'
+			: 'long';
 
-			return ZERO;
-		};
+		const targettingSameSide = !currentPosition
+			? true
+			: targetSide === currentPositionSide;
 
-		const currentPosition =
-			this.getUserPosition(targetMarketIndex) ||
-			this.getEmptyPosition(targetMarketIndex);
+		// add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
+		const oppositeSizeValueUSDC = targettingSameSide
+			? ZERO
+			: this.getPositionValue(targetMarketIndex);
 
 		// get current leverage
 		const currentLeverage = this.getLeverage();
 
-		// remaining leverage
-		// let remainingLeverage = userMaxLeverageSetting;
-
 		const remainingLeverage = BN.max(
 			userMaxLeverageSetting.sub(currentLeverage),
 			ZERO
@@ -784,10 +793,57 @@ export class ClearingHouseUser {
 			.mul(totalCollateral)
 			.div(TEN_THOUSAND);
 
-		// add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
-		const oppositeSizeValueUSDC = getOppositePositionValueUSDC();
+		if (userMaxLeverageSetting.sub(currentLeverage).gte(ZERO)) {
+			if (oppositeSizeValueUSDC.eq(ZERO)) {
+				// case 1 : Regular trade where current total position less than max, and no opposite position to account for
+				// do nothing
+			} else {
+				// case 2 : trade where current total position less than max, but need to account for flipping the current position over to the other side
+				maxPositionSize = maxPositionSize.add(
+					oppositeSizeValueUSDC.mul(new BN(2))
+				);
+			}
+		} else {
+			// current leverage is greater than max leverage - can only reduce position size
 
-		maxPositionSize = maxPositionSize.add(oppositeSizeValueUSDC.mul(new BN(2)));
+			if (!targettingSameSide) {
+				const currentPositionQuoteSize =
+					this.getPositionValue(targetMarketIndex);
+
+				const currentTotalQuoteSize = currentLeverage
+					.mul(totalCollateral)
+					.div(TEN_THOUSAND);
+
+				const otherPositionsTotalQuoteSize = currentTotalQuoteSize.sub(
+					currentPositionQuoteSize
+				);
+
+				const quoteValueOfMaxLeverage = userMaxLeverageSetting
+					.mul(totalCollateral)
+					.div(TEN_THOUSAND);
+
+				if (
+					otherPositionsTotalQuoteSize
+						.sub(currentPositionQuoteSize)
+						.gte(quoteValueOfMaxLeverage)
+				) {
+					// case 3: Can only reduce the current position because it will still be greater than max leverage
+
+					maxPositionSize = currentPositionQuoteSize;
+				} else {
+					// case 4: Can reduce the position, and then take extra remaining quote to get to max leverage
+
+					const allowedQuoteSizeAfterClosingCurrentPosition =
+						quoteValueOfMaxLeverage.sub(otherPositionsTotalQuoteSize);
+
+					maxPositionSize = currentPositionQuoteSize.add(
+						allowedQuoteSizeAfterClosingCurrentPosition
+					);
+				}
+			} else {
+				// do nothing if targetting same side
+			}
+		}
 
 		// subtract oneMillionth of maxPositionSize
 		// => to avoid rounding errors when taking max leverage
@@ -832,13 +888,18 @@ export class ClearingHouseUser {
 
 		const totalPositionAfterTradeExcludingTargetMarket =
 			this.getTotalPositionValueExcludingMarket(targetMarketIndex);
-		const newLeverage = currentMarketPositionAfterTrade
-			.add(totalPositionAfterTradeExcludingTargetMarket)
-			.abs()
-			.mul(TEN_THOUSAND)
-			.div(this.getTotalCollateral());
 
-		return newLeverage;
+		const totalCollateral = this.getTotalCollateral();
+		if (totalCollateral.gt(ZERO)) {
+			const newLeverage = currentMarketPositionAfterTrade
+				.add(totalPositionAfterTradeExcludingTargetMarket)
+				.abs()
+				.mul(TEN_THOUSAND)
+				.div(totalCollateral);
+			return newLeverage;
+		} else {
+			return new BN(0);
+		}
 	}
 
 	/**
@@ -866,13 +927,7 @@ export class ClearingHouseUser {
 
 		let currentMarketPositionValueUSDC = ZERO;
 		if (currentMarketPosition) {
-			const market = this.clearingHouse.getMarket(
-				currentMarketPosition.marketIndex
-			);
-			currentMarketPositionValueUSDC = calculateBaseAssetValue(
-				market,
-				currentMarketPosition
-			);
+			currentMarketPositionValueUSDC = this.getPositionValue(marketToIgnore);
 		}
 
 		return this.getTotalPositionValue().sub(currentMarketPositionValueUSDC);

package/src/idl/clearing_house.json

@@ -2435,7 +2435,7 @@
                 {
                   "defined": "Order"
                 },
-                20
+                32
               ]
             }
           }

package/src/math/amm.ts

@@ -4,6 +4,9 @@ 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 {
@@ -175,6 +178,30 @@ export function calculateAdjustKCost(
 
 	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;
 }
 
@@ -217,6 +244,17 @@ export function calculateRepegCost(
 
 	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;
 }
 
@@ -238,6 +276,7 @@ export function calculateTerminalPrice(market: Market) {
 			market.baseAssetAmount.abs(),
 			getSwapDirection('base', directionToClose)
 		);
+
 	const terminalPrice = newQuoteAssetReserve
 		.mul(MARK_PRICE_PRECISION)
 		.mul(market.amm.pegMultiplier)
@@ -276,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;
+}