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

package/lib/accounts/fetch.d.ts

@@ -1,4 +1,5 @@
 import { Connection, PublicKey } from '@solana/web3.js';
-import { UserAccount } from '../types';
+import { UserAccount, UserStatsAccount } from '../types';
 import { Program } from '@project-serum/anchor';
 export declare function fetchUserAccounts(connection: Connection, program: Program, authority: PublicKey, limit?: number): Promise<(UserAccount | undefined)[]>;
+export declare function fetchUserStatsAccount(connection: Connection, program: Program, authority: PublicKey): Promise<UserStatsAccount | undefined>;

package/lib/accounts/fetch.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchUserAccounts = void 0;
+exports.fetchUserStatsAccount = exports.fetchUserAccounts = void 0;
 const pda_1 = require("../addresses/pda");
 async function fetchUserAccounts(connection, program, authority, limit = 8) {
     const userAccountPublicKeys = new Array();
@@ -16,3 +16,11 @@ async function fetchUserAccounts(connection, program, authority, limit = 8) {
     });
 }
 exports.fetchUserAccounts = fetchUserAccounts;
+async function fetchUserStatsAccount(connection, program, authority) {
+    const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(program.programId, authority);
+    const accountInfo = await connection.getAccountInfo(userStatsPublicKey, 'confirmed');
+    return accountInfo
+        ? program.account.user.coder.accounts.decode('UserStats', accountInfo.data)
+        : undefined;
+}
+exports.fetchUserStatsAccount = fetchUserStatsAccount;

package/lib/accounts/pollingUserStatsAccountSubscriber.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { DataAndSlot, AccountToPoll, 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';
+export declare class PollingUserStatsAccountSubscriber implements UserStatsAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+    userStatsAccountPublicKey: PublicKey;
+    accountLoader: BulkAccountLoader;
+    accountsToPoll: Map<string, AccountToPoll>;
+    errorCallbackId?: string;
+    userStats?: DataAndSlot<UserStatsAccount>;
+    constructor(program: Program, userStatsAccountPublicKey: PublicKey, accountLoader: BulkAccountLoader);
+    subscribe(): Promise<boolean>;
+    addToAccountLoader(): Promise<void>;
+    fetchIfUnloaded(): Promise<void>;
+    fetch(): Promise<void>;
+    didSubscriptionSucceed(): boolean;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}

package/lib/accounts/pollingUserStatsAccountSubscriber.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingUserStatsAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const utils_1 = require("./utils");
+class PollingUserStatsAccountSubscriber {
+    constructor(program, userStatsAccountPublicKey, accountLoader) {
+        this.accountsToPoll = new Map();
+        this.isSubscribed = false;
+        this.program = program;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+    }
+    async subscribe() {
+        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() {
+        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((0, utils_1.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() {
+        let shouldFetch = false;
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            if (this[accountToPoll.key] === undefined) {
+                shouldFetch = true;
+                break;
+            }
+        }
+        if (shouldFetch) {
+            await this.fetch();
+        }
+    }
+    async fetch() {
+        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((0, utils_1.capitalize)(accountToPoll.key), buffer);
+                this[accountToPoll.key] = { data: account, slot };
+            }
+        }
+    }
+    didSubscriptionSucceed() {
+        let success = true;
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            if (!this[accountToPoll.key]) {
+                success = false;
+                break;
+            }
+        }
+        return success;
+    }
+    async unsubscribe() {
+        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() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getUserStatsAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.userStats;
+    }
+}
+exports.PollingUserStatsAccountSubscriber = PollingUserStatsAccountSubscriber;

package/lib/accounts/types.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="bn.js" />
 /// <reference types="node" />
-import { BankAccount, MarketAccount, OracleSource, StateAccount, UserAccount } from '../types';
+import { BankAccount, MarketAccount, OracleSource, StateAccount, UserAccount, UserStatsAccount } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
@@ -100,3 +100,16 @@ export declare 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/lib/accounts/webSocketUserStatsAccountSubsriber.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { DataAndSlot, AccountSubscriber, 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';
+export declare class WebSocketUserStatsAccountSubscriber implements UserStatsAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+    userStatsAccountPublicKey: PublicKey;
+    userStatsAccountSubscriber: AccountSubscriber<UserStatsAccount>;
+    constructor(program: Program, userStatsAccountPublicKey: PublicKey);
+    subscribe(): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}

