rocketh 0.15.15 → 0.16.0

package/src/executor/index.ts

@@ -1,38 +1,34 @@
-import {EIP1193GenericRequestProvider, EIP1193ProviderWithoutEvents} from 'eip-1193';
 import fs from 'node:fs';
 import path from 'node:path';
 import prompts from 'prompts';
-// import {tsImport as tsImport_} from 'tsx/esm/api';
-import { register } from 'tsx/esm/api'
-import {formatEther} from 'viem';
-import type {
-	Environment,
-	ExecutionParams,
-	ResolvedExecutionParams,
-	UnknownDeployments,
-	UnresolvedNetworkSpecificData,
-	UnresolvedUnknownNamedAccounts,
-	DeployScriptModule,
-	EnhancedDeployScriptFunction,
-	EnhancedEnvironment,
-	ResolvedUserConfig,
-	ConfigOverrides,
-	UserConfig,
-	ChainConfig,
-} from '../types.js';
-import {withEnvironment} from '../utils/extensions.js';
-import {logger, setLogLevel, spin} from '../internal/logging.js';
-import {getRoughGasPriceEstimate} from '../utils/eth.js';
+import {
+	type Environment,
+	type ExecutionParams,
+	type ResolvedExecutionParams,
+	type UnknownDeployments,
+	type UnresolvedNetworkSpecificData,
+	type UnresolvedUnknownNamedAccounts,
+	type DeployScriptModule,
+	type EnhancedEnvironment,
+	type ResolvedUserConfig,
+	type ConfigOverrides,
+	type UserConfig,
+	type PromptExecutor,
+} from '@rocketh/core/types';
+import {
+	withEnvironment,
+	resolveConfig,
+	resolveExecutionParams,
+	createEnvironment,
+	logger,
+	getEnvironmentName,
+	getChainIdForEnvironment,
+	createExecutor,
+	setupDeployScripts,
+	loadDeployments,
+} from '@rocketh/core';
 import {traverseMultipleDirectory} from '../utils/fs.js';
-import {getChainByName, getChainConfig} from '../environment/utils/chains.js';
-import {JSONRPCHTTPProvider} from 'eip-1193-jsonrpc-provider';
-import {createEnvironment} from '../environment/index.js';
-
-
-
-// @ts-ignore
-// const tsImport = (path: string, opts: any) => (typeof Bun !== 'undefined' ? import(path) : tsImport_(path, opts));
-const unregister = register();
+import {createFSDeploymentStore} from '../environment/deployment-store.js';
 
 /**
  * Setup function that creates the execute function for deploy scripts. It allow to specify a set of functions that will be available in the environment.
@@ -60,6 +56,7 @@ const unregister = register();
  * }, { tags: ['deploy'] });
  * ```
  */
+
 export function setup<
 	Extensions extends Record<string, (env: Environment<any, any, any>) => any> = {},
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
@@ -67,33 +64,20 @@ export function setup<
 	Deployments extends UnknownDeployments = UnknownDeployments,
 	Extra extends Record<string, unknown> = Record<string, unknown>
 >(extensions: Extensions) {
-	function enhancedExecute<ArgumentsType = undefined>(
-		callback: EnhancedDeployScriptFunction<NamedAccounts, Data, ArgumentsType, Deployments, Extensions>,
-		options: {tags?: string[]; dependencies?: string[]; id?: string; runAtTheEnd?: boolean}
-	): DeployScriptModule<NamedAccounts, Data, ArgumentsType, Deployments, Extra> {
-		const scriptModule: DeployScriptModule<NamedAccounts, Data, ArgumentsType, Deployments, Extra> = (
-			env: Environment<NamedAccounts, Data, Deployments, Extra>,
-			args?: ArgumentsType
-		) => {
-			// Create the enhanced environment by combining the original environment with extensions
-			const curriedFunctions = withEnvironment(env, extensions);
-			const enhancedEnv = Object.assign(
-				Object.create(Object.getPrototypeOf(env)),
-				env,
-				curriedFunctions
-			) as EnhancedEnvironment<NamedAccounts, Data, Deployments, Extensions, Extra>;
-
-			return callback(enhancedEnv, args);
-		};
-
-		scriptModule.tags = options.tags;
-		scriptModule.dependencies = options.dependencies;
-		scriptModule.id = options.id;
-		scriptModule.runAtTheEnd = options.runAtTheEnd;
-
-		return scriptModule;
-	}
+	const {deployScript} = setupDeployScripts<Extensions, NamedAccounts, Data, Deployments, Extra>(extensions);
+	const {loadAndExecuteDeployments} = setupEnvironmentFromFiles<Extensions, NamedAccounts, Data, Deployments, Extra>(
+		extensions
+	);
+	return {deployScript, loadAndExecuteDeployments};
+}
 
