Limit Orders and Swap Flow Redesign

packages/math/src/pool/concentrated/__tests__/tick.spec.ts

@@ -2,7 +2,7 @@ import { Dec, Int } from "@keplr-wallet/unit";
 
 import { approxSqrt } from "../../../utils";
 import { maxSpotPrice, maxTick, minSpotPrice } from "../const";
-import { priceToTick, tickToSqrtPrice } from "../tick";
+import { priceToTick, tickToPrice, tickToSqrtPrice } from "../tick";
 
 // https://github.com/osmosis-labs/osmosis/blob/0f9eb3c1259078035445b3e3269659469b95fd9f/x/concentrated-liquidity/math/tick_test.go#L30
 describe("tickToSqrtPrice", () => {
@@ -217,6 +217,38 @@ describe("priceToTick", () => {
   });
 });
 
+describe("tickToPrice", () => {
+  const testCases: Record<string, { tick: Int; priceExpected: Dec }> = {
+    "Tick Zero": {
+      tick: new Int("0"),
+      priceExpected: new Dec("1"),
+    },
+    "Large Positive Tick": {
+      tick: new Int("1000000"),
+      priceExpected: new Dec("2"),
+    },
+    "Large Negative Tick": {
+      tick: new Int("-5000000"),
+      priceExpected: new Dec("0.5"),
+    },
+    "Max Tick": {
+      tick: new Int("182402823"),
+      priceExpected: new Dec("340282300000000000000"),
+    },
+    "Min Tick": {
+      tick: new Int("-108000000"),
+      priceExpected: new Dec("0.000000000001"),
+    },
+  };
+
+  Object.values(testCases).forEach(({ tick, priceExpected }, i) => {
+    it(Object.keys(testCases)[i], () => {
+      const price = tickToPrice(tick);
+      expect(price.toString()).toEqual(priceExpected.toString());
+    });
+  });
+});
+
 // TEMORARY: commenting out until we confirm adding a buffer around current tick avoids invalid queries
 // describe("estimateInitialTickBound", () => {
 //   // src: https://github.com/osmosis-labs/osmosis/blob/0b199ee187fbff02f68c2dc503d60efe617a67b2/x/concentrated-liquidity/tick_test.go#L1865

packages/math/src/pool/concentrated/tick.ts

@@ -66,6 +66,53 @@ export function tickToSqrtPrice(tickIndex: Int): Dec {
   return approxSqrt(price);
 }
 
+export function tickToPrice(tickIndex: Int): Dec {
+  if (tickIndex.isZero()) {
+    return new Dec(1);
+  }
+
+  const geometricExponentIncrementDistanceInTicks = nine.mul(
+    powTenBigDec(new Int(exponentAtPriceOne).neg()).toDec()
+  );
+
+  if (tickIndex.lt(minTick) || tickIndex.gt(maxTick)) {
+    throw new Error(
+      `tickIndex is out of range: ${tickIndex.toString()}, min: ${minTick.toString()}, max: ${maxTick.toString()}`
+    );
+  }
+
+  const geometricExponentDelta = new Dec(tickIndex)
+    .quoTruncate(new Dec(geometricExponentIncrementDistanceInTicks.truncate()))
+    .truncate();
+
+  let exponentAtCurTick = new Int(exponentAtPriceOne).add(
+    geometricExponentDelta
+  );
+  if (tickIndex.lt(new Int(0))) {
+    exponentAtCurTick = exponentAtCurTick.sub(new Int(1));
+  }
+
+  const currentAdditiveIncrementInTicks = powTenBigDec(exponentAtCurTick);
+
+  const numAdditiveTicks = tickIndex.sub(
+    geometricExponentDelta.mul(
+      geometricExponentIncrementDistanceInTicks.truncate()
+    )
+  );
+
+  const price = powTenBigDec(geometricExponentDelta)
+    .add(new BigDec(numAdditiveTicks).mul(currentAdditiveIncrementInTicks))
+    .toDec();
+
+  if (price.gt(maxSpotPrice) || price.lt(minSpotPrice)) {
+    throw new Error(
+      `price is out of range: ${price.toString()}, min: ${minSpotPrice.toString()}, max: ${maxSpotPrice.toString()}`
+    );
+  }
+
+  return price;
+}
+
 /** PriceToTick takes a price and returns the corresponding tick index
  *  This function does not take into consideration tick spacing.
  */