package/lib/accounts/webSocketUserStatsAccountSubsriber.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketUserStatsAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+class WebSocketUserStatsAccountSubscriber {
+    constructor(program, userStatsAccountPublicKey) {
+        this.isSubscribed = false;
+        this.program = program;
+        this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.userStatsAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('userStats', this.program, this.userStatsAccountPublicKey);
+        await this.userStatsAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('userStatsAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+    async fetch() {
+        await Promise.all([this.userStatsAccountSubscriber.fetch()]);
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        await Promise.all([this.userStatsAccountSubscriber.unsubscribe()]);
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getUserStatsAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.userStatsAccountSubscriber.dataAndSlot;
+    }
+}
+exports.WebSocketUserStatsAccountSubscriber = WebSocketUserStatsAccountSubscriber;

package/lib/addresses/pda.d.ts

@@ -6,6 +6,7 @@ export declare function getClearingHouseStateAccountPublicKey(programId: PublicK
 export declare function getUserAccountPublicKeyAndNonce(programId: PublicKey, authority: PublicKey, userId?: number): Promise<[PublicKey, number]>;
 export declare function getUserAccountPublicKey(programId: PublicKey, authority: PublicKey, userId?: number): Promise<PublicKey>;
 export declare function getUserAccountPublicKeySync(programId: PublicKey, authority: PublicKey, userId?: number): PublicKey;
+export declare function getUserStatsAccountPublicKey(programId: PublicKey, authority: PublicKey): PublicKey;
 export declare function getMarketPublicKey(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
 export declare function getBankPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
 export declare function getBankVaultPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;

package/lib/addresses/pda.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBankVaultAuthorityPublicKey = exports.getBankVaultPublicKey = exports.getBankPublicKey = exports.getMarketPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getClearingHouseStateAccountPublicKey = exports.getClearingHouseStateAccountPublicKeyAndNonce = void 0;
+exports.getBankVaultAuthorityPublicKey = exports.getBankVaultPublicKey = exports.getBankPublicKey = exports.getMarketPublicKey = exports.getUserStatsAccountPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getClearingHouseStateAccountPublicKey = exports.getClearingHouseStateAccountPublicKeyAndNonce = void 0;
 const anchor = __importStar(require("@project-serum/anchor"));
 async function getClearingHouseStateAccountPublicKeyAndNonce(programId) {
     return anchor.web3.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('clearing_house'))], programId);
@@ -53,6 +53,13 @@ function getUserAccountPublicKeySync(programId, authority, userId = 0) {
     ], programId)[0];
 }
 exports.getUserAccountPublicKeySync = getUserAccountPublicKeySync;
