rocketh 0.9.1 → 0.10.0

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-import { EIP1193Account, EIP1193DATA, EIP1193QUANTITY, EIP1193SignerProvider, EIP1193ProviderWithoutEvents, EIP1193WalletProvider, EIP1193TransactionReceipt } from 'eip-1193';
+import { EIP1193Account, EIP1193DATA, EIP1193QUANTITY, EIP1193SignerProvider, EIP1193ProviderWithoutEvents, EIP1193WalletProvider, EIP1193TransactionReceipt, EIP1193GenericRequestProvider } from 'eip-1193';
+import * as abitype from 'abitype';
 import { Abi, Narrow } from 'abitype';
 export { Abi, AbiConstructor, AbiError, AbiEvent, AbiFallback, AbiFunction, AbiReceive } from 'abitype';
-import { Chain, DeployContractParameters } from 'viem';
+import { Chain, Address, DeployContractParameters } from 'viem';
+import { Chain as Chain$1 } from 'viem/chains';
 
 type ProgressIndicator = {
     start(msg?: string): ProgressIndicator;
@@ -195,27 +197,38 @@ type Context<Artifacts extends UnknownArtifacts = UnknownArtifacts, NamedAccount
     accounts: NamedAccounts;
     artifacts: Artifacts;
 };
-type BaseConfig = {
-    networkName?: string;
+type NetworkConfigBase = {
+    name: string;
+    tags: string[];
+    fork?: boolean;
+};
+type NetworkConfigForJSONRPC = NetworkConfigBase & {
+    nodeUrl: string;
+};
+type NetworkConfigForEIP1193Provider = NetworkConfigBase & {
+    provider: EIP1193ProviderWithoutEvents;
+};
+type NetworkConfig = NetworkConfigForJSONRPC | NetworkConfigForEIP1193Provider;
+type Config = {
+    network: NetworkConfig;
+    networkTags?: string[];
     scripts?: string;
     deployments?: string;
+    saveDeployments?: boolean;
     tags?: string[];
     logLevel?: number;
     gasPricing?: {};
 };
-type ConfigForJSONRPC = BaseConfig & {
-    networkName: string;
-    nodeUrl: string;
-};
-type ConfigForEIP1193Provider = BaseConfig & {
-    provider: EIP1193ProviderWithoutEvents;
-};
-type Config = ConfigForJSONRPC | ConfigForEIP1193Provider;
 type ResolvedConfig = Config & {
     deployments: string;
     scripts: string;
     tags: string[];
-    networkName: string;
+    network: {
+        name: string;
+        tags: string[];
+        fork?: boolean;
+    };
+    saveDeployments?: boolean;
 };
 interface Environment<Artifacts extends UnknownArtifacts = UnknownArtifacts, NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts, Deployments extends UnknownDeployments = UnknownDeployments> {
     config: ResolvedConfig;
@@ -238,7 +251,15 @@ interface Environment<Artifacts extends UnknownArtifacts = UnknownArtifacts, Nam
     savePendingDeployment<TAbi extends Abi = Abi>(pendingDeployment: PendingDeployment<TAbi>): Promise<Deployment<TAbi>>;
     savePendingExecution(pendingExecution: PendingExecution): Promise<EIP1193TransactionReceipt>;
     get<TAbi extends Abi>(name: string): Deployment<TAbi>;
-    getOrNull<TAbi extends Abi>(name: string): Deployment<TAbi> | undefined;
+    getOrNull<TAbi extends Abi>(name: string): Deployment<TAbi> | null;
+    fromAddressToNamedABI<TAbi extends Abi>(address: Address): {
+        mergedABI: TAbi;
+        names: string[];
+    };
+    fromAddressToNamedABIOrNull<TAbi extends Abi>(address: Address): {
+        mergedABI: TAbi;
+        names: string[];
+    } | null;
     showMessage(message: string): void;
     showProgress(message?: string): ProgressIndicator;
 }
@@ -294,20 +315,22 @@ declare function execute<Artifacts extends UnknownArtifacts = UnknownArtifacts,
     dependencies?: string[];
 }): DeployScriptModule<Artifacts, NamedAccounts, ArgumentsType, Deployments>;
 type ConfigOptions = {
-    network: string;
+    network?: string | {
+        fork: string;
+    };
     deployments?: string;
     scripts?: string;
     tags?: string;
-};
-declare function readConfig(options: ConfigOptions, extra?: {
-    ignoreMissingRPC?: boolean;
-}): Config;
-declare function readAndResolveConfig(options: ConfigOptions, extra?: {
+    logLevel?: number;
+    provider?: EIP1193ProviderWithoutEvents | EIP1193GenericRequestProvider;
     ignoreMissingRPC?: boolean;
-}): ResolvedConfig;
+    saveDeployments?: boolean;
+};
+declare function readConfig(options: ConfigOptions): Config;
+declare function readAndResolveConfig(options: ConfigOptions): ResolvedConfig;
 declare function resolveConfig(config: Config): ResolvedConfig;
