rocketh 0.15.14 → 0.16.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/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);
-}