feat: auto fund test accounts on local networks

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

Author: tmigone

.gitignore

@@ -48,7 +48,7 @@ tx-*.log
 addresses-fork.json
 addresses-hardhat.json
 addresses-localhost.json
-
+addresses-local-network.json
 # Keys
 .keystore
 

packages/hardhat-graph-protocol/src/gre.ts

@@ -76,21 +76,25 @@ export const greExtendEnvironment = (hre: HardhatRuntimeEnvironment) => {
       }
     }
 
+    // Accounts
+    const grtTokenAddress = greDeployments?.horizon?.contracts?.GraphToken?.target
+    const accounts = {
+      getAccounts: async () => getAccounts(provider, grtTokenAddress),
+      getDeployer: async (accountIndex?: number) => getDeployer(provider, accountIndex, grtTokenAddress),
+      getGovernor: async (accountIndex?: number) => getGovernor(provider, accountIndex, grtTokenAddress),
+      getArbitrator: async (accountIndex?: number) => getArbitrator(provider, accountIndex, grtTokenAddress),
+      getPauseGuardian: async (accountIndex?: number) => getPauseGuardian(provider, accountIndex, grtTokenAddress),
+      getSubgraphAvailabilityOracle: async (accountIndex?: number) => getSubgraphAvailabilityOracle(provider, accountIndex, grtTokenAddress),
+      getGateway: async (accountIndex?: number) => getGateway(provider, accountIndex, grtTokenAddress),
+      getTestAccounts: async () => getTestAccounts(provider, grtTokenAddress),
+    }
+
     logDebug('GRE initialized successfully!')
     return {
       ...greDeployments,
       provider,
       chainId,
-      accounts: {
-        getAccounts: async () => getAccounts(provider),
-        getDeployer: async (accountIndex?: number) => getDeployer(provider, accountIndex),
-        getGovernor: async (accountIndex?: number) => getGovernor(provider, accountIndex),
-        getArbitrator: async (accountIndex?: number) => getArbitrator(provider, accountIndex),
-        getPauseGuardian: async (accountIndex?: number) => getPauseGuardian(provider, accountIndex),
-        getSubgraphAvailabilityOracle: async (accountIndex?: number) => getSubgraphAvailabilityOracle(provider, accountIndex),
-        getGateway: async (accountIndex?: number) => getGateway(provider, accountIndex),
-        getTestAccounts: async () => getTestAccounts(provider),
-      },
+      accounts: accounts,
     }
   })
 }

packages/toolshed/src/core/accounts.ts

@@ -1,5 +1,9 @@
+import { setGRTBalance } from '../hardhat'
+import { toBeHex } from 'ethers'
+
+import type { Addressable } from 'ethers'
 import type { HardhatEthersProvider } from '@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider'
