rocketh 0.11.20 → 0.11.22-testing.0

package/src/executor/index.ts

@@ -5,13 +5,13 @@ import type {
 	Config,
 	Environment,
 	ResolvedConfig,
-	ResolvedNamedAccounts,
 	UnknownDeployments,
 	UnresolvedNetworkSpecificData,
 	UnresolvedUnknownNamedAccounts,
 } from '../environment/types.js';
-import {createEnvironment} from '../environment/index.js';
-import {DeployScriptFunction, DeployScriptModule} from './types.js';
+import {createEnvironment, SignerProtocolFunction} from '../environment/index.js';
+import {DeployScriptFunction, DeployScriptModule, EnhancedDeployScriptFunction, EnhancedEnvironment} from './types.js';
+import {withEnvironment} from '../utils/curry.js';
 import {logger, setLogLevel, spin} from '../internal/logging.js';
 import {EIP1193GenericRequestProvider, EIP1193ProviderWithoutEvents} from 'eip-1193';
 import {getRoughGasPriceEstimate} from '../utils/eth.js';
@@ -19,24 +19,70 @@ import prompts from 'prompts';
 import {formatEther} from 'viem';
 import {tsImport} from 'tsx/esm/api';
 
-export function execute<
+/**
+ * Setup function that creates the execute function for deploy scripts. It allow to specify a set of functions that will be available in the environment.
+ *
+ * @param functions - An object of utility functions that expect Environment as their first parameter
+ * @returns An execute function that provides an enhanced environment with curried functions
+ *
+ * @example
+ * ```typescript
+ * const functions = {
+ *   deploy: (env: Environment, contractName: string, args: any[]) => Promise<void>,
+ *   verify: (env: Environment, address: string) => Promise<boolean>
+ * };
+ *
+ * const execute = setup(functions);
+ *
+ * export default execute(async (env, args) => {
+ *   // env now includes both the original environment AND the curried functions
+ *   await env.deploy('MyContract', []); // No need to pass env
+ *   await env.verify('0x123...'); // No need to pass env
+ *
+ *   // Original environment properties are still available
+ *   console.log(env.network.name);
+ *   const deployment = env.get('MyContract');
+ * }, { tags: ['deploy'] });
+ * ```
+ */
+export function setup<
+	Functions extends Record<string, (env: Environment<any, any, any>, ...args: any[]) => any> = {},
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
-	ArgumentsType = undefined,
 	Deployments extends UnknownDeployments = UnknownDeployments
->(
-	callback: DeployScriptFunction<NamedAccounts, Data, ArgumentsType, Deployments>,
-	options: {tags?: string[]; dependencies?: string[]; id?: string}
-): DeployScriptModule<NamedAccounts, Data, ArgumentsType, Deployments> {
-	const scriptModule: DeployScriptModule<NamedAccounts, Data, ArgumentsType, Deployments> = (
-		env: Environment<NamedAccounts, Data, Deployments>,
-		args?: ArgumentsType
-	) => callback(env, args);
-	scriptModule.tags = options.tags;
-	scriptModule.dependencies = options.dependencies;
-	scriptModule.id = options.id;
-	// TODO runAtTheEnd ?
-	return scriptModule;
+>(functions: Functions, signerProtocols?: Record<string, SignerProtocolFunction>) {
+	return function enhancedExecute<ArgumentsType = undefined>(
+		callback: EnhancedDeployScriptFunction<NamedAccounts, Data, ArgumentsType, Deployments, Functions>,
+		options: {tags?: string[]; dependencies?: string[]; id?: string; runAtTheEnd?: boolean}
+	): DeployScriptModule<NamedAccounts, Data, ArgumentsType, Deployments> {
+		const scriptModule: DeployScriptModule<NamedAccounts, Data, ArgumentsType, Deployments> = (
+			env: Environment<NamedAccounts, Data, Deployments>,
+			args?: ArgumentsType
+		) => {
+			if (signerProtocols) {
+				for (const key of Object.keys(signerProtocols)) {
+					env.registerProtocol(key, signerProtocols[key]);
+				}
+			}
+
+			// Create the enhanced environment by combining the original environment with curried functions
+			const curriedFunctions = withEnvironment(env, functions);
+			const enhancedEnv = Object.assign(
+				Object.create(Object.getPrototypeOf(env)),
+				env,
+				curriedFunctions
+			) as EnhancedEnvironment<NamedAccounts, Data, Deployments, Functions>;
+
+			return callback(enhancedEnv, args);
+		};
+
+		scriptModule.tags = options.tags;
+		scriptModule.dependencies = options.dependencies;
+		scriptModule.id = options.id;
+		scriptModule.runAtTheEnd = options.runAtTheEnd;
+
+		return scriptModule;
+	};
 }
 
 export type NamedAccountExecuteFunction<
@@ -107,43 +153,10 @@ export type UserConfig<
 	data?: Data;
 };
 
