@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.10

package/src/events/sort.ts

@@ -0,0 +1,65 @@
+import {
+	EventMap,
+	EventSubscriptionOrderBy,
+	EventSubscriptionOrderDirection,
+	EventType,
+	SortFn,
+	Event,
+} from './types';
+import { OrderRecord } from '../types';
+import { PublicKey, ZERO } from '../index';
+
+function clientSortAscFn(): 'less than' {
+	return 'less than';
+}
+
+function clientSortDescFn(): 'greater than' {
+	return 'greater than';
+}
+
+function defaultBlockchainSortFn(
+	currentEvent: EventMap[EventType],
+	newEvent: EventMap[EventType]
+): 'less than' | 'greater than' {
+	return currentEvent.slot <= newEvent.slot ? 'less than' : 'greater than';
+}
+
+function orderRecordSortFn(
+	currentEvent: Event<OrderRecord>,
+	newEvent: Event<OrderRecord>
+): 'less than' | 'greater than' {
+	const currentEventMarketIndex = !currentEvent.maker.equals(PublicKey.default)
+		? currentEvent.makerOrder.marketIndex
+		: currentEvent.takerOrder.marketIndex;
+	const newEventMarketIndex = !newEvent.maker.equals(PublicKey.default)
+		? newEvent.makerOrder.marketIndex
+		: newEvent.takerOrder.marketIndex;
+	if (!currentEventMarketIndex.eq(newEventMarketIndex)) {
+		return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
+	}
+
+	if (currentEvent.fillRecordId.gt(ZERO) && newEvent.fillRecordId.gt(ZERO)) {
+		return currentEvent.fillRecordId.lte(newEvent.fillRecordId)
+			? 'less than'
+			: 'greater than';
+	} else {
+		return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
+	}
+}
+
+export function getSortFn(
+	orderBy: EventSubscriptionOrderBy,
+	orderDir: EventSubscriptionOrderDirection,
+	eventType: EventType
+): SortFn {
+	if (orderBy === 'client') {
+		return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
+	}
+
+	switch (eventType) {
+		case 'OrderRecord':
+			return orderRecordSortFn;
+		default:
+			return defaultBlockchainSortFn;
+	}
+}

package/src/events/txEventCache.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxEventCache = void 0;
+class Node {
+    constructor(key, value, next, prev) {
+        this.key = key;
+        this.value = value;
+        this.next = next;
+        this.prev = prev;
+    }
+}
+// lru cache
+class TxEventCache {
+    constructor(maxTx = 1024) {
+        this.maxTx = maxTx;
+        this.size = 0;
+        this.cacheMap = {};
+    }
+    add(key, events) {
+        const existingNode = this.cacheMap[key];
+        if (existingNode) {
+            this.detach(existingNode);
+            this.size--;
+        }
+        else if (this.size === this.maxTx) {
+            delete this.cacheMap[this.tail.key];
+            this.detach(this.tail);
+            this.size--;
+        }
+        // Write to head of LinkedList
+        if (!this.head) {
+            this.head = this.tail = new Node(key, events);
+        }
+        else {
+            const node = new Node(key, events, this.head);
+            this.head.prev = node;
+            this.head = node;
+        }
+        // update cacheMap with LinkedList key and Node reference
+        this.cacheMap[key] = this.head;
+        this.size++;
+    }
+    has(key) {
+        return this.cacheMap.hasOwnProperty(key);
+    }
+    get(key) {
+        var _a;
+        return (_a = this.cacheMap[key]) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    detach(node) {
+        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;
+        }
+    }
+    clear() {
+        this.head = undefined;
+        this.tail = undefined;
+        this.size = 0;
+        this.cacheMap = {};
+    }
+}
+exports.TxEventCache = TxEventCache;

package/src/events/txEventCache.ts

@@ -0,0 +1,74 @@
+import { WrappedEvent, EventType } from './types';
+
+class Node {
+	constructor(
+		public key: string,
+		public value: WrappedEvent<EventType>[],
+		public next?: Node,
+		public prev?: Node
+	) {}
+}
+
+// lru cache
+export class TxEventCache {
+	size = 0;
+	head?: Node;
+	tail?: Node;
+	cacheMap: { [key: string]: Node } = {};
+
+	constructor(public maxTx = 1024) {}
+
+	public add(key: string, events: WrappedEvent<EventType>[]): void {
+		const existingNode = this.cacheMap[key];
+		if (existingNode) {
+			this.detach(existingNode);
+			this.size--;
+		} else if (this.size === this.maxTx) {
+			delete this.cacheMap[this.tail.key];
+			this.detach(this.tail);
+			this.size--;
+		}
+
+		// Write to head of LinkedList
+		if (!this.head) {
+			this.head = this.tail = new Node(key, events);
+		} else {
+			const node = new Node(key, events, this.head);
+			this.head.prev = node;
+			this.head = node;
+		}
+
+		// update cacheMap with LinkedList key and Node reference
+		this.cacheMap[key] = this.head;
+		this.size++;
+	}
+
+	public has(key: string): boolean {
+		return this.cacheMap.hasOwnProperty(key);
+	}
+
+	public get(key: string): WrappedEvent<EventType>[] | undefined {
+		return this.cacheMap[key]?.value;
+	}
+
+	detach(node: Node): void {
+		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;
+		}
+	}
+
+	public clear(): void {
+		this.head = undefined;
+		this.tail = undefined;
+		this.size = 0;
+		this.cacheMap = {};
+	}
+}

