@drift-labs/sdk 2.86.0-beta.3 → 2.86.0-beta.31

package/src/types.ts

@@ -44,8 +44,9 @@ export enum PerpOperation {
 export enum SpotOperation {
 	UPDATE_CUMULATIVE_INTEREST = 1,
 	FILL = 2,
-	WITHDRAW = 4,
-	LIQUIDATION = 8,
+	DEPOSIT = 4,
+	WITHDRAW = 8,
+	LIQUIDATION = 16,
 }
 
 export enum InsuranceFundOperation {
@@ -636,6 +637,10 @@ export type PerpMarketAccount = {
 	quoteSpotMarketIndex: number;
 	feeAdjustment: number;
 	pausedOperations: number;
+
+	fuelBoostTaker: number;
+	fuelBoostMaker: number;
+	fuelBoostPosition: number;
 };
 
 export type HistoricalOracleData = {
@@ -734,6 +739,12 @@ export type SpotMarketAccount = {
 
 	maxTokenBorrowsFraction: number;
 	minBorrowRate: number;
+
+	fuelBoostDeposits: number;
+	fuelBoostBorrows: number;
+	fuelBoostTaker: number;
+	fuelBoostMaker: number;
+	fuelBoostInsurance: number;
 };
 
 export type PoolBalance = {
@@ -876,6 +887,17 @@ export type UserStatsAccount = {
 	isReferrer: boolean;
 	authority: PublicKey;
 	ifStakedQuoteAssetAmount: BN;
+
+	lastFuelIfBonusUpdateTs: number; // u32 onchain
+
+	fuelInsurance: number;
+	fuelDeposits: number;
+	fuelBorrows: number;
+	fuelPositions: number;
+	fuelTaker: number;
+	fuelMaker: number;
+
+	ifStakedGovTokenAmount: BN;
 };
 
 export type UserAccount = {
@@ -905,6 +927,7 @@ export type UserAccount = {
 	hasOpenOrder: boolean;
 	openAuctions: number;
 	hasOpenAuction: boolean;
+	lastFuelBonusUpdateTs: number;
 };
 
 export type SpotPosition = {
@@ -1159,6 +1182,23 @@ export type PhoenixV1FulfillmentConfigAccount = {
 	status: SpotFulfillmentStatus;
 };
 
+export type OpenbookV2FulfillmentConfigAccount = {
+	pubkey: PublicKey;
+	openbookV2ProgramId: PublicKey;
+	openbookV2Market: PublicKey;
+	openbookV2MarketAuthority: PublicKey;
+	openbookV2EventHeap: PublicKey;
+	openbookV2Bids: PublicKey;
+	openbookV2Asks: PublicKey;
+	openbookV2BaseVault: PublicKey;
+	openbookV2QuoteVault: PublicKey;
+	marketIndex: number;
+	fulfillmentType: SpotFulfillmentType;
+	status: SpotFulfillmentStatus;
+	// not actually on the account, just used to pass around remaining accounts in ts
+	remainingAccounts?: PublicKey[];
+};
+
 export type ReferrerNameAccount = {
 	name: number[];
 	user: PublicKey;

package/src/user.ts

@@ -31,10 +31,12 @@ import {
 	QUOTE_PRECISION_EXP,
 	QUOTE_SPOT_MARKET_INDEX,
 	SPOT_MARKET_WEIGHT_PRECISION,
+	GOV_SPOT_MARKET_INDEX,
 	TEN,
 	TEN_THOUSAND,
 	TWO,
 	ZERO,
+	FUEL_START_TS,
 } from './constants/numericConstants';
 import {
 	DataAndSlot,
@@ -88,6 +90,12 @@ import { calculateLiveOracleTwap } from './math/oracles';
 import { getPerpMarketTierNumber, getSpotMarketTierNumber } from './math/tiers';
 import { StrictOraclePrice } from './oracles/strictOraclePrice';
 
+import {
+	calculateSpotFuelBonus,
+	calculatePerpFuelBonus,
+	calculateInsuranceFuelBonus,
+} from './math/fuel';
+
 export class User {
 	driftClient: DriftClient;
 	userAccountPublicKey: PublicKey;
@@ -873,6 +881,175 @@ export class User {
 			}, ZERO);
 	}
 
+	public getFuelBonus(
+		now: BN,
+		includeSettled = true,
+		includeUnsettled = true
+	): {
+		depositFuel: BN;
+		borrowFuel: BN;
+		positionFuel: BN;
+		takerFuel: BN;
+		makerFuel: BN;
+		insuranceFuel: BN;
+	} {
+		const userAccount: UserAccount = this.getUserAccount();
+
+		const result = {
+			insuranceFuel: ZERO,
+			takerFuel: ZERO,
+			makerFuel: ZERO,
+			depositFuel: ZERO,
+			borrowFuel: ZERO,
+			positionFuel: ZERO,
+		};
+
+		if (includeSettled) {
+			const userStats: UserStatsAccount = this.driftClient
+				.getUserStats()
+				.getAccount();
+			result.insuranceFuel = result.insuranceFuel.add(
+				new BN(userStats.fuelInsurance)
+			);
+			result.takerFuel = result.takerFuel.add(new BN(userStats.fuelTaker));
+			result.makerFuel = result.makerFuel.add(new BN(userStats.fuelMaker));
+			result.depositFuel = result.depositFuel.add(
+				new BN(userStats.fuelDeposits)
+			);
+			result.borrowFuel = result.borrowFuel.add(new BN(userStats.fuelBorrows));
+			result.positionFuel = result.positionFuel.add(
+				new BN(userStats.fuelPositions)
+			);
+		}
+
+		if (includeUnsettled) {
+			const fuelBonusNumerator = BN.max(
+				now.sub(
+					BN.max(new BN(userAccount.lastFuelBonusUpdateTs), FUEL_START_TS)
+				),
+				ZERO
+			);
+
+			if (fuelBonusNumerator.gt(ZERO)) {
+				for (const spotPosition of this.getActiveSpotPositions()) {
+					const spotMarketAccount: SpotMarketAccount =
+						this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
+
+					const tokenAmount = this.getTokenAmount(spotPosition.marketIndex);
+					const oraclePriceData = this.getOracleDataForSpotMarket(
+						spotPosition.marketIndex
+					);
+
+					const twap5min = calculateLiveOracleTwap(
+						spotMarketAccount.historicalOracleData,
+						oraclePriceData,
+						now,
+						FIVE_MINUTE // 5MIN
+					);
+					const strictOraclePrice = new StrictOraclePrice(
+						oraclePriceData.price,
+						twap5min
+					);
+
+					const signedTokenValue = getStrictTokenValue(
+						tokenAmount,
+						spotMarketAccount.decimals,
+						strictOraclePrice
+					);
+
+					if (signedTokenValue.gt(ZERO)) {
+						result.depositFuel = result.depositFuel.add(
+							calculateSpotFuelBonus(
+								spotMarketAccount,
+								signedTokenValue,
+								fuelBonusNumerator
+							)
+						);
+					} else {
+						result.borrowFuel = result.borrowFuel.add(
+							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(
+						calculatePerpFuelBonus(
+							perpMarketAccount,
+							baseAssetValue,
+							fuelBonusNumerator
+						)
+					);
+				}
+			}
+
+			const userStats: UserStatsAccount = this.driftClient
+				.getUserStats()
+				.getAccount();
+
+			// todo: get real time ifStakedGovTokenAmount using ifStakeAccount
+			if (userStats.ifStakedGovTokenAmount.gt(ZERO)) {
+				const spotMarketAccount: SpotMarketAccount =
+					this.driftClient.getSpotMarketAccount(GOV_SPOT_MARKET_INDEX);
+
+				const fuelBonusNumeratorUserStats = BN.max(
+					now.sub(
+						BN.max(new BN(userStats.lastFuelIfBonusUpdateTs), FUEL_START_TS)
+					),
+					ZERO
+				);
+
+				result.insuranceFuel = result.insuranceFuel.add(
+					calculateInsuranceFuelBonus(
+						spotMarketAccount,
+						userStats.ifStakedGovTokenAmount,
+						fuelBonusNumeratorUserStats
+					)
+				);
+			}
+
+			if (userStats.ifStakedQuoteAssetAmount.gt(ZERO)) {
+				const spotMarketAccount: SpotMarketAccount =
+					this.driftClient.getSpotMarketAccount(QUOTE_SPOT_MARKET_INDEX);
+
+				const fuelBonusNumeratorUserStats = BN.max(
+					now.sub(
+						BN.max(new BN(userStats.lastFuelIfBonusUpdateTs), FUEL_START_TS)
+					),
+					ZERO
+				);
+
+				result.insuranceFuel = result.insuranceFuel.add(
+					calculateInsuranceFuelBonus(
+						spotMarketAccount,
+						userStats.ifStakedQuoteAssetAmount,
+						fuelBonusNumeratorUserStats
+					)
+				);
+			}
+		}
+
+		return result;
+	}
+
 	public getSpotMarketAssetAndLiabilityValue(
 		marketIndex?: number,
 		marginCategory?: MarginCategory,

package/tests/ci/verifyConstants.ts

@@ -0,0 +1,214 @@
+import {
+	DriftClient,
+	DevnetSpotMarkets,
+	MainnetSpotMarkets,
+	DevnetPerpMarkets,
+	MainnetPerpMarkets,
+	BulkAccountLoader,
+	getVariant,
+} from '../../src';
+import { Connection, Keypair } from '@solana/web3.js';
+import { Wallet } from '@coral-xyz/anchor';
+import dotenv from 'dotenv';
+import { assert } from 'chai';
+
+dotenv.config();
+
+describe('Verify Constants', function () {
+	this.timeout(100_000);
+	const MAINNET_RPC_ENDPOINT = process.env.MAINNET_RPC_ENDPOINT;
+    const DEVNET_RPC_ENDPOINT = process.env.DEVNET_RPC_ENDPOINT;
+
+	if (MAINNET_RPC_ENDPOINT === undefined) {
+	    throw new Error("MAINNET_RPC_ENDPOINT not found in .env");
+	}
+
+    if (DEVNET_RPC_ENDPOINT === undefined) {
+	    throw new Error("DEVNET_RPC_ENDPOINT not found in .env");
+	}
+
+	const wallet = new Wallet(Keypair.generate());
+
+    const devnetConnection = new Connection(DEVNET_RPC_ENDPOINT);
+	const mainnetConnection = new Connection(MAINNET_RPC_ENDPOINT);
+
+	const devnetBulkAccountLoader = new BulkAccountLoader(
+		devnetConnection,
+		'processed',
+		1
+	);
+
+	const mainnetBulkAccountLoader = new BulkAccountLoader(
+		mainnetConnection,
+		'processed',
+		1
+	);
+
+	const devnetDriftClient = new DriftClient({
+		connection: devnetConnection,
+		wallet,
+		env: 'devnet',
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: devnetBulkAccountLoader,
+		},
+	});
+
+	const mainnetDriftClient = new DriftClient({
+		connection: mainnetConnection,
+		wallet,
+		env: 'mainnet-beta',
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: mainnetBulkAccountLoader,
+		},
+	});
+
+	before(async () => {
+		await devnetDriftClient.subscribe();
+		await mainnetDriftClient.subscribe();
+	});
+
+	after(async () => {
+		await devnetDriftClient.unsubscribe();
+		await mainnetDriftClient.unsubscribe();
+	});
+
+	it('has all mainnet markets', async () => {
+		const spotMarkets = mainnetDriftClient.getSpotMarketAccounts();
+        spotMarkets.sort((a, b) => a.marketIndex - b.marketIndex);
+
+		for (const market of spotMarkets) {
+			const correspondingConfigMarket = MainnetSpotMarkets.find(
+				(configMarket) => configMarket.marketIndex === market.marketIndex
+			);
+			assert(
+				correspondingConfigMarket !== undefined,
+				`Market ${
+					market.marketIndex
+				} not found in MainnetSpotMarkets. market: ${market.pubkey.toBase58()}`
+			);
+			assert(
+				correspondingConfigMarket.oracle.toBase58() == market.oracle.toBase58(),
+				`Oracle mismatch for mainnet spot market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.oracle.toBase58()}, chain: ${market.oracle.toBase58()}`
+			);
+			assert(
+				getVariant(correspondingConfigMarket.oracleSource) ===
+					getVariant(market.oracleSource),
+				`Oracle source mismatch for mainnet spot market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${getVariant(
+					correspondingConfigMarket.oracleSource
+				)}, chain: ${getVariant(market.oracleSource)}`
+			);
+			assert(
+				correspondingConfigMarket.mint.toBase58() === market.mint.toBase58(),
+				`Mint mismatch for mainnet spot market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.mint.toBase58()}, chain: ${market.mint.toBase58()}`
+			);
+		}
+
+		const perpMarkets = mainnetDriftClient.getPerpMarketAccounts();
+        perpMarkets.sort((a, b) => a.marketIndex - b.marketIndex);
+
+		for (const market of perpMarkets) {
+			const correspondingConfigMarket = MainnetPerpMarkets.find(
+				(configMarket) => configMarket.marketIndex === market.marketIndex
+			);
+			assert(
+				correspondingConfigMarket !== undefined,
+				`Market ${
+					market.marketIndex
+				} not found in MainnetPerpMarkets, market: ${market.pubkey.toBase58()}`
+			);
+			assert(
+				correspondingConfigMarket.oracle.toBase58() ==
+					market.amm.oracle.toBase58(),
+				`Oracle mismatch for mainnet perp market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.oracle.toBase58()}, chain: ${market.amm.oracle.toBase58()}`
+			);
+			assert(
+				getVariant(correspondingConfigMarket.oracleSource) ===
+					getVariant(market.amm.oracleSource),
+				`Oracle source mismatch for mainnet perp market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${getVariant(
+					correspondingConfigMarket.oracleSource
+				)}, chain: ${getVariant(market.amm.oracleSource)}`
+			);
+		}
+	});
+
+	it('has all devnet markets', async () => {
+		const spotMarkets = devnetDriftClient.getSpotMarketAccounts();
+        spotMarkets.sort((a, b) => a.marketIndex - b.marketIndex);
+
+		for (const market of spotMarkets) {
+			const correspondingConfigMarket = DevnetSpotMarkets.find(
+				(configMarket) => configMarket.marketIndex === market.marketIndex
+			);
+			assert(
+				correspondingConfigMarket !== undefined,
+				`Market ${
+					market.marketIndex
+				} not found in DevnetSpotMarkets, market: ${market.pubkey.toBase58()}`
+			);
+			assert(
+				correspondingConfigMarket.oracle.toBase58() == market.oracle.toBase58(),
+				`Oracle mismatch for devnet spot market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.oracle.toBase58()}, chain: ${market.oracle.toBase58()}`
+			);
+			assert(
+				getVariant(correspondingConfigMarket.oracleSource) ===
+					getVariant(market.oracleSource),
+				`Oracle source mismatch for devnet spot market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${getVariant(
+					correspondingConfigMarket.oracleSource
+				)}, chain: ${getVariant(market.oracleSource)}`
+			);
+			assert(
+				correspondingConfigMarket.mint.toBase58() === market.mint.toBase58(),
+				`Mint mismatch for devnet spot market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.mint.toBase58()}, chain: ${market.mint.toBase58()}`
+			);
+		}
+
+		const perpMarkets = devnetDriftClient.getPerpMarketAccounts();
+        perpMarkets.sort((a, b) => a.marketIndex - b.marketIndex);
+
+		for (const market of perpMarkets) {
+			const correspondingConfigMarket = DevnetPerpMarkets.find(
+				(configMarket) => configMarket.marketIndex === market.marketIndex
+			);
+			assert(
+				correspondingConfigMarket !== undefined,
+				`Market ${
+					market.marketIndex
+				} not found in DevnetPerpMarkets, market: ${market.pubkey.toBase58()}`
+			);
+			assert(
+				correspondingConfigMarket.oracle.toBase58() ==
+					market.amm.oracle.toBase58(),
+				`Oracle mismatch for devnet perp market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${correspondingConfigMarket.oracle.toBase58()}, chain: ${market.amm.oracle.toBase58()}`
+			);
+			assert(
+				getVariant(correspondingConfigMarket.oracleSource) ===
+					getVariant(market.amm.oracleSource),
+				`Oracle source mismatch for devnet perp market ${
+					market.marketIndex
+				}, market: ${market.pubkey.toBase58()}, constants: ${getVariant(
+					correspondingConfigMarket.oracleSource
+				)}, chain: ${getVariant(market.amm.oracleSource)}`
+			);
+		}
+	});
+});

package/tests/dlob/helpers.ts

@@ -187,6 +187,9 @@ export const mockPerpMarkets: Array<PerpMarketAccount> = [
 		quoteSpotMarketIndex: 0,
 		feeAdjustment: 0,
 		pausedOperations: 0,
+		fuelBoostPosition: 0,
+		fuelBoostMaker: 0,
+		fuelBoostTaker: 0,
 	},
 	{
 		status: MarketStatus.INITIALIZED,
@@ -226,6 +229,9 @@ export const mockPerpMarkets: Array<PerpMarketAccount> = [
 		quoteSpotMarketIndex: 0,
 		feeAdjustment: 0,
 		pausedOperations: 0,
+		fuelBoostPosition: 0,
+		fuelBoostMaker: 0,
+		fuelBoostTaker: 0,
 	},
 	{
 		status: MarketStatus.INITIALIZED,
@@ -265,6 +271,9 @@ export const mockPerpMarkets: Array<PerpMarketAccount> = [
 		quoteSpotMarketIndex: 0,
 		feeAdjustment: 0,
 		pausedOperations: 0,
+		fuelBoostPosition: 0,
+		fuelBoostMaker: 0,
+		fuelBoostTaker: 0,
 	},
 ];
 
@@ -351,6 +360,13 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 		},
 		pausedOperations: 0,
 		ifPausedOperations: 0,
+		maxTokenBorrowsFraction: 0,
+		minBorrowRate: 0,
+		fuelBoostDeposits: 0,
+		fuelBoostBorrows: 0,
+		fuelBoostTaker: 0,
+		fuelBoostMaker: 0,
+		fuelBoostInsurance: 0,
 	},
 	{
 		status: MarketStatus.ACTIVE,
@@ -434,6 +450,13 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 		},
 		pausedOperations: 0,
 		ifPausedOperations: 0,
+		maxTokenBorrowsFraction: 0,
+		minBorrowRate: 0,
+		fuelBoostDeposits: 0,
+		fuelBoostBorrows: 0,
+		fuelBoostTaker: 0,
+		fuelBoostMaker: 0,
+		fuelBoostInsurance: 0,
 	},
 	{
 		status: MarketStatus.ACTIVE,
@@ -517,6 +540,13 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 		},
 		pausedOperations: 0,
 		ifPausedOperations: 0,
+		maxTokenBorrowsFraction: 0,
+		minBorrowRate: 0,
+		fuelBoostDeposits: 0,
+		fuelBoostBorrows: 0,
+		fuelBoostTaker: 0,
+		fuelBoostMaker: 0,
+		fuelBoostInsurance: 0,
 	},
 ];
 

package/tests/user/helpers.ts

@@ -85,4 +85,5 @@ export const mockUserAccount: UserAccount = {
 	hasOpenOrder: false,
 	openAuctions: 0,
 	hasOpenAuction: false,
+	lastFuelBonusUpdateTs: 0,
 };

package/tests/user/test.ts

@@ -35,6 +35,8 @@ async function makeMockUser(
 	const mockUser: User = await umap.mustGet('1');
 	mockUser._isSubscribed = true;
 	mockUser.driftClient._isSubscribed = true;
+	mockUser.driftClient.accountSubscriber.isSubscribed = true;
+
 	const oraclePriceMap = {};
 	// console.log(perpOraclePriceList, myMockPerpMarkets.length);
 	// console.log(spotOraclePriceList, myMockSpotMarkets.length);