@drift-labs/sdk 2.96.0-beta.8 → 2.96.0-beta.9

package/VERSION

@@ -1 +1 @@
-2.96.0-beta.8
+2.96.0-beta.9

package/lib/driftClient.d.ts

@@ -239,6 +239,7 @@ export declare class DriftClient {
      */
     getAssociatedTokenAccount(marketIndex: number, useNative?: boolean, tokenProgram?: anchor.web3.PublicKey): Promise<PublicKey>;
     createAssociatedTokenAccountIdempotentInstruction(account: PublicKey, payer: PublicKey, owner: PublicKey, mint: PublicKey, tokenProgram?: anchor.web3.PublicKey): TransactionInstruction;
+    getDepositTxnIx(amount: BN, marketIndex: number, associatedTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean): Promise<TransactionInstruction[]>;
     createDepositTxn(amount: BN, marketIndex: number, associatedTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean, txParams?: TxParams): Promise<VersionedTransaction | Transaction>;
     /**
      * Deposit funds into the given spot market
@@ -261,6 +262,10 @@ export declare class DriftClient {
     getTokenProgramForSpotMarket(spotMarketAccount: SpotMarketAccount): PublicKey;
     addTokenMintToRemainingAccounts(spotMarketAccount: SpotMarketAccount, remainingAccounts: AccountMeta[]): void;
     getAssociatedTokenAccountCreationIx(tokenMintAddress: PublicKey, associatedTokenAddress: PublicKey, tokenProgram: PublicKey): anchor.web3.TransactionInstruction;
+    createInitializeUserAccountAndDepositCollateralIxs(amount: BN, userTokenAccount: PublicKey, marketIndex?: number, subAccountId?: number, name?: string, fromSubAccountId?: number, referrerInfo?: ReferrerInfo, donateAmount?: BN, customMaxMarginRatio?: number): Promise<{
+        ixs: TransactionInstruction[];
+        userAccountPublicKey: PublicKey;
+    }>;
     createInitializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, marketIndex?: number, subAccountId?: number, name?: string, fromSubAccountId?: number, referrerInfo?: ReferrerInfo, donateAmount?: BN, txParams?: TxParams, customMaxMarginRatio?: number): Promise<[Transaction | VersionedTransaction, PublicKey]>;
     /**
      * Creates the User account for a user, and deposits some initial collateral
@@ -340,7 +345,10 @@ export declare class DriftClient {
         signedSettlePnlTx?: Transaction;
     }>;
     placePerpOrder(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
-    getPlacePerpOrderIx(orderParams: OptionalOrderParams, subAccountId?: number): Promise<TransactionInstruction>;
+    getPlacePerpOrderIx(orderParams: OptionalOrderParams, subAccountId?: number, depositToTradeArgs?: {
+        isMakingNewAccount: boolean;
+        depositMarketIndex: number;
+    }): Promise<TransactionInstruction>;
     updateAMMs(marketIndexes: number[], txParams?: TxParams): Promise<TransactionSignature>;
     getUpdateAMMsIx(marketIndexes: number[]): Promise<TransactionInstruction>;
     settleExpiredMarket(marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;

package/lib/driftClient.js

@@ -1118,7 +1118,7 @@ class DriftClient {
             data: Buffer.from([0x1]),
         });
     }
-    async createDepositTxn(amount, marketIndex, associatedTokenAccount, subAccountId, reduceOnly = false, txParams) {
+    async getDepositTxnIx(amount, marketIndex, associatedTokenAccount, subAccountId, reduceOnly = false) {
         const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
         const isSolMarket = spotMarketAccount.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
         const signerAuthority = this.wallet.publicKey;
@@ -1135,6 +1135,10 @@ class DriftClient {
         if (createWSOLTokenAccount) {
             instructions.push((0, spl_token_1.createCloseAccountInstruction)(associatedTokenAccount, signerAuthority, signerAuthority, []));
         }
+        return instructions;
+    }
+    async createDepositTxn(amount, marketIndex, associatedTokenAccount, subAccountId, reduceOnly = false, txParams) {
+        const instructions = await this.getDepositTxnIx(amount, marketIndex, associatedTokenAccount, subAccountId, reduceOnly);
         txParams = { ...(txParams !== null && txParams !== void 0 ? txParams : this.txParams), computeUnits: 600000 };
         const tx = await this.buildTransaction(instructions, txParams);
         return tx;
@@ -1242,7 +1246,7 @@ class DriftClient {
     getAssociatedTokenAccountCreationIx(tokenMintAddress, associatedTokenAddress, tokenProgram) {
         return (0, spl_token_1.createAssociatedTokenAccountInstruction)(this.wallet.publicKey, associatedTokenAddress, this.wallet.publicKey, tokenMintAddress, tokenProgram);
     }
-    async createInitializeUserAccountAndDepositCollateral(amount, userTokenAccount, marketIndex = 0, subAccountId = 0, name, fromSubAccountId, referrerInfo, donateAmount, txParams, customMaxMarginRatio) {
+    async createInitializeUserAccountAndDepositCollateralIxs(amount, userTokenAccount, marketIndex = 0, subAccountId = 0, name, fromSubAccountId, referrerInfo, donateAmount, customMaxMarginRatio) {
         const ixs = [];
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(subAccountId, name, referrerInfo);
         const spotMarket = this.getSpotMarketAccount(marketIndex);
@@ -1288,6 +1292,13 @@ class DriftClient {
         if (createWSOLTokenAccount) {
             ixs.push((0, spl_token_1.createCloseAccountInstruction)(wsolTokenAccount, authority, authority, []));
         }
+        return {
+            ixs,
+            userAccountPublicKey,
+        };
+    }
+    async createInitializeUserAccountAndDepositCollateral(amount, userTokenAccount, marketIndex = 0, subAccountId = 0, name, fromSubAccountId, referrerInfo, donateAmount, txParams, customMaxMarginRatio) {
+        const { ixs, userAccountPublicKey } = await this.createInitializeUserAccountAndDepositCollateralIxs(amount, userTokenAccount, marketIndex, subAccountId, name, fromSubAccountId, referrerInfo, donateAmount, customMaxMarginRatio);
         const tx = await this.buildTransaction(ixs, txParams);
         return [tx, userAccountPublicKey];
     }
@@ -1663,13 +1674,21 @@ class DriftClient {
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    async getPlacePerpOrderIx(orderParams, subAccountId) {
+    async getPlacePerpOrderIx(orderParams, subAccountId, depositToTradeArgs) {
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
-        const user = await this.getUserAccountPublicKey(subAccountId);
+        const isDepositToTradeTx = depositToTradeArgs !== undefined;
+        const user = isDepositToTradeTx
+            ? (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.authority, subAccountId)
+            : await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount(subAccountId)],
-            useMarketLastSlotCache: true,
+            userAccounts: (depositToTradeArgs === null || depositToTradeArgs === void 0 ? void 0 : depositToTradeArgs.isMakingNewAccount)
+                ? []
+                : [this.getUserAccount(subAccountId)],
+            useMarketLastSlotCache: false,
             readablePerpMarketIndex: orderParams.marketIndex,
+            readableSpotMarketIndexes: isDepositToTradeTx
+                ? [depositToTradeArgs === null || depositToTradeArgs === void 0 ? void 0 : depositToTradeArgs.depositMarketIndex]
+                : undefined,
         });
         return await this.program.instruction.placePerpOrder(orderParams, {
             accounts: {

package/lib/math/margin.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import { BN } from '@coral-xyz/anchor';
 import { OraclePriceData } from '../oracles/types';
-import { PerpMarketAccount, PerpPosition } from '..';
+import { DriftClient, PerpMarketAccount, PerpPosition } from '..';
 export declare function calculateSizePremiumLiabilityWeight(size: BN, // AMM_RESERVE_PRECISION
 imfFactor: BN, liabilityWeight: BN, precision: BN): BN;
 export declare function calculateSizeDiscountAssetWeight(size: BN, // AMM_RESERVE_PRECISION
@@ -22,3 +22,18 @@ export declare function calculateWorstCasePerpLiabilityValue(perpPosition: PerpP
     worstCaseLiabilityValue: BN;
 };
 export declare function calculatePerpLiabilityValue(baseAssetAmount: BN, oraclePrice: BN, isPredictionMarket: boolean): BN;
+/**
+ * Calculates the margin required to open a trade, in quote amount. Only accounts for the trade size as a scalar value, does not account for the trade direction or current open positions and whether the trade would _actually_ be risk-increasing and use any extra collateral.
+ * @param targetMarketIndex
+ * @param baseSize
+ * @returns
+ */
+export declare function calculateMarginUSDCRequiredForTrade(driftClient: DriftClient, targetMarketIndex: number, baseSize: BN, userMaxMarginRatio?: number): BN;
+/**
+ * Similar to calculatetMarginUSDCRequiredForTrade, but calculates how much of a given collateral is required to cover the margin requirements for a given trade. Basically does the same thing as getMarginUSDCRequiredForTrade but also accounts for asset weight of the selected collateral.
+ *
+ * Returns collateral required in the precision of the target collateral market.
+ */
+export declare function calculateCollateralDepositRequiredForTrade(driftClient: DriftClient, targetMarketIndex: number, baseSize: BN, collateralIndex: number, userMaxMarginRatio?: number): BN;
+export declare function calculateCollateralValueOfDeposit(driftClient: DriftClient, collateralIndex: number, baseSize: BN): BN;
+export declare function calculateLiquidationPrice(freeCollateral: BN, freeCollateralDelta: BN, oraclePrice: BN): BN;

package/lib/math/margin.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculatePerpLiabilityValue = exports.calculateWorstCasePerpLiabilityValue = exports.calculateWorstCaseBaseAssetAmount = exports.calculateBaseAssetValueWithOracle = exports.calculateOraclePriceForPerpMargin = exports.calculateSizeDiscountAssetWeight = exports.calculateSizePremiumLiabilityWeight = void 0;
+exports.calculateLiquidationPrice = exports.calculateCollateralValueOfDeposit = exports.calculateCollateralDepositRequiredForTrade = exports.calculateMarginUSDCRequiredForTrade = exports.calculatePerpLiabilityValue = exports.calculateWorstCasePerpLiabilityValue = exports.calculateWorstCaseBaseAssetAmount = exports.calculateBaseAssetValueWithOracle = exports.calculateOraclePriceForPerpMargin = exports.calculateSizeDiscountAssetWeight = exports.calculateSizePremiumLiabilityWeight = void 0;
 const utils_1 = require("./utils");
 const numericConstants_1 = require("../constants/numericConstants");
 const anchor_1 = require("@coral-xyz/anchor");
+const __1 = require("..");
 const types_1 = require("../types");
 const assert_1 = require("../assert/assert");
 function calculateSizePremiumLiabilityWeight(size, // AMM_RESERVE_PRECISION
@@ -116,3 +117,68 @@ function calculatePerpLiabilityValue(baseAssetAmount, oraclePrice, isPredictionM
     }
 }
 exports.calculatePerpLiabilityValue = calculatePerpLiabilityValue;
+/**
+ * Calculates the margin required to open a trade, in quote amount. Only accounts for the trade size as a scalar value, does not account for the trade direction or current open positions and whether the trade would _actually_ be risk-increasing and use any extra collateral.
+ * @param targetMarketIndex
+ * @param baseSize
+ * @returns
+ */
+function calculateMarginUSDCRequiredForTrade(driftClient, targetMarketIndex, baseSize, userMaxMarginRatio) {
+    const targetMarket = driftClient.getPerpMarketAccount(targetMarketIndex);
+    const oracleData = driftClient.getOracleDataForPerpMarket(targetMarket.marketIndex);
+    const perpLiabilityValue = calculatePerpLiabilityValue(baseSize, oracleData.price, (0, types_1.isVariant)(targetMarket.contractType, 'prediction'));
+    const marginRequired = new anchor_1.BN((0, __1.calculateMarketMarginRatio)(targetMarket, baseSize.abs(), 'Initial', userMaxMarginRatio))
+        .mul(perpLiabilityValue)
+        .div(numericConstants_1.MARGIN_PRECISION);
+    return marginRequired;
+}
+exports.calculateMarginUSDCRequiredForTrade = calculateMarginUSDCRequiredForTrade;
+/**
+ * Similar to calculatetMarginUSDCRequiredForTrade, but calculates how much of a given collateral is required to cover the margin requirements for a given trade. Basically does the same thing as getMarginUSDCRequiredForTrade but also accounts for asset weight of the selected collateral.
+ *
+ * Returns collateral required in the precision of the target collateral market.
+ */
+function calculateCollateralDepositRequiredForTrade(driftClient, targetMarketIndex, baseSize, collateralIndex, userMaxMarginRatio) {
+    const marginRequiredUsdc = calculateMarginUSDCRequiredForTrade(driftClient, targetMarketIndex, baseSize, userMaxMarginRatio);
+    const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);
+    const collateralOracleData = driftClient.getOracleDataForSpotMarket(collateralIndex);
+    const scaledAssetWeight = (0, __1.calculateScaledInitialAssetWeight)(collateralMarket, collateralOracleData.price);
+    // Base amount required to deposit = (marginRequiredUsdc / priceOfAsset) / assetWeight .. (E.g. $100 required / $10000 price / 0.5 weight)
+    const baseAmountRequired = driftClient
+        .convertToSpotPrecision(collateralIndex, marginRequiredUsdc)
+        .mul(numericConstants_1.PRICE_PRECISION) // adjust for division by oracle price
+        .mul(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION) // adjust for division by scaled asset weight
+        .div(collateralOracleData.price)
+        .div(scaledAssetWeight)
+        .div(numericConstants_1.QUOTE_PRECISION); // adjust for marginRequiredUsdc value's QUOTE_PRECISION
+    // TODO : Round by step size?
+    return baseAmountRequired;
+}
+exports.calculateCollateralDepositRequiredForTrade = calculateCollateralDepositRequiredForTrade;
+function calculateCollateralValueOfDeposit(driftClient, collateralIndex, baseSize) {
+    const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);
+    const collateralOracleData = driftClient.getOracleDataForSpotMarket(collateralIndex);
+    const scaledAssetWeight = (0, __1.calculateScaledInitialAssetWeight)(collateralMarket, collateralOracleData.price);
+    // CollateralBaseValue = oracle price * collateral base amount (and shift to QUOTE_PRECISION)
+    const collateralBaseValue = collateralOracleData.price
+        .mul(baseSize)
+        .mul(numericConstants_1.QUOTE_PRECISION)
+        .div(numericConstants_1.PRICE_PRECISION)
+        .div(new anchor_1.BN(10).pow(new anchor_1.BN(collateralMarket.decimals)));
+    const depositCollateralValue = collateralBaseValue
+        .mul(scaledAssetWeight)
+        .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+    return depositCollateralValue;
+}
+exports.calculateCollateralValueOfDeposit = calculateCollateralValueOfDeposit;
+function calculateLiquidationPrice(freeCollateral, freeCollateralDelta, oraclePrice) {
+    const liqPriceDelta = freeCollateral
+        .mul(numericConstants_1.QUOTE_PRECISION)
+        .div(freeCollateralDelta);
+    const liqPrice = oraclePrice.sub(liqPriceDelta);
+    if (liqPrice.lt(numericConstants_1.ZERO)) {
+        return new anchor_1.BN(-1);
+    }
+    return liqPrice;
+}
+exports.calculateLiquidationPrice = calculateLiquidationPrice;

