@rocketh/core 0.17.7 → 0.17.9

package/src/artifacts.ts

@@ -0,0 +1,176 @@
+import type {Abi} from 'abitype';
+import type {Artifact, DevDoc, UserDoc} from './types.js';
+import {toFunctionSelector} from 'viem';
+
+type CreateMutable<Type> = {
+	-readonly [Property in keyof Type]: Type[Property];
+};
+
+type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[]
+	? ElementType
+	: never;
+
+// from https://gist.github.com/egardner/efd34f270cc33db67c0246e837689cb9
+function deepEqual(obj1: any, obj2: any): boolean {
+	// Private
+	function isObject(obj: any) {
+		if (typeof obj === 'object' && obj != null) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	if (obj1 === obj2) {
+		return true;
+	} else if (isObject(obj1) && isObject(obj2)) {
+		if (Object.keys(obj1).length !== Object.keys(obj2).length) {
+			return false;
+		}
+		for (var prop in obj1) {
+			if (!deepEqual(obj1[prop], obj2[prop])) {
+				return false;
+			}
+		}
+		return true;
+	}
+	return false;
+}
+
+function mergeDoc(values: any, mergedDevDocs: any, field: string) {
+	if (values[field]) {
+		const mergedEventDocs = (mergedDevDocs[field] = mergedDevDocs[field] || {});
+		for (const signature of Object.keys(values[field])) {
+			if (mergedEventDocs[signature] && !deepEqual(mergedEventDocs[signature], values[field][signature])) {
+				throw new Error(`Doc ${field} conflict: "${signature}" `);
+			}
+			mergedEventDocs[signature] = values[field][signature];
+		}
+	}
+}
+
+export function mergeABIs(list: {name: string; abi: Abi}[], options?: {doNotCheckForConflicts?: boolean}) {
+	const added: Map<string, ArrayElement<Abi>> = new Map();
+	const mergedABI: CreateMutable<Abi> = [];
+	const sigJSMap: Map<`0x${string}`, {index: number; routeName: string; functionName: string}> = new Map();
+	for (let i = 0; i < list.length; i++) {
+		const listElem = list[i];
+		for (const element of listElem.abi) {
+			if (element.type === 'function') {
+				// const selector = getFunctionSelector(element);
+				const selector = toFunctionSelector(element);
+				if (sigJSMap.has(selector)) {
+					if (!options?.doNotCheckForConflicts) {
+						const existing = sigJSMap.get(selector);
+						throw new Error(
+							`ABI conflict: ${existing!.routeName} has function "${existing!.functionName}" which conflict with ${
+								listElem.name
+							}'s "${element.name}" (selector: "${selector}")  `,
+						);
+					} else {
+						continue;
+					}
+				}
+				sigJSMap.set(selector, {index: i, routeName: listElem.name, functionName: element.name});
+
+				const exists = added.has(element.name);
+				if (exists) {
+					// TODO check if same
+				} else {
+					added.set(element.name, element);
+					mergedABI.push(element);
+				}
+			} else if (element.type === 'constructor') {
+				// we skip it
+			} else if (element.type === 'error') {
+				const exists = added.has(element.name);
+				if (exists) {
+					// TODO check if same
+				} else {
+					added.set(element.name, element);
+					mergedABI.push(element);
+				}
+			} else if (element.type === 'event') {
+				const exists = added.has(element.name);
+				if (exists) {
+					// TODO check if same
+				} else {
+					added.set(element.name, element);
+					mergedABI.push(element);
+				}
+			} else if (element.type === 'fallback') {
+			} else if (element.type === 'receive') {
+			} else {
+				// if ('name' in element) {
+				// 	const exists = added.has(element.name);
+				// 	if (exists) {
+				// 		// TODO check if same
+				// 	} else {
+				// 		added.set(element.name, element);
+				// 		mergedABI.push(element);
+				// 	}
+				// }
+			}
+		}
+	}
+
+	return {
+		mergedABI,
+		added,
+		sigJSMap,
+	};
+}
+
+export function mergeArtifacts(
+	list: {name: string; artifact: Partial<Artifact<Abi>> & {abi: Abi}}[],
+	options?: {doNotCheckForConflicts?: boolean},
+) {
+	const {mergedABI, added, sigJSMap} = mergeABIs(
+		list.map((v) => ({name: v.name, abi: v.artifact.abi})),
+		options,
+	);
+
+	const mergedDevDocs: CreateMutable<DevDoc> = {kind: 'dev', version: 1, methods: {}};
+	const mergedUserDocs: CreateMutable<UserDoc> = {kind: 'user', version: 1, methods: {}};
+
+	for (let i = 0; i < list.length; i++) {
+		const listElem = list[i];
+
+		const devdoc = listElem.artifact.devdoc;
+		if (devdoc) {
+			mergeDoc(devdoc, mergedDevDocs, 'events');
+			mergeDoc(devdoc, mergedDevDocs, 'errors');
+			mergeDoc(devdoc, mergedDevDocs, 'methods');
+			if (devdoc.author) {
+				if (mergedDevDocs.author && mergedDevDocs.author != devdoc.author) {
+					throw new Error(`DevDoc author conflict `);
+				}
+				mergedDevDocs.author = devdoc.author;
+				if (mergedDevDocs.title && mergedDevDocs.title != devdoc.title) {
+					throw new Error(`DevDoc title conflict `);
+				}
+				mergedDevDocs.title = devdoc.title;
+			}
+		}
+
+		const userdoc = listElem.artifact.userdoc;
+		if (userdoc) {
+			mergeDoc(userdoc, mergedUserDocs, 'events');
+			mergeDoc(userdoc, mergedUserDocs, 'errors');
+			mergeDoc(userdoc, mergedUserDocs, 'methods');
+			if (userdoc.notice) {
+				if (mergedUserDocs.notice && mergedUserDocs.notice != userdoc.notice) {
+					throw new Error(`UserDoc notice conflict `);
+				}
+				mergedUserDocs.notice = userdoc.notice;
+			}
+		}
+	}
+	return {
+		mergedABI,
+		added,
+		mergedDevDocs,
+		mergedUserDocs,
+		sigJSMap,
+	};
+}

package/src/environment.ts

@@ -0,0 +1,98 @@
+import {
+	EnhancedEnvironment,
+	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;
+}
+
+export function enhanceEnvIfNeeded<
+	Extensions extends Record<string, (env: Environment<any, any, any>) => any> = {},
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
+	Extra extends Record<string, unknown> = Record<string, unknown>,
+>(
+	env: Environment,
+	extensions: Extensions,
+): EnhancedEnvironment<NamedAccounts, Data, UnknownDeployments, Extensions, Extra> {
+	// Use the original env object as the base
+	const enhancedEnv = env as EnhancedEnvironment<NamedAccounts, Data, UnknownDeployments, Extensions, Extra>;
+
+	// Only create curried functions for extensions not already present in env
+	for (const key in extensions) {
+		if (!Object.prototype.hasOwnProperty.call(env, key)) {
+			// Create curried function only for this specific extension
+			const singleExtension: Record<string, unknown> = {};
+			singleExtension[key] = (extensions as any)[key];
+			const curriedFunction = withEnvironment(env, singleExtension as any);
+			(enhancedEnv as any)[key] = (curriedFunction as any)[key];
+		}
+	}
+	return enhancedEnv;
+}

package/src/index.ts

@@ -0,0 +1,24 @@
+// Re-export types
+export type * from './types.js';
+
+// Re-export JSON utilities
+export {
+	postfixBigIntReplacer,
+	bigIntToStringReplacer,
+	postfixBigIntReviver,
+	JSONToString,
+	stringToJSON,
+	toJSONCompatibleLinkedData,
+} from './json.js';
+
+// Re-export artifact utilities
+export {mergeABIs, mergeArtifacts} from './artifacts.js';
+
+// Re-export environment utilities
+export {withEnvironment, enhanceEnvIfNeeded} from './environment.js';
+
+// Re-export providers
+export {TransactionHashTrackerProvider, type TransactionHashTracker} from './providers/index.js';
+
+// Re-export account utilities
+export {resolveAccount, resolveAccountOrUndefined} from './account.js';

package/src/json.ts

@@ -0,0 +1,63 @@
+import type {LinkedDataProvided, LinkedData, JSONType, JSONTypePlusBigInt} from './types.js';
+
+// 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);
+}
+
+/**
+ * Convert a LinkedDataProvided object into LinkedData by turning every
+ * bigint into its string representation (recursively).
+ */
+export function toJSONCompatibleLinkedData(input: LinkedDataProvided | undefined): LinkedData | undefined {
+	if (!input) {
+		return undefined;
+	}
+	return Object.fromEntries(Object.entries(input).map(([k, v]) => [k, walk(v)]));
+}
+
+/* ---------- internal helpers ---------- */
+
+function walk(node: JSONTypePlusBigInt): JSONType {
+	if (typeof node === 'bigint') return node.toString();
+
+	if (Array.isArray(node)) return node.map(walk);
+
+	if (node && typeof node === 'object') {
+		const out: Record<string, JSONType> = {};
+		for (const [k, v] of Object.entries(node)) out[k] = walk(v);
+		return out;
+	}
+
+	/* string | number | boolean | null */
+	return node;
+}

