rocketh 0.15.0-testing.6 → 0.15.0-testing.7

package/src/environment/index.ts

@@ -9,7 +9,6 @@ import {
 	PendingDeployment,
 	PendingTransaction,
 	ResolvedAccount,
-	ResolvedConfig,
 	ResolvedNamedAccounts,
 	ResolvedNamedSigners,
 	UnknownDeployments,
@@ -17,8 +16,8 @@ import {
 	UnresolvedNetworkSpecificData,
 	ResolvedNetworkSpecificData,
 	DataType,
+	ResolvedExecutionParams,
 } from './types.js';
-import {JSONRPCHTTPProvider} from 'eip-1193-jsonrpc-provider';
 import {Abi, Address} from 'abitype';
 import {InternalEnvironment} from '../internal/types.js';
 import path from 'node:path';
@@ -29,16 +28,14 @@ import {
 	EIP1193Block,
 	EIP1193BlockWithTransactions,
 	EIP1193DATA,
-	EIP1193ProviderWithoutEvents,
-	EIP1193QUANTITY,
 	EIP1193Transaction,
 	EIP1193TransactionReceipt,
 } from 'eip-1193';
 import {ProgressIndicator, log, spin} from '../internal/logging.js';
 import {PendingExecution} from './types.js';
-import {getChainWithConfig} from './utils/chains.js';
 import {mergeArtifacts} from './utils/artifacts.js';
 import {TransactionHashTracker, TransactionHashTrackerProvider} from './providers/TransactionHashTracker.js';
+import {ResolvedUserConfig} from '../executor/index.js';
 
 export type SignerProtocolFunction = (protocolString: string) => Promise<Signer>;
 export type SignerProtocol = {
@@ -66,12 +63,10 @@ export async function createEnvironment<
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
 	Deployments extends UnknownDeployments = UnknownDeployments
 >(
-	config: ResolvedConfig<NamedAccounts, Data>
+	userConfig: ResolvedUserConfig<NamedAccounts, Data>,
+	resolvedExecutionParams: ResolvedExecutionParams
 ): Promise<{internal: InternalEnvironment; external: Environment<NamedAccounts, Data, Deployments>}> {
-	const rawProvider =
-		'provider' in config.target
-			? config.target.provider
-			: (new JSONRPCHTTPProvider(config.target.nodeUrl) as EIP1193ProviderWithoutEvents);
+	const rawProvider = resolvedExecutionParams.provider;
 
 	const provider: TransactionHashTracker = new TransactionHashTrackerProvider(rawProvider);
 
@@ -95,34 +90,14 @@ export async function createEnvironment<
 		console.error(`failed to get genesis block`);
 	}
 
-	let networkName: string;
-	let saveDeployments: boolean;
+	const deploymentsFolder = userConfig.deployments || 'deployments';
+	const targetName = resolvedExecutionParams.target.name;
+	const saveDeployments = resolvedExecutionParams.saveDeployments;
 	let networkTags: {[tag: string]: boolean} = {};
-	for (const networkTag of config.target.tags) {
+	for (const networkTag of resolvedExecutionParams.target.tags) {
 		networkTags[networkTag] = true;
 	}
 
-	if ('nodeUrl' in config) {
-		networkName = config.target.name;
-		saveDeployments = true;
-	} else {
-		if (config.target.name) {
-			networkName = config.target.name;
-		} else {
-			networkName = 'memory';
-		}
-		if (networkName === 'memory' || networkName === 'hardhat' || networkName === 'default') {
-			networkTags['memory'] = true;
-			saveDeployments = false;
-		} else {
-			saveDeployments = true;
-		}
-	}
-
-	if (config.saveDeployments !== undefined) {
-		saveDeployments = config.saveDeployments;
-	}
-
 	const resolvedAccounts: {[name: string]: ResolvedAccount} = {};
 
 	const allRemoteAccounts = await provider.request({method: 'eth_accounts'});
@@ -149,7 +124,7 @@ export async function createEnvironment<
 		} else if (typeof accountDef === 'string') {
 			if (accountDef.startsWith('0x')) {
 				if (accountDef.length === 66) {
-					const privateKeyProtocol = config.signerProtocols['privateKey'];
+					const privateKeyProtocol = userConfig.signerProtocols?.['privateKey'];
 					if (privateKeyProtocol) {
 						const namedSigner = await privateKeyProtocol(`privateKey:${accountDef}`);
 						const [address] = await namedSigner.signer.request({method: 'eth_accounts'});
@@ -168,7 +143,7 @@ export async function createEnvironment<
 			} else {
 				if (accountDef.indexOf(':') > 0) {
 					const [protocolID, extra] = accountDef.split(':');
-					const protocol = config.signerProtocols[protocolID];
+					const protocol = userConfig.signerProtocols?.[protocolID];
 					if (!protocol) {
 						throw new Error(`protocol: ${protocolID} is not supported`);
 					}
@@ -186,7 +161,8 @@ export async function createEnvironment<
 				}
 			}
 		} else {
-			const accountForNetwork = accountDef[networkName] || accountDef[chainId] || accountDef['default'];
+			// TODO allow for canonical chain name ?
+			const accountForNetwork = accountDef[targetName] || accountDef[chainId] || accountDef['default'];
 			if (typeof accountForNetwork !== undefined) {
 				const accountFetched = await getAccount(name, accounts, accountForNetwork);
 				if (accountFetched) {
@@ -198,24 +174,24 @@ export async function createEnvironment<
 		return account;
 	}
 
-	if (config.accounts) {
-		const accountNames = Object.keys(config.accounts);
+	if (userConfig.accounts) {
+		const accountNames = Object.keys(userConfig.accounts);
 		for (const accountName of accountNames) {
-			let account = await getAccount(accountName, config.accounts, config.accounts[accountName]);
+			let account = await getAccount(accountName, userConfig.accounts, userConfig.accounts[accountName]);
 			(resolvedAccounts as any)[accountName] = account;
 		}
 	}
 
 	const resolvedData: ResolvedNetworkSpecificData<Data> = {} as ResolvedNetworkSpecificData<Data>;
 	async function getData<T = unknown>(name: string, dataDef: DataType<T>): Promise<T | undefined> {
-		const dataForNetwork = dataDef[networkName] || dataDef[chainId] || dataDef['default'];
+		const dataForNetwork = dataDef[targetName] || dataDef[chainId] || dataDef['default'];
 		return dataForNetwork;
 	}
 
-	if (config.data) {
-		const dataFields = Object.keys(config.data);
+	if (userConfig.data) {
+		const dataFields = Object.keys(userConfig.data);
 		for (const dataField of dataFields) {
-			let fieldData = await getData(dataField, config.data[dataField]);
+			let fieldData = await getData(dataField, userConfig.data[dataField]);
 			(resolvedData as any)[dataField] = fieldData;
 		}
 	}
@@ -224,8 +200,7 @@ export async function createEnvironment<
 		accounts: resolvedAccounts,
 		data: resolvedData,
 		network: {
-			name: networkName,
-			fork: config.target.fork,
+			fork: resolvedExecutionParams.target.fork,
 			saveDeployments,
 			tags: networkTags,
 		},
@@ -234,8 +209,8 @@ export async function createEnvironment<
 	// console.log(`context`, JSON.stringify(context.network, null, 2));
 
 	const {deployments, migrations} = loadDeployments(
-		config.deployments,
-		context.network.name,
+		deploymentsFolder,
+		targetName,
 		false,
 		context.network.fork
 			? undefined
@@ -267,7 +242,8 @@ export async function createEnvironment<
 	}
 
 	const perliminaryEnvironment = {
-		config,
+		name: targetName,
+		tags: context.network.tags,
 		deployments: deployments as Deployments,
 		namedAccounts: namedAccounts as ResolvedNamedAccounts<NamedAccounts>,
 		data: resolvedData,
@@ -275,16 +251,16 @@ export async function createEnvironment<
 		unnamedAccounts,
 		addressSigners: addressSigners,
 		network: {
-			chain: getChainWithConfig(chainId, config),
-			name: context.network.name,
-			tags: context.network.tags,
+			chain: resolvedExecutionParams.chain,
+			fork: context.network.fork,
 			provider,
+			deterministicDeployment: resolvedExecutionParams.target.deterministicDeployment,
 		},
-		extra: config.extra || {},
+		extra: resolvedExecutionParams.extra || {},
 	};
 
 	function getDeploymentFolder(): string {
-		const folderPath = path.join(config.deployments, context.network.name);
+		const folderPath = path.join(deploymentsFolder, targetName);
 		return folderPath;
 	}
 
@@ -458,7 +434,7 @@ export async function createEnvironment<
 		// confirmations?: number; // TODO
 		// timeout?: number; // TODO
 	}): Promise<EIP1193TransactionReceipt> {
-		const {hash, pollingInterval} = {pollingInterval: config.target.pollingInterval, ...params};
+		const {hash, pollingInterval} = {pollingInterval: resolvedExecutionParams.pollingInterval, ...params};
 
 		let receipt: EIP1193TransactionReceipt | null = null;
 		try {

package/src/environment/types.ts

@@ -9,14 +9,9 @@ import {
 	EIP1193WalletProvider,
 } from 'eip-1193';
 import type {Address, Chain, DeployContractParameters} from 'viem';
-import {
-	DeterministicDeploymentInfo,
-	type Create2DeterministicDeploymentInfo,
-	type Create3DeterministicDeploymentInfo,
-} from '../executor/index.js';
+import {ConfigOverrides, DeterministicDeploymentInfo} from '../executor/index.js';
 import {ProgressIndicator} from '../internal/logging.js';
 import {TransactionHashTracker} from './providers/TransactionHashTracker.js';
-import {SignerProtocolFunction} from './index.js';
 import {ChainInfo} from '../executor/types.js';
 
 export type {Abi, AbiConstructor, AbiError, AbiEvent, AbiFallback, AbiFunction, AbiReceive};
@@ -231,84 +226,36 @@ export type ResolvedNamedSigners<T extends UnknownNamedAccounts> = {
 
 export type UnknownDeploymentsAcrossNetworks = Record<string, UnknownDeployments>;
 
-type TargetConfigBase = {
-	name: string;
-	tags: string[];
-	fork?: boolean;
-	deterministicDeployment?: DeterministicDeploymentInfo;
-	scripts?: string | string[];
-	chainInfo: ChainInfo;
-	pollingInterval?: number;
-};
-type TargetConfigForJSONRPC = TargetConfigBase & {
-	nodeUrl: string;
-};
-
-type TargetConfigForEIP1193Provider = TargetConfigBase & {
-	provider: EIP1193ProviderWithoutEvents;
-};
-
-export type TargetConfig = TargetConfigForJSONRPC | TargetConfigForEIP1193Provider;
-
-type ResolvedTargetConfigBase = {
-	name: string;
-	tags: string[];
-	fork?: boolean;
-	deterministicDeployment: DeterministicDeploymentInfo;
-	chainInfo: ChainInfo;
-	pollingInterval: number;
-};
-type ResolvedTargetConfigForJSONRPC = ResolvedTargetConfigBase & {
-	nodeUrl: string;
-};
-
-type ResolvedTargetConfigForEIP1193Provider = ResolvedTargetConfigBase & {
-	provider: EIP1193ProviderWithoutEvents;
-};
-
-export type ResolvedTargetConfig = ResolvedTargetConfigForJSONRPC | ResolvedTargetConfigForEIP1193Provider;
-
-export type Config<
-	AccountsType extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
-	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
-> = {
-	target: TargetConfig;
-	targetTags?: string[];
-	scripts?: string | string[];
-	deployments?: string;
-	saveDeployments?: boolean;
-
+export type ExecutionParams<Extra extends Record<string, unknown> = Record<string, unknown>> = {
+	target?: string | {fork: string};
 	tags?: string[];
+	saveDeployments?: boolean;
 	askBeforeProceeding?: boolean;
 	reportGasUse?: boolean;
-
-	logLevel?: number;
-	// TODO
-	gasPricing?: {};
-	accounts?: AccountsType;
-
-	data?: Data;
-	signerProtocols?: Record<string, SignerProtocolFunction>;
-	extra?: Record<string, unknown>;
 	defaultPollingInterval?: number;
+	extra?: Extra;
+	logLevel?: number;
+	provider?: EIP1193ProviderWithoutEvents;
+	config: ConfigOverrides;
 };
 
-export type ResolvedConfig<
-	AccountsType extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
-	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
-> = Omit<Config, 'target'> & {
-	deployments: string;
-	scripts: string[];
-	tags: string[];
-	target: ResolvedTargetConfig;
-	saveDeployments?: boolean;
-	askBeforeProceeding?: boolean;
-	reportGasUse?: boolean;
-	accounts: AccountsType;
-	data: Data;
-	signerProtocols: Record<string, SignerProtocolFunction>;
-	extra: Record<string, unknown>;
-	defaultPollingInterval: number;
+export type ResolvedExecutionParams<Extra extends Record<string, unknown> = Record<string, unknown>> = {
+	readonly target: {
+		readonly name: string;
+		readonly tags: readonly string[];
+		readonly fork?: boolean;
+		readonly deterministicDeployment: DeterministicDeploymentInfo;
+	};
+	readonly chain: ChainInfo;
+	readonly tags: readonly string[];
+	readonly saveDeployments: boolean;
+	readonly askBeforeProceeding: boolean;
+	readonly reportGasUse: boolean;
+	readonly pollingInterval: number;
+	readonly extra?: Extra;
+	readonly logLevel: number;
+	readonly provider: EIP1193ProviderWithoutEvents;
+	readonly scripts: readonly string[];
 };
 
 export interface Environment<
@@ -317,20 +264,21 @@ export interface Environment<
 	Deployments extends UnknownDeployments = UnknownDeployments,
 	Extra extends Record<string, unknown> = Record<string, unknown>
 > {
-	config: ResolvedConfig;
-	network: {
-		chain: Chain;
-		name: string;
-		tags: {[tag: string]: boolean};
-		provider: TransactionHashTracker;
+	readonly name: string;
+	readonly tags: {readonly [tag: string]: boolean};
+	readonly network: {
+		readonly chain: Chain;
+		readonly provider: TransactionHashTracker;
+		readonly fork?: boolean;
+		readonly deterministicDeployment: DeterministicDeploymentInfo;
 	};
-	deployments: Deployments;
-	namedAccounts: ResolvedNamedAccounts<NamedAccounts>;
-	data: ResolvedNetworkSpecificData<Data>;
-	namedSigners: ResolvedNamedSigners<ResolvedNamedAccounts<NamedAccounts>>;
-	unnamedAccounts: EIP1193Account[];
+	readonly deployments: Deployments;
+	readonly namedAccounts: ResolvedNamedAccounts<NamedAccounts>;
+	readonly data: ResolvedNetworkSpecificData<Data>;
+	readonly namedSigners: ResolvedNamedSigners<ResolvedNamedAccounts<NamedAccounts>>;
+	readonly unnamedAccounts: EIP1193Account[];
 	// unnamedSigners: {type: 'remote'; signer: EIP1193ProviderWithoutEvents}[];
-	addressSigners: {[name: `0x${string}`]: Signer};
+	readonly addressSigners: {[name: `0x${string}`]: Signer};
 	save<TAbi extends Abi = Abi>(
 		name: string,
 		deployment: Deployment<TAbi>,
@@ -346,7 +294,7 @@ export interface Environment<
 	showProgress(message?: string): ProgressIndicator;
 
 	hasMigrationBeenDone(id: string): boolean;
-	extra?: Extra;
+	readonly extra?: Extra;
 }
 
 export type DeploymentConstruction<TAbi extends Abi> = Omit<

package/src/environment/utils/chains.ts

@@ -1,8 +1,14 @@
-import type {Chain} from 'viem/chains';
 import * as chains from 'viem/chains';
-import {ResolvedConfig} from '../types.js';
 import {kebabCase} from 'change-case';
 import {ChainInfo} from '../../executor/types.js';
+import {
+	ChainConfig,
+	ChainUserConfig,
+	Create2DeterministicDeploymentInfo,
+	Create3DeterministicDeploymentInfo,
+	ResolvedUserConfig,
+	UserConfig,
+} from '../../executor/index.js';
 
 export type ChainType = 'zksync' | 'op-stack' | 'celo' | 'default';
 
@@ -31,7 +37,7 @@ export const chainTypes: {[chainId: string]: ChainType} = {};
 
 export const chainById: {[chainId: string]: ChainInfo} = {};
 export const allChains = {...((chains as any).default || chains)};
-delete allChains['localhost'];
+allChains['localhost'] = allChains['hardhat'];
 
 for (const key of Object.keys(allChains)) {
 	const chain = (allChains as any)[key] as ChainInfo;
@@ -50,7 +56,7 @@ for (const key of Object.keys(allChains)) {
 	chainByCanonicalName[canonicalName] = chain;
 }
 
-export function getChain(id: string | number): ChainInfo | undefined {
+export function getChainById(id: string | number): ChainInfo | undefined {
 	const chain = chainById['' + id];
 
 	return chain;
@@ -61,35 +67,119 @@ export function getChainByName(name: string): ChainInfo | undefined {
 	return chain;
 }
 
-export function getChainWithConfig(id: string, config: ResolvedConfig): ChainInfo {
-	if (config.target.chainInfo) {
-		return config.target.chainInfo;
+export function getChainConfig(id: number, config: ResolvedUserConfig): ChainConfig {
+	const defaultChainInfo = getChainById(id);
+	const canonicalName = defaultChainInfo ? kebabCase(defaultChainInfo.name) : undefined;
+	if (canonicalName) {
+		if (config.chains?.[id] && config.chains?.[canonicalName]) {
+			throw new Error(
+				`chain should be configured by chainId or name but not both, remove either ${id} or ${canonicalName}`
+			);
+		}
 	}
 
-	const chain = getChain(id);
-	if (chain) {
-		return chain;
+	let chainConfig: ChainUserConfig | undefined = config.chains?.[id];
+	if (!chainConfig && canonicalName) {
+		chainConfig = config.chains?.[canonicalName];
 	}
-	console.error(`network ${config.target.name} has no public info`);
-	let nodeUrl: string | undefined;
-	if (!('nodeUrl' in config.target)) {
-		console.error(`no nodeUrl found either for ${config.target.name}`);
-	} else {
-		nodeUrl = config.target.nodeUrl;
+	if (!chainConfig) {
+		chainConfig = {info: defaultChainInfo};
 	}
-	return {
-		id: parseInt(id),
-		name: 'unkwown',
-		nativeCurrency: {
-			name: 'Unknown Currency',
-			symbol: 'UNKNOWN',
-			decimals: 18,
-		},
-		rpcUrls: {
-			default: {
-				http: nodeUrl ? [nodeUrl] : [],
+
+	let chainInfo = chainConfig?.info || defaultChainInfo;
+
+	let rpcUrl = process.env['ETH_NODE_URI_' + id];
+	if (canonicalName) {
+		const fromEnv = process.env['ETH_NODE_URI_' + canonicalName];
+		if (fromEnv) {
+			rpcUrl = fromEnv;
+		}
+	}
+
+	if (!rpcUrl) {
+		rpcUrl = chainConfig.rpcUrl;
+	}
+
+	if (!rpcUrl) {
+		rpcUrl = chainConfig.info?.rpcUrls.default.http[0];
+	}
+
+	if (!rpcUrl) {
+		if (id === 31337 || id === 1337) {
+			rpcUrl = 'http://127.0.0.1:8545';
+		}
+	}
+
+	if (!chainInfo) {
+		if (!rpcUrl) {
+			throw new Error(`no chain info found for chain with id ${id}`);
+		} else {
+			console.error(`chain with id ${id} has no public info`);
+		}
+
+		chainInfo = {
+			id,
+			name: 'unkwown',
+			nativeCurrency: {
+				name: 'Unknown Currency',
+				symbol: 'UNKNOWN',
+				decimals: 18,
+			},
+			rpcUrls: {
+				default: {
+					http: [rpcUrl],
+				},
 			},
-		},
-		chainType: 'default',
+			chainType: 'default',
+		};
+	}
+
+	const create2Info = {
+		factory: '0x4e59b44847b379578588920ca78fbf26c0b4956c',
+		deployer: '0x3fab184622dc19b6109349b94811493bf2a45362',
+		funding: '10000000000000000',
+		signedTx:
+			'0xf8a58085174876e800830186a08080b853604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf31ba02222222222222222222222222222222222222222222222222222222222222222a02222222222222222222222222222222222222222222222222222222222222222',
+	} as const;
+	const create3Info = {
+		factory: '0x000000000004d4f168daE7DB3C610F408eE22F57',
+		salt: '0x5361109ca02853ca8e22046b7125306d9ec4ae4cdecc393c567b6be861df3db6',
+		bytecode:
+			'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',
+		proxyBytecode: '0x67363d3d37363d34f03d5260086018f3',
+	} as const;
+
+	const pollingInterval = chainConfig.pollingInterval || config.defaultPollingInterval || 1;
+
+	let deterministicDeployment: {
+		create2: Create2DeterministicDeploymentInfo;
+		create3: Create3DeterministicDeploymentInfo;
+	} = {
+		create2: (() => {
+			if (!chainConfig.deterministicDeployment) return create2Info;
+			if (!('create3' in chainConfig.deterministicDeployment) && !('create2' in chainConfig.deterministicDeployment))
+				return create2Info;
+			return chainConfig.deterministicDeployment.create2 || create2Info;
+		})(),
+		create3:
+			chainConfig.deterministicDeployment &&
+			'create3' in chainConfig.deterministicDeployment &&
+			chainConfig.deterministicDeployment.create3
+				? chainConfig.deterministicDeployment.create3
+				: create3Info,
+	};
+
+	const defaultTags: string[] = [];
+	if (chainInfo.testnet) {
+		defaultTags.push('testnet');
+	}
+
+	return {
+		info: {...chainInfo},
+		deterministicDeployment,
+		pollingInterval,
+		properties: chainConfig.properties || {},
+		rpcUrl: rpcUrl || chainInfo.rpcUrls.default.http[0],
+		tags: chainConfig.tags || [...defaultTags],
 	};
 }