package/src/events/types.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultEventSubscriptionOptions = void 0;
+exports.DefaultEventSubscriptionOptions = {
+    eventTypes: [
+        'DepositRecord',
+        'FundingPaymentRecord',
+        'LiquidationRecord',
+        'OrderRecord',
+        'FundingRateRecord',
+    ],
+    maxEventsPerType: 4096,
+    orderBy: 'blockchain',
+    orderDir: 'asc',
+    commitment: 'confirmed',
+    maxTx: 4096,
+    logProviderConfig: {
+        type: 'websocket',
+    },
+};

package/src/events/types.ts

@@ -0,0 +1,98 @@
+import { Commitment, TransactionSignature } from '@solana/web3.js';
+import {
+	DepositRecord,
+	FundingPaymentRecord,
+	FundingRateRecord,
+	LiquidationRecord,
+	OrderRecord,
+} from '../index';
+
+export type EventSubscriptionOptions = {
+	eventTypes?: EventType[];
+	maxEventsPerType?: number;
+	orderBy?: EventSubscriptionOrderBy;
+	orderDir?: EventSubscriptionOrderDirection;
+	commitment?: Commitment;
+	maxTx?: number;
+	logProviderConfig?: LogProviderConfig;
+	// when the subscription starts, client might want to backtrack and fetch old tx's
+	// this specifies how far to backtrack
+	untilTx?: TransactionSignature;
+};
+
+export const DefaultEventSubscriptionOptions: EventSubscriptionOptions = {
+	eventTypes: [
+		'DepositRecord',
+		'FundingPaymentRecord',
+		'LiquidationRecord',
+		'OrderRecord',
+		'FundingRateRecord',
+	],
+	maxEventsPerType: 4096,
+	orderBy: 'blockchain',
+	orderDir: 'asc',
+	commitment: 'confirmed',
+	maxTx: 4096,
+	logProviderConfig: {
+		type: 'websocket',
+	},
+};
+
+// Whether we sort events based on order blockchain produced events or client receives events
+export type EventSubscriptionOrderBy = 'blockchain' | 'client';
+export type EventSubscriptionOrderDirection = 'asc' | 'desc';
+
+export type Event<T> = T & {
+	txSig: TransactionSignature;
+	slot: number;
+};
+
+export type WrappedEvent<Type extends EventType> = EventMap[Type] & {
+	eventType: Type;
+};
+
+export type WrappedEvents = WrappedEvent<EventType>[];
+
+export type EventMap = {
+	DepositRecord: Event<DepositRecord>;
+	FundingPaymentRecord: Event<FundingPaymentRecord>;
+	LiquidationRecord: Event<LiquidationRecord>;
+	FundingRateRecord: Event<FundingRateRecord>;
+	OrderRecord: Event<OrderRecord>;
+};
+
+export type EventType = keyof EventMap;
+
+export interface EventSubscriberEvents {
+	newEvent: (event: WrappedEvent<EventType>) => void;
+}
+
+export type SortFn = (
+	currentRecord: EventMap[EventType],
+	newRecord: EventMap[EventType]
+) => 'less than' | 'greater than';
+
+export type logProviderCallback = (
+	txSig: TransactionSignature,
+	slot: number,
+	logs: string[]
+) => void;
+
+export interface LogProvider {
+	isSubscribed(): boolean;
+	subscribe(callback: logProviderCallback): boolean;
+	unsubscribe(): Promise<boolean>;
+}
+
+export type WebSocketLogProviderConfig = {
+	type: 'websocket';
+};
+
+export type PollingLogProviderConfig = {
+	type: 'polling';
+	frequency: number;
+};
+
+export type LogProviderConfig =
+	| WebSocketLogProviderConfig
+	| PollingLogProviderConfig;

package/src/events/webSocketLogProvider.js

@@ -0,0 +1,41 @@
+"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.WebSocketLogProvider = void 0;
+class WebSocketLogProvider {
+    constructor(connection, programId, commitment) {
+        this.connection = connection;
+        this.programId = programId;
+        this.commitment = commitment;
+    }
+    subscribe(callback) {
+        if (this.subscriptionId) {
+            return true;
+        }
+        this.subscriptionId = this.connection.onLogs(this.programId, (logs, ctx) => {
+            callback(logs.signature, ctx.slot, logs.logs);
+        }, this.commitment);
+        return true;
+    }
+    isSubscribed() {
+        return this.subscriptionId !== undefined;
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.subscriptionId !== undefined) {
+                yield this.connection.removeOnLogsListener(this.subscriptionId);
+                this.subscriptionId = undefined;
+            }
+            return true;
+        });
+    }
+}
+exports.WebSocketLogProvider = WebSocketLogProvider;