package/src/providers/BaseProvider.ts

@@ -0,0 +1,13 @@
+import {EIP1193GenericRequest, EIP1193GenericRequestProvider, EIP1193ProviderWithoutEvents} from 'eip-1193';
+
+export abstract class BaseProvider implements EIP1193ProviderWithoutEvents {
+	constructor(protected provider: EIP1193ProviderWithoutEvents) {}
+
+	request(args: any): Promise<any> {
+		return this._request(args);
+	}
+
+	protected abstract _request<T = unknown, V extends EIP1193GenericRequest = EIP1193GenericRequest>(
+		args: V,
+	): Promise<T>;
+}

package/src/providers/TransactionHashTracker.ts

@@ -0,0 +1,26 @@
+import type {EIP1193GenericRequest, EIP1193ProviderWithoutEvents} from 'eip-1193';
+import {BaseProvider} from './BaseProvider.js';
+import {logs} from 'named-logs';
+
+const console = logs('rocketh-provider');
+
+export class TransactionHashTrackerProvider extends BaseProvider implements EIP1193ProviderWithoutEvents {
+	public transactionHashes: `0x${string}`[] = [];
+
+	constructor(provider: EIP1193ProviderWithoutEvents) {
+		super(provider);
+	}
+
+	protected async _request<T = unknown, V extends EIP1193GenericRequest = EIP1193GenericRequest>(args: V): Promise<T> {
+		console.debug(`calling ${args.method} with ${args.params?.length || 0} arguments`);
+		const response = await this.provider.request(args as any);
+		if (args.method === 'eth_sendRawTransaction' || args.method === 'eth_sendTransaction') {
+			this.transactionHashes.push(response as `0x${string}`);
+		}
+		return response as T;
+	}
+}
+
+export type TransactionHashTracker = EIP1193ProviderWithoutEvents & {
+	transactionHashes: `0x${string}`[];
+};

package/src/providers/index.ts

@@ -0,0 +1 @@
+export * from './TransactionHashTracker.js';