fix: ensure toolshed core components dont import hardhat runtime

tmigone · tmigone · commit d52644a52849 · 2025-05-22T12:57:42.000-03:00
Signed-off-by: Tomás Migone &lt;tomas@edgeandnode.com&gt;
diff --git a/packages/hardhat-graph-protocol/CHANGELOG.md b/packages/hardhat-graph-protocol/CHANGELOG.md
@@ -1,5 +1,12 @@
 # hardhat-graph-protocol
 
+## 0.1.16
+
+### Patch Changes
+
+- Updated dependencies
+  - @graphprotocol/toolshed@0.5.0
+
 ## 0.1.15
 
 ### Patch Changes
diff --git a/packages/hardhat-graph-protocol/package.json b/packages/hardhat-graph-protocol/package.json
@@ -1,6 +1,6 @@
 {
   "name": "hardhat-graph-protocol",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "publishConfig": {
     "access": "public"
   },
diff --git a/packages/hardhat-graph-protocol/src/accounts.ts b/packages/hardhat-graph-protocol/src/accounts.ts
@@ -0,0 +1,84 @@
+import {
+  getAccounts as getAccountsToolshed,
+  getArbitrator,
+  getDeployer,
+  getGateway, getGovernor, getPauseGuardian, getSubgraphAvailabilityOracle, getTestAccounts,
+  TEN_MILLION,
+} from '@graphprotocol/toolshed'
+import { setGRTBalance } from '@graphprotocol/toolshed/hardhat'
+
+import type { Addressable } from 'ethers'
+import type { HardhatEthersProvider } from '@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider'
+import type { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
+
+type Accounts = {
+  getAccounts: () => ReturnType<typeof getAccountsToolshed>
+  getDeployer: (accountIndex?: number) => ReturnType<typeof getDeployer>
+  getGovernor: (accountIndex?: number) => ReturnType<typeof getGovernor>
+  getArbitrator: (accountIndex?: number) => ReturnType<typeof getArbitrator>
+  getPauseGuardian: (accountIndex?: number) => ReturnType<typeof getPauseGuardian>
+  getSubgraphAvailabilityOracle: (accountIndex?: number) => ReturnType<typeof getSubgraphAvailabilityOracle>
+  getGateway: (accountIndex?: number) => ReturnType<typeof getGateway>
+  getTestAccounts: () => ReturnType<typeof getTestAccounts>
+}
+
+export function getAccounts(provider: HardhatEthersProvider, chainId: number, grtTokenAddress: string | Addressable): Accounts {
+  return {
+    getAccounts: async () => {
+      const accounts = await getAccountsToolshed(provider)
+      for (const account of Object.values(accounts)) {
+        if (typeof account === 'object' && 'address' in account) {
+          await setBalanceIfLocal(provider, chainId, grtTokenAddress, account)
+        } else if (Array.isArray(account)) {
+          for (const testAccount of account) {
+            await setBalanceIfLocal(provider, chainId, grtTokenAddress, testAccount)
+          }
+        }
+      }
+      return accounts
+    },
+    getDeployer: async (accountIndex?: number) => {
+      const account = await getDeployer(provider, accountIndex)
+      await setBalanceIfLocal(provider, chainId, grtTokenAddress, account)
+      return account
+    },
+    getGovernor: async (accountIndex?: number) => {
+      const account = await getGovernor(provider, accountIndex)
+      await setBalanceIfLocal(provider, chainId, grtTokenAddress, account)
+      return account
+    },
+    getArbitrator: async (accountIndex?: number) => {
+      const account = await getArbitrator(provider, accountIndex)
+      await setBalanceIfLocal(provider, chainId, grtTokenAddress, account)
+      return account
+    },
+    getPauseGuardian: async (accountIndex?: number) => {
+      const account = await getPauseGuardian(provider, accountIndex)
+      await setBalanceIfLocal(provider, chainId, grtTokenAddress, account)
+      return account
+    },
+    getSubgraphAvailabilityOracle: async (accountIndex?: number) => {
+      const account = await getSubgraphAvailabilityOracle(provider, accountIndex)
+      await setBalanceIfLocal(provider, chainId, grtTokenAddress, account)
+      return account
+    },
+    getGateway: async (accountIndex?: number) => {
+      const account = await getGateway(provider, accountIndex)
+      await setBalanceIfLocal(provider, chainId, grtTokenAddress, account)
+      return account
+    },
+    getTestAccounts: async () => {
+      const accounts = await getTestAccounts(provider)
+      for (const account of accounts) {
+        await setBalanceIfLocal(provider, chainId, grtTokenAddress, account)
+      }
+      return accounts
+    },
+  }
+}
+
+async function setBalanceIfLocal(provider: HardhatEthersProvider, chainId: number, grtTokenAddress: string | Addressable, account: HardhatEthersSigner) {
+  if ([1337, 31337].includes(chainId)) {
+    await setGRTBalance(provider, grtTokenAddress, account.address, TEN_MILLION)
+  }
+}
diff --git a/packages/hardhat-graph-protocol/src/gre.ts b/packages/hardhat-graph-protocol/src/gre.ts
@@ -1,16 +1,6 @@
 /* eslint-disable no-case-declarations */
 import path from 'path'
 
-import {
-  getAccounts,
-  getArbitrator,
-  getDeployer,
-  getGateway,
-  getGovernor,
-  getPauseGuardian,
-  getSubgraphAvailabilityOracle,
-  getTestAccounts,
-} from '@graphprotocol/toolshed'
 import { loadGraphHorizon, loadSubgraphService } from '@graphprotocol/toolshed/deployments'
 import { logDebug, logError } from './logger'
 import { getAddressBookPath } from './config'
@@ -22,6 +12,7 @@ import { lazyFunction } from 'hardhat/plugins'
 import type { HardhatConfig, HardhatRuntimeEnvironment, HardhatUserConfig } from 'hardhat/types'
 import type { GraphDeployments } from '@graphprotocol/toolshed/deployments'
 import type { GraphRuntimeEnvironmentOptions } from './types'
+import { getAccounts } from './accounts'
 
 export const greExtendConfig = (config: HardhatConfig, userConfig: Readonly<HardhatUserConfig>) => {
   const userPath = userConfig.paths?.graph
@@ -79,6 +70,7 @@ export const greExtendEnvironment = (hre: HardhatRuntimeEnvironment) => {
             greDeployments.subgraphService = loadSubgraphService(addressBookPath, chainId, provider)
             break
           default:
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
             logError(`Skipping deployment ${deployment} - Reason: unknown deployment`)
             break
         }
@@ -90,25 +82,15 @@ 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),
-    }
+    const accounts = getAccounts(provider, chainId, greDeployments.horizon?.contracts?.GraphToken?.target)
 
     logDebug('GRE initialized successfully!')
 
     return {
       ...greDeployments,
       provider,
       chainId,
-      accounts: accounts,
+      accounts,
     }
   })
 }