package/lib/user.d.ts

@@ -265,9 +265,10 @@ export declare class User {
      * @param estimatedEntryPrice
      * @param marginCategory // allow Initial to be passed in if we are trying to calculate price for DLP de-risking
      * @param includeOpenOrders
+     * @param offsetCollateral // allows calculating the liquidation price after this offset collateral is added to the user's account (e.g. : what will the liquidation price be for this position AFTER I deposit $x worth of collateral)
      * @returns Precision : PRICE_PRECISION
      */
-    liquidationPrice(marketIndex: number, positionBaseSizeChange?: BN, estimatedEntryPrice?: BN, marginCategory?: MarginCategory, includeOpenOrders?: boolean): BN;
+    liquidationPrice(marketIndex: number, positionBaseSizeChange?: BN, estimatedEntryPrice?: BN, marginCategory?: MarginCategory, includeOpenOrders?: boolean, offsetCollateral?: BN): BN;
     calculateEntriesEffectOnFreeCollateral(market: PerpMarketAccount, oraclePrice: BN, perpPosition: PerpPosition, positionBaseSizeChange: BN, estimatedEntryPrice: BN, includeOpenOrders: boolean): BN;
     calculateFreeCollateralDeltaForPerp(market: PerpMarketAccount, perpPosition: PerpPosition, positionBaseSizeChange: BN, oraclePrice: BN, marginCategory?: MarginCategory, includeOpenOrders?: boolean): BN | undefined;
     calculateFreeCollateralDeltaForSpot(market: SpotMarketAccount, signedTokenAmount: BN, marginCategory?: MarginCategory): BN;
@@ -278,6 +279,8 @@ export declare class User {
      * @returns : Precision PRICE_PRECISION
      */
     liquidationPriceAfterClose(positionMarketIndex: number, closeQuoteAmount: BN, estimatedEntryPrice?: BN): BN;
+    getMarginUSDCRequiredForTrade(targetMarketIndex: number, baseSize: BN): BN;
+    getCollateralDepositRequiredForTrade(targetMarketIndex: number, baseSize: BN, collateralIndex: number): BN;
     /**
      * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
      *

package/lib/user.js

@@ -1202,12 +1202,13 @@ class User {
      * @param estimatedEntryPrice
      * @param marginCategory // allow Initial to be passed in if we are trying to calculate price for DLP de-risking
      * @param includeOpenOrders
+     * @param offsetCollateral // allows calculating the liquidation price after this offset collateral is added to the user's account (e.g. : what will the liquidation price be for this position AFTER I deposit $x worth of collateral)
      * @returns Precision : PRICE_PRECISION
      */
-    liquidationPrice(marketIndex, positionBaseSizeChange = numericConstants_1.ZERO, estimatedEntryPrice = numericConstants_1.ZERO, marginCategory = 'Maintenance', includeOpenOrders = false) {
+    liquidationPrice(marketIndex, positionBaseSizeChange = numericConstants_1.ZERO, estimatedEntryPrice = numericConstants_1.ZERO, marginCategory = 'Maintenance', includeOpenOrders = false, offsetCollateral = numericConstants_1.ZERO) {
         const totalCollateral = this.getTotalCollateral(marginCategory);
         const marginRequirement = this.getMarginRequirement(marginCategory, undefined, false, includeOpenOrders);
-        let freeCollateral = _1.BN.max(numericConstants_1.ZERO, totalCollateral.sub(marginRequirement));
+        let freeCollateral = _1.BN.max(numericConstants_1.ZERO, totalCollateral.sub(marginRequirement)).add(offsetCollateral);
         const oracle = this.driftClient.getPerpMarketAccount(marketIndex).amm.oracle;
         const oraclePrice = this.driftClient.getOracleDataForPerpMarket(marketIndex).price;
         const market = this.driftClient.getPerpMarketAccount(marketIndex);
@@ -1367,6 +1368,12 @@ class User {
             .neg();
         return this.liquidationPrice(positionMarketIndex, closeBaseAmount, estimatedEntryPrice);
     }
+    getMarginUSDCRequiredForTrade(targetMarketIndex, baseSize) {
+        return (0, margin_1.calculateMarginUSDCRequiredForTrade)(this.driftClient, targetMarketIndex, baseSize, this.getUserAccount().maxMarginRatio);
+    }
+    getCollateralDepositRequiredForTrade(targetMarketIndex, baseSize, collateralIndex) {
+        return (0, margin_1.calculateCollateralDepositRequiredForTrade)(this.driftClient, targetMarketIndex, baseSize, collateralIndex, this.getUserAccount().maxMarginRatio);
+    }
     /**
      * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
      *

package/package.json

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

package/src/driftClient.ts

@@ -1906,14 +1906,13 @@ export class DriftClient {
 		});
 	}
 
-	public async createDepositTxn(
+	public async getDepositTxnIx(
 		amount: BN,
 		marketIndex: number,
 		associatedTokenAccount: PublicKey,
 		subAccountId?: number,
-		reduceOnly = false,
-		txParams?: TxParams
-	): Promise<VersionedTransaction | Transaction> {
+		reduceOnly = false
+	): Promise<TransactionInstruction[]> {
 		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
 
 		const isSolMarket = spotMarketAccount.mint.equals(WRAPPED_SOL_MINT);
@@ -1959,6 +1958,25 @@ export class DriftClient {
 			);
 		}
 
+		return instructions;
+	}
+
+	public async createDepositTxn(
+		amount: BN,
+		marketIndex: number,
+		associatedTokenAccount: PublicKey,
+		subAccountId?: number,
+		reduceOnly = false,
+		txParams?: TxParams
+	): Promise<VersionedTransaction | Transaction> {
+		const instructions = await this.getDepositTxnIx(
+			amount,
+			marketIndex,
+			associatedTokenAccount,
+			subAccountId,
+			reduceOnly
+		);
+
 		txParams = { ...(txParams ?? this.txParams), computeUnits: 600_000 };
 
 		const tx = await this.buildTransaction(instructions, txParams);
@@ -2151,7 +2169,7 @@ export class DriftClient {
 		);
 	}
 
-	public async createInitializeUserAccountAndDepositCollateral(
+	public async createInitializeUserAccountAndDepositCollateralIxs(
 		amount: BN,
 		userTokenAccount: PublicKey,
 		marketIndex = 0,
@@ -2160,9 +2178,11 @@ export class DriftClient {
 		fromSubAccountId?: number,
 		referrerInfo?: ReferrerInfo,
 		donateAmount?: BN,
-		txParams?: TxParams,
 		customMaxMarginRatio?: number
-	): Promise<[Transaction | VersionedTransaction, PublicKey]> {
+	): Promise<{
+		ixs: TransactionInstruction[];
+		userAccountPublicKey: PublicKey;
+	}> {
 		const ixs = [];
 
 		const [userAccountPublicKey, initializeUserAccountIx] =
@@ -2263,6 +2283,37 @@ export class DriftClient {
 			);
 		}
 
+		return {
+			ixs,
+			userAccountPublicKey,
+		};
+	}
+
+	public async createInitializeUserAccountAndDepositCollateral(
+		amount: BN,
+		userTokenAccount: PublicKey,
+		marketIndex = 0,
+		subAccountId = 0,
+		name?: string,
+		fromSubAccountId?: number,
+		referrerInfo?: ReferrerInfo,
+		donateAmount?: BN,
+		txParams?: TxParams,
+		customMaxMarginRatio?: number
+	): Promise<[Transaction | VersionedTransaction, PublicKey]> {
+		const { ixs, userAccountPublicKey } =
+			await this.createInitializeUserAccountAndDepositCollateralIxs(
+				amount,
+				userTokenAccount,
+				marketIndex,
+				subAccountId,
+				name,
+				fromSubAccountId,
+				referrerInfo,
+				donateAmount,
+				customMaxMarginRatio
+			);
+
 		const tx = await this.buildTransaction(ixs, txParams);
 
 		return [tx, userAccountPublicKey];
@@ -3129,15 +3180,33 @@ export class DriftClient {
 
 	public async getPlacePerpOrderIx(
 		orderParams: OptionalOrderParams,
-		subAccountId?: number
+		subAccountId?: number,
+		depositToTradeArgs?: {
+			isMakingNewAccount: boolean;
+			depositMarketIndex: number;
+		}
 	): Promise<TransactionInstruction> {
 		orderParams = getOrderParams(orderParams, { marketType: MarketType.PERP });
-		const user = await this.getUserAccountPublicKey(subAccountId);
+
+		const isDepositToTradeTx = depositToTradeArgs !== undefined;
+
+		const user = isDepositToTradeTx
+			? getUserAccountPublicKeySync(
+					this.program.programId,
+					this.authority,
+					subAccountId
+			  )
+			: await this.getUserAccountPublicKey(subAccountId);
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(subAccountId)],
-			useMarketLastSlotCache: true,
+			userAccounts: depositToTradeArgs?.isMakingNewAccount
+				? []
+				: [this.getUserAccount(subAccountId)],
+			useMarketLastSlotCache: false,
 			readablePerpMarketIndex: orderParams.marketIndex,
+			readableSpotMarketIndexes: isDepositToTradeTx
+				? [depositToTradeArgs?.depositMarketIndex]
+				: undefined,
 		});
 
 		return await this.program.instruction.placePerpOrder(orderParams, {

package/src/math/margin.ts

@@ -7,10 +7,19 @@ import {
 	AMM_RESERVE_PRECISION,
 	MAX_PREDICTION_PRICE,
 	BASE_PRECISION,
+	MARGIN_PRECISION,
+	PRICE_PRECISION,
+	QUOTE_PRECISION,
 } from '../constants/numericConstants';
 import { BN } from '@coral-xyz/anchor';
 import { OraclePriceData } from '../oracles/types';
-import { PerpMarketAccount, PerpPosition } from '..';
+import {
+	calculateMarketMarginRatio,
+	calculateScaledInitialAssetWeight,
+	DriftClient,
+	PerpMarketAccount,
+	PerpPosition,
+} from '..';
 import { isVariant } from '../types';
 import { assert } from '../assert/assert';
 
@@ -194,3 +203,130 @@ export function calculatePerpLiabilityValue(
 		return baseAssetAmount.abs().mul(oraclePrice).div(BASE_PRECISION);
 	}
 }
+
+/**
+ * Calculates the margin required to open a trade, in quote amount. Only accounts for the trade size as a scalar value, does not account for the trade direction or current open positions and whether the trade would _actually_ be risk-increasing and use any extra collateral.
+ * @param targetMarketIndex
+ * @param baseSize
+ * @returns
+ */
+export function calculateMarginUSDCRequiredForTrade(
+	driftClient: DriftClient,
+	targetMarketIndex: number,
+	baseSize: BN,
+	userMaxMarginRatio?: number
+): BN {
+	const targetMarket = driftClient.getPerpMarketAccount(targetMarketIndex);
+	const oracleData = driftClient.getOracleDataForPerpMarket(
+		targetMarket.marketIndex
+	);
+
+	const perpLiabilityValue = calculatePerpLiabilityValue(
+		baseSize,
+		oracleData.price,
+		isVariant(targetMarket.contractType, 'prediction')
+	);
+
+	const marginRequired = new BN(
+		calculateMarketMarginRatio(
+			targetMarket,
+			baseSize.abs(),
+			'Initial',
+			userMaxMarginRatio
+		)
+	)
+		.mul(perpLiabilityValue)
+		.div(MARGIN_PRECISION);
+
+	return marginRequired;
+}
+
+/**
+ * Similar to calculatetMarginUSDCRequiredForTrade, but calculates how much of a given collateral is required to cover the margin requirements for a given trade. Basically does the same thing as getMarginUSDCRequiredForTrade but also accounts for asset weight of the selected collateral.
+ *
+ * Returns collateral required in the precision of the target collateral market.
+ */
+export function calculateCollateralDepositRequiredForTrade(
+	driftClient: DriftClient,
+	targetMarketIndex: number,
+	baseSize: BN,
+	collateralIndex: number,
+	userMaxMarginRatio?: number
+): BN {
+	const marginRequiredUsdc = calculateMarginUSDCRequiredForTrade(
+		driftClient,
+		targetMarketIndex,
+		baseSize,
+		userMaxMarginRatio
+	);
+
+	const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);
+
+	const collateralOracleData =
+		driftClient.getOracleDataForSpotMarket(collateralIndex);
+
+	const scaledAssetWeight = calculateScaledInitialAssetWeight(
+		collateralMarket,
+		collateralOracleData.price
+	);
+
+	// Base amount required to deposit = (marginRequiredUsdc / priceOfAsset) / assetWeight .. (E.g. $100 required / $10000 price / 0.5 weight)
+	const baseAmountRequired = driftClient
+		.convertToSpotPrecision(collateralIndex, marginRequiredUsdc)
+		.mul(PRICE_PRECISION) // adjust for division by oracle price
+		.mul(SPOT_MARKET_WEIGHT_PRECISION) // adjust for division by scaled asset weight
+		.div(collateralOracleData.price)
+		.div(scaledAssetWeight)
+		.div(QUOTE_PRECISION); // adjust for marginRequiredUsdc value's QUOTE_PRECISION
+
+	// TODO : Round by step size?
+
+	return baseAmountRequired;
+}
+
+export function calculateCollateralValueOfDeposit(
+	driftClient: DriftClient,
+	collateralIndex: number,
+	baseSize: BN
+): BN {
+	const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);
+
+	const collateralOracleData =
+		driftClient.getOracleDataForSpotMarket(collateralIndex);
+
+	const scaledAssetWeight = calculateScaledInitialAssetWeight(
+		collateralMarket,
+		collateralOracleData.price
+	);
+
+	// CollateralBaseValue = oracle price * collateral base amount (and shift to QUOTE_PRECISION)
+	const collateralBaseValue = collateralOracleData.price
+		.mul(baseSize)
+		.mul(QUOTE_PRECISION)
+		.div(PRICE_PRECISION)
+		.div(new BN(10).pow(new BN(collateralMarket.decimals)));
+
+	const depositCollateralValue = collateralBaseValue
+		.mul(scaledAssetWeight)
+		.div(SPOT_MARKET_WEIGHT_PRECISION);
+
+	return depositCollateralValue;
+}
+
+export function calculateLiquidationPrice(
+	freeCollateral: BN,
+	freeCollateralDelta: BN,
+	oraclePrice: BN
+): BN {
+	const liqPriceDelta = freeCollateral
+		.mul(QUOTE_PRECISION)
+		.div(freeCollateralDelta);
+
+	const liqPrice = oraclePrice.sub(liqPriceDelta);
+
+	if (liqPrice.lt(ZERO)) {
+		return new BN(-1);
+	}
+
+	return liqPrice;
+}

package/src/user.ts

@@ -78,6 +78,8 @@ import {
 import { calculateMarketOpenBidAsk } from './math/amm';
 import {
 	calculateBaseAssetValueWithOracle,
+	calculateCollateralDepositRequiredForTrade,
+	calculateMarginUSDCRequiredForTrade,
 	calculateWorstCaseBaseAssetAmount,
 } from './math/margin';
 import { OraclePriceData } from './oracles/types';
@@ -2274,6 +2276,7 @@ export class User {
 	 * @param estimatedEntryPrice
 	 * @param marginCategory // allow Initial to be passed in if we are trying to calculate price for DLP de-risking
 	 * @param includeOpenOrders
+	 * @param offsetCollateral // allows calculating the liquidation price after this offset collateral is added to the user's account (e.g. : what will the liquidation price be for this position AFTER I deposit $x worth of collateral)
 	 * @returns Precision : PRICE_PRECISION
 	 */
 	public liquidationPrice(
@@ -2281,7 +2284,8 @@ export class User {
 		positionBaseSizeChange: BN = ZERO,
 		estimatedEntryPrice: BN = ZERO,
 		marginCategory: MarginCategory = 'Maintenance',
-		includeOpenOrders = false
+		includeOpenOrders = false,
+		offsetCollateral = ZERO
 	): BN {
 		const totalCollateral = this.getTotalCollateral(marginCategory);
 		const marginRequirement = this.getMarginRequirement(
@@ -2290,7 +2294,10 @@ export class User {
 			false,
 			includeOpenOrders
 		);
-		let freeCollateral = BN.max(ZERO, totalCollateral.sub(marginRequirement));
+		let freeCollateral = BN.max(
+			ZERO,
+			totalCollateral.sub(marginRequirement)
+		).add(offsetCollateral);
 
 		const oracle =
 			this.driftClient.getPerpMarketAccount(marketIndex).amm.oracle;
@@ -2593,6 +2600,32 @@ export class User {
 		);
 	}
 
+	public getMarginUSDCRequiredForTrade(
+		targetMarketIndex: number,
+		baseSize: BN
+	): BN {
+		return calculateMarginUSDCRequiredForTrade(
+			this.driftClient,
+			targetMarketIndex,
+			baseSize,
+			this.getUserAccount().maxMarginRatio
+		);
+	}
+
+	public getCollateralDepositRequiredForTrade(
+		targetMarketIndex: number,
+		baseSize: BN,
+		collateralIndex: number
+	): BN {
+		return calculateCollateralDepositRequiredForTrade(
+			this.driftClient,
+			targetMarketIndex,
+			baseSize,
+			collateralIndex,
+			this.getUserAccount().maxMarginRatio
+		);
+	}
+
 	/**
 	 * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
 	 *

package/tests/ci/idl.ts

@@ -51,7 +51,9 @@ describe('Verify IDL', function () {
 		);
 
 		if (onChainIdl === null) {
-			throw new Error(`onChainIdl for ${mainnetDriftClient.program.programId.toBase58()} null`);
+			throw new Error(
+				`onChainIdl for ${mainnetDriftClient.program.programId.toBase58()} null`
+			);
 		}
 
 		// anchor idl init seems to strip the metadata
@@ -65,13 +67,20 @@ describe('Verify IDL', function () {
 		const encodedSdkIdl = JSON.stringify(sdkIdl);
 
 		try {
-			assert(encodedSdkIdl === encodedMainnetIdl, 'on-chain IDL does not match SDK IDL');
+			assert(
+				encodedSdkIdl === encodedMainnetIdl,
+				'on-chain IDL does not match SDK IDL'
+			);
 		} catch (error) {
 			const diff = {};
 			for (const key of IDL_KEYS_TO_CHECK) {
 				const onChainItems = onChainIdl[key];
 				const sdkItems = sdkIdl[key];
-				for (let i = 0; i < Math.max(onChainItems.length, sdkItems.length); i++) {
+				for (
+					let i = 0;
+					i < Math.max(onChainItems.length, sdkItems.length);
+					i++
+				) {
 					let onChainItem = null;
 					let sdkItem = null;
 					if (i < onChainItems.length) {