@drift-labs/sdk 0.2.0-master.2 → 0.2.0-master.20

package/lib/clearingHouse.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 /// <reference types="bn.js" />
 import { AnchorProvider, BN, Program } from '@project-serum/anchor';
-import { StateAccount, IWallet, PositionDirection, UserAccount, MarketAccount, OrderParams, Order, BankAccount, UserBankBalance, MakerInfo } from './types';
+import { StateAccount, IWallet, PositionDirection, UserAccount, MarketAccount, OrderParams, Order, BankAccount, UserBankBalance, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo } from './types';
 import { Connection, PublicKey, TransactionSignature, ConfirmOptions, TransactionInstruction, AccountMeta } from '@solana/web3.js';
-import { MockUSDCFaucet } from './mockUSDCFaucet';
+import { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { ClearingHouseAccountSubscriber, ClearingHouseAccountEvents, DataAndSlot } from './accounts/types';
@@ -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;
@@ -60,10 +62,14 @@ export declare class ClearingHouse {
     updateWallet(newWallet: IWallet, userIds?: number[], activeUserId?: number): Promise<void>;
     switchActiveUser(userId: number): Promise<void>;
     addUser(userId: number): Promise<void>;
-    initializeUserAccount(userId?: number, name?: string): Promise<[TransactionSignature, PublicKey]>;
-    getInitializeUserInstructions(userId?: number, name?: string): Promise<[PublicKey, TransactionInstruction]>;
+    initializeUserAccount(userId?: number, name?: string, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    getInitializeUserInstructions(userId?: number, name?: string, referrerInfo?: ReferrerInfo): 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,63 +78,86 @@ 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
      */
-    initializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, bankIndex?: BN, userId?: number, name?: string, fromUserId?: number): Promise<[TransactionSignature, PublicKey]>;
-    initializeUserAccountForDevnet(userId: number, name: string, mockUSDCFaucet: MockUSDCFaucet, amount: BN): Promise<[TransactionSignature, PublicKey]>;
+    initializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, bankIndex?: BN, userId?: number, name?: string, fromUserId?: number, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    initializeUserAccountForDevnet(userId: number, name: string, bankIndex: BN, tokenFaucet: TokenFaucet, amount: BN, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
     withdraw(amount: BN, bankIndex: BN, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionSignature>;
     getWithdrawIx(amount: BN, bankIndex: BN, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionInstruction>;
     transferDeposit(amount: BN, bankIndex: BN, fromUserId: number, toUserId: number): Promise<TransactionSignature>;
     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: OrderParams): Promise<TransactionSignature>;
-    getPlaceOrderIx(orderParams: OrderParams): Promise<TransactionInstruction>;
-    expireOrders(userAccountPublicKey: PublicKey): Promise<TransactionSignature>;
-    getExpireOrdersIx(userAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
+    placeOrder(orderParams: OptionalOrderParams): Promise<TransactionSignature>;
+    getOrderParams(optionalOrderParams: OptionalOrderParams): OrderParams;
+    getPlaceOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
     updateAMMs(marketIndexes: BN[]): Promise<TransactionSignature>;
     getUpdateAMMsIx(marketIndexes: BN[]): Promise<TransactionInstruction>;
     cancelOrder(orderId?: BN): Promise<TransactionSignature>;
     getCancelOrderIx(orderId?: BN): Promise<TransactionInstruction>;
     cancelOrderByUserId(userOrderId: number): Promise<TransactionSignature>;
     getCancelOrderByUserIdIx(userOrderId: number): Promise<TransactionInstruction>;
-    cancelAllOrders(bestEffort?: boolean): Promise<TransactionSignature>;
-    getCancelAllOrdersIx(bestEffort?: boolean): Promise<TransactionInstruction>;
-    cancelOrdersByMarketAndSide(bestEffort?: boolean, marketIndexOnly?: BN, directionOnly?: PositionDirection): Promise<TransactionSignature>;
-    getCancelOrdersByMarketAndSideIx(bestEffort?: boolean, marketIndexOnly?: BN, directionOnly?: PositionDirection): Promise<TransactionInstruction>;
-    fillOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, makerInfo?: MakerInfo): Promise<TransactionSignature>;
-    getFillOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order, makerInfo?: MakerInfo): Promise<TransactionInstruction>;
+    fillOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getFillOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order): Promise<TransactionSignature>;
     getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
-    placeAndTake(orderParams: OrderParams, makerInfo?: MakerInfo): Promise<TransactionSignature>;
-    getPlaceAndTakeIx(orderParams: OrderParams, makerInfo?: MakerInfo): Promise<TransactionInstruction>;
+    placeAndTake(orderParams: OptionalOrderParams, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getPlaceAndTakeIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    placeAndMake(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getPlaceAndMakeIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     /**
      * Close an entire position. If you want to reduce a position, use the {@link openPosition} method in the opposite direction of the current position.
      * @param marketIndex
      * @returns
      */
-    closePosition(marketIndex: BN): Promise<TransactionSignature>;
+    closePosition(marketIndex: BN, limitPrice?: BN): Promise<TransactionSignature>;
     settlePNLs(users: {
         settleeUserAccountPublicKey: PublicKey;
         settleeUserAccount: UserAccount;
     }[], marketIndex: BN): Promise<TransactionSignature>;
     settlePNL(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: BN): Promise<TransactionSignature>;
     settlePNLIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: BN): Promise<TransactionInstruction>;
-    liquidate(liquidateeUserAccountPublicKey: PublicKey): Promise<TransactionSignature>;
-    getLiquidateIx(liquidateeUserAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
+    liquidatePerp(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN, maxBaseAssetAmount: BN): Promise<TransactionSignature>;
+    getLiquidatePerpIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN, maxBaseAssetAmount: BN): Promise<TransactionInstruction>;
+    liquidateBorrow(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetBankIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
+    getLiquidateBorrowIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetBankIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
+    liquidateBorrowForPerpPnl(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
+    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;
+        writableBankIndexes?: BN[];
+    }): AccountMeta[];
     updateFundingRate(oracle: PublicKey, marketIndex: BN): Promise<TransactionSignature>;
     getUpdateFundingRateIx(oracle: PublicKey, marketIndex: BN): Promise<TransactionInstruction>;
     settleFundingPayment(userAccount: PublicKey): Promise<TransactionSignature>;