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

package/lib/clearingHouse.d.ts

@@ -1,9 +1,10 @@
 /// <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 { Connection, PublicKey, TransactionSignature, ConfirmOptions, TransactionInstruction, AccountMeta } from '@solana/web3.js';
-import { MockUSDCFaucet } from './mockUSDCFaucet';
+import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo, MarketType, SerumV3FulfillmentConfigAccount } from './types';
+import * as anchor from '@project-serum/anchor';
+import { Connection, PublicKey, TransactionSignature, ConfirmOptions, Transaction, TransactionInstruction, AccountMeta } from '@solana/web3.js';
+import { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { ClearingHouseAccountSubscriber, ClearingHouseAccountEvents, DataAndSlot } from './accounts/types';
@@ -12,6 +13,15 @@ import { OraclePriceData } from './oracles/types';
 import { ClearingHouseConfig } from './clearingHouseConfig';
 import { ClearingHouseUser } from './clearingHouseUser';
 import { ClearingHouseUserAccountSubscriptionConfig } from './clearingHouseUserConfig';
+import { ClearingHouseUserStats } from './clearingHouseUserStats';
+declare type RemainingAccountParams = {
+    userAccounts: UserAccount[];
+    writablePerpMarketIndexes?: number[];
+    writableSpotMarketIndexes?: number[];
+    readablePerpMarketIndex?: number;
+    readableSpotMarketIndex?: number;
+    useMarketLastSlotCache?: boolean;
+};
 /**
  * # 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 +33,7 @@ export declare class ClearingHouse {
     provider: AnchorProvider;
     opts?: ConfirmOptions;
     users: Map<number, ClearingHouseUser>;
+    userStats?: ClearingHouseUserStats;
     activeUserId: number;
     userAccountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig;
     accountSubscriber: ClearingHouseAccountSubscriber;
@@ -30,6 +41,7 @@ export declare class ClearingHouse {
     _isSubscribed: boolean;
     txSender: TxSender;
     marketLastSlotCache: Map<number, number>;
+    authority: PublicKey;
     get isSubscribed(): boolean;
     set isSubscribed(val: boolean);
     constructor(config: ClearingHouseConfig);
@@ -45,12 +57,16 @@ export declare class ClearingHouse {
     unsubscribeUsers(): Promise<void>[];
     statePublicKey?: PublicKey;
     getStatePublicKey(): Promise<PublicKey>;
+    signerPublicKey?: PublicKey;
+    getSignerPublicKey(): PublicKey;
     getStateAccount(): StateAccount;
-    getMarketAccount(marketIndex: BN | number): MarketAccount | undefined;
-    getMarketAccounts(): MarketAccount[];
-    getBankAccount(bankIndex: BN | number): BankAccount | undefined;
-    getQuoteAssetBankAccount(): BankAccount;
+    getPerpMarketAccount(marketIndex: number): PerpMarketAccount | undefined;
+    getPerpMarketAccounts(): PerpMarketAccount[];
+    getSpotMarketAccount(marketIndex: number): SpotMarketAccount | undefined;
+    getSpotMarketAccounts(): SpotMarketAccount[];
+    getQuoteSpotMarketAccount(): SpotMarketAccount;
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
+    getSerumV3FulfillmentConfig(serumMarket: PublicKey): Promise<SerumV3FulfillmentConfigAccount>;
     /**
      * Update the wallet to use for clearing house transactions and linked user account
      * @param newWallet
@@ -60,73 +76,138 @@ 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>;
+    updateUserName(name: string, userId?: number): Promise<TransactionSignature>;
+    updateUserCustomMarginRatio(marginRatio: number, userId?: number): Promise<TransactionSignature>;
+    updateUserDelegate(delegate: PublicKey, userId?: number): Promise<TransactionSignature>;
+    getUserAccountsForDelegate(delegate: PublicKey): Promise<UserAccount[]>;
+    deleteUser(userId?: number): Promise<TransactionSignature>;
     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;
-    getUserBankBalance(bankIndex: number | BN): UserBankBalance | undefined;
+    getSpotPosition(marketIndex: number): SpotPosition | undefined;
     getQuoteAssetTokenAmount(): BN;
-    getRemainingAccounts(params: {
-        writableMarketIndex?: BN;
-        writableBankIndex?: BN;
-    }): AccountMeta[];
-    getOrder(orderId: BN | number): Order | undefined;
+    getRemainingAccounts(params: RemainingAccountParams): AccountMeta[];
+    getRemainingAccountMapsForUsers(userAccounts: UserAccount[]): {
+        oracleAccountMap: Map<string, AccountMeta>;
+        spotMarketAccountMap: Map<number, AccountMeta>;
+        perpMarketAccountMap: Map<number, AccountMeta>;
+    };
+    getOrder(orderId: 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>;
+    deposit(amount: BN, marketIndex: number, collateralAccountPublicKey: PublicKey, userId?: number, reduceOnly?: boolean): Promise<TransactionSignature>;
+    getDepositInstruction(amount: BN, marketIndex: number, userTokenAccount: PublicKey, userId?: number, reduceOnly?: boolean, userInitialized?: boolean): Promise<TransactionInstruction>;
+    private checkIfAccountExists;
+    private getWrappedSolAccountCreationIxs;
+    getAssociatedTokenAccountCreationIx(tokenMintAddress: PublicKey, associatedTokenAddress: PublicKey): anchor.web3.TransactionInstruction;
     /**
      * Creates the Clearing House User account for a user, and deposits some initial collateral
-     * @param userId
-     * @param name
      * @param amount
      * @param userTokenAccount
+     * @param marketIndex
+     * @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]>;
-    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>;
-    updateAMMs(marketIndexes: BN[]): Promise<TransactionSignature>;
-    getUpdateAMMsIx(marketIndexes: BN[]): Promise<TransactionInstruction>;
-    cancelOrder(orderId?: BN): Promise<TransactionSignature>;
-    getCancelOrderIx(orderId?: BN): Promise<TransactionInstruction>;
+    initializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, marketIndex?: number, userId?: number, name?: string, fromUserId?: number, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    initializeUserAccountForDevnet(userId: number, name: string, marketIndex: number, tokenFaucet: TokenFaucet, amount: BN, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    withdraw(amount: BN, marketIndex: number, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionSignature>;
+    getWithdrawIx(amount: BN, marketIndex: number, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionInstruction>;
+    transferDeposit(amount: BN, marketIndex: number, fromUserId: number, toUserId: number): Promise<TransactionSignature>;
+    getTransferDepositIx(amount: BN, marketIndex: number, fromUserId: number, toUserId: number): Promise<TransactionInstruction>;
+    updateSpotMarketCumulativeInterest(marketIndex: number): Promise<TransactionSignature>;
+    updateSpotMarketCumulativeInterestIx(marketIndex: number): Promise<TransactionInstruction>;
+    settleLP(settleeUserAccountPublicKey: PublicKey, marketIndex: number): Promise<TransactionSignature>;
+    settleLPIx(settleeUserAccountPublicKey: PublicKey, marketIndex: number): Promise<TransactionInstruction>;
+    removeLiquidity(marketIndex: number, sharesToBurn?: BN): Promise<TransactionSignature>;
+    getRemoveLiquidityIx(marketIndex: number, sharesToBurn?: BN): Promise<TransactionInstruction>;
+    addLiquidity(amount: BN, marketIndex: number): Promise<TransactionSignature>;
+    getAddLiquidityIx(amount: BN, marketIndex: number): Promise<TransactionInstruction>;
+    openPosition(direction: PositionDirection, amount: BN, marketIndex: number, limitPrice?: BN): Promise<TransactionSignature>;
+    sendSignedTx(tx: Transaction): Promise<TransactionSignature>;
+    /**
+     * Sends a market order and returns a signed tx which can fill the order against the vamm, which the caller can use to fill their own order if required.
+     * @param orderParams
+     * @param userAccountPublicKey
+     * @param userAccount
+     * @returns
+     */
+    sendMarketOrderAndGetSignedFillTx(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<{
+        txSig: TransactionSignature;
+        signedFillTx: Transaction;
+    }>;
+    placeOrder(orderParams: OptionalOrderParams): Promise<TransactionSignature>;
+    getOrderParams(optionalOrderParams: OptionalOrderParams, marketType: MarketType): OrderParams;
+    getPlaceOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
+    updateAMMs(marketIndexes: number[]): Promise<TransactionSignature>;
+    getUpdateAMMsIx(marketIndexes: number[]): Promise<TransactionInstruction>;
+    settleExpiredMarket(marketIndex: number): Promise<TransactionSignature>;
+    getSettleExpiredMarketIx(marketIndex: number): Promise<TransactionInstruction>;
+    cancelOrder(orderId?: number): Promise<TransactionSignature>;
+    getCancelOrderIx(orderId?: number): Promise<TransactionInstruction>;
     cancelOrderByUserId(userOrderId: number): Promise<TransactionSignature>;
     getCancelOrderByUserIdIx(userOrderId: number): 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?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getFillOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    placeSpotOrder(orderParams: OptionalOrderParams): Promise<TransactionSignature>;
+    getPlaceSpotOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
+    fillSpotOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getFillSpotOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, 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: number, 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>;
-    updateFundingRate(oracle: PublicKey, marketIndex: BN): Promise<TransactionSignature>;
-    getUpdateFundingRateIx(oracle: PublicKey, marketIndex: BN): Promise<TransactionInstruction>;
-    settleFundingPayment(userAccount: PublicKey): Promise<TransactionSignature>;
-    getSettleFundingPaymentIx(userAccount: PublicKey): Promise<TransactionInstruction>;
+    }[], marketIndex: number): Promise<TransactionSignature>;
+    settlePNL(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number): Promise<TransactionSignature>;
+    settlePNLIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
+    settleExpiredPosition(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number): Promise<TransactionSignature>;
+    getSettleExpiredPositionIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
+    liquidatePerp(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN): Promise<TransactionSignature>;
+    getLiquidatePerpIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN): Promise<TransactionInstruction>;
+    liquidateSpot(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
+    getLiquidateSpotIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
+    liquidateBorrowForPerpPnl(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
+    getLiquidateBorrowForPerpPnlIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
+    liquidatePerpPnlForDeposit(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, assetMarketIndex: number, maxPnlTransfer: BN): Promise<TransactionSignature>;
+    getLiquidatePerpPnlForDepositIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, assetMarketIndex: number, maxPnlTransfer: BN): Promise<TransactionInstruction>;
+    resolvePerpBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionSignature>;
+    getResolvePerpBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
+    resolveSpotBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionSignature>;
+    getResolveSpotBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
+    updateFundingRate(oracle: PublicKey, marketIndex: number): Promise<TransactionSignature>;
+    getUpdateFundingRateIx(oracle: PublicKey, marketIndex: number): Promise<TransactionInstruction>;
+    settleFundingPayment(userAccountPublicKey: PublicKey): Promise<TransactionSignature>;
+    getSettleFundingPaymentIx(userAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
     triggerEvent(eventName: keyof ClearingHouseAccountEvents, data?: any): void;
-    getOracleDataForMarket(marketIndex: BN): OraclePriceData;
+    getOracleDataForMarket(marketIndex: number): OraclePriceData;
+    getOracleDataForSpotMarket(marketIndex: number): OraclePriceData;
+    initializeInsuranceFundStake(marketIndex: number): Promise<TransactionSignature>;
+    getInitializeInsuranceFundStakeIx(marketIndex: number): Promise<TransactionInstruction>;
+    addInsuranceFundStake(marketIndex: number, amount: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionSignature>;
+    requestRemoveInsuranceFundStake(marketIndex: number, amount: BN): Promise<TransactionSignature>;
+    cancelRequestRemoveInsuranceFundStake(marketIndex: number): Promise<TransactionSignature>;
+    removeInsuranceFundStake(marketIndex: number, collateralAccountPublicKey: PublicKey): Promise<TransactionSignature>;
+    settleRevenueToInsuranceFund(marketIndex: number): Promise<TransactionSignature>;
+    resolvePerpPnlDeficit(spotMarketIndex: number, perpMarketIndex: number): Promise<TransactionSignature>;
+    getResolvePerpPnlDeficitIx(spotMarketIndex: number, perpMarketIndex: number): Promise<TransactionInstruction>;
 }
+export {};