packages/server/src/queries/complex/index.ts

@@ -4,6 +4,7 @@ export * from "./chains";
 export * from "./concentrated-liquidity";
 export * from "./earn";
 export * from "./get-timeout-height";
+export * from "./orderbooks";
 export * from "./osmosis";
 export * from "./pools";
 export * from "./portfolio";

packages/server/src/queries/complex/orderbooks/active-orders.ts

@@ -0,0 +1,158 @@
+import { Dec, Int } from "@keplr-wallet/unit";
+import { tickToPrice } from "@osmosis-labs/math";
+import { Chain } from "@osmosis-labs/types";
+import { getAssetFromAssetList } from "@osmosis-labs/utils";
+import cachified, { CacheEntry } from "cachified";
+import dayjs from "dayjs";
+import { LRUCache } from "lru-cache";
+
+import { DEFAULT_LRU_OPTIONS } from "../../../utils/cache";
+import { LimitOrder, queryOrderbookActiveOrders } from "../../osmosis";
+import {
+  getOrderbookTickState,
+  getOrderbookTickUnrealizedCancels,
+} from "./tick-state";
+import type { MappedLimitOrder, OrderStatus } from "./types";
+
+const activeOrdersCache = new LRUCache<string, CacheEntry>(DEFAULT_LRU_OPTIONS);
+
+export function getOrderbookActiveOrders({
+  orderbookAddress,
+  userOsmoAddress,
+  chainList,
+  baseAsset,
+  quoteAsset,
+}: {
+  orderbookAddress: string;
+  userOsmoAddress: string;
+  chainList: Chain[];
+  baseAsset: ReturnType<typeof getAssetFromAssetList>;
+  quoteAsset: ReturnType<typeof getAssetFromAssetList>;
+}) {
+  return cachified({
+    cache: activeOrdersCache,
+    key: `orderbookActiveOrders-${orderbookAddress}-${userOsmoAddress}`,
+    ttl: 500, // 2 seconds
+    getFreshValue: () =>
+      queryOrderbookActiveOrders({
+        orderbookAddress,
+        userAddress: userOsmoAddress,
+        chainList,
+      }).then(
+        async ({ data }: { data: { count: number; orders: LimitOrder[] } }) => {
+          const resp = await getTickInfoAndTransformOrders(
+            orderbookAddress,
+            data.orders,
+            chainList,
+            quoteAsset,
+            baseAsset
+          );
+          return resp;
+        }
+      ),
+  });
+}
+
+function mapOrderStatus(order: LimitOrder, percentFilled: Dec): OrderStatus {
+  const quantInt = parseInt(order.quantity);
+  if (quantInt === 0 || percentFilled.equals(new Dec(1))) return "filled";
+  if (percentFilled.isZero()) return "open";
+  if (percentFilled.lt(new Dec(1))) return "partiallyFilled";
+
+  return "open";
+}
+
+async function getTickInfoAndTransformOrders(
+  orderbookAddress: string,
+  orders: LimitOrder[],
+  chainList: Chain[],
+  quoteAsset: ReturnType<typeof getAssetFromAssetList>,
+  baseAsset: ReturnType<typeof getAssetFromAssetList>
+): Promise<MappedLimitOrder[]> {
+  if (orders.length === 0) return [];
+
+  const tickIds = [...new Set(orders.map((o) => o.tick_id))];
+
+  const [tickStates, unrealizedTickCancels] = await Promise.all([
+    getOrderbookTickState({
+      orderbookAddress,
+      chainList,
+      tickIds,
+    }),
+    getOrderbookTickUnrealizedCancels({
+      orderbookAddress,
+      chainList,
+      tickIds,
+    }),
+  ]);
+
+  const fullTickState = tickStates.map(({ tick_id, tick_state }) => ({
+    tickId: tick_id,
+    tickState: tick_state,
+    unrealizedCancels: unrealizedTickCancels.find((c) => c.tick_id === tick_id),
+  }));
+
+  return orders.map((o) => {
+    const { tickState, unrealizedCancels } = fullTickState.find(
+      ({ tickId }) => tickId === o.tick_id
+    ) ?? { tickState: undefined, unrealizedCancels: undefined };
+
+    const quantity = parseInt(o.quantity);
+    const placedQuantity = parseInt(o.placed_quantity);
+
+    const percentClaimed = new Dec(
+      (placedQuantity - quantity) / placedQuantity
+    );
+
+    const normalizationFactor = new Dec(10).pow(
+      new Int((quoteAsset?.decimals ?? 0) - (baseAsset?.decimals ?? 0))
+    );
+    const [tickEtas, tickUnrealizedCancelled] =
+      o.order_direction === "bid"
+        ? [
+            parseInt(
+              tickState?.bid_values.effective_total_amount_swapped ?? "0"
+            ),
+            parseInt(
+              unrealizedCancels?.unrealized_cancels.bid_unrealized_cancels ??
+                "0"
+            ),
+          ]
+        : [
+            parseInt(
+              tickState?.ask_values.effective_total_amount_swapped ?? "0"
+            ),
+            parseInt(
+              unrealizedCancels?.unrealized_cancels.ask_unrealized_cancels ??
+                "0"
+            ),
+          ];
+    const tickTotalEtas = tickEtas + tickUnrealizedCancelled;
+    const totalFilled = Math.max(
+      tickTotalEtas - (parseInt(o.etas) - (placedQuantity - quantity)),
+      0
+    );
+    const percentFilled = new Dec(Math.min(totalFilled / placedQuantity, 1));
+    const price = tickToPrice(new Int(o.tick_id));
+    const status = mapOrderStatus(o, percentFilled);
+    const output =
+      o.order_direction === "bid"
+        ? new Dec(placedQuantity).quo(price)
+        : new Dec(placedQuantity).mul(price);
+    return {
+      ...o,
+      price: price.quo(normalizationFactor),
+      quantity,
+      placed_quantity: placedQuantity,
+      percentClaimed,
+      totalFilled,
+      percentFilled,
+      orderbookAddress,
+      status,
+      output,
+      quoteAsset,
+      baseAsset,
+      placed_at: dayjs(parseInt(o.placed_at) / 1_000).unix(),
+    };
+  });
+}

packages/server/src/queries/complex/orderbooks/denoms.ts

@@ -0,0 +1,47 @@
+import { AssetList, Chain } from "@osmosis-labs/types";
+import { getAssetFromAssetList } from "@osmosis-labs/utils";
+import cachified, { CacheEntry } from "cachified";
+import { LRUCache } from "lru-cache";
+
+import { DEFAULT_LRU_OPTIONS } from "../../../utils/cache";
+import { getOrderbookPools } from "./pools";
+
+const orderbookDenomsCache = new LRUCache<string, CacheEntry>(
+  DEFAULT_LRU_OPTIONS
+);
+
+export function getOrderbookDenoms({
+  orderbookAddress,
+  assetLists,
+}: {
+  orderbookAddress: string;
+  chainList: Chain[];
+  assetLists: AssetList[];
+}) {
+  return cachified({
+    cache: orderbookDenomsCache,
+    key: `orderbookDenoms-${orderbookAddress}`,
+    ttl: 1000 * 60 * 60 * 24 * 30, // 30 days
+    swr: 1000 * 60 * 60 * 24 * 30, // 30 days
+    staleRefreshTimeout: 1000 * 60 * 60 * 24 * 30, // 30 days
+    getFreshValue: () =>
+      getOrderbookPools().then((pools) => {
+        const pool = pools.find((p) => p.contractAddress === orderbookAddress);
+        if (!pool)
+          return {
+            quoteAsset: undefined,
+            baseAsset: undefined,
+          };
+        const quoteAsset = getAssetFromAssetList({
+          coinMinimalDenom: pool.quoteDenom,
+          assetLists,
+        });
+        const baseAsset = getAssetFromAssetList({
+          coinMinimalDenom: pool.baseDenom,
+          assetLists,
+        });
+
+        return { quoteAsset, baseAsset };
+      }),
+  });
+}