-declare function loadEnvironment<Artifacts extends UnknownArtifacts = UnknownArtifacts, NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts>(config: Config, context: ProvidedContext<Artifacts, NamedAccounts>): Promise<Environment>;
-declare function loadAndExecuteDeployments<Artifacts extends UnknownArtifacts = UnknownArtifacts, NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts, ArgumentsType = undefined, Deployments extends UnknownDeployments = UnknownDeployments>(config: Config, args?: ArgumentsType): Promise<Environment>;
+declare function loadEnvironment<Artifacts extends UnknownArtifacts = UnknownArtifacts, NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts>(options: ConfigOptions, context: ProvidedContext<Artifacts, NamedAccounts>): Promise<Environment>;
+declare function loadAndExecuteDeployments<Artifacts extends UnknownArtifacts = UnknownArtifacts, NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts, ArgumentsType = undefined, Deployments extends UnknownDeployments = UnknownDeployments>(options: ConfigOptions, args?: ArgumentsType): Promise<Environment>;
 declare function executeDeployScripts<Artifacts extends UnknownArtifacts = UnknownArtifacts, NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts, ArgumentsType = undefined, Deployments extends UnknownDeployments = UnknownDeployments>(config: ResolvedConfig, args?: ArgumentsType): Promise<Environment>;
 
 type EnvironmentExtenstion = (env: Environment) => Environment;
@@ -315,7 +338,7 @@ declare function extendEnvironment(extension: EnvironmentExtenstion): void;
 type SignerProtocolFunction = (protocolString: string) => Promise<NamedSigner>;
 declare function handleSignerProtocol(protocol: string, getSigner: SignerProtocolFunction): void;
 
