@deployoor/hardhat 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Valerio Leo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,67 @@
+# @deployoor/hardhat
+
+> A [Hardhat](https://hardhat.org) plugin that regenerates [deployoor](../deployoor)'s typed deployers automatically after every `hardhat compile`.
+
+Without it, the flow is two steps — `hardhat compile` then `deployoor generate`. With it, `hardhat compile` runs `deployoor generate` in process the moment fresh `artifacts/` are written: no extra terminal, no separate command, no stale deployers. Edit a contract, compile, and the typed `getOrDeploy<Name>` functions are already up to date.
+
+## Install
+
+```bash
+pnpm add -D @deployoor/hardhat deployoor viem
+```
+
+You still need a `deployoor.config.ts` (run `npx deployoor init` once).
+
+## Usage
+
+```ts
+// hardhat.config.ts
+import "@deployoor/hardhat";
+
+export default {
+  solidity: "0.8.24",
+};
+```
+
+```js
+// hardhat.config.js (CommonJS)
+require("@deployoor/hardhat");
+
+module.exports = { solidity: "0.8.24" };
+```
+
+Now every compile regenerates the deployers:
+
+```bash
+npx hardhat compile
+# deployoor: generated 3 deployer file(s)
+```
+
+## Options
+
+Configure under a `deployoor` key in your Hardhat config:
+
+```ts
+export default {
+  solidity: "0.8.24",
+  deployoor: {
+    generate: false, // opt out of auto-generation (default: true)
+  },
+};
+```
+
+| Option     | Type      | Default | Description                                            |
+| ---------- | --------- | ------- | ------------------------------------------------------ |
+| `generate` | `boolean` | `true`  | Run `deployoor generate` after each `hardhat compile`. |
+
+Output location, which contracts to include, and the deployments path all come from your `deployoor.config.ts` — this plugin only decides _when_ generation runs.
+
+## Notes
+
+- **Compile never breaks.** If generation fails (no config yet, nothing compiled, a bad `include`), the plugin logs a warning and lets `hardhat compile` finish — it never rethrows.
+- It calls deployoor's programmatic `generateDeployers` (exported from [`deployoor/generate`](../deployoor)) — exactly what the `deployoor generate` CLI runs, so results are identical whichever way you trigger it.
+- Foundry users get the same behavior via `forge build`'s hooks or a `forge build && deployoor generate` script; this plugin is the Hardhat-native convenience.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,54 @@
+let hardhat_config_js = require("hardhat/config.js");
+let hardhat_builtin_tasks_task_names_js = require("hardhat/builtin-tasks/task-names.js");
+let deployoor_generate = require("deployoor/generate");
+require("hardhat/types/config.js");
+//#region src/runner.ts
+/**
+* Run `deployoor generate` after a Hardhat compile. A generation failure (e.g. no config yet,
+* nothing compiled) is reported but never rethrown, so a deployoor misconfiguration can never
+* break `hardhat compile` itself.
+*/
+const runAfterCompile = async (opts) => {
+	if (!opts.enabled) return;
+	const log = opts.log ?? {
+		info: (message) => console.log(message),
+		warn: (message) => console.warn(message)
+	};
+	try {
+		const files = await opts.generate({ root: opts.root });
+		log.info(`deployoor: generated ${files.length} deployer file(s)`);
+	} catch (error) {
+		log.warn(`deployoor: skipped generate — ${error instanceof Error ? error.message : String(error)}`);
+	}
+};
+//#endregion
+//#region src/index.ts
+/**
+* @deployoor/hardhat — regenerate deployoor's typed deployers automatically after every
+* `hardhat compile`, in process. No extra terminal, no separate `deployoor generate` step:
+* the moment Hardhat writes fresh `artifacts/`, the deployers are rebuilt from them.
+*
+* Add it to your Hardhat config:
+*
+*   // hardhat.config.ts
+*   import "@deployoor/hardhat";
+*   // hardhat.config.js
+*   require("@deployoor/hardhat");
+*
+* Opt out per project with `deployoor: { generate: false }` in the Hardhat config.
+*/
+(0, hardhat_config_js.extendConfig)((config, userConfig) => {
+	config.deployoor = { generate: userConfig.deployoor?.generate ?? true };
+});
+(0, hardhat_config_js.task)(hardhat_builtin_tasks_task_names_js.TASK_COMPILE).setAction(async (args, hre, runSuper) => {
+	const result = await runSuper(args);
+	await runAfterCompile({
+		root: hre.config.paths.root,
+		enabled: hre.config.deployoor.generate,
+		generate: deployoor_generate.generateDeployers
+	});
+	return result;
+});
+//#endregion
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["TASK_COMPILE","generateDeployers"],"sources":["../src/runner.ts","../src/index.ts"],"sourcesContent":["/** The slice of a generated file this plugin reports on (the full record carries `contents` too). */\nexport interface GeneratedFileInfo {\n  readonly path: string;\n}\n\nexport interface RunAfterCompileOptions {\n  /** Project root handed to `generateDeployers` (Hardhat's `config.paths.root`). */\n  readonly root: string;\n  /** When false, generation is skipped — the `deployoor: { generate: false }` opt-out. */\n  readonly enabled: boolean;\n  /** The generate function, injected so this wiring is testable without a Hardhat runtime. */\n  readonly generate: (opts: { root: string }) => Promise<ReadonlyArray<GeneratedFileInfo>>;\n  /** Where progress/failures are reported. Defaults to the console. */\n  readonly log?: { info: (message: string) => void; warn: (message: string) => void };\n}\n\n/**\n * Run `deployoor generate` after a Hardhat compile. A generation failure (e.g. no config yet,\n * nothing compiled) is reported but never rethrown, so a deployoor misconfiguration can never\n * break `hardhat compile` itself.\n */\nexport const runAfterCompile = async (opts: RunAfterCompileOptions): Promise<void> => {\n  if (!opts.enabled) return;\n  const log = opts.log ?? {\n    info: (message: string) => console.log(message),\n    warn: (message: string) => console.warn(message),\n  };\n  try {\n    const files = await opts.generate({ root: opts.root });\n    log.info(`deployoor: generated ${files.length} deployer file(s)`);\n  } catch (error) {\n    log.warn(`deployoor: skipped generate — ${error instanceof Error ? error.message : String(error)}`);\n  }\n};\n","import { extendConfig, task } from \"hardhat/config\";\nimport { TASK_COMPILE } from \"hardhat/builtin-tasks/task-names\";\nimport { generateDeployers } from \"deployoor/generate\";\nimport { runAfterCompile } from \"./runner\";\nimport \"./type-extensions\";\n\n/**\n * @deployoor/hardhat — regenerate deployoor's typed deployers automatically after every\n * `hardhat compile`, in process. No extra terminal, no separate `deployoor generate` step:\n * the moment Hardhat writes fresh `artifacts/`, the deployers are rebuilt from them.\n *\n * Add it to your Hardhat config:\n *\n *   // hardhat.config.ts\n *   import \"@deployoor/hardhat\";\n *   // hardhat.config.js\n *   require(\"@deployoor/hardhat\");\n *\n * Opt out per project with `deployoor: { generate: false }` in the Hardhat config.\n */\nextendConfig((config, userConfig) => {\n  config.deployoor = { generate: userConfig.deployoor?.generate ?? true };\n});\n\n// Wrap the built-in compile: run it, then regenerate from the fresh artifacts.\ntask(TASK_COMPILE).setAction(async (args, hre, runSuper) => {\n  const result = await runSuper(args);\n  await runAfterCompile({\n    root: hre.config.paths.root,\n    enabled: hre.config.deployoor.generate,\n    generate: generateDeployers,\n  });\n  return result;\n});\n"],"mappings":";;;;;;;;;;AAqBA,MAAa,kBAAkB,OAAO,SAAgD;CACpF,IAAI,CAAC,KAAK,SAAS;CACnB,MAAM,MAAM,KAAK,OAAO;EACtB,OAAO,YAAoB,QAAQ,IAAI,OAAO;EAC9C,OAAO,YAAoB,QAAQ,KAAK,OAAO;CACjD;CACA,IAAI;EACF,MAAM,QAAQ,MAAM,KAAK,SAAS,EAAE,MAAM,KAAK,KAAK,CAAC;EACrD,IAAI,KAAK,wBAAwB,MAAM,OAAO,kBAAkB;CAClE,SAAS,OAAO;EACd,IAAI,KAAK,iCAAiC,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GAAG;CACpG;AACF;;;;;;;;;;;;;;;;;qCCbc,QAAQ,eAAe;CACnC,OAAO,YAAY,EAAE,UAAU,WAAW,WAAW,YAAY,KAAK;AACxE,CAAC;4BAGIA,oCAAAA,YAAY,CAAC,CAAC,UAAU,OAAO,MAAM,KAAK,aAAa;CAC1D,MAAM,SAAS,MAAM,SAAS,IAAI;CAClC,MAAM,gBAAgB;EACpB,MAAM,IAAI,OAAO,MAAM;EACvB,SAAS,IAAI,OAAO,UAAU;EAC9B,UAAUC,mBAAAA;CACZ,CAAC;CACD,OAAO;AACT,CAAC"}

