rocketh 0.15.15 → 0.17.0-next.0

package/src/utils/extensions.test.ts

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

package/src/utils/extensions.ts

@@ -1,72 +0,0 @@
-import type {
-	Environment,
-	UnknownDeployments,
-	UnresolvedNetworkSpecificData,
-	UnresolvedUnknownNamedAccounts,
-	CurriedFunctions,
-} from '../types.js';
-
-/**
- * @param env - The environment object to inject as the first parameter
- * @param functionsAndGetters - An object containing functions that expect the environment as their first parameter,
- *                             or getter functions that return a value from the environment
- * @returns An object with the same function/property names, but with the environment parameter removed
- *
- * @example
- * ```typescript
- * const functionsAndGetters = {
- *   // Functions that expect env as first parameter
- *   deploy: (env: Environment, contractName: string, args: any[]) => Promise<void>,
- *   verify: (env: Environment, address: string) => Promise<boolean>,
- *
- *   // Getter properties that can be accessed directly
- *   myValue: (env: Environment) => env.someValue,
- *   networkId: (env: Environment) => env.network.id
- * };
- *
- * const enhancedEnv = withEnvironment(env, functionsAndGetters);
- *
- * // Now you can call functions without passing env:
- * await enhancedEnv.deploy('MyContract', []);
- * await enhancedEnv.verify('0x123...');
- *
- * // And access getter properties directly:
- * console.log(enhancedEnv.myValue);
- * console.log(enhancedEnv.networkId);
- * ```
- */
-export function withEnvironment<
-	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
-	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
-	Deployments extends UnknownDeployments = UnknownDeployments,
-	Extra extends Record<string, unknown> = Record<string, unknown>,
-	T extends Record<
-		string,
-		| ((env: Environment<NamedAccounts, Data, Deployments, Extra>) => (...args: any[]) => any)
-		| ((env: Environment<NamedAccounts, Data, Deployments, Extra>) => any)
-	> = Record<
-		string,
-		| ((env: Environment<NamedAccounts, Data, Deployments>) => (...args: any[]) => any)
-		| ((env: Environment<NamedAccounts, Data, Deployments>) => any)
-	>
->(env: Environment<NamedAccounts, Data, Deployments, Extra>, functionsAndGetters: T): CurriedFunctions<T> {
-	const result = {} as CurriedFunctions<T>;
-
-	for (const [key, func] of Object.entries(functionsAndGetters)) {
-		// Check if the function is a getter or a regular function
-		const value = func(env);
-
-		if (typeof value === 'function') {
-			// Regular function case: Create a function that automatically passes the environment
-			(result as any)[key] = (...args: any[]) => func(env)(...args);
-		} else {
-			// Getter case: Define property with getter that returns the value
-			Object.defineProperty(result, key, {
-				get: () => func(env),
-				enumerable: true,
-			});
-		}
-	}
-
-	return result;
-}

package/src/utils/fs.ts

@@ -1,70 +0,0 @@
-// taken from https://github.com/vitejs/vite/blob/63524bac878e8d3771d34ad7ad2e10cd16870ff4/packages/vite/src/node/utils.ts#L371-L400
-import fs from 'node:fs';
-import path from 'node:path';
-
-interface LookupFileOptions {
-	pathOnly?: boolean;
-	rootDir?: string;
-	predicate?: (file: string) => boolean;
-}
-
-export function lookupFile(dir: string, formats: string[], options?: LookupFileOptions): string | undefined {
-	for (const format of formats) {
-		const fullPath = path.join(dir, format);
-		if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
-			const result = options?.pathOnly ? fullPath : fs.readFileSync(fullPath, 'utf-8');
-			if (!options?.predicate || options.predicate(result)) {
-				return result;
-			}
-		}
-	}
-	const parentDir = path.dirname(dir);
-	if (parentDir !== dir && (!options?.rootDir || parentDir.startsWith(options?.rootDir))) {
-		return lookupFile(parentDir, formats, options);
-	}
-}
-
-export function traverseMultipleDirectory(dirs: readonly string[]): string[] {
-	const filepaths = [];
-	for (const dir of dirs) {
-		let filesStats = traverse(dir);
-		filesStats = filesStats.filter((v) => !v.directory);
-		for (const filestat of filesStats) {
-			filepaths.push(path.join(dir, filestat.relativePath));
-		}
-	}
-	return filepaths;
-}
-
-export const traverse = function (
-	dir: string,
-	result: any[] = [],
-	topDir?: string,
-	filter?: (name: string, stats: any) => boolean // TODO any is Stats
-): Array<{
-	name: string;
-	path: string;
-	relativePath: string;
-	mtimeMs: number;
-	directory: boolean;
-}> {
-	fs.readdirSync(dir).forEach((name) => {
-		const fPath = path.resolve(dir, name);
-		const stats = fs.statSync(fPath);
-		if ((!filter && !name.startsWith('.')) || (filter && filter(name, stats))) {
-			const fileStats = {
-				name,
-				path: fPath,
-				relativePath: path.relative(topDir || dir, fPath),
-				mtimeMs: stats.mtimeMs,
-				directory: stats.isDirectory(),
-			};
-			if (fileStats.directory) {
-				result.push(fileStats);
-				return traverse(fPath, result, topDir || dir, filter);
-			}
-			result.push(fileStats);
-		}
-	});
-	return result;
-};

package/src/utils/json.ts

@@ -1,33 +0,0 @@
-// TODO share with db-utils
-export function postfixBigIntReplacer(k: string, v: any): any {
-	if (typeof v === 'bigint') {
-		return v.toString() + 'n';
-	}
-	return v;
-}
-
-export function bigIntToStringReplacer(k: string, v: any): any {
-	if (typeof v === 'bigint') {
-		return v.toString();
-	}
-	return v;
-}
-
-export function postfixBigIntReviver(k: string, v: any): any {
-	if (
-		typeof v === 'string' &&
-		(v.startsWith('-') ? !isNaN(parseInt(v.charAt(1))) : !isNaN(parseInt(v.charAt(0)))) &&
-		v.charAt(v.length - 1) === 'n'
-	) {
-		return BigInt(v.slice(0, -1));
-	}
-	return v;
-}
-
-export function JSONToString<T = unknown>(json: unknown, space?: string | number) {
-	return JSON.stringify(json, bigIntToStringReplacer, space);
-}
-
-export function stringToJSON<T = unknown>(str: string): T {
-	return JSON.parse(str);
-}

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-	"compilerOptions": {
-		"strict": true,
-		"strictNullChecks": true,
-		"target": "ESNext",
-		"module": "NodeNext",
-		"lib": ["ESNext", "dom"],
-		"moduleResolution": "NodeNext",
-		"resolveJsonModule": true,
-		"skipLibCheck": true,
-		"sourceMap": true,
-		"declaration": true,
-		"declarationMap": true,
-		"rootDir": "./src",
-		"outDir": "./dist"
-	},
-	"include": ["src/**/*.ts"]
-}