refactor indexer management API layer

packages/indexer-agent/src/__tests__/agent.ts

@@ -3,10 +3,8 @@ import {
   consolidateAllocationDecisions,
 } from '../agent'
 import {
+  GeneratedGraphQLTypes,
   INDEXING_RULE_GLOBAL,
-  IndexingDecisionBasis,
-  IndexingRuleAttributes,
-  SubgraphIdentifierType,
   SubgraphVersion,
 } from '@graphprotocol/indexer-common'
 import { SubgraphDeploymentID } from '@graphprotocol/common-ts'
@@ -16,44 +14,56 @@ describe('Agent convenience function tests', () => {
     const inputRules = [
       {
         identifier: INDEXING_RULE_GLOBAL,
-        identifierType: SubgraphIdentifierType.GROUP,
-        allocationAmount: '2300',
+        identifierType: 'group',
+        allocationAmount: BigInt(2300),
         parallelAllocations: null,
         maxAllocationPercentage: null,
         minSignal: null,
         maxSignal: null,
         minStake: null,
         minAverageQueryFees: null,
         custom: null,
-        decisionBasis: IndexingDecisionBasis.RULES,
+        decisionBasis: 'rules',
+        autoRenewal: false,
+        requireSupported: false,
+        safety: false,
+        protocolNetwork: 'sepolia',
       },
       {
         identifier: '0x0000000000000000000000000000000000000000-0',
-        identifierType: SubgraphIdentifierType.SUBGRAPH,
-        allocationAmount: '3000',
+        identifierType: 'subgraph',
+        allocationAmount: BigInt(3000),
         parallelAllocations: null,
         maxAllocationPercentage: null,
         minSignal: null,
         maxSignal: null,
         minStake: null,
         minAverageQueryFees: null,
         custom: null,
-        decisionBasis: IndexingDecisionBasis.RULES,
+        decisionBasis: 'rules',
+        autoRenewal: false,
+        requireSupported: false,
+        safety: false,
+        protocolNetwork: 'sepolia',
       },
       {
         identifier: 'QmZZtzZkfzCWMNrajxBf22q7BC9HzoT5iJUK3S8qA6zNZr',
-        identifierType: SubgraphIdentifierType.DEPLOYMENT,
-        allocationAmount: '12000',
+        identifierType: 'deployment',
+        allocationAmount: BigInt(12000),
         parallelAllocations: null,
         maxAllocationPercentage: null,
         minSignal: null,
         maxSignal: null,
         minStake: null,
         minAverageQueryFees: null,
         custom: null,
-        decisionBasis: IndexingDecisionBasis.RULES,
+        decisionBasis: 'rules',
+        protocolNetwork: 'sepolia',
+        autoRenewal: false,
+        requireSupported: false,
+        safety: false,
       },
-    ] as IndexingRuleAttributes[]
+    ] satisfies GeneratedGraphQLTypes.IndexingRule[]
 
     const subgraphs = [
       {
@@ -73,45 +83,57 @@ describe('Agent convenience function tests', () => {
     const expectedRules = [
       {
         identifier: INDEXING_RULE_GLOBAL,
-        identifierType: SubgraphIdentifierType.GROUP,
-        allocationAmount: '2300',
+        identifierType: 'group',
+        allocationAmount: BigInt(2300),
         parallelAllocations: null,
         maxAllocationPercentage: null,
         minSignal: null,
         maxSignal: null,
         minStake: null,
         minAverageQueryFees: null,
         custom: null,
-        decisionBasis: IndexingDecisionBasis.RULES,
+        decisionBasis: 'rules',
+        protocolNetwork: 'sepolia',
+        autoRenewal: false,
+        requireSupported: false,
+        safety: false,
       },
       {
         identifier:
           '0xc9d18c59e4aaf2c1f86dfef16fbdc0f81eae8ada58d87a23d2666c45704b8823',
-        identifierType: SubgraphIdentifierType.DEPLOYMENT,
-        allocationAmount: '3000',
+        identifierType: 'deployment',
+        allocationAmount: BigInt(3000),
         parallelAllocations: null,
         maxAllocationPercentage: null,
         minSignal: null,
         maxSignal: null,
         minStake: null,
         minAverageQueryFees: null,
         custom: null,
-        decisionBasis: IndexingDecisionBasis.RULES,
+        decisionBasis: 'rules',
+        protocolNetwork: 'sepolia',
+        autoRenewal: false,
+        requireSupported: false,
+        safety: false,
       },
       {
         identifier: 'QmZZtzZkfzCWMNrajxBf22q7BC9HzoT5iJUK3S8qA6zNZr',
-        identifierType: SubgraphIdentifierType.DEPLOYMENT,
-        allocationAmount: '12000',
+        identifierType: 'deployment',
+        allocationAmount: BigInt(12000),
         parallelAllocations: null,
         maxAllocationPercentage: null,
         minSignal: null,
         maxSignal: null,
         minStake: null,
         minAverageQueryFees: null,
         custom: null,
-        decisionBasis: IndexingDecisionBasis.RULES,
+        decisionBasis: 'rules',
+        protocolNetwork: 'sepolia',
+        autoRenewal: false,
+        requireSupported: false,
+        safety: false,
       },
-    ] as IndexingRuleAttributes[]
+    ] satisfies GeneratedGraphQLTypes.IndexingRule[]
 
     expect(
       convertSubgraphBasedRulesToDeploymentBased(inputRules, subgraphs, 1000),
@@ -122,31 +144,39 @@ describe('Agent convenience function tests', () => {
     const inputRules = [
       {
         identifier: INDEXING_RULE_GLOBAL,
-        identifierType: SubgraphIdentifierType.GROUP,
-        allocationAmount: '2300',
+        identifierType: 'group',
+        allocationAmount: BigInt(2300),
         parallelAllocations: null,
         maxAllocationPercentage: null,
         minSignal: null,
         maxSignal: null,
         minStake: null,
         minAverageQueryFees: null,
         custom: null,
-        decisionBasis: IndexingDecisionBasis.RULES,
+        decisionBasis: 'rules',
+        protocolNetwork: 'sepolia',
+        autoRenewal: false,
+        requireSupported: false,
+        safety: false,
       },
       {
         identifier: 'QmZZtzZkfzCWMNrajxBf22q7BC9HzoT5iJUK3S8qA6zNZr',
-        identifierType: SubgraphIdentifierType.DEPLOYMENT,
-        allocationAmount: '12000',
+        identifierType: 'deployment',
+        allocationAmount: BigInt(12000),
         parallelAllocations: null,
         maxAllocationPercentage: null,
         minSignal: null,
         maxSignal: null,
         minStake: null,
         minAverageQueryFees: null,
         custom: null,
-        decisionBasis: IndexingDecisionBasis.RULES,
+        decisionBasis: 'rules',
+        protocolNetwork: 'sepolia',
+        autoRenewal: false,
+        requireSupported: false,
+        safety: false,
       },
-    ] as IndexingRuleAttributes[]
+    ] satisfies GeneratedGraphQLTypes.IndexingRule[]
 
     const subgraphs = [
       {

packages/indexer-agent/src/__tests__/indexer.ts

@@ -7,9 +7,7 @@ import {
   parseGRT,
 } from '@graphprotocol/common-ts'
 import {
-  createIndexerManagementClient,
   defineIndexerManagementModels,
-  IndexerManagementClient,
   IndexerManagementModels,
   GraphNode,
   Operator,
@@ -19,8 +17,8 @@ import {
   QueryFeeModels,
   defineQueryFeeModels,
   MultiNetworks,
+  createIndexerManagementYogaClient,
 } from '@graphprotocol/indexer-common'
-import { BigNumber } from 'ethers'
 import { Sequelize } from 'sequelize'
 
 const TEST_DISPUTE_1: POIDisputeAttributes = {
@@ -66,52 +64,15 @@ const TEST_DISPUTE_2: POIDisputeAttributes = {
   protocolNetwork: 'eip155:11155111',
 }
 
-const POI_DISPUTES_CONVERTERS_FROM_GRAPHQL: Record<
-  keyof POIDisputeAttributes,
-  (x: never) => string | BigNumber | number | undefined
-> = {
-  allocationID: x => x,
-  subgraphDeploymentID: x => x,
-  allocationIndexer: x => x,
-  allocationAmount: x => x,
-  allocationProof: x => x,
-  closedEpoch: x => +x,
-  closedEpochStartBlockHash: x => x,
-  closedEpochStartBlockNumber: x => +x,
-  closedEpochReferenceProof: x => x,
-  previousEpochStartBlockHash: x => x,
-  previousEpochStartBlockNumber: x => +x,
-  previousEpochReferenceProof: x => x,
-  status: x => x,
-  protocolNetwork: x => x,
-}
-
-/**
- * Parses a POI dispute returned from the indexer management GraphQL
- * API into normalized form.
- */
-const disputeFromGraphQL = (
-  dispute: Partial<POIDisputeAttributes>,
-): POIDisputeAttributes => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const obj = {} as any
-  for (const [key, value] of Object.entries(dispute)) {
-    if (key === '__typename') {
-      continue
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    obj[key] = (POI_DISPUTES_CONVERTERS_FROM_GRAPHQL as any)[key](value)
-  }
-  return obj as POIDisputeAttributes
-}
-
 declare const __DATABASE__: never
 
 let sequelize: Sequelize
 let models: IndexerManagementModels
 let queryFeeModels: QueryFeeModels
 let logger: Logger
-let indexerManagementClient: IndexerManagementClient
+let indexerManagementClient: Awaited<
+  ReturnType<typeof createIndexerManagementYogaClient>
+>
 let graphNode: GraphNode
 let operator: Operator
 let metrics: Metrics
@@ -196,7 +157,7 @@ const setup = async () => {
     (n: Network) => n.specification.networkIdentifier,
   )
 
-  indexerManagementClient = await createIndexerManagementClient({
+  indexerManagementClient = await createIndexerManagementYogaClient({
     models,
     graphNode,
     indexNodeIDs,
@@ -257,34 +218,34 @@ describe('Indexer tests', () => {
   test('Store POI Disputes is idempotent', async () => {
     const disputes: POIDisputeAttributes[] = [TEST_DISPUTE_1, TEST_DISPUTE_2]
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const expectedResult = disputes.map((dispute: Record<string, any>) => {
-      return disputeFromGraphQL(dispute)
-    })
-    await expect(operator.storePoiDisputes(disputes)).resolves.toEqual(
-      expectedResult,
-    )
-    await expect(operator.storePoiDisputes(disputes)).resolves.toEqual(
-      expectedResult,
-    )
-    await expect(operator.storePoiDisputes(disputes)).resolves.toEqual(
-      expectedResult,
-    )
+    const result1 = (await operator.storePoiDisputes(disputes)).map(a => ({
+      ...a,
+      allocationAmount: a.allocationAmount.toString(),
+    }))
+    expect(result1).toEqual(disputes)
+    const result2 = (await operator.storePoiDisputes(disputes)).map(a => ({
+      ...a,
+      allocationAmount: a.allocationAmount.toString(),
+    }))
+    expect(result2).toEqual(disputes)
+    const result3 = (await operator.storePoiDisputes(disputes)).map(a => ({
+      ...a,
+      allocationAmount: a.allocationAmount.toString(),
+    }))
+    expect(result3).toEqual(disputes)
   })
 
   test('Fetch POIDisputes', async () => {
     const disputes: POIDisputeAttributes[] = [TEST_DISPUTE_1, TEST_DISPUTE_2]
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const expectedResult = disputes.map((dispute: Record<string, any>) => {
-      return disputeFromGraphQL(dispute)
-    })
-    const expectedFilteredResult = [disputeFromGraphQL(TEST_DISPUTE_2)]
-    await expect(operator.storePoiDisputes(disputes)).resolves.toEqual(
-      expectedResult,
-    )
-    await expect(
-      operator.fetchPOIDisputes('potential', 205, 'eip155:11155111'),
-    ).resolves.toEqual(expectedFilteredResult)
+    const result1 = (await operator.storePoiDisputes(disputes)).map(a => ({
+      ...a,
+      allocationAmount: a.allocationAmount.toString(),
+    }))
+    expect(result1).toEqual(disputes)
+    const result2 = (
+      await operator.fetchPOIDisputes('potential', 205, 'eip155:11155111')
+    ).map(a => ({ ...a, allocationAmount: a.allocationAmount.toString() }))
+    expect(result2).toEqual([TEST_DISPUTE_2])
   })
 })