@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.31

package/lib/types.js

@@ -1,22 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TradeSide = exports.isOneOfVariant = exports.isVariant = exports.OrderTriggerCondition = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.PositionDirection = exports.BankBalanceType = exports.SwapDirection = void 0;
+exports.DefaultOrderParams = exports.LiquidationType = exports.LPAction = exports.TradeSide = exports.getVariant = exports.isOneOfVariant = exports.isVariant = exports.SpotFulfillmentStatus = exports.SpotFulfillmentType = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.MarketType = exports.OrderType = exports.OracleSource = exports.DepositDirection = exports.PositionDirection = exports.SpotBalanceType = exports.SwapDirection = exports.AssetTier = exports.ContractTier = exports.ContractType = exports.MarketStatus = exports.ExchangeStatus = void 0;
+const _1 = require(".");
 // # Utility Types / Enums / Constants
+class ExchangeStatus {
+}
+exports.ExchangeStatus = ExchangeStatus;
+ExchangeStatus.ACTIVE = { active: {} };
+ExchangeStatus.FUNDINGPAUSED = { fundingpaused: {} };
+ExchangeStatus.AMMPAUSED = { ammpaused: {} };
+ExchangeStatus.FILLPAUSED = { fillpaused: {} };
+ExchangeStatus.LIQPAUSED = { liqpaused: {} };
+ExchangeStatus.WITHDRAWPAUSED = { withdrawpaused: {} };
+ExchangeStatus.PAUSED = { paused: {} };
+class MarketStatus {
+}
+exports.MarketStatus = MarketStatus;
+MarketStatus.INITIALIZED = { initialized: {} };
+MarketStatus.ACTIVE = { active: {} };
+MarketStatus.FUNDINGPAUSED = { fundingpaused: {} };
+MarketStatus.AMMPAUSED = { ammpaused: {} };
+MarketStatus.FILLPAUSED = { fillpaused: {} };
+MarketStatus.WITHDRAWPAUSED = { withdrawpaused: {} };
+MarketStatus.REDUCEONLY = { reduceonly: {} };
+MarketStatus.SETTLEMENT = { settlement: {} };
+MarketStatus.DELISTED = { delisted: {} };
+class ContractType {
+}
+exports.ContractType = ContractType;
+ContractType.PERPETUAL = { perpetual: {} };
+ContractType.FUTURE = { future: {} };
+class ContractTier {
+}
+exports.ContractTier = ContractTier;
+ContractTier.A = { a: {} };
+ContractTier.B = { b: {} };
+ContractTier.C = { c: {} };
+ContractTier.Speculative = { speculative: {} };
+class AssetTier {
+}
+exports.AssetTier = AssetTier;
+AssetTier.COLLATERAL = { collateral: {} };
+AssetTier.PROTECTED = { protected: {} };
+AssetTier.CROSS = { cross: {} };
+AssetTier.ISOLATED = { isolated: {} };
+AssetTier.UNLISTED = { unlisted: {} };
 class SwapDirection {
 }
 exports.SwapDirection = SwapDirection;
 SwapDirection.ADD = { add: {} };
 SwapDirection.REMOVE = { remove: {} };
