@drift-labs/sdk 2.84.0-beta.6 → 2.84.0-beta.7

package/VERSION

@@ -1 +1 @@
-2.84.0-beta.6
+2.84.0-beta.7

package/lib/adminClient.d.ts

@@ -89,6 +89,8 @@ export declare class AdminClient extends DriftClient {
     getUpdateSpotMarketRevenueSettlePeriodIx(spotMarketIndex: number, revenueSettlePeriod: BN): Promise<TransactionInstruction>;
     updateSpotMarketMaxTokenDeposits(spotMarketIndex: number, maxTokenDeposits: BN): Promise<TransactionSignature>;
     getUpdateSpotMarketMaxTokenDepositsIx(spotMarketIndex: number, maxTokenDeposits: BN): Promise<TransactionInstruction>;
+    updateSpotMarketMaxTokenBorrows(spotMarketIndex: number, maxTokenBorrows: BN): Promise<TransactionSignature>;
+    getUpdateSpotMarketMaxTokenBorrowsIx(spotMarketIndex: number, maxTokenBorrows: BN): Promise<TransactionInstruction>;
     updateSpotMarketScaleInitialAssetWeightStart(spotMarketIndex: number, scaleInitialAssetWeightStart: BN): Promise<TransactionSignature>;
     getUpdateSpotMarketScaleInitialAssetWeightStartIx(spotMarketIndex: number, scaleInitialAssetWeightStart: BN): Promise<TransactionInstruction>;
     updateInsuranceFundUnstakingPeriod(spotMarketIndex: number, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionSignature>;
@@ -125,8 +127,8 @@ export declare class AdminClient extends DriftClient {
     getUpdateDiscountMintIx(discountMint: PublicKey): Promise<TransactionInstruction>;
     updateSpotMarketMarginWeights(spotMarketIndex: number, initialAssetWeight: number, maintenanceAssetWeight: number, initialLiabilityWeight: number, maintenanceLiabilityWeight: number, imfFactor?: number): Promise<TransactionSignature>;
     getUpdateSpotMarketMarginWeightsIx(spotMarketIndex: number, initialAssetWeight: number, maintenanceAssetWeight: number, initialLiabilityWeight: number, maintenanceLiabilityWeight: number, imfFactor?: number): Promise<TransactionInstruction>;
-    updateSpotMarketBorrowRate(spotMarketIndex: number, optimalUtilization: number, optimalBorrowRate: number, optimalMaxRate: number): Promise<TransactionSignature>;
-    getUpdateSpotMarketBorrowRateIx(spotMarketIndex: number, optimalUtilization: number, optimalBorrowRate: number, optimalMaxRate: number): Promise<TransactionInstruction>;
+    updateSpotMarketBorrowRate(spotMarketIndex: number, optimalUtilization: number, optimalBorrowRate: number, optimalMaxRate: number, minBorrowRate?: number | undefined): Promise<TransactionSignature>;
+    getUpdateSpotMarketBorrowRateIx(spotMarketIndex: number, optimalUtilization: number, optimalBorrowRate: number, optimalMaxRate: number, minBorrowRate?: number | undefined): Promise<TransactionInstruction>;
     updateSpotMarketAssetTier(spotMarketIndex: number, assetTier: AssetTier): Promise<TransactionSignature>;
     getUpdateSpotMarketAssetTierIx(spotMarketIndex: number, assetTier: AssetTier): Promise<TransactionInstruction>;
     updateSpotMarketStatus(spotMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionSignature>;

package/lib/adminClient.js

@@ -829,6 +829,23 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
+    async updateSpotMarketMaxTokenBorrows(spotMarketIndex, maxTokenBorrows) {
+        const updateSpotMarketMaxTokenBorrowsIx = await this.getUpdateSpotMarketMaxTokenBorrowsIx(spotMarketIndex, maxTokenBorrows);
+        const tx = await this.buildTransaction(updateSpotMarketMaxTokenBorrowsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketMaxTokenBorrowsIx(spotMarketIndex, maxTokenBorrows) {
+        return this.program.instruction.updateSpotMarketMaxTokenBorrows(maxTokenBorrows, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().admin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
     async updateSpotMarketScaleInitialAssetWeightStart(spotMarketIndex, scaleInitialAssetWeightStart) {
         const updateSpotMarketScaleInitialAssetWeightStartIx = await this.getUpdateSpotMarketScaleInitialAssetWeightStartIx(spotMarketIndex, scaleInitialAssetWeightStart);
         const tx = await this.buildTransaction(updateSpotMarketScaleInitialAssetWeightStartIx);
@@ -1150,14 +1167,14 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
-    async updateSpotMarketBorrowRate(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate) {
-        const updateSpotMarketBorrowRateIx = await this.getUpdateSpotMarketBorrowRateIx(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate);
+    async updateSpotMarketBorrowRate(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate, minBorrowRate) {
+        const updateSpotMarketBorrowRateIx = await this.getUpdateSpotMarketBorrowRateIx(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate, minBorrowRate);
         const tx = await this.buildTransaction(updateSpotMarketBorrowRateIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
-    async getUpdateSpotMarketBorrowRateIx(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate) {
-        return await this.program.instruction.updateSpotMarketBorrowRate(optimalUtilization, optimalBorrowRate, optimalMaxRate, {
+    async getUpdateSpotMarketBorrowRateIx(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate, minBorrowRate) {
+        return await this.program.instruction.updateSpotMarketBorrowRate(optimalUtilization, optimalBorrowRate, optimalMaxRate, minBorrowRate, {
             accounts: {
                 admin: this.isSubscribed
                     ? this.getStateAccount().admin

package/lib/blockhashSubscriber/BlockhashSubscriber.d.ts

@@ -13,7 +13,13 @@ export declare class BlockhashSubscriber {
     getBlockhashCacheSize(): number;
     getLatestBlockHeight(): number;
     getLatestBlockHeightContext(): Context | undefined;
-    getLatestBlockhash(offset?: number): BlockhashWithExpiryBlockHeight | undefined;
+    /**
+     * Returns the latest cached blockhash, based on an offset from the latest obtained
+     * @param offset Offset to use, defaulting to 0
+     * @param offsetType If 'seconds', it will use calculate the actual element offset based on the update interval; otherwise it will return a fixed index
+     * @returns Cached blockhash at the given offset, or undefined
+     */
+    getLatestBlockhash(offset?: number, offsetType?: 'index' | 'seconds'): BlockhashWithExpiryBlockHeight | undefined;
     pruneBlockhashes(): void;
     updateBlockhash(): Promise<void>;
     subscribe(): Promise<void>;

package/lib/blockhashSubscriber/BlockhashSubscriber.js

@@ -23,11 +23,20 @@ class BlockhashSubscriber {
     getLatestBlockHeightContext() {
         return this.latestBlockHeightContext;
     }
-    getLatestBlockhash(offset) {
+    /**
+     * Returns the latest cached blockhash, based on an offset from the latest obtained
+     * @param offset Offset to use, defaulting to 0
+     * @param offsetType If 'seconds', it will use calculate the actual element offset based on the update interval; otherwise it will return a fixed index
+     * @returns Cached blockhash at the given offset, or undefined
+     */
+    getLatestBlockhash(offset = 0, offsetType = 'index') {
         if (this.blockhashes.length === 0) {
             return undefined;
         }
-        const clampedOffset = Math.max(0, Math.min(this.blockhashes.length - 1, offset !== null && offset !== void 0 ? offset : 0));
+        const elementOffset = offsetType == 'seconds'
+            ? Math.floor((offset * 1000) / this.updateIntervalMs)
+            : offset;
+        const clampedOffset = Math.max(0, Math.min(this.blockhashes.length - 1, elementOffset));
         return this.blockhashes[this.blockhashes.length - 1 - clampedOffset];
     }
     pruneBlockhashes() {

package/lib/driftClient.d.ts

@@ -99,7 +99,9 @@ export declare class DriftClient {
     getQuoteSpotMarketAccount(): SpotMarketAccount;
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
     getSerumV3FulfillmentConfig(serumMarket: PublicKey): Promise<SerumV3FulfillmentConfigAccount>;
+    getSerumV3FulfillmentConfigs(): Promise<SerumV3FulfillmentConfigAccount[]>;
     getPhoenixV1FulfillmentConfig(phoenixMarket: PublicKey): Promise<PhoenixV1FulfillmentConfigAccount>;
+    getPhoenixV1FulfillmentConfigs(): Promise<PhoenixV1FulfillmentConfigAccount[]>;
     fetchMarketLookupTableAccount(): Promise<AddressLookupTableAccount>;
     /**
      * Update the wallet to use for drift transactions and linked user account

package/lib/driftClient.js

@@ -304,10 +304,18 @@ class DriftClient {
         const address = await (0, pda_1.getSerumFulfillmentConfigPublicKey)(this.program.programId, serumMarket);
         return (await this.program.account.serumV3FulfillmentConfig.fetch(address));
     }
+    async getSerumV3FulfillmentConfigs() {
+        const accounts = await this.program.account.serumV3FulfillmentConfig.all();
+        return accounts.map((account) => account.account);
+    }
     async getPhoenixV1FulfillmentConfig(phoenixMarket) {
         const address = await (0, pda_1.getPhoenixFulfillmentConfigPublicKey)(this.program.programId, phoenixMarket);
         return (await this.program.account.phoenixV1FulfillmentConfig.fetch(address));
     }
+    async getPhoenixV1FulfillmentConfigs() {
+        const accounts = await this.program.account.phoenixV1FulfillmentConfig.all();
+        return accounts.map((account) => account.account);
+    }
     async fetchMarketLookupTableAccount() {
         if (this.lookupTableAccount)
             return this.lookupTableAccount;

package/lib/math/spotBalance.js

@@ -237,6 +237,12 @@ function calculateSpotMarketBorrowCapacity(spotMarketAccount, targetBorrowRate)
     else {
         remainingCapacity = anchor_1.BN.max(numericConstants_1.ZERO, totalCapacity.sub(tokenBorrowAmount));
     }
+    if (spotMarketAccount.maxTokenBorrowsFraction > 0) {
+        const maxTokenBorrows = spotMarketAccount.maxTokenDeposits
+            .mul(new anchor_1.BN(spotMarketAccount.maxTokenBorrowsFraction))
+            .divn(10000);
+        remainingCapacity = anchor_1.BN.min(remainingCapacity, anchor_1.BN.max(numericConstants_1.ZERO, maxTokenBorrows.sub(tokenBorrowAmount)));
+    }
     return { totalCapacity, remainingCapacity };
 }
 exports.calculateSpotMarketBorrowCapacity = calculateSpotMarketBorrowCapacity;
@@ -260,7 +266,7 @@ function calculateInterestRate(bank, delta = numericConstants_1.ZERO) {
             .mul(borrowRateSlope)
             .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
     }
-    return interestRate;
+    return anchor_1.BN.max(interestRate, new anchor_1.BN(bank.minBorrowRate).mul(numericConstants_2.PERCENTAGE_PRECISION.divn(200)));
 }
 exports.calculateInterestRate = calculateInterestRate;
 function calculateDepositRate(bank, delta = numericConstants_1.ZERO) {

package/lib/types.d.ts

@@ -810,6 +810,8 @@ export type SpotMarketAccount = {
     ordersEnabled: boolean;
     pausedOperations: number;
     ifPausedOperations: number;
+    maxTokenBorrowsFraction: number;
+    minBorrowRate: number;
 };
 export type PoolBalance = {
     scaledBalance: BN;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.84.0-beta.6",
+	"version": "2.84.0-beta.7",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -39,8 +39,9 @@
 		"@project-serum/serum": "^0.13.38",
 		"@pythnetwork/client": "2.5.3",
 		"@pythnetwork/pyth-solana-receiver": "^0.7.0",
-		"@solana/spl-token": "^0.3.7",
+		"@solana/spl-token": "0.3.7",
 		"@solana/web3.js": "1.92.3",
+		"rpc-websockets": "7.5.1",
 		"strict-event-emitter-types": "^2.0.0",
 		"uuid": "^8.3.2",
 		"zstddec": "^0.1.0"
@@ -51,17 +52,17 @@
 		"@types/chai": "^4.3.1",
 		"@types/jest": "^28.1.3",
 		"@types/mocha": "^9.1.1",
-		"@typescript-eslint/eslint-plugin": "^4.28.0",
-		"@typescript-eslint/parser": "^4.28.0",
+		"@typescript-eslint/eslint-plugin": "4.28.0",
+		"@typescript-eslint/parser": "4.28.0",
 		"chai": "^4.3.6",
 		"encoding": "^0.1.13",
-		"eslint": "^7.29.0",
-		"eslint-config-prettier": "^8.3.0",
-		"eslint-plugin-prettier": "^3.4.0",
+		"eslint": "7.29.0",
+		"eslint-config-prettier": "8.3.0",
+		"eslint-plugin-prettier": "3.4.0",
 		"lodash": "^4.17.21",
 		"mocha": "^10.0.0",
 		"object-sizeof": "^2.6.3",
-		"prettier": "^3.0.1",
+		"prettier": "3.0.1",
 		"ts-node": "^10.8.0",
 		"typescript": "^4.9.5"
 	},

package/src/adminClient.ts

@@ -1812,6 +1812,44 @@ export class AdminClient extends DriftClient {
 		);
 	}
 
+	public async updateSpotMarketMaxTokenBorrows(
+		spotMarketIndex: number,
+		maxTokenBorrows: BN
+	): Promise<TransactionSignature> {
+		const updateSpotMarketMaxTokenBorrowsIx =
+			await this.getUpdateSpotMarketMaxTokenBorrowsIx(
+				spotMarketIndex,
+				maxTokenBorrows
+			);
+
+		const tx = await this.buildTransaction(updateSpotMarketMaxTokenBorrowsIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async getUpdateSpotMarketMaxTokenBorrowsIx(
+		spotMarketIndex: number,
+		maxTokenBorrows: BN
+	): Promise<TransactionInstruction> {
+		return this.program.instruction.updateSpotMarketMaxTokenBorrows(
+			maxTokenBorrows,
+			{
+				accounts: {
+					admin: this.isSubscribed
+						? this.getStateAccount().admin
+						: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					spotMarket: await getSpotMarketPublicKey(
+						this.program.programId,
+						spotMarketIndex
+					),
+				},
+			}
+		);
+	}
+
 	public async updateSpotMarketScaleInitialAssetWeightStart(
 		spotMarketIndex: number,
 		scaleInitialAssetWeightStart: BN
@@ -2506,14 +2544,16 @@ export class AdminClient extends DriftClient {
 		spotMarketIndex: number,
 		optimalUtilization: number,
 		optimalBorrowRate: number,
-		optimalMaxRate: number
+		optimalMaxRate: number,
+		minBorrowRate?: number | undefined
 	): Promise<TransactionSignature> {
 		const updateSpotMarketBorrowRateIx =
 			await this.getUpdateSpotMarketBorrowRateIx(
 				spotMarketIndex,
 				optimalUtilization,
 				optimalBorrowRate,
-				optimalMaxRate
+				optimalMaxRate,
+				minBorrowRate
 			);
 
 		const tx = await this.buildTransaction(updateSpotMarketBorrowRateIx);
@@ -2527,12 +2567,14 @@ export class AdminClient extends DriftClient {
 		spotMarketIndex: number,
 		optimalUtilization: number,
 		optimalBorrowRate: number,
-		optimalMaxRate: number
+		optimalMaxRate: number,
+		minBorrowRate?: number | undefined
 	): Promise<TransactionInstruction> {
 		return await this.program.instruction.updateSpotMarketBorrowRate(
 			optimalUtilization,
 			optimalBorrowRate,
 			optimalMaxRate,
+			minBorrowRate,
 			{
 				accounts: {
 					admin: this.isSubscribed

package/src/blockhashSubscriber/BlockhashSubscriber.ts

@@ -39,15 +39,28 @@ export class BlockhashSubscriber {
 		return this.latestBlockHeightContext;
 	}
 
+	/**
+	 * Returns the latest cached blockhash, based on an offset from the latest obtained
+	 * @param offset Offset to use, defaulting to 0
+	 * @param offsetType If 'seconds', it will use calculate the actual element offset based on the update interval; otherwise it will return a fixed index
+	 * @returns Cached blockhash at the given offset, or undefined
+	 */
 	getLatestBlockhash(
-		offset?: number
+		offset = 0,
+		offsetType: 'index' | 'seconds' = 'index'
 	): BlockhashWithExpiryBlockHeight | undefined {
 		if (this.blockhashes.length === 0) {
 			return undefined;
 		}
+
+		const elementOffset =
+			offsetType == 'seconds'
+				? Math.floor((offset * 1000) / this.updateIntervalMs)
+				: offset;
+
 		const clampedOffset = Math.max(
 			0,
-			Math.min(this.blockhashes.length - 1, offset ?? 0)
+			Math.min(this.blockhashes.length - 1, elementOffset)
 		);
 
 		return this.blockhashes[this.blockhashes.length - 1 - clampedOffset];

package/src/driftClient.ts

@@ -524,6 +524,15 @@ export class DriftClient {
 		)) as SerumV3FulfillmentConfigAccount;
 	}
 
+	public async getSerumV3FulfillmentConfigs(): Promise<
+		SerumV3FulfillmentConfigAccount[]
+	> {
+		const accounts = await this.program.account.serumV3FulfillmentConfig.all();
+		return accounts.map(
+			(account) => account.account
+		) as SerumV3FulfillmentConfigAccount[];
+	}
+
 	public async getPhoenixV1FulfillmentConfig(
 		phoenixMarket: PublicKey
 	): Promise<PhoenixV1FulfillmentConfigAccount> {
@@ -536,6 +545,16 @@ export class DriftClient {
 		)) as PhoenixV1FulfillmentConfigAccount;
 	}
 
+	public async getPhoenixV1FulfillmentConfigs(): Promise<
+		PhoenixV1FulfillmentConfigAccount[]
+	> {
+		const accounts =
+			await this.program.account.phoenixV1FulfillmentConfig.all();
+		return accounts.map(
+			(account) => account.account
+		) as PhoenixV1FulfillmentConfigAccount[];
+	}
+
 	public async fetchMarketLookupTableAccount(): Promise<AddressLookupTableAccount> {
 		if (this.lookupTableAccount) return this.lookupTableAccount;
 

package/src/math/spotBalance.ts

@@ -363,6 +363,17 @@ export function calculateSpotMarketBorrowCapacity(
 		remainingCapacity = BN.max(ZERO, totalCapacity.sub(tokenBorrowAmount));
 	}
 
+	if (spotMarketAccount.maxTokenBorrowsFraction > 0) {
+		const maxTokenBorrows = spotMarketAccount.maxTokenDeposits
+			.mul(new BN(spotMarketAccount.maxTokenBorrowsFraction))
+			.divn(10000);
+
+		remainingCapacity = BN.min(
+			remainingCapacity,
+			BN.max(ZERO, maxTokenBorrows.sub(tokenBorrowAmount))
+		);
+	}
+
 	return { totalCapacity, remainingCapacity };
 }
 
@@ -395,7 +406,10 @@ export function calculateInterestRate(
 			.div(SPOT_MARKET_UTILIZATION_PRECISION);
 	}
 
-	return interestRate;
+	return BN.max(
+		interestRate,
+		new BN(bank.minBorrowRate).mul(PERCENTAGE_PRECISION.divn(200))
+	);
 }
 
 export function calculateDepositRate(

package/src/types.ts

@@ -731,6 +731,9 @@ export type SpotMarketAccount = {
 	pausedOperations: number;
 
 	ifPausedOperations: number;
+
+	maxTokenBorrowsFraction: number;
+	minBorrowRate: number;
 };
 
 export type PoolBalance = {