@drift-labs/sdk 2.86.0-beta.2 → 2.86.0-beta.21

package/lib/user.js

@@ -14,6 +14,7 @@ const spotPosition_1 = require("./math/spotPosition");
 const oracles_1 = require("./math/oracles");
 const tiers_1 = require("./math/tiers");
 const strictOraclePrice_1 = require("./oracles/strictOraclePrice");
+const fuel_1 = require("./math/fuel");
 class User {
     get isSubscribed() {
         return this._isSubscribed && this.accountSubscriber.isSubscribed;
@@ -539,6 +540,64 @@ class User {
             return pnl.add((0, _1.calculatePositionFundingPNL)(market, perpPosition));
         }, numericConstants_1.ZERO);
     }
+    getFuelBonus(now, includeSettled = true, includeUnsettled = true) {
+        const userAccount = this.getUserAccount();
+        const result = {
+            insuranceFuel: numericConstants_1.ZERO,
+            takerFuel: numericConstants_1.ZERO,
+            makerFuel: numericConstants_1.ZERO,
+            depositFuel: numericConstants_1.ZERO,
+            borrowFuel: numericConstants_1.ZERO,
+            positionFuel: numericConstants_1.ZERO,
+        };
+        if (includeSettled) {
+            const userStats = this.driftClient
+                .getUserStats()
+                .getAccount();
+            result.insuranceFuel = result.insuranceFuel.add(new _1.BN(userStats.fuelInsurance));
+            result.takerFuel = result.takerFuel.add(new _1.BN(userStats.fuelTaker));
+            result.makerFuel = result.makerFuel.add(new _1.BN(userStats.fuelMaker));
+            result.depositFuel = result.depositFuel.add(new _1.BN(userStats.fuelDeposits));
+            result.borrowFuel = result.borrowFuel.add(new _1.BN(userStats.fuelBorrows));
+            result.positionFuel = result.positionFuel.add(new _1.BN(userStats.fuelPositions));
+        }
+        if (includeUnsettled) {
+            const fuelBonusNumerator = _1.BN.max(now.sub(_1.BN.max(new _1.BN(userAccount.lastFuelBonusUpdateTs), numericConstants_1.FUEL_START_TS)), numericConstants_1.ZERO);
+            if (fuelBonusNumerator.gt(numericConstants_1.ZERO)) {
+                for (const spotPosition of this.getActiveSpotPositions()) {
+                    const spotMarketAccount = this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
+                    const tokenAmount = this.getTokenAmount(spotPosition.marketIndex);
+                    const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
+                    const twap5min = (0, oracles_1.calculateLiveOracleTwap)(spotMarketAccount.historicalOracleData, oraclePriceData, now, numericConstants_1.FIVE_MINUTE // 5MIN
+                    );
+                    const strictOraclePrice = new strictOraclePrice_1.StrictOraclePrice(oraclePriceData.price, twap5min);
+                    const signedTokenValue = (0, _1.getStrictTokenValue)(tokenAmount, spotMarketAccount.decimals, strictOraclePrice);
+                    if (signedTokenValue.gt(numericConstants_1.ZERO)) {
+                        result.depositFuel = result.depositFuel.add((0, fuel_1.calculateSpotFuelBonus)(spotMarketAccount, signedTokenValue, fuelBonusNumerator));
+                    }
+                    else {
+                        result.borrowFuel = result.borrowFuel.add((0, fuel_1.calculateSpotFuelBonus)(spotMarketAccount, signedTokenValue, fuelBonusNumerator));
+                    }
+                }
+                for (const perpPosition of this.getActivePerpPositions()) {
+                    const oraclePriceData = this.getOracleDataForPerpMarket(perpPosition.marketIndex);
+                    const perpMarketAccount = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
+                    const baseAssetValue = this.getPerpPositionValue(perpPosition.marketIndex, oraclePriceData, false);
+                    result.positionFuel = result.positionFuel.add((0, fuel_1.calculatePerpFuelBonus)(perpMarketAccount, baseAssetValue, fuelBonusNumerator));
+                }
+            }
+            const userStats = this.driftClient
+                .getUserStats()
+                .getAccount();
+            // todo: get real time ifStakedGovTokenAmount using ifStakeAccount
+            if (userStats.ifStakedGovTokenAmount.gt(numericConstants_1.ZERO)) {
+                const spotMarketAccount = this.driftClient.getSpotMarketAccount(numericConstants_1.GOV_SPOT_MARKET_INDEX);
+                const fuelBonusNumeratorUserStats = now.sub(new _1.BN(userStats.lastFuelBonusUpdateTs));
+                result.insuranceFuel = result.insuranceFuel.add((0, fuel_1.calculateInsuranceFuelBonus)(spotMarketAccount, userStats.ifStakedGovTokenAmount, fuelBonusNumeratorUserStats));
+            }
+        }
+        return result;
+    }
     getSpotMarketAssetAndLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict = false, now) {
         now = now || new _1.BN(new Date().getTime() / 1000);
         let netQuoteValue = numericConstants_1.ZERO;

package/package.json

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

package/src/accounts/pollingDriftClientAccountSubscriber.ts

@@ -101,7 +101,7 @@ export class PollingDriftClientAccountSubscriber
 		}
 
 		await this.updateAccountsToPoll();
