forge-pack 0.2.0 → 0.3.0

package/dist/cli.mjs

@@ -1,10 +1,45 @@
-import { i as resolveLibraries, n as generateDeployer, r as parseArtifact, t as findArtifact } from "./pack-Be_7Cz7w.mjs";
+import { i as parseArtifact, n as resolveLibraries, r as findArtifact, t as generateDeployer } from "./codegen--WByOfZu.mjs";
 import { parseArgs } from "node:util";
 import { execSync } from "node:child_process";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 
+//#region src/deploy-helper.ts
+const DEPLOY_HELPER_SOL = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+library DeployHelper {
+    function deploy(bytes memory initcode, bytes32 salt) internal returns (address contractAddress) {
+        assembly ("memory-safe") {
+            contractAddress := create2(callvalue(), add(initcode, 32), mload(initcode), salt)
+            if iszero(contractAddress) {
+                let ptr := mload(0x40)
+                let errorSize := returndatasize()
+                returndatacopy(ptr, 0, errorSize)
+                revert(ptr, errorSize)
+            }
+        }
+    }
+
+    function deploy(bytes memory initcode) internal returns (address contractAddress) {
+        contractAddress = deploy(initcode, bytes32(0));
+    }
+
+    /// @dev Deploys a library using CREATE2 with zero salt.
+    ///      If the library is already deployed (duplicate across contracts), returns the existing address.
+    function deployLibrary(bytes memory initcode) internal returns (address contractAddress) {
+        bytes32 salt = bytes32(0);
+        contractAddress = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, keccak256(initcode))))));
+        if (contractAddress.code.length > 0) return contractAddress;
+        contractAddress = deploy(initcode, salt);
+    }
+}
+`;
+
+//#endregion
 //#region src/cli.ts
+const pkgPath = new URL("../package.json", import.meta.url);
+const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
 const { values, positionals } = parseArgs({
 	allowPositionals: true,
 	options: {
@@ -20,11 +55,15 @@ const { values, positionals } = parseArgs({
 			type: "boolean",
 			default: false
 		},
-		solc: { type: "string" },
 		pragma: {
 			type: "string",
 			default: ">=0.8.0"
 		},
+		version: {
+			type: "boolean",
+			short: "v",
+			default: false
+		},
 		help: {
 			type: "boolean",
 			short: "h",
@@ -32,19 +71,22 @@ const { values, positionals } = parseArgs({
 		}
 	}
 });
+if (values.version) {
+	console.log(pkg.version);
+	process.exit(0);
+}
 if (values.help || positionals.length === 0) {
-	console.log(`Usage: forge-pack <ContractName> [options]
+	console.log(`Usage: forge-pack <ContractName...> [options]
 
 Options:
   --out <dir>        Forge output directory (default: ./out)
-  --output <dir>     Where to write the deployer .sol file (default: ./deployers)
+  --output <dir>     Where to write the deployer .sol files (default: ./deployers)
   --build            Run \`forge build\` before reading artifacts
-  --solc <version>   Filter artifact by solc version (when multiple exist)
-  --pragma <range>   Solidity pragma for generated file (default: >=0.8.0)
+  --pragma <range>   Solidity pragma for generated files (default: >=0.8.0)
+  -v, --version      Show version number
   -h, --help         Show this help message`);
 	process.exit(values.help ? 0 : 1);
 }
-const contractName = positionals[0];
 const outDir = resolve(values.out);
 const outputDir = resolve(values.output);
 const pragma = values.pragma;
@@ -52,18 +94,27 @@ if (values.build) {
 	console.log("Running forge build...");
 	execSync("forge build", { stdio: "inherit" });
 }