-class BankBalanceType {
+class SpotBalanceType {
 }
-exports.BankBalanceType = BankBalanceType;
-BankBalanceType.DEPOSIT = { deposit: {} };
-BankBalanceType.BORROW = { borrow: {} };
+exports.SpotBalanceType = SpotBalanceType;
+SpotBalanceType.DEPOSIT = { deposit: {} };
+SpotBalanceType.BORROW = { borrow: {} };
 class PositionDirection {
 }
 exports.PositionDirection = PositionDirection;
 PositionDirection.LONG = { long: {} };
 PositionDirection.SHORT = { short: {} };
+class DepositDirection {
+}
+exports.DepositDirection = DepositDirection;
+DepositDirection.DEPOSIT = { deposit: {} };
+DepositDirection.WITHDRAW = { withdraw: {} };
 class OracleSource {
 }
 exports.OracleSource = OracleSource;
@@ -30,6 +78,11 @@ OrderType.LIMIT = { limit: {} };
 OrderType.TRIGGER_MARKET = { triggerMarket: {} };
 OrderType.TRIGGER_LIMIT = { triggerLimit: {} };
 OrderType.MARKET = { market: {} };
+class MarketType {
+}
+exports.MarketType = MarketType;
+MarketType.SPOT = { spot: {} };
+MarketType.PERP = { perp: {} };
 class OrderStatus {
 }
 exports.OrderStatus = OrderStatus;
@@ -51,11 +104,36 @@ OrderAction.CANCEL = { cancel: {} };
 OrderAction.EXPIRE = { expire: {} };
 OrderAction.FILL = { fill: {} };
 OrderAction.TRIGGER = { trigger: {} };
+class OrderActionExplanation {
+}
+exports.OrderActionExplanation = OrderActionExplanation;
+OrderActionExplanation.NONE = { none: {} };
+OrderActionExplanation.ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
+    oraclePriceBreachedLimitPrice: {},
+};
+OrderActionExplanation.MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
+    marketOrderFilledToLimitPrice: {},
+};
+OrderActionExplanation.CANCELED_FOR_LIQUIDATION = {
+    canceledForLiquidation: {},
+};
+OrderActionExplanation.MARKET_ORDER_AUCTION_EXPIRED = {
+    marketOrderAuctionExpired: {},
+};
 class OrderTriggerCondition {
 }
 exports.OrderTriggerCondition = OrderTriggerCondition;
 OrderTriggerCondition.ABOVE = { above: {} };
 OrderTriggerCondition.BELOW = { below: {} };
+class SpotFulfillmentType {
+}
+exports.SpotFulfillmentType = SpotFulfillmentType;
+SpotFulfillmentType.SERUM_v3 = { serumV3: {} };
+class SpotFulfillmentStatus {
+}
+exports.SpotFulfillmentStatus = SpotFulfillmentStatus;
+SpotFulfillmentStatus.ENABLED = { enabled: {} };
+SpotFulfillmentStatus.DISABLED = { disabled: {} };
 function isVariant(object, type) {
     return object.hasOwnProperty(type);
 }
@@ -66,9 +144,55 @@ function isOneOfVariant(object, types) {
     }, false);
 }
 exports.isOneOfVariant = isOneOfVariant;
+function getVariant(object) {
+    return Object.keys(object)[0];
+}
+exports.getVariant = getVariant;
 var TradeSide;
 (function (TradeSide) {
     TradeSide[TradeSide["None"] = 0] = "None";
     TradeSide[TradeSide["Buy"] = 1] = "Buy";
     TradeSide[TradeSide["Sell"] = 2] = "Sell";
 })(TradeSide = exports.TradeSide || (exports.TradeSide = {}));
+class LPAction {
+}
+exports.LPAction = LPAction;
+LPAction.ADD_LIQUIDITY = { addLiquidity: {} };
+LPAction.REMOVE_LIQUIDITY = { removeLiquidity: {} };
+LPAction.SETTLE_LIQUIDITY = { settleLiquidity: {} };
+class LiquidationType {
+}
+exports.LiquidationType = LiquidationType;
+LiquidationType.LIQUIDATE_PERP = { liquidatePerp: {} };
+LiquidationType.LIQUIDATE_BORROW = { liquidateBorrow: {} };
+LiquidationType.LIQUIDATE_BORROW_FOR_PERP_PNL = {
+    liquidateBorrowForPerpPnl: {},
+};
+LiquidationType.LIQUIDATE_PERP_PNL_FOR_DEPOSIT = {
+    liquidatePerpPnlForDeposit: {},
+};
+LiquidationType.PERP_BANKRUPTCY = {
+    perpBankruptcy: {},
+};
+LiquidationType.BORROW_BANKRUPTCY = {
+    borrowBankruptcy: {},
+};
+exports.DefaultOrderParams = {
+    orderType: OrderType.MARKET,
+    marketType: MarketType.PERP,
+    userOrderId: 0,
+    direction: PositionDirection.LONG,
+    baseAssetAmount: _1.ZERO,
+    price: _1.ZERO,
+    marketIndex: 0,
+    reduceOnly: false,
+    postOnly: false,
+    immediateOrCancel: false,
+    triggerPrice: null,
+    triggerCondition: OrderTriggerCondition.ABOVE,
+    positionLimit: _1.ZERO,
+    oraclePriceOffset: null,
+    auctionDuration: null,
+    timeInForce: null,
+    auctionStartPrice: null,
+};

package/lib/userMap/userMap.d.ts

@@ -0,0 +1,25 @@
+import { ClearingHouseUser, ClearingHouse, OrderRecord, ClearingHouseUserAccountSubscriptionConfig } from '..';
+import { PublicKey } from '@solana/web3.js';
+export declare class UserMap {
+    private userMap;
+    private clearingHouse;
+    private accountSubscription;
+    constructor(clearingHouse: ClearingHouse, accountSubscription: ClearingHouseUserAccountSubscriptionConfig);
+    fetchAllUsers(): Promise<void>;
+    addPubkey(userAccountPublicKey: PublicKey): Promise<void>;
+    has(key: string): boolean;
+    /**
+     * gets the ClearingHouseUser for a particular userAccountPublicKey, if no ClearingHouseUser exists, undefined is returned
+     * @param key userAccountPublicKey to get ClearngHouseUserFor
+     * @returns user ClearingHouseUser | undefined
+     */
+    get(key: string): ClearingHouseUser | undefined;
+    /**
+     * gets the ClearingHouseUser for a particular userAccountPublicKey, if no ClearingHouseUser exists, new one is created
+     * @param key userAccountPublicKey to get ClearngHouseUserFor
+     * @returns  ClearingHouseUser
+     */
+    mustGet(key: string): Promise<ClearingHouseUser>;
+    updateWithOrderRecord(record: OrderRecord): Promise<void>;
+    values(): IterableIterator<ClearingHouseUser>;
+}

package/lib/userMap/userMap.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserMap = void 0;
+const __1 = require("..");
+const web3_js_1 = require("@solana/web3.js");
+class UserMap {
+    constructor(clearingHouse, accountSubscription) {
+        this.userMap = new Map();
+        this.clearingHouse = clearingHouse;
+        this.accountSubscription = accountSubscription;
+    }
+    async fetchAllUsers() {
+        const userArray = [];
+        const programUserAccounts = (await this.clearingHouse.program.account.user.all());
+        for (const programUserAccount of programUserAccounts) {
+            if (this.userMap.has(programUserAccount.publicKey.toString())) {
+                continue;
+            }
+            const user = new __1.ClearingHouseUser({
+                clearingHouse: this.clearingHouse,
+                userAccountPublicKey: programUserAccount.publicKey,
+                accountSubscription: this.accountSubscription,
+            });
+            userArray.push(user);
+        }
+        if (this.accountSubscription.type === 'polling') {
+            await (0, __1.bulkPollingUserSubscribe)(userArray, this.accountSubscription.accountLoader);
+        }
+        for (const user of userArray) {
+            this.userMap.set(user.getUserAccountPublicKey().toString(), user);
+        }
+    }
+    async addPubkey(userAccountPublicKey) {
+        const user = new __1.ClearingHouseUser({
+            clearingHouse: this.clearingHouse,
+            userAccountPublicKey,
+            accountSubscription: this.accountSubscription,
+        });
+        await user.subscribe();
+        this.userMap.set(userAccountPublicKey.toString(), user);
+    }
+    has(key) {
+        return this.userMap.has(key);
+    }
+    /**
+     * gets the ClearingHouseUser for a particular userAccountPublicKey, if no ClearingHouseUser exists, undefined is returned
+     * @param key userAccountPublicKey to get ClearngHouseUserFor
+     * @returns user ClearingHouseUser | undefined
+     */
+    get(key) {
+        return this.userMap.get(key);
+    }
+    /**
+     * gets the ClearingHouseUser for a particular userAccountPublicKey, if no ClearingHouseUser exists, new one is created
+     * @param key userAccountPublicKey to get ClearngHouseUserFor
+     * @returns  ClearingHouseUser
+     */
+    async mustGet(key) {
+        if (!this.has(key)) {
+            await this.addPubkey(new web3_js_1.PublicKey(key));
+        }
+        const user = this.userMap.get(key);
+        await user.fetchAccounts();
+        return user;
+    }
+    async updateWithOrderRecord(record) {
+        await this.addPubkey(record.user);
+    }
+    values() {
+        return this.userMap.values();
+    }
+}
+exports.UserMap = UserMap;

package/lib/userMap/userStatsMap.d.ts

@@ -0,0 +1,19 @@
+import { ClearingHouse, OrderRecord, ClearingHouseUserStats, ClearingHouseUserStatsAccountSubscriptionConfig } from '..';
+import { PublicKey } from '@solana/web3.js';
+import { UserMap } from './userMap';
+export declare class UserStatsMap {
+    /**
+     * map from authority pubkey to ClearingHouseUserStats
+     */
+    private userStatsMap;
+    private clearingHouse;
+    private accountSubscription;
+    constructor(clearingHouse: ClearingHouse, accountSubscription: ClearingHouseUserStatsAccountSubscriptionConfig);
+    fetchAllUserStats(): Promise<void>;
+    addUserStat(authority: PublicKey): Promise<void>;
+    updateWithOrderRecord(record: OrderRecord, userMap: UserMap): Promise<void>;
+    has(authorityPublicKey: string): boolean;
+    get(authorityPublicKey: string): ClearingHouseUserStats;
+    mustGet(authorityPublicKey: string): Promise<ClearingHouseUserStats>;
+    values(): IterableIterator<ClearingHouseUserStats>;
+}

package/lib/userMap/userStatsMap.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserStatsMap = void 0;
+const __1 = require("..");
+const web3_js_1 = require("@solana/web3.js");
+class UserStatsMap {
+    constructor(clearingHouse, accountSubscription) {
+        /**
+         * map from authority pubkey to ClearingHouseUserStats
+         */
+        this.userStatsMap = new Map();
+        this.clearingHouse = clearingHouse;
+        this.accountSubscription = accountSubscription;
+    }
+    async fetchAllUserStats() {
+        const userStatArray = [];
+        const programUserAccounts = (await this.clearingHouse.program.account.userStats.all());
+        for (const programUserAccount of programUserAccounts) {
+            const userStat = programUserAccount.account;
+            if (this.userStatsMap.has(userStat.authority.toString())) {
+                continue;
+            }
+            const chUserStat = new __1.ClearingHouseUserStats({
+                clearingHouse: this.clearingHouse,
+                userStatsAccountPublicKey: (0, __1.getUserStatsAccountPublicKey)(this.clearingHouse.program.programId, userStat.authority),
+                accountSubscription: this.accountSubscription,
+            });
+            userStatArray.push(chUserStat);
+        }
+        if (this.accountSubscription.type === 'polling') {
+            await (0, __1.bulkPollingUserStatsSubscribe)(userStatArray, this.accountSubscription.accountLoader);
+        }
+        for (const userStat of userStatArray) {
+            this.userStatsMap.set(userStat.getAccount().authority.toString(), userStat);
+        }
+    }
+    async addUserStat(authority) {
+        const userStat = new __1.ClearingHouseUserStats({
+            clearingHouse: this.clearingHouse,
+            userStatsAccountPublicKey: (0, __1.getUserStatsAccountPublicKey)(this.clearingHouse.program.programId, authority),
+            accountSubscription: this.accountSubscription,
+        });
+        await userStat.subscribe();
+        this.userStatsMap.set(authority.toString(), userStat);
+    }
+    async updateWithOrderRecord(record, userMap) {
+        if (!this.has(record.user.toString())) {
+            const takerUserAccount = await userMap.mustGet(record.user.toString());
+            this.addUserStat(takerUserAccount.getUserAccount().authority);
+        }
+    }
+    has(authorityPublicKey) {
+        return this.userStatsMap.has(authorityPublicKey);
+    }
+    get(authorityPublicKey) {
+        return this.userStatsMap.get(authorityPublicKey);
+    }
+    async mustGet(authorityPublicKey) {
+        if (!this.has(authorityPublicKey)) {
+            await this.addUserStat(new web3_js_1.PublicKey(authorityPublicKey));
+        }
+        return this.get(authorityPublicKey);
+    }
+    values() {
+        return this.userStatsMap.values();
+    }
+}
+exports.UserStatsMap = UserStatsMap;

package/lib/util/computeUnits.js

@@ -4,7 +4,7 @@ exports.findComputeUnitConsumption = void 0;
 async function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
     const tx = await connection.getTransaction(txSignature, { commitment });
     const computeUnits = [];
-    const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of 200000 compute units`);
+    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]) {

package/lib/util/getTokenAddress.d.ts

@@ -0,0 +1,2 @@
+import { PublicKey } from '@solana/web3.js';
+export declare const getTokenAddress: (mintAddress: string, userPubKey: string) => Promise<PublicKey>;

package/lib/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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.2.0-master.3",
+	"version": "0.2.0-master.31",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -14,7 +14,11 @@
 		"build": "yarn clean && tsc",
 		"clean": "rm -rf lib",
 		"test": "mocha -r ts-node/register tests/**/*.ts",
-		"patch-and-pub": "npm version patch --force && npm publish"
+		"test:inspect": "mocha --inspect-brk -r ts-node/register tests/**/*.ts",
+		"test:bignum": "mocha -r ts-node/register tests/bn/**/*.ts",
+		"patch-and-pub": "npm version patch --force && npm publish",
+		"prettify": "prettier --check './src/***/*.ts'",
+		"prettify:fix": "prettier --write './{src,tests}/***/*.ts'"
 	},
 	"keywords": [
 		"drift-labs",
@@ -29,8 +33,9 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@project-serum/anchor": "0.24.2",
-		"@pythnetwork/client": "2.5.1",
+		"@project-serum/serum": "^0.13.38",
+		"@project-serum/anchor": "0.25.0-beta.1",
+		"@pythnetwork/client": "2.5.3",
 		"@solana/spl-token": "^0.1.6",
 		"@solana/web3.js": "1.41.0",
 		"@switchboard-xyz/switchboard-v2": "^0.0.67",
@@ -39,16 +44,17 @@
 	},
 	"devDependencies": {
 		"@types/chai": "^4.3.1",
+		"@types/jest": "^28.1.3",
 		"@types/mocha": "^9.1.1",
 		"@typescript-eslint/eslint-plugin": "^4.28.0",
 		"@typescript-eslint/parser": "^4.28.0",
-		"@types/jest": "^28.1.3",
 		"chai": "^4.3.6",
 		"eslint": "^7.29.0",
 		"eslint-config-prettier": "^8.3.0",
 		"eslint-plugin-prettier": "^3.4.0",
 		"mocha": "^10.0.0",
-		"ts-node": "^10.8.0"
+		"ts-node": "^10.8.0",
+		"prettier": "^2.4.1"
 	},
 	"description": "SDK for Drift Protocol v1",
 	"engines": {

package/src/accounts/bulkUserStatsSubscription.ts

@@ -0,0 +1,33 @@
+import { ClearingHouseUserStats } from '../clearingHouseUserStats';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { PollingUserStatsAccountSubscriber } from './pollingUserStatsAccountSubscriber';
+
+/**
+ * @param userStats
+ * @param accountLoader
+ */
+export async function bulkPollingUserStatsSubscribe(
+	userStats: ClearingHouseUserStats[],
+	accountLoader: BulkAccountLoader
+): Promise<void> {
+	if (userStats.length === 0) {
+		await accountLoader.load();
+		return;
+	}
+
+	await Promise.all(
+		userStats.map((userStat) => {
+			return (
+				userStat.accountSubscriber as PollingUserStatsAccountSubscriber
+			).addToAccountLoader();
+		})
+	);
+
+	await accountLoader.load();
+
+	await Promise.all(
+		userStats.map(async (userStat) => {
+			return userStat.subscribe();
+		})
+	);
+}

package/src/accounts/bulkUserSubscription.ts

@@ -17,7 +17,6 @@ export async function bulkPollingUserSubscribe(
 
 	await Promise.all(
 		users.map((user) => {
-			// Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
 			return (
 				user.accountSubscriber as PollingUserAccountSubscriber
 			).addToAccountLoader();

package/src/accounts/fetch.ts

@@ -1,6 +1,9 @@
 import { Connection, PublicKey } from '@solana/web3.js';
-import { UserAccount } from '../types';
-import { getUserAccountPublicKey } from '../addresses/pda';
+import { UserAccount, UserStatsAccount } from '../types';
+import {
+	getUserAccountPublicKey,
+	getUserStatsAccountPublicKey,
+} from '../addresses/pda';
 import { Program } from '@project-serum/anchor';
 
 export async function fetchUserAccounts(
@@ -31,3 +34,25 @@ export async function fetchUserAccounts(
 		) as UserAccount;
 	});
 }
+
+export async function fetchUserStatsAccount(
+	connection: Connection,
+	program: Program,
+	authority: PublicKey
+): Promise<UserStatsAccount | undefined> {
+	const userStatsPublicKey = getUserStatsAccountPublicKey(
+		program.programId,
+		authority
+	);
+	const accountInfo = await connection.getAccountInfo(
+		userStatsPublicKey,
+		'confirmed'
+	);
+
+	return accountInfo
+		? (program.account.user.coder.accounts.decode(
+				'UserStats',
+				accountInfo.data
+		  ) as UserStatsAccount)
+		: undefined;
+}