@drift-labs/sdk 0.2.0-master.32 → 0.2.0-master.33

package/src/events/eventList.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventList = void 0;
+class Node {
+    constructor(event, next, prev) {
+        this.event = event;
+        this.next = next;
+        this.prev = prev;
+    }
+}
+class EventList {
+    constructor(eventType, maxSize, sortFn, orderDirection) {
+        this.eventType = eventType;
+        this.maxSize = maxSize;
+        this.sortFn = sortFn;
+        this.orderDirection = orderDirection;
+        this.size = 0;
+    }
+    insert(event) {
+        this.size++;
+        const newNode = new Node(event);
+        if (this.head === undefined) {
+            this.head = this.tail = newNode;
+            return;
+        }
+        if (this.sortFn(this.head.event, newNode.event) ===
+            (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
+            this.head.prev = newNode;
+            newNode.next = this.head;
+            this.head = newNode;
+        }
+        else {
+            let currentNode = this.head;
+            while (currentNode.next !== undefined &&
+                this.sortFn(currentNode.next.event, newNode.event) !==
+                    (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
+                currentNode = currentNode.next;
+            }
+            newNode.next = currentNode.next;
+            if (currentNode.next !== undefined) {
+                newNode.next.prev = newNode;
+            }
+            currentNode.next = newNode;
+            newNode.prev = currentNode;
+        }
+        if (this.size > this.maxSize) {
+            this.detach();
+        }
+    }
+    detach() {
+        const node = this.tail;
+        if (node.prev !== undefined) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next !== undefined) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+        this.size--;
+    }
+    toArray() {
+        return Array.from(this);
+    }
+    *[Symbol.iterator]() {
+        let node = this.head;
+        while (node) {
+            yield node.event;
+            node = node.next;
+        }
+    }
+}
+exports.EventList = EventList;

package/src/events/eventSubscriber.ts

@@ -26,6 +26,7 @@ export class EventSubscriber {
 	private logProvider: LogProvider;
 	public eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
 	private lastSeenSlot: number;
+	private lastSeenBlockTime: number | undefined;
 	public lastSeenTxSig: string;
 
 	public constructor(
@@ -70,8 +71,8 @@ export class EventSubscriber {
 				return true;
 			}
 
-			this.logProvider.subscribe((txSig, slot, logs) => {
-				this.handleTxLogs(txSig, slot, logs);
+			this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
+				this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
 			}, true);
 
 			return true;
@@ -85,7 +86,8 @@ export class EventSubscriber {
 	private handleTxLogs(
 		txSig: TransactionSignature,
 		slot: number,
-		logs: string[]
+		logs: string[],
+		mostRecentBlockTime: number | undefined
 	): void {
 		if (this.txEventCache.has(txSig)) {
 			return;
@@ -94,6 +96,10 @@ export class EventSubscriber {
 		const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs);
 		for (const wrappedEvent of wrappedEvents) {
 			this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
+		}
+
+		// dont emit event till we've added all the events to the eventListMap
+		for (const wrappedEvent of wrappedEvents) {
 			this.eventEmitter.emit('newEvent', wrappedEvent);
 		}
 
@@ -106,6 +112,14 @@ export class EventSubscriber {
 		if (slot > this.lastSeenSlot) {
 			this.lastSeenTxSig = txSig;
 		}
+
+		if (
+			this.lastSeenBlockTime === undefined ||
+			mostRecentBlockTime > this.lastSeenBlockTime
+		) {
+			this.lastSeenBlockTime = mostRecentBlockTime;
+		}
+
 		this.txEventCache.add(txSig, wrappedEvents);
 	}
 
@@ -134,7 +148,7 @@ export class EventSubscriber {
 			beforeTx = response.earliestTx;
 
 			for (const { txSig, slot, logs } of response.transactionLogs) {
-				this.handleTxLogs(txSig, slot, logs);
+				this.handleTxLogs(txSig, slot, logs, response.mostRecentBlockTime);
 			}
 		}
 	}

package/src/events/fetchLogs.ts

@@ -3,6 +3,7 @@ import {
 	Connection,
 	Finality,
 	PublicKey,
+	TransactionResponse,
 	TransactionSignature,
 } from '@solana/web3.js';
 import { WrappedEvents } from './types';
@@ -14,8 +15,17 @@ type FetchLogsResponse = {
 	earliestSlot: number;
 	mostRecentSlot: number;
 	transactionLogs: Log[];
+	mostRecentBlockTime: number | undefined;
 };
 
+function mapTransactionResponseToLog(transaction: TransactionResponse): Log {
+	return {
+		txSig: transaction.transaction.signatures[0],
+		slot: transaction.slot,
+		logs: transaction.meta.logMessages,
+	};
+}
+
 export async function fetchLogs(
 	connection: Connection,
 	programId: PublicKey,
@@ -57,11 +67,7 @@ export async function fetchLogs(
 				);
 
 				return transactions.map((transaction) => {
-					return {
-						txSig: transaction.transaction.signatures[0],
-						slot: transaction.slot,
-						logs: transaction.meta.logMessages,
-					};
+					return mapTransactionResponseToLog(transaction);
 				});
 			})
 		)
@@ -76,6 +82,7 @@ export async function fetchLogs(
 		mostRecentTx: mostRecent.signature,
 		earliestSlot: earliest.slot,
 		mostRecentSlot: mostRecent.slot,
+		mostRecentBlockTime: mostRecent.blockTime,
 	};
 }
 
@@ -93,6 +100,14 @@ export class LogParser {
 		this.program = program;
 	}
 
+	public parseEventsFromTransaction(
+		transaction: TransactionResponse
+	): WrappedEvents {
+		const transactionLogObject = mapTransactionResponseToLog(transaction);
+
+		return this.parseEventsFromLogs(transactionLogObject);
+	}
+
 	public parseEventsFromLogs(event: Log): WrappedEvents {
 		const records: WrappedEvents = [];
 		// @ts-ignore

package/src/events/pollingLogProvider.ts

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

package/src/events/types.ts

@@ -93,7 +93,8 @@ export type SortFn = (
 export type logProviderCallback = (
 	txSig: TransactionSignature,
 	slot: number,
-	logs: string[]
+	logs: string[],
+	mostRecentBlockTime: number | undefined
 ) => void;
 
 export interface LogProvider {

package/src/events/webSocketLogProvider.ts

@@ -17,7 +17,7 @@ export class WebSocketLogProvider implements LogProvider {
 		this.subscriptionId = this.connection.onLogs(
 			this.programId,
 			(logs, ctx) => {
-				callback(logs.signature, ctx.slot, logs.logs);
+				callback(logs.signature, ctx.slot, logs.logs, undefined);
 			},
 			this.commitment
 		);

package/src/examples/makeTradeExample.js

@@ -0,0 +1,157 @@
+'use strict';
+var __awaiter =
+	(this && this.__awaiter) ||
+	function (thisArg, _arguments, P, generator) {
+		function adopt(value) {
+			return value instanceof P
+				? value
+				: new P(function (resolve) {
+						resolve(value);
+				  });
+		}
+		return new (P || (P = Promise))(function (resolve, reject) {
+			function fulfilled(value) {
+				try {
+					step(generator.next(value));
+				} catch (e) {
+					reject(e);
+				}
+			}
+			function rejected(value) {
+				try {
+					step(generator['throw'](value));
+				} catch (e) {
+					reject(e);
+				}
+			}
+			function step(result) {
+				result.done
+					? resolve(result.value)
+					: adopt(result.value).then(fulfilled, rejected);
+			}
+			step((generator = generator.apply(thisArg, _arguments || [])).next());
+		});
+	};
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getTokenAddress = void 0;
+const anchor_1 = require('@project-serum/anchor');
+const __1 = require('..');
+const spl_token_1 = require('@solana/spl-token');
+const web3_js_1 = require('@solana/web3.js');
+const __2 = require('..');
+const banks_1 = require('../constants/spotMarkets');
+const getTokenAddress = (mintAddress, userPubKey) => {
+	return spl_token_1.Token.getAssociatedTokenAddress(
+		new web3_js_1.PublicKey(`ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL`),
+		spl_token_1.TOKEN_PROGRAM_ID,
+		new web3_js_1.PublicKey(mintAddress),
+		new web3_js_1.PublicKey(userPubKey)
+	);
+};
+exports.getTokenAddress = getTokenAddress;
+const main = () =>
+	__awaiter(void 0, void 0, void 0, function* () {
+		// Initialize Drift SDK
+		const sdkConfig = __2.initialize({ env: 'devnet' });
+		// Set up the Wallet and Provider
+		const privateKey = process.env.BOT_PRIVATE_KEY; // stored as an array string
+		const keypair = web3_js_1.Keypair.fromSecretKey(
+			Uint8Array.from(JSON.parse(privateKey))
+		);
+		const wallet = new __1.Wallet(keypair);
+		// Set up the Connection
+		const rpcAddress = process.env.RPC_ADDRESS; // can use: https://api.devnet.solana.com for devnet; https://api.mainnet-beta.solana.com for mainnet;
+		const connection = new web3_js_1.Connection(rpcAddress);
+		// Set up the Provider
+		const provider = new anchor_1.AnchorProvider(
+			connection,
+			wallet,
+			anchor_1.AnchorProvider.defaultOptions()
+		);
+		// Check SOL Balance
+		const lamportsBalance = yield connection.getBalance(wallet.publicKey);
+		console.log('SOL balance:', lamportsBalance / Math.pow(10, 9));
+		// Misc. other things to set up
+		const usdcTokenAddress = yield exports.getTokenAddress(
+			sdkConfig.USDC_MINT_ADDRESS,
+			wallet.publicKey.toString()
+		);
+		// Set up the Drift Clearing House
+		const clearingHousePublicKey = new web3_js_1.PublicKey(
+			sdkConfig.CLEARING_HOUSE_PROGRAM_ID
+		);
+		const clearingHouse = new __2.ClearingHouse({
+			connection,
+			wallet: provider.wallet,
+			programID: clearingHousePublicKey,
+		});
+		yield clearingHouse.subscribe();
+		// Set up Clearing House user client
+		const user = new __2.ClearingHouseUser({
+			clearingHouse,
+			userAccountPublicKey: yield clearingHouse.getUserAccountPublicKey(),
+		});
+		//// Check if clearing house account exists for the current wallet
+		const userAccountExists = yield user.exists();
+		if (!userAccountExists) {
+			//// Create a Clearing House account by Depositing some USDC ($10,000 in this case)
+			const depositAmount = new anchor_1.BN(10000).mul(__2.QUOTE_PRECISION);
+			yield clearingHouse.initializeUserAccountAndDepositCollateral(
+				depositAmount,
+				yield exports.getTokenAddress(
+					usdcTokenAddress.toString(),
+					wallet.publicKey.toString()
+				),
+				banks_1.SpotMarkets['devnet'][0].marketIndex
+			);
+		}
+		yield user.subscribe();
+		// Get current price
+		const solMarketInfo = sdkConfig.PERP_MARKETS.find(
+			(market) => market.baseAssetSymbol === 'SOL'
+		);
+		const currentMarketPrice = __2.calculateMarkPrice(
+			clearingHouse.getMarketAccount(solMarketInfo.marketIndex),
+			undefined
+		);
+		const formattedPrice = __2.convertToNumber(
+			currentMarketPrice,
+			__2.PRICE_PRECISION
+		);
+		console.log(`Current Market Price is $${formattedPrice}`);
+		// Estimate the slippage for a $5000 LONG trade
+		const solMarketAccount = clearingHouse.getMarketAccount(
+			solMarketInfo.marketIndex
+		);
+		const longAmount = new anchor_1.BN(5000).mul(__2.QUOTE_PRECISION);
+		const slippage = __2.convertToNumber(
+			__2.calculateTradeSlippage(
+				__2.PositionDirection.LONG,
+				longAmount,
+				solMarketAccount,
+				'quote',
+				undefined
+			)[0],
+			__2.PRICE_PRECISION
+		);
+		console.log(
+			`Slippage for a $5000 LONG on the SOL market would be $${slippage}`
+		);
+		// Make a $5000 LONG trade
+		yield clearingHouse.openPosition(
+			__2.PositionDirection.LONG,
+			longAmount,
+			solMarketInfo.marketIndex
+		);
+		console.log(`LONGED $5000 SOL`);
+		// Reduce the position by $2000
+		const reduceAmount = new anchor_1.BN(2000).mul(__2.QUOTE_PRECISION);
+		yield clearingHouse.openPosition(
+			__2.PositionDirection.SHORT,
+			reduceAmount,
+			solMarketInfo.marketIndex
+		);
+		// Close the rest of the position
+		yield clearingHouse.closePosition(solMarketInfo.marketIndex);
+	});
+main();

package/src/factory/bigNum.ts

@@ -306,7 +306,11 @@ export class BigNum {
 	 * @param fixedPrecision
 	 * @returns
 	 */
-	public toFixed(fixedPrecision: number): string {
+	public toFixed(fixedPrecision: number, rounded = false): string {
+		if (rounded) {
+			return this.toRounded(fixedPrecision).toFixed(fixedPrecision);
+		}
+
 		const printString = this.print();
 
 		const [leftSide, rightSide] = printString.split(BigNum.delim);
@@ -322,7 +326,41 @@ export class BigNum {
 	}
 
 	private getZeroes(count: number) {
-		return new Array(count).fill('0').join('');
+		return new Array(Math.max(count, 0)).fill('0').join('');
+	}
+
+	public toRounded(roundingPrecision: number) {
+		const printString = this.toString();
+
+		let shouldRoundUp = false;
+
+		const roundingDigitChar = printString[roundingPrecision];
+
+		if (roundingDigitChar) {
+			const roundingDigitVal = Number(roundingDigitChar);
+			if (roundingDigitVal >= 5) shouldRoundUp = true;
+		}
+
+		if (shouldRoundUp) {
+			const valueWithRoundedPrecisionAdded = this.add(
+				BigNum.from(
+					new BN(10).pow(new BN(printString.length - roundingPrecision)),
+					this.precision
+				)
+			);
+
+			const roundedUpPrintString =
+				valueWithRoundedPrecisionAdded.toString().slice(0, roundingPrecision) +
+				this.getZeroes(printString.length - roundingPrecision);
+
+			return BigNum.from(roundedUpPrintString, this.precision);
+		} else {
+			const roundedDownPrintString =
+				printString.slice(0, roundingPrecision) +
+				this.getZeroes(printString.length - roundingPrecision);
+
+			return BigNum.from(roundedDownPrintString, this.precision);
+		}
 	}
 
 	/**
@@ -330,7 +368,18 @@ export class BigNum {
 	 * @param fixedPrecision
 	 * @returns
 	 */
-	public toPrecision(fixedPrecision: number, trailingZeroes = false): string {
+	public toPrecision(
+		fixedPrecision: number,
+		trailingZeroes = false,
+		rounded = false
+	): string {
+		if (rounded) {
+			return this.toRounded(fixedPrecision).toPrecision(
+				fixedPrecision,
+				trailingZeroes
+			);
+		}
+
 		const printString = this.print();
 
 		let precisionPrintString = printString.slice(0, fixedPrecision + 1);
@@ -404,8 +453,8 @@ export class BigNum {
 		return precisionPrintString;
 	}
 
-	public toTradePrecision(): string {
-		return this.toPrecision(6, true);
+	public toTradePrecision(rounded = false): string {
+		return this.toPrecision(6, true, rounded);
 	}
 
 	/**
@@ -448,7 +497,11 @@ export class BigNum {
 		return `${prefix}${val.replace('-', '')}`;
 	}
 
-	public toMillified(precision = 3): string {
+	public toMillified(precision = 3, rounded = false): string {
+		if (rounded) {
+			return this.toRounded(precision).toMillified(precision);
+		}
+
 		const stringVal = this.print();
 
 		const [leftSide] = stringVal.split(BigNum.delim);