-try {
-	const parsed = parseArtifact(findArtifact(contractName, outDir, { solcVersion: values.solc }), contractName);
+const utilsDir = join(outputDir, "utils");
+const deployHelperPath = join(utilsDir, "DeployHelper.sol");
+mkdirSync(utilsDir, { recursive: true });
+if (!existsSync(deployHelperPath)) {
+	writeFileSync(deployHelperPath, DEPLOY_HELPER_SOL);
+	console.log(`Generated ${deployHelperPath}`);
+}
+let hasError = false;
+for (const contractName of positionals) try {
+	const parsed = parseArtifact(findArtifact(contractName, outDir), contractName);
 	if (!parsed.bytecode) {
 		console.error(`Error: No bytecode found for "${contractName}". Is it an abstract contract or interface?`);
-		process.exit(1);
+		hasError = true;
+		continue;
 	}
 	const hasLinks = Object.keys(parsed.linkReferences).length > 0;
 	let libraries;
 	if (hasLinks) {
 		libraries = resolveLibraries(parsed.linkReferences, outDir);
 		const libNames = libraries.map((l) => l.lib);
-		console.log(`Resolved ${libNames.length} library dep(s): ${libNames.join(", ")}`);
+		console.log(`[${contractName}] Resolved ${libNames.length} library dep(s): ${libNames.join(", ")}`);
 	}
 	const solidity = generateDeployer(parsed, {
 		pragma,
@@ -74,9 +125,10 @@ try {
 	writeFileSync(outPath, solidity);
 	console.log(`Generated ${outPath}`);
 } catch (err) {
-	console.error(`Error: ${err.message}`);
-	process.exit(1);
+	console.error(`Error [${contractName}]: ${err.message}`);
+	hasError = true;
 }
+if (hasError) process.exit(1);
 
 //#endregion
 export {  };

package/dist/{pack-Be_7Cz7w.mjs → codegen--WByOfZu.mjs}

@@ -1,8 +1,8 @@
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 
-//#region src/pack.ts
-function findArtifact(contractName, outDir, options) {
+//#region src/artifact.ts
+function findArtifact(contractName, outDir) {
 	const candidates = [];
 	const entries = readdirSync(outDir);
 	for (const entry of entries) {
@@ -15,11 +15,6 @@ function findArtifact(contractName, outDir, options) {
 		} catch {}
 	}
 	if (candidates.length === 0) throw new Error(`No artifact found for "${contractName}" in ${outDir}. Run \`forge build\` first.`);
-	if (options?.solcVersion && candidates.length > 1) {
-		for (const c of candidates) if ((JSON.parse(readFileSync(c, "utf-8"))?.metadata?.compiler?.version)?.startsWith(options.solcVersion)) return c;
-		throw new Error(`No artifact for "${contractName}" compiled with solc ${options.solcVersion}.`);
-	}
-	if (candidates.length > 1) throw new Error(`Multiple artifacts found for "${contractName}". Use --solc to disambiguate:\n` + candidates.map((c) => `  ${c}`).join("\n"));
 	return candidates[0];
 }
 function parseArtifact(artifactPath, contractName) {
@@ -34,6 +29,7 @@ function parseArtifact(artifactPath, contractName) {
 	const optimizerRuns = settings?.optimizer?.runs;
 	const viaIR = settings?.viaIR;
 	const evmVersion = settings?.evmVersion;
+	const bytecodeHash = metadata?.settings?.metadata?.bytecodeHash ?? settings?.metadata?.bytecodeHash;
 	let sourcePath;
 	if (metadata?.settings?.compilationTarget) {
 		const targets = metadata.settings.compilationTarget;
@@ -48,13 +44,13 @@ function parseArtifact(artifactPath, contractName) {
 		solcVersion,
 		optimizerRuns,
 		viaIR,
-		evmVersion
+		evmVersion,
+		bytecodeHash
 	};
 }
-/**
-* Collect unique library identities from linkReferences.
-* Returns deduped entries as { file, lib } pairs.
-*/
+
+//#endregion
+//#region src/resolve.ts
 function collectLibIds(linkRefs) {
 	const seen = /* @__PURE__ */ new Set();
 	const result = [];
@@ -76,6 +72,7 @@ function makeParamName(libName) {
 /**
 * Recursively resolve all library dependencies for a contract's linkReferences.
 * Returns libraries in topological order (deploy-order: leaves first).
+* Disambiguates duplicate paramName values with numeric suffixes.
 */
 function resolveLibraries(linkRefs, outDir) {
 	const resolved = /* @__PURE__ */ new Map();
@@ -105,8 +102,31 @@ function resolveLibraries(linkRefs, outDir) {
 	}
 	const topLevel = collectLibIds(linkRefs);
 	for (const { file, lib } of topLevel) resolve(file, lib);
-	return Array.from(resolved.values());
+	const libs = Array.from(resolved.values());
+	const nameCount = /* @__PURE__ */ new Map();
+	for (const entry of libs) {
+		const count = nameCount.get(entry.paramName) ?? 0;
+		nameCount.set(entry.paramName, count + 1);
+	}
+	const collisions = /* @__PURE__ */ new Set();
+	for (const [name, count] of nameCount) if (count > 1) collisions.add(name);
+	if (collisions.size > 0) {
+		const nameIndex = /* @__PURE__ */ new Map();
+		for (const entry of libs) {
+			if (!collisions.has(entry.paramName)) continue;
+			const idx = (nameIndex.get(entry.paramName) ?? 0) + 1;
+			nameIndex.set(entry.paramName, idx);
+			if (idx > 1) entry.paramName = `${entry.paramName}${idx}`;
+		}
+		const keyToName = /* @__PURE__ */ new Map();
+		for (const entry of libs) keyToName.set(`${entry.file}:${entry.lib}`, entry.paramName);
+		for (const entry of libs) entry.deps = collectLibIds(entry.artifact.linkReferences).map((d) => keyToName.get(`${d.file}:${d.lib}`));
+	}
+	return libs;
 }
+
+//#endregion
+//#region src/codegen.ts
 function extractStructName(internalType) {
 	let name = internalType.replace(/^struct\s+/, "");
 	name = name.replace(/(\[\d*\])+$/, "");
@@ -216,13 +236,31 @@ function renderInitcodeBody(bytecode, segments, hasLinks) {
 	if (!hasLinks) return `        return hex"${bytecode}";`;
 	return `        return abi.encodePacked(${segments.map((seg) => seg.type === "hex" ? `hex"${seg.value}"` : seg.value).join(", ")});`;
 }
+function renderDeployBody(opts) {
+	const { inlineLibs, resolvedLibs, ctorParams, initcodeCallArgs } = opts;
+	const lines = [];
+	if (inlineLibs) for (const rlib of resolvedLibs) {
+		const { libParams: libLibParams } = buildBytecodeSegments(rlib.artifact.bytecode, rlib.artifact.linkReferences);
+		const callArgs = libLibParams.length > 0 ? libLibParams.map((lp) => lp.name).join(", ") : "";
+		lines.push(`        address ${rlib.paramName} = DeployHelper.deployLibrary(_${rlib.paramName}Initcode(${callArgs}));`);
+	}
+	if (ctorParams.length > 0) {
+		const encodeArgs = ctorParams.map((p, i) => p.name || `arg${i}`).join(", ");
+		lines.push(`        bytes memory args = abi.encode(${encodeArgs});`);
+		lines.push(`        bytes memory initcode_ = abi.encodePacked(initcode(${initcodeCallArgs}), args);`);
+	} else lines.push(`        bytes memory initcode_ = initcode(${initcodeCallArgs});`);
+	lines.push(`        deployed = DeployHelper.deploy(initcode_, salt);`);
+	return lines.join("\n");
+}
 function generateDeployer(parsed, pragmaOrOpts) {
 	const opts = typeof pragmaOrOpts === "string" ? { pragma: pragmaOrOpts } : pragmaOrOpts ?? {};
 	const pragma = opts.pragma ?? ">=0.8.0";
 	const resolvedLibs = opts.libraries ?? [];
 	const { contractName, abi, bytecode, linkReferences } = parsed;
 	const libName = `${contractName}Deployer`;
-	const ctorParams = abi.find((e) => e.type === "constructor")?.inputs ?? [];
+	const ctorEntry = abi.find((e) => e.type === "constructor");
+	const ctorParams = ctorEntry?.inputs ?? [];
+	const isPayable = ctorEntry?.stateMutability === "payable";
 	const structDefs = collectStructDefs(ctorParams);
 	const structNames = new Set(structDefs.map((s) => s.name));
 	const { segments: mainSegments, libParams: mainLibParams } = buildBytecodeSegments(bytecode, linkReferences);
@@ -232,8 +270,9 @@ function generateDeployer(parsed, pragmaOrOpts) {
 	if (parsed.sourcePath) metaLines.push(`@notice Source Contract: ${parsed.sourcePath}`);
 	if (parsed.solcVersion) metaLines.push(`- solc: ${parsed.solcVersion}`);
 	if (parsed.optimizerRuns !== void 0) metaLines.push(`- optimizer_runs: ${parsed.optimizerRuns}`);
-	if (parsed.viaIR) metaLines.push(`- viaIR: true`);
+	metaLines.push(`- viaIR: ${parsed.viaIR ?? false}`);
 	if (parsed.evmVersion) metaLines.push(`- evm_version: ${parsed.evmVersion}`);
+	metaLines.push(`- bytecodeHash: ${parsed.bytecodeHash ?? "ipfs"}`);
 	const metaBlock = metaLines.length > 0 ? [
 		`    /**`,
 		`     * @dev autogenerated by forge-pack`,
@@ -258,74 +297,33 @@ function generateDeployer(parsed, pragmaOrOpts) {
 	const deployParams = [];
 	for (let i = 0; i < ctorParams.length; i++) deployParams.push(formatParamWithStructs(ctorParams[i], i, structNames));
 	if (hasLinks && !inlineLibs) for (const lp of mainLibParams) deployParams.push(`address ${lp.name}`);
-	const deployParamStr = deployParams.join(", ");
-	const deployBodyLines = [];
-	if (inlineLibs) for (const rlib of resolvedLibs) {
-		const { libParams: libLibParams } = buildBytecodeSegments(rlib.artifact.bytecode, rlib.artifact.linkReferences);
-		const callArgs = libLibParams.length > 0 ? libLibParams.map((lp) => lp.name).join(", ") : "";
-		deployBodyLines.push(`        address ${rlib.paramName} = _create(_${rlib.paramName}Initcode(${callArgs}));`);
-	}
+	const deployParamStr = deployParams.length > 0 ? `${deployParams.join(", ")}, bytes32 salt` : `bytes32 salt`;
 	const initcodeCallArgs = hasLinks ? mainLibParams.map((lp) => lp.name).join(", ") : "";
-	if (ctorParams.length > 0) {
-		const encodeArgs = ctorParams.map((p, i) => p.name || `arg${i}`).join(", ");
-		deployBodyLines.push(`        bytes memory args = abi.encode(${encodeArgs});`);
-		deployBodyLines.push(`        bytes memory initcode_ = abi.encodePacked(initcode(${initcodeCallArgs}), args);`);
-		deployBodyLines.push(`        deployed = _create(initcode_);`);
-	} else {
-		deployBodyLines.push(`        bytes memory initcode_ = initcode(${initcodeCallArgs});`);
-		deployBodyLines.push(`        deployed = _create(initcode_);`);
-	}
-	const deployBody = deployBodyLines.join("\n");
-	const deploy2BodyLines = [];
-	if (inlineLibs) for (const rlib of resolvedLibs) {
-		const { libParams: libLibParams } = buildBytecodeSegments(rlib.artifact.bytecode, rlib.artifact.linkReferences);
-		const callArgs = libLibParams.length > 0 ? libLibParams.map((lp) => lp.name).join(", ") : "";
-		deploy2BodyLines.push(`        address ${rlib.paramName} = _create(_${rlib.paramName}Initcode(${callArgs}));`);
-	}
-	if (ctorParams.length > 0) {
-		const encodeArgs = ctorParams.map((p, i) => p.name || `arg${i}`).join(", ");
-		deploy2BodyLines.push(`        bytes memory args = abi.encode(${encodeArgs});`);
-		deploy2BodyLines.push(`        bytes memory initcode_ = abi.encodePacked(initcode(${initcodeCallArgs}), args);`);
-		deploy2BodyLines.push(`        deployed = _create2(initcode_, salt);`);
-	} else {
-		deploy2BodyLines.push(`        bytes memory initcode_ = initcode(${initcodeCallArgs});`);
-		deploy2BodyLines.push(`        deployed = _create2(initcode_, salt);`);
-	}
-	const deploy2Body = deploy2BodyLines.join("\n");
-	const deploy2Params = deployParams.length > 0 ? `${deployParamStr}, bytes32 salt` : `bytes32 salt`;
+	const payableModifier = isPayable ? " payable" : "";
+	const deployBody = renderDeployBody({
+		inlineLibs,
+		resolvedLibs,
+		ctorParams,
+		initcodeCallArgs,
+		isPayable
+	});
 	return `// SPDX-License-Identifier: MIT
 pragma solidity ${pragma};
 
+import {DeployHelper} from "./utils/DeployHelper.sol";
+
 library ${libName} {
 ${metaBlock}${structBlock ? `\n${structBlock}\n` : ""}
-    function deploy(${deployParamStr}) internal returns (address deployed) {
+    function deploy(${deployParamStr}) internal${payableModifier} returns (address deployed) {
 ${deployBody}
     }
 
-    function deploy2(${deploy2Params}) internal returns (address deployed) {
-${deploy2Body}
-    }
-
     function initcode(${initcodeParams}) internal pure returns (bytes memory) {
 ${initcodeBody}
     }
-${libInitcodeFns.length > 0 ? "\n" + libInitcodeFns.join("\n\n") + "\n" : ""}
-    function _create(bytes memory initcode_) private returns (address deployed) {
-        assembly {
-            deployed := create(0, add(initcode_, 0x20), mload(initcode_))
-            if iszero(deployed) { revert(0, returndatasize()) }
-        }
-    }
-
-    function _create2(bytes memory initcode_, bytes32 salt) private returns (address deployed) {
-        assembly {
-            deployed := create2(0, add(initcode_, 0x20), mload(initcode_), salt)
-            if iszero(deployed) { revert(0, returndatasize()) }
-        }
-    }
-}
+${libInitcodeFns.length > 0 ? "\n" + libInitcodeFns.join("\n\n") + "\n" : ""}}
 `;
 }
 
 //#endregion
-export { resolveLibraries as i, generateDeployer as n, parseArtifact as r, findArtifact as t };
+export { parseArtifact as i, resolveLibraries as n, findArtifact as r, generateDeployer as t };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-//#region src/pack.d.ts
+//#region src/types.d.ts
 interface LinkReference {
   start: number;
   length: number;
@@ -32,14 +32,8 @@ interface ParsedArtifact {
   optimizerRuns?: number;
   viaIR?: boolean;
   evmVersion?: string;
+  bytecodeHash?: string;
 }
-interface FindArtifactOptions {
-  solcVersion?: string;
-}
-/**
- * A library dependency resolved from linkReferences, with its own parsed
- * artifact and the param name used in generated code.
- */
 interface ResolvedLibrary {
   /** Parameter-style name, e.g. "mathLib" */
   paramName: string;
@@ -52,17 +46,24 @@ interface ResolvedLibrary {
   /** Param names of libraries this library depends on (its own linkReferences) */
   deps: string[];
 }
-declare function findArtifact(contractName: string, outDir: string, options?: FindArtifactOptions): string;
+interface GenerateDeployerOptions {
+  pragma?: string;
+  libraries?: ResolvedLibrary[];
+}
+//#endregion
+//#region src/artifact.d.ts
+declare function findArtifact(contractName: string, outDir: string): string;
 declare function parseArtifact(artifactPath: string, contractName: string): ParsedArtifact;
+//#endregion
+//#region src/resolve.d.ts
 /**
  * Recursively resolve all library dependencies for a contract's linkReferences.
  * Returns libraries in topological order (deploy-order: leaves first).
+ * Disambiguates duplicate paramName values with numeric suffixes.
  */
 declare function resolveLibraries(linkRefs: LinkReferences, outDir: string): ResolvedLibrary[];
-interface GenerateDeployerOptions {
-  pragma?: string;
-  libraries?: ResolvedLibrary[];
-}
+//#endregion
+//#region src/codegen.d.ts
 declare function generateDeployer(parsed: ParsedArtifact, pragmaOrOpts?: string | GenerateDeployerOptions): string;
 //#endregion
-export { type AbiEntry, type AbiParam, type FindArtifactOptions, type GenerateDeployerOptions, type LinkReference, type LinkReferences, type ParsedArtifact, type ResolvedLibrary, findArtifact, generateDeployer, parseArtifact, resolveLibraries };
+export { type AbiEntry, type AbiParam, type GenerateDeployerOptions, type LinkReference, type LinkReferences, type ParsedArtifact, type ResolvedLibrary, findArtifact, generateDeployer, parseArtifact, resolveLibraries };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { i as resolveLibraries, n as generateDeployer, r as parseArtifact, t as findArtifact } from "./pack-Be_7Cz7w.mjs";
+import { i as parseArtifact, n as resolveLibraries, r as findArtifact, t as generateDeployer } from "./codegen--WByOfZu.mjs";
 
 export { findArtifact, generateDeployer, parseArtifact, resolveLibraries };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-pack",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Generate self-contained Solidity deployer files from Forge build artifacts",
   "type": "module",
   "bin": {
@@ -34,9 +34,10 @@
     "@changesets/changelog-github": "^0.5.2",
     "@changesets/cli": "^2.29.8",
     "@changesets/config": "^3.1.2",
+    "@types/node": "^24.10.13",
+    "prettier": "^3.8.1",
     "tsdown": "^0.20.3",
-    "typescript": "^5.8.3",
-    "@types/node": "^24.10.13"
+    "typescript": "^5.9.3"
   },
   "publishConfig": {
     "access": "public"
@@ -46,6 +47,7 @@
     "dev": "tsdown --watch",
     "changeset": "changeset",
     "version": "changeset version",
-    "release": "changeset publish"
+    "release": "changeset publish",
+    "format": "prettier --write \"**/*.{ts,tsx,md,json}\""
   }
 }