@drift-labs/common/lib/utils/index.d.ts

Common functions for Drift

/// <reference types="node" />
import { BN, Event, OrderActionRecord, OrderRecord, PublicKey, BigNum, MarketType, DriftClient, SpotMarketConfig } from '@drift-labs/sdk';
import { UIMatchedOrderRecordAndAction, UISerializableOrderActionRecord } from '../serializableTypes';
import { AccountInfo, Connection } from '@solana/web3.js';
export declare const matchEnum: (enum1: any, enum2: any) => boolean;
declare function enumToObj(enumStr: string): {
    [x: string]: {};
};
declare function enumToStr(enumStr: Record<string, any>): string;
export declare const ENUM_UTILS: {
    match: (enum1: any, enum2: any) => boolean;
    toObj: typeof enumToObj;
    toStr: typeof enumToStr;
};
export declare function sleep(ms: any): Promise<unknown>;
/**
 * Converts an objects with potential Pubkeys and BNs in it into a form that can be JSON stringified. When pubkeys get converted a _pbky_ suffix will be added to their key, and _bgnm_ for BNs.
 *
 * e.g.
 * input : {
 * QuoteAmount: BN
 * }
 *
 * output: {
 * _bgnm_QuoteAmount: string
 * }
 * @param value
 * @returns
 */
export declare const encodeStringifiableObject: (value: any) => any;
/**
 * Converts a parsed object with potential Pubkeys and BNs in it (in string form) to their proper form. Pubkey values must have a key starting in _pbky_ and BN values must have a key starting in _bnnm_
 *
 * * e.g.
 * input : {
 * _bgnm_QuoteAmount: string
 * }
 *
 * output: {
 * QuoteAmount: BN
 * }
 * @param value
 * @returns
 */
export declare const decodeStringifiableObject: (value: any) => any;
/**
 * Returns 1 if the first Order is chronologically later than the second Order, -1 if before, 0 if equal
 * @param orderA
 * @param orderB
 * @returns
 */
export declare const getSortScoreForOrderRecords: (orderA: {
    slot: number;
}, orderB: {
    slot: number;
}) => 0 | 1 | -1;
export declare const getTradeInfoFromActionRecord: (actionRecord: PartialUISerializableOrderActionRecord) => {
    ts: BN;
    baseAssetAmount: BigNum;
    baseAssetAmountFilled: BigNum;
    quoteAssetAmountFilled: BigNum;
};
export type PartialOrderActionRecord = PartialUISerializableOrderActionRecord | PartialOrderActionEventRecord;
export type PartialUISerializableOrderActionRecord = Pick<UISerializableOrderActionRecord, 'quoteAssetAmountFilled' | 'baseAssetAmountFilled' | 'ts' | 'slot' | 'action' | 'fillRecordId' | 'taker' | 'takerOrderBaseAssetAmount' | 'makerOrderBaseAssetAmount' | 'takerOrderCumulativeBaseAssetAmountFilled' | 'makerOrderCumulativeBaseAssetAmountFilled' | 'takerOrderCumulativeQuoteAssetAmountFilled' | 'makerOrderCumulativeQuoteAssetAmountFilled' | 'oraclePrice'>;
export type PartialOrderActionEventRecord = Pick<Event<OrderActionRecord>, 'quoteAssetAmountFilled' | 'baseAssetAmountFilled' | 'ts' | 'slot' | 'action' | 'fillRecordId' | 'taker' | 'takerOrderBaseAssetAmount' | 'makerOrderBaseAssetAmount' | 'takerOrderCumulativeBaseAssetAmountFilled' | 'makerOrderCumulativeBaseAssetAmountFilled' | 'takerOrderCumulativeQuoteAssetAmountFilled' | 'makerOrderCumulativeQuoteAssetAmountFilled'>;
/**
 * Returns 1 if the first Order is chronologically later than the second Order, -1 if before, 0 if equal
 * @param orderA
 * @param orderB
 * @returns
 */
export declare const getSortScoreForOrderActionRecords: (orderA: PartialOrderActionRecord, orderB: PartialOrderActionRecord) => 0 | 1 | -1;
export declare const sortUIMatchedOrderRecordAndAction: (records: UIMatchedOrderRecordAndAction[], direction?: 'asc' | 'desc') => UIMatchedOrderRecordAndAction[];
export declare const sortUIOrderActionRecords: (records: PartialUISerializableOrderActionRecord[], direction?: 'asc' | 'desc') => PartialUISerializableOrderActionRecord[];
export declare const sortUIOrderRecords: <T extends {
    slot: number;
}>(records: T[], direction?: 'asc' | 'desc') => T[];
export declare const sortOrderRecords: (records: Event<OrderRecord>[], direction?: 'asc' | 'desc') => Event<OrderRecord>[];
export declare const getLatestOfTwoUIOrderRecords: <T extends {
    slot: number;
}>(orderA: T, orderB: T) => T;
export declare const getLatestOfTwoOrderRecords: <T extends {
    slot: number;
}>(orderA: T, orderB: T) => T;
export declare const getUIOrderRecordsLaterThanTarget: <T extends {
    slot: number;
}>(target: T, records: T[]) => T[];
export declare const orderActionRecordIsTrade: (orderRecord: OrderActionRecord) => boolean;
export declare const uiOrderActionRecordIsTrade: (orderRecord: UISerializableOrderActionRecord) => boolean;
export declare const filterTradeRecordsFromOrderActionRecords: (orderRecords: OrderActionRecord[]) => OrderActionRecord[];
export declare const filterTradeRecordsFromUIOrderRecords: (orderRecords: UISerializableOrderActionRecord[]) => UISerializableOrderActionRecord[];
/**
 * Returns the average price for a given base amount and quote amount.
 * @param quoteAmount
 * @param baseAmount
 * @returns PRICE_PRECISION
 */