-		await this.updateOraclesToPoll();
+		this.updateOraclesToPoll();
 		await this.addToAccountLoader();
 
 		let subscriptionSucceeded = false;
@@ -116,8 +116,7 @@ export class PollingDriftClientAccountSubscriber
 			this.eventEmitter.emit('update');
 		}
 
-		await this.setPerpOracleMap();
-		await this.setSpotOracleMap();
+		await Promise.all([this.setPerpOracleMap(), this.setSpotOracleMap()]);
 
 		this.isSubscribing = false;
 		this.isSubscribed = subscriptionSucceeded;
@@ -141,14 +140,18 @@ export class PollingDriftClientAccountSubscriber
 			eventType: 'stateAccountUpdate',
 		});
 
-		await this.updatePerpMarketAccountsToPoll();
-		await this.updateSpotMarketAccountsToPoll();
+		await Promise.all([
+			this.updatePerpMarketAccountsToPoll(),
+			this.updateSpotMarketAccountsToPoll(),
+		]);
 	}
 
 	async updatePerpMarketAccountsToPoll(): Promise<boolean> {
-		for (const marketIndex of this.perpMarketIndexes) {
-			await this.addPerpMarketAccountToPoll(marketIndex);
-		}
+		await Promise.all(
+			this.perpMarketIndexes.map((marketIndex) => {
+				return this.addPerpMarketAccountToPoll(marketIndex);
+			})
+		);
 		return true;
 	}
 
@@ -169,9 +172,11 @@ export class PollingDriftClientAccountSubscriber
 	}
 
 	async updateSpotMarketAccountsToPoll(): Promise<boolean> {
-		for (const marketIndex of this.spotMarketIndexes) {
-			await this.addSpotMarketAccountToPoll(marketIndex);
-		}
+		await Promise.all(
+			this.spotMarketIndexes.map(async (marketIndex) => {
+				await this.addSpotMarketAccountToPoll(marketIndex);
+			})
+		);
 
 		return true;
 	}
@@ -209,16 +214,19 @@ export class PollingDriftClientAccountSubscriber
 
 		return true;
 	}
-
 	async addToAccountLoader(): Promise<void> {
+		const accountPromises = [];
 		for (const [_, accountToPoll] of this.accountsToPoll) {
-			await this.addAccountToAccountLoader(accountToPoll);
+			accountPromises.push(this.addAccountToAccountLoader(accountToPoll));
 		}
 
+		const oraclePromises = [];
 		for (const [_, oracleToPoll] of this.oraclesToPoll) {
-			await this.addOracleToAccountLoader(oracleToPoll);
+			oraclePromises.push(this.addOracleToAccountLoader(oracleToPoll));
 		}
 
+		await Promise.all([...accountPromises, ...oraclePromises]);
+
 		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
 			this.eventEmitter.emit('error', error);
 		});
@@ -446,37 +454,44 @@ export class PollingDriftClientAccountSubscriber
 		}
 		console.log(`Pausing to find oracle ${oracle} failed`);
 	}