-import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
+import type { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
 
 // The Graph convention for account derivation is:
 // 0: Deployer
@@ -10,6 +14,15 @@ import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
 // 5: Gateway/payer
 // 6+: Test accounts
 
+enum GraphAccountIndex {
+  Deployer = 0,
+  Governor = 1,
+  Arbitrator = 2,
+  PauseGuardian = 3,
+  SubgraphAvailabilityOracle = 4,
+  Gateway = 5,
+}
+
 export type GraphAccounts = {
   deployer: HardhatEthersSigner
   governor: HardhatEthersSigner
@@ -20,46 +33,64 @@ export type GraphAccounts = {
   test: HardhatEthersSigner[]
 }
 
-export async function getAccounts(provider: HardhatEthersProvider): Promise<GraphAccounts> {
+export async function getAccounts(provider: HardhatEthersProvider, grtTokenAddress?: string | Addressable): Promise<GraphAccounts> {
   return {
-    deployer: await getDeployer(provider),
-    governor: await getGovernor(provider),
-    arbitrator: await getArbitrator(provider),
-    pauseGuardian: await getPauseGuardian(provider),
-    subgraphAvailabilityOracle: await getSubgraphAvailabilityOracle(provider),
-    gateway: await getGateway(provider),
-    test: await getTestAccounts(provider),
+    deployer: await getDeployer(provider, GraphAccountIndex.Deployer, grtTokenAddress),
+    governor: await getGovernor(provider, GraphAccountIndex.Governor, grtTokenAddress),
+    arbitrator: await getArbitrator(provider, GraphAccountIndex.Arbitrator, grtTokenAddress),
+    pauseGuardian: await getPauseGuardian(provider, GraphAccountIndex.PauseGuardian, grtTokenAddress),
+    subgraphAvailabilityOracle: await getSubgraphAvailabilityOracle(provider, GraphAccountIndex.SubgraphAvailabilityOracle, grtTokenAddress),
+    gateway: await getGateway(provider, GraphAccountIndex.Gateway, grtTokenAddress),
+    test: await getTestAccounts(provider, grtTokenAddress),
   }
 }
 
-export async function getDeployer(provider: HardhatEthersProvider, accountIndex = 0) {
-  return provider.getSigner(accountIndex)
+export async function getDeployer(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.Deployer, grtTokenAddress?: string | Addressable) {
+  return _getAccount(provider, accountIndex, grtTokenAddress)
 }
 
-export async function getGovernor(provider: HardhatEthersProvider, accountIndex = 1) {
-  return provider.getSigner(accountIndex)
+export async function getGovernor(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.Governor, grtTokenAddress?: string | Addressable) {
+  return _getAccount(provider, accountIndex, grtTokenAddress)
 }
 
-export async function getArbitrator(provider: HardhatEthersProvider, accountIndex = 2) {
-  return provider.getSigner(accountIndex)
+export async function getArbitrator(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.Arbitrator, grtTokenAddress?: string | Addressable) {
+  return _getAccount(provider, accountIndex, grtTokenAddress)
 }
 
-export async function getPauseGuardian(provider: HardhatEthersProvider, accountIndex = 3) {
-  return provider.getSigner(accountIndex)
+export async function getPauseGuardian(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.PauseGuardian, grtTokenAddress?: string | Addressable) {
+  return _getAccount(provider, accountIndex, grtTokenAddress)
 }
 
-export async function getSubgraphAvailabilityOracle(provider: HardhatEthersProvider, accountIndex = 4) {
-  return provider.getSigner(accountIndex)
+export async function getSubgraphAvailabilityOracle(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.SubgraphAvailabilityOracle, grtTokenAddress?: string | Addressable) {
+  return _getAccount(provider, accountIndex, grtTokenAddress)
 }
 
-export async function getGateway(provider: HardhatEthersProvider, accountIndex = 5) {
-  return provider.getSigner(accountIndex)
+export async function getGateway(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.Gateway, grtTokenAddress?: string | Addressable) {
+  return _getAccount(provider, accountIndex, grtTokenAddress)
 }
 
-export async function getTestAccounts(provider: HardhatEthersProvider) {
+export async function getTestAccounts(provider: HardhatEthersProvider, grtTokenAddress?: string | Addressable) {
   const accounts = await provider.send('eth_accounts', []) as string[]
-  if (accounts.length < 6) {
+  const numReservedAccounts = Object.values(GraphAccountIndex).filter(v => typeof v === 'number').length
+  if (accounts.length < numReservedAccounts) {
     return []
   }
-  return await Promise.all(accounts.slice(6).map(async account => await provider.getSigner(account)))
+  return await Promise.all(
+    accounts
+      .slice(numReservedAccounts)
+      .map(async account => await _getAccount(provider, account, grtTokenAddress)),
+  )
+}
+
+async function _getAccount(provider: HardhatEthersProvider, accountIndex: number | string, grtTokenAddress?: string | Addressable) {
+  const account = await provider.getSigner(accountIndex)
+
+  // If the chain is local, send 10M GRT to the account
+  const chainId = await provider.send('eth_chainId', []) as string
+  const isLocal = [toBeHex(1337), toBeHex(31337)].includes(toBeHex(BigInt(chainId)))
+  if (grtTokenAddress && isLocal) {
+    await setGRTBalance(provider, grtTokenAddress, account.address, 10_000_000n)
+  }
+
+  return account
 }

packages/toolshed/src/hardhat/hardhat.base.config.ts

@@ -91,8 +91,8 @@ export const networksUserConfig: BaseNetworksUserConfig = {
   localNetwork: {
     chainId: 1337,
     url: LOCAL_NETWORK_RPC,
-    secureAccounts: {
-      enabled: false,
+    accounts: {
+      mnemonic: 'myth like bonus scare over problem client lizard pioneer submit female collect',
     },
     deployments: {
       horizon: resolveNodeModulesPath('@graphprotocol/horizon/addresses-local-network.json'),