@drift-labs/sdk 2.96.0-beta.0 → 2.96.0-beta.10

package/src/events/eventsServerLogProvider.ts

@@ -0,0 +1,152 @@
+// import WebSocket from 'ws';
+import { logProviderCallback, EventType, LogProvider } from './types';
+import { EventEmitter } from 'events';
+
+// browser support
+let WebSocketImpl: typeof WebSocket;
+if (typeof window !== 'undefined' && window.WebSocket) {
+	WebSocketImpl = window.WebSocket;
+} else {
+	WebSocketImpl = require('ws');
+}
+
+const EVENT_SERVER_HEARTBEAT_INTERVAL_MS = 5000;
+const ALLOWED_MISSED_HEARTBEATS = 3;
+
+export class EventsServerLogProvider implements LogProvider {
+	private ws?: WebSocket;
+	private callback?: logProviderCallback;
+	private isUnsubscribing = false;
+	private externalUnsubscribe = false;
+	private lastHeartbeat = 0;
+	private timeoutId?: NodeJS.Timeout;
+	private reconnectAttempts = 0;
+	eventEmitter?: EventEmitter;
+
+	public constructor(
+		private readonly url: string,
+		private readonly eventTypes: EventType[],
+		private readonly userAccount?: string
+	) {
+		this.eventEmitter = new EventEmitter();
+	}
+
+	public isSubscribed(): boolean {
+		return this.ws !== undefined;
+	}
+
+	public async subscribe(callback: logProviderCallback): Promise<boolean> {
+		if (this.ws !== undefined) {
+			return true;
+		}
+		this.ws = new WebSocketImpl(this.url);
+
+		this.callback = callback;
+		this.ws.addEventListener('open', () => {
+			for (const channel of this.eventTypes) {
+				const subscribeMessage = {
+					type: 'subscribe',
+					channel: channel,
+				};
+				if (this.userAccount) {
+					subscribeMessage['user'] = this.userAccount;
+				}
+				this.ws.send(JSON.stringify(subscribeMessage));
+			}
+			this.reconnectAttempts = 0;
+		});
+
+		this.ws.addEventListener('message', (data) => {
+			try {
+				if (!this.isUnsubscribing) {
+					clearTimeout(this.timeoutId);
+					this.setTimeout();
+					if (this.reconnectAttempts > 0) {
+						console.log(
+							'eventsServerLogProvider: Resetting reconnect attempts to 0'
+						);
+					}
+					this.reconnectAttempts = 0;
+				}
+
+				const parsedData = JSON.parse(data.data.toString());
+				if (parsedData.channel === 'heartbeat') {
+					this.lastHeartbeat = Date.now();
+					return;
+				}
+				if (parsedData.message !== undefined) {
+					return;
+				}
+				const event = JSON.parse(parsedData.data);
+				this.callback(
+					event.txSig,
+					event.slot,
+					[
+						'Program dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH invoke [1]',
+						event.rawLog,
+						'Program dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH success',
+					],
+					undefined,
+					event.txSigIndex
+				);
+			} catch (error) {
+				console.error('Error parsing message:', error);
+			}
+		});
+
+		this.ws.addEventListener('close', () => {
+			console.log('eventsServerLogProvider: WebSocket closed');
+		});
+
+		this.ws.addEventListener('error', (error) => {
+			console.error('eventsServerLogProvider: WebSocket error:', error);
+		});
+
+		this.setTimeout();
+
+		return true;
+	}
+
+	public async unsubscribe(external = false): Promise<boolean> {
+		this.isUnsubscribing = true;
+		this.externalUnsubscribe = external;
+		if (this.timeoutId) {
+			clearInterval(this.timeoutId);
+			this.timeoutId = undefined;
+		}
+
+		if (this.ws !== undefined) {
+			this.ws.close();
+			this.ws = undefined;
+			return true;
+		} else {
+			this.isUnsubscribing = false;
+			return true;
+		}
+	}
+
+	private setTimeout(): void {
+		this.timeoutId = setTimeout(async () => {
+			if (this.isUnsubscribing || this.externalUnsubscribe) {
+				// If we are in the process of unsubscribing, do not attempt to resubscribe
+				return;
+			}
+
+			const timeSinceLastHeartbeat = Date.now() - this.lastHeartbeat;
+			if (
+				timeSinceLastHeartbeat >
+				EVENT_SERVER_HEARTBEAT_INTERVAL_MS * ALLOWED_MISSED_HEARTBEATS
+			) {
+				console.log(
+					`eventServerLogProvider: No heartbeat in ${timeSinceLastHeartbeat}ms, resubscribing on attempt ${
+						this.reconnectAttempts + 1
+					}`
+				);
+				await this.unsubscribe();
+				this.reconnectAttempts++;
+				this.eventEmitter.emit('reconnect', this.reconnectAttempts);
+				this.subscribe(this.callback);
+			}
+		}, EVENT_SERVER_HEARTBEAT_INTERVAL_MS * 2);
+	}
+}

