@drift-labs/sdk 2.10.0-beta.0 → 2.10.0-beta.2

package/lib/math/amm.js

@@ -23,6 +23,7 @@ function calculateOptimalPegAndBudget(amm, oraclePriceData) {
     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));
+    let checkLowerBound = true;
     if (budget.lt(prePegCost)) {
         const halfMaxPriceSpread = new anchor_1.BN(amm.maxSpread)
             .div(new anchor_1.BN(2))
@@ -42,19 +43,23 @@ function calculateOptimalPegAndBudget(amm, oraclePriceData) {
             }
             newOptimalPeg = calculatePegFromTargetPrice(newTargetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
             newBudget = (0, repeg_1.calculateRepegCost)(amm, newOptimalPeg);
+            checkLowerBound = false;
             return [newTargetPrice, newOptimalPeg, newBudget, false];
         }
+        else if (amm.totalFeeMinusDistributions.lt(amm.totalExchangeFee.div(new anchor_1.BN(2)))) {
+            checkLowerBound = false;
+        }
     }
-    return [targetPrice, newPeg, budget, true];
+    return [targetPrice, newPeg, budget, checkLowerBound];
 }
 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);
+    const [targetPrice, _newPeg, budget, _checkLowerBound] = calculateOptimalPegAndBudget(amm, oraclePriceData);
     let prePegCost = (0, repeg_1.calculateRepegCost)(amm, _newPeg);
     let newPeg = _newPeg;
-    if (prePegCost.gt(budget) && checkLowerBound) {
+    if (prePegCost.gte(budget) && prePegCost.gt(numericConstants_1.ZERO)) {
         [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)));
