@drift-labs/sdk 2.8.0 → 2.9.0-beta.0

package/lib/accounts/types.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { SpotMarketAccount, PerpMarketAccount, OracleSource, StateAccount, UserAccount, UserStatsAccount } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';

package/lib/dlob/DLOB.d.ts

@@ -67,7 +67,7 @@ export declare class DLOB {
     getLimitBids(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
     getAsks(marketIndex: number, fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
     getBids(marketIndex: number, fallbackBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
-    findCrossingLimitOrders(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
+    findCrossingLimitOrders(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
     determineMakerAndTaker(askNode: DLOBNode, bidNode: DLOBNode): {
         takerNode: DLOBNode;
         makerNode: DLOBNode;

package/lib/dlob/DLOB.js

@@ -261,7 +261,7 @@ class DLOB {
     }
     findLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
-        const crossingNodes = this.findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData);
+        const crossingNodes = this.findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData, fallbackAsk, fallbackBid);
         for (const crossingNode of crossingNodes) {
             nodesToFill.push(crossingNode);
         }
@@ -584,7 +584,7 @@ class DLOB {
             return bestPrice.gt(currentPrice);
         });
     }
-    findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData) {
+    findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
         for (const askNode of this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData)) {
             for (const bidNode of this.getLimitBids(marketIndex, slot, marketType, oraclePriceData)) {
@@ -602,6 +602,22 @@ class DLOB {
                     continue;
                 }
                 const { takerNode, makerNode } = this.determineMakerAndTaker(askNode, bidNode);
+                // extra guard against bad fills for limit orders where auction is incomplete
+                if (!(0, __1.isAuctionComplete)(takerNode.order, slot)) {
+                    let bidPrice;
+                    let askPrice;
+                    if ((0, __1.isVariant)(takerNode.order.direction, 'long')) {
+                        bidPrice = __1.BN.min(takerNode.getPrice(oraclePriceData, slot), fallbackAsk || __1.BN_MAX);
+                        askPrice = makerNode.getPrice(oraclePriceData, slot);
+                    }
+                    else {
+                        bidPrice = makerNode.getPrice(oraclePriceData, slot);
+                        askPrice = __1.BN.max(takerNode.getPrice(oraclePriceData, slot), fallbackBid || __1.ZERO);
+                    }
+                    if (bidPrice.lt(askPrice)) {
+                        continue;
+                    }
+                }
                 const bidBaseRemaining = bidOrder.baseAssetAmount.sub(bidOrder.baseAssetAmountFilled);
                 const askBaseRemaining = askOrder.baseAssetAmount.sub(askOrder.baseAssetAmountFilled);
                 const baseFilled = __1.BN.min(bidBaseRemaining, askBaseRemaining);

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.8.0",
+    "version": "2.9.0-beta.0",
     "name": "drift",
     "instructions": [
         {

package/lib/tx/retryTxSender.js

@@ -22,10 +22,10 @@ class RetryTxSender {
         if (opts === undefined) {
             opts = this.provider.opts;
         }
-        if (!preSigned) {
-            await this.prepareTx(tx, additionalSigners, opts);
-        }
-        const rawTransaction = tx.serialize();
+        const signedTx = preSigned
+            ? tx
+            : await this.prepareTx(tx, additionalSigners, opts);
+        const rawTransaction = signedTx.serialize();
         const startTime = this.getTimestamp();
         let txid;
         try {
@@ -77,13 +77,13 @@ class RetryTxSender {
     async prepareTx(tx, additionalSigners, opts) {
         tx.feePayer = this.provider.wallet.publicKey;
         tx.recentBlockhash = (await this.provider.connection.getRecentBlockhash(opts.preflightCommitment)).blockhash;
-        await this.provider.wallet.signTransaction(tx);
+        const signedTx = await this.provider.wallet.signTransaction(tx);
         additionalSigners
             .filter((s) => s !== undefined)
             .forEach((kp) => {
-            tx.partialSign(kp);
+            signedTx.partialSign(kp);
         });
-        return tx;
+        return signedTx;
     }
     async confirmTransaction(signature, commitment) {
         let decodedSignature;

package/lib/userMap/userStatsMap.js

@@ -31,7 +31,6 @@ class UserStatsMap {
             await (0, __1.bulkPollingUserStatsSubscribe)(userStatArray, this.accountSubscription.accountLoader);
         }
         for (const userStat of userStatArray) {
-            await userStat.subscribe();
             this.userStatsMap.set(userStat.getAccount().authority.toString(), userStat);
         }
     }

package/package.json

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

package/src/assert/assert.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+function assert(condition, error) {
+    if (!condition) {
+        throw new Error(error || 'Unspecified AssertionError');
+    }
+}
+exports.assert = assert;

package/src/dlob/DLOB.ts

@@ -26,6 +26,8 @@ import {
 	UserMap,
 	OrderRecord,
 	OrderActionRecord,
+	ZERO,
+	BN_MAX,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { DLOBNode, DLOBNodeType, TriggerOrderNode } from '..';
@@ -440,7 +442,9 @@ export class DLOB {
 			marketIndex,
 			slot,
 			marketType,
-			oraclePriceData
+			oraclePriceData,
+			fallbackAsk,
+			fallbackBid
 		);
 
 		for (const crossingNode of crossingNodes) {
@@ -1009,7 +1013,9 @@ export class DLOB {
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
-		oraclePriceData: OraclePriceData
+		oraclePriceData: OraclePriceData,
+		fallbackAsk: BN | undefined,
+		fallbackBid: BN | undefined
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
@@ -1047,6 +1053,29 @@ export class DLOB {
 					bidNode
 				);
 
+				// extra guard against bad fills for limit orders where auction is incomplete
+				if (!isAuctionComplete(takerNode.order, slot)) {
+					let bidPrice: BN;
+					let askPrice: BN;
+					if (isVariant(takerNode.order.direction, 'long')) {
+						bidPrice = BN.min(
+							takerNode.getPrice(oraclePriceData, slot),
+							fallbackAsk || BN_MAX
+						);
+						askPrice = makerNode.getPrice(oraclePriceData, slot);
+					} else {
+						bidPrice = makerNode.getPrice(oraclePriceData, slot);
+						askPrice = BN.max(
+							takerNode.getPrice(oraclePriceData, slot),
+							fallbackBid || ZERO
+						);
+					}
+
+					if (bidPrice.lt(askPrice)) {
+						continue;
+					}
+				}
+
 				const bidBaseRemaining = bidOrder.baseAssetAmount.sub(
 					bidOrder.baseAssetAmountFilled
 				);

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.DRIFT_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/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.8.0",
+  "version": "2.9.0-beta.0",
   "name": "drift",
   "instructions": [
     {

package/src/token/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokenAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+function parseTokenAccount(data) {
+    const accountInfo = spl_token_1.AccountLayout.decode(data);
+    accountInfo.mint = new web3_js_1.PublicKey(accountInfo.mint);
+    accountInfo.owner = new web3_js_1.PublicKey(accountInfo.owner);
+    accountInfo.amount = spl_token_1.u64.fromBuffer(accountInfo.amount);
+    if (accountInfo.delegateOption === 0) {
+        accountInfo.delegate = null;
+        // eslint-disable-next-line new-cap
+        accountInfo.delegatedAmount = new spl_token_1.u64(0);
+    }
+    else {
+        accountInfo.delegate = new web3_js_1.PublicKey(accountInfo.delegate);
+        accountInfo.delegatedAmount = spl_token_1.u64.fromBuffer(accountInfo.delegatedAmount);
+    }
+    accountInfo.isInitialized = accountInfo.state !== 0;
+    accountInfo.isFrozen = accountInfo.state === 2;
+    if (accountInfo.isNativeOption === 1) {
+        accountInfo.rentExemptReserve = spl_token_1.u64.fromBuffer(accountInfo.isNative);
+        accountInfo.isNative = true;
+    }
+    else {
+        accountInfo.rentExemptReserve = null;
+        accountInfo.isNative = false;
+    }
+    if (accountInfo.closeAuthorityOption === 0) {
+        accountInfo.closeAuthority = null;
+    }
+    else {
+        accountInfo.closeAuthority = new web3_js_1.PublicKey(accountInfo.closeAuthority);
+    }
+    return accountInfo;
+}
+exports.parseTokenAccount = parseTokenAccount;

package/src/tx/retryTxSender.ts

@@ -52,11 +52,11 @@ export class RetryTxSender implements TxSender {
 			opts = this.provider.opts;
 		}
 
-		if (!preSigned) {
-			await this.prepareTx(tx, additionalSigners, opts);
-		}
+		const signedTx = preSigned
+			? tx
+			: await this.prepareTx(tx, additionalSigners, opts);
 
-		const rawTransaction = tx.serialize();
+		const rawTransaction = signedTx.serialize();
 		const startTime = this.getTimestamp();
 
 		let txid: TransactionSignature;
@@ -123,14 +123,14 @@ export class RetryTxSender implements TxSender {
 			)
 		).blockhash;
 
-		await this.provider.wallet.signTransaction(tx);
+		const signedTx = await this.provider.wallet.signTransaction(tx);
 		additionalSigners
 			.filter((s): s is Signer => s !== undefined)
 			.forEach((kp) => {
-				tx.partialSign(kp);
+				signedTx.partialSign(kp);
 			});
 
-		return tx;
+		return signedTx;
 	}
 
 	async confirmTransaction(

package/src/tx/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/tx/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapInTx = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const COMPUTE_UNITS_DEFAULT = 200000;
+function wrapInTx(instruction, computeUnits = 600000 // TODO, requires less code change
+) {
+    const tx = new web3_js_1.Transaction();
+    if (computeUnits != COMPUTE_UNITS_DEFAULT) {
+        tx.add(web3_js_1.ComputeBudgetProgram.requestUnits({
+            units: computeUnits,
+            additionalFee: 0,
+        }));
+    }
+    return tx.add(instruction);
+}
+exports.wrapInTx = wrapInTx;

package/src/userMap/userStatsMap.ts

@@ -68,7 +68,6 @@ export class UserStatsMap {
 		}
 
 		for (const userStat of userStatArray) {
-			await userStat.subscribe();
 			this.userStatsMap.set(
 				userStat.getAccount().authority.toString(),
 				userStat

package/src/util/computeUnits.js

@@ -0,0 +1,27 @@
+"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.findComputeUnitConsumption = void 0;
+function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tx = yield connection.getTransaction(txSignature, { commitment });
+        const computeUnits = [];
+        const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of ([0-9]{0,7}) compute units`);
+        tx.meta.logMessages.forEach((logMessage) => {
+            const match = logMessage.match(regex);
+            if (match && match[1]) {
+                computeUnits.push(match[1]);
+            }
+        });
+        return computeUnits;
+    });
+}
+exports.findComputeUnitConsumption = findComputeUnitConsumption;

package/src/util/getTokenAddress.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenAddress = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const getTokenAddress = (mintAddress, userPubKey) => {
+    return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
+};
+exports.getTokenAddress = getTokenAddress;

package/src/util/promiseTimeout.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTimeout = void 0;
+function promiseTimeout(promise, timeoutMs) {
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => resolve(null), timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).then((result) => {
+        clearTimeout(timeoutId);
+        return result;
+    });
+}
+exports.promiseTimeout = promiseTimeout;

package/src/util/tps.js

@@ -0,0 +1,27 @@
+"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.estimateTps = void 0;
+function estimateTps(programId, connection, failed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let signatures = yield connection.getSignaturesForAddress(programId, undefined, 'finalized');
+        if (failed) {
+            signatures = signatures.filter((signature) => signature.err);
+        }
+        const numberOfSignatures = signatures.length;
+        if (numberOfSignatures === 0) {
+            return 0;
+        }
+        return (numberOfSignatures /
+            (signatures[0].blockTime - signatures[numberOfSignatures - 1].blockTime));
+    });
+}
+exports.estimateTps = estimateTps;

package/tests/dlob/test.ts

@@ -369,14 +369,16 @@ describe('DLOB Tests', () => {
 		expect(b).to.equal(3);
 
 		dlob.clear();
-		let thrown = false;
-		try {
-			const bids1 = dlob.getBids(marketIndex, vBid, 0, MarketType.PERP, oracle);
-			bids1.next();
-		} catch (e) {
-			thrown = true;
-		}
-		expect(thrown, 'should throw after clearing').to.equal(true);
+
+		const bids1 = dlob.getBids(
+			marketIndex,
+			undefined,
+			0,
+			MarketType.PERP,
+			oracle
+		);
+		bids1.next();
+		expect(bids1.next().done, 'bid generator should be done').to.equal(true);
 	});
 
 	it('DLOB orders', () => {