diff --git a/packages/horizon/package.json b/packages/horizon/package.json
@@ -55,7 +55,7 @@
     "hardhat": "^2.22.18",
     "hardhat-contract-sizer": "^2.10.0",
     "hardhat-gas-reporter": "^1.0.8",
-    "hardhat-graph-protocol": "workspace:^0.1.15",
+    "hardhat-graph-protocol": "workspace:^0.1.16",
     "hardhat-secure-accounts": "^1.0.5",
     "lint-staged": "^15.2.2",
     "prettier": "^3.2.5",
diff --git a/packages/subgraph-service/package.json b/packages/subgraph-service/package.json
@@ -56,7 +56,7 @@
     "hardhat": "^2.22.18",
     "hardhat-contract-sizer": "^2.10.0",
     "hardhat-gas-reporter": "^1.0.8",
-    "hardhat-graph-protocol": "workspace:^0.1.15",
+    "hardhat-graph-protocol": "workspace:^0.1.16",
     "hardhat-secure-accounts": "^1.0.5",
     "json5": "^2.2.3",
     "lint-staged": "^15.2.2",
diff --git a/packages/toolshed/CHANGELOG.md b/packages/toolshed/CHANGELOG.md
@@ -1,5 +1,16 @@
 # @graphprotocol/toolshed
 
+## 0.5.0
+
+### Minor Changes
+
+- Ensure toolshed core components dont import hardhat runtime
+
+### Patch Changes
+
+- @graphprotocol/horizon@0.3.2
+- @graphprotocol/subgraph-service@0.3.4
+
 ## 0.4.2
 
 ### Patch Changes
diff --git a/packages/toolshed/package.json b/packages/toolshed/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/toolshed",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "publishConfig": {
     "access": "public"
   },