+export function setupEnvironmentFromFiles<
+	Extensions extends Record<string, (env: Environment<any, any, any>) => any> = {},
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
+	Deployments extends UnknownDeployments = UnknownDeployments,
+	Extra extends Record<string, unknown> = Record<string, unknown>
+>(extensions: Extensions) {
 	async function loadAndExecuteDeploymentsWithExtensions<
 		Extra extends Record<string, unknown> = Record<string, unknown>,
 		ArgumentsType = undefined
@@ -113,7 +97,6 @@ export function setup<
 	}
 
 	return {
-		deployScript: enhancedExecute,
 		loadAndExecuteDeployments: loadAndExecuteDeploymentsWithExtensions,
 		loadEnvironment: loadEnvironmentWithExtensions,
 	};
@@ -155,12 +138,26 @@ export async function readConfig<
 	let jsVersion: string | undefined;
 
 	if (typeof process !== 'undefined') {
-		// TODO more sophisticated config file finding mechanism (look up parents, etc..)
-		const tsFilePath = path.join(process.cwd(), 'rocketh.ts');
-		const jsFilePath = path.join(process.cwd(), 'rocketh.js');
-
-		tsVersion = fs.existsSync(tsFilePath) ? `file://${tsFilePath}` : undefined;
-		jsVersion = fs.existsSync(jsFilePath) ? `file://${jsFilePath}` : undefined;
+		const listOfFileToTryForTS = [
+			path.join(process.cwd(), 'rocketh.ts'),
+			path.join(process.cwd(), 'rocketh', 'config.ts'),
+		];
+		for (const filepath of listOfFileToTryForTS) {
+			if (fs.existsSync(filepath)) {
+				tsVersion = `file://${filepath}`;
+				break;
+			}
+		}
+		const listOfFileToTryForJS = [
+			path.join(process.cwd(), 'rocketh.js'),
+			path.join(process.cwd(), 'rocketh', 'config.s'),
+		];
+		for (const filepath of listOfFileToTryForJS) {
+			if (fs.existsSync(filepath)) {
+				jsVersion = `file://${filepath}`;
+				break;
+			}
+		}
 	}
 	const existingConfigs = [tsVersion, jsVersion].filter(Boolean).length;
 
@@ -189,34 +186,6 @@ export async function readConfig<
 	return configFile || {};
 }
 
-export function resolveConfig<
-	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
-	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
->(configFile: UserConfig, overrides?: ConfigOverrides): ResolvedUserConfig<NamedAccounts, Data> {
-	const config = {
-		deployments: 'deployments',
-		defaultPollingInterval: 1,
-		...configFile,
-		scripts: configFile?.scripts
-			? typeof configFile.scripts === 'string'
-				? [configFile.scripts]
-				: configFile.scripts.length == 0
-				? ['deploy']
-				: configFile.scripts
-			: ['deploy'],
-	};
-
-	if (overrides) {
-		for (const key of Object.keys(overrides)) {
-			if ((overrides as any)[key] !== undefined) {
-				(config as any)[key] = (overrides as any)[key];
-			}
-		}
-	}
-
-	return config;
-}
-
 export async function readAndResolveConfig<
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
@@ -225,137 +194,27 @@ export async function readAndResolveConfig<
 	return resolveConfig(configFile, overrides);
 }
 
-export async function getChainIdForEnvironment(
-	config: ResolvedUserConfig,
-	environmentName: string,
-	provider?: EIP1193ProviderWithoutEvents
-) {
-	if (config?.environments?.[environmentName]?.chain) {
-		const chainAsNumber =
-			typeof config.environments[environmentName].chain === 'number'
-				? config.environments[environmentName].chain
-				: parseInt(config.environments[environmentName].chain);
-		if (!isNaN(chainAsNumber)) {
-			return chainAsNumber;
-		}
-		const chainFound = getChainByName(config.environments[environmentName].chain as string);
-		if (chainFound) {
-			return chainFound.id;
-		} else {
-			throw new Error(`environment ${environmentName} chain id cannot be found, specify it in the rocketh config`);
-		}
-	} else {
-		const chainFound = getChainByName(environmentName);
-		if (chainFound) {
-			return chainFound.id;
-		} else {
-			if (provider) {
-				const chainIdAsHex = await provider.request({method: 'eth_chainId'});
-				return Number(chainIdAsHex);
-			} else {
-				throw new Error(`environment ${environmentName} chain id cannot be found, specify it in the rocketh config`);
-			}
-		}
-	}
-}
-
-function getEnvironmentName(executionParams: ExecutionParams): {name: string; fork: boolean} {
-	const environmentProvided = executionParams.environment || (executionParams as any).network;
-	let environmentName = 'memory';
-	if (environmentProvided) {
-		if (typeof environmentProvided === 'string') {
-			environmentName = environmentProvided;
-		} else if ('fork' in environmentProvided) {
-			environmentName = environmentProvided.fork;
-		}
-	}
-	const fork = typeof environmentProvided !== 'string';
-	return {name: environmentName, fork};
-}
-
-export function resolveExecutionParams<Extra extends Record<string, unknown> = Record<string, unknown>>(
-	config: ResolvedUserConfig,
-	executionParameters: ExecutionParams<Extra>,
-	chainId: number
-): ResolvedExecutionParams<Extra> {
-	const {name: environmentName, fork} = getEnvironmentName(executionParameters);
-
-	// TODO fork chainId resolution option to keep the network being used
-	let chainConfig: ChainConfig = getChainConfig(fork ? 31337 : chainId, config);
-
-	let chainInfo = chainConfig.info;
-	const environmentConfig = config?.environments?.[environmentName];
-	const actualChainConfig = environmentConfig?.overrides
-		? {
-				...chainConfig,
-				...environmentConfig.overrides,
-				properties: {
-					...chainConfig?.properties,
-					...environmentConfig.overrides.properties,
-				},
-		  }
-		: chainConfig;
-
-	if (actualChainConfig?.properties) {
-		chainInfo = {...chainInfo, properties: actualChainConfig.properties};
-	}
-
-	// let environmentTags: string[] = actualChainConfig.tags.concat(environmentConfig?.tags); // TODO
-	const environmentTags = actualChainConfig.tags;
-
-	let scripts = ['deploy'];
-	if (config.scripts) {
-		if (typeof config.scripts === 'string') {
-			scripts = [config.scripts];
-		} else {
-			scripts = [...config.scripts];
-		}
-	}
-
-	if (environmentConfig?.scripts) {
-		if (typeof environmentConfig.scripts === 'string') {
-			scripts = [environmentConfig.scripts];
-		} else {
-			scripts = [...environmentConfig.scripts];
-		}
-	}
-
-	const provider =
-		executionParameters.provider || (new JSONRPCHTTPProvider(actualChainConfig.rpcUrl) as EIP1193ProviderWithoutEvents);
-
-	let saveDeployments = executionParameters.saveDeployments;
-
-	if (saveDeployments === undefined) {
-		if (!executionParameters.provider) {
-			saveDeployments = true;
-		} else {
-			if (environmentName === 'memory' || environmentName === 'hardhat' || environmentName === 'default') {
-				// networkTags['memory'] = true;
-				saveDeployments = false;
-			} else {
-				saveDeployments = true;
-			}
-		}
-	}
-
+const deploymentStore = createFSDeploymentStore();
+const promptExecutor: PromptExecutor = async (request: {type: 'confirm'; name: string; message: string}) => {
+	const answer = await prompts<string>(request);
 	return {
-		askBeforeProceeding: executionParameters.askBeforeProceeding || false,
-		chain: chainInfo,
-		logLevel: executionParameters.logLevel || 0, // TODO
-		pollingInterval: actualChainConfig.pollingInterval,
-		reportGasUse: executionParameters.reportGasUse || false,
-		saveDeployments,
-		tags: executionParameters.tags || [],
-		environment: {
-			name: environmentName,
-			tags: environmentTags,
-			fork,
-			deterministicDeployment: actualChainConfig.deterministicDeployment,
-		},
-		extra: executionParameters.extra,
-		provider,
-		scripts,
+		proceed: answer.proceed,
 	};
+};
+const executor = createExecutor(deploymentStore, promptExecutor);
+
+export function loadDeploymentsFromFiles(
+	deploymentsPath: string,
+	networkName: string,
+	onlyABIAndAddress?: boolean,
+	expectedChain?: {chainId: string; genesisHash?: `0x${string}`; deleteDeploymentsIfDifferentGenesisHash?: boolean}
+): Promise<{
+	deployments: UnknownDeployments;
+	migrations: Record<string, number>;
+	chainId?: string;
+	genesisHash?: `0x${string}`;
+}> {
+	return loadDeployments(deploymentStore, deploymentsPath, networkName, onlyABIAndAddress, expectedChain);
 }
 
 export async function loadEnvironment<
@@ -370,7 +229,8 @@ export async function loadEnvironment<
 	// console.log(JSON.stringify(resolvedConfig, null, 2));
 	const {external, internal} = await createEnvironment<NamedAccounts, Data, UnknownDeployments>(
 		userConfig,
-		resolvedExecutionParams
+		resolvedExecutionParams,
+		deploymentStore
 	);
 	return external;
 }
@@ -390,6 +250,7 @@ export async function loadAndExecuteDeployments<
 	const resolvedExecutionParams = resolveExecutionParams(userConfig, executionParams, chainId);
 	// console.log(JSON.stringify(options, null, 2));
 	// console.log(JSON.stringify(resolvedConfig, null, 2));
+
 	return _executeDeployScripts<NamedAccounts, Data, ArgumentsType>(userConfig, resolvedExecutionParams, args);
 }
 
@@ -420,8 +281,6 @@ async function _executeDeployScripts<
 	resolvedExecutionParams: ResolvedExecutionParams,
 	args?: ArgumentsType
 ): Promise<Environment<NamedAccounts, Data, UnknownDeployments>> {
-	setLogLevel(typeof resolvedExecutionParams.logLevel === 'undefined' ? 0 : resolvedExecutionParams.logLevel);
-
 	let filepaths;
 	filepaths = traverseMultipleDirectory(resolvedExecutionParams.scripts);
 	filepaths = filepaths
@@ -436,10 +295,7 @@ async function _executeDeployScripts<
 			return 0;
 		});
 
-	const scriptModuleByFilePath: {[filename: string]: DeployScriptModule<NamedAccounts, Data, ArgumentsType>} = {};
-	const scriptPathBags: {[tag: string]: string[]} = {};
-	const scriptFilePaths: string[] = [];
-
+	const moduleObjects: {id: string; module: DeployScriptModule<NamedAccounts, Data, ArgumentsType>}[] = [];
 	for (const filepath of filepaths) {
 		const scriptFilePath = path.resolve(filepath);
 		let scriptModule: DeployScriptModule<NamedAccounts, Data, ArgumentsType>;
@@ -457,182 +313,17 @@ async function _executeDeployScripts<
 					scriptModule = (scriptModule as any).default as DeployScriptModule<NamedAccounts, Data, ArgumentsType>;
 				}
 			}
-			scriptModuleByFilePath[scriptFilePath] = scriptModule;
+			moduleObjects.push({id: scriptFilePath, module: scriptModule});
 		} catch (e) {
 			logger.error(`could not import ${filepath}`);
 			throw e;
 		}
-
-		let scriptTags = scriptModule.tags;
-		if (scriptTags !== undefined) {
-			if (typeof scriptTags === 'string') {
-				scriptTags = [scriptTags];
-			}
-			for (const tag of scriptTags) {
-				if (tag.indexOf(',') >= 0) {
-					throw new Error('Tag cannot contains commas');
-				}
-				const bag = scriptPathBags[tag] || [];
-				scriptPathBags[tag] = bag;
-				bag.push(scriptFilePath);
-			}
-		}
-
-		if (resolvedExecutionParams.tags !== undefined && resolvedExecutionParams.tags.length > 0) {
-			let found = false;
-			if (scriptTags !== undefined) {
-				for (const tagToFind of resolvedExecutionParams.tags) {
-					for (const tag of scriptTags) {
-						if (tag === tagToFind) {
-							scriptFilePaths.push(scriptFilePath);
-							found = true;
-							break;
-						}
-					}
-					if (found) {
-						break;
-					}
-				}
-			}
-		} else {
-			scriptFilePaths.push(scriptFilePath);
-		}
 	}
 
-	const {internal, external} = await createEnvironment<NamedAccounts, Data, UnknownDeployments>(
+	return executor.executeDeployScriptModules<NamedAccounts, Data, ArgumentsType>(
+		moduleObjects,
 		userConfig,
-		resolvedExecutionParams
+		resolvedExecutionParams,
+		args
 	);
-
-	await internal.recoverTransactionsIfAny();
-
-	const scriptsRegisteredToRun: {[filename: string]: boolean} = {};
-	const scriptsToRun: Array<{
-		func: DeployScriptModule<NamedAccounts, Data, ArgumentsType>;
-		filePath: string;
-	}> = [];
-	const scriptsToRunAtTheEnd: Array<{
-		func: DeployScriptModule<NamedAccounts, Data, ArgumentsType>;
-		filePath: string;
-	}> = [];
-	function recurseDependencies(scriptFilePath: string) {
-		if (scriptsRegisteredToRun[scriptFilePath]) {
-			return;
-		}
-		const scriptModule = scriptModuleByFilePath[scriptFilePath];
-		if (scriptModule.dependencies) {
-			for (const dependency of scriptModule.dependencies) {
-				const scriptFilePathsToAdd = scriptPathBags[dependency];
-				if (scriptFilePathsToAdd) {
-					for (const scriptFilenameToAdd of scriptFilePathsToAdd) {
-						recurseDependencies(scriptFilenameToAdd);
-					}
-				}
-			}
-		}
-		if (!scriptsRegisteredToRun[scriptFilePath]) {
-			if (scriptModule.runAtTheEnd) {
-				scriptsToRunAtTheEnd.push({
-					filePath: scriptFilePath,
-					func: scriptModule,
-				});
-			} else {
-				scriptsToRun.push({
-					filePath: scriptFilePath,
-					func: scriptModule,
-				});
-			}
-			scriptsRegisteredToRun[scriptFilePath] = true;
-		}
-	}
-	for (const scriptFilePath of scriptFilePaths) {
-		recurseDependencies(scriptFilePath);
-	}
-
-	if (resolvedExecutionParams.askBeforeProceeding) {
-		console.log(
-			`Network: ${external.name} \n \t Chain: ${external.network.chain.name} \n \t Tags: ${Object.keys(
-				external.tags
-			).join(',')}`
-		);
-		const gasPriceEstimate = await getRoughGasPriceEstimate(external.network.provider);
-		const prompt = await prompts({
-			type: 'confirm',
-			name: 'proceed',
-			message: `gas price is currently in this range:
-slow: ${formatEther(gasPriceEstimate.slow.maxFeePerGas)} (priority: ${formatEther(
-				gasPriceEstimate.slow.maxPriorityFeePerGas
-			)})
-average: ${formatEther(gasPriceEstimate.average.maxFeePerGas)} (priority: ${formatEther(
-				gasPriceEstimate.average.maxPriorityFeePerGas
-			)})
-fast: ${formatEther(gasPriceEstimate.fast.maxFeePerGas)} (priority: ${formatEther(
-				gasPriceEstimate.fast.maxPriorityFeePerGas
-			)})
-
-Do you want to proceed (note that gas price can change for each tx)`,
-		});
-
-		if (!prompt.proceed) {
-			process.exit();
-		}
-	}
-
-	for (const deployScript of scriptsToRun.concat(scriptsToRunAtTheEnd)) {
-		const filename = path.basename(deployScript.filePath);
-		const relativeFilepath = path.relative('.', deployScript.filePath);
-		if (deployScript.func.id && external.hasMigrationBeenDone(deployScript.func.id)) {
-			logger.info(`skipping ${filename} as migrations already executed and complete`);
-			continue;
-		}
-		let skip = false;
-		const spinner = spin(`- Executing ${filename}`);
-		// if (deployScript.func.skip) {
-		// 	const spinner = spin(`  - skip?()`);
-		// 	try {
-		// 		skip = await deployScript.func.skip(external, args);
-		// 		spinner.succeed(skip ? `skipping ${filename}` : undefined);
-		// 	} catch (e) {
-		// 		spinner.fail();
-		// 		throw e;
-		// 	}
-		// }
-		if (!skip) {
-			let result;
-
-			try {
-				result = await deployScript.func(external, args);
-				spinner.succeed(`\n`);
-			} catch (e) {
-				spinner.fail();
-				throw e;
-			}
-			if (result && typeof result === 'boolean') {
-				if (!deployScript.func.id) {
-					throw new Error(
-						`${deployScript.filePath} return true to not be executed again, but does not provide an id. the script function needs to have the field "id" to be set`
-					);
-				}
-				internal.recordMigration(deployScript.func.id);
-			}
-		}
-	}
-
-	if (resolvedExecutionParams.reportGasUse) {
-		const provider = external.network.provider;
-		const transactionHashes = provider.transactionHashes;
-
-		let totalGasUsed = 0;
-		for (const hash of transactionHashes) {
-			const transactionReceipt = await provider.request({method: 'eth_getTransactionReceipt', params: [hash]});
-			if (transactionReceipt) {
-				const gasUsed = Number(transactionReceipt.gasUsed);
-				totalGasUsed += gasUsed;
-			}
-		}
-
-		console.log({totalGasUsed});
-	}
-
-	return external;
 }

package/src/index.ts

@@ -1,17 +1,16 @@
 export {
-	setup,
-	loadAndExecuteDeployments,
-	executeDeployScripts,
-	readAndResolveConfig,
+	executeDeployScripts, // TODO rename ...FromFiles
+	setupEnvironmentFromFiles, // TODO rename ...FromFiles
 	enhanceEnvIfNeeded,
-	loadEnvironment,
+	loadEnvironment, // TODO rename loadEnvironmentFromFiles
+	readAndResolveConfig, // TODO rename ...FromFiles
+	loadAndExecuteDeployments, // TODO rename ...FromFiles
+	setup, // TODO remove, we use split setup to make it explicity which require file system access
+	loadDeploymentsFromFiles,
 } from './executor/index.js';
 
-export {getChainConfig, chainByCanonicalName} from './environment/utils/chains.js';
-export * from './types.js';
-export {loadDeployments} from './environment/deployments.js';
-export {mergeArtifacts, mergeABIs} from './environment/utils/artifacts.js';
-export {getGasPriceEstimate, getRoughGasPriceEstimate} from './utils/eth.js';
-export {bigIntToStringReplacer} from './utils/json.js';
+export {setupDeployScripts, chainByCanonicalName} from '@rocketh/core';
+
+export type * from '@rocketh/core/types';
 
 export type * from 'eip-1193';