rocketh 0.15.0-testing.16 → 0.15.0-testing.2

package/src/executor/index.ts

@@ -5,27 +5,29 @@ import prompts from 'prompts';
 import {tsImport as tsImport_} from 'tsx/esm/api';
 import {formatEther} from 'viem';
 import type {
+	Config,
 	Environment,
-	ExecutionParams,
-	ResolvedExecutionParams,
+	JSONTypePlusBigInt,
+	ResolvedConfig,
+	TargetConfig,
 	UnknownDeployments,
 	UnresolvedNetworkSpecificData,
 	UnresolvedUnknownNamedAccounts,
+} from '../environment/types.js';
+import {createEnvironment, SignerProtocolFunction} from '../environment/index.js';
+import {
+	ChainInfo,
+	DeployScriptFunction,
 	DeployScriptModule,
 	EnhancedDeployScriptFunction,
 	EnhancedEnvironment,
-	ResolvedUserConfig,
-	ConfigOverrides,
-	UserConfig,
-	ChainConfig,
-} from '../types.js';
+} from './types.js';
 import {withEnvironment} from '../utils/extensions.js';
 import {logger, setLogLevel, spin} from '../internal/logging.js';
 import {getRoughGasPriceEstimate} from '../utils/eth.js';
 import {traverseMultipleDirectory} from '../utils/fs.js';
-import {getChainByName, getChainConfig} from '../environment/utils/chains.js';
+import {getChain, getChainByName} 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));
@@ -90,21 +92,18 @@ export function setup<
 		return scriptModule;
 	}
 
-	async function loadAndExecuteDeploymentsWithExtensions<
-		Extra extends Record<string, unknown> = Record<string, unknown>,
-		ArgumentsType = undefined
-	>(
-		executionParams: ExecutionParams<Extra>,
+	async function loadAndExecuteDeploymentsWithExtensions<ArgumentsType = undefined>(
+		options: ConfigOptions<Extra>,
 		args?: ArgumentsType
 	): Promise<EnhancedEnvironment<NamedAccounts, Data, UnknownDeployments, Extensions>> {
-		const env = await loadAndExecuteDeployments<NamedAccounts, Data, ArgumentsType, Extra>(executionParams, args);
+		const env = await loadAndExecuteDeployments<NamedAccounts, Data, ArgumentsType, Extra>(options, args);
 		return enhanceEnvIfNeeded(env, extensions);
 	}
 
 	async function loadEnvironmentWithExtensions(
-		executionParams: ExecutionParams<Extra>
+		options: ConfigOptions<Extra>
 	): Promise<EnhancedEnvironment<NamedAccounts, Data, UnknownDeployments, Extensions>> {
-		const env = await loadEnvironment<NamedAccounts, Data, Extra>(executionParams);
+		const env = await loadEnvironment<NamedAccounts, Data, Extra>(options);
 		return enhanceEnvIfNeeded(env, extensions);
 	}
 
@@ -140,10 +139,253 @@ export function enhanceEnvIfNeeded<
 	return enhancedEnv;
 }
 
-export async function readConfig<
+export type NamedAccountExecuteFunction<
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
->(): Promise<UserConfig> {
+> = <ArgumentsType = undefined, Deployments extends UnknownDeployments = UnknownDeployments>(
+	callback: DeployScriptFunction<NamedAccounts, Data, ArgumentsType, Deployments>,
+	options: {tags?: string[]; dependencies?: string[]; id?: string}
+) => DeployScriptModule<NamedAccounts, Data, ArgumentsType, Deployments>;
+
+export interface UntypedRequestArguments {
+	readonly method: string;
+	readonly params?: readonly unknown[] | object;
+}
+export type UntypedEIP1193Provider = {
+	request(requestArguments: UntypedRequestArguments): Promise<unknown>;
+};
+
+export type ConfigOptions<Extra extends Record<string, unknown> = Record<string, unknown>> = {
+	target?: string | {fork: string};
+	deployments?: string;
+	scripts?: string | string[];
+	tags?: string;
+	logLevel?: number;
+	provider?: EIP1193ProviderWithoutEvents | EIP1193GenericRequestProvider | UntypedEIP1193Provider;
+	ignoreMissingRPC?: boolean;
+	saveDeployments?: boolean;
+	askBeforeProceeding?: boolean;
+	reportGasUse?: boolean;
+	extra?: Extra;
+};
+
+export type Create2DeterministicDeploymentInfo = {
+	factory: `0x${string}`;
+	deployer: `0x${string}`;
+	funding: string;
+	signedTx: `0x${string}`;
+};
+
+export type Create3DeterministicDeploymentInfo = {
+	salt?: `0x${string}`;
+	factory: `0x${string}`;
+	bytecode: `0x${string}`;
+	proxyBytecode: `0x${string}`;
+};
+
+export type DeterministicDeploymentInfo =
+	| Create2DeterministicDeploymentInfo
+	| {
+			create2?: Create2DeterministicDeploymentInfo;
+			create3?: Create3DeterministicDeploymentInfo;
+	  };
+
+export type ChainUserConfig = {
+	rpcUrl?: string;
+	tags?: string[];
+	deterministicDeployment?: DeterministicDeploymentInfo;
+	info?: ChainInfo;
+	pollingInterval?: number;
+	properties?: Record<string, JSONTypePlusBigInt>;
+};
+
+export type DeploymentTargetConfig = {
+	chainId: number;
+	scripts?: string | string[];
+	overrides: Omit<ChainUserConfig, 'info'>;
+};
+
+export type Chains = {
+	[idOrName: number | string]: ChainUserConfig;
+};
+export type UserConfig<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
+> = {
+	targets: {[name: string]: DeploymentTargetConfig};
+	chains?: Chains;
+	deployments?: string;
+	scripts?: string | string[];
+	accounts?: NamedAccounts;
+	data?: Data;
+	signerProtocols?: Record<string, SignerProtocolFunction>;
+	defaultPollingInterval?: number;
+};
+
+export async function transformUserConfig<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
+	Extra extends Record<string, unknown> = Record<string, unknown>
+>(
+	configFile: UserConfig<NamedAccounts, Data> | undefined,
+	options: ConfigOptions<Extra>
+): Promise<Config<NamedAccounts, Data>> {
+	if (configFile) {
+		if (!options.deployments && configFile.deployments) {
+			options.deployments = configFile.deployments;
+		}
+		if (!options.scripts && configFile.scripts) {
+			options.scripts = configFile.scripts;
+		}
+	}
+
+	const targetProvided = options.target || (options as any).network; // fallback on network
+	const fork = typeof targetProvided !== 'string';
+	let targetName = 'memory';
+	if (options.target) {
+		if (typeof options.target === 'string') {
+			targetName = options.target;
+		} else if ('fork' in options.target) {
+			targetName = options.target.fork;
+		}
+	}
+
+	let chainInfo: ChainInfo;
+
+	let chainId: number;
+
+	if (configFile?.targets?.[targetName]) {
+		chainId = configFile.targets[targetName].chainId;
+	} else {
+		const chainFound = getChainByName(targetName);
+		if (chainFound) {
+			chainInfo = chainFound;
+			chainId = chainInfo.id;
+		} else {
+			if (options.provider) {
+				const chainIdAsHex = await (options.provider as EIP1193ProviderWithoutEvents).request({method: 'eth_chainId'});
+				chainId = Number(chainIdAsHex);
+			} else {
+				throw new Error(`target ${targetName} is unknown`);
+			}
+		}
+	}
+
+	const chainConfigFromChainId = configFile?.chains?.[chainId];
+	const chainConfigFromChainName = configFile?.chains?.[targetName];
+	if (chainConfigFromChainId && chainConfigFromChainName) {
+		throw new Error(
+			`conflicting config for chain, choose to configure via its chainId (${chainId}) or via its name ${targetName} but not both`
+		);
+	}
+	const chainConfig = chainConfigFromChainId || chainConfigFromChainName;
+
+	const targetConfig = configFile?.targets?.[targetName];
+	const actualChainConfig = targetConfig?.overrides
+		? {
+				...chainConfig,
+				...targetConfig.overrides,
+				properties: {
+					...chainConfig?.properties,
+					...targetConfig.overrides.properties,
+				},
+		  }
+		: chainConfig;
+
+	const defaultTags: string[] = [];
+
+	const chainFound = actualChainConfig?.info || getChain(chainId);
+	if (chainFound) {
+		chainInfo = chainFound;
+	} else {
+		throw new Error(`chain with id ${chainId} has no chainInfo associated with it`);
+	}
+	if (chainInfo.testnet) {
+		defaultTags.push('testnet');
+	}
+
+	let targetTags: string[] = actualChainConfig?.tags || defaultTags;
+
+	let networkScripts: string | string[] | undefined = targetConfig?.scripts;
+
+	// no default for publicInfo
+	const defaultPollingInterval = configFile?.defaultPollingInterval;
+	const pollingInterval = actualChainConfig?.pollingInterval;
+	const deterministicDeployment = actualChainConfig?.deterministicDeployment;
+	const properties = actualChainConfig?.properties;
+
+	let resolvedTargetConfig: TargetConfig;
+
+	if (!options.provider) {
+		let rpcURL = actualChainConfig?.rpcUrl;
+		if (!rpcURL) {
+			rpcURL = chainInfo.rpcUrls.default.http[0];
+		}
+
+		const fromEnv = process.env['ETH_NODE_URI_' + targetName];
+		let nodeUrl: string;
+		if (typeof fromEnv === 'string' && fromEnv) {
+			nodeUrl = fromEnv;
+		} else {
+			if (rpcURL) {
+				nodeUrl = rpcURL;
+			} else if (options?.ignoreMissingRPC) {
+				nodeUrl = '';
+			} else if (options.target === 'localhost') {
+				nodeUrl = 'http://127.0.0.1:8545';
+			} else {
+				console.error(`network "${options.target}" is not configured. Please add it to the rocketh.js/ts file`);
+				process.exit(1);
+			}
+		}
+
+		resolvedTargetConfig = {
+			nodeUrl,
+			name: targetName,
+			tags: targetTags,
+			fork,
+			deterministicDeployment,
+			scripts: networkScripts,
+			chainInfo,
+			pollingInterval,
+			properties,
+		};
+	} else {
+		resolvedTargetConfig = {
+			provider: options.provider as EIP1193ProviderWithoutEvents,
+			name: targetName,
+			tags: targetTags,
+			fork,
+			deterministicDeployment,
+			scripts: networkScripts,
+			chainInfo,
+			pollingInterval,
+			properties,
+		};
+	}
+
+	return {
+		target: resolvedTargetConfig,
+		deployments: options.deployments,
+		saveDeployments: options.saveDeployments,
+		scripts: options.scripts,
+		data: configFile?.data,
+		tags: typeof options.tags === 'undefined' ? undefined : options.tags.split(','),
+		logLevel: options.logLevel,
+		askBeforeProceeding: options.askBeforeProceeding,
+		reportGasUse: options.reportGasUse,
+		accounts: configFile?.accounts,
+		signerProtocols: configFile?.signerProtocols,
+		extra: options.extra,
+		defaultPollingInterval,
+	};
+}
+
+export async function readConfig<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
+	Extra extends Record<string, unknown> = Record<string, unknown>
+>(options: ConfigOptions<Extra>): Promise<Config<NamedAccounts, Data>> {
 	type ConfigFile = UserConfig<NamedAccounts, Data>;
 	let configFile: ConfigFile | undefined;
 
@@ -182,192 +424,101 @@ export async function readConfig<
 		configFile = moduleLoaded.config;
 	}
 
-	return configFile || {};
+	return transformUserConfig(configFile, options);
 }
 
-export function resolveConfig<
+export async function readAndResolveConfig<
 	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;
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
+	Extra extends Record<string, unknown> = Record<string, unknown>
+>(options: ConfigOptions<Extra>): Promise<ResolvedConfig<NamedAccounts, Data>> {
+	return resolveConfig<NamedAccounts, Data>(await readConfig<NamedAccounts, Data>(options));
 }
 
-export async function readAndResolveConfig<
+export function resolveConfig<
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
->(overrides?: ConfigOverrides): Promise<ResolvedUserConfig<NamedAccounts, Data>> {
-	const configFile = await readConfig();
-	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;
+>(config: Config<NamedAccounts, Data>): ResolvedConfig<NamedAccounts, Data> {
+	const create2Info = {
+		factory: '0x4e59b44847b379578588920ca78fbf26c0b4956c',
+		deployer: '0x3fab184622dc19b6109349b94811493bf2a45362',
+		funding: '10000000000000000',
+		signedTx:
+			'0xf8a58085174876e800830186a08080b853604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf31ba02222222222222222222222222222222222222222222222222222222222222222a02222222222222222222222222222222222222222222222222222222222222222',
+	} as const;
+	const create3Info = {
+		factory: '0x000000000004d4f168daE7DB3C610F408eE22F57',
+		salt: '0x5361109ca02853ca8e22046b7125306d9ec4ae4cdecc393c567b6be861df3db6',
+		bytecode:
+			'0x6080604052348015600f57600080fd5b506103ca8061001f6000396000f3fe6080604052600436106100295760003560e01c8063360d0fad1461002e5780639881d19514610077575b600080fd5b34801561003a57600080fd5b5061004e610049366004610228565b61008a565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b61004e61008536600461029c565b6100ee565b6040517fffffffffffffffffffffffffffffffffffffffff000000000000000000000000606084901b166020820152603481018290526000906054016040516020818303038152906040528051906020012091506100e78261014c565b9392505050565b6040517fffffffffffffffffffffffffffffffffffffffff0000000000000000000000003360601b166020820152603481018290526000906054016040516020818303038152906040528051906020012091506100e734848461015e565b600061015882306101ce565b92915050565b60006f67363d3d37363d34f03d5260086018f3600052816010806000f58061018e5763301164256000526004601cfd5b8060145261d69460005260016034536017601e20915060008085516020870188855af1823b026101c65763301164256000526004601cfd5b509392505050565b60006040518260005260ff600b53836020527f21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f6040526055600b20601452806040525061d694600052600160345350506017601e20919050565b6000806040838503121561023b57600080fd5b823573ffffffffffffffffffffffffffffffffffffffff8116811461025f57600080fd5b946020939093013593505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080604083850312156102af57600080fd5b823567ffffffffffffffff8111156102c657600080fd5b8301601f810185136102d757600080fd5b803567ffffffffffffffff8111156102f1576102f161026d565b6040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0603f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f8501160116810181811067ffffffffffffffff8211171561035d5761035d61026d565b60405281815282820160200187101561037557600080fd5b816020840160208301376000602092820183015296940135945050505056fea264697066735822122059dcc5dc6453397d13ff28021e28472a80a45bbd97f3135f69bd2650773aeb0164736f6c634300081a0033',
+		proxyBytecode: '0x67363d3d37363d34f03d5260086018f3',
+	} as const;
+
+	const defaultPollingInterval = config.defaultPollingInterval || 1;
+	const networkPollingInterval = config.target.pollingInterval || defaultPollingInterval;
+
+	let deterministicDeployment: {
+		create2: Create2DeterministicDeploymentInfo;
+		create3: Create3DeterministicDeploymentInfo;
+	} = {
+		create2: (() => {
+			if (!config.target.deterministicDeployment) return create2Info;
+			if (
+				!('create3' in config.target.deterministicDeployment) &&
+				!('create2' in config.target.deterministicDeployment)
+			)
+				return create2Info;
+			return config.target.deterministicDeployment.create2 || create2Info;
+		})(),
+		create3:
+			config.target.deterministicDeployment &&
+			'create3' in config.target.deterministicDeployment &&
+			config.target.deterministicDeployment.create3
+				? config.target.deterministicDeployment.create3
+				: create3Info,
+	};
 
 	let scripts = ['deploy'];
 	if (config.scripts) {
 		if (typeof config.scripts === 'string') {
 			scripts = [config.scripts];
 		} else {
-			scripts = [...config.scripts];
+			scripts = config.scripts;
 		}
 	}
 
-	if (environmentConfig?.scripts) {
-		if (typeof environmentConfig.scripts === 'string') {
-			scripts = [environmentConfig.scripts];
+	if (config.target.scripts) {
+		if (typeof config.target.scripts === 'string') {
+			scripts = [config.target.scripts];
 		} else {
-			scripts = [...environmentConfig.scripts];
+			scripts = config.target.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;
-			}
-		}
-	}
-
-	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,
+	const resolvedConfig: ResolvedConfig<NamedAccounts, Data> = {
+		...config,
+		target: {...config.target, deterministicDeployment, pollingInterval: networkPollingInterval},
+		deployments: config.deployments || 'deployments',
 		scripts,
+		tags: config.tags || [],
+		targetTags: config.targetTags || [],
+		saveDeployments: config.saveDeployments,
+		accounts: config.accounts || ({} as NamedAccounts),
+		data: config.data || ({} as Data),
+		signerProtocols: config.signerProtocols || {},
+		extra: config.extra || {},
+		defaultPollingInterval,
 	};
+	return resolvedConfig;
 }
 
 export async function loadEnvironment<
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
 	Extra extends Record<string, unknown> = Record<string, unknown>
->(executionParams: ExecutionParams<Extra>): Promise<Environment<NamedAccounts, Data, UnknownDeployments>> {
-	const userConfig = await readAndResolveConfig<NamedAccounts, Data>(executionParams.config);
-	const {name: environmentName, fork} = getEnvironmentName(executionParams);
-	const chainId = await getChainIdForEnvironment(userConfig, environmentName, executionParams.provider);
-	const resolvedExecutionParams = resolveExecutionParams(userConfig, executionParams, chainId);
+>(options: ConfigOptions<Extra>): Promise<Environment<NamedAccounts, Data, UnknownDeployments>> {
+	const resolvedConfig = await readAndResolveConfig<NamedAccounts, Data>(options);
 	// console.log(JSON.stringify(resolvedConfig, null, 2));
-	const {external, internal} = await createEnvironment<NamedAccounts, Data, UnknownDeployments>(
-		userConfig,
-		resolvedExecutionParams
-	);
+	const {external, internal} = await createEnvironment(resolvedConfig);
 	return external;
 }
 
@@ -376,35 +527,11 @@ export async function loadAndExecuteDeployments<
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
 	ArgumentsType = undefined,
 	Extra extends Record<string, unknown> = Record<string, unknown>
->(
-	executionParams: ExecutionParams<Extra>,
-	args?: ArgumentsType
-): Promise<Environment<NamedAccounts, Data, UnknownDeployments>> {
-	const userConfig = await readAndResolveConfig<NamedAccounts, Data>(executionParams.config);
-	const {name: environmentName, fork} = getEnvironmentName(executionParams);
-	const chainId = await getChainIdForEnvironment(userConfig, environmentName, executionParams.provider);
-	const resolvedExecutionParams = resolveExecutionParams(userConfig, executionParams, chainId);
+>(options: ConfigOptions<Extra>, args?: ArgumentsType): Promise<Environment<NamedAccounts, Data, UnknownDeployments>> {
+	const resolvedConfig = await readAndResolveConfig<NamedAccounts, Data>(options);
 	// console.log(JSON.stringify(options, null, 2));
 	// console.log(JSON.stringify(resolvedConfig, null, 2));
-	return executeDeployScripts<NamedAccounts, Data, ArgumentsType>(userConfig, resolvedExecutionParams, args);
-}
-
-export async function executeDeployScriptsDirectly<
-	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
-	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
-	ArgumentsType = undefined,
-	Extra extends Record<string, unknown> = Record<string, unknown>
->(
-	userConfig: UserConfig,
-	executionParams?: ExecutionParams<Extra>,
-	args?: ArgumentsType
-): Promise<Environment<NamedAccounts, Data, UnknownDeployments>> {
-	executionParams = executionParams || {};
-	const resolveduserConfig = resolveConfig<NamedAccounts, Data>(userConfig, executionParams.config);
-	const {name: environmentName, fork} = getEnvironmentName(executionParams);
-	const chainId = await getChainIdForEnvironment(resolveduserConfig, environmentName, executionParams.provider);
-	const resolvedExecutionParams = resolveExecutionParams(resolveduserConfig, executionParams, chainId);
-	return executeDeployScripts<NamedAccounts, Data, ArgumentsType>(resolveduserConfig, resolvedExecutionParams, args);
+	return executeDeployScripts<NamedAccounts, Data, ArgumentsType>(resolvedConfig, args);
 }
 
 export async function executeDeployScripts<
@@ -412,14 +539,13 @@ export async function executeDeployScripts<
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
 	ArgumentsType = undefined
 >(
-	userConfig: ResolvedUserConfig<NamedAccounts, Data>,
-	resolvedExecutionParams: ResolvedExecutionParams,
+	config: ResolvedConfig<NamedAccounts, Data>,
 	args?: ArgumentsType
 ): Promise<Environment<NamedAccounts, Data, UnknownDeployments>> {
-	setLogLevel(typeof resolvedExecutionParams.logLevel === 'undefined' ? 0 : resolvedExecutionParams.logLevel);
+	setLogLevel(typeof config.logLevel === 'undefined' ? 0 : config.logLevel);
 
 	let filepaths;
-	filepaths = traverseMultipleDirectory(resolvedExecutionParams.scripts);
+	filepaths = traverseMultipleDirectory(config.scripts);
 	filepaths = filepaths
 		.filter((v) => !path.basename(v).startsWith('_'))
 		.sort((a: string, b: string) => {
@@ -474,10 +600,10 @@ export async function executeDeployScripts<
 			}
 		}
 
-		if (resolvedExecutionParams.tags !== undefined && resolvedExecutionParams.tags.length > 0) {
+		if (config.tags !== undefined && config.tags.length > 0) {
 			let found = false;
 			if (scriptTags !== undefined) {
-				for (const tagToFind of resolvedExecutionParams.tags) {
+				for (const tagToFind of config.tags) {
 					for (const tag of scriptTags) {
 						if (tag === tagToFind) {
 							scriptFilePaths.push(scriptFilePath);
@@ -495,10 +621,7 @@ export async function executeDeployScripts<
 		}
 	}
 
-	const {internal, external} = await createEnvironment<NamedAccounts, Data, UnknownDeployments>(
-		userConfig,
-		resolvedExecutionParams
-	);
+	const {internal, external} = await createEnvironment(config);
 
 	await internal.recoverTransactionsIfAny();
 
@@ -545,10 +668,10 @@ export async function executeDeployScripts<
 		recurseDependencies(scriptFilePath);
 	}
 
-	if (resolvedExecutionParams.askBeforeProceeding) {
+	if (config.askBeforeProceeding) {
 		console.log(
-			`Network: ${external.name} \n \t Chain: ${external.network.chain.name} \n \t Tags: ${Object.keys(
-				external.tags
+			`Network: ${external.network.name} \n \t Chain: ${external.network.chain.name} \n \t Tags: ${Object.keys(
+				external.network.tags
 			).join(',')}`
 		);
 		const gasPriceEstimate = await getRoughGasPriceEstimate(external.network.provider);
@@ -614,7 +737,7 @@ Do you want to proceed (note that gas price can change for each tx)`,
 		}
 	}
 
-	if (resolvedExecutionParams.reportGasUse) {
+	if (config.reportGasUse) {
 		const provider = external.network.provider;
 		const transactionHashes = provider.transactionHashes;