perf: optimize allocation rules evaluation from O(n²) to O(n)

Replace repeated Array.filter() and Array.find() operations with a
Map-based lookup system for deployment rules.

Changes:
- Add preprocessRules() function to create a Map for O(1) rule lookups
- Update isDeploymentWorthAllocatingTowards() to use preprocessed rules
- Update evaluateDeployments() to preprocess rules once before iteration
- Update matchingRuleExists() in AllocationManager to use optimized lookup

This eliminates quadratic complexity when evaluating thousands of
deployments against hundreds of rules.

Based on: #1147
Original author: madumas
Original commit: 2618f23

Author: dwerner

packages/indexer-common/src/indexer-management/allocations.ts

@@ -26,6 +26,7 @@ import {
   IndexingStatus,
   isActionFailure,
   isDeploymentWorthAllocatingTowards,
+  preprocessRules,
   Network,
   ReallocateAllocationResult,
   SubgraphIdentifierType,
@@ -1791,8 +1792,14 @@ export class AllocationManager {
         `SHOULD BE UNREACHABLE: No matching subgraphDeployment (${subgraphDeploymentID.ipfsHash}) found on the network`,
       )
     }
-    return isDeploymentWorthAllocatingTowards(logger, subgraphDeployment, indexingRules)
-      .toAllocate
+    // Use preprocessed rules for O(1) lookup
+    const { deploymentRulesMap, globalRule } = preprocessRules(indexingRules)
+    return isDeploymentWorthAllocatingTowards(
+      logger,
+      subgraphDeployment,
+      deploymentRulesMap,
+      globalRule,
+    ).toAllocate
   }
 
   // Calculates the balance (GRT delta) of a single Action.

packages/indexer-common/src/subgraphs.ts

@@ -159,6 +159,30 @@ interface RuleMatch {
   activationCriteria: ActivationCriteria
 }
 
+export interface PreprocessedRules {
+  deploymentRulesMap: { [key: string]: IndexingRuleAttributes }
+  globalRule: IndexingRuleAttributes | undefined
+}
+
+// Preprocess rules into a Map for O(1) lookups instead of O(n) Array.filter().find()
+// This optimizes performance from O(n²) to O(n) when evaluating many deployments
+export function preprocessRules(rules: IndexingRuleAttributes[]): PreprocessedRules {
+  const deploymentRulesMap: { [key: string]: IndexingRuleAttributes } = {}
+  let globalRule: IndexingRuleAttributes | undefined = undefined
+
+  for (let i = 0; i < rules.length; i++) {
+    const rule = rules[i]
+    if (rule.identifier === INDEXING_RULE_GLOBAL) {
+      globalRule = rule
+    } else if (rule.identifierType === SubgraphIdentifierType.DEPLOYMENT) {
+      const key = new SubgraphDeploymentID(rule.identifier).bytes32
+      deploymentRulesMap[key] = rule
+    }
+  }
+
+  return { deploymentRulesMap, globalRule }
+}
+
 export class AllocationDecision {
   declare deployment: SubgraphDeploymentID
   declare toAllocate: boolean
@@ -192,24 +216,26 @@ export function evaluateDeployments(
   networkDeployments: SubgraphDeployment[],
   rules: IndexingRuleAttributes[],
 ): AllocationDecision[] {
+  // Preprocess rules once for O(1) lookups instead of O(n) per deployment
+  const { deploymentRulesMap, globalRule } = preprocessRules(rules)
   return networkDeployments.map((deployment) =>
-    isDeploymentWorthAllocatingTowards(logger, deployment, rules),
+    isDeploymentWorthAllocatingTowards(
+      logger,
+      deployment,
+      deploymentRulesMap,
+      globalRule,
+    ),
   )
 }
 
 export function isDeploymentWorthAllocatingTowards(
   logger: Logger,
   deployment: SubgraphDeployment,
-  rules: IndexingRuleAttributes[],
+  deploymentRulesMap: { [key: string]: IndexingRuleAttributes },
+  globalRule: IndexingRuleAttributes | undefined,
 ): AllocationDecision {
-  const globalRule = rules.find((rule) => rule.identifier === INDEXING_RULE_GLOBAL)
-  const deploymentRule =
-    rules
-      .filter((rule) => rule.identifierType == SubgraphIdentifierType.DEPLOYMENT)
-      .find(
-        (rule) =>
-          new SubgraphDeploymentID(rule.identifier).bytes32 === deployment.id.bytes32,
-      ) || globalRule
+  // O(1) lookup using preprocessed rules map
+  const deploymentRule = deploymentRulesMap[deployment.id.bytes32] || globalRule
 
   logger.trace('Evaluating whether subgraphDeployment is worth allocating towards', {
     deployment,