feat: add e2e deployment tests for L2s

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

Author: tmigone

e2e/deployment/config/controller.test.ts

@@ -1,12 +1,13 @@
 import { expect } from 'chai'
 import hre, { ethers } from 'hardhat'
 import { NamedAccounts } from '../../../gre/type-extensions'
+import GraphChain from '../../../gre/helpers/network'
 
 describe('Controller configuration', () => {
-  const { contracts, getNamedAccounts } = hre.graph()
-  const { Controller } = contracts
+  const graph = hre.graph()
+  const { Controller } = graph.contracts
 
-  const proxyContracts = [
+  const l1ProxyContracts = [
     'Curation',
     'GNS',
     'DisputeManager',
@@ -17,10 +18,21 @@ describe('Controller configuration', () => {
     'L1GraphTokenGateway',
   ]
 
+  const l2ProxyContracts = [
+    'Curation',
+    'GNS',
+    'DisputeManager',
+    'EpochManager',
+    'RewardsManager',
+    'Staking',
+    'L2GraphToken',
+    'L2GraphTokenGateway',
+  ]
+
   let namedAccounts: NamedAccounts
 
   before(async () => {
-    namedAccounts = await getNamedAccounts()
+    namedAccounts = await graph.getNamedAccounts()
   })
 
   const proxyShouldMatchDeployed = async (contractName: string) => {
@@ -30,7 +42,7 @@ describe('Controller configuration', () => {
     const address = await Controller.getContractProxy(
       ethers.utils.solidityKeccak256(['string'], [name]),
     )
-    expect(address).eq(contracts[contractName].address)
+    expect(address).eq(graph.contracts[contractName].address)
   }
 
   it('should be owned by governor', async function () {
@@ -44,6 +56,7 @@ describe('Controller configuration', () => {
   })
 
   describe('proxy contract', async function () {
+    const proxyContracts = GraphChain.isL1(graph.chainId) ? l1ProxyContracts : l2ProxyContracts
     for (const contract of proxyContracts) {
       it(`${contract} should match deployed`, async function () {
         await proxyShouldMatchDeployed(contract)

e2e/deployment/config/graphToken.test.ts

@@ -23,7 +23,7 @@ describe('GraphToken configuration', () => {
   it('deployer should not be minter', async function () {
     const deployer = await getDeployer()
     const deployerIsMinter = await GraphToken.isMinter(deployer.address)
-    hre.network.config.chainId === 1337 ? this.skip() : expect(deployerIsMinter).eq(false)
+    expect(deployerIsMinter).eq(false)
   })
 
   it('RewardsManager should be minter', async function () {

e2e/deployment/config/l1/bridgeEscrow.test.ts

@@ -1,10 +1,14 @@
 import { expect } from 'chai'
 import hre from 'hardhat'
+import GraphChain from '../../../../gre/helpers/network'
 
-describe('BridgeEscrow configuration', () => {
-  const {
-    contracts: { Controller, BridgeEscrow },
-  } = hre.graph()
+describe('[L1] BridgeEscrow configuration', function () {
+  const graph = hre.graph()
+  const { Controller, BridgeEscrow } = graph.contracts
+
+  before(async function () {
+    if (GraphChain.isL2(graph.chainId)) this.skip()
+  })
 
   it('should be controlled by Controller', async function () {
     const controller = await BridgeEscrow.controller()

e2e/deployment/config/l1/l1GraphTokenGateway.test.ts

@@ -1,10 +1,14 @@
 import { expect } from 'chai'
 import hre from 'hardhat'
+import GraphChain from '../../../../gre/helpers/network'
 
-describe('L1GraphTokenGateway configuration', () => {
-  const {
-    contracts: { Controller, L1GraphTokenGateway },
-  } = hre.graph()
+describe('[L1] L1GraphTokenGateway configuration', function () {
+  const graph = hre.graph()
+  const { Controller, L1GraphTokenGateway } = graph.contracts
+
+  before(async function () {
+    if (GraphChain.isL2(graph.chainId)) this.skip()
+  })
 
   it('should be controlled by Controller', async function () {
     const controller = await L1GraphTokenGateway.controller()

e2e/deployment/config/l2/l2GraphTokenGateway.test.ts

@@ -0,0 +1,17 @@
+import { expect } from 'chai'
+import hre from 'hardhat'
+import GraphChain from '../../../../gre/helpers/network'
+
+describe('[L2] L2GraphTokenGateway configuration', function () {
+  const graph = hre.graph()
+  const { Controller, L2GraphTokenGateway } = graph.contracts
+
+  before(async function () {
+    if (GraphChain.isL1(graph.chainId)) this.skip()
+  })
+
+  it('should be controlled by Controller', async function () {
+    const controller = await L2GraphTokenGateway.controller()
+    expect(controller).eq(Controller.address)
+  })
+})

e2e/deployment/init/l1/graphToken.test.ts

@@ -1,16 +1,19 @@
 import { expect } from 'chai'
 import hre from 'hardhat'
 import { getItemValue } from '../../../../cli/config'
+import GraphChain from '../../../../gre/helpers/network'
 
-describe('GraphToken initialization', () => {
-  const {
-    graphConfig,
-    contracts: { GraphToken },
-  } = hre.graph()
+describe('[L1] GraphToken initialization', () => {
+  const graph = hre.graph()
+  const { GraphToken } = graph.contracts
+
+  before(async function () {
+    if (GraphChain.isL2(graph.chainId)) this.skip()
+  })
 
   it('total supply should match "initialSupply" on the config file', async function () {
     const value = await GraphToken.totalSupply()
-    const expected = getItemValue(graphConfig, 'contracts/GraphToken/init/initialSupply')
-    hre.network.config.chainId === 1337 ? expect(value).eq(expected) : expect(value).gte(expected)
+    const expected = getItemValue(graph.graphConfig, 'contracts/GraphToken/init/initialSupply')
+    expect(value).eq(expected)
   })
 })

e2e/deployment/init/l2/graphToken.test.ts

@@ -0,0 +1,17 @@
+import { expect } from 'chai'
+import hre from 'hardhat'
+import GraphChain from '../../../../gre/helpers/network'
+
+describe('[L2] GraphToken initialization', () => {
+  const graph = hre.graph()
+  const { GraphToken } = graph.contracts
+
+  before(async function () {
+    if (GraphChain.isL1(graph.chainId)) this.skip()
+  })
+
+  it('total supply should be zero', async function () {
+    const value = await GraphToken.totalSupply()
+    expect(value).eq(0)
+  })
+})

hardhat.config.ts

@@ -153,10 +153,12 @@ const config: HardhatUserConfig = {
         process.env.FORK === 'true' ? getAccountsKeys() : { mnemonic: DEFAULT_TEST_MNEMONIC },
     },
     localnitrol1: {
+      chainId: 1337,
       url: 'http://localhost:8545',
       accounts: { mnemonic: DEFAULT_TEST_MNEMONIC },
     },
     localnitrol2: {
+      chainId: 412346,
       url: 'http://localhost:8547',
       accounts: { mnemonic: DEFAULT_TEST_MNEMONIC },
     },

tasks/deployment/ownership.ts

@@ -1,22 +1,28 @@
 import { ContractTransaction } from 'ethers'
 import { task } from 'hardhat/config'
 import { cliOpts } from '../../cli/defaults'
+import GraphChain from '../../gre/helpers/network'
 
 task('migrate:ownership', 'Accepts ownership of protocol contracts on behalf of governor')
   .addOptionalParam('addressBook', cliOpts.addressBook.description)
   .addOptionalParam('graphConfig', cliOpts.graphConfig.description)
   .setAction(async (taskArgs, hre) => {
-    const { contracts, getNamedAccounts } = hre.graph(taskArgs)
-    const { governor } = await getNamedAccounts()
+    const graph = hre.graph(taskArgs)
+    const { GraphToken, Controller, GraphProxyAdmin, SubgraphNFT } = graph.contracts
+    const { governor } = await graph.getNamedAccounts()
 
     console.log('> Accepting ownership of contracts')
     console.log(`- Governor: ${governor.address}`)
 
     const txs: ContractTransaction[] = []
-    txs.push(await contracts.GraphToken.connect(governor).acceptOwnership())
-    txs.push(await contracts.Controller.connect(governor).acceptOwnership())
-    txs.push(await contracts.GraphProxyAdmin.connect(governor).acceptOwnership())
-    txs.push(await contracts.SubgraphNFT.connect(governor).acceptOwnership())
+    txs.push(await GraphToken.connect(governor).acceptOwnership())
+    txs.push(await Controller.connect(governor).acceptOwnership())
+    txs.push(await GraphProxyAdmin.connect(governor).acceptOwnership())
+    txs.push(await SubgraphNFT.connect(governor).acceptOwnership())
+
+    if (GraphChain.isL1(graph.chainId)) {
+      txs.push(await GraphToken.connect(governor).acceptOwnership())
+    }
 
     await Promise.all(txs.map((tx) => tx.wait()))
     console.log('Done!')