make use of useChainIdOfForkedNetwork for forks indexing

contracts/package.json

@@ -18,7 +18,7 @@
     "fs-extra": "^11.2.0",
     "hardhat": "^2.20.1",
     "hardhat-preprocessor": "^0.1.5",
-    "hardhat-rocketh": "^4.0.9",
+    "hardhat-rocketh": "^4.0.12",
     "ldenv": "^0.3.10",
     "prettier": "^3.2.5",
     "prettier-plugin-solidity": "^1.3.1",

contracts/scripts/data/main.ts

@@ -3,15 +3,17 @@ import {keepStreamOnFile} from 'ethereum-indexer-fs';
 import contractsInfo from './contracts';
 import hre from 'hardhat';
 import {createProcessor} from 'stratagems-indexer';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 export const processor = createProcessor();
 export const {state, init, indexToLatest} = createIndexerState(processor, {
 	keepStream: keepStreamOnFile('.data', 'stratagems'),
 });
 
 export async function indexAll() {
+	const env = await loadEnvironmentFromHardhat({hre}, {useChainIdOfForkedNetwork: true});
 	await init({
-		provider: hre.network.provider as any, // TOD type
+		provider: env.network.provider,
 		source: {
 			chainId: contractsInfo.chainId,
 			contracts: Object.keys(contractsInfo.contracts).map((name) => (contractsInfo as any).contracts[name]),

contracts/scripts/data/playerWithWithdrawals.ts

@@ -6,6 +6,7 @@ import {Color} from 'stratagems-common';
 
 import type {MergedAbis, JSProcessor} from 'ethereum-indexer-js-processor';
 import {fromJSProcessor} from 'ethereum-indexer-js-processor';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 export type Data = {
 	players: {
@@ -45,8 +46,9 @@ export const {state, init, indexToLatest} = createIndexerState(processor, {
 });
 
 export async function indexPlayersWithWithdrawals() {
+	const env = await loadEnvironmentFromHardhat({hre}, {useChainIdOfForkedNetwork: true});
 	await init({
-		provider: hre.network.provider as any, // TOD type
+		provider: env.network.provider,
 		source: {
 			chainId: contractsInfo.chainId,
 			contracts: Object.keys(contractsInfo.contracts).map((name) => (contractsInfo as any).contracts[name]),

contracts/scripts/data/players.ts

@@ -6,6 +6,7 @@ import hre from 'hardhat';
 import type {MergedAbis, JSProcessor} from 'ethereum-indexer-js-processor';
 import {fromJSProcessor} from 'ethereum-indexer-js-processor';
 import {formatEther, zeroAddress} from 'viem';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 const testTokenAddress = contractsInfo.contracts['TestTokens'].address.toLowerCase();
 const stratagemsAddress = contractsInfo.contracts['Stratagems'].address.toLowerCase();
@@ -92,8 +93,9 @@ export const {state, init, indexToLatest} = createIndexerState(processor, {
 });
 
 export async function indexPlayers() {
+	const env = await loadEnvironmentFromHardhat({hre}, {useChainIdOfForkedNetwork: true});
 	await init({
-		provider: hre.network.provider as any, // TOD type
+		provider: env.network.provider,
 		source: {
 			chainId: contractsInfo.chainId,
 			contracts: Object.keys(contractsInfo.contracts).map((name) => (contractsInfo as any).contracts[name]),

contracts/scripts/distributeMoreTokens.ts

@@ -1,20 +1,14 @@
-import {loadEnvironment} from 'rocketh';
 import {context} from '../deploy/_context';
 import {formatEther, parseUnits} from 'viem';
 import hre from 'hardhat';
 import 'rocketh-deploy';
 import prompts from 'prompts';
 
 import {indexPlayers} from './data/players';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			provider: hre.network.provider as any,
-			network: hre.network.name,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 
 	const state = await indexPlayers();
 

contracts/scripts/distributeTokens.ts

@@ -1,16 +1,10 @@
-import {loadEnvironment} from 'rocketh';
 import {context} from '../deploy/_context';
 import {parseUnits} from 'viem';
 import hre from 'hardhat';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			provider: hre.network.provider,
-			network: hre.network.name,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 
 	const TestTokens = env.get<typeof context.artifacts.TestTokens.abi>('TestTokens');
 	const decimals = await env.read(TestTokens, {functionName: 'decimals'});

contracts/scripts/fixDistribution.ts

@@ -1,20 +1,14 @@
-import {loadEnvironment} from 'rocketh';
 import {context} from '../deploy/_context';
 import {formatEther, formatUnits, parseEther, parseUnits} from 'viem';
 import hre from 'hardhat';
 import 'rocketh-deploy';
 import prompts from 'prompts';
 
 import {indexPlayers} from './data/players';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			provider: hre.network.provider as any,
-			network: hre.network.name,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 
 	const state = await indexPlayers();
 

contracts/scripts/fixPointsBalance.ts

@@ -1,4 +1,4 @@
-import {loadEnvironment} from 'rocketh';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 import {context} from '../deploy/_context';
 import {formatEther, formatUnits, parseEther, parseUnits} from 'viem';
 import hre from 'hardhat';
@@ -7,17 +7,7 @@ import prompts from 'prompts';
 import {indexAll} from './data/main';
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			provider: hre.network.provider as any,
-			network: process.env.HARDHAT_FORK // TODO move that in rocketh-harchat somehow
-				? {
-						fork: process.env.HARDHAT_FORK,
-					}
-				: hre.network.name,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 
 	const state = await indexAll();
 

contracts/scripts/gas.ts

@@ -1,9 +1,10 @@
-import {getGasPriceEstimate, getRoughGasPriceEstimate, loadEnvironment} from 'rocketh';
-import type {EIP1193BlockTag, EIP1193GenericRequestProvider} from 'eip-1193';
+import {getGasPriceEstimate, getRoughGasPriceEstimate} from 'rocketh';
+import type {EIP1193BlockTag} from 'eip-1193';
 import {context} from '../deploy/_context';
 import hre from 'hardhat';
-import {decodeFunctionResult, encodeFunctionData, formatEther} from 'viem';
+import {formatEther} from 'viem';
 import {getBaseFee, getGasPrice, getL1BaseFee, getL1Fee, getL1GasUsed} from './op';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 const args = process.argv.slice(2);
 const blockTag = (args[0] || 'latest') as EIP1193BlockTag;
@@ -25,13 +26,7 @@ function formatAll(obj: object) {
 }
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			network: hre.network.name,
-			provider: hre.network.provider as EIP1193GenericRequestProvider,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 	const provider = env.network.provider;
 
 	const gasPriceEstimates = await getRoughGasPriceEstimate(provider);

contracts/scripts/generateTokenLinks.ts

@@ -1,13 +1,13 @@
 import {generatePrivateKey, privateKeyToAccount} from 'viem/accounts';
 
-import {Deployment, loadEnvironment} from 'rocketh';
+import {Deployment} from 'rocketh';
 import {context} from '../deploy/_context';
 import {formatEther, parseEther, parseUnits} from 'viem';
 import hre from 'hardhat';
 import fs from 'fs-extra';
 import prompts from 'prompts';
 import 'rocketh-deploy';
-import {EIP1193GenericRequestProvider} from 'eip-1193';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 const args = process.argv.slice(2);
 const num = (args[0] && parseInt(args[0])) || 100;
@@ -20,13 +20,7 @@ const valuePerChainId = {
 };
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			provider: hre.network.provider as EIP1193GenericRequestProvider,
-			network: hre.network.name,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 
 	const TestTokens = env.get<typeof context.artifacts.TestTokens.abi>('TestTokens');
 	const decimals = await env.read(TestTokens, {functionName: 'decimals'});

contracts/scripts/getGasFee.ts

@@ -1,8 +1,7 @@
-import {loadEnvironment} from 'rocketh';
 import {context} from '../deploy/_context';
 import {EIP1193ProviderWithoutEvents} from 'eip-1193';
-import {parseUnits} from 'viem';
 import hre from 'hardhat';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 function avg(arr: bigint[]) {
 	const sum = arr.reduce((a: bigint, v: bigint) => a + v);
@@ -46,13 +45,7 @@ export async function estimateGasPrice(provider: EIP1193ProviderWithoutEvents) {
 }
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			provider: hre.network.provider,
-			network: hre.network.name,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 
 	const result = await estimateGasPrice(env.network.provider);
 	console.log(result);

contracts/scripts/poke.ts

@@ -1,17 +1,11 @@
-import {loadEnvironment} from 'rocketh';
 import {context} from '../deploy/_context';
 import {xyToBigIntID} from 'stratagems-common';
 import hre from 'hardhat';
 import 'rocketh-deploy';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			provider: hre.network.provider as any,
-			network: hre.network.name,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 
 	const args = process.argv.slice(2);
 	const positionStr = args[0];

contracts/scripts/readConfig.ts

@@ -1,17 +1,11 @@
-import {Deployment, loadEnvironment} from 'rocketh';
+import {Deployment} from 'rocketh';
 import {context} from '../deploy/_context';
 import hre from 'hardhat';
 import {fetchContract} from '../utils/connection';
-import {EIP1193GenericRequestProvider} from 'eip-1193';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			provider: hre.network.provider as EIP1193GenericRequestProvider,
-			network: hre.network.name,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 
 	const args = process.argv.slice(2);
 	const account = (args[0] || process.env.ACCOUNT) as `0x${string}`;

contracts/scripts/readReward.ts

@@ -1,19 +1,13 @@
-import {Deployment, loadEnvironment} from 'rocketh';
+import {Deployment} from 'rocketh';
 import 'rocketh-deploy';
 import {context} from '../deploy/_context';
 import hre from 'hardhat';
-import {EIP1193GenericRequestProvider} from 'eip-1193';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 const args = process.argv.slice(2) as `0x${string}`[];
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			provider: hre.network.provider as EIP1193GenericRequestProvider,
-			network: hre.network.name,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 
 	const GemsGenerator = env.deployments.GemsGenerator as Deployment<typeof context.artifacts.RewardsGenerator.abi>;
 	const value = await env.read(GemsGenerator, {

contracts/scripts/readTimestamp.ts

@@ -1,23 +1,20 @@
-import {Deployment, loadEnvironment} from 'rocketh';
+import {Deployment} from 'rocketh';
 import {context} from '../deploy/_context';
 import hre from 'hardhat';
-import {fetchContract} from '../utils/connection';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
+import artifacts from 'solidity-kit/generated/artifacts';
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			provider: hre.network.provider,
-			network: hre.network.name,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 
 	const args = process.argv.slice(2);
 	const account = (args[0] || process.env.ACCOUNT) as `0x${string}`;
-	const Stratagems = env.deployments.Stratagems as Deployment<typeof context.artifacts.IStratagemsDebug.abi>;
-	const StratagemsContract = await fetchContract(Stratagems);
-	const timestamp = await StratagemsContract.read.timestamp();
+	const Time = env.deployments.Stratagems as Deployment<typeof artifacts.Time.abi>;
+	const timestamp = await env.read(Time, {
+		functionName: 'timestamp',
+		args: [],
+	});
 
-	console.log({account, timeContract: StratagemsContract.address, timestamp: timestamp.toString()});
+	console.log({account, timeContract: Time.address, timestamp: timestamp.toString()});
 }
 main();

contracts/scripts/skipDays.ts

@@ -1,18 +1,11 @@
-import {loadEnvironment} from 'rocketh';
 import {context} from '../deploy/_context';
 import hre from 'hardhat';
-import {EIP1193GenericRequestProvider} from 'eip-1193';
 import SolidityKit from 'solidity-kit/generated/artifacts';
 import 'rocketh-deploy';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			provider: hre.network.provider as EIP1193GenericRequestProvider,
-			network: hre.network.name,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 
 	const args = process.argv.slice(2);
 	const valueStr = args[0];

contracts/scripts/steal.ts

@@ -1,18 +1,11 @@
-import {loadEnvironment} from 'rocketh';
 import {context} from '../deploy/_context';
-import {xyToBigIntID} from 'stratagems-common';
 import hre from 'hardhat';
 import 'rocketh-deploy';
 import {formatEther, parseEther} from 'viem';
+import {loadEnvironmentFromHardhat} from 'hardhat-rocketh/helpers';
 
 async function main() {
-	const env = await loadEnvironment(
-		{
-			provider: hre.network.provider as any,
-			network: hre.network.name,
-		},
-		context,
-	);
+	const env = await loadEnvironmentFromHardhat({hre, context});
 
 	const {deployer, tokensBeneficiary} = env.accounts;