package/dist/index.d.cts

@@ -0,0 +1,15 @@
+//#region src/type-extensions.d.ts
+declare module "hardhat/types/config" {
+  interface HardhatUserConfig {
+    /** deployoor options. `generate` (default `true`): run `deployoor generate` after `hardhat compile`. */
+    deployoor?: {
+      readonly generate?: boolean;
+    };
+  }
+  interface HardhatConfig {
+    deployoor: {
+      readonly generate: boolean;
+    };
+  }
+} //# sourceMappingURL=type-extensions.d.ts.map
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/type-extensions.ts"],"mappings":";;YAGY,iBAAA;IAHkB;IAK1B,SAAA;MAAA,SACW,QAAA;IAAA;EAAA;EAAA,UAIH,aAAA;IACR,SAAA;MAAA,SACW,QAAA;IAAA;EAAA;AAAA"}

package/dist/index.d.mts

@@ -0,0 +1,15 @@
+//#region src/type-extensions.d.ts
+declare module "hardhat/types/config" {
+  interface HardhatUserConfig {
+    /** deployoor options. `generate` (default `true`): run `deployoor generate` after `hardhat compile`. */
+    deployoor?: {
+      readonly generate?: boolean;
+    };
+  }
+  interface HardhatConfig {
+    deployoor: {
+      readonly generate: boolean;
+    };
+  }
+} //# sourceMappingURL=type-extensions.d.ts.map
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/type-extensions.ts"],"mappings":";;YAGY,iBAAA;IAHkB;IAK1B,SAAA;MAAA,SACW,QAAA;IAAA;EAAA;EAAA,UAIH,aAAA;IACR,SAAA;MAAA,SACW,QAAA;IAAA;EAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,55 @@
+import { extendConfig, task } from "hardhat/config.js";
+import { TASK_COMPILE } from "hardhat/builtin-tasks/task-names.js";
+import { generateDeployers } from "deployoor/generate";
+import "hardhat/types/config.js";
+//#region src/runner.ts
+/**
+* Run `deployoor generate` after a Hardhat compile. A generation failure (e.g. no config yet,
+* nothing compiled) is reported but never rethrown, so a deployoor misconfiguration can never
+* break `hardhat compile` itself.
+*/
+const runAfterCompile = async (opts) => {
+	if (!opts.enabled) return;
+	const log = opts.log ?? {
+		info: (message) => console.log(message),
+		warn: (message) => console.warn(message)
+	};
+	try {
+		const files = await opts.generate({ root: opts.root });
+		log.info(`deployoor: generated ${files.length} deployer file(s)`);
+	} catch (error) {
+		log.warn(`deployoor: skipped generate — ${error instanceof Error ? error.message : String(error)}`);
+	}
+};
+//#endregion
+//#region src/index.ts
+/**
+* @deployoor/hardhat — regenerate deployoor's typed deployers automatically after every
+* `hardhat compile`, in process. No extra terminal, no separate `deployoor generate` step:
+* the moment Hardhat writes fresh `artifacts/`, the deployers are rebuilt from them.
+*
+* Add it to your Hardhat config:
+*
+*   // hardhat.config.ts
+*   import "@deployoor/hardhat";
+*   // hardhat.config.js
+*   require("@deployoor/hardhat");
+*
+* Opt out per project with `deployoor: { generate: false }` in the Hardhat config.
+*/
+extendConfig((config, userConfig) => {
+	config.deployoor = { generate: userConfig.deployoor?.generate ?? true };
+});
+task(TASK_COMPILE).setAction(async (args, hre, runSuper) => {
+	const result = await runSuper(args);
+	await runAfterCompile({
+		root: hre.config.paths.root,
+		enabled: hre.config.deployoor.generate,
+		generate: generateDeployers
+	});
+	return result;
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/runner.ts","../src/index.ts"],"sourcesContent":["/** The slice of a generated file this plugin reports on (the full record carries `contents` too). */\nexport interface GeneratedFileInfo {\n  readonly path: string;\n}\n\nexport interface RunAfterCompileOptions {\n  /** Project root handed to `generateDeployers` (Hardhat's `config.paths.root`). */\n  readonly root: string;\n  /** When false, generation is skipped — the `deployoor: { generate: false }` opt-out. */\n  readonly enabled: boolean;\n  /** The generate function, injected so this wiring is testable without a Hardhat runtime. */\n  readonly generate: (opts: { root: string }) => Promise<ReadonlyArray<GeneratedFileInfo>>;\n  /** Where progress/failures are reported. Defaults to the console. */\n  readonly log?: { info: (message: string) => void; warn: (message: string) => void };\n}\n\n/**\n * Run `deployoor generate` after a Hardhat compile. A generation failure (e.g. no config yet,\n * nothing compiled) is reported but never rethrown, so a deployoor misconfiguration can never\n * break `hardhat compile` itself.\n */\nexport const runAfterCompile = async (opts: RunAfterCompileOptions): Promise<void> => {\n  if (!opts.enabled) return;\n  const log = opts.log ?? {\n    info: (message: string) => console.log(message),\n    warn: (message: string) => console.warn(message),\n  };\n  try {\n    const files = await opts.generate({ root: opts.root });\n    log.info(`deployoor: generated ${files.length} deployer file(s)`);\n  } catch (error) {\n    log.warn(`deployoor: skipped generate — ${error instanceof Error ? error.message : String(error)}`);\n  }\n};\n","import { extendConfig, task } from \"hardhat/config\";\nimport { TASK_COMPILE } from \"hardhat/builtin-tasks/task-names\";\nimport { generateDeployers } from \"deployoor/generate\";\nimport { runAfterCompile } from \"./runner\";\nimport \"./type-extensions\";\n\n/**\n * @deployoor/hardhat — regenerate deployoor's typed deployers automatically after every\n * `hardhat compile`, in process. No extra terminal, no separate `deployoor generate` step:\n * the moment Hardhat writes fresh `artifacts/`, the deployers are rebuilt from them.\n *\n * Add it to your Hardhat config:\n *\n *   // hardhat.config.ts\n *   import \"@deployoor/hardhat\";\n *   // hardhat.config.js\n *   require(\"@deployoor/hardhat\");\n *\n * Opt out per project with `deployoor: { generate: false }` in the Hardhat config.\n */\nextendConfig((config, userConfig) => {\n  config.deployoor = { generate: userConfig.deployoor?.generate ?? true };\n});\n\n// Wrap the built-in compile: run it, then regenerate from the fresh artifacts.\ntask(TASK_COMPILE).setAction(async (args, hre, runSuper) => {\n  const result = await runSuper(args);\n  await runAfterCompile({\n    root: hre.config.paths.root,\n    enabled: hre.config.deployoor.generate,\n    generate: generateDeployers,\n  });\n  return result;\n});\n"],"mappings":";;;;;;;;;;AAqBA,MAAa,kBAAkB,OAAO,SAAgD;CACpF,IAAI,CAAC,KAAK,SAAS;CACnB,MAAM,MAAM,KAAK,OAAO;EACtB,OAAO,YAAoB,QAAQ,IAAI,OAAO;EAC9C,OAAO,YAAoB,QAAQ,KAAK,OAAO;CACjD;CACA,IAAI;EACF,MAAM,QAAQ,MAAM,KAAK,SAAS,EAAE,MAAM,KAAK,KAAK,CAAC;EACrD,IAAI,KAAK,wBAAwB,MAAM,OAAO,kBAAkB;CAClE,SAAS,OAAO;EACd,IAAI,KAAK,iCAAiC,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GAAG;CACpG;AACF;;;;;;;;;;;;;;;;;ACbA,cAAc,QAAQ,eAAe;CACnC,OAAO,YAAY,EAAE,UAAU,WAAW,WAAW,YAAY,KAAK;AACxE,CAAC;AAGD,KAAK,YAAY,CAAC,CAAC,UAAU,OAAO,MAAM,KAAK,aAAa;CAC1D,MAAM,SAAS,MAAM,SAAS,IAAI;CAClC,MAAM,gBAAgB;EACpB,MAAM,IAAI,OAAO,MAAM;EACvB,SAAS,IAAI,OAAO,UAAU;EAC9B,UAAU;CACZ,CAAC;CACD,OAAO;AACT,CAAC"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@deployoor/hardhat",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "Hardhat plugin: regenerate deployoor's typed deployers automatically after every `hardhat compile`.",
+  "keywords": [
+    "ethereum",
+    "evm",
+    "hardhat",
+    "hardhat-plugin",
+    "deployments",
+    "smart-contracts",
+    "codegen"
+  ],
+  "license": "MIT",
+  "author": "Valerio Leo",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "deployoor": "*",
+    "hardhat": "^2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "hardhat": "^2.22.0",
+    "tsdown": "^0.22.3",
+    "typescript": "^5.9.3",
+    "unrun": "^0.3.1",
+    "vitest": "^4.0.17",
+    "deployoor": "0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/valerioleo/deployoor.git",
+    "directory": "packages/deployoor-hardhat"
+  },
+  "homepage": "https://github.com/valerioleo/deployoor/tree/main/packages/deployoor-hardhat#readme",
+  "bugs": {
+    "url": "https://github.com/valerioleo/deployoor/issues"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}