feat: Limit Orders

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 "./pools";
 export * from "./staking";
 export * from "./swap-routers";

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

@@ -0,0 +1,32 @@
+import { Chain } from "@osmosis-labs/types";
+import cachified, { CacheEntry } from "cachified";
+import { LRUCache } from "lru-cache";
+
+import { DEFAULT_LRU_OPTIONS } from "../../../utils/cache";
+import { LimitOrder, queryOrderbookActiveOrders } from "../../osmosis";
+
+const activeOrdersCache = new LRUCache<string, CacheEntry>(DEFAULT_LRU_OPTIONS);
+
+export function getOrderbookActiveOrders({
+  orderbookAddress,
+  userOsmoAddress,
+  chainList,
+}: {
+  orderbookAddress: string;
+  userOsmoAddress: string;
+  chainList: Chain[];
+}) {
+  return cachified({
+    cache: activeOrdersCache,
+    key: `orderbookActiveOrders-${orderbookAddress}-${userOsmoAddress}`,
+    ttl: 1000 * 60 * 2, // 2 minutes
+    getFreshValue: () =>
+      queryOrderbookActiveOrders({
+        orderbookAddress,
+        userAddress: userOsmoAddress,
+        chainList,
+      }).then(
+        ({ data }: { data: { count: number; orders: LimitOrder[] } }) => data
+      ),
+  });
+}

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

@@ -0,0 +1,4 @@
+export * from "./active-orders";
+export * from "./maker-fee";
+export * from "./spot-price";
+export * from "./tick-state";

packages/server/src/queries/complex/orderbooks/maker-fee.ts

@@ -0,0 +1,27 @@
+import { Dec } from "@keplr-wallet/unit";
+import { Chain } from "@osmosis-labs/types";
+import cachified, { CacheEntry } from "cachified";
+import { LRUCache } from "lru-cache";
+
+import { DEFAULT_LRU_OPTIONS } from "../../../utils/cache";
+import { queryOrderbookMakerFee } from "../../osmosis";
+
+const makerFeeCache = new LRUCache<string, CacheEntry>(DEFAULT_LRU_OPTIONS);
+
+export function getOrderbookMakerFee({
+  orderbookAddress,
+  chainList,
+}: {
+  orderbookAddress: string;
+  chainList: Chain[];
+}) {
+  return cachified({
+    cache: makerFeeCache,
+    key: `orderbookMakerFee-${orderbookAddress}`,
+    ttl: 1000 * 60 * 60 * 4, // 4 hours
+    getFreshValue: () =>
+      queryOrderbookMakerFee({ orderbookAddress, chainList }).then(
+        ({ data }: { data: string }) => new Dec(data)
+      ),
+  });
+}

packages/server/src/queries/complex/orderbooks/spot-price.ts

@@ -0,0 +1,36 @@
+import { Dec } from "@keplr-wallet/unit";
+import { Chain } from "@osmosis-labs/types";
+import cachified, { CacheEntry } from "cachified";
+import { LRUCache } from "lru-cache";
+
+import { DEFAULT_LRU_OPTIONS } from "../../../utils/cache";
+import { queryOrderbookSpotPrice } from "../../osmosis";
+
+const orderbookSpotPriceCache = new LRUCache<string, CacheEntry>(
+  DEFAULT_LRU_OPTIONS
+);
+
+export function getOrderbookSpotPrice({
+  orderbookAddress,
+  chainList,
+  quoteAssetDenom,
+  baseAssetDenom,
+}: {
+  orderbookAddress: string;
+  quoteAssetDenom: string;
+  baseAssetDenom: string;
+  chainList: Chain[];
+}) {
+  return cachified({
+    cache: orderbookSpotPriceCache,
+    key: `orderbookSpotPrice-${orderbookAddress}-${quoteAssetDenom}-${baseAssetDenom}`,
+    ttl: 1000 * 60 * 2, // 2 minutes
+    getFreshValue: () =>
+      queryOrderbookSpotPrice({
+        orderbookAddress,
+        chainList,
+        quoteAssetDenom,
+        baseAssetDenom,
+      }).then(({ data }) => new Dec(data.spot_price)),
+  });
+}

packages/server/src/queries/complex/orderbooks/tick-state.ts

@@ -0,0 +1,57 @@
+import { Chain } from "@osmosis-labs/types";
+import cachified, { CacheEntry } from "cachified";
+import { LRUCache } from "lru-cache";
+
+import { DEFAULT_LRU_OPTIONS } from "../../../utils/cache";
+import {
+  queryOrderbookTicks,
+  queryOrderbookTickUnrealizedCancelsById,
+} from "../../osmosis";
+
+const tickInfoCache = new LRUCache<string, CacheEntry>(DEFAULT_LRU_OPTIONS);
+
+export function getOrderbookTickState({
+  orderbookAddress,
+  chainList,
+  tickIds,
+}: {
+  orderbookAddress: string;
+  chainList: Chain[];
+  tickIds: number[];
+}) {
+  return cachified({
+    cache: tickInfoCache,
+    key: `orderbookTickInfo-${orderbookAddress}-${tickIds
+      .sort((a, b) => a - b)
+      .join(",")}`,
+    ttl: 1000 * 60 * 2, // 2 minutes
+    getFreshValue: () =>
+      queryOrderbookTicks({ orderbookAddress, chainList, tickIds }).then(
+        ({ data }) => data.ticks
+      ),
+  });
+}
+
+export function getOrderbookTickUnrealizedCancels({
+  orderbookAddress,
+  chainList,
+  tickIds,
+}: {
+  orderbookAddress: string;
+  chainList: Chain[];
+  tickIds: number[];
+}) {
+  return cachified({
+    cache: tickInfoCache,
+    key: `orderbookTickUnrealizedCancels-${orderbookAddress}-${tickIds
+      .sort((a, b) => a - b)
+      .join(",")}`,
+    ttl: 1000 * 60 * 2, // 2 minutes
+    getFreshValue: () =>
+      queryOrderbookTickUnrealizedCancelsById({
+        orderbookAddress,
+        chainList,
+        tickIds,
+      }).then(({ data }) => data.ticks),
+  });
+}

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

@@ -5,6 +5,7 @@ export * from "./icns";
 export * from "./incentives";
 export * from "./lockup";
 export * from "./mint";
+export * from "./orderbooks";
 export * from "./poolmanager";
 export * from "./superfluid";
 export * from "./txfees";