@drift-labs/sdk 2.31.1-beta.14 → 2.31.1-beta.16

package/VERSION

@@ -1 +1 @@
-2.31.1-beta.14
+2.31.1-beta.16

package/lib/driftClient.d.ts

@@ -205,7 +205,11 @@ export declare class DriftClient {
     deposit(amount: BN, marketIndex: number, associatedTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean): Promise<TransactionSignature>;
     getDepositInstruction(amount: BN, marketIndex: number, userTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean, userInitialized?: boolean): Promise<TransactionInstruction>;
     private checkIfAccountExists;
-    private getWrappedSolAccountCreationIxs;
+    getWrappedSolAccountCreationIxs(amount: BN, includeRent?: boolean): Promise<{
+        ixs: anchor.web3.TransactionInstruction[];
+        signers: Signer[];
+        pubkey: PublicKey;
+    }>;
     getAssociatedTokenAccountCreationIx(tokenMintAddress: PublicKey, associatedTokenAddress: PublicKey): anchor.web3.TransactionInstruction;
     /**
      * Creates the User account for a user, and deposits some initial collateral

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.31.1-beta.13",
+    "version": "2.31.1-beta.15",
     "name": "drift",
     "instructions": [
         {

package/lib/math/spotBalance.d.ts

@@ -50,6 +50,13 @@ export declare function getTokenValue(tokenAmount: BN, spotDecimals: number, ora
 export declare function calculateAssetWeight(balanceAmount: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
 export declare function calculateLiabilityWeight(size: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
 export declare function calculateUtilization(bank: SpotMarketAccount): BN;
+/**
+ * calculates max borrow amount where rate would stay below targetBorrowRate
+ * @param spotMarketAccount
+ * @param targetBorrowRate
+ * @returns : Precision: TOKEN DECIMALS
+ */
+export declare function calculateSpotMarketBorrowCapacity(spotMarketAccount: SpotMarketAccount, targetBorrowRate: BN): BN;
 export declare function calculateInterestRate(bank: SpotMarketAccount): BN;
 export declare function calculateDepositRate(bank: SpotMarketAccount): BN;
 export declare function calculateBorrowRate(bank: SpotMarketAccount): BN;

package/lib/math/spotBalance.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateWithdrawLimit = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateAssetWeight = exports.getTokenValue = exports.getStrictTokenValue = exports.getSignedTokenAmount = exports.getTokenAmount = exports.getBalance = void 0;
+exports.calculateWithdrawLimit = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateSpotMarketBorrowCapacity = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateAssetWeight = exports.getTokenValue = exports.getStrictTokenValue = exports.getSignedTokenAmount = exports.getTokenAmount = exports.getBalance = void 0;
 const types_1 = require("../types");
 const anchor_1 = require("@coral-xyz/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
@@ -174,6 +174,48 @@ function calculateUtilization(bank) {
     return utilization;
 }
 exports.calculateUtilization = calculateUtilization;
+/**
+ * calculates max borrow amount where rate would stay below targetBorrowRate
+ * @param spotMarketAccount
+ * @param targetBorrowRate
+ * @returns : Precision: TOKEN DECIMALS
+ */
+function calculateSpotMarketBorrowCapacity(spotMarketAccount, targetBorrowRate) {
+    const currentBorrowRate = calculateBorrowRate(spotMarketAccount);
+    if (currentBorrowRate.gte(targetBorrowRate)) {
+        return numericConstants_1.ZERO;
+    }
+    else {
+        const tokenDepositAmount = getTokenAmount(spotMarketAccount.depositBalance, spotMarketAccount, types_1.SpotBalanceType.DEPOSIT);
+        const tokenBorrowAmount = getTokenAmount(spotMarketAccount.borrowBalance, spotMarketAccount, types_1.SpotBalanceType.BORROW);
+        let targetUtilization;
+        // target utilization past mid point
+        if (targetBorrowRate.gte(new anchor_1.BN(spotMarketAccount.optimalBorrowRate))) {
+            const borrowRateSlope = new anchor_1.BN(spotMarketAccount.maxBorrowRate - spotMarketAccount.optimalBorrowRate)
+                .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+                .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(new anchor_1.BN(spotMarketAccount.optimalUtilization)));
+            const surplusTargetUtilization = targetBorrowRate
+                .sub(new anchor_1.BN(spotMarketAccount.optimalBorrowRate))
+                .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+                .div(borrowRateSlope);
+            targetUtilization = surplusTargetUtilization.add(new anchor_1.BN(spotMarketAccount.optimalUtilization));
+        }
+        else {
+            const borrowRateSlope = new anchor_1.BN(spotMarketAccount.optimalBorrowRate)
+                .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+                .div(new anchor_1.BN(spotMarketAccount.optimalUtilization));
+            targetUtilization = targetBorrowRate
+                .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+                .div(borrowRateSlope);
+        }
+        const targetBorrowAmount = tokenDepositAmount
+            .mul(targetUtilization)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+        const capacity = anchor_1.BN.max(numericConstants_1.ZERO, targetBorrowAmount.sub(tokenBorrowAmount));
+        return capacity;
+    }
+}
+exports.calculateSpotMarketBorrowCapacity = calculateSpotMarketBorrowCapacity;
 function calculateInterestRate(bank) {
     const utilization = calculateUtilization(bank);
     let interestRate;

package/package.json

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

package/src/driftClient.ts

@@ -1672,7 +1672,7 @@ export class DriftClient {
 		}
 	}
 
-	private async getWrappedSolAccountCreationIxs(
+	public async getWrappedSolAccountCreationIxs(
 		amount: BN,
 		includeRent?: boolean
 	): Promise<{

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.31.1-beta.14",
+  "version": "2.31.1-beta.16",
   "name": "drift",
   "instructions": [
     {

package/src/math/spotBalance.ts

@@ -262,6 +262,73 @@ export function calculateUtilization(bank: SpotMarketAccount): BN {
 	return utilization;
 }
 
+/**
+ * calculates max borrow amount where rate would stay below targetBorrowRate
+ * @param spotMarketAccount
+ * @param targetBorrowRate
+ * @returns : Precision: TOKEN DECIMALS
+ */
+export function calculateSpotMarketBorrowCapacity(
+	spotMarketAccount: SpotMarketAccount,
+	targetBorrowRate: BN
+): BN {
+	const currentBorrowRate = calculateBorrowRate(spotMarketAccount);
+
+	if (currentBorrowRate.gte(targetBorrowRate)) {
+		return ZERO;
+	} else {
+		const tokenDepositAmount = getTokenAmount(
+			spotMarketAccount.depositBalance,
+			spotMarketAccount,
+			SpotBalanceType.DEPOSIT
+		);
+		const tokenBorrowAmount = getTokenAmount(
+			spotMarketAccount.borrowBalance,
+			spotMarketAccount,
+			SpotBalanceType.BORROW
+		);
+
+		let targetUtilization;
+
+		// target utilization past mid point
+		if (targetBorrowRate.gte(new BN(spotMarketAccount.optimalBorrowRate))) {
+			const borrowRateSlope = new BN(
+				spotMarketAccount.maxBorrowRate - spotMarketAccount.optimalBorrowRate
+			)
+				.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+				.div(
+					SPOT_MARKET_UTILIZATION_PRECISION.sub(
+						new BN(spotMarketAccount.optimalUtilization)
+					)
+				);
+
+			const surplusTargetUtilization = targetBorrowRate
+				.sub(new BN(spotMarketAccount.optimalBorrowRate))
+				.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+				.div(borrowRateSlope);
+
+			targetUtilization = surplusTargetUtilization.add(
+				new BN(spotMarketAccount.optimalUtilization)
+			);
+		} else {
+			const borrowRateSlope = new BN(spotMarketAccount.optimalBorrowRate)
+				.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+				.div(new BN(spotMarketAccount.optimalUtilization));
+
+			targetUtilization = targetBorrowRate
+				.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+				.div(borrowRateSlope);
+		}
+
+		const targetBorrowAmount = tokenDepositAmount
+			.mul(targetUtilization)
+			.div(SPOT_MARKET_UTILIZATION_PRECISION);
+		const capacity = BN.max(ZERO, targetBorrowAmount.sub(tokenBorrowAmount));
+
+		return capacity;
+	}
+}
+
 export function calculateInterestRate(bank: SpotMarketAccount): BN {
 	const utilization = calculateUtilization(bank);
 

package/tests/spot/test.ts

@@ -0,0 +1,102 @@
+import { BN, ZERO, calculateSpotMarketBorrowCapacity } from '../../src';
+import { mockSpotMarkets } from '../dlob/helpers';
+
+import { assert } from '../../src/assert/assert';
+import { SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION } from '@drift-labs/sdk';
+
+describe('Spot Tests', () => {
+	it('base borrow capacity', () => {
+        const mockSpot = mockSpotMarkets[0];
+        mockSpot.maxBorrowRate = 1000000;
+        mockSpot.optimalBorrowRate = 100000;
+        mockSpot.optimalUtilization = 700000;
+
+        mockSpot.decimals = 9;
+        mockSpot.cumulativeDepositInterest = SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION;
+        mockSpot.cumulativeBorrowInterest = SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION;
+
+        const tokenAmount = 100000;
+        // no borrows
+        mockSpot.depositBalance = new BN(tokenAmount * 1e9);
+        mockSpot.borrowBalance = ZERO; 
+
+        // todo, should incorp all other spot market constraints?
+        const aboveMaxAmount = calculateSpotMarketBorrowCapacity(mockSpot, new BN(2000000));
+        assert(aboveMaxAmount.gt(mockSpot.depositBalance));
+
+        const maxAmount = calculateSpotMarketBorrowCapacity(mockSpot, new BN(1000000));
+        assert(maxAmount.eq(mockSpot.depositBalance));
+
+        const optAmount = calculateSpotMarketBorrowCapacity(mockSpot, new BN(100000));
+        const ans = new BN(mockSpot.depositBalance.toNumber() * 7 / 10);
+        // console.log('optAmount:', optAmount.toNumber(), ans.toNumber());
+        assert(optAmount.eq(ans));
+
+        const betweenOptMaxAmount = calculateSpotMarketBorrowCapacity(mockSpot, new BN(810000));
+        // console.log('betweenOptMaxAmount:', betweenOptMaxAmount.toNumber());
+        assert(betweenOptMaxAmount.lt(mockSpot.depositBalance));
+        assert(betweenOptMaxAmount.gt(ans));
+        assert(betweenOptMaxAmount.eq(new BN(93666600000000)));
+
+        const belowOptAmount = calculateSpotMarketBorrowCapacity(mockSpot, new BN(50000));
+        // console.log('belowOptAmount:', belowOptAmount.toNumber());
+        assert(belowOptAmount.eq(ans.div(new BN(2))));
+
+        const belowOptAmount2 = calculateSpotMarketBorrowCapacity(mockSpot, new BN(24900));
+        // console.log('belowOptAmount2:', belowOptAmount2.toNumber());
+        assert(belowOptAmount2.lt(ans.div(new BN(4))));
+        assert(belowOptAmount2.eq(new BN('17430000000000')));
+
+        const belowOptAmount3 = calculateSpotMarketBorrowCapacity(mockSpot, new BN(1));
+        // console.log('belowOptAmount3:', belowOptAmount3.toNumber());
+        assert(belowOptAmount3.eq(new BN('700000000'))); //0.7
+    });
+
+
+    it('complex borrow capacity', () => {
+        const mockSpot = mockSpotMarkets[0];
+        mockSpot.maxBorrowRate = 1000000;
+        mockSpot.optimalBorrowRate =  70000;
+        mockSpot.optimalUtilization = 700000;
+
+        mockSpot.decimals = 9;
+        mockSpot.cumulativeDepositInterest = new BN(1.0154217042 * SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION.toNumber());
+        mockSpot.cumulativeBorrowInterest = new BN(1.0417153549 * SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION.toNumber());
+
+        mockSpot.depositBalance = new BN(88522.734106451 * 1e9);
+        mockSpot.borrowBalance = new BN(7089.91675884 * 1e9);
+
+        // todo, should incorp all other spot market constraints?
+        const aboveMaxAmount = calculateSpotMarketBorrowCapacity(mockSpot, new BN(2000000));
+        assert(aboveMaxAmount.eq(new BN('111498270939007')));
+
+        const maxAmount = calculateSpotMarketBorrowCapacity(mockSpot, new BN(1000000));
+        assert(maxAmount.eq(new BN('82502230374168')));
+        // console.log('aboveMaxAmount:', aboveMaxAmount.toNumber(), 'maxAmount:', maxAmount.toNumber());
+        const optAmount = calculateSpotMarketBorrowCapacity(mockSpot, new BN(70000));
+        // console.log('optAmount:', optAmount.toNumber());
+        assert(optAmount.eq(new BN('55535858716123'))); // ~ 55535
+
+        const betweenOptMaxAmount = calculateSpotMarketBorrowCapacity(mockSpot, new BN(810000));
+        // console.log('betweenOptMaxAmount:', betweenOptMaxAmount.toNumber());
+        assert(betweenOptMaxAmount.lt(maxAmount));
+        assert(betweenOptMaxAmount.eq(new BN(76992910756523)));
+        assert(betweenOptMaxAmount.gt(optAmount));
+
+        const belowOptAmount = calculateSpotMarketBorrowCapacity(mockSpot, new BN(50000));
+        // console.log('belowOptAmount:', belowOptAmount.toNumber());
+        assert(belowOptAmount.eq(new BN('37558277610760')));
+
+        const belowOptAmount2 = calculateSpotMarketBorrowCapacity(mockSpot, new BN(24900));
+        // console.log('belowOptAmount2:', belowOptAmount2.toNumber());
+        assert(belowOptAmount2.eq(new BN('14996413323529')));
+
+        const belowOptAmount3 = calculateSpotMarketBorrowCapacity(mockSpot, new BN(4900));
+        // console.log('belowOptAmount2:', belowOptAmount3.toNumber());
+        assert(belowOptAmount3.eq(new BN('0')));
+
+        const belowOptAmount4 = calculateSpotMarketBorrowCapacity(mockSpot, new BN(1));
+        // console.log('belowOptAmount3:', belowOptAmount4.toNumber());
+        assert(belowOptAmount4.eq(new BN('0')));
+    });
+});