diff --git a/packages/toolshed/src/core/accounts.ts b/packages/toolshed/src/core/accounts.ts
@@ -1,8 +1,3 @@
-import { setGRTBalance } from '../hardhat'
-import { TEN_MILLION } from './constants'
-import { toBeHex } from 'ethers'
-
-import type { Addressable } from 'ethers'
 import type { HardhatEthersProvider } from '@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider'
 import type { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers'
 
@@ -34,43 +29,43 @@ export type GraphAccounts = {
   test: HardhatEthersSigner[]
 }
 
-export async function getAccounts(provider: HardhatEthersProvider, grtTokenAddress?: string | Addressable): Promise<GraphAccounts> {
+export async function getAccounts(provider: HardhatEthersProvider): Promise<GraphAccounts> {
   return {
-    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),
+    deployer: await getDeployer(provider, GraphAccountIndex.Deployer),
+    governor: await getGovernor(provider, GraphAccountIndex.Governor),
+    arbitrator: await getArbitrator(provider, GraphAccountIndex.Arbitrator),
+    pauseGuardian: await getPauseGuardian(provider, GraphAccountIndex.PauseGuardian),
+    subgraphAvailabilityOracle: await getSubgraphAvailabilityOracle(provider, GraphAccountIndex.SubgraphAvailabilityOracle),
+    gateway: await getGateway(provider, GraphAccountIndex.Gateway),
+    test: await getTestAccounts(provider),
   }
 }
 
-export async function getDeployer(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.Deployer, grtTokenAddress?: string | Addressable) {
-  return _getAccount(provider, accountIndex, grtTokenAddress)
+export async function getDeployer(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.Deployer) {
+  return _getAccount(provider, accountIndex)
 }
 
-export async function getGovernor(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.Governor, grtTokenAddress?: string | Addressable) {
-  return _getAccount(provider, accountIndex, grtTokenAddress)
+export async function getGovernor(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.Governor) {
+  return _getAccount(provider, accountIndex)
 }
 
-export async function getArbitrator(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.Arbitrator, grtTokenAddress?: string | Addressable) {
-  return _getAccount(provider, accountIndex, grtTokenAddress)
+export async function getArbitrator(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.Arbitrator) {
+  return _getAccount(provider, accountIndex)
 }
 
-export async function getPauseGuardian(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.PauseGuardian, grtTokenAddress?: string | Addressable) {
-  return _getAccount(provider, accountIndex, grtTokenAddress)
+export async function getPauseGuardian(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.PauseGuardian) {
+  return _getAccount(provider, accountIndex)
 }
 
-export async function getSubgraphAvailabilityOracle(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.SubgraphAvailabilityOracle, grtTokenAddress?: string | Addressable) {
-  return _getAccount(provider, accountIndex, grtTokenAddress)
+export async function getSubgraphAvailabilityOracle(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.SubgraphAvailabilityOracle) {
+  return _getAccount(provider, accountIndex)
 }
 
-export async function getGateway(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.Gateway, grtTokenAddress?: string | Addressable) {
-  return _getAccount(provider, accountIndex, grtTokenAddress)
+export async function getGateway(provider: HardhatEthersProvider, accountIndex = GraphAccountIndex.Gateway) {
+  return _getAccount(provider, accountIndex)
 }
 
-export async function getTestAccounts(provider: HardhatEthersProvider, grtTokenAddress?: string | Addressable) {
+export async function getTestAccounts(provider: HardhatEthersProvider) {
   const accounts = await provider.send('eth_accounts', []) as string[]
   const numReservedAccounts = Object.values(GraphAccountIndex).filter(v => typeof v === 'number').length
   if (accounts.length < numReservedAccounts) {
@@ -79,21 +74,10 @@ export async function getTestAccounts(provider: HardhatEthersProvider, grtTokenA
   return await Promise.all(
     accounts
       .slice(numReservedAccounts)
-      .map(async account => await _getAccount(provider, account, grtTokenAddress)),
+      .map(async account => await _getAccount(provider, account)),
   )
 }
 
-async function _getAccount(provider: HardhatEthersProvider, accountIndex: number | string, grtTokenAddress?: string | Addressable) {
-  const account = await provider.getSigner(accountIndex)
-
-  // If the chain is local, set balance to 10M GRT
-  if (grtTokenAddress) {
-    const chainId = await provider.send('eth_chainId', []) as string
-    const isLocal = [toBeHex(1337), toBeHex(31337)].includes(toBeHex(BigInt(chainId)))
-    if (isLocal) {
-      await setGRTBalance(provider, grtTokenAddress, account.address, TEN_MILLION)
-    }
-  }
-
-  return account
+async function _getAccount(provider: HardhatEthersProvider, accountIndex: number | string) {
+  return await provider.getSigner(accountIndex)
 }

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "hardhat-graph-protocol",`
`3`		`- "version": "0.1.15",`
	`3`	`+ "version": "0.1.16",`
`4`	`4`	`"publishConfig": {`
`5`	`5`	`"access": "public"`
`6`	`6`	`},`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@graphprotocol/toolshed",`
`3`		`- "version": "0.4.2",`
	`3`	`+ "version": "0.5.0",`
`4`	`4`	`"publishConfig": {`
`5`	`5`	`"access": "public"`
`6`	`6`	`},`