-declare function loadDeployments(deploymentsPath: string, subPath: string, onlyABIAndAddress?: boolean, expectedChain?: {
+declare function loadDeployments(deploymentsPath: string, networkName: string, onlyABIAndAddress?: boolean, expectedChain?: {
     chainId: string;
     genesisHash?: `0x${string}`;
     deleteDeploymentsIfDifferentGenesisHash?: boolean;
@@ -325,4 +348,27 @@ declare function loadDeployments(deploymentsPath: string, subPath: string, onlyA
     genesisHash?: `0x${string}`;
 };
 
-export { type AccountDefinition, type AccountType, type Artifact, type Config, type ConfigOptions, type Context, type CreationGasEstimate, type DeployScriptFunction, type DeployScriptModule, type Deployment, type DeploymentConstruction, type DevDoc, type DevErrorDoc, type DevEventDoc, type DevMethodDoc, type Environment, type GasEstimate, type GasEstimates, type Libraries, type NamedSigner, type NoticeUserDoc, type PartialDeployment, type PendingDeployment, type PendingExecution, type PendingTransaction, type ProvidedContext, type ResolvedAccount, type ResolvedConfig, type ResolvedNamedAccounts, type ResolvedNamedSigners, type ScriptCallback, type Storage, type StorageLayout, type TypeDef, type UnknownArtifacts, type UnknownDeployments, type UnknownDeploymentsAcrossNetworks, type UnknownNamedAccounts, type UnresolvedUnknownNamedAccounts, type UserDoc, execute, executeDeployScripts, extendEnvironment, handleSignerProtocol, loadAndExecuteDeployments, loadDeployments, loadEnvironment, readAndResolveConfig, readConfig, resolveConfig };
+type CreateMutable<Type> = {
+    -readonly [Property in keyof Type]: Type[Property];
+};
+declare function mergeArtifacts(list: {
+    name: string;
+    artifact: Artifact<Abi>;
+}[]): {
+    mergedABI: (abitype.AbiConstructor | abitype.AbiError | abitype.AbiEvent | abitype.AbiFallback | abitype.AbiFunction | abitype.AbiReceive)[];
+    added: Map<string, abitype.AbiConstructor | abitype.AbiError | abitype.AbiEvent | abitype.AbiFallback | abitype.AbiFunction | abitype.AbiReceive>;
+    mergedDevDocs: CreateMutable<DevDoc>;
+    mergedUserDocs: CreateMutable<UserDoc>;
+    sigJSMap: Map<`0x${string}`, {
+        index: number;
+        routeName: string;
+        functionName: string;
+    }>;
+};
+
+declare const chainById: {
+    [chainId: string]: Chain$1;
+};
+declare function getChain(id: string): Chain$1;
+
+export { type AccountDefinition, type AccountType, type Artifact, type Config, type ConfigOptions, type Context, type CreationGasEstimate, type DeployScriptFunction, type DeployScriptModule, type Deployment, type DeploymentConstruction, type DevDoc, type DevErrorDoc, type DevEventDoc, type DevMethodDoc, type Environment, type GasEstimate, type GasEstimates, type Libraries, type NamedSigner, type NetworkConfig, type NoticeUserDoc, type PartialDeployment, type PendingDeployment, type PendingExecution, type PendingTransaction, type ProvidedContext, type ResolvedAccount, type ResolvedConfig, type ResolvedNamedAccounts, type ResolvedNamedSigners, type ScriptCallback, type Storage, type StorageLayout, type TypeDef, type UnknownArtifacts, type UnknownDeployments, type UnknownDeploymentsAcrossNetworks, type UnknownNamedAccounts, type UnresolvedUnknownNamedAccounts, type UserDoc, chainById, execute, executeDeployScripts, extendEnvironment, getChain, handleSignerProtocol, loadAndExecuteDeployments, loadDeployments, loadEnvironment, mergeArtifacts, readAndResolveConfig, readConfig, resolveConfig };

package/dist/index.js

@@ -1,23 +1,29 @@
 import {
+  chainById,
   execute,
   executeDeployScripts,
   extendEnvironment,
+  getChain,
   handleSignerProtocol,
   loadAndExecuteDeployments,
   loadDeployments,
   loadEnvironment,
+  mergeArtifacts,
   readAndResolveConfig,
   readConfig,
   resolveConfig
-} from "./chunk-LPKP3ACG.js";
+} from "./chunk-4RQLWJEN.js";
 export {
+  chainById,
   execute,
   executeDeployScripts,
   extendEnvironment,
+  getChain,
   handleSignerProtocol,
   loadAndExecuteDeployments,
   loadDeployments,
   loadEnvironment,
+  mergeArtifacts,
   readAndResolveConfig,
   readConfig,
   resolveConfig

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rocketh",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "deploy smart contract on ethereum-compatible networks",
   "publishConfig": {
     "access": "public"
@@ -28,6 +28,7 @@
     "eip-1193-jsonrpc-provider": "^0.3.0",
     "esbuild": "^0.20.1",
     "esbuild-register": "^3.5.0",
+    "ethers": "^6.11.1",
     "figlet": "^1.7.0",
     "ldenv": "^0.3.9",
     "named-logs": "^0.2.2",

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});

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

@@ -4,6 +4,7 @@ import {TransactionReceipt, createPublicClient, custom} from 'viem';
 
 import {
 	AccountType,
+	Artifact,
 	Deployment,
 	Environment,
 	NamedSigner,
@@ -18,7 +19,7 @@ import {
 	UnresolvedUnknownNamedAccounts,
 } from './types';
 import {JSONRPCHTTPProvider} from 'eip-1193-jsonrpc-provider';
-import {Abi} from 'abitype';
+import {Abi, Address} from 'abitype';
 import {InternalEnvironment} from '../internal/types';
 import path from 'node:path';
 import {JSONToString, stringToJSON} from '../utils/json';
@@ -35,6 +36,7 @@ import {ProvidedContext} from '../executor/types';
 import {ProgressIndicator, log, spin} from '../internal/logging';
 import {PendingExecution} from './types';
 import {getChain} from './utils/chains';
+import {mergeArtifacts} from './utils/artifacts';
 
 type ReceiptResult = {receipt: EIP1193TransactionReceipt; latestBlockNumber: EIP1193QUANTITY};
 
@@ -83,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});
@@ -98,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} = {};
@@ -203,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} = {};
@@ -280,8 +302,35 @@ export async function createEnvironment<
 		return deployment;
 	}
 