package/src/events/pollingLogProvider.ts

@@ -60,7 +60,7 @@ export class PollingLogProvider implements LogProvider {
 				const { mostRecentTx, transactionLogs } = response;
 
 				for (const { txSig, slot, logs } of transactionLogs) {
-					callback(txSig, slot, logs, response.mostRecentBlockTime);
+					callback(txSig, slot, logs, response.mostRecentBlockTime, undefined);
 				}
 
 				this.mostRecentSeenTx = mostRecentTx;

package/src/events/types.ts

@@ -56,7 +56,11 @@ export const DefaultEventSubscriptionOptions: EventSubscriptionOptions = {
 	commitment: 'confirmed',
 	maxTx: 4096,
 	logProviderConfig: {
-		type: 'websocket',
+		type: 'events-server',
+		url: 'wss://events.drift.trade/ws',
+		maxReconnectAttempts: 5,
+		fallbackFrequency: 1000,
+		fallbackBatchSize: 100,
 	},
 };
 
@@ -126,7 +130,8 @@ export type logProviderCallback = (
 	txSig: TransactionSignature,
 	slot: number,
 	logs: string[],
-	mostRecentBlockTime: number | undefined
+	mostRecentBlockTime: number | undefined,
+	txSigIndex: number | undefined
 ) => void;
 
 export interface LogProvider {
@@ -139,20 +144,38 @@ export interface LogProvider {
 	eventEmitter?: EventEmitter;
 }
 
-export type WebSocketLogProviderConfig = {
-	type: 'websocket';
-	resubTimeoutMs?: number;
+export type LogProviderType = 'websocket' | 'polling' | 'events-server';
+
+export type StreamingLogProviderConfig = {
+	/// Max number of times to try reconnecting before failing over to fallback provider
 	maxReconnectAttempts?: number;
+	/// used for PollingLogProviderConfig on fallback
 	fallbackFrequency?: number;
+	/// used for PollingLogProviderConfig on fallback
 	fallbackBatchSize?: number;
 };
 
+export type WebSocketLogProviderConfig = StreamingLogProviderConfig & {
+	type: 'websocket';
+	/// Max time to wait before resubscribing
+	resubTimeoutMs?: number;
+};
+
 export type PollingLogProviderConfig = {
 	type: 'polling';
+	/// frequency to poll for new events
 	frequency: number;
+	/// max number of events to fetch per poll
 	batchSize?: number;
 };
 
+export type EventsServerLogProviderConfig = StreamingLogProviderConfig & {
+	type: 'events-server';
+	/// url of the events server
+	url: string;
+};
+
 export type LogProviderConfig =
 	| WebSocketLogProviderConfig
-	| PollingLogProviderConfig;
+	| PollingLogProviderConfig
+	| EventsServerLogProviderConfig;

package/src/events/webSocketLogProvider.ts

@@ -64,7 +64,7 @@ export class WebSocketLogProvider implements LogProvider {
 				if (logs.err !== null) {
 					return;
 				}
-				callback(logs.signature, ctx.slot, logs.logs, undefined);
+				callback(logs.signature, ctx.slot, logs.logs, undefined, undefined);
 			},
 			this.commitment
 		);
@@ -106,9 +106,9 @@ export class WebSocketLogProvider implements LogProvider {
 
 			if (this.receivingData) {
 				console.log(
-					`No log data in ${this.resubTimeoutMs}ms, resubscribing on attempt ${
-						this.reconnectAttempts + 1
-					}`
+					`webSocketLogProvider: No log data in ${
+						this.resubTimeoutMs
+					}ms, resubscribing on attempt ${this.reconnectAttempts + 1}`
 				);
 				await this.unsubscribe();
 				this.receivingData = false;

package/src/idl/drift.json

@@ -608,6 +608,56 @@
         }
       ]
     },
+    {
+      "name": "placeSwiftTakerOrder",
+      "accounts": [
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "user",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "userStats",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "ixSysvar",
+          "isMut": false,
+          "isSigner": false,
+          "docs": [
+            "the supplied Sysvar could be anything else.",
+            "The Instruction Sysvar has not been implemented",
+            "in the Anchor framework yet, so this is the safe approach."
+          ]
+        }
+      ],
+      "args": [
+        {
+          "name": "takerOrderParamsMessageBytes",
+          "type": "bytes"
+        },
+        {
+          "name": "signature",
+          "type": {
+            "array": [
+              "u8",
+              64
+            ]
+          }
+        }
+      ]
+    },
     {
       "name": "placeSpotOrder",
       "accounts": [
@@ -8050,6 +8100,40 @@
         ]
       }
     },
