Merge remote-tracking branch 'origin/main' into tu/take-profit

package.json

@@ -60,7 +60,7 @@
     "@dydxprotocol/v4-localization": "^1.1.259",
     "@dydxprotocol/v4-proto": "^7.0.0-dev.0",
     "@emotion/is-prop-valid": "^1.3.0",
-    "@funkit/connect": "^4.1.6",
+    "@funkit/connect": "^4.1.7",
     "@hugocxl/react-to-image": "^0.0.9",
     "@js-joda/core": "^5.5.3",
     "@keplr-wallet/types": "^0.12.121",

src/abacus-ts/calculators/accountActions.ts

@@ -77,15 +77,14 @@ function addUsdcAssetPosition(
   });
 }
 
+export type UsdcDepositArgs = {
+  subaccountNumber: number;
+  depositAmount: string;
+};
+
 export function createUsdcDepositOperations(
   parentSubaccount: ParentSubaccountData,
-  {
-    subaccountNumber,
-    depositAmount,
-  }: {
-    subaccountNumber: number;
-    depositAmount: string;
-  }
+  { subaccountNumber, depositAmount }: UsdcDepositArgs
 ): SubaccountBatchedOperations {
   const updatedParentSubaccountData = addUsdcAssetPosition(parentSubaccount, {
     side: IndexerPositionSide.LONG,
@@ -107,15 +106,13 @@ export function createUsdcDepositOperations(
   };
 }
 
+export type UsdcWithdrawArgs = {
+  subaccountNumber: number;
+  withdrawAmount: string;
+};
 export function createUsdcWithdrawalOperations(
   parentSubaccount: ParentSubaccountData,
-  {
-    subaccountNumber,
-    withdrawAmount,
-  }: {
-    subaccountNumber: number;
-    withdrawAmount: string;
-  }
+  { subaccountNumber, withdrawAmount }: UsdcWithdrawArgs
 ): SubaccountBatchedOperations {
   const updatedParentSubaccountData = addUsdcAssetPosition(parentSubaccount, {
     side: IndexerPositionSide.SHORT,

src/abacus-ts/calculators/funding.ts

@@ -13,7 +13,14 @@ export const getDirectionFromFundingRate = (fundingRate: string) => {
       : FundingDirection.ToLong;
 };
 
-export const mapFundingChartObject = (funding: IndexerHistoricalFundingResponseObject) => ({
+export type HistoricalFundingObject = {
+  fundingRate: number;
+  time: number;
+  direction: FundingDirection;
+};
+export const mapFundingChartObject = (
+  funding: IndexerHistoricalFundingResponseObject
+): HistoricalFundingObject => ({
   fundingRate: MustBigNumber(funding.rate).toNumber(),
   time: new Date(funding.effectiveAt).getTime(),
   direction: getDirectionFromFundingRate(funding.rate),

src/abacus-ts/calculators/markets.ts

@@ -79,18 +79,27 @@ function calculateDerivedMarketDisplayItems(market: IndexerWsBaseMarketObject) {
   };
 }
 
+function calculatePriceChangePercent(
+  priceChange24H: string | null | undefined,
+  oraclePrice: string | null | undefined
+): BigNumber | null {
+  if (priceChange24H == null || oraclePrice == null) {
+    return null;
+  }
+
+  const price24hAgo = MustBigNumber(oraclePrice).minus(priceChange24H);
+  return price24hAgo.gt(0) ? MustBigNumber(priceChange24H).div(price24hAgo) : null;
+}
+
 function calculateDerivedMarketCore(market: IndexerWsBaseMarketObject) {
   return {
     effectiveInitialMarginFraction:
       getMarketEffectiveInitialMarginForMarket(market)?.toNumber() ?? null,
     openInterestUSDC: MustBigNumber(market.openInterest)
       .times(market.oraclePrice ?? 0)
       .toNumber(),
-    percentChange24h: MustBigNumber(market.oraclePrice).isZero()
-      ? null
-      : MustBigNumber(market.priceChange24H)
-          .div(market.oraclePrice ?? 0)
-          .toNumber(),
+    percentChange24h:
+      calculatePriceChangePercent(market.priceChange24H, market.oraclePrice)?.toNumber() ?? null,
     stepSizeDecimals: MaybeBigNumber(market.stepSize)?.decimalPlaces() ?? TOKEN_DECIMALS,
     tickSizeDecimals: MaybeBigNumber(market.tickSize)?.decimalPlaces() ?? USD_DECIMALS,
   };
@@ -110,7 +119,7 @@ export function formatSparklineData(sparklines?: {
   if (sparklines == null) return sparklines;
   return mapValues(sparklines, (map) => {
     return mapValues(map, (sparkline) => {
-      return sparkline.map((point) => MustBigNumber(point).toNumber());
+      return sparkline.map((point) => MustBigNumber(point).toNumber()).toReversed();
     });
   });
 }
@@ -120,9 +129,9 @@ export function createMarketSummary(
   sparklines: PerpetualMarketSparklines | undefined,
   assetInfo: AllAssetData | undefined,
   listOfFavorites: string[]
-): PerpetualMarketSummaries | null {
+): PerpetualMarketSummaries | undefined {
   if (markets == null || assetInfo == null) {
-    return null;
+    return undefined;
   }
 
   return pickBy(

src/abacus-ts/calculators/orderbook.ts

@@ -0,0 +1,155 @@
+import BigNumber from 'bignumber.js';
+import { weakMapMemoize } from 'reselect';
+
+import { isTruthy } from '@/lib/isTruthy';
+import { BIG_NUMBERS, MustBigNumber } from '@/lib/numbers';
+import { objectEntries } from '@/lib/objectHelpers';
+
+import { OrderbookData } from '../types/rawTypes';
+import { OrderbookLine, OrderbookProcessedData } from '../types/summaryTypes';
+
+type OrderbookLineBN = {
+  price: BigNumber;
+  size: BigNumber;
+  sizeCost: BigNumber;
+  offset: number;
+  depth?: BigNumber;
+  depthCost?: BigNumber;
+};
+
+export const calculateOrderbook = weakMapMemoize(
+  (orderbook: OrderbookData | undefined): OrderbookProcessedData | undefined => {
+    if (orderbook == null) {
+      return undefined;
+    }
+
+    const { asks, bids } = orderbook;
+
+    /**
+     * 1. Process raw orderbook data
+     * 2. filter out lines with size <= 0
+     * 3. sort by price
+     */
+    const asksBase: OrderbookLineBN[] = objectEntries(asks)
+      .map(mapRawOrderbookLineToBN)
+      .filter(isTruthy)
+      .sort((a, b) => a.price.minus(b.price).toNumber());
+
+    const bidsBase: OrderbookLineBN[] = objectEntries(bids)
+      .map(mapRawOrderbookLineToBN)
+      .filter(isTruthy)
+      .sort((a, b) => a.price.minus(b.price).toNumber());
+
+    // calculate depth and depthCost
+    const asksComposite = calculateDepthAndDepthCost(asksBase);
+    const bidsComposite = calculateDepthAndDepthCost(bidsBase);
+
+    // un-cross orderbook
+    const uncrossedBook: { asks: OrderbookLineBN[]; bids: OrderbookLineBN[] } = uncrossOrderbook(
+      asksComposite,
+      bidsComposite
+    );
+
+    // calculate midPrice, spread, and spreadPercent
+    const lowestAsk = uncrossedBook.asks.at(0);
+    const highestBid = uncrossedBook.bids.at(-1);
+    const midPriceBN = lowestAsk && highestBid && lowestAsk.price.plus(highestBid.price).div(2);
+    const spreadBN = lowestAsk && highestBid && lowestAsk.price.minus(highestBid.price);
+    const spreadPercentBN = spreadBN && midPriceBN && spreadBN.div(midPriceBN).times(100);
+
+    return {
+      bids: uncrossedBook.bids.map(mapOrderbookLineToNumber),
+      asks: uncrossedBook.asks.map(mapOrderbookLineToNumber),
+      midPrice: midPriceBN?.toNumber(),
+      spread: spreadBN?.toNumber(),
+      spreadPercent: spreadPercentBN?.toNumber(),
+    };
+  }
+);
+
+function uncrossOrderbook(asks: OrderbookLineBN[], bids: OrderbookLineBN[]) {
+  if (asks.length === 0 || bids.length === 0) {
+    return { asks, bids };
+  }
+
+  const asksCopy = [...asks];
+  const bidsCopy = [...bids];
+
+  let ask = asksCopy.at(-1);
+  let bid = bidsCopy.at(0);
+
+  while (ask && bid && isCrossed(ask, bid)) {
+    if (ask.offset === bid.offset) {
+      // If offsets are the same, give precedence to the larger size. In this case,
+      // one of the sizes "should" be zero, but we simply check for the larger size.
+      if (ask.size.gt(bid.size)) {
+        // remove the bid
+        bid = bidsCopy.shift();
+      } else {
+        // remove the ask
+        ask = asksCopy.shift();
+      }
+    } else {
+      // If offsets are different, remove the older offset.
+      if (ask.offset < bid.offset) {
+        // remove the ask
+        ask = asksCopy.shift();
+      } else {
+        // remove the bid
+        bid = bidsCopy.shift();
+      }
+    }
+  }
+
+  return { asks: asksCopy, bids: bidsCopy };
+}
+
+function calculateDepthAndDepthCost(lines: OrderbookLineBN[]) {
+  let depth = BIG_NUMBERS.ZERO;
+  let depthCost = BIG_NUMBERS.ZERO;
+
+  return lines.map((line) => {
+    depth = depth.plus(line.size);
+    depthCost = depthCost.plus(line.sizeCost);
+
+    return {
+      ...line,
+      depth,
+      depthCost,
+    };
+  });
+}
+
+function mapRawOrderbookLineToBN(
+  rawOrderbookLineEntry: [string, { size: string; offset: number }]
+) {
+  const [price, { size, offset }] = rawOrderbookLineEntry;
+  const sizeBN = MustBigNumber(size);
+  const priceBN = MustBigNumber(price);
+
+  if (sizeBN.isZero()) return undefined;
+
+  return {
+    price: priceBN,
+    size: sizeBN,
+    sizeCost: priceBN.times(sizeBN),
+    offset,
+  };
+}
+
+function mapOrderbookLineToNumber(orderbookLineBN: OrderbookLineBN): OrderbookLine {
+  const { price, size, sizeCost, depth, depthCost, offset } = orderbookLineBN;
+
+  return {
+    price: price.toNumber(),
+    size: size.toNumber(),
+    sizeCost: sizeCost.toNumber(),
+    offset,
+    depth: depth?.toNumber() ?? 0,
+    depthCost: depthCost?.toNumber() ?? 0,
+  };
+}
+
+function isCrossed(ask: OrderbookLineBN, bid: OrderbookLineBN) {
+  return ask.price.lte(bid.price);
+}

src/abacus-ts/lib/loadable.ts

@@ -3,6 +3,7 @@ export type LoadableSuccess<T> = { status: 'success'; data: T };
 export type LoadableIdle = { status: 'idle'; data: undefined };
 export type LoadableError<T> = { status: 'error'; data?: T; error: any };
 export type Loadable<T> = LoadableIdle | LoadableSuccess<T> | LoadablePending<T> | LoadableError<T>;
+export type LoadableStatus = Loadable<any>['status'];
 
 export function loadablePending<T>() {
   return { status: 'pending' } as LoadablePending<T>;