@drift-labs/sdk 0.1.36-master.5 → 0.2.0-master.0

package/lib/clearingHouse.d.ts

@@ -1,19 +1,20 @@
 /// <reference types="node" />
 /// <reference types="bn.js" />
 import { AnchorProvider, BN, Program } from '@project-serum/anchor';
-import { MarketsAccount, StateAccount, DepositHistoryAccount, FundingPaymentHistoryAccount, FundingRateHistoryAccount, IWallet, LiquidationHistoryAccount, PositionDirection, TradeHistoryAccount, UserAccount, Market, OrderHistoryAccount, OrderStateAccount, OrderParams, Order, ExtendedCurveHistoryAccount, UserPositionsAccount } from './types';
-import { Connection, PublicKey, TransactionSignature, Keypair, ConfirmOptions, TransactionInstruction } from '@solana/web3.js';
+import { StateAccount, IWallet, PositionDirection, UserAccount, MarketAccount, OrderParams, Order, BankAccount, UserBankBalance, MakerInfo } from './types';
+import { Connection, PublicKey, TransactionSignature, ConfirmOptions, TransactionInstruction, AccountMeta } from '@solana/web3.js';
 import { MockUSDCFaucet } from './mockUSDCFaucet';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
-import { ClearingHouseAccountSubscriber, ClearingHouseAccountEvents, ClearingHouseAccountTypes } from './accounts/types';
+import { ClearingHouseAccountSubscriber, ClearingHouseAccountEvents, DataAndSlot } from './accounts/types';
 import { TxSender } from './tx/types';