-
 	async setPerpOracleMap() {
 		const perpMarkets = this.getMarketAccountsAndSlots();
+		const oraclePromises = [];
 		for (const perpMarket of perpMarkets) {
 			const perpMarketAccount = perpMarket.data;
 			const perpMarketIndex = perpMarketAccount.marketIndex;
 			const oracle = perpMarketAccount.amm.oracle;
 			if (!this.oracles.has(oracle.toBase58())) {
-				await this.addOracle({
-					publicKey: oracle,
-					source: perpMarketAccount.amm.oracleSource,
-				});
+				oraclePromises.push(
+					this.addOracle({
+						publicKey: oracle,
+						source: perpMarketAccount.amm.oracleSource,
+					})
+				);
 			}
 			this.perpOracleMap.set(perpMarketIndex, oracle);
 		}
+		await Promise.all(oraclePromises);
 	}
 
 	async setSpotOracleMap() {
 		const spotMarkets = this.getSpotMarketAccountsAndSlots();
+		const oraclePromises = [];
 		for (const spotMarket of spotMarkets) {
 			const spotMarketAccount = spotMarket.data;
 			const spotMarketIndex = spotMarketAccount.marketIndex;
 			const oracle = spotMarketAccount.oracle;
 			if (!this.oracles.has(oracle.toBase58())) {
-				await this.addOracle({
-					publicKey: oracle,
-					source: spotMarketAccount.oracleSource,
-				});
+				oraclePromises.push(
+					this.addOracle({
+						publicKey: oracle,
+						source: spotMarketAccount.oracleSource,
+					})
+				);
 			}
 			this.spotOracleMap.set(spotMarketIndex, oracle);
 		}
+		await Promise.all(oraclePromises);
 	}
 
 	assertIsSubscribed(): void {

package/src/accounts/webSocketDriftClientAccountSubscriber.ts

@@ -115,19 +115,18 @@ export class WebSocketDriftClientAccountSubscriber
 			this.eventEmitter.emit('update');
 		});
 
-		// subscribe to market accounts
-		await this.subscribeToPerpMarketAccounts();
-
-		// subscribe to spot market accounts
-		await this.subscribeToSpotMarketAccounts();
-
-		// subscribe to oracles
-		await this.subscribeToOracles();
+		await Promise.all([
+			// subscribe to market accounts
+			this.subscribeToPerpMarketAccounts(),
+			// subscribe to spot market accounts
+			this.subscribeToSpotMarketAccounts(),
+			// subscribe to oracles
+			this.subscribeToOracles(),
+		]);
 
 		this.eventEmitter.emit('update');
 
-		await this.setPerpOracleMap();
-		await this.setSpotOracleMap();
+		await Promise.all([this.setPerpOracleMap(), this.setSpotOracleMap()]);
 
 		this.isSubscribing = false;
 		this.isSubscribed = true;
@@ -137,9 +136,11 @@ export class WebSocketDriftClientAccountSubscriber
 	}
 
 	async subscribeToPerpMarketAccounts(): Promise<boolean> {
-		for (const marketIndex of this.perpMarketIndexes) {
-			await this.subscribeToPerpMarketAccount(marketIndex);
-		}
+		await Promise.all(
+			this.perpMarketIndexes.map((marketIndex) =>
+				this.subscribeToPerpMarketAccount(marketIndex)
+			)
+		);
 		return true;
 	}
 
@@ -165,9 +166,11 @@ export class WebSocketDriftClientAccountSubscriber
 	}
 
 	async subscribeToSpotMarketAccounts(): Promise<boolean> {
-		for (const marketIndex of this.spotMarketIndexes) {
-			await this.subscribeToSpotMarketAccount(marketIndex);
-		}
+		await Promise.all(
+			this.spotMarketIndexes.map((marketIndex) =>
+				this.subscribeToSpotMarketAccount(marketIndex)
+			)
+		);
 		return true;
 	}
 
@@ -193,11 +196,11 @@ export class WebSocketDriftClientAccountSubscriber
 	}
 
 	async subscribeToOracles(): Promise<boolean> {
-		for (const oracleInfo of this.oracleInfos) {
-			if (!oracleInfo.publicKey.equals(PublicKey.default)) {
-				await this.subscribeToOracle(oracleInfo);
-			}
-		}
+		await Promise.all(
+			this.oracleInfos
+				.filter((oracleInfo) => !oracleInfo.publicKey.equals(PublicKey.default))
+				.map((oracleInfo) => this.subscribeToOracle(oracleInfo))
+		);
 
 		return true;
 	}
