feat: reduce number of order database upserts in order validation cronjob, reduce rpc calls

- lowers the amount of upserts done, by only updating orders that have
their validity or error codes changed. Previously, it was updating all
orders that we're checked, resulting in unnecessary cache invalidations
- properly utilizes the checkMakerOrders method to prevent unnecessary
calls to the RPC endpoint, which might have been related with our infura
issues.

Author: Jipperism

src/services/SupabaseDataService.ts

@@ -22,6 +22,7 @@ import type { DataDatabase as KyselyDataDatabase } from "../types/kyselySupabase
 import type { Database as DataDatabase } from "../types/supabaseData.js";
 import { BaseSupabaseService } from "./BaseSupabaseService.js";
 import { EvmClientFactory } from "../client/evmClient.js";
+import _ from "lodash";
 
 @singleton()
 export class SupabaseDataService extends BaseSupabaseService<KyselyDataDatabase> {
@@ -247,50 +248,89 @@ export class SupabaseDataService extends BaseSupabaseService<KyselyDataDatabase>
     tokenIds: string[];
     chainId: number;
   }) {
-    console.log("[marketplace-api] Validating orders by token IDs", tokenIds);
+    console.log(
+      "[marketplace-api] Validating orders by token IDs",
+      tokenIds,
+      "on chain",
+      chainId,
+    );
     const ordersToUpdate: {
       id: string;
       invalidated: boolean;
       validator_codes: OrderValidatorCode[];
     }[] = [];
-    for (const tokenId of tokenIds) {
-      // Fetch all orders for token ID from database
-      const { data: matchingOrders, error } = await this.getOrdersByTokenId({
-        tokenId,
-        chainId,
-      });
-
-      if (error) {
+    const getOrdersResults = await Promise.all(
+      tokenIds.map(async (tokenId) =>
+        this.getOrdersByTokenId({
+          tokenId,
+          chainId,
+        }),
+      ),
+    );
+
+    if (getOrdersResults.some((res) => res.error)) {
+      throw new Error(
+        `[SupabaseDataService::validateOrderByTokenId] Error fetching orders: ${getOrdersResults.find((res) => res.error)?.error?.message}`,
+      );
+    }
+
+    const matchingOrders = getOrdersResults
+      .flatMap((res) => res.data)
+      .filter((x) => x !== null);
+
+    // Validate orders using logic in the SDK
+    const hec = new HypercertExchangeClient(
+      chainId,
+      // @ts-expect-error Typing issue with provider
+      EvmClientFactory.createEthersClient(chainId),
+    );
+    const validationResults = await hec.checkOrdersValidity(matchingOrders);
+
+    // Determine all orders that have changed validity or validator codes
+    for (const order of matchingOrders) {
+      const validationResult = validationResults.find(
+        (result) => result.id === order.id,
+      );
+
+      if (!validationResult) {
         throw new Error(
-          `[SupabaseDataService::validateOrderByTokenId] Error fetching orders: ${error.message}`,
+          `[SupabaseDataService::validateOrderByTokenId] No validation result found for order ${order.id}`,
         );
       }
 
-      if (!matchingOrders) {
-        console.warn(
-          `[SupabaseDataService::validateOrderByTokenId] No orders found for tokenId: ${tokenId}`,
-        );
+      const orderValidity = !order.invalidated;
+
+      if (validationResult.valid !== orderValidity) {
+        ordersToUpdate.push({
+          id: order.id,
+          invalidated: !validationResult.valid,
+          validator_codes: validationResult.validatorCodes,
+        });
         continue;
       }
 
-      // Validate orders using logic in the SDK
-      const hec = new HypercertExchangeClient(
-        chainId,
-        // @ts-expect-error Typing issue with provider
-        EvmClientFactory.createEthersClient(chainId),
-      );
-      const validationResults = await hec.checkOrdersValidity(matchingOrders);
-
-      // Determine which orders to update in DB, and update them
-      ordersToUpdate.push(
-        ...validationResults.map(({ validatorCodes, id, valid }) => ({
-          id,
-          invalidated: !valid,
-          validator_codes: validatorCodes,
-        })),
-      );
+      if (
+        order.validator_codes === null &&
+        validationResult.validatorCodes.every(
+          (code) => code === OrderValidatorCode.ORDER_EXPECTED_TO_BE_VALID,
+        )
+      ) {
+        continue;
+      }
+
+      if (!_.isEqual(validationResult.validatorCodes, order.validator_codes)) {
+        ordersToUpdate.push({
+          id: order.id,
+          invalidated: !validationResult.valid,
+          validator_codes: validationResult.validatorCodes,
+        });
+      }
     }
-    console.log("[marketplace-api] Invalidating orders", ordersToUpdate);
+
+    console.log(
+      "[marketplace-api] Updating orders from validation results",
+      ordersToUpdate,
+    );
     await this.updateOrders(ordersToUpdate);
     return ordersToUpdate;
   }