export declare const getPriceForBaseAndQuoteAmount: (quoteAmount: BN, baseAmount: BN) => BN;
export declare const getPriceForOrderRecord: (orderRecord: Pick<OrderActionRecord, 'quoteAssetAmountFilled' | 'baseAssetAmountFilled'>) => BN;
export declare const getPriceForUIOrderRecord: (orderRecord: Pick<UISerializableOrderActionRecord, 'quoteAssetAmountFilled' | 'baseAssetAmountFilled'>) => BigNum;
export declare const orderIsNull: (order: UISerializableOrderActionRecord | Event<OrderActionRecord>, side: 'taker' | 'maker') => boolean;
export declare const getAnchorEnumString: (enumVal: Record<string, unknown>) => string;
export declare class Ref<T> {
    val: T;
    constructor(val: T);
    set(val: T): void;
    get(): T;
}
export declare class Counter {
    private val;
    get(): number;
    increment(value?: number): void;
    reset(): void;
}
/**
 * A class which allows a group of switches to seperately turn a multiswitch on or off. The base state is the state of the "multiswitch" when all of the constituent switches are off. When any of the switches are "on" then the multiswitch flips to the opposite state
 *
 * If baseState is on  => any switch being "on" will turn the multiswitch off.
 * If baseState is off => any switch being "off" will turn the multiswitch off.
 */
export declare class MultiSwitch {
    private baseState;
    private switches;
    private switchValue;
    constructor(baseState?: 'on' | 'off');
    private getSwitchKey;
    switchOn(key: string): void;
    switchOff(key: string): void;
    private _switchOff;
    private _switchOn;
    get isOn(): boolean;
}
export declare const aprFromApy: (apy: number, compoundsPerYear: number) => number;
/**
 * Helper utility to get a sort score for "tiered" parameters.
 *
 * Example: Want to sort students by Grade, but fall back to using Age if they are equal. This method will accept an array for each student of [grade, age] and return the appropriate sort score for each.
 *
 * @param aScores
 * @param bScores
 * @returns
 */
export declare const getTieredSortScore: (aScores: number[], bScores: number[]) => number;
export declare const COMMON_UTILS: {
    getIfVaultBalance: (spotMarketConfig: SpotMarketConfig, driftClient: DriftClient) => Promise<BigNum>;
    getIfStakingVaultApr: (spotMarketConfig: SpotMarketConfig, driftClient: DriftClient) => Promise<number>;
    getCurrentOpenInterestForMarket: (marketIndex: number, marketType: MarketType, driftClient: DriftClient) => number;
    getDepositAprForMarket: (marketIndex: number, marketType: MarketType, driftClient: DriftClient) => number;
    getBorrowAprForMarket: (marketIndex: number, marketType: MarketType, driftClient: DriftClient) => number;
    getTotalBorrowsForMarket: (market: SpotMarketConfig, driftClient: DriftClient) => number;
    getTotalDepositsForMarket: (market: SpotMarketConfig, driftClient: DriftClient) => {
        totalDepositsBase: number;
        totalDepositsQuote: number;
    };
    dividesExactly: (numerator: number, denominator: number) => boolean;
    toSnakeCase: (str: string) => string;
    toCamelCase: (str: string) => string;
    getTieredSortScore: (aScores: number[], bScores: number[]) => number;
    normalizeBaseAssetSymbol: (symbol: string) => string;
    calculateZScore: (target: number, previousValues: number[]) => number;
    glueArray: <T>(size: number, elements: T[]) => T[][];
    timedPromise: <T_1>(promise: T_1) => Promise<{
        promiseTime: number;
        promiseResult: Awaited<T_1>;
    }>;
    chunks: <T_2>(array: readonly T_2[], size: number) => T_2[][];
    getMultipleAccountsInfoChunked: (connection: Connection, accounts: PublicKey[]) => Promise<(AccountInfo<Buffer> | null)[]>;
    MATH: {
        NUM: {
            mean: (numbers: number[]) => number;
            median: (numbers: number[]) => number;
        };
        BN: {
            bnMax: (numbers: BN[]) => BN;
            bnMin: (numbers: BN[]) => BN;
            bnMean: (numbers: BN[]) => BN;
            bnMedian: (numbers: BN[]) => BN;
        };
    };
};
export {};