@@ -232,21 +235,27 @@ export class WebSocketDriftClientAccountSubscriber
 	}
 
 	async unsubscribeFromMarketAccounts(): Promise<void> {
-		for (const accountSubscriber of this.perpMarketAccountSubscribers.values()) {
-			await accountSubscriber.unsubscribe();
-		}
+		await Promise.all(
+			Array.from(this.perpMarketAccountSubscribers.values()).map(
+				(accountSubscriber) => accountSubscriber.unsubscribe()
+			)
+		);
 	}
 
 	async unsubscribeFromSpotMarketAccounts(): Promise<void> {
-		for (const accountSubscriber of this.spotMarketAccountSubscribers.values()) {
-			await accountSubscriber.unsubscribe();
-		}
+		await Promise.all(
+			Array.from(this.spotMarketAccountSubscribers.values()).map(
+				(accountSubscriber) => accountSubscriber.unsubscribe()
+			)
+		);
 	}
 
 	async unsubscribeFromOracles(): Promise<void> {
-		for (const accountSubscriber of this.oracleSubscribers.values()) {
-			await accountSubscriber.unsubscribe();
-		}
+		await Promise.all(
+			Array.from(this.oracleSubscribers.values()).map((accountSubscriber) =>
+				accountSubscriber.unsubscribe()
+			)
+		);
 	}
 
 	public async fetch(): Promise<void> {
@@ -315,6 +324,7 @@ export class WebSocketDriftClientAccountSubscriber
 
 	async setPerpOracleMap() {
 		const perpMarkets = this.getMarketAccountsAndSlots();
+		const addOraclePromises = [];
 		for (const perpMarket of perpMarkets) {
 			if (!perpMarket) {
 				continue;
@@ -323,17 +333,21 @@ export class WebSocketDriftClientAccountSubscriber
 			const perpMarketIndex = perpMarketAccount.marketIndex;
 			const oracle = perpMarketAccount.amm.oracle;
 			if (!this.oracleSubscribers.has(oracle.toBase58())) {
-				await this.addOracle({
-					publicKey: oracle,
-					source: perpMarket.data.amm.oracleSource,
-				});
+				addOraclePromises.push(
+					this.addOracle({
+						publicKey: oracle,
+						source: perpMarket.data.amm.oracleSource,
+					})
+				);
 			}
 			this.perpOracleMap.set(perpMarketIndex, oracle);
 		}
+		await Promise.all(addOraclePromises);
 	}
 
 	async setSpotOracleMap() {
 		const spotMarkets = this.getSpotMarketAccountsAndSlots();
+		const addOraclePromises = [];
 		for (const spotMarket of spotMarkets) {
 			if (!spotMarket) {
 				continue;
@@ -342,13 +356,16 @@ export class WebSocketDriftClientAccountSubscriber
 			const spotMarketIndex = spotMarketAccount.marketIndex;
 			const oracle = spotMarketAccount.oracle;
 			if (!this.oracleSubscribers.has(oracle.toBase58())) {
-				await this.addOracle({
-					publicKey: oracle,
-					source: spotMarketAccount.oracleSource,
-				});
+				addOraclePromises.push(
+					this.addOracle({
+						publicKey: oracle,
+						source: spotMarketAccount.oracleSource,
+					})
+				);
 			}
 			this.spotOracleMap.set(spotMarketIndex, oracle);
 		}
+		await Promise.all(addOraclePromises);
 	}
 
 	assertIsSubscribed(): void {

package/src/adminClient.ts

@@ -30,6 +30,7 @@ import {
 	getProtocolIfSharesTransferConfigPublicKey,
 	getPrelaunchOraclePublicKey,
 	getPythPullOraclePublicKey,
+	getUserStatsAccountPublicKey,
 } from './addresses/pda';
 import { squareRootBN } from './math/utils';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
@@ -3533,6 +3534,164 @@ export class AdminClient extends DriftClient {
 		});
 	}
 
+	public async updateSpotMarketFuel(
+		spotMarketIndex: number,
+		fuelBoostDeposits?: number,
+		fuelBoostBorrows?: number,
+		fuelBoostTaker?: number,
+		fuelBoostMaker?: number,
+		fuelBoostInsurance?: number
+	): Promise<TransactionSignature> {
+		const updateSpotMarketFuelIx = await this.getUpdateSpotMarketFuelIx(
+			spotMarketIndex,
+			fuelBoostDeposits || null,
+			fuelBoostBorrows || null,
+			fuelBoostTaker || null,
+			fuelBoostMaker || null,
+			fuelBoostInsurance || null
+		);
+
+		const tx = await this.buildTransaction(updateSpotMarketFuelIx);
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async getUpdateSpotMarketFuelIx(
+		spotMarketIndex: number,
+		fuelBoostDeposits?: number,
+		fuelBoostBorrows?: number,
+		fuelBoostTaker?: number,
+		fuelBoostMaker?: number,
+		fuelBoostInsurance?: number
+	): Promise<TransactionInstruction> {
+		const spotMarketPublicKey = await getSpotMarketPublicKey(
+			this.program.programId,
+			spotMarketIndex
+		);
+
+		return await this.program.instruction.updateSpotMarketFuel(
+			fuelBoostDeposits || null,
+			fuelBoostBorrows || null,
+			fuelBoostTaker || null,
+			fuelBoostMaker || null,
+			fuelBoostInsurance || null,
+			{
+				accounts: {
+					admin: this.isSubscribed
+						? this.getStateAccount().admin
+						: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					spotMarket: spotMarketPublicKey,
+				},
+			}
+		);
+	}
+
+	public async updatePerpMarketFuel(
+		perpMarketIndex: number,
+		fuelBoostTaker?: number,
+		fuelBoostMaker?: number,
+		fuelBoostPosition?: number
+	): Promise<TransactionSignature> {
+		const updatePerpMarketFuelIx = await this.getUpdatePerpMarketFuelIx(
+			perpMarketIndex,
+			fuelBoostTaker || null,
+			fuelBoostMaker || null,
+			fuelBoostPosition || null
+		);
+
+		const tx = await this.buildTransaction(updatePerpMarketFuelIx);
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async getUpdatePerpMarketFuelIx(
+		perpMarketIndex: number,
+		fuelBoostTaker?: number,
+		fuelBoostMaker?: number,
+		fuelBoostPosition?: number
+	): Promise<TransactionInstruction> {
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
+			this.program.programId,
+			perpMarketIndex
+		);
+
+		return await this.program.instruction.updatePerpMarketFuel(
+			fuelBoostTaker || null,
+			fuelBoostMaker || null,
+			fuelBoostPosition || null,
+			{
+				accounts: {
+					admin: this.isSubscribed
+						? this.getStateAccount().admin
+						: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					perpMarket: perpMarketPublicKey,
+				},
+			}
+		);
+	}
+
+	public async initUserFuel(
+		user: PublicKey,
+		authority: PublicKey,
+		fuelBonusDeposits?: number,
+		fuelBonusBorrows?: number,
+		fuelBonusTaker?: number,
+		fuelBonusMaker?: number,
+		fuelBonusInsurance?: number
+	): Promise<TransactionSignature> {
+		const updatePerpMarketFuelIx = await this.getInitUserFuelIx(
+			user,
+			authority,
+			fuelBonusDeposits,
+			fuelBonusBorrows,
+			fuelBonusTaker,
+			fuelBonusMaker,
+			fuelBonusInsurance
+		);
+
+		const tx = await this.buildTransaction(updatePerpMarketFuelIx);
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async getInitUserFuelIx(
+		user: PublicKey,
+		authority: PublicKey,
+		fuelBonusDeposits?: number,
+		fuelBonusBorrows?: number,
+		fuelBonusTaker?: number,
+		fuelBonusMaker?: number,
+		fuelBonusInsurance?: number
+	): Promise<TransactionInstruction> {
+		const userStats = await getUserStatsAccountPublicKey(
+			this.program.programId,
+			authority
+		);
+
+		return await this.program.instruction.initUserFuel(
+			fuelBonusDeposits || null,
+			fuelBonusBorrows || null,
+			fuelBonusTaker || null,
+			fuelBonusMaker || null,
+			fuelBonusInsurance || null,
+			{
+				accounts: {
+					admin: this.isSubscribed
+						? this.getStateAccount().admin
+						: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					user,
+					userStats,
+				},
+			}
+		);
+	}
+
 	public async initializePythPullOracle(
 		feedId: string
 	): Promise<TransactionSignature> {

package/src/bankrun/bankrunConnection.ts

@@ -118,6 +118,19 @@ export class BankrunContextWrapper {
 		);
 		await this.context.setClock(newClock);
 	}
+
+	async setTimestamp(unix_timestamp: number): Promise<void> {
+		const currentClock = await this.context.banksClient.getClock();
+		const newUnixTimestamp = BigInt(unix_timestamp);
+		const newClock = new Clock(
+			currentClock.slot,
+			currentClock.epochStartTimestamp,
+			currentClock.epoch,
+			currentClock.leaderScheduleEpoch,
+			newUnixTimestamp
+		);
+		await this.context.setClock(newClock);
+	}
 }
 
 export class BankrunConnection {

package/src/constants/numericConstants.ts

@@ -90,6 +90,7 @@ export const ONE_HOUR = new BN(60 * 60);
 export const ONE_YEAR = new BN(31536000);
 
 export const QUOTE_SPOT_MARKET_INDEX = 0;
+export const GOV_SPOT_MARKET_INDEX = 15;
 
 export const LAMPORTS_PRECISION = new BN(LAMPORTS_PER_SOL);
 export const LAMPORTS_EXP = new BN(Math.log10(LAMPORTS_PER_SOL));
@@ -105,3 +106,6 @@ export const IDLE_TIME_SLOTS = 9000;
 export const SLOT_TIME_ESTIMATE_MS = 400;
 
 export const DUST_POSITION_SIZE = QUOTE_PRECISION.divn(100); // Dust position is any position smaller than 1c
+
+export const FUEL_WINDOW = new BN(60 * 60 * 24 * 28); // 28 days
+export const FUEL_START_TS = new BN(1722384000); // unix timestamp