+function getUserStatsAccountPublicKey(programId, authority) {
+    return anchor.web3.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('user_stats')),
+        authority.toBuffer(),
+    ], programId)[0];
+}
+exports.getUserStatsAccountPublicKey = getUserStatsAccountPublicKey;
 async function getMarketPublicKey(programId, marketIndex) {
     return (await anchor.web3.PublicKey.findProgramAddress([
         Buffer.from(anchor.utils.bytes.utf8.encode('market')),

package/lib/admin.d.ts

@@ -29,6 +29,8 @@ export declare class Admin extends ClearingHouse {
     updateOrderFillerRewardStructure(orderFillerRewardStructure: OrderFillerRewardStructure): Promise<TransactionSignature>;
     updateFee(fees: FeeStructure): Promise<TransactionSignature>;
     updateOracleGuardRails(oracleGuardRails: OracleGuardRails): Promise<TransactionSignature>;
+    updateBankWithdrawGuardThreshold(bankIndex: BN, withdrawGuardThreshold: BN): Promise<TransactionSignature>;
+    updateLpCooldownTime(marketIndex: BN, cooldownTime: BN): Promise<TransactionSignature>;
     updateMarketOracle(marketIndex: BN, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
     updateMarketMinimumQuoteAssetTradeSize(marketIndex: BN, minimumTradeSize: BN): Promise<TransactionSignature>;
     updateMarketBaseAssetAmountStepSize(marketIndex: BN, stepSize: BN): Promise<TransactionSignature>;

package/lib/admin.js

@@ -333,6 +333,24 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
+    async updateBankWithdrawGuardThreshold(bankIndex, withdrawGuardThreshold) {
+        return await this.program.rpc.updateBankWithdrawGuardThreshold(withdrawGuardThreshold, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                bank: await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex),
+            },
+        });
+    }
+    async updateLpCooldownTime(marketIndex, cooldownTime) {
+        return await this.program.rpc.updateLpCooldownTime(cooldownTime, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
     async updateMarketOracle(marketIndex, oracle, oracleSource) {
         return await this.program.rpc.updateMarketOracle(oracle, oracleSource, {
             accounts: {

package/lib/clearingHouse.d.ts

@@ -12,6 +12,7 @@ import { OraclePriceData } from './oracles/types';
 import { ClearingHouseConfig } from './clearingHouseConfig';
 import { ClearingHouseUser } from './clearingHouseUser';
 import { ClearingHouseUserAccountSubscriptionConfig } from './clearingHouseUserConfig';
+import { ClearingHouseUserStats } from './clearingHouseUserStats';
 /**
  * # ClearingHouse
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -23,6 +24,7 @@ export declare class ClearingHouse {
     provider: AnchorProvider;
     opts?: ConfirmOptions;
     users: Map<number, ClearingHouseUser>;
+    userStats?: ClearingHouseUserStats;
     activeUserId: number;
     userAccountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig;
     accountSubscriber: ClearingHouseAccountSubscriber;
@@ -62,8 +64,12 @@ export declare class ClearingHouse {
     addUser(userId: number): Promise<void>;
     initializeUserAccount(userId?: number, name?: string): Promise<[TransactionSignature, PublicKey]>;
     getInitializeUserInstructions(userId?: number, name?: string): Promise<[PublicKey, TransactionInstruction]>;
+    getInitializeUserStatsIx(): Promise<TransactionInstruction>;
     getUser(userId?: number): ClearingHouseUser;
     getUsers(): ClearingHouseUser[];
+    getUserStats(): ClearingHouseUserStats;
+    userStatsAccountPublicKey: PublicKey;
+    getUserStatsAccountPublicKey(): PublicKey;
     getUserAccountPublicKey(): Promise<PublicKey>;
     getUserAccount(userId?: number): UserAccount | undefined;
     getUserAccountAndSlot(userId?: number): DataAndSlot<UserAccount> | undefined;
@@ -72,17 +78,22 @@ export declare class ClearingHouse {
     getRemainingAccounts(params: {
         writableMarketIndex?: BN;
         writableBankIndex?: BN;
+        readableMarketIndex?: BN;
     }): AccountMeta[];
     getOrder(orderId: BN | number): Order | undefined;
     getOrderByUserId(userOrderId: number): Order | undefined;
     deposit(amount: BN, bankIndex: BN, collateralAccountPublicKey: PublicKey, userId?: number, reduceOnly?: boolean): Promise<TransactionSignature>;
     getDepositInstruction(amount: BN, bankIndex: BN, userTokenAccount: PublicKey, userId?: number, reduceOnly?: boolean, userInitialized?: boolean): Promise<TransactionInstruction>;
+    private checkIfAccountExists;
+    private getSolWithdrawalIxs;
+    private getWrappedSolAccountCreationIxs;
     /**
      * Creates the Clearing House User account for a user, and deposits some initial collateral
-     * @param userId
-     * @param name
      * @param amount
      * @param userTokenAccount
+     * @param bankIndex
+     * @param userId
+     * @param name
      * @param fromUserId
      * @returns
      */
@@ -94,6 +105,12 @@ export declare class ClearingHouse {
     getTransferDepositIx(amount: BN, bankIndex: BN, fromUserId: number, toUserId: number): Promise<TransactionInstruction>;
     updateBankCumulativeInterest(bankIndex: BN): Promise<TransactionSignature>;
     updateBankCumulativeInterestIx(bankIndex: BN): Promise<TransactionInstruction>;
+    settleLP(settleeUserAccountPublicKey: PublicKey, marketIndex: BN): Promise<TransactionSignature>;
+    settleLPIx(settleeUserAccountPublicKey: PublicKey, marketIndex: BN): Promise<TransactionInstruction>;
+    removeLiquidity(marketIndex: BN, sharesToBurn?: BN): Promise<TransactionSignature>;
+    getRemoveLiquidityIx(marketIndex: BN, sharesToBurn?: BN): Promise<TransactionInstruction>;
+    addLiquidity(amount: BN, marketIndex: BN): Promise<TransactionSignature>;
+    getAddLiquidityIx(amount: BN, marketIndex: BN): Promise<TransactionInstruction>;
     openPosition(direction: PositionDirection, amount: BN, marketIndex: BN, limitPrice?: BN): Promise<TransactionSignature>;
     placeOrder(orderParams: OptionalOrderParams): Promise<TransactionSignature>;
     getOrderParams(optionalOrderParams: OptionalOrderParams): OrderParams;
@@ -117,7 +134,7 @@ export declare class ClearingHouse {
      * @param marketIndex
      * @returns
      */
-    closePosition(marketIndex: BN): Promise<TransactionSignature>;
+    closePosition(marketIndex: BN, limitPrice?: BN): Promise<TransactionSignature>;
     settlePNLs(users: {
         settleeUserAccountPublicKey: PublicKey;
         settleeUserAccount: UserAccount;
@@ -132,6 +149,10 @@ export declare class ClearingHouse {
     getLiquidateBorrowForPerpPnlIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
     liquidatePerpPnlForDeposit(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, assetBankIndex: BN, maxPnlTransfer: BN): Promise<TransactionSignature>;
     getLiquidatePerpPnlForDepositIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, assetBankIndex: BN, maxPnlTransfer: BN): Promise<TransactionInstruction>;
+    resolvePerpBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN): Promise<TransactionSignature>;
+    getResolvePerpBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN): Promise<TransactionInstruction>;
+    resolveBorrowBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, bankIndex: BN): Promise<TransactionSignature>;
+    getResolveBorrowBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, bankIndex: BN): Promise<TransactionInstruction>;
     getRemainingAccountsForLiquidation(params: {
         userAccount: UserAccount;
         writableMarketIndex?: BN;