-	function getOrNull<TAbi extends Abi>(name: string): Deployment<TAbi> | undefined {
-		return deployments[name] as Deployment<TAbi> | undefined;
+	function getOrNull<TAbi extends Abi>(name: string): Deployment<TAbi> | null {
+		return (deployments[name] || null) as Deployment<TAbi> | null;
+	}
+
+	function fromAddressToNamedABIOrNull<TAbi extends Abi>(address: Address): {mergedABI: TAbi; names: string[]} | null {
+		let list: {name: string; artifact: Artifact<Abi>}[] = [];
+		for (const name of Object.keys(deployments)) {
+			const deployment = deployments[name];
+			if (deployment.address.toLowerCase() == address.toLowerCase()) {
+				list.push({name, artifact: deployment});
+			}
+		}
+		if (list.length === 0) {
+			return null;
+		}
+
+		const {mergedABI} = mergeArtifacts(list);
+		return {
+			mergedABI: mergedABI as unknown as TAbi,
+			names: list.map((v) => v.name),
+		};
+	}
+
+	function fromAddressToNamedABI<TAbi extends Abi>(address: Address): {mergedABI: TAbi; names: string[]} {
+		const n = fromAddressToNamedABIOrNull<TAbi>(address);
+		if (!n) {
+			throw new Error(`could not find artifact for address ${address}`);
+		}
+		return n;
 	}
 
 	async function save<TAbi extends Abi>(name: string, deployment: Deployment<TAbi>): Promise<Deployment<TAbi>> {
@@ -594,6 +643,8 @@ export async function createEnvironment<
 		savePendingExecution,
 		get,
 		getOrNull,
+		fromAddressToNamedABI,
+		fromAddressToNamedABIOrNull,
 		showMessage,
 		showProgress,
 	};

package/src/environment/types.ts

@@ -9,7 +9,7 @@ import {
 	EIP1193WalletProvider,
 } from 'eip-1193';
 import {Abi, Narrow, AbiError, AbiEvent, AbiConstructor, AbiFallback, AbiFunction, AbiReceive} from 'abitype';
-import type {DeployContractParameters} from 'viem';
+import type {Address, DeployContractParameters} from 'viem';
 import type {Chain} from 'viem';
 import {ProgressIndicator} from '../internal/logging';
 
@@ -209,30 +209,47 @@ 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[];
+
 	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;
 };
 
-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,
@@ -254,7 +271,9 @@ export interface Environment<
 	savePendingDeployment<TAbi extends Abi = Abi>(pendingDeployment: PendingDeployment<TAbi>): Promise<Deployment<TAbi>>;
 	savePendingExecution(pendingExecution: PendingExecution): Promise<EIP1193TransactionReceipt>;
 	get<TAbi extends Abi>(name: string): Deployment<TAbi>;
-	getOrNull<TAbi extends Abi>(name: string): Deployment<TAbi> | undefined;
+	getOrNull<TAbi extends Abi>(name: string): Deployment<TAbi> | null;
+	fromAddressToNamedABI<TAbi extends Abi>(address: Address): {mergedABI: TAbi; names: string[]};
+	fromAddressToNamedABIOrNull<TAbi extends Abi>(address: Address): {mergedABI: TAbi; names: string[]} | null;
 	showMessage(message: string): void;
 	showProgress(message?: string): ProgressIndicator;
 }

package/src/environment/utils/artifacts.ts

@@ -0,0 +1,151 @@
+import {Abi} from 'abitype';
+import {Artifact, DevDoc, UserDoc} from '../types';
+import {FunctionFragment} from 'ethers';
+
+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 mergeArtifacts(list: {name: string; artifact: Artifact<Abi>}[]) {
+	const mergedABI: CreateMutable<Abi> = [];
+	const added: Map<string, ArrayElement<Abi>> = new Map();
+	const mergedDevDocs: CreateMutable<DevDoc> = {kind: 'dev', version: 1, methods: {}};
+	const mergedUserDocs: CreateMutable<UserDoc> = {kind: 'user', version: 1, methods: {}};
+	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.artifact.abi) {
+			if (element.type === 'function') {
+				// const selector = getFunctionSelector(element);
+				const selector = FunctionFragment.from(element).selector as `0x${string}`;
+				if (sigJSMap.has(selector)) {
+					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}")  `
+					);
+				}
+				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);
+				// 	}
+				// }
+			}
+		}
+		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,
+	};
+}