@@ -76,7 +81,7 @@ function calculateNewAmm(amm, oraclePriceData) {
 }
 exports.calculateNewAmm = calculateNewAmm;
 function calculateUpdatedAMM(amm, oraclePriceData) {
-    if (amm.curveUpdateIntensity == 0) {
+    if (amm.curveUpdateIntensity == 0 || oraclePriceData === undefined) {
         return amm;
     }
     const newAmm = Object.assign({}, amm);
@@ -325,8 +330,12 @@ function calculateSpreadBN(baseSpread, lastOracleReservePriceSpreadPct, lastOrac
     spreadTerms.longSpreadwEL = longSpread;
     spreadTerms.shortSpreadwEL = shortSpread;
     if (netRevenueSinceLastFunding.lt(numericConstants_1.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT)) {
-        const revenueRetreatAmount = Math.min(maxTargetSpread / 10, Math.floor((baseSpread * netRevenueSinceLastFunding.abs().toNumber()) /
-            numericConstants_1.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.abs().toNumber()));
+        const maxRetreat = maxTargetSpread / 10;
+        let revenueRetreatAmount = maxRetreat;
+        if (netRevenueSinceLastFunding.gte(numericConstants_1.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.mul(new anchor_1.BN(1000)))) {
+            revenueRetreatAmount = Math.min(maxRetreat, Math.floor((baseSpread * netRevenueSinceLastFunding.abs().toNumber()) /
+                numericConstants_1.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.abs().toNumber()));
+        }
         const halfRevenueRetreatAmount = Math.floor(revenueRetreatAmount / 2);
         spreadTerms.revenueRetreatAmount = revenueRetreatAmount;
         spreadTerms.halfRevenueRetreatAmount = halfRevenueRetreatAmount;

package/lib/math/oracles.js

@@ -53,7 +53,7 @@ function isOracleTooDivergent(amm, oraclePriceData, oracleGuardRails, now) {
 }
 exports.isOracleTooDivergent = isOracleTooDivergent;
 function calculateLiveOracleTwap(amm, oraclePriceData, now) {
-    const sinceLastUpdate = now.sub(amm.historicalOracleData.lastOraclePriceTwapTs);
+    const sinceLastUpdate = index_1.BN.max(numericConstants_1.ONE, now.sub(amm.historicalOracleData.lastOraclePriceTwapTs));
     const sinceStart = index_1.BN.max(numericConstants_1.ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
     const clampRange = amm.historicalOracleData.lastOraclePriceTwap.div(new index_1.BN(3));
     const clampedOraclePrice = index_1.BN.min(amm.historicalOracleData.lastOraclePriceTwap.add(clampRange), index_1.BN.max(oraclePriceData.price, amm.historicalOracleData.lastOraclePriceTwap.sub(clampRange)));
@@ -65,7 +65,7 @@ function calculateLiveOracleTwap(amm, oraclePriceData, now) {
 }
 exports.calculateLiveOracleTwap = calculateLiveOracleTwap;
 function calculateLiveOracleStd(amm, oraclePriceData, now) {
-    const sinceLastUpdate = now.sub(amm.historicalOracleData.lastOraclePriceTwapTs);
+    const sinceLastUpdate = index_1.BN.max(numericConstants_1.ONE, now.sub(amm.historicalOracleData.lastOraclePriceTwapTs));
     const sinceStart = index_1.BN.max(numericConstants_1.ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
     const liveOracleTwap = calculateLiveOracleTwap(amm, oraclePriceData, now);
     const priceDeltaVsTwap = oraclePriceData.price.sub(liveOracleTwap).abs();

package/lib/math/repeg.d.ts

@@ -19,4 +19,4 @@ export declare function calculateAdjustKCost(amm: AMM, numerator: BN, denomenato
 export declare function calculateRepegCost(amm: AMM, newPeg: BN): BN;
 export declare function calculateBudgetedKBN(x: BN, y: BN, budget: BN, Q: BN, d: BN): [BN, BN];
 export declare function calculateBudgetedK(amm: AMM, cost: BN): [BN, BN];
-export declare function calculateBudgetedPeg(amm: AMM, cost: BN, targetPrice: BN): BN;
+export declare function calculateBudgetedPeg(amm: AMM, budget: BN, targetPrice: BN): BN;

package/lib/math/repeg.js

@@ -20,16 +20,46 @@ function calculateAdjustKCost(amm, numerator, denomenator) {
     const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
     const p = numerator.mul(numericConstants_1.PRICE_PRECISION).div(denomenator);
     const cost = quoteScale
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
         .div(x.add(d))
         .sub(quoteScale
         .mul(p)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
         .div(numericConstants_1.PRICE_PRECISION)
         .div(x.mul(p).div(numericConstants_1.PRICE_PRECISION).add(d)))
+        .div(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(numericConstants_1.PERCENTAGE_PRECISION)
         .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(numericConstants_1.PEG_PRECISION);
     return cost.mul(new anchor_1.BN(-1));
 }
 exports.calculateAdjustKCost = calculateAdjustKCost;
+// /**
+//  * Helper function calculating adjust k cost
+//  * @param amm
+//  * @param numerator
+//  * @param denomenator
+//  * @returns cost : Precision QUOTE_ASSET_PRECISION
+//  */
+// export function calculateAdjustKCost2(
+// 	amm: AMM,
+// 	numerator: BN,
+// 	denomenator: BN
+// ): BN {
+// 	// const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+// 	const directionToClose = amm.baseAssetAmountWithAmm.gt(ZERO)
+// 		? PositionDirection.SHORT
+// 		: PositionDirection.LONG;
+// 	const [newQuoteAssetReserve, _newBaseAssetReserve] =
+// 		calculateAmmReservesAfterSwap(
+// 			amm,
+// 			'base',
+// 			amm.baseAssetAmountWithAmm.abs(),
+// 			getSwapDirection('base', directionToClose)
+// 		);
+// }
 /**
  * Helper function calculating adjust pegMultiplier (repeg) cost
  *
@@ -107,31 +137,28 @@ function calculateBudgetedK(amm, cost) {
     return [numerator, denominator];
 }
 exports.calculateBudgetedK = calculateBudgetedK;
-function calculateBudgetedPeg(amm, cost, targetPrice) {
-    // 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
+function calculateBudgetedPeg(amm, budget, targetPrice) {
+    let perPegCost = amm.quoteAssetReserve
+        .sub(amm.terminalQuoteAssetReserve)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION.div(numericConstants_1.PRICE_PRECISION));
+    if (perPegCost.gt(numericConstants_1.ZERO)) {
+        perPegCost = perPegCost.add(numericConstants_1.ONE);
+    }
+    else if (perPegCost.lt(numericConstants_1.ZERO)) {
+        perPegCost = perPegCost.sub(numericConstants_1.ONE);
+    }
     const targetPeg = targetPrice
         .mul(amm.baseAssetReserve)
         .div(amm.quoteAssetReserve)
         .div(numericConstants_1.PRICE_DIV_PEG);
-    const k = amm.sqrtK.mul(amm.sqrtK);
-    const x = amm.baseAssetReserve;
-    const y = amm.quoteAssetReserve;
-    const d = amm.baseAssetAmountWithAmm;
-    const Q = amm.pegMultiplier;
-    const C = cost.mul(new anchor_1.BN(-1));
-    const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
-    const pegChangeDirection = targetPeg.sub(Q);
-    const useTargetPeg = (deltaQuoteAssetReserves.lt(numericConstants_1.ZERO) && pegChangeDirection.gt(numericConstants_1.ZERO)) ||
-        (deltaQuoteAssetReserves.gt(numericConstants_1.ZERO) && pegChangeDirection.lt(numericConstants_1.ZERO));
-    if (deltaQuoteAssetReserves.eq(numericConstants_1.ZERO) || useTargetPeg) {
+    const pegChangeDirection = targetPeg.sub(amm.pegMultiplier);
+    const useTargetPeg = (perPegCost.lt(numericConstants_1.ZERO) && pegChangeDirection.gt(numericConstants_1.ZERO)) ||
+        (perPegCost.gt(numericConstants_1.ZERO) && pegChangeDirection.lt(numericConstants_1.ZERO));
+    if (perPegCost.eq(numericConstants_1.ZERO) || useTargetPeg) {
         return targetPeg;
     }
-    const deltaPegMultiplier = C.mul(numericConstants_1.PRICE_PRECISION).div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO));
-    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.PRICE_PRECISION));
+    const budgetDeltaPeg = budget.mul(numericConstants_1.PEG_PRECISION).div(perPegCost);
+    const newPeg = anchor_1.BN.max(numericConstants_1.ONE, amm.pegMultiplier.add(budgetDeltaPeg));
     return newPeg;
 }
 exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/lib/math/spotBalance.js

@@ -60,7 +60,7 @@ function calculateAssetWeight(balanceAmount, spotMarket, marginCategory) {
             assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialAssetWeight));
             break;
         case 'Maintenance':
-            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceAssetWeight));
+            assetWeight = new anchor_1.BN(spotMarket.maintenanceAssetWeight);
             break;
         default:
             assetWeight = new anchor_1.BN(spotMarket.initialAssetWeight);

package/lib/testClient.d.ts

@@ -0,0 +1,8 @@
+import { AdminClient } from './adminClient';
+import { ConfirmOptions, Signer, Transaction } from '@solana/web3.js';
+import { TxSigAndSlot } from './tx/types';
+import { DriftClientConfig } from './driftClientConfig';
+export declare class TestClient extends AdminClient {
+    constructor(config: DriftClientConfig);
+    sendTransaction(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
+}

package/lib/testClient.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestClient = void 0;
+const adminClient_1 = require("./adminClient");
+class TestClient extends adminClient_1.AdminClient {
+    constructor(config) {
+        if (config.accountSubscription.type !== 'polling') {
+            throw new Error('Test client must be polling');
+        }
+        super(config);
+    }
+    async sendTransaction(tx, additionalSigners, opts, preSigned) {
+        const { txSig, slot } = await super.sendTransaction(tx, additionalSigners, opts, preSigned);
+        let lastFetchedSlot = this.accountSubscriber.accountLoader.mostRecentSlot;
+        while (lastFetchedSlot < slot) {
+            await this.fetchAccounts();
+            lastFetchedSlot = this.accountSubscriber.accountLoader.mostRecentSlot;
+        }
+        return { txSig, slot };
+    }
+}
+exports.TestClient = TestClient;

package/lib/user.d.ts

@@ -29,6 +29,7 @@ export declare class User {
     fetchAccounts(): Promise<void>;
     unsubscribe(): Promise<void>;
     getUserAccount(): UserAccount;
+    forceGetUserAccount(): Promise<UserAccount>;
     getUserAccountAndSlot(): DataAndSlot<UserAccount> | undefined;
     /**
      * Gets the user's current position for a given perp market. If the user has no position returns undefined

package/lib/user.js

@@ -52,6 +52,10 @@ class User {
     getUserAccount() {
         return this.accountSubscriber.getUserAccountAndSlot().data;
     }
+    async forceGetUserAccount() {
+        await this.fetchAccounts();
+        return this.accountSubscriber.getUserAccountAndSlot().data;
+    }
     getUserAccountAndSlot() {
         return this.accountSubscriber.getUserAccountAndSlot();
     }

package/package.json

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

package/src/accounts/pollingDriftClientAccountSubscriber.ts

@@ -340,21 +340,44 @@ export class PollingDriftClientAccountSubscriber
 	}
 
 	async addSpotMarket(marketIndex: number): Promise<boolean> {
+		const marketPublicKey = await getSpotMarketPublicKey(
+			this.program.programId,
+			marketIndex
+		);
+
+		if (this.accountsToPoll.has(marketPublicKey.toString())) {
+			return true;
+		}
+
 		await this.addSpotMarketAccountToPoll(marketIndex);
-		const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
+
+		const accountToPoll = this.accountsToPoll.get(marketPublicKey.toString());
+
 		await this.addAccountToAccountLoader(accountToPoll);
 		return true;
 	}
 
 	async addPerpMarket(marketIndex: number): Promise<boolean> {
+		const marketPublicKey = await getPerpMarketPublicKey(
+			this.program.programId,
+			marketIndex
+		);
+
+		if (this.accountsToPoll.has(marketPublicKey.toString())) {
+			return true;
+		}
+
 		await this.addPerpMarketAccountToPoll(marketIndex);
-		const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
+		const accountToPoll = this.accountsToPoll.get(marketPublicKey.toString());
 		await this.addAccountToAccountLoader(accountToPoll);
 		return true;
 	}
 
 	async addOracle(oracleInfo: OracleInfo): Promise<boolean> {
-		if (oracleInfo.publicKey.equals(PublicKey.default)) {
+		if (
+			oracleInfo.publicKey.equals(PublicKey.default) ||
+			this.oraclesToPoll.has(oracleInfo.publicKey.toString())
+		) {
 			return true;
 		}