chore: ensure DIPs indexing rules in the reconciliation loop

Author: pcarranzav

packages/indexer-agent/src/agent.ts

@@ -223,6 +223,16 @@ export class Agent {
         { logger, milliseconds: requestIntervalSmall },
         async () => {
           const { network, operator } = this.networkAndOperator
+          if (network.specification.indexerOptions.enableDips) {
+            // There should be a DipsManager in the operator
+            if (!operator.dipsManager) {
+              throw new Error('DipsManager is not available')
+            }
+            logger.trace('Ensuring indexing rules for DIPS', {
+              protocolNetwork: network.specification.networkIdentifier,
+            })
+            await operator.dipsManager.ensureAgreementRules()
+          }
           logger.trace('Fetching indexing rules', {
             protocolNetwork: network.specification.networkIdentifier,
           })

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

@@ -454,9 +454,11 @@ export interface IndexerManagementClientOptions {
   graphNode: GraphNode
   network: Network
   defaults: IndexerManagementDefaults
+  actionManager?: ActionManager | undefined
 }
 
 export class IndexerManagementClient extends Client {
+  declare actionManager: ActionManager | undefined
   private logger?: Logger
   private models: IndexerManagementModels
 
@@ -465,6 +467,7 @@ export class IndexerManagementClient extends Client {
 
     this.logger = options.logger
     this.models = options.models
+    this.actionManager = options.actionManager
   }
 }
 
@@ -501,5 +504,8 @@ export const createIndexerManagementClient = async (
     context,
   })
 
-  return new IndexerManagementClient({ url: 'no-op', exchanges: [exchange] }, options)
+  return new IndexerManagementClient(
+    { url: 'no-op', exchanges: [exchange] },
+    { ...options, actionManager },
+  )
 }

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

@@ -374,7 +374,13 @@ export default {
       amount: string
       protocolNetwork: string
     },
-    { network, graphNode, logger, models, actionManager }: IndexerManagementResolverContext,
+    {
+      network,
+      graphNode,
+      logger,
+      models,
+      actionManager,
+    }: IndexerManagementResolverContext,
   ): Promise<CreateAllocationResult> => {
     logger.debug('Execute createAllocation() mutation', {
       deployment,
@@ -735,9 +741,7 @@ export default {
       await models.IndexingRule.upsert(offchainIndexingRule)
 
       if (actionManager?.allocationManager?.dipsManager) {
-        await actionManager.allocationManager.dipsManager.tryCancelAgreement(
-          allocation,
-        )
+        await actionManager.allocationManager.dipsManager.tryCancelAgreement(allocation)
         await actionManager.allocationManager.dipsManager.tryUpdateAgreementAllocation(
           allocationData.subgraphDeployment.id.toString(),
           allocation,

packages/indexer-common/src/operator.ts

@@ -16,6 +16,7 @@ import {
   specification as spec,
   Action,
   POIDisputeAttributes,
+  DipsManager,
 } from '@graphprotocol/indexer-common'
 import { Logger, formatGRT } from '@graphprotocol/common-ts'
 import { BigNumber, utils } from 'ethers'
@@ -82,6 +83,10 @@ export class Operator {
     this.specification = specification
   }
 
+  get dipsManager(): DipsManager | null {
+    return this.indexerManagement.actionManager?.allocationManager?.dipsManager ?? null
+  }
+
   // --------------------------------------------------------------------------------
   // * Indexing Rules
   // --------------------------------------------------------------------------------