-export async function readConfig<
+export function transformUserConfig<
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
->(options: ConfigOptions): Promise<Config<NamedAccounts, Data>> {
-	type ConfigFile = UserConfig<NamedAccounts, Data>;
-	let configFile: ConfigFile | undefined;
-
-	// TODO more sophisticated config file finding mechanism (look up parents, etc..)
-	const tsFilePath = path.join(process.cwd(), 'rocketh.ts');
-	const jsFilePath = path.join(process.cwd(), 'rocketh.js');
-
-	const tsVersionExists = fs.existsSync(tsFilePath);
-	const jsVersionExists = fs.existsSync(jsFilePath);
-	const existingConfigs = [tsVersionExists, jsVersionExists].filter(Boolean).length;
-
-	// console.log({tsFilePath, tsVersionExists, existingConfigs});
-
-	// Throw error if multiple config files exist
-	if (existingConfigs > 1) {
-		throw new Error('Multiple configuration files found. Please use only one of: rocketh.ts, rocketh.js');
-	}
-	if (tsVersionExists) {
-		const moduleLoaded = await tsImport(`file://${tsFilePath}`, import.meta.url);
-		configFile = moduleLoaded.config;
-		// console.log({tsVersionExists: configFile});
-		// if ((configFile as any).default) {
-		// 	configFile = (configFile as any).default as ConfigFile;
-		// 	if ((configFile as any).default) {
-		// 		logger.warn(`double default...`);
-		// 		configFile = (configFile as any).default as ConfigFile;
-		// 	}
-		// }
-	} else if (jsVersionExists) {
-		const moduleLoaded = await tsImport(`file://${jsFilePath}`, import.meta.url);
-		configFile = moduleLoaded.config;
-	}
-
+>(configFile: UserConfig<NamedAccounts, Data> | undefined, options: ConfigOptions) {
 	if (configFile) {
 		if (!options.deployments && configFile.deployments) {
 			options.deployments = configFile.deployments;
@@ -257,6 +270,51 @@ export async function readConfig<
 	}
 }
 
+export async function readConfig<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
+>(options: ConfigOptions): Promise<Config<NamedAccounts, Data>> {
+	type ConfigFile = UserConfig<NamedAccounts, Data>;
+	let configFile: ConfigFile | undefined;
+
+	let tsVersion: string | undefined;
+	let jsVersion: string | undefined;
+
+	if (typeof process !== 'undefined') {
+		// TODO more sophisticated config file finding mechanism (look up parents, etc..)
+		const tsFilePath = path.join(process.cwd(), 'rocketh.ts');
+		const jsFilePath = path.join(process.cwd(), 'rocketh.js');
+
+		tsVersion = fs.existsSync(tsFilePath) ? `file://${tsFilePath}` : undefined;
+		jsVersion = fs.existsSync(jsFilePath) ? `file://${jsFilePath}` : undefined;
+	}
+	const existingConfigs = [tsVersion, jsVersion].filter(Boolean).length;
+
+	// console.log({tsFilePath, tsVersionExists, existingConfigs});
+
+	// Throw error if multiple config files exist
+	if (existingConfigs > 1) {
+		throw new Error('Multiple configuration files found. Please use only one of: rocketh.ts, rocketh.js');
+	}
+	if (tsVersion) {
+		const moduleLoaded = await tsImport(tsVersion, import.meta.url);
+		configFile = moduleLoaded.config;
+		// console.log({tsVersionExists: configFile});
+		// if ((configFile as any).default) {
+		// 	configFile = (configFile as any).default as ConfigFile;
+		// 	if ((configFile as any).default) {
+		// 		logger.warn(`double default...`);
+		// 		configFile = (configFile as any).default as ConfigFile;
+		// 	}
+		// }
+	} else if (jsVersion) {
+		const moduleLoaded = await tsImport(jsVersion, import.meta.url);
+		configFile = moduleLoaded.config;
+	}
+
+	return transformUserConfig(configFile, options);
+}
+
 export async function readAndResolveConfig<
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData

package/src/executor/setup.test.ts

@@ -0,0 +1,133 @@
+import type {Environment} from '../environment/types.js';
+import {setup} from './index.js';
+
+// Mock environment for testing
+const mockEnv = {} as Environment;
+
+// Example utility functions that take Environment as first parameter
+const utilityFunctions = {
+	deployContract: async (env: Environment, contractName: string, args: any[] = []): Promise<string> => {
+		console.log(`Deploying ${contractName} with args:`, args);
+		return '0x1234567890123456789012345678901234567890';
+	},
+
+	verifyContract: async (env: Environment, address: string): Promise<boolean> => {
+		console.log(`Verifying contract at ${address}`);
+		return true;
+	},
+
+	getBalance: async (env: Environment, address: string): Promise<bigint> => {
+		console.log(`Getting balance for ${address}`);
+		return BigInt('1000000000000000000'); // 1 ETH
+	},
+
+	calculateGas: (env: Environment, operation: string): number => {
+		console.log(`Calculating gas for ${operation}`);
+		return 21000;
+	},
+
+	isDeployed: (env: Environment, contractName: string): boolean => {
+		console.log(`Checking if ${contractName} is deployed`);
+		return false;
+	},
+};
+
+// Create the enhanced execute function using setup
+const execute = setup(utilityFunctions);
+
+// Test the enhanced execute function
+const testScript = execute(
+	async (env, args) => {
+		// Type test: env should have both original Environment properties AND curried functions
+
+		// Test curried functions (no need to pass env)
+		const address = await env.deployContract('MyToken', ['TokenName', 'TKN']);
+		const isVerified = await env.verifyContract(address);
+		const balance = await env.getBalance(address);
+		const gasEstimate = env.calculateGas('transfer');
+		const deployed = env.isDeployed('MyToken');
+
+		// Test that original environment properties are still accessible
+		// (These would normally be available on a real environment)
+		// console.log('Network name:', env.network?.name);
+		// console.log('Chain ID:', env.network?.chain?.id);
+
+		console.log('Test results:', {
+			address,
+			isVerified,
+			balance: balance.toString(),
+			gasEstimate,
+			deployed,
+		});
+
+		return true; // Return true to indicate successful completion
+	},
+	{
+		tags: ['test'],
+		dependencies: [],
+		id: 'test-setup-function',
+	}
+);
+
+// Type tests - these should compile without errors
+async function testTypes() {
+	// The script should be a valid DeployScriptModule
+	console.log('Script tags:', testScript.tags);
+	console.log('Script dependencies:', testScript.dependencies);
+	console.log('Script ID:', testScript.id);
+
+	// The script should be callable with an environment
+	try {
+		const result = await testScript(mockEnv, undefined);
+		console.log('Script execution result:', result);
+	} catch (error) {
+		console.log('Script execution test completed (expected with mock env)');
+	}
+}
+
+// Example of how this would be used in a real deployment script
+export const exampleUsage = () => {
+	// Define your utility functions
+	const myFunctions = {
+		deployERC20: async (env: Environment, name: string, symbol: string): Promise<string> => {
+			// Implementation would use env.save, env.network.provider, etc.
+			return '0x...';
+		},
+
+		setupPermissions: async (env: Environment, contractAddress: string, admin: string): Promise<void> => {
+			// Implementation would interact with contracts
+		},
+
+		verifyOnEtherscan: async (env: Environment, address: string, constructorArgs: any[]): Promise<boolean> => {
+			// Implementation would call verification service
+			return true;
+		},
+	};
+
+	// Create the enhanced execute function
+	const execute = setup(myFunctions);
+
+	// Export your deployment script
+	return execute(
+		async (env, args) => {
+			// Now you can use the functions without passing env each time
+			const tokenAddress = await env.deployERC20('MyToken', 'MTK');
+			await env.setupPermissions(tokenAddress, env.namedAccounts.deployer);
+			await env.verifyOnEtherscan(tokenAddress, ['MyToken', 'MTK']);
+
+			// Original environment is still fully accessible
+			console.log(`Deployed on network: ${env.network.name}`);
+			const deployment = env.get('MyToken');
+
+			return true;
+		},
+		{
+			tags: ['token', 'deploy'],
+			dependencies: ['setup'],
+			id: 'deploy-my-token',
+		}
+	);
+};
+
+// Export for potential use in actual tests
+export {testTypes, testScript, utilityFunctions};

package/src/executor/types.ts

@@ -30,3 +30,48 @@ export type ScriptCallback<
 	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
 	Deployments extends UnknownDeployments = UnknownDeployments
 > = (env: Environment<NamedAccounts, Data, Deployments>) => Promise<void>;
+
+/**
+ * Utility type to remove the first parameter from a function type
+ */
+type RemoveFirstParameter<T> = T extends (first: any, ...rest: infer R) => infer Return
+	? (...args: R) => Return
+	: never;
+
+/**
+ * Utility type to transform an object of functions by removing their first parameter
+ */
+type CurriedFunctions<T> = {
+	[K in keyof T]: RemoveFirstParameter<T[K]>;
+};
+
+/**
+ * Type for the enhanced environment proxy that includes both the original environment
+ * and the curried functions
+ */
+export type EnhancedEnvironment<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
+	Deployments extends UnknownDeployments = UnknownDeployments,
+	Functions extends Record<
+		string,
+		(env: Environment<NamedAccounts, Data, Deployments>, ...args: any[]) => any
+	> = Record<string, (env: Environment<NamedAccounts, Data, Deployments>, ...args: any[]) => any>
+> = Environment<NamedAccounts, Data, Deployments> & CurriedFunctions<Functions>;
+
+/**
+ * Type for a deploy script function that receives an enhanced environment
+ */
+export type EnhancedDeployScriptFunction<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
+	ArgumentsTypes = undefined,
+	Deployments extends UnknownDeployments = UnknownDeployments,
+	Functions extends Record<
+		string,
+		(env: Environment<NamedAccounts, Data, Deployments>, ...args: any[]) => any
+	> = Record<string, (env: Environment<NamedAccounts, Data, Deployments>, ...args: any[]) => any>
+> = (
+	env: EnhancedEnvironment<NamedAccounts, Data, Deployments, Functions>,
+	args?: ArgumentsTypes
+) => Promise<void | boolean>;

package/src/index.ts

@@ -1,7 +1,6 @@
 export * from './executor/index.js';
 export * from './executor/types.js';
 export * from './environment/types.js';
-export {extendEnvironment, handleSignerProtocol} from './environment/index.js';
 export {loadDeployments} from './environment/deployments.js';
 export * from './environment/utils/artifacts.js';
 export * from './environment/utils/chains.js';

package/src/internal/types.ts

@@ -1,5 +1,8 @@
+import {SignerProtocol} from '../environment/index.js';
+
 export type InternalEnvironment = {
 	exportDeploymentsAsTypes(): Promise<void>;
 	recoverTransactionsIfAny(): Promise<void>;
 	recordMigration(id: string): void;
+	getSignerProtocol(protocol: string): SignerProtocol | undefined;
 };

package/src/utils/curry.test.ts

@@ -0,0 +1,42 @@
+import type {Environment} from '../environment/types.js';
+import {withEnvironment} from './curry.js';
+
+// Mock environment for testing
+const mockEnv = {} as Environment;
+
+// Example functions that take environment as first parameter
+const exampleFunctions = {
+	deploy: (env: Environment, contractName: string, args: any[]): Promise<void> => {
+		return Promise.resolve();
+	},
+
+	verify: (env: Environment, address: string): Promise<boolean> => {
+		return Promise.resolve(true);
+	},
+
+	getBalance: (env: Environment, address: string): Promise<bigint> => {
+		return Promise.resolve(BigInt(0));
+	},
+
+	syncFunction: (env: Environment, value: number): number => {
+		return value * 2;
+	},
+};
+
+// Test the currying function
+const curriedFunctions = withEnvironment(mockEnv, exampleFunctions);
+
+// Type tests - these should compile without errors
+async function testTypes() {
+	// These calls should work without passing env
+	await curriedFunctions.deploy('MyContract', []);
+	const isVerified = await curriedFunctions.verify('0x123...');
+	const balance = await curriedFunctions.getBalance('0x456...');
+	const doubled = curriedFunctions.syncFunction(42);
+
+	console.log('Type tests passed!');
+	console.log({isVerified, balance, doubled});
+}
+
+// Export for potential use in actual tests
+export {testTypes, curriedFunctions, exampleFunctions};

package/src/utils/curry.ts

@@ -0,0 +1,60 @@
+import type {
+	Environment,
+	UnknownDeployments,
+	UnresolvedNetworkSpecificData,
+	UnresolvedUnknownNamedAccounts,
+} from '../environment/types.js';
+
+/**
+ * Utility type to remove the first parameter from a function type
+ */
+type RemoveFirstParameter<T> = T extends (first: any, ...rest: infer R) => infer Return
+	? (...args: R) => Return
+	: never;
+
+/**
+ * Utility type to transform an object of functions by removing their first parameter
+ */
+type CurriedFunctions<T> = {
+	[K in keyof T]: RemoveFirstParameter<T[K]>;
+};
+
+/**
+ * Creates a curried version of functions that automatically inject an environment as the first parameter.
+ *
+ * @param env - The environment object to inject as the first parameter
+ * @param functions - An object containing functions that expect the environment as their first parameter
+ * @returns An object with the same function names, but with the environment parameter removed
+ *
+ * @example
+ * ```typescript
+ * const functions = {
+ *   deploy: (env: Environment, contractName: string, args: any[]) => Promise<void>,
+ *   verify: (env: Environment, address: string) => Promise<boolean>
+ * };
+ *
+ * const curriedFunctions = withEnvironment(env, functions);
+ *
+ * // Now you can call without passing env:
+ * await curriedFunctions.deploy('MyContract', []);
+ * await curriedFunctions.verify('0x123...');
+ * ```
+ */
+export function withEnvironment<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
+	Deployments extends UnknownDeployments = UnknownDeployments,
+	T extends Record<string, (env: Environment<NamedAccounts, Data, Deployments>, ...args: any[]) => any> = Record<
+		string,
+		(env: Environment<NamedAccounts, Data, Deployments>, ...args: any[]) => any
+	>
+>(env: Environment<NamedAccounts, Data, Deployments>, functions: T): CurriedFunctions<T> {
+	const result = {} as CurriedFunctions<T>;
+
+	for (const [key, func] of Object.entries(functions)) {
+		// Create a new function that automatically passes the environment as the first argument
+		(result as any)[key] = (...args: any[]) => func(env, ...args);
+	}
+
+	return result;
+}