package/src/events/webSocketLogProvider.ts

@@ -0,0 +1,38 @@
+import { LogProvider, logProviderCallback } from './types';
+import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+
+export class WebSocketLogProvider implements LogProvider {
+	private subscriptionId: number;
+	public constructor(
+		private connection: Connection,
+		private programId: PublicKey,
+		private commitment: Commitment
+	) {}
+
+	public subscribe(callback: logProviderCallback): boolean {
+		if (this.subscriptionId) {
+			return true;
+		}
+
+		this.subscriptionId = this.connection.onLogs(
+			this.programId,
+			(logs, ctx) => {
+				callback(logs.signature, ctx.slot, logs.logs);
+			},
+			this.commitment
+		);
+		return true;
+	}
+
+	public isSubscribed(): boolean {
+		return this.subscriptionId !== undefined;
+	}
+
+	public async unsubscribe(): Promise<boolean> {
+		if (this.subscriptionId !== undefined) {
+			await this.connection.removeOnLogsListener(this.subscriptionId);
+			this.subscriptionId = undefined;
+		}
+		return true;
+	}
+}

package/src/examples/makeTradeExample.js

@@ -0,0 +1,80 @@
+"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/banks");
+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.Banks['devnet'][0].bankIndex);
+    }
+    yield user.subscribe();
+    // Get current price
+    const solMarketInfo = sdkConfig.MARKETS.find((market) => market.baseAssetSymbol === 'SOL');
+    const currentMarketPrice = __2.calculateMarkPrice(clearingHouse.getMarketAccount(solMarketInfo.marketIndex), undefined);
+    const formattedPrice = __2.convertToNumber(currentMarketPrice, __2.MARK_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.MARK_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/examples/makeTradeExample.ts

@@ -7,13 +7,13 @@ import {
 	ClearingHouse,
 	ClearingHouseUser,
 	initialize,
-	Markets,
 	PositionDirection,
 	convertToNumber,
 	calculateTradeSlippage,
 	MARK_PRICE_PRECISION,
 	QUOTE_PRECISION,
 } from '..';
+import { Banks } from '../constants/banks';
 
 export const getTokenAddress = (
 	mintAddress: string,
@@ -63,15 +63,18 @@ const main = async () => {
 	const clearingHousePublicKey = new PublicKey(
 		sdkConfig.CLEARING_HOUSE_PROGRAM_ID
 	);
-	const clearingHouse = ClearingHouse.from(
+	const clearingHouse = new ClearingHouse({
 		connection,
-		provider.wallet,
-		clearingHousePublicKey
-	);
+		wallet: provider.wallet,
+		programID: clearingHousePublicKey,
+	});
 	await clearingHouse.subscribe();
 
 	// Set up Clearing House user client
-	const user = ClearingHouseUser.from(clearingHouse, wallet.publicKey);
+	const user = new ClearingHouseUser({
+		clearingHouse,
+		userAccountPublicKey: await clearingHouse.getUserAccountPublicKey(),
+	});
 
 	//// Check if clearing house account exists for the current wallet
 	const userAccountExists = await user.exists();
@@ -84,19 +87,21 @@ const main = async () => {
 			await getTokenAddress(
 				usdcTokenAddress.toString(),
 				wallet.publicKey.toString()
-			)
+			),
+			Banks['devnet'][0].bankIndex
 		);
 	}
 
 	await user.subscribe();
 
 	// Get current price
-	const solMarketInfo = Markets.find(
+	const solMarketInfo = sdkConfig.MARKETS.find(
 		(market) => market.baseAssetSymbol === 'SOL'
 	);
 
 	const currentMarketPrice = calculateMarkPrice(
-		clearingHouse.getMarket(solMarketInfo.marketIndex)
+		clearingHouse.getMarketAccount(solMarketInfo.marketIndex),
+		undefined
 	);
 
 	const formattedPrice = convertToNumber(
@@ -107,14 +112,18 @@ const main = async () => {
 	console.log(`Current Market Price is $${formattedPrice}`);
 
 	// Estimate the slippage for a $5000 LONG trade
-	const solMarketAccount = clearingHouse.getMarket(solMarketInfo.marketIndex);
+	const solMarketAccount = clearingHouse.getMarketAccount(
+		solMarketInfo.marketIndex
+	);
 
 	const longAmount = new BN(5000).mul(QUOTE_PRECISION);
 	const slippage = convertToNumber(
 		calculateTradeSlippage(
 			PositionDirection.LONG,
 			longAmount,
-			solMarketAccount
+			solMarketAccount,
+			'quote',
+			undefined
 		)[0],
 		MARK_PRICE_PRECISION
 	);