+    {
+      "name": "SwiftOrderParamsMessage",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "swiftOrderParams",
+            "type": {
+              "vec": {
+                "defined": "OrderParams"
+              }
+            }
+          },
+          {
+            "name": "marketIndex",
+            "type": "u16"
+          },
+          {
+            "name": "marketType",
+            "type": {
+              "defined": "MarketType"
+            }
+          },
+          {
+            "name": "expectedOrderId",
+            "type": "i32"
+          },
+          {
+            "name": "slot",
+            "type": "u64"
+          }
+        ]
+      }
+    },
     {
       "name": "ModifyOrderParams",
       "type": {
@@ -12958,6 +13042,26 @@
       "code": 6284,
       "name": "InvalidPredictionMarketOrder",
       "msg": "Invalid prediction market order"
+    },
+    {
+      "code": 6285,
+      "name": "InvalidVerificationIxIndex",
+      "msg": "Ed25519 Ix must be before place and make swift order ix"
+    },
+    {
+      "code": 6286,
+      "name": "SigVerificationFailed",
+      "msg": "Swift taker message verificaiton failed"
+    },
+    {
+      "code": 6287,
+      "name": "MismatchedSwiftOrderParamsMarketIndex",
+      "msg": "Market index mismatched b/w taker and maker swift order params"
+    },
+    {
+      "code": 6288,
+      "name": "SwiftOrderSequenceError",
+      "msg": "Swift order message must be ordered 0th order is market and rest are triggers"
     }
   ],
   "metadata": {

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/orderParams.ts

@@ -10,9 +10,11 @@ import { BN } from '@coral-xyz/anchor';
 export function getLimitOrderParams(
 	params: Omit<OptionalOrderParams, 'orderType'> & { price: BN }
 ): OptionalOrderParams {
-	return Object.assign({}, params, {
-		orderType: OrderType.LIMIT,
-	});
+	return getOrderParams(
+		Object.assign({}, params, {
+			orderType: OrderType.LIMIT,
+		})
+	);
 }
 
 export function getTriggerMarketOrderParams(
@@ -21,9 +23,11 @@ export function getTriggerMarketOrderParams(
 		triggerPrice: BN;
 	}
 ): OptionalOrderParams {
-	return Object.assign({}, params, {
-		orderType: OrderType.TRIGGER_MARKET,
-	});
+	return getOrderParams(
+		Object.assign({}, params, {
+			orderType: OrderType.TRIGGER_MARKET,
+		})
+	);
 }
 
 export function getTriggerLimitOrderParams(
@@ -33,17 +37,21 @@ export function getTriggerLimitOrderParams(
 		price: BN;
 	}
 ): OptionalOrderParams {
-	return Object.assign({}, params, {
-		orderType: OrderType.TRIGGER_LIMIT,
-	});
+	return getOrderParams(
+		Object.assign({}, params, {
+			orderType: OrderType.TRIGGER_LIMIT,
+		})
+	);
 }
 
 export function getMarketOrderParams(
 	params: Omit<OptionalOrderParams, 'orderType'>
 ): OptionalOrderParams {
-	return Object.assign({}, params, {
-		orderType: OrderType.MARKET,
-	});
+	return getOrderParams(
+		Object.assign({}, params, {
+			orderType: OrderType.MARKET,
+		})
+	);
 }
 
 /**

package/src/types.ts

@@ -1,4 +1,9 @@
-import { PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
+import {
+	Keypair,
+	PublicKey,
+	Transaction,
+	VersionedTransaction,
+} from '@solana/web3.js';
 import { BN, ZERO } from '.';
 
 // Utility type which lets you denote record with values of type A mapped to a record with the same keys but values of type B
@@ -1051,6 +1056,14 @@ export const DefaultOrderParams: OrderParams = {
 	auctionEndPrice: null,
 };
 
+export type SwiftOrderParamsMessage = {
+	marketIndex: number;
+	swiftOrderParams: OptionalOrderParams[];
+	expectedOrderId: number;
+	marketType: MarketType;
+	slot: BN;
+};
+
 export type MakerInfo = {
 	maker: PublicKey;
 	makerStats: PublicKey;
@@ -1097,6 +1110,7 @@ export interface IWallet {
 	signTransaction(tx: Transaction): Promise<Transaction>;
 	signAllTransactions(txs: Transaction[]): Promise<Transaction[]>;
 	publicKey: PublicKey;
+	payer: Keypair;
 }
 export interface IVersionedWallet {
 	signVersionedTransaction(
@@ -1106,6 +1120,7 @@ export interface IVersionedWallet {
 		txs: VersionedTransaction[]
 	): Promise<VersionedTransaction[]>;
 	publicKey: PublicKey;
+	payer: Keypair;
 }
 
 export type FeeStructure = {

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.
 	 *