+import { OraclePriceData } from './oracles/types';
+import { ClearingHouseConfig } from './clearingHouseConfig';
+import { ClearingHouseUser } from './clearingHouseUser';
+import { ClearingHouseUserAccountSubscriptionConfig } from './clearingHouseUserConfig';
 /**
  * # 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.
- *
- * The default way to construct a ClearingHouse instance is using the {@link from} method. This will create an instance using the static {@link WebSocketClearingHouseAccountSubscriber}, which will use a websocket for each state account subscription.
- * Alternatively, if you want to implement your own method of subscribing to the state accounts on the blockchain, you can implement a {@link ClearingHouseAccountSubscriber} and use it in the {@link ClearingHouse.constructor}
  */
 export declare class ClearingHouse {
     connection: Connection;
@@ -21,135 +22,115 @@ export declare class ClearingHouse {
     program: Program;
     provider: AnchorProvider;
     opts?: ConfirmOptions;
+    users: Map<number, ClearingHouseUser>;
+    activeUserId: number;
+    userAccountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig;
     accountSubscriber: ClearingHouseAccountSubscriber;
     eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
     _isSubscribed: boolean;
     txSender: TxSender;
+    marketLastSlotCache: Map<number, number>;
     get isSubscribed(): boolean;
     set isSubscribed(val: boolean);
-    /**
-     * @deprecated You should use the getClearingHouse factory method instead
-     * @param connection
-     * @param wallet
-     * @param clearingHouseProgramId
-     * @param opts
-     * @returns
-     */
-    static from(connection: Connection, wallet: IWallet, clearingHouseProgramId: PublicKey, opts?: ConfirmOptions): ClearingHouse;
-    constructor(connection: Connection, wallet: IWallet, program: Program, accountSubscriber: ClearingHouseAccountSubscriber, txSender: TxSender, opts: ConfirmOptions);
-    /**
-     *
-     * @param optionalSubscriptions - Optional extra accounts to subcribe to. Always subscribes to base clearing house state and market account state by default. You should only subscribe to optional extra accounts if required, to avoid overloading your RPC.
-     * @returns Promise<boolean> : SubscriptionSuccess
-     */
-    subscribe(optionalSubscriptions?: ClearingHouseAccountTypes[]): Promise<boolean>;
-    /**
-     * Shorthand function to subscribe to all available Clearing House State Accounts
-     * @returns Promise<boolean> : SubscriptionSuccess
-     */
-    subscribeToAll(): Promise<boolean>;
+    constructor(config: ClearingHouseConfig);
+    createUsers(userIds: number[], accountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig): void;
+    createUser(userId: number, accountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig): ClearingHouseUser;
+    subscribe(): Promise<boolean>;
+    subscribeUsers(): Promise<boolean>[];
     /**
      *	Forces the accountSubscriber to fetch account updates from rpc
      */
     fetchAccounts(): Promise<void>;
-    /**
-     * Unsubscribe from all currently subscribed state accounts
-     */
     unsubscribe(): Promise<void>;
+    unsubscribeUsers(): Promise<void>[];
     statePublicKey?: PublicKey;
     getStatePublicKey(): Promise<PublicKey>;
     getStateAccount(): StateAccount;
-    getMarketsAccount(): MarketsAccount;
-    getMarket(marketIndex: BN | number): Market;
-    getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
-    getFundingRateHistoryAccount(): FundingRateHistoryAccount;
-    getTradeHistoryAccount(): TradeHistoryAccount;
-    getLiquidationHistoryAccount(): LiquidationHistoryAccount;
-    getDepositHistoryAccount(): DepositHistoryAccount;
-    getCurveHistoryAccount(): ExtendedCurveHistoryAccount;
-    getOrderHistoryAccount(): OrderHistoryAccount;
-    orderStatePublicKey?: PublicKey;
-    getOrderStatePublicKey(): Promise<PublicKey>;
-    getOrderStateAccount(): OrderStateAccount;
+    getMarketAccount(marketIndex: BN | number): MarketAccount | undefined;
+    getMarketAccounts(): MarketAccount[];
+    getBankAccount(bankIndex: BN | number): BankAccount | undefined;
+    getQuoteAssetBankAccount(): BankAccount;
+    getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
     /**
      * Update the wallet to use for clearing house transactions and linked user account
      * @param newWallet
+     * @param userIds
+     * @param activeUserId
      */
-    updateWallet(newWallet: IWallet): void;
-    initializeUserAccount(): Promise<[
-        TransactionSignature,
-        PublicKey
-    ]>;
-    getInitializeUserInstructions(): Promise<[
-        Keypair,
-        PublicKey,
-        TransactionInstruction,
-        TransactionInstruction
-    ]>;
-    getInitializeUserOrdersInstruction(userAccountPublicKey?: PublicKey): Promise<TransactionInstruction>;
-    userAccountPublicKey?: PublicKey;
-    /**
-     * Get the address for the Clearing House User's account. NOT the user's wallet address.
-     * @returns
-     */
+    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]>;
+    getUser(userId?: number): ClearingHouseUser;
+    getUsers(): ClearingHouseUser[];
     getUserAccountPublicKey(): Promise<PublicKey>;
-    userAccount?: UserAccount;
-    getUserAccount(): Promise<UserAccount>;
-    userOrdersAccountPublicKey?: PublicKey;
-    /**
-     * Get the address for the Clearing House User Order's account. NOT the user's wallet address.
-     * @returns
-     */
-    getUserOrdersAccountPublicKey(): Promise<PublicKey>;
-    userOrdersExist?: boolean;
-    userOrdersAccountExists(): Promise<boolean>;
-    depositCollateral(amount: BN, collateralAccountPublicKey: PublicKey, userPositionsAccountPublicKey?: PublicKey): Promise<TransactionSignature>;
-    getDepositCollateralInstruction(amount: BN, collateralAccountPublicKey: PublicKey, userPositionsAccountPublicKey?: PublicKey): Promise<TransactionInstruction>;
+    getUserAccount(userId?: number): UserAccount | undefined;
+    getUserAccountAndSlot(userId?: number): DataAndSlot<UserAccount> | undefined;
+    getUserBankBalance(bankIndex: number | BN): UserBankBalance | undefined;
+    getQuoteAssetTokenAmount(): BN;
+    getRemainingAccounts(params: {
+        writableMarketIndex?: BN;
+        writableBankIndex?: 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>;
     /**
      * Creates the Clearing House User account for a user, and deposits some initial collateral
+     * @param userId
+     * @param name
      * @param amount
-     * @param collateralAccountPublicKey
+     * @param userTokenAccount
+     * @param fromUserId
      * @returns
      */
-    initializeUserAccountAndDepositCollateral(amount: BN, collateralAccountPublicKey: PublicKey): Promise<[TransactionSignature, PublicKey]>;
-    initializeUserAccountForDevnet(mockUSDCFaucet: MockUSDCFaucet, amount: BN): Promise<[TransactionSignature, PublicKey]>;
-    withdrawCollateral(amount: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionSignature>;
-    getWithdrawCollateralIx(amount: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
-    openPosition(direction: PositionDirection, amount: BN, marketIndex: BN, limitPrice?: BN, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
-    getOpenPositionIx(direction: PositionDirection, amount: BN, marketIndex: BN, limitPrice?: BN, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionInstruction>;
-    initializeUserOrdersThenPlaceOrder(orderParams: OrderParams, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
-    placeOrder(orderParams: OrderParams, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
-    getPlaceOrderIx(orderParams: OrderParams, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionInstruction>;
-    expireOrders(userAccountPublicKey: PublicKey, userOrdersAccountPublicKey: PublicKey): Promise<TransactionSignature>;
-    getExpireOrdersIx(userAccountPublicKey: PublicKey, userOrdersAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
-    cancelOrder(orderId: BN, oracle?: PublicKey): Promise<TransactionSignature>;
-    getCancelOrderIx(orderId: BN, oracle?: PublicKey): Promise<TransactionInstruction>;
-    cancelOrderByUserId(userOrderId: number, oracle?: PublicKey): Promise<TransactionSignature>;
-    getCancelOrderByUserIdIx(userOrderId: number, oracle?: PublicKey): Promise<TransactionInstruction>;
-    cancelAllOrders(oracles?: PublicKey[], bestEffort?: boolean): Promise<TransactionSignature>;
-    getCancelAllOrdersIx(oracles: PublicKey[], bestEffort?: boolean): Promise<TransactionInstruction>;
-    cancelOrdersByMarketAndSide(oracles?: PublicKey[], bestEffort?: boolean, marketIndexOnly?: BN, directionOnly?: PositionDirection): Promise<TransactionSignature>;
-    getCancelOrdersByMarketAndSideIx(oracles: PublicKey[], bestEffort?: boolean, marketIndexOnly?: BN, directionOnly?: PositionDirection): Promise<TransactionInstruction>;
-    fillOrder(userAccountPublicKey: PublicKey, userOrdersAccountPublicKey: PublicKey, order: Order): Promise<TransactionSignature>;
-    getFillOrderIx(userAccountPublicKey: PublicKey, userOrdersAccountPublicKey: PublicKey, order: Order): Promise<TransactionInstruction>;
-    initializeUserOrdersThenPlaceAndFillOrder(orderParams: OrderParams, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
-    placeAndFillOrder(orderParams: OrderParams, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
-    getPlaceAndFillOrderIx(orderParams: OrderParams, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionInstruction>;
+    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]>;
+    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>;
+    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>;
+    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>;
+    placeAndTake(orderParams: OrderParams, makerInfo?: MakerInfo): Promise<TransactionSignature>;
+    getPlaceAndTakeIx(orderParams: OrderParams, makerInfo?: MakerInfo): 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
-     * @param discountToken
-     * @param referrer
      * @returns
      */
-    closePosition(marketIndex: BN, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
-    getClosePositionIx(marketIndex: BN, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionInstruction>;
-    closeAllPositions(userPositionsAccount: UserPositionsAccount, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
+    closePosition(marketIndex: 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>;
     updateFundingRate(oracle: PublicKey, marketIndex: BN): Promise<TransactionSignature>;
     getUpdateFundingRateIx(oracle: PublicKey, marketIndex: BN): Promise<TransactionInstruction>;
-    settleFundingPayment(userAccount: PublicKey, userPositionsAccount: PublicKey): Promise<TransactionSignature>;
-    getSettleFundingPaymentIx(userAccount: PublicKey, userPositionsAccount: PublicKey): Promise<TransactionInstruction>;
+    settleFundingPayment(userAccount: PublicKey): Promise<TransactionSignature>;
+    getSettleFundingPaymentIx(userAccount: PublicKey): Promise<TransactionInstruction>;
     triggerEvent(eventName: keyof ClearingHouseAccountEvents, data?: any): void;
+    getOracleDataForMarket(marketIndex: BN): OraclePriceData;
 }