import { COMMON_UTILS } from '@drift/common';

COMMON_UTILS.getIfVaultBalance(/* parameters */);

COMMON_UTILS.getIfStakingVaultApr(/* parameters */);

const openInterest = COMMON_UTILS.getCurrentOpenInterestForMarket(
  marketIndex: number,
  marketType: MarketType,
  driftClient: DriftClient
);

const depositApr = COMMON_UTILS.getDepositAprForMarket(
  marketIndex: number,
  marketType: MarketType,
  driftClient: DriftClient
);

const borrowApr = COMMON_UTILS.getBorrowAprForMarket(
  marketIndex: number,
  marketType: MarketType,
  driftClient: DriftClient
);

const totalBorrows = COMMON_UTILS.getTotalBorrowsForMarket(
  market: SpotMarketConfig,
  driftClient: DriftClient
);

const deposits = COMMON_UTILS.getTotalDepositsForMarket(
  market: SpotMarketConfig,
  driftClient: DriftClient
);

const snakeCase = COMMON_UTILS.toSnakeCase('MyVariableName');
// Returns: 'my_variable_name'

const camelCase = COMMON_UTILS.toCamelCase('my_variable_name');
// Returns: 'myVariableName'

const normalized = COMMON_UTILS.normalizeBaseAssetSymbol('1MWEN');
// Returns: 'WEN'

const average = COMMON_UTILS.MATH.NUM.mean([1, 2, 3, 4, 5]);
// Returns: 3

const median = COMMON_UTILS.MATH.NUM.median([1, 2, 3, 4, 5]);
// Returns: 3

import { BN } from '@drift-labs/sdk';

const max = COMMON_UTILS.MATH.BN.bnMax([new BN(100), new BN(200), new BN(50)]);
// Returns: BN(200)

const min = COMMON_UTILS.MATH.BN.bnMin([new BN(100), new BN(200), new BN(50)]);
// Returns: BN(50)

const mean = COMMON_UTILS.MATH.BN.bnMean([new BN(100), new BN(200), new BN(300)]);
// Returns: BN(200)

const median = COMMON_UTILS.MATH.BN.bnMedian([new BN(100), new BN(200), new BN(300)]);
// Returns: BN(200)

const zScore = COMMON_UTILS.calculateZScore(
  target: number,
  previousValues: number[]
);

const zScore = COMMON_UTILS.calculateZScore(150, [100, 110, 120, 130, 140]);
// Returns the z-score indicating how many standard deviations 150 is from the mean

const divides = COMMON_UTILS.dividesExactly(
  numerator: number,
  denominator: number
);

const score = COMMON_UTILS.getTieredSortScore(
  aScores: number[],
  bScores: number[]
);

// Sort students by grade, then by age if grades are equal
students.sort((a, b) => 
  COMMON_UTILS.getTieredSortScore(
    [a.grade, a.age],
    [b.grade, b.age]
  )
);

const grouped = COMMON_UTILS.glueArray<T>(
  size: number,
  elements: T[]
);

const result = COMMON_UTILS.glueArray(2, [1, 2, 3, 4, 5]);
// Returns: [[1, 2], [3, 4], [5]]

const chunked = COMMON_UTILS.chunks<T>(
  array: readonly T[],
  size: number
);

const result = COMMON_UTILS.chunks([1, 2, 3, 4, 5], 2);
// Returns: [[1, 2], [3, 4], [5]]

const { promiseResult, promiseTime } = await COMMON_UTILS.timedPromise(
  promise: Promise<T>
);

const { promiseResult, promiseTime } = await COMMON_UTILS.timedPromise(
  fetch('https://api.example.com/data')
);
console.log(`Request took ${promiseTime}ms`);

import { Connection, PublicKey } from '@solana/web3.js';

const accountsInfo = await COMMON_UTILS.getMultipleAccountsInfoChunked(
  connection: Connection,
  accounts: PublicKey[]
);