fix: wired in sqs query for active orders

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

@@ -1,13 +1,14 @@
 import { Dec, Int } from "@keplr-wallet/unit";
 import { tickToPrice } from "@osmosis-labs/math";
-import { Chain } from "@osmosis-labs/types";
+import { AssetList, 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 { queryActiveOrdersSQS } from "../../sidecar/orderbooks";
 import {
   getOrderbookTickState,
   getOrderbookTickUnrealizedCancels,
@@ -16,6 +17,48 @@ import type { MappedLimitOrder, OrderStatus } from "./types";
 
 const activeOrdersCache = new LRUCache<string, CacheEntry>(DEFAULT_LRU_OPTIONS);
 
+export function getOrderbookActiveOrdersSQS({
+  userOsmoAddress,
+  chainList,
+  assetList,
+}: {
+  userOsmoAddress: string;
+  chainList: Chain[];
+  assetList: AssetList[];
+}) {
+  return cachified({
+    cache: activeOrdersCache,
+    key: `orderbookActiveOrders-sqs-${userOsmoAddress}`,
+    ttl: 10000, // 10 seconds
+    getFreshValue: () =>
+      queryActiveOrdersSQS({
+        userOsmoAddress,
+      }).then(async ({ orders }) => {
+        const mappedOrders: MappedLimitOrder[] = orders.map((o) => {
+          return {
+            ...o,
+            price: new Dec(o.price),
+            quantity: o.quantity,
+            placed_quantity: o.placed_quantity,
+            percentClaimed: new Dec(o.percentClaimed),
+            totalFilled: o.totalFilled,
+            percentFilled: new Dec(o.percentFilled),
+            quoteAsset: getAssetFromAssetList({
+              coinMinimalDenom: o.quote_asset.symbol,
+              assetLists: assetList,
+            }),
+            baseAsset: getAssetFromAssetList({
+              coinMinimalDenom: o.base_asset.symbol,
+              assetLists: assetList,
+            }),
+            output: new Dec(o.output),
+          };
+        });
+        return mappedOrders;
+      }),
+  });
+}
+
 export function getOrderbookActiveOrders({
   orderbookAddress,
   userOsmoAddress,

packages/server/src/queries/sidecar/orderbooks.ts

@@ -9,7 +9,47 @@ export type CanonicalOrderbooksResponse = {
   contract_address: string;
 }[];
 
+export interface SQSActiveOrder {
+  tick_id: number;
+  order_id: number;
+  order_direction: "bid" | "ask";
+  owner: string;
+  quantity: number;
+  etas: string;
+  placed_quantity: number;
+  placed_at: number;
+  price: string;
+  percentClaimed: string;
+  totalFilled: number;
+  percentFilled: string;
+  orderbookAddress: string;
+  status: "open" | "partiallyFilled";
+  output: string;
+  quote_asset: {
+    symbol: string;
+  };
+  base_asset: {
+    symbol: string;
+  };
+}
+
+export type ActiveOrdersResponse = {
+  orders: SQSActiveOrder[];
+};
+
 export async function queryCanonicalOrderbooks() {
   const url = new URL("/pools/canonical-orderbooks", SIDECAR_BASE_URL);
   return await apiClient<CanonicalOrderbooksResponse>(url.toString());
 }
+
+export async function queryActiveOrdersSQS({
+  userOsmoAddress,
+}: {
+  userOsmoAddress: string;
+}) {
+  const url = new URL(
+    `/orderbook/active-orders?userOsmoAddress=${userOsmoAddress}`,
+    SIDECAR_BASE_URL
+  );
+  return await apiClient<ActiveOrdersResponse>(url.toString());
+}

packages/trpc/src/orderbook-router.ts

@@ -3,6 +3,7 @@ import { tickToPrice } from "@osmosis-labs/math";
 import {
   CursorPaginationSchema,
   getOrderbookActiveOrders,
+  getOrderbookActiveOrdersSQS,
   getOrderbookHistoricalOrders,
   getOrderbookMakerFee,
   getOrderbookPools,
@@ -134,6 +135,30 @@ export const orderbookRouter = createTRPCRouter({
         limit: input.limit,
       });
     }),
+  getAllOrdersSQS: publicProcedure
+    .input(GetInfiniteLimitOrdersInputSchema)
+    .query(async ({ input, ctx }) => {
+      return maybeCachePaginatedItems({
+        getFreshItems: async () => {
+          const { userOsmoAddress } = input;
+          const orders = await getOrderbookActiveOrdersSQS({
+            userOsmoAddress,
+            chainList: ctx.chainList,
+            assetList: ctx.assetLists,
+          });
+          const historicalOrders = await getOrderbookHistoricalOrders({
+            userOsmoAddress,
+            assetLists: ctx.assetLists,
+            chainList: ctx.chainList,
+          });
+          return [...orders, ...historicalOrders].sort(defaultSortOrders);
+        },
+        cacheKey: `all-active-orders-sqs-${input.userOsmoAddress}`,
+        ttl: 2000,
+        cursor: input.cursor,
+        limit: input.limit,
+      });
+    }),
   getOrderbookState: publicProcedure
     .input(OsmoAddressSchema.required())
     .query(async ({ input, ctx }) => {

packages/web/components/complex/orders-history/index.tsx

@@ -85,7 +85,6 @@ export const OrderHistory = observer(() => {
     userAddress: wallet?.address ?? "",
     pageSize: 20,
   });
-
   const groupedOrders = useMemo(() => groupOrdersByStatus(orders), [orders]);
   const groups = useMemo(
     () =>

packages/web/components/trade-tool/index.tsx

@@ -15,6 +15,7 @@ import {
 } from "~/components/swap-tool/swap-tool-tabs";
 import { EventName, EventPage } from "~/config";
 import { useAmplitudeAnalytics, useTranslation } from "~/hooks";
+import { useOrderbookAllActiveOrders } from "~/hooks/limit-orders/use-orderbook";
 import { PreviousTrade } from "~/pages";
 import { useStore } from "~/stores";
 
@@ -39,6 +40,7 @@ export const TradeTool: FunctionComponent<TradeToolProps> = observer(
     const { accountStore } = useStore();
     const wallet = accountStore.getWallet(accountStore.osmosisChainId);
 
+    useOrderbookAllActiveOrders({ userAddress: wallet?.address ?? "" });
     useEffect(() => {
       switch (tab) {
         case SwapToolTab.BUY:

packages/web/hooks/limit-orders/use-orderbook.ts

@@ -265,7 +265,7 @@ export type DisplayableLimitOrder = MappedLimitOrder;
 export const useOrderbookAllActiveOrders = ({
   userAddress,
   pageSize = 10,
-  refetchInterval = 30000,
+  refetchInterval = 2000,
 }: {
   userAddress: string;
   pageSize?: number;
@@ -282,7 +282,7 @@ export const useOrderbookAllActiveOrders = ({
     hasNextPage,
     refetch,
     isRefetching,
-  } = api.edge.orderbooks.getAllOrders.useInfiniteQuery(
+  } = api.edge.orderbooks.getAllOrdersSQS.useInfiniteQuery(
     {
       userOsmoAddress: userAddress,
       limit: pageSize,