fix build lint

babel.config.json

@@ -1,3 +1,12 @@
 {
-  "presets": [["@babel/preset-env", { "targets": { "node": "current" } }]]
-}
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "targets": {
+          "node": "current"
+        }
+      }
+    ]
+  ]
+}

lerna.json

@@ -16,4 +16,4 @@
       "message": "chore(release): publish"
     }
   }
-}
+}

package.json

@@ -82,4 +82,4 @@
     "@keplr-wallet/types": "0.10.24-ibc.go.v7.hot.fix",
     "@keplr-wallet/unit": "0.10.24-ibc.go.v7.hot.fix"
   }
-}
+}

packages/keplr-stores/src/price/index.ts

@@ -12,7 +12,7 @@ import type { AppCurrency } from "@osmosis-labs/types";
 class Throttler {
   protected fns: (() => void)[] = [];
 
-  private timeoutId?: NodeJS.Timeout;
+  private timeoutId?: number;
 
   constructor(public readonly duration: number) {}
 

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 * 3, // 3 seconds
+    getFreshValue: () =>
+      queryOrderbookActiveOrders({
+        orderbookAddress,
+        userAddress: userOsmoAddress,
+        chainList,
+      }).then(
+        ({ data }: { data: { count: number; orders: LimitOrder[] } }) => data
+      ),
+  });
+}

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

@@ -0,0 +1,28 @@
+import { Chain } from "@osmosis-labs/types";
+import cachified, { CacheEntry } from "cachified";
+import { LRUCache } from "lru-cache";
+
+import { DEFAULT_LRU_OPTIONS } from "../../../utils/cache";
+import { queryOrderbookDenoms } from "../../osmosis";
+
+const orderbookDenomsCache = new LRUCache<string, CacheEntry>(
+  DEFAULT_LRU_OPTIONS
+);
+
+export function getOrderbookDenoms({
+  orderbookAddress,
+  chainList,
+}: {
+  orderbookAddress: string;
+  chainList: Chain[];
+}) {
+  return cachified({
+    cache: orderbookDenomsCache,
+    key: `orderbookDenoms-${orderbookAddress}`,
+    ttl: 1000 * 60 * 60 * 24 * 7, // 7 days
+    getFreshValue: () =>
+      queryOrderbookDenoms({ orderbookAddress, chainList }).then(
+        ({ data }) => data
+      ),
+  });
+}

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

@@ -0,0 +1,36 @@
+import cachified, { CacheEntry } from "cachified";
+import { LRUCache } from "lru-cache";
+
+import { DEFAULT_LRU_OPTIONS } from "../../../utils/cache";
+import { HistoricalLimitOrder, queryHistoricalOrders } from "../../osmosis";
+
+const orderbookHistoricalOrdersCache = new LRUCache<string, CacheEntry>(
+  DEFAULT_LRU_OPTIONS
+);
+
+export function getOrderbookHistoricalOrders({
+  userOsmoAddress,
+}: {
+  userOsmoAddress: string;
+}) {
+  return cachified({
+    cache: orderbookHistoricalOrdersCache,
+    key: `orderbookHistoricalOrders-${userOsmoAddress}`,
+    ttl: 1000 * 3, // 3 seconds
+    getFreshValue: () =>
+      queryHistoricalOrders(userOsmoAddress).then((data) => {
+        const orders = data;
+        orders.forEach((o) => {
+          if (o.status === "cancelled" && o.claimed_quantity !== "0") {
+            const newOrder: HistoricalLimitOrder = {
+              ...o,
+              quantity: o.claimed_quantity,
+              status: "fullyClaimed",
+            };
+            orders.push(newOrder);
+          }
+        });
+        return orders;
+      }),
+  });
+}

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

@@ -0,0 +1,7 @@
+export * from "./active-orders";
+export * from "./denoms";
+export * from "./historical-orders";
+export * from "./maker-fee";
+export * from "./orderbook-state";
+export * from "./pools";
+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/orderbook-state.ts

@@ -0,0 +1,29 @@
+import { Chain } from "@osmosis-labs/types";
+import cachified, { CacheEntry } from "cachified";
+import { LRUCache } from "lru-cache";
+
+import { DEFAULT_LRU_OPTIONS } from "../../../utils/cache";
+import { queryOrderbookState } from "../../osmosis";
+
+const orderbookStateCache = new LRUCache<string, CacheEntry>(
+  DEFAULT_LRU_OPTIONS
+);
+
+export function getOrderbookState({
+  orderbookAddress,
+  chainList,
+}: {
+  orderbookAddress: string;
+  chainList: Chain[];
+}) {
+  return cachified({
+    cache: orderbookStateCache,
+    key: `orderbookState-${orderbookAddress}`,
+    ttl: 1000 * 3, // 3 seconds
+    getFreshValue: () =>
+      queryOrderbookState({
+        orderbookAddress,
+        chainList,
+      }).then(({ data }) => data),
+  });
+}

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

@@ -0,0 +1,35 @@
+import cachified, { CacheEntry } from "cachified";
+import { LRUCache } from "lru-cache";
+
+import { DEFAULT_LRU_OPTIONS } from "../../../utils/cache";
+import { queryCanonicalOrderbooks } from "../../sidecar/orderbooks";
+
+const orderbookPoolsCache = new LRUCache<string, CacheEntry>(
+  DEFAULT_LRU_OPTIONS
+);
+
+export interface Orderbook {
+  baseDenom: string;
+  quoteDenom: string;
+  contractAddress: string;
+  poolId: string;
+}
+
+export function getOrderbookPools() {
+  return cachified({
+    cache: orderbookPoolsCache,
+    key: `orderbookPools`,
+    ttl: 1000 * 60 * 60, // 1 hour
+    getFreshValue: () =>
+      queryCanonicalOrderbooks().then(async (data) => {
+        return data.map((orderbook) => {
+          return {
+            baseDenom: orderbook.base,
+            quoteDenom: orderbook.quote,
+            contractAddress: orderbook.contract_address,
+            poolId: orderbook.pool_id.toString(),
+          };
+        }) as Orderbook[];
+      }),
+  });
+}