feat(gre): desambiguate chainIds using secondary network name

Signed-off-by: Tomás Migone <[email protected]>

Author: tmigone

gre/config.ts

@@ -7,7 +7,7 @@ import { HttpNetworkConfig } from 'hardhat/types/config'
 
 import { GraphRuntimeEnvironmentOptions } from './type-extensions'
 import { GREPluginError } from './helpers/error'
-import GraphNetwork from './helpers/network'
+import GraphNetwork, { counterpartName } from './helpers/network'
 
 import { createProvider } from 'hardhat/internal/core/providers/construction'
 import { EthersProviderWrapper } from '@nomiclabs/hardhat-ethers/internal/ethers-provider-wrapper'
@@ -217,7 +217,7 @@ function getNetworkConfig(
   chainId: number,
   mainNetworkName: string,
 ): (NetworkConfig & { name: string }) | undefined {
-  let candidateNetworks = Object.keys(networks)
+  const candidateNetworks = Object.keys(networks)
     .map((n) => ({ ...networks[n], name: n }))
     .filter((n) => n.chainId === chainId)
 
@@ -226,14 +226,26 @@ function getNetworkConfig(
       `Found multiple networks with chainId ${chainId}, trying to use main network name to desambiguate`,
     )
 
-    candidateNetworks = candidateNetworks.filter((n) => n.name === mainNetworkName)
+    const filteredByMainNetworkName = candidateNetworks.filter((n) => n.name === mainNetworkName)
 
-    if (candidateNetworks.length === 1) {
+    if (filteredByMainNetworkName.length === 1) {
+      logDebug(`Found network with chainId ${chainId} and name ${mainNetworkName}`)
       return candidateNetworks[0]
     } else {
-      throw new GREPluginError(
-        `Found multiple networks with chainID ${chainId}. This is not supported!`,
+      logWarn(`Could not desambiguate with main network name, trying secondary network name`)
+      const secondaryNetworkName = counterpartName(mainNetworkName)
+      const filteredBySecondaryNetworkName = candidateNetworks.filter(
+        (n) => n.name === secondaryNetworkName,
       )
+
+      if (filteredBySecondaryNetworkName.length === 1) {
+        logDebug(`Found network with chainId ${chainId} and name ${mainNetworkName}`)
+        return candidateNetworks[0]
+      } else {
+        throw new GREPluginError(
+          `Could not desambiguate network with chainID ${chainId}. Use case not supported!`,
+        )
+      }
     }
   } else if (candidateNetworks.length === 1) {
     return candidateNetworks[0]

gre/helpers/network.ts

@@ -16,22 +16,46 @@ const chainMap = new MapWithGetKey<number>([
   [1337, 412346], // Localhost - Arbitrum Localhost
 ])
 
+// Hardhat network names as per our convention
+const nameMap = new MapWithGetKey<string>([
+  ['mainnet', 'arbitrum-one'], // Ethereum Mainnet - Arbitrum One
+  ['rinkeby', 'arbitrum-rinkeby'], // Ethereum Rinkeby - Arbitrum Rinkeby
+  ['goerli', 'arbitrum-goerli'], // Ethereum Goerli - Arbitrum Goerli
+  ['localnitrol1', 'localnitrol2'], // Arbitrum testnode L1 - Arbitrum testnode L2
+])
+
 export const l1Chains = Array.from(chainMap.keys())
 export const l2Chains = Array.from(chainMap.values())
 export const chains = [...l1Chains, ...l2Chains]
 
+export const l1ChainNames = Array.from(nameMap.keys())
+export const l2ChainNames = Array.from(nameMap.values())
+export const chainNames = [...l1ChainNames, ...l2ChainNames]
+
 export const isL1 = (chainId: number): boolean => l1Chains.includes(chainId)
 export const isL2 = (chainId: number): boolean => l2Chains.includes(chainId)
 export const isSupported = (chainId: number | undefined): boolean =>
   chainId !== undefined && chains.includes(chainId)
 
+export const isL1Name = (name: string): boolean => l1ChainNames.includes(name)
+export const isL2Name = (name: string): boolean => l2ChainNames.includes(name)
+export const isSupportedName = (name: string | undefined): boolean =>
+  name !== undefined && chainNames.includes(name)
+
 export const l1ToL2 = (chainId: number): number | undefined => chainMap.get(chainId)
 export const l2ToL1 = (chainId: number): number | undefined => chainMap.getKey(chainId)
 export const counterpart = (chainId: number): number | undefined => {
   if (!isSupported(chainId)) return
   return isL1(chainId) ? l1ToL2(chainId) : l2ToL1(chainId)
 }
 
+export const l1ToL2Name = (name: string): string | undefined => nameMap.get(name)
+export const l2ToL1Name = (name: string): string | undefined => nameMap.getKey(name)
+export const counterpartName = (name: string): string | undefined => {
+  if (!isSupportedName(name)) return
+  return isL1Name(name) ? l1ToL2Name(name) : l2ToL1Name(name)
+}
+
 export default {
   l1Chains,
   l2Chains,

gre/test/config.test.ts

@@ -104,6 +104,22 @@ describe('GRE init functions', function () {
     })
   })
 
+  describe('getProviders with graph-config-desambiguate project', function () {
+    useEnvironment('graph-config-desambiguate')
+
+    it('should desambiguate chains correctly if multiple chains are defined with same chainId (HH L1)', function () {
+      const { l1Provider, l2Provider } = getProviders(this.hre, 1337, 412346, true)
+      expect(l1Provider).to.be.an('object')
+      expect(l2Provider).to.be.an('object')
+    })
+
+    it('should desambiguate chain correctly if multiple chains are defined with same chainId (HH L2)', function () {
+      const { l1Provider, l2Provider } = getProviders(this.hre, 1337, 412346, false)
+      expect(l1Provider).to.be.an('object')
+      expect(l2Provider).to.be.an('object')
+    })
+  })
+
   describe('getGraphConfigPaths with graph-config-full project', function () {
     useEnvironment('graph-config-full')
 

gre/test/fixture-projects/graph-config-desambiguate/hardhat.config.ts

@@ -0,0 +1,59 @@
+import '../../../gre'
+
+module.exports = {
+  paths: {
+    graph: '../../files',
+  },
+  solidity: '0.8.9',
+  defaultNetwork: 'hardhat',
+  networks: {
+    hardhat: {
+      chainId: 1337,
+    },
+    localhost: {
+      chainId: 1337,
+      url: `http://localhost:8545`,
+    },
+    localnitrol1: {
+      chainId: 1337,
+      url: `http://localhost:8545`,
+    },
+    localnitrol2: {
+      chainId: 412346,
+      url: `http://localhost:8547`,
+    },
+    mainnet: {
+      chainId: 1,
+      graphConfig: 'config/graph.mainnet.yml',
+      url: `https://mainnet.infura.io/v3/123456`,
+    },
+    'arbitrum-one': {
+      chainId: 42161,
+      url: 'https://arb1.arbitrum.io/rpc',
+      graphConfig: 'config/graph.arbitrum-goerli.yml',
+    },
+    goerli: {
+      chainId: 5,
+      url: `https://goerli.infura.io/v3/123456`,
+      graphConfig: 'config/graph.goerli.yml',
+    },
+    'arbitrum-goerli': {
+      chainId: 421613,
+      url: 'https://goerli-rollup.arbitrum.io/rpc',
+      graphConfig: 'config/graph.arbitrum-goerli.yml',
+    },
+    rinkeby: {
+      chainId: 4,
+      url: `https://goerli.infura.io/v3/123456`,
+    },
+    'arbitrum-rinkeby': {
+      chainId: 421611,
+      url: `https://goerli.infura.io/v3/123456`,
+    },
+  },
+  graph: {
+    addressBook: 'addresses-hre.json',
+    l1GraphConfig: 'config/graph.hre.yml',
+    l2GraphConfig: 'config/graph.arbitrum-hre.yml',
+  },
+}