@drift-labs/common/lib/common-ui-utils/commonUiUtils.d.ts

Common functions for Drift

/// <reference types="node" />
import { BN, BigNum, DriftClient, IWallet, MarketType, OptionalOrderParams, OrderType, PositionDirection, PublicKey, SpotMarketConfig, User, UserAccount } from '@drift-labs/sdk';
import { AccountInfo, Connection, ParsedAccountData } from '@solana/web3.js';
import { AuctionParams, TradeOffsetPrice } from 'src/types';
declare function chunks<T>(array: T[], size: number): T[][];
export declare const COMMON_UI_UTILS: {
    getOrderLabelFromOrderDetails: (orderDetails: Pick<import("..").UISerializableOrder, "orderType" | "direction" | "triggerCondition" | "oraclePriceOffset" | "existingPositionDirection">) => string;
    getLimitPriceFromOracleOffset: (order: import("..").UISerializableOrder, oraclePrice: BigNum) => BigNum;
    isAuctionEmpty: (auctionParams: AuctionParams) => boolean;
    getUIOrderTypeFromSdkOrderType: (orderType: OrderType, triggerCondition: import("@drift-labs/sdk").OrderTriggerCondition, direction: PositionDirection, oracleOffset: BigNum) => import("src/types").UIOrderTypeValue;
    getPerpAuctionDuration: (priceDiff: BN, price: BN, contractTier: import("@drift-labs/sdk").ContractTier) => number;
    getPerpOrderParamsBitFlags: (marketIndex: number, driftClient: DriftClient, userAccount: User, quoteSize: BN, side: PositionDirection, enterHighLeverageModeBufferPct?: number) => number;
    getBaseAssetSymbol: (marketName: string, removePrefix?: boolean) => string;
    getPausedOperations: (marketAccount: import("@drift-labs/sdk").SpotMarketAccount | import("@drift-labs/sdk").PerpMarketAccount) => string[];
    PerpOperationsMap: {
        UPDATE_FUNDING: string;
        AMM_FILL: string;
        FILL: string;
        SETTLE_PNL: string;
        SETTLE_PNL_WITH_POSITION: string;
    };
    SpotOperationsMap: {
        UPDATE_CUMULATIVE_INTEREST: string;
        FILL: string;
        WITHDRAW: string;
    };
    InsuranceFundOperationsMap: {
        INIT: string;
        ADD: string;
        REQUEST_REMOVE: string;
        REMOVE: string;
    };
    getMarketConfig: {
        (driftEnv: import("@drift-labs/sdk").DriftEnv, marketType: {
            perp: {};
        }, marketIndex: number): import("@drift-labs/sdk").PerpMarketConfig;
        (driftEnv: import("@drift-labs/sdk").DriftEnv, marketType: {
            spot: {};
        }, marketIndex: number): SpotMarketConfig;
    };
    getMaxLeverageForMarket: (marketType: MarketType, marketIndex: number, driftClient: DriftClient) => {
        maxLeverage: number;
        highLeverageMaxLeverage: number;
        hasHighLeverage: boolean;
    };
    calculatePnlPctFromPosition: (pnl: BN, quoteEntryAmount: BN, leverage?: number) => number;
    calculatePotentialProfit: (props: {
        currentPositionSize: BigNum;
        currentPositionDirection: PositionDirection;
        currentPositionEntryPrice: BigNum;
        tradeDirection: PositionDirection;
        exitBaseSize: BigNum;
        exitPrice: BigNum;
        takerFeeBps: number;
        slippageTolerance?: number;
        isMarketOrder?: boolean;
    }) => {
        estimatedProfit: BigNum;
        estimatedProfitBeforeFees: BigNum;
        estimatedTakerFee: BigNum;
        notionalSizeAtEntry: BigNum;
        notionalSizeAtExit: BigNum;
    };
    calculateLiquidationPriceAfterPerpTrade: ({ estEntryPrice, orderType, perpMarketIndex, tradeBaseSize, isLong, userClient, oraclePrice, limitPrice, offsetCollateral, precision, isEnteringHighLeverageMode, capLiqPrice, }: {
        estEntryPrice: BN;
        orderType: import("src/types").UIOrderType;
        perpMarketIndex: number;
        tradeBaseSize: BN;
        isLong: boolean;
        userClient: User;
        oraclePrice: BN;
        limitPrice?: BN;
        offsetCollateral?: BN;
        precision?: number;
        isEnteringHighLeverageMode?: boolean;
        capLiqPrice?: boolean;
    }) => number;
    checkIsMarketOrderType: (orderType: import("src/types").UIOrderType) => boolean;
    convertLeverageToMarginRatio: (leverage: number) => number;
    getMarketTickSize: (driftClient: DriftClient, marketId: import("src/types").MarketId) => BN;
    getMarketTickSizeDecimals: (driftClient: DriftClient, marketId: import("src/types").MarketId) => number;
    getMarketStepSize: (driftClient: DriftClient, marketId: import("src/types").MarketId) => BN;
    getMarketStepSizeDecimals: (driftClient: DriftClient, marketId: import("src/types").MarketId) => number;
    isEntirePositionOrder: (orderAmount: BigNum) => boolean;
    getOpenPositionData: (driftClient: DriftClient, userPositions: import("@drift-labs/sdk").PerpPosition[], user: User, perpMarketLookup: import("@drift-labs/sdk").PerpMarketConfig[], markPriceCallback?: (marketIndex: number) => BN) => import("src/types").OpenPosition[];
    checkIfUserAccountExists: (driftClient: DriftClient, config: {
        type: "userPubKey";
        userPubKey: PublicKey;
    } | {
        type: "subAccountId";
        subAccountId: number;
        authority: PublicKey;
    }) => Promise<boolean>;
    abbreviateAddress: (address: string | PublicKey, length?: number) => string;
    calculateAverageEntryPrice: (quoteAssetAmount: BigNum, baseAssetAmount: BigNum) => BigNum;
    chunks: typeof chunks;
    compareSignatures: (original: string, hashed: string) => Promise<boolean>;
    createThrowawayIWallet: (walletPubKey?: PublicKey) => IWallet;
    createPlaceholderIWallet: (walletPubKey?: PublicKey) => IWallet;
    deriveMarketOrderParams: ({ marketType, marketIndex, direction, maxLeverageSelected, maxLeverageOrderSize, baseAmount, reduceOnly, allowInfSlippage, oraclePrice, bestPrice, entryPrice, worstPrice, markPrice, auctionDuration, auctionStartPriceOffset, auctionEndPriceOffset, auctionStartPriceOffsetFrom, auctionEndPriceOffsetFrom, auctionPriceCaps, slippageTolerance, isOracleOrder, additionalEndPriceBuffer, forceUpToSlippage, }: {
        marketType: MarketType;
        marketIndex: number;
        direction: PositionDirection;
        maxLeverageSelected: boolean;
        maxLeverageOrderSize: BN;
        baseAmount: BN;
        reduceOnly: boolean;
        allowInfSlippage: boolean;
        oraclePrice: BN;
        bestPrice: BN;
        entryPrice: BN;
        worstPrice: BN;
        markPrice: BN;
        auctionDuration: number;
        auctionStartPriceOffset: number;
        auctionEndPriceOffset: number;
        auctionPriceCaps?: {
            min: BN;
            max: BN;
        };
        auctionStartPriceOffsetFrom: TradeOffsetPrice;
        auctionEndPriceOffsetFrom: TradeOffsetPrice;
        slippageTolerance: number;
        isOracleOrder?: boolean;
        additionalEndPriceBuffer?: BN;
        forceUpToSlippage?: boolean;
    }) => OptionalOrderParams & {
        constrainedBySlippage?: boolean;
    };
    fetchCurrentSubaccounts: (driftClient: DriftClient) => UserAccount[];
    fetchUserClientsAndAccounts: (driftClient: DriftClient) => {
        user: User;
        userAccount: UserAccount;
    }[];
    formatTokenInputCurried: (setAmount: (amount: string) => void, spotMarketConfig: SpotMarketConfig) => (newAmount: string) => void;
    getBalanceFromTokenAccountResult: (account: {
        pubkey: PublicKey;
        account: AccountInfo<ParsedAccountData>;
    }) => any;
    getIdAndAuthorityFromKey: (key: string) => {
        userId: number;
        userAuthority: PublicKey;
    };
    getLimitAuctionParams: ({ direction, inputPrice, startPriceFromSettings, duration, auctionStartPriceOffset, oraclePriceBands, }: {
        direction: PositionDirection;
        inputPrice: BigNum;
        startPriceFromSettings: BN;
        duration: number;
        auctionStartPriceOffset: number;
        oraclePriceBands?: [BN, BN];
    }) => AuctionParams;
    getLpSharesAmountForQuote: (driftClient: DriftClient, marketIndex: number, quoteAmount: BN) => BigNum;
    getMarketAuctionParams: ({ direction, startPriceFromSettings, endPriceFromSettings, limitPrice, duration, auctionStartPriceOffset, auctionEndPriceOffset, additionalEndPriceBuffer, forceUpToSlippage, }: {
        direction: PositionDirection;
        startPriceFromSettings: BN;
        endPriceFromSettings: BN;
        /**
         * Limit price is the oracle limit price - market orders use the oracle order type under the hood on Drift UI
         * So oracle limit price is the oracle price + oracle offset
         */
        limitPrice: BN;
        duration: number;
        auctionStartPriceOffset: number;
        auctionEndPriceOffset: number;
        additionalEndPriceBuffer?: BN;
        forceUpToSlippage?: boolean;
    }) => AuctionParams;
    getMarketKey: (marketIndex: number, marketType: MarketType) => string;
    getMarketOrderLimitPrice: ({ direction, baselinePrice, slippageTolerance, }: {
        direction: PositionDirection;
        baselinePrice: BN;
        slippageTolerance: number;
    }) => BN;
    getMultipleAccounts: (connection: any, keys: string[], commitment: string) => Promise<{
        keys: string[];
        array: AccountInfo<Buffer>[];
    }>;
    getMultipleAccountsCore: (connection: any, keys: string[], commitment: string) => Promise<{
        keys: string[];
        array: AccountInfo<string[]>[];
    }>;
    getPriceObject: ({ oraclePrice, bestOffer, entryPrice, worstPrice, markPrice, direction, }: {
        oraclePrice: BN;
        bestOffer: BN;
        entryPrice: BN;
        worstPrice: BN;
        markPrice: BN;
        direction: PositionDirection;
    }) => {
        oracle: BN;
        bestOffer: BN;
        entry: BN;
        best: BN;
        worst: BN;
        mark: BN;
    };
    getQuoteValueForLpShares: (driftClient: DriftClient, marketIndex: number, sharesAmount: BN) => BigNum;
    getSignatureVerificationMessageForSettings: (authority: PublicKey, signTs: number) => Uint8Array;
    getTokenAccount: (connection: Connection, mintAddress: PublicKey, userPubKey: PublicKey) => Promise<{
        tokenAccount: {
            pubkey: PublicKey;
            account: import('@solana/web3.js').AccountInfo<import('@solana/web3.js').ParsedAccountData>;
        };
        tokenAccountWarning: boolean;
    }>;
    getTokenAddress: (mintAddress: PublicKey, userPubKey: PublicKey) => Promise<PublicKey>;
    getUserKey: (userId: number, authority: PublicKey) => string;
    hashSignature: (signature: string) => Promise<string>;
    initializeAndSubscribeToNewUserAccount: (driftClient: DriftClient, userIdToInit: number, authority: PublicKey, callbacks: {
        initializationStep: () => Promise<boolean>;
        postInitializationStep?: () => Promise<boolean>;
        handleSuccessStep?: (accountAlreadyExisted: boolean) => Promise<boolean>;
    }) => Promise<'ok' | 'failed_initializationStep' | 'failed_postInitializationStep' | 'failed_awaitAccountInitializationChainState' | 'failed_handleSuccessStep'>;
    userExists: (driftClient: DriftClient, userId: number, authority: PublicKey) => Promise<boolean>;
    verifySignature: (signature: Uint8Array, message: Uint8Array, pubKey: PublicKey) => boolean;
    trimTrailingZeros: (str: string, zerosToShow?: number) => string;
};
export {};