rocketh 0.15.0-testing.9 → 0.15.1

package/src/executor/index.ts

@@ -221,15 +221,27 @@ export async function readAndResolveConfig<
 	return resolveConfig(configFile, overrides);
 }
 
-export async function getChainIdForTarget(
+export async function getChainIdForEnvironment(
 	config: ResolvedUserConfig,
-	targetName: string,
+	environmentName: string,
 	provider?: EIP1193ProviderWithoutEvents
 ) {
-	if (config?.targets?.[targetName]?.chainId) {
-		return config.targets[targetName].chainId;
+	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(targetName);
+		const chainFound = getChainByName(environmentName);
 		if (chainFound) {
 			return chainFound.id;
 		} else {
@@ -237,24 +249,24 @@ export async function getChainIdForTarget(
 				const chainIdAsHex = await provider.request({method: 'eth_chainId'});
 				return Number(chainIdAsHex);
 			} else {
-				throw new Error(`target ${targetName} chain id cannot be found, specify it in the rocketh config`);
+				throw new Error(`environment ${environmentName} chain id cannot be found, specify it in the rocketh config`);
 			}
 		}
 	}
 }
 
-function getTargetName(executionParams: ExecutionParams): {name: string; fork: boolean} {
-	const targetProvided = executionParams.target || (executionParams as any).network;
-	let targetName = 'memory';
-	if (targetProvided) {
-		if (typeof targetProvided === 'string') {
-			targetName = targetProvided;
-		} else if ('fork' in targetProvided) {
-			targetName = targetProvided.fork;
+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 targetProvided !== 'string';
-	return {name: targetName, fork};
+	const fork = typeof environmentProvided !== 'string';
+	return {name: environmentName, fork};
 }
 
 export function resolveExecutionParams<Extra extends Record<string, unknown> = Record<string, unknown>>(
@@ -262,19 +274,20 @@ export function resolveExecutionParams<Extra extends Record<string, unknown> = R
 	executionParameters: ExecutionParams<Extra>,
 	chainId: number
 ): ResolvedExecutionParams<Extra> {
-	const {name: targetName, fork} = getTargetName(executionParameters);
+	const {name: environmentName, fork} = getEnvironmentName(executionParameters);
 
-	let chainConfig: ChainConfig = getChainConfig(chainId, config);
+	// TODO fork chainId resolution option to keep the network being used
+	let chainConfig: ChainConfig = getChainConfig(fork ? 31337 : chainId, config);
 
 	let chainInfo = chainConfig.info;
-	const targetConfig = config?.targets?.[targetName];
-	const actualChainConfig = targetConfig?.overrides
+	const environmentConfig = config?.environments?.[environmentName];
+	const actualChainConfig = environmentConfig?.overrides
 		? {
 				...chainConfig,
-				...targetConfig.overrides,
+				...environmentConfig.overrides,
 				properties: {
 					...chainConfig?.properties,
-					...targetConfig.overrides.properties,
+					...environmentConfig.overrides.properties,
 				},
 		  }
 		: chainConfig;
@@ -283,23 +296,23 @@ export function resolveExecutionParams<Extra extends Record<string, unknown> = R
 		chainInfo = {...chainInfo, properties: actualChainConfig.properties};
 	}
 
-	// let targetTags: string[] = actualChainConfig.tags.concat(targetConfig?.tags); // TODO
-	const targetTags = actualChainConfig.tags;
+	// 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;
+			scripts = [...config.scripts];
 		}
 	}
 
-	if (targetConfig?.scripts) {
-		if (typeof targetConfig.scripts === 'string') {
-			scripts = [targetConfig.scripts];
+	if (environmentConfig?.scripts) {
+		if (typeof environmentConfig.scripts === 'string') {
+			scripts = [environmentConfig.scripts];
 		} else {
-			scripts = targetConfig.scripts;
+			scripts = [...environmentConfig.scripts];
 		}
 	}
 
@@ -312,7 +325,7 @@ export function resolveExecutionParams<Extra extends Record<string, unknown> = R
 		if (!executionParameters.provider) {
 			saveDeployments = true;
 		} else {
-			if (targetName === 'memory' || targetName === 'hardhat' || targetName === 'default') {
+			if (environmentName === 'memory' || environmentName === 'hardhat' || environmentName === 'default') {
 				// networkTags['memory'] = true;
 				saveDeployments = false;
 			} else {
@@ -329,9 +342,9 @@ export function resolveExecutionParams<Extra extends Record<string, unknown> = R
 		reportGasUse: executionParameters.reportGasUse || false,
 		saveDeployments,
 		tags: executionParameters.tags || [],
-		target: {
-			name: targetName,
-			tags: targetTags,
+		environment: {
+			name: environmentName,
+			tags: environmentTags,
 			fork,
 			deterministicDeployment: actualChainConfig.deterministicDeployment,
 		},
@@ -347,8 +360,8 @@ export async function loadEnvironment<
 	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: targetName, fork} = getTargetName(executionParams);
-	const chainId = await getChainIdForTarget(userConfig, targetName, executionParams.provider);
+	const {name: environmentName, fork} = getEnvironmentName(executionParams);
+	const chainId = await getChainIdForEnvironment(userConfig, environmentName, executionParams.provider);
 	const resolvedExecutionParams = resolveExecutionParams(userConfig, executionParams, chainId);
 	// console.log(JSON.stringify(resolvedConfig, null, 2));
 	const {external, internal} = await createEnvironment<NamedAccounts, Data, UnknownDeployments>(
@@ -368,15 +381,15 @@ export async function loadAndExecuteDeployments<
 	args?: ArgumentsType
 ): Promise<Environment<NamedAccounts, Data, UnknownDeployments>> {
 	const userConfig = await readAndResolveConfig<NamedAccounts, Data>(executionParams.config);
-	const {name: targetName, fork} = getTargetName(executionParams);
-	const chainId = await getChainIdForTarget(userConfig, targetName, executionParams.provider);
+	const {name: environmentName, fork} = getEnvironmentName(executionParams);
+	const chainId = await getChainIdForEnvironment(userConfig, environmentName, executionParams.provider);
 	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);
+	return _executeDeployScripts<NamedAccounts, Data, ArgumentsType>(userConfig, resolvedExecutionParams, args);
 }
 
-export async function executeDeployScriptsDirectly<
+export async function executeDeployScripts<
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
 	ArgumentsType = undefined,
@@ -387,14 +400,14 @@ export async function executeDeployScriptsDirectly<
 	args?: ArgumentsType
 ): Promise<Environment<NamedAccounts, Data, UnknownDeployments>> {
 	executionParams = executionParams || {};
-	const resolveduserConfig = resolveConfig<NamedAccounts, Data>(userConfig);
-	const {name: targetName, fork} = getTargetName(executionParams);
-	const chainId = await getChainIdForTarget(resolveduserConfig, targetName, executionParams.provider);
+	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>(resolveduserConfig, resolvedExecutionParams, args);
 }
 
-export async function executeDeployScripts<
+async function _executeDeployScripts<
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
 	ArgumentsType = undefined

package/src/executor/setup.test.ts

@@ -134,7 +134,7 @@ export const exampleUsage = () => {
 			await env.verifyOnEtherscan(tokenAddress, ['MyToken', 'MTK']);
 
 			// Original environment is still fully accessible
-			console.log(`Deployed on target: ${env.name}`);
+			console.log(`Deployed on environment: ${env.name}`);
 			const deployment = env.get('MyToken');
 
 			return true;

package/src/index.ts

@@ -1,14 +1,15 @@
 export {
 	setup,
 	loadAndExecuteDeployments,
-	executeDeployScriptsDirectly,
+	executeDeployScripts,
 	readAndResolveConfig,
 	enhanceEnvIfNeeded,
 	loadEnvironment,
 } from './executor/index.js';
 
-export {getChainConfig} from './environment/utils/chains.js';
+export {getChainConfig, chainByCanonicalName} from './environment/utils/chains.js';
 export * from './types.js';
 export {loadDeployments} from './environment/deployments.js';
 export {mergeArtifacts} from './environment/utils/artifacts.js';
 export {getGasPriceEstimate, getRoughGasPriceEstimate} from './utils/eth.js';
+export {bigIntToStringReplacer} from './utils/json.js';

package/src/types.ts

@@ -158,7 +158,7 @@ export type ChainInfo = {
 	/** Flag for test networks */
 	testnet?: boolean | undefined;
 
-	chainType: 'zksync' | 'op-stack' | 'celo' | 'default';
+	chainType?: 'zksync' | 'op-stack' | 'celo' | 'default';
 
 	genesisHash?: string;
 
@@ -223,31 +223,31 @@ export type DeterministicDeploymentInfo =
 	  };
 
 export type ChainUserConfig = {
-	rpcUrl?: string;
-	tags?: string[];
-	deterministicDeployment?: DeterministicDeploymentInfo;
-	info?: ChainInfo;
-	pollingInterval?: number;
-	properties?: Record<string, JSONTypePlusBigInt>;
+	readonly rpcUrl?: string;
+	readonly tags?: readonly string[];
+	readonly deterministicDeployment?: DeterministicDeploymentInfo;
+	readonly info?: ChainInfo;
+	readonly pollingInterval?: number;
+	readonly properties?: Record<string, JSONTypePlusBigInt>;
 };
 
 export type ChainConfig = {
-	rpcUrl: string;
-	tags: string[];
-	deterministicDeployment: DeterministicDeploymentInfo;
-	info: ChainInfo;
-	pollingInterval: number;
-	properties: Record<string, JSONTypePlusBigInt>;
+	readonly rpcUrl: string;
+	readonly tags: readonly string[];
+	readonly deterministicDeployment: DeterministicDeploymentInfo;
+	readonly info: ChainInfo;
+	readonly pollingInterval: number;
+	readonly properties: Record<string, JSONTypePlusBigInt>;
 };
 
-export type DeploymentTargetConfig = {
-	chainId: number;
-	scripts?: string | string[];
-	overrides: Omit<ChainUserConfig, 'info'>;
+export type DeploymentEnvironmentConfig = {
+	readonly chain?: string | number;
+	readonly scripts?: string | readonly string[];
+	readonly overrides?: Omit<ChainUserConfig, 'info'>;
 };
 
 export type Chains = {
-	[idOrName: number | string]: ChainUserConfig;
+	readonly [idOrName: number | string]: ChainUserConfig;
 };
 
 export type SignerProtocolFunction = (protocolString: string) => Promise<Signer>;
@@ -259,27 +259,27 @@ 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;
+	readonly environments?: {readonly [name: string]: DeploymentEnvironmentConfig};
+	readonly chains?: Chains;
+	readonly deployments?: string;
+	readonly scripts?: string | readonly string[];
+	readonly accounts?: NamedAccounts;
+	readonly data?: Data;
+	readonly signerProtocols?: Record<string, SignerProtocolFunction>;
+	readonly defaultPollingInterval?: number;
 };
 
 export type ResolvedUserConfig<
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
 > = UserConfig & {
-	deployments: string;
-	scripts: string[];
-	defaultPollingInterval: number;
+	readonly deployments: string;
+	readonly scripts: readonly string[];
+	readonly defaultPollingInterval: number;
 };
 
 export type ExecutionParams<Extra extends Record<string, unknown> = Record<string, unknown>> = {
-	target?: string | {fork: string};
+	environment?: string | {fork: string};
 	tags?: string[];
 	saveDeployments?: boolean;
 	askBeforeProceeding?: boolean;
@@ -504,7 +504,7 @@ export type ResolvedNamedSigners<T extends UnknownNamedAccounts> = {
 export type UnknownDeploymentsAcrossNetworks = Record<string, UnknownDeployments>;
 
 export type ResolvedExecutionParams<Extra extends Record<string, unknown> = Record<string, unknown>> = {
-	readonly target: {
+	readonly environment: {
 		readonly name: string;
 		readonly tags: readonly string[];
 		readonly fork?: boolean;
@@ -529,6 +529,9 @@ export interface Environment<
 	Extra extends Record<string, unknown> = Record<string, unknown>
 > {
 	readonly name: string;
+	readonly context: {
+		readonly saveDeployments: boolean;
+	};
 	readonly tags: {readonly [tag: string]: boolean};
 	readonly network: {
 		readonly chain: Chain;