@drift-labs/sdk 0.2.0-master.11 → 0.2.0-master.14

package/lib/tokenFaucet.js

@@ -73,8 +73,8 @@ class TokenFaucet {
     async fetchState() {
         return await this.program.account.faucetConfig.fetch(await this.getFaucetConfigPublicKey());
     }
-    async mintToUser(userTokenAccount, amount) {
-        return await this.program.rpc.mintToUser(amount, {
+    async mintToUserIx(userTokenAccount, amount) {
+        return this.program.instruction.mintToUser(amount, {
             accounts: {
                 faucetConfig: await this.getFaucetConfigPublicKey(),
                 mintAccount: this.mint,
@@ -84,6 +84,12 @@ class TokenFaucet {
             },
         });
     }
+    async mintToUser(userTokenAccount, amount) {
+        const mintIx = await this.mintToUserIx(userTokenAccount, amount);
+        const tx = new web3_js_1.Transaction().add(mintIx);
+        const txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
+        return txSig;
+    }
     async transferMintAuthority() {
         return await this.program.rpc.transferMintAuthority({
             accounts: {
@@ -96,8 +102,21 @@ class TokenFaucet {
         });
     }
     async createAssociatedTokenAccountAndMintTo(userPublicKey, amount) {
+        const tx = new web3_js_1.Transaction();
         const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] = await this.createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount);
-        const tx = new web3_js_1.Transaction().add(createAssociatedAccountIx).add(mintToTx);
+        let associatedTokenAccountExists = false;
+        try {
+            const assosciatedTokenAccount = await this.connection.getAccountInfo(associatedTokenPublicKey);
+            associatedTokenAccountExists = !!assosciatedTokenAccount;
+        }
+        catch (e) {
+            // token account doesn't exist
+            associatedTokenAccountExists = false;
+        }
+        const skipAccountCreation = associatedTokenAccountExists;
+        if (!skipAccountCreation)
+            tx.add(createAssociatedAccountIx);
+        tx.add(mintToTx);
         const txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
         return [associatedTokenPublicKey, txSig];
     }
@@ -105,15 +124,7 @@ class TokenFaucet {
         const state = await this.fetchState();
         const associateTokenPublicKey = await this.getAssosciatedMockUSDMintAddress({ userPubKey: userPublicKey });
         const createAssociatedAccountIx = spl_token_1.Token.createAssociatedTokenAccountInstruction(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.mint, associateTokenPublicKey, userPublicKey, this.wallet.publicKey);
-        const mintToIx = await this.program.instruction.mintToUser(amount, {
-            accounts: {
-                faucetConfig: await this.getFaucetConfigPublicKey(),
-                mintAccount: state.mint,
-                userTokenAccount: associateTokenPublicKey,
-                mintAuthority: state.mintAuthority,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
+        const mintToIx = await this.mintToUserIx(associateTokenPublicKey, amount);
         return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
     }
     async getAssosciatedMockUSDMintAddress(props) {

package/lib/tx/retryTxSender.js

@@ -25,8 +25,15 @@ class RetryTxSender {
         await this.prepareTx(tx, additionalSigners, opts);
         const rawTransaction = tx.serialize();
         const startTime = this.getTimestamp();
-        const txid = await this.provider.connection.sendRawTransaction(rawTransaction, opts);
-        this.sendToAdditionalConnections(rawTransaction, opts);
+        let txid;
+        try {
+            txid = await this.provider.connection.sendRawTransaction(rawTransaction, opts);
+            this.sendToAdditionalConnections(rawTransaction, opts);
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
         let done = false;
         const resolveReference = {
             resolve: undefined,

package/lib/types.d.ts

@@ -113,6 +113,12 @@ export declare class OrderActionExplanation {
     static readonly MARKET_ORDER_FILLED_TO_LIMIT_PRICE: {
         marketOrderFilledToLimitPrice: {};
     };
+    static readonly CANCELED_FOR_LIQUIDATION: {
+        canceledForLiquidation: {};
+    };
+    static readonly MARKET_ORDER_AUCTION_EXPIRED: {
+        marketOrderAuctionExpired: {};
+    };
 }
 export declare class OrderTriggerCondition {
     static readonly ABOVE: {
@@ -192,10 +198,13 @@ export declare type LiquidationRecord = {
     liquidationType: LiquidationType;
     marginRequirement: BN;
     totalCollateral: BN;
+    liquidationId: number;
     liquidatePerp: LiquidatePerpRecord;
     liquidateBorrow: LiquidateBorrowRecord;
     liquidateBorrowForPerpPnl: LiquidateBorrowForPerpPnlRecord;
     liquidatePerpPnlForDeposit: LiquidatePerpPnlForDepositRecord;
+    perpBankruptcy: PerpBankruptcyRecord;
+    borrowBankruptcy: BorrowBankruptcyRecord;
 };
 export declare class LiquidationType {
     static readonly LIQUIDATE_PERP: {
@@ -210,6 +219,12 @@ export declare class LiquidationType {
     static readonly LIQUIDATE_PERP_PNL_FOR_DEPOSIT: {
         liquidatePerpPnlForDeposit: {};
     };
+    static readonly PERP_BANKRUPTCY: {
+        perpBankruptcy: {};
+    };
+    static readonly BORROW_BANKRUPTCY: {
+        borrowBankruptcy: {};
+    };
 }
 export declare type LiquidatePerpRecord = {
     marketIndex: BN;
@@ -248,14 +263,34 @@ export declare type LiquidatePerpPnlForDepositRecord = {
     assetPrice: BN;
     assetTransfer: BN;
 };
+export declare type PerpBankruptcyRecord = {
+    marketIndex: BN;
+    pnl: BN;
+    cumulativeFundingRateDelta: BN;
+};
+export declare type BorrowBankruptcyRecord = {
+    bankIndex: BN;
+    borrowAmount: BN;
+    cumulativeDepositInterestDelta: BN;
+};
+export declare type SettlePnlRecord = {
+    ts: BN;
+    user: PublicKey;
+    marketIndex: BN;
+    pnl: BN;
+    baseAssetAmount: BN;
+    quoteAssetAmountAfter: BN;
+    quoteEntryamount: BN;
+    settlePrice: BN;
+};
 export declare type OrderRecord = {
     ts: BN;
     taker: PublicKey;
     maker: PublicKey;
     takerOrder: Order;
     makerOrder: Order;
-    takerUnsettledPnl: BN;
-    makerUnsettledPnl: BN;
+    takerPnl: BN;
+    makerPnl: BN;
     action: OrderAction;
     actionExplanation: OrderActionExplanation;
     filler: PublicKey;
@@ -313,6 +348,10 @@ export declare type MarketAccount = {
     nextFillRecordId: BN;
     pnlPool: PoolBalance;
     liquidationFee: BN;
+    imfFactor: BN;
+    unsettledImfFactor: BN;
+    unsettledInitialAssetWeight: number;
+    unsettledMaintenanceAssetWeight: number;
 };
 export declare type BankAccount = {
     bankIndex: BN;
@@ -336,6 +375,11 @@ export declare type BankAccount = {
     initialLiabilityWeight: BN;
     maintenanceLiabilityWeight: BN;
     liquidationFee: BN;
+    imfFactor: BN;
+    withdrawGuardThreshold: BN;
+    depositTokenTwap: BN;
+    borrowTokenTwap: BN;
+    utilizationTwap: BN;
 };
 export declare type PoolBalance = {
     balance: BN;
@@ -347,8 +391,10 @@ export declare type AMM = {
     lastFundingRate: BN;
     lastFundingRateTs: BN;
     lastMarkPriceTwap: BN;
+    lastMarkPriceTwap5min: BN;
     lastMarkPriceTwapTs: BN;
     lastOraclePriceTwap: BN;
+    lastOraclePriceTwap5min: BN;
     lastOraclePriceTwapTs: BN;
     lastOracleMarkSpreadPct: BN;
     lastOracleConfPct: BN;
@@ -359,11 +405,16 @@ export declare type AMM = {
     pegMultiplier: BN;
     cumulativeFundingRateLong: BN;
     cumulativeFundingRateShort: BN;
+    cumulativeFundingRateLp: BN;
     cumulativeRepegRebateLong: BN;
     cumulativeRepegRebateShort: BN;
     totalFeeMinusDistributions: BN;
     totalFeeWithdrawn: BN;
     totalFee: BN;
+    cumulativeFundingPaymentPerLp: BN;
+    cumulativeFeePerLp: BN;
+    cumulativeNetBaseAssetAmountPerLp: BN;
+    userLpShares: BN;
     minimumQuoteAssetTradeSize: BN;
     baseAssetAmountStepSize: BN;
     maxBaseAssetAmountRatio: number;
@@ -385,6 +436,8 @@ export declare type AMM = {
     longSpread: BN;
     shortSpread: BN;
     maxSpread: number;
+    marketPosition: UserPosition;
+    marketPositionPerLp: UserPosition;
 };
 export declare type UserPosition = {
     baseAssetAmount: BN;
@@ -393,17 +446,22 @@ export declare type UserPosition = {
     quoteAssetAmount: BN;
     quoteEntryAmount: BN;
     openOrders: BN;
-    unsettledPnl: BN;
     openBids: BN;
     openAsks: BN;
+    realizedPnl: BN;
+    lpShares: BN;
+    lastFeePerLp: BN;
+    lastNetBaseAssetAmountPerLp: BN;
+    lastNetQuoteAssetAmountPerLp: BN;
 };
-export declare type UserAccount = {
-    authority: PublicKey;
-    name: number[];
-    userId: number;
-    bankBalances: UserBankBalance[];
-    collateral: BN;
-    cumulativeDeposits: BN;
+export declare type UserStatsAccount = {
+    numberOfUsers: number;
+    makerVolume30D: BN;
+    takerVolume30D: BN;
+    fillerVolume30D: BN;
+    lastMakerVolume30DTs: BN;
+    lastTakerVolume30DTs: BN;
+    lastFillerVolume30DTs: BN;
     fees: {
         totalFeePaid: BN;
         totalFeeRebate: BN;
@@ -411,9 +469,17 @@ export declare type UserAccount = {
         totalReferralReward: BN;
         totalRefereeDiscount: BN;
     };
+};
+export declare type UserAccount = {
+    authority: PublicKey;
+    name: number[];
+    userId: number;
+    bankBalances: UserBankBalance[];
     positions: UserPosition[];
     orders: Order[];
     beingLiquidated: boolean;
+    bankrupt: boolean;
+    nextLiquidationId: number;
 };
 export declare type UserBankBalance = {
     bankIndex: BN;
@@ -508,10 +574,12 @@ export declare const DefaultOrderParams: {
 };
 export declare type MakerInfo = {
     maker: PublicKey;
+    makerStats: PublicKey;
     order: Order;
 };
 export declare type TakerInfo = {
     taker: PublicKey;
+    takerStats: PublicKey;
     order: Order;
 };
 export interface IWallet {

package/lib/types.js

@@ -70,6 +70,12 @@ OrderActionExplanation.ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
 OrderActionExplanation.MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
     marketOrderFilledToLimitPrice: {},
 };
+OrderActionExplanation.CANCELED_FOR_LIQUIDATION = {
+    canceledForLiquidation: {},
+};
+OrderActionExplanation.MARKET_ORDER_AUCTION_EXPIRED = {
+    marketOrderAuctionExpired: {},
+};
 class OrderTriggerCondition {
 }
 exports.OrderTriggerCondition = OrderTriggerCondition;
@@ -102,6 +108,12 @@ LiquidationType.LIQUIDATE_BORROW_FOR_PERP_PNL = {
 LiquidationType.LIQUIDATE_PERP_PNL_FOR_DEPOSIT = {
     liquidatePerpPnlForDeposit: {},
 };
+LiquidationType.PERP_BANKRUPTCY = {
+    perpBankruptcy: {},
+};
+LiquidationType.BORROW_BANKRUPTCY = {
+    borrowBankruptcy: {},
+};
 exports.DefaultOrderParams = {
     orderType: OrderType.MARKET,
     userOrderId: 0,

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.11",
+	"version": "0.2.0-master.14",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

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;
+}

package/src/accounts/pollingUserStatsAccountSubscriber.ts

@@ -0,0 +1,172 @@
+import {
+	DataAndSlot,
+	AccountToPoll,
+	NotSubscribedError,
+	UserStatsAccountSubscriber,
+	UserStatsAccountEvents,
+} from './types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { UserStatsAccount } from '../types';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { capitalize } from './utils';
+
+export class PollingUserStatsAccountSubscriber
+	implements UserStatsAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+	userStatsAccountPublicKey: PublicKey;
+
+	accountLoader: BulkAccountLoader;
+	accountsToPoll = new Map<string, AccountToPoll>();
+	errorCallbackId?: string;
+
+	userStats?: DataAndSlot<UserStatsAccount>;
+
+	public constructor(
+		program: Program,
+		userStatsAccountPublicKey: PublicKey,
+		accountLoader: BulkAccountLoader
+	) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.accountLoader = accountLoader;
+		this.eventEmitter = new EventEmitter();
+		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+	}
+
+	async subscribe(): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		await this.addToAccountLoader();
+
+		let subscriptionSucceeded = false;
+		let retries = 0;
+		while (!subscriptionSucceeded && retries < 5) {
+			await this.fetchIfUnloaded();
+			subscriptionSucceeded = this.didSubscriptionSucceed();
+			retries++;
+		}
+
+		if (subscriptionSucceeded) {
+			this.eventEmitter.emit('update');
+		}
+
+		this.isSubscribed = subscriptionSucceeded;
+		return subscriptionSucceeded;
+	}
+
+	async addToAccountLoader(): Promise<void> {
+		if (this.accountsToPoll.size > 0) {
+			return;
+		}
+
+		this.accountsToPoll.set(this.userStatsAccountPublicKey.toString(), {
+			key: 'userStats',
+			publicKey: this.userStatsAccountPublicKey,
+			eventType: 'userStatsAccountUpdate',
+		});
+
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			accountToPoll.callbackId = this.accountLoader.addAccount(
+				accountToPoll.publicKey,
+				(buffer, slot) => {
+					if (!buffer) {
+						return;
+					}
+
+					const account = this.program.account[
+						accountToPoll.key
+					].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
+					this[accountToPoll.key] = { data: account, slot };
+					// @ts-ignore
+					this.eventEmitter.emit(accountToPoll.eventType, account);
+					this.eventEmitter.emit('update');
+				}
+			);
+		}
+
+		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+			this.eventEmitter.emit('error', error);
+		});
+	}
+
+	async fetchIfUnloaded(): Promise<void> {
+		let shouldFetch = false;
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			if (this[accountToPoll.key] === undefined) {
+				shouldFetch = true;
+				break;
+			}
+		}
+
+		if (shouldFetch) {
+			await this.fetch();
+		}
+	}
+
+	async fetch(): Promise<void> {
+		await this.accountLoader.load();
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			const { buffer, slot } = this.accountLoader.getBufferAndSlot(
+				accountToPoll.publicKey
+			);
+			if (buffer) {
+				const account = this.program.account[
+					accountToPoll.key
+				].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
+				this[accountToPoll.key] = { data: account, slot };
+			}
+		}
+	}
+
+	didSubscriptionSucceed(): boolean {
+		let success = true;
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			if (!this[accountToPoll.key]) {
+				success = false;
+				break;
+			}
+		}
+		return success;
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			this.accountLoader.removeAccount(
+				accountToPoll.publicKey,
+				accountToPoll.callbackId
+			);
+		}
+
+		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+		this.errorCallbackId = undefined;
+
+		this.accountsToPoll.clear();
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount> {
+		this.assertIsSubscribed();
+		return this.userStats;
+	}
+}

package/src/accounts/types.ts

@@ -4,6 +4,7 @@ import {
 	OracleSource,
 	StateAccount,
 	UserAccount,
+	UserStatsAccount,
 } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
@@ -130,3 +131,20 @@ export type DataAndSlot<T> = {
 	data: T;
 	slot: number;
 };
+
+export interface UserStatsAccountEvents {
+	userStatsAccountUpdate: (payload: UserStatsAccount) => void;
+	update: void;
+	error: (e: Error) => void;
+}
+
+export interface UserStatsAccountSubscriber {
+	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+	isSubscribed: boolean;
+
+	subscribe(): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}

package/src/accounts/webSocketUserStatsAccountSubsriber.ts

@@ -0,0 +1,80 @@
+import {
+	DataAndSlot,
+	AccountSubscriber,
+	NotSubscribedError,
+	UserStatsAccountSubscriber,
+	UserStatsAccountEvents,
+} from './types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+import { UserStatsAccount } from '../types';
+
+export class WebSocketUserStatsAccountSubscriber
+	implements UserStatsAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+	userStatsAccountPublicKey: PublicKey;
+
+	userStatsAccountSubscriber: AccountSubscriber<UserStatsAccount>;
+
+	public constructor(program: Program, userStatsAccountPublicKey: PublicKey) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	async subscribe(): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		this.userStatsAccountSubscriber = new WebSocketAccountSubscriber(
+			'userStats',
+			this.program,
+			this.userStatsAccountPublicKey
+		);
+		await this.userStatsAccountSubscriber.subscribe(
+			(data: UserStatsAccount) => {
+				this.eventEmitter.emit('userStatsAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.eventEmitter.emit('update');
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async fetch(): Promise<void> {
+		await Promise.all([this.userStatsAccountSubscriber.fetch()]);
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		await Promise.all([this.userStatsAccountSubscriber.unsubscribe()]);
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount> {
+		this.assertIsSubscribed();
+		return this.userStatsAccountSubscriber.dataAndSlot;
+	}
+}

package/src/addresses/pda.ts

@@ -57,6 +57,19 @@ export function getUserAccountPublicKeySync(
 	)[0];
 }
 
+export function getUserStatsAccountPublicKey(
+	programId: PublicKey,
+	authority: PublicKey
+): PublicKey {
+	return anchor.web3.PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('user_stats')),
+			authority.toBuffer(),
+		],
+		programId
+	)[0];
+}
+
 export async function getMarketPublicKey(
 	programId: PublicKey,
 	marketIndex: BN