rocketh 0.14.9 → 0.15.0-testing.1

package/src/environment/utils/chains.ts

@@ -1,6 +1,8 @@
 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';
 
 export type ChainType = 'zksync' | 'op-stack' | 'celo' | 'default';
 
@@ -27,10 +29,10 @@ const chainTypesByNames: {[chainExportName: string]: ChainType} = {
 
 export const chainTypes: {[chainId: string]: ChainType} = {};
 
-export const chainById: {[chainId: string]: Chain} = {};
-const allChains = (chains as any).default || chains;
+export const chainById: {[chainId: string]: ChainInfo} = {};
+export const allChains = (chains as any).default || chains;
 for (const key of Object.keys(allChains)) {
-	const chain = (allChains as any)[key] as Chain;
+	const chain = (allChains as any)[key] as ChainInfo;
 	const chainId = chain.id.toString();
 	const specificChainType = chainTypesByNames[key];
 	if (specificChainType) {
@@ -39,28 +41,37 @@ for (const key of Object.keys(allChains)) {
 	chainById[chainId] = chain;
 }
 
-export function getChain(id: string): Chain | undefined {
-	const chain = chainById[id];
+export const chainByCanonicalName: {[canonicalName: string]: ChainInfo} = {};
+for (const key of Object.keys(allChains)) {
+	const chain = (allChains as any)[key] as ChainInfo;
+	const canonicalName = kebabCase(chain.name);
+	chainByCanonicalName[canonicalName] = chain;
+}
+
+export function getChain(id: string | number): ChainInfo | undefined {
+	const chain = chainById['' + id];
+
+	return chain;
+}
 
+export function getChainByName(name: string): ChainInfo | undefined {
+	const chain = chainByCanonicalName[name];
 	return chain;
 }
 
-export function getChainWithConfig(id: string, config: ResolvedConfig): Chain {
+export function getChainWithConfig(id: string, config: ResolvedConfig): ChainInfo {
 	const chain = getChain(id);
 
 	if (!chain) {
-		if (config.network.publicInfo) {
-			return {
-				id: parseInt(id),
-				...config.network.publicInfo,
-			};
+		if (config.target.chain) {
+			return config.target.chain;
 		}
-		console.error(`network ${config.network.name} has no public info`);
+		console.error(`network ${config.target.name} has no public info`);
 		let nodeUrl: string | undefined;
-		if (!config.network.nodeUrl) {
-			console.error(`no nodeUrl found either for ${config.network.name}`);
+		if (!config.target.nodeUrl) {
+			console.error(`no nodeUrl found either for ${config.target.name}`);
 		} else {
-			nodeUrl = config.network.nodeUrl;
+			nodeUrl = config.target.nodeUrl;
 		}
 		return {
 			id: parseInt(id),
@@ -75,6 +86,7 @@ export function getChainWithConfig(id: string, config: ResolvedConfig): Chain {
 					http: nodeUrl ? [nodeUrl] : [],
 				},
 			},
+			chainType: 'default',
 		};
 	}
 	return chain;

package/src/executor/index.ts

@@ -9,16 +9,25 @@ import type {
 	Environment,
 	JSONTypePlusBigInt,
 	ResolvedConfig,
+	TargetConfig,
 	UnknownDeployments,
 	UnresolvedNetworkSpecificData,
 	UnresolvedUnknownNamedAccounts,
 } from '../environment/types.js';
 import {createEnvironment, SignerProtocolFunction} from '../environment/index.js';
-import {DeployScriptFunction, DeployScriptModule, EnhancedDeployScriptFunction, EnhancedEnvironment} from './types.js';
+import {
+	ChainInfo,
+	DeployScriptFunction,
+	DeployScriptModule,
+	EnhancedDeployScriptFunction,
+	EnhancedEnvironment,
+} 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 {getChain, getChainByName} from '../environment/utils/chains.js';
+import {JSONRPCHTTPProvider} from 'eip-1193-jsonrpc-provider';
 
 // @ts-ignore
 const tsImport = (path: string, opts: any) => (typeof Bun !== 'undefined' ? import(path) : tsImport_(path, opts));
@@ -147,7 +156,7 @@ export type UntypedEIP1193Provider = {
 };
 
 export type ConfigOptions<Extra extends Record<string, unknown> = Record<string, unknown>> = {
-	network?: string | {fork: string};
+	target?: string | {fork: string};
 	deployments?: string;
 	scripts?: string | string[];
 	tags?: string;
@@ -181,35 +190,30 @@ export type DeterministicDeploymentInfo =
 			create3?: Create3DeterministicDeploymentInfo;
 	  };
 
-type Networks = {
-	[name: string]: {
-		rpcUrl?: string;
-		tags?: string[];
-		deterministicDeployment?: DeterministicDeploymentInfo;
-		scripts?: string | string[];
-		publicInfo?: {
-			name: string;
-			nativeCurrency: {
-				name: string;
-				symbol: string;
-				decimals: number;
-			};
-			rpcUrls: {
-				default: {
-					http: string[];
-				};
-			};
-			chainType?: string;
-		};
-		pollingInterval?: number;
-		properties?: Record<string, JSONTypePlusBigInt>;
-	};
+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
 > = {
-	networks?: Networks;
+	targets: {[name: string]: DeploymentTargetConfig};
+	chains?: Chains;
 	deployments?: string;
 	scripts?: string | string[];
 	accounts?: NamedAccounts;
@@ -218,11 +222,14 @@ export type UserConfig<
 	defaultPollingInterval?: number;
 };
 
-export function transformUserConfig<
+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>): Config<NamedAccounts, Data> {
+>(
+	configFile: UserConfig<NamedAccounts, Data> | undefined,
+	options: ConfigOptions<Extra>
+): Promise<Config<NamedAccounts, Data>> {
 	if (configFile) {
 		if (!options.deployments && configFile.deployments) {
 			options.deployments = configFile.deployments;
@@ -232,121 +239,146 @@ export function transformUserConfig<
 		}
 	}
 
-	const fromEnv = process.env['ETH_NODE_URI_' + options.network];
-	const fork = typeof options.network !== 'string';
-	let networkName = 'memory';
-	if (options.network) {
-		if (typeof options.network === 'string') {
-			networkName = options.network;
-		} else if ('fork' in options.network) {
-			networkName = options.network.fork;
+	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 defaultTags: string[] = [];
+	let chainInfo: ChainInfo;
 
-	let networkTags: string[] =
-		(configFile?.networks && (configFile?.networks[networkName]?.tags || configFile?.networks['default']?.tags)) ||
-		defaultTags;
+	let chainId: number;
 
-	let networkScripts: string | string[] | undefined =
-		(configFile?.networks &&
-			(configFile?.networks[networkName]?.scripts || configFile?.networks['default']?.scripts)) ||
-		undefined;
+	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 publicInfo = configFile?.networks ? configFile?.networks[networkName]?.publicInfo : undefined;
 	const defaultPollingInterval = configFile?.defaultPollingInterval;
-	const pollingInterval = configFile?.networks?.[networkName]?.pollingInterval;
-	const deterministicDeployment = configFile?.networks?.[networkName]?.deterministicDeployment;
-	const properties = configFile?.networks ? configFile?.networks[networkName]?.properties : undefined;
+	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') {
+		if (typeof fromEnv === 'string' && fromEnv) {
 			nodeUrl = fromEnv;
 		} else {
-			if (configFile) {
-				const network = configFile.networks && configFile.networks[networkName];
-				if (network && network.rpcUrl) {
-					nodeUrl = network.rpcUrl;
-				} else {
-					if (options?.ignoreMissingRPC) {
-						nodeUrl = '';
-					} else {
-						if (options.network === 'localhost') {
-							nodeUrl = 'http://127.0.0.1:8545';
-						} else {
-							console.error(`network "${options.network}" is not configured. Please add it to the rocketh.js/ts file`);
-							process.exit(1);
-						}
-					}
-				}
+			if (rpcURL) {
+				nodeUrl = rpcURL;
+			} else if (options?.ignoreMissingRPC) {
+				nodeUrl = '';
+			} else if (options.target === 'localhost') {
+				nodeUrl = 'http://127.0.0.1:8545';
 			} else {
-				if (options?.ignoreMissingRPC) {
-					nodeUrl = '';
-				} else {
-					if (options.network === 'localhost') {
-						nodeUrl = 'http://127.0.0.1:8545';
-					} else {
-						console.error(`network "${options.network}" is not configured. Please add it to the rocketh.js/ts file`);
-						process.exit(1);
-					}
-				}
+				console.error(`network "${options.target}" is not configured. Please add it to the rocketh.js/ts file`);
+				process.exit(1);
 			}
 		}
 
-		return {
-			network: {
-				nodeUrl,
-				name: networkName,
-				tags: networkTags,
-				fork,
-				deterministicDeployment,
-				scripts: networkScripts,
-				publicInfo,
-				pollingInterval,
-				properties,
-			},
-			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,
+		resolvedTargetConfig = {
+			nodeUrl,
+			name: targetName,
+			tags: targetTags,
+			fork,
+			deterministicDeployment,
+			scripts: networkScripts,
+			chainInfo,
+			pollingInterval,
+			properties,
 		};
 	} else {
-		return {
-			network: {
-				provider: options.provider as EIP1193ProviderWithoutEvents,
-				name: networkName,
-				tags: networkTags,
-				fork,
-				deterministicDeployment,
-				scripts: networkScripts,
-				publicInfo,
-				pollingInterval,
-				properties,
-			},
-			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,
+		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<
@@ -423,26 +455,26 @@ export function resolveConfig<
 	} as const;
 
 	const defaultPollingInterval = config.defaultPollingInterval || 1;
-	const networkPollingInterval = config.network.pollingInterval || defaultPollingInterval;
+	const networkPollingInterval = config.target.pollingInterval || defaultPollingInterval;
 
 	let deterministicDeployment: {
 		create2: Create2DeterministicDeploymentInfo;
 		create3: Create3DeterministicDeploymentInfo;
 	} = {
 		create2: (() => {
-			if (!config.network.deterministicDeployment) return create2Info;
+			if (!config.target.deterministicDeployment) return create2Info;
 			if (
-				!('create3' in config.network.deterministicDeployment) &&
-				!('create2' in config.network.deterministicDeployment)
+				!('create3' in config.target.deterministicDeployment) &&
+				!('create2' in config.target.deterministicDeployment)
 			)
 				return create2Info;
-			return config.network.deterministicDeployment.create2 || create2Info;
+			return config.target.deterministicDeployment.create2 || create2Info;
 		})(),
 		create3:
-			config.network.deterministicDeployment &&
-			'create3' in config.network.deterministicDeployment &&
-			config.network.deterministicDeployment.create3
-				? config.network.deterministicDeployment.create3
+			config.target.deterministicDeployment &&
+			'create3' in config.target.deterministicDeployment &&
+			config.target.deterministicDeployment.create3
+				? config.target.deterministicDeployment.create3
 				: create3Info,
 	};
 
@@ -455,20 +487,20 @@ export function resolveConfig<
 		}
 	}
 
-	if (config.network.scripts) {
-		if (typeof config.network.scripts === 'string') {
-			scripts = [config.network.scripts];
+	if (config.target.scripts) {
+		if (typeof config.target.scripts === 'string') {
+			scripts = [config.target.scripts];
 		} else {
-			scripts = config.network.scripts;
+			scripts = config.target.scripts;
 		}
 	}
 	const resolvedConfig: ResolvedConfig<NamedAccounts, Data> = {
 		...config,
-		network: {...config.network, deterministicDeployment, pollingInterval: networkPollingInterval},
+		target: {...config.target, deterministicDeployment, pollingInterval: networkPollingInterval},
 		deployments: config.deployments || 'deployments',
 		scripts,
 		tags: config.tags || [],
-		networkTags: config.networkTags || [],
+		targetTags: config.targetTags || [],
 		saveDeployments: config.saveDeployments,
 		accounts: config.accounts || ({} as NamedAccounts),
 		data: config.data || ({} as Data),

package/src/executor/types.ts

@@ -1,5 +1,7 @@
+import {Address} from 'abitype';
 import type {
 	Environment,
+	JSONTypePlusBigInt,
 	UnknownDeployments,
 	UnresolvedNetworkSpecificData,
 	UnresolvedUnknownNamedAccounts,
@@ -80,3 +82,95 @@ export type EnhancedDeployScriptFunction<
 	env: EnhancedEnvironment<NamedAccounts, Data, Deployments, Functions, Extra>,
 	args?: ArgumentsTypes
 ) => Promise<void | boolean>;
+
+type ChainBlockExplorer = {
+	name: string;
+	url: string;
+	apiUrl?: string | undefined;
+};
+type ChainContract = {
+	address: Address;
+	blockCreated?: number | undefined;
+};
+
+type ChainNativeCurrency = {
+	name: string;
+	/** 2-6 characters long */
+	symbol: string;
+	decimals: number;
+};
+
+type ChainRpcUrls = {
+	http: readonly string[];
+	webSocket?: readonly string[] | undefined;
+};
+
+/**
+ * @description Combines members of an intersection into a readable type.
+ *
+ * @see {@link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg}
+ * @example
+ * Prettify<{ a: string } & { b: string } & { c: number, d: bigint }>
+ * => { a: string, b: string, c: number, d: bigint }
+ */
+type Prettify<T> = {
+	[K in keyof T]: T[K];
+} & {};
+
+export type ChainInfo = {
+	/** ID in number form */
+	id: number;
+	/** Human-readable name */
+	name: string;
+	/** Collection of block explorers */
+	blockExplorers?:
+		| {
+				[key: string]: ChainBlockExplorer;
+				default: ChainBlockExplorer;
+		  }
+		| undefined;
+	/** Collection of contracts */
+	contracts?:
+		| Prettify<
+				{
+					[key: string]: ChainContract | {[sourceId: number]: ChainContract | undefined} | undefined;
+				} & {
+					ensRegistry?: ChainContract | undefined;
+					ensUniversalResolver?: ChainContract | undefined;
+					multicall3?: ChainContract | undefined;
+				}
+		  >
+		| undefined;
+	/** Currency used by chain */
+	nativeCurrency: ChainNativeCurrency;
+	/** Collection of RPC endpoints */
+	rpcUrls: {
+		[key: string]: ChainRpcUrls;
+		default: ChainRpcUrls;
+	};
+	/** Source Chain ID (ie. the L1 chain) */
+	sourceId?: number | undefined;
+	/** Flag for test networks */
+	testnet?: boolean | undefined;
+
+	chainType: 'zksync' | 'op-stack' | 'celo' | 'default';
+
+	genesisHash?: string;
+
+	properties?: Record<string, JSONTypePlusBigInt>;
+
+	// this will bring in the following when reconstructed from the data above
+
+	// /** Custom chain data. */
+	// custom?: any;
+
+	// /**
+	//  * Modifies how chain data structures (ie. Blocks, Transactions, etc)
+	//  * are formatted & typed.
+	//  */
+	// formatters?: any | undefined;
+	// /** Modifies how data (ie. Transactions) is serialized. */
+	// serializers?: any | undefined;
+	// /** Modifies how fees are derived. */
+	// fees?: any | undefined;
+};