rocketh 0.9.2 → 0.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rocketh",
-  "version": "0.9.2",
+  "version": "0.10.1",
   "description": "deploy smart contract on ethereum-compatible networks",
   "publishConfig": {
     "access": "public"
@@ -15,8 +15,9 @@
   "devDependencies": {
     "@types/figlet": "^1.5.8",
     "@types/node": "^20.11.19",
+    "@types/prompts": "^2.4.9",
     "abitype": "^1.0.0",
-    "eip-1193": "^0.4.7",
+    "eip-1193": "^0.5.0",
     "ipfs-gateway-emulator": "4.2.1-ipfs.2",
     "rimraf": "^5.0.5",
     "tsup": "^8.0.2",
@@ -33,6 +34,7 @@
     "ldenv": "^0.3.9",
     "named-logs": "^0.2.2",
     "named-logs-console": "^0.3.0",
+    "prompts": "^2.4.2",
     "viem": "^2.7.11"
   },
   "scripts": {

package/src/cli.ts

@@ -1,6 +1,6 @@
 #! /usr/bin/env node
 import {loadEnv} from 'ldenv';
-import {loadAndExecuteDeployments, readConfig} from '.';
+import {ConfigOptions, loadAndExecuteDeployments, readConfig} from '.';
 import {Command} from 'commander';
 import pkg from '../package.json';
 
@@ -20,6 +20,5 @@ program
 	.parse(process.argv);
 
 const options = program.opts();
-const config = readConfig(options as any);
 
-loadAndExecuteDeployments({...config, logLevel: 1});
+loadAndExecuteDeployments({...(options as ConfigOptions), logLevel: 1, askBeforeProceeding: true});

package/src/environment/deployments.ts

@@ -5,12 +5,12 @@ import {UnknownDeployments} from './types';
 
 export function loadDeployments(
 	deploymentsPath: string,
-	subPath: string,
+	networkName: string,
 	onlyABIAndAddress?: boolean,
 	expectedChain?: {chainId: string; genesisHash?: `0x${string}`; deleteDeploymentsIfDifferentGenesisHash?: boolean}
 ): {deployments: UnknownDeployments; chainId?: string; genesisHash?: `0x${string}`} {
 	const deploymentsFound: UnknownDeployments = {};
-	const deployPath = path.join(deploymentsPath, subPath);
+	const deployPath = path.join(deploymentsPath, networkName);
 
 	let filesStats;
 	try {
@@ -34,7 +34,7 @@ export function loadDeployments(
 				genesisHash = chainData.genesisHash;
 			} else {
 				throw new Error(
-					`A '.chain' or '.chainId' file is expected to be present in the deployment folder for network ${subPath}`
+					`A '.chain' or '.chainId' file is expected to be present in the deployment folder for network ${networkName}`
 				);
 			}
 		}

package/src/environment/index.ts

@@ -85,7 +85,9 @@ export async function createEnvironment<
 	providedContext: ProvidedContext<Artifacts, NamedAccounts>
 ): Promise<{internal: InternalEnvironment; external: Environment<Artifacts, NamedAccounts, Deployments>}> {
 	const provider =
-		'provider' in config ? config.provider : (new JSONRPCHTTPProvider(config.nodeUrl) as EIP1193ProviderWithoutEvents);
+		'provider' in config.network
+			? config.network.provider
+			: (new JSONRPCHTTPProvider(config.network.nodeUrl) as EIP1193ProviderWithoutEvents);
 
 	const transport = custom(provider);
 	const viemClient = createPublicClient({transport});
@@ -100,24 +102,32 @@ export async function createEnvironment<
 
 	let networkName: string;
 	let saveDeployments: boolean;
-	let tags: {[tag: string]: boolean} = {};
+	let networkTags: {[tag: string]: boolean} = {};
+	for (const networkTag of config.network.tags) {
+		networkTags[networkTag] = true;
+	}
+
 	if ('nodeUrl' in config) {
-		networkName = config.networkName;
+		networkName = config.network.name;
 		saveDeployments = true;
 	} else {
-		if (config.networkName) {
-			networkName = config.networkName;
+		if (config.network.name) {
+			networkName = config.network.name;
 		} else {
 			networkName = 'memory';
 		}
 		if (networkName === 'memory' || networkName === 'hardhat') {
-			tags['memory'] = true;
+			networkTags['memory'] = true;
 			saveDeployments = false;
 		} else {
 			saveDeployments = true;
 		}
 	}
 
+	if (config.saveDeployments !== undefined) {
+		saveDeployments = config.saveDeployments;
+	}
+
 	const resolvedAccounts: {[name: string]: ResolvedAccount} = {};
 
 	const accountCache: {[name: string]: ResolvedAccount} = {};
@@ -205,16 +215,26 @@ export async function createEnvironment<
 		artifacts: providedContext.artifacts as Artifacts,
 		network: {
 			name: networkName,
+			fork: config.network.fork,
 			saveDeployments,
-			tags,
+			tags: networkTags,
 		},
 	};
 
-	const {deployments} = loadDeployments(config.deployments, context.network.name, false, {
-		chainId,
-		genesisHash,
-		deleteDeploymentsIfDifferentGenesisHash: true,
-	});
+	// console.log(`context`, JSON.stringify(context.network, null, 2));
+
+	const {deployments} = loadDeployments(
+		config.deployments,
+		context.network.name,
+		false,
+		context.network.fork
+			? undefined
+			: {
+					chainId,
+					genesisHash,
+					deleteDeploymentsIfDifferentGenesisHash: true,
+			  }
+	);
 
 	const namedAccounts: {[name: string]: EIP1193Account} = {};
 	const namedSigners: {[name: string]: NamedSigner} = {};

package/src/environment/types.ts

@@ -209,30 +209,49 @@ export type Context<
 	artifacts: Artifacts;
 };
 
-type BaseConfig = {
-	networkName?: string;
+type NetworkConfigBase = {
+	name: string;
+	tags: string[];
+	fork?: boolean;
+};
+type NetworkConfigForJSONRPC = NetworkConfigBase & {
+	nodeUrl: string;
+};
+
+type NetworkConfigForEIP1193Provider = NetworkConfigBase & {
+	provider: EIP1193ProviderWithoutEvents;
+};
+
+export type NetworkConfig = NetworkConfigForJSONRPC | NetworkConfigForEIP1193Provider;
+
+export type Config = {
+	network: NetworkConfig;
+	networkTags?: string[];
 	scripts?: string;
 	deployments?: string;
+	saveDeployments?: boolean;
 
 	tags?: string[];
+	askBeforeProceeding?: boolean;
+
 	logLevel?: number;
 	// TODO
 	gasPricing?: {};
 };
 
-type ConfigForJSONRPC = BaseConfig & {
-	networkName: string;
-	nodeUrl: string;
-};
-
-type ConfigForEIP1193Provider = BaseConfig & {
-	provider: EIP1193ProviderWithoutEvents;
+export type ResolvedConfig = Config & {
+	deployments: string;
+	scripts: string;
+	tags: string[];
+	network: {
+		name: string;
+		tags: string[];
+		fork?: boolean;
+	};
+	saveDeployments?: boolean;
+	askBeforeProceeding?: boolean;
 };
 
-export type Config = ConfigForJSONRPC | ConfigForEIP1193Provider;
-
-export type ResolvedConfig = Config & {deployments: string; scripts: string; tags: string[]; networkName: string};
-
 export interface Environment<
 	Artifacts extends UnknownArtifacts = UnknownArtifacts,
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,

package/src/executor/index.ts

@@ -13,6 +13,10 @@ import type {
 import {createEnvironment} from '../environment';
 import {DeployScriptFunction, DeployScriptModule, ProvidedContext} from './types';
 import {logger, setLogLevel, spin} from '../internal/logging';
+import {EIP1193GenericRequestProvider, EIP1193ProviderWithoutEvents} from 'eip-1193';
+import {getRoughGasPriceEstimate} from '../utils/eth';
+import prompts from 'prompts';
+import {formatEther} from 'viem';
 
 if (!process.env['ROCKETH_SKIP_ESBUILD']) {
 	require('esbuild-register/dist/node').register();
@@ -39,28 +43,71 @@ export function execute<
 	return scriptModule as unknown as DeployScriptModule<Artifacts, NamedAccounts, ArgumentsType, Deployments>;
 }
 
-export type ConfigOptions = {network: string; deployments?: string; scripts?: string; tags?: string};
+export type ConfigOptions = {
+	network?: string | {fork: string};
+	deployments?: string;
+	scripts?: string;
+	tags?: string;
+	logLevel?: number;
+	provider?: EIP1193ProviderWithoutEvents | EIP1193GenericRequestProvider;
+	ignoreMissingRPC?: boolean;
+	saveDeployments?: boolean;
+	askBeforeProceeding?: boolean;
+};
 
-export function readConfig(options: ConfigOptions, extra?: {ignoreMissingRPC?: boolean}): Config {
-	type Networks = {[name: string]: {rpcUrl: string}};
-	type ConfigFile = {networks: Networks};
+export function readConfig(options: ConfigOptions): Config {
+	type Networks = {[name: string]: {rpcUrl?: string; tags?: string[]}};
+	type ConfigFile = {networks: Networks; deployments?: string; scripts?: string};
 	let configFile: ConfigFile | undefined;
 	try {
 		const configString = fs.readFileSync('./rocketh.json', 'utf-8');
 		configFile = JSON.parse(configString);
 	} catch {}
 
-	let nodeUrl: string;
+	if (configFile) {
+		if (!options.deployments && configFile.deployments) {
+			options.deployments = configFile.deployments;
+		}
+		if (!options.scripts && configFile.scripts) {
+			options.scripts = configFile.scripts;
+		}
+	}
+
 	const fromEnv = process.env['ETH_NODE_URI_' + options.network];
-	if (typeof fromEnv === 'string') {
-		nodeUrl = fromEnv;
-	} else {
-		if (configFile) {
-			const network = configFile.networks && configFile.networks[options.network];
-			if (network) {
-				nodeUrl = network.rpcUrl;
+	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;
+		}
+	}
+
+	let networkTags: string[] = (configFile?.networks && configFile?.networks[networkName]?.tags) || [];
+	if (!options.provider) {
+		let nodeUrl: string;
+		if (typeof fromEnv === 'string') {
+			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 {
+							logger.error(`network "${options.network}" is not configured. Please add it to the rocketh.json file`);
+							process.exit(1);
+						}
+					}
+				}
 			} else {
-				if (extra?.ignoreMissingRPC) {
+				if (options?.ignoreMissingRPC) {
 					nodeUrl = '';
 				} else {
 					if (options.network === 'localhost') {
@@ -71,40 +118,52 @@ export function readConfig(options: ConfigOptions, extra?: {ignoreMissingRPC?: b
 					}
 				}
 			}
-		} else {
-			if (extra?.ignoreMissingRPC) {
-				nodeUrl = '';
-			} else {
-				if (options.network === 'localhost') {
-					nodeUrl = 'http://127.0.0.1:8545';
-				} else {
-					logger.error(`network "${options.network}" is not configured. Please add it to the rocketh.json file`);
-					process.exit(1);
-				}
-			}
 		}
+		return {
+			network: {
+				nodeUrl,
+				name: networkName,
+				tags: networkTags,
+				fork,
+			},
+			deployments: options.deployments,
+			saveDeployments: options.saveDeployments,
+			scripts: options.scripts,
+			tags: typeof options.tags === 'undefined' ? undefined : options.tags.split(','),
+			logLevel: options.logLevel,
+			askBeforeProceeding: options.askBeforeProceeding,
+		};
+	} else {
+		return {
+			network: {
+				provider: options.provider as EIP1193ProviderWithoutEvents,
+				name: networkName,
+				tags: networkTags,
+				fork,
+			},
+			deployments: options.deployments,
+			saveDeployments: options.saveDeployments,
+			scripts: options.scripts,
+			tags: typeof options.tags === 'undefined' ? undefined : options.tags.split(','),
+			logLevel: options.logLevel,
+			askBeforeProceeding: options.askBeforeProceeding,
+		};
 	}
-
-	return {
-		nodeUrl,
-		networkName: options.network,
-		deployments: options.deployments,
-		scripts: options.scripts,
-		tags: typeof options.tags === 'undefined' ? undefined : options.tags.split(','),
-	};
 }
 
-export function readAndResolveConfig(options: ConfigOptions, extra?: {ignoreMissingRPC?: boolean}): ResolvedConfig {
-	return resolveConfig(readConfig(options, extra));
+export function readAndResolveConfig(options: ConfigOptions): ResolvedConfig {
+	return resolveConfig(readConfig(options));
 }
 
 export function resolveConfig(config: Config): ResolvedConfig {
 	const resolvedConfig: ResolvedConfig = {
 		...config,
-		networkName: config.networkName || 'memory',
+		network: config.network, // TODO default to || {name: 'memory'....}
 		deployments: config.deployments || 'deployments',
 		scripts: config.scripts || 'deploy',
 		tags: config.tags || [],
+		networkTags: config.networkTags || [],
+		saveDeployments: config.saveDeployments,
 	};
 	return resolvedConfig;
 }
@@ -112,8 +171,8 @@ export function resolveConfig(config: Config): ResolvedConfig {
 export async function loadEnvironment<
 	Artifacts extends UnknownArtifacts = UnknownArtifacts,
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts
->(config: Config, context: ProvidedContext<Artifacts, NamedAccounts>): Promise<Environment> {
-	const resolvedConfig = resolveConfig(config);
+>(options: ConfigOptions, context: ProvidedContext<Artifacts, NamedAccounts>): Promise<Environment> {
+	const resolvedConfig = readAndResolveConfig(options);
 	const {external, internal} = await createEnvironment(resolvedConfig, context);
 	return external;
 }
@@ -123,8 +182,10 @@ export async function loadAndExecuteDeployments<
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	ArgumentsType = undefined,
 	Deployments extends UnknownDeployments = UnknownDeployments
->(config: Config, args?: ArgumentsType): Promise<Environment> {
-	const resolvedConfig = resolveConfig(config);
+>(options: ConfigOptions, args?: ArgumentsType): Promise<Environment> {
+	const resolvedConfig = readAndResolveConfig(options);
+	// console.log(JSON.stringify(options, null, 2));
+	// console.log(JSON.stringify(resolvedConfig, null, 2));
 	return executeDeployScripts<Artifacts, NamedAccounts, ArgumentsType, Deployments>(resolvedConfig, args);
 }
 
@@ -269,6 +330,30 @@ export async function executeDeployScripts<
 		recurseDependencies(scriptFilePath);
 	}
 
+	if (config.askBeforeProceeding) {
+		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);

package/src/utils/eth.ts

@@ -0,0 +1,103 @@
+import {EIP1193BlockTag, EIP1193ProviderWithoutEvents} from 'eip-1193';
+
+function avg(arr: bigint[]) {
+	const sum = arr.reduce((a: bigint, v: bigint) => a + v);
+	return sum / BigInt(arr.length);
+}
+
+type EIP1193FeeHistory = {
+	oldestBlock: string;
+	reward: `0x${string}`[][];
+	baseFeePerGas: string[];
+	gasUsedRatio: string[];
+};
+
+export type EstimateGasPriceOptions = {
+	blockCount: number;
+	newestBlock: EIP1193BlockTag;
+	rewardPercentiles: number[];
+};
+
+export type RoughEstimateGasPriceOptions = {
+	blockCount: number;
+	newestBlock: EIP1193BlockTag;
+	rewardPercentiles: [number, number, number];
+};
+
+export type GasPrice = {maxFeePerGas: bigint; maxPriorityFeePerGas: bigint};
+export type EstimateGasPriceResult = GasPrice[];
+export type RoughEstimateGasPriceResult = {slow: GasPrice; average: GasPrice; fast: GasPrice};
+
+export async function getGasPriceEstimate(
+	provider: EIP1193ProviderWithoutEvents,
+	options?: Partial<EstimateGasPriceOptions>
+): Promise<EstimateGasPriceResult> {
+	const defaultOptions: EstimateGasPriceOptions = {
+		blockCount: 20,
+		newestBlock: 'pending',
+		rewardPercentiles: [10, 50, 80],
+	};
+	const optionsResolved = options ? {...defaultOptions, ...options} : defaultOptions;
+
+	const historicalBlocks = optionsResolved.blockCount;
+
+	const rawFeeHistory = await provider.request<EIP1193FeeHistory>({
+		method: 'eth_feeHistory',
+		params: [`0x${historicalBlocks.toString(16)}`, optionsResolved.newestBlock, optionsResolved.rewardPercentiles],
+	});
+
+	let blockNum = Number(rawFeeHistory.oldestBlock);
+	const lastBlock = blockNum + rawFeeHistory.reward.length;
+	let index = 0;
+	const blocksHistory: {number: number; baseFeePerGas: bigint; gasUsedRatio: number; priorityFeePerGas: bigint[]}[] =
+		[];
+	while (blockNum < lastBlock) {
+		blocksHistory.push({
+			number: blockNum,
+			baseFeePerGas: BigInt(rawFeeHistory.baseFeePerGas[index]),
+			gasUsedRatio: Number(rawFeeHistory.gasUsedRatio[index]),
+			priorityFeePerGas: rawFeeHistory.reward[index].map((x) => BigInt(x)),
+		});
+		blockNum += 1;
+		index += 1;
+	}
+
+	const percentilePriorityFeeAverages: bigint[] = [];
+	for (let i = 0; i < optionsResolved.rewardPercentiles.length; i++) {
+		percentilePriorityFeeAverages.push(avg(blocksHistory.map((b) => b.priorityFeePerGas[i])));
+	}
+
+	const baseFeePerGas = BigInt(rawFeeHistory.baseFeePerGas[rawFeeHistory.baseFeePerGas.length - 1]);
+
+	const result: EstimateGasPriceResult = [];
+	for (let i = 0; i < optionsResolved.rewardPercentiles.length; i++) {
+		result.push({
+			maxFeePerGas: percentilePriorityFeeAverages[i] + baseFeePerGas,
+			maxPriorityFeePerGas: percentilePriorityFeeAverages[i],
+		});
+	}
+	return result;
+}
+
+export async function getRoughGasPriceEstimate(
+	provider: EIP1193ProviderWithoutEvents,
+	options?: Partial<RoughEstimateGasPriceOptions>
+): Promise<RoughEstimateGasPriceResult> {
+	const defaultOptions: EstimateGasPriceOptions = {
+		blockCount: 20,
+		newestBlock: 'pending',
+		rewardPercentiles: [10, 50, 80],
+	};
+	const optionsResolved = options ? {...defaultOptions, ...options} : defaultOptions;
+
+	if (optionsResolved.rewardPercentiles.length !== 3) {
+		throw new Error(`rough gas estimate require 3 percentile, it defaults to [10,50,80]`);
+	}
+
+	const result = await getGasPriceEstimate(provider, optionsResolved);
+	return {
+		slow: result[0],
+		average: result[1],
+		fast: result[2],
+	};
+}