txs count route

Author: vrtnd

src/handlers/getBridgeTxCounts.ts

@@ -0,0 +1,43 @@
+import { IResponse, successResponse } from "../utils/lambda-response";
+import wrap from "../utils/wrap";
+import bridgeNetworks from "../data/bridgeNetworkData";
+import { normalizeChain } from "../utils/normalizeChain";
+import { DEFAULT_TTL } from "../utils/cache";
+import { queryBridgeTxCounts24h } from "../utils/wrappa/postgres/query";
+
+const secondsInDay = 24 * 60 * 60;
+
+const getBridgeTxCounts = async (chain?: string) => {
+  const queryChain = chain && chain !== "all" ? normalizeChain(chain) : undefined;
+  const startTimestamp = Math.floor(Date.now() / 1000) - secondsInDay;
+  const txCounts = await queryBridgeTxCounts24h(startTimestamp, queryChain);
+  const txCountsByBridgeName = txCounts.reduce((acc, row) => {
+    acc[row.bridge_name] = row;
+    return acc;
+  }, {} as Record<string, (typeof txCounts)[number]>);
+
+  return {
+    bridges: bridgeNetworks.map(({ id, displayName, slug, bridgeDbName }) => {
+      const counts = txCountsByBridgeName[bridgeDbName];
+      const depositTxs24h = counts?.deposit_txs_24h ?? 0;
+      const withdrawTxs24h = counts?.withdraw_txs_24h ?? 0;
+
+      return {
+        id,
+        displayName,
+        slug,
+        txsPrevDay: depositTxs24h + withdrawTxs24h,
+        depositTxs24h,
+        withdrawTxs24h,
+      };
+    }),
+  };
+};
+
+const handler = async (event: AWSLambda.APIGatewayEvent): Promise<IResponse> => {
+  const chain = event.pathParameters?.chain?.toLowerCase().replace(/%20/g, " ");
+  const response = await getBridgeTxCounts(chain);
+  return successResponse(response, DEFAULT_TTL);
+};
+
+export default wrap(handler);

src/server/index.ts

@@ -6,6 +6,7 @@ import getBridgeVolumeBySlug from "../handlers/getBridgeVolumeBySlug";
 import getBridges from "../handlers/getBridges";
 import getBridge from "../handlers/getBridge";
 import getBridgeChains from "../handlers/getBridgeChains";
+import getBridgeTxCounts from "../handlers/getBridgeTxCounts";
 import getLargeTransactions from "../handlers/getLargeTransactions";
 import getLastBlocks from "../handlers/getLastBlocks";
 import getNetflows from "../handlers/getNetflows";
@@ -86,6 +87,7 @@ const start = async () => {
     server.get("/bridgedaystats/:timestamp/:chain", lambdaToFastify(getBridgeStatsOnDay));
     server.get("/bridgevolume/:chain", lambdaToFastify(getBridgeVolume));
     server.get("/bridgevolume/slug/:slug", lambdaToFastify(getBridgeVolumeBySlug));
+    server.get("/bridgetxcounts/:chain", lambdaToFastify(getBridgeTxCounts));
     server.get("/bridges", lambdaToFastify(getBridges));
     server.get("/bridge/:id", lambdaToFastify(getBridge));
     server.get("/bridgechains", lambdaToFastify(getBridgeChains));

src/utils/wrappa/postgres/query.ts

@@ -44,6 +44,12 @@ interface IAggregatedData {
   total_address_withdrawn: string[];
 }
 
+interface IBridgeTxCounts24H {
+  bridge_name: string;
+  deposit_txs_24h: number;
+  withdraw_txs_24h: number;
+}
+
 type TimePeriod = "day" | "week" | "month";
 
 const getBridgeID = async (bridgNetworkName: string, chain: string) => {
@@ -380,6 +386,95 @@ const getLast24HVolume = async (bridgeName: string, volumeType: VolumeType = "bo
   return totalVolume / 2;
 };
 
+const queryBridgeTxCounts24h = async (startTimestamp: number, chain?: string) => {
+  if (!chain) {
+    return await sql<IBridgeTxCounts24H[]>`
+      SELECT
+        c.bridge_name,
+        CAST(
+          COALESCE(
+            SUM(
+              CASE
+                WHEN t.is_deposit THEN COALESCE(t.txs_counted_as, 1)
+                ELSE 0
+              END
+            ),
+            0
+          ) AS INTEGER
+        ) AS deposit_txs_24h,
+        CAST(
+          COALESCE(
+            SUM(
+              CASE
+                WHEN NOT t.is_deposit THEN COALESCE(t.txs_counted_as, 1)
+                ELSE 0
+              END
+            ),
+            0
+          ) AS INTEGER
+        ) AS withdraw_txs_24h
+      FROM bridges.config c
+      LEFT JOIN bridges.transactions t
+        ON t.bridge_id = c.id
+       AND t.ts >= to_timestamp(${startTimestamp})
+      GROUP BY c.bridge_name
+      ORDER BY c.bridge_name;
+    `;
+  }
+
+  return await sql<IBridgeTxCounts24H[]>`
+    SELECT
+      c.bridge_name,
+      CAST(
+        COALESCE(
+          SUM(
+            CASE
+              WHEN c.chain = ${chain} THEN
+                CASE
+                  WHEN t.is_deposit THEN COALESCE(t.txs_counted_as, 1)
+                  ELSE 0
+                END
+              WHEN c.destination_chain = ${chain} THEN
+                CASE
+                  WHEN NOT t.is_deposit THEN COALESCE(t.txs_counted_as, 1)
+                  ELSE 0
+                END
+              ELSE 0
+            END
+          ),
+          0
+        ) AS INTEGER
+      ) AS deposit_txs_24h,
+      CAST(
+        COALESCE(
+          SUM(
+            CASE
+              WHEN c.chain = ${chain} THEN
+                CASE
+                  WHEN NOT t.is_deposit THEN COALESCE(t.txs_counted_as, 1)
+                  ELSE 0
+                END
+              WHEN c.destination_chain = ${chain} THEN
+                CASE
+                  WHEN t.is_deposit THEN COALESCE(t.txs_counted_as, 1)
+                  ELSE 0
+                END
+              ELSE 0
+            END
+          ),
+          0
+        ) AS INTEGER
+      ) AS withdraw_txs_24h
+    FROM bridges.config c
+    LEFT JOIN bridges.transactions t
+      ON t.bridge_id = c.id
+     AND t.ts >= to_timestamp(${startTimestamp})
+    WHERE (c.chain = ${chain} OR c.destination_chain = ${chain})
+    GROUP BY c.bridge_name
+    ORDER BY c.bridge_name;
+  `;
+};
+
 const getNetflows = async (period: TimePeriod) => {
   let tableAndWhere = sql``;
   switch (period) {
@@ -484,6 +579,7 @@ export {
   queryAggregatedDailyTimestampRange,
   queryAggregatedHourlyTimestampRange,
   getLast24HVolume,
+  queryBridgeTxCounts24h,
   getNetflows,
   queryAggregatedTokensInRange,
 };