diff --git a/hardhat/hardhat-exposed/hook-handlers/config.ts b/hardhat/hardhat-exposed/hook-handlers/config.ts index 2d6d84c42ab..db92069a2bf 100644 --- a/hardhat/hardhat-exposed/hook-handlers/config.ts +++ b/hardhat/hardhat-exposed/hook-handlers/config.ts @@ -38,8 +38,10 @@ export default async (): Promise> => ({ resolveUserConfig: async (userConfig, resolveConfigurationVariable, next) => { const partiallyResolvedConfig = await next(userConfig, resolveConfigurationVariable); + // Patterns starting with `npm:` match the npm root paths of the files listed in `solidity.npmFilesToBuild` (e.g. + // `npm:@openzeppelin/contracts/**/*.sol`), and are kept as-is. const makeAbsolutePath = (p: string) => - path.isAbsolute(p) ? p : path.resolve(partiallyResolvedConfig.paths.root, p); + path.isAbsolute(p) || p.startsWith('npm:') ? p : path.resolve(partiallyResolvedConfig.paths.root, p); // Note: the output directory is deliberately NOT added to `paths.sources.solidity` here. The `build` task adds it, // in place, right after generating its content. That way tasks that don't generate the exposed contracts (docgen, diff --git a/hardhat/hardhat-exposed/internal/expose.ts b/hardhat/hardhat-exposed/internal/expose.ts index c773354772f..b361eb9d0cf 100644 --- a/hardhat/hardhat-exposed/internal/expose.ts +++ b/hardhat/hardhat-exposed/internal/expose.ts @@ -28,27 +28,40 @@ type ExposedFile = { content: string; }; -type ParsedRemapping = { prefix: string; target: string }; +// `exact` remappings apply to a single file, rather than to every file whose input source name starts with `target`. +type ParsedRemapping = { prefix: string; target: string; exact?: boolean }; export function getExposed( solidityBuildInfo: SolidityBuildInfo, solcOutput: CompilerOutput, config: HardhatConfig, -): Map { - const res = new Map(); + // input source name -> name it was listed with, for every exposed npm root (see `npmFilesToBuild`), including the + // ones that are not part of this build info because they are cached + npmRoots: Map, +): { + // exposed file absolute path -> content + files: Map; + // exposed files that are needed by an import (see the `imports` option), including the ones of npm roots, which may + // not be part of `files` if they are cached + imported: Set; +} { + const files = new Map(); + const imported = new Set(); const deref = astDereferencer(solcOutput); const projectSourcePrefixes = getProjectSourcePrefixes(config); - const applicableRemappings = parseApplicableRemappings( - solidityBuildInfo.input.settings.remappings ?? [], - projectSourcePrefixes, - ); + const applicableRemappings: ParsedRemapping[] = [ + // npm roots are referred to by the name they were listed with, which may differ from their path in the package when + // it uses `package.json#exports`. + ...Array.from(npmRoots, ([inputSourceName, name]) => ({ prefix: name, target: inputSourceName, exact: true })), + ...parseApplicableRemappings(solidityBuildInfo.input.settings.remappings ?? [], projectSourcePrefixes), + ]; for (const [sourceName, inputSourceName] of Object.entries(solidityBuildInfo.userSourceNameMap)) { const ast = solcOutput.sources[inputSourceName].ast; const exposedFile = getExposedFile(sourceName, inputSourceName, ast, deref, config, applicableRemappings); if (exposedFile !== undefined) { - res.set(exposedFile.absolutePath, exposedFile.content); + files.set(exposedFile.absolutePath, exposedFile.content); } } @@ -61,6 +74,20 @@ export function getExposed( )) { const ast = solcOutput.sources[inputSourceName].ast; + // An npm root's exposed file already exposes all of its contracts: it must not be replaced, even when it is not + // regenerated here because the npm root is cached. + if (npmRoots.has(inputSourceName)) { + imported.add( + getExposedFileAbsolutePath( + inputSourceName.replace(/^project\//, ''), + inputSourceName, + config, + applicableRemappings, + ), + ); + continue; + } + // sourceName is a fallback path for vendored `project/` deps not covered by a remapping. const exposedFile = getExposedFile( inputSourceName.replace(/^project\//, ''), @@ -72,15 +99,17 @@ export function getExposed( c => contracts.has(c), ); if (exposedFile !== undefined) { - res.set(exposedFile.absolutePath, exposedFile.content); + files.set(exposedFile.absolutePath, exposedFile.content); + imported.add(exposedFile.absolutePath); } } } - return res; + return { files, imported }; } -// Non-interface contracts named in an import from outside the project sources, grouped by declaring file. +// Non-interface contracts named in an import from outside the project sources, grouped by declaring file. npm roots +// (see `npmFilesToBuild`) are not project sources: the imports of their contracts are reported too. // Blanket imports contribute nothing: only `import {X} from '...'` symbols count. function getImportedContracts( solidityBuildInfo: SolidityBuildInfo, @@ -90,7 +119,8 @@ function getImportedContracts( ): Map> { const userInputSourceNames = new Set(Object.values(solidityBuildInfo.userSourceNameMap)); const isCoveredByUserSources = (inputSourceName: string) => - userInputSourceNames.has(inputSourceName) || projectSourcePrefixes.some(p => inputSourceName.startsWith(p)); + (userInputSourceNames.has(inputSourceName) && !inputSourceName.startsWith('npm/')) || + projectSourcePrefixes.some(p => inputSourceName.startsWith(p)); const res = new Map>(); @@ -180,7 +210,9 @@ function parseApplicableRemappings(remappings: string[], projectSourcePrefixes: } function getRemappedImportPath(inputSourceName: string, applicableRemappings: ParsedRemapping[]): string | undefined { - const item = applicableRemappings.find(({ target }) => inputSourceName.startsWith(target)); + const item = applicableRemappings.find(({ target, exact }) => + exact ? inputSourceName === target : inputSourceName.startsWith(target), + ); return item && item.prefix + inputSourceName.slice(item.target.length); } @@ -198,11 +230,7 @@ function getExposedFile( applicableRemappings: ParsedRemapping[], filter?: (c: ContractDefinition) => boolean, ): ExposedFile | undefined { - const exposedFileAbsolutePath = path.join( - config.exposed.outDir, - getRemappedImportPath(inputSourceName, applicableRemappings) ?? - (inputSourceName.startsWith('project/') ? sourceName : getNpmImportPath(inputSourceName)), - ); + const exposedFileAbsolutePath = getExposedFileAbsolutePath(sourceName, inputSourceName, config, applicableRemappings); const content = getExposedContent( exposedFileAbsolutePath, @@ -218,6 +246,19 @@ function getExposedFile( return content === undefined ? undefined : { absolutePath: exposedFileAbsolutePath, content }; } +function getExposedFileAbsolutePath( + sourceName: string, + inputSourceName: string, + config: HardhatConfig, + applicableRemappings: ParsedRemapping[], +): string { + return path.join( + config.exposed.outDir, + getRemappedImportPath(inputSourceName, applicableRemappings) ?? + (inputSourceName.startsWith('project/') ? sourceName : getNpmImportPath(inputSourceName)), + ); +} + function getExposedContent( exposedFileAbsolutePath: string, ast: SourceUnit, diff --git a/hardhat/hardhat-exposed/internal/manifest.ts b/hardhat/hardhat-exposed/internal/manifest.ts index a16a8bd70ca..1f55cc6d169 100644 --- a/hardhat/hardhat-exposed/internal/manifest.ts +++ b/hardhat/hardhat-exposed/internal/manifest.ts @@ -80,8 +80,9 @@ export class ExposedManifest { } } + // npm roots (`npm:`, see `npmFilesToBuild`) are not paths: they are stored as-is. private relative(p: string): string { - return path.relative(this.rootDir, p); + return p.startsWith('npm:') ? p : path.relative(this.rootDir, p); } private absolute(p: string): string { diff --git a/hardhat/hardhat-exposed/tasks/generate-exposed-contracts.ts b/hardhat/hardhat-exposed/tasks/generate-exposed-contracts.ts index ce38526260a..5588cad4760 100644 --- a/hardhat/hardhat-exposed/tasks/generate-exposed-contracts.ts +++ b/hardhat/hardhat-exposed/tasks/generate-exposed-contracts.ts @@ -2,6 +2,7 @@ import { createSpinner } from '@nomicfoundation/hardhat-utils/spinner'; import type { HardhatRuntimeEnvironment } from 'hardhat/types/hre'; import type { CompilationJob, SolidityBuildInfo } from 'hardhat/types/solidity'; +import { ResolvedFileType } from 'hardhat/types/solidity'; import type { Result } from 'hardhat/types/utils'; import assert from 'node:assert'; import path from 'node:path'; @@ -56,12 +57,26 @@ export default async function generateExposedContracts( const filteredRootPathsToExpose = rootPathsToExpose.filter(p => force || !compilationJobs.cacheHits.has(p)); + // Input source name of each exposed npm root (see `npmFilesToBuild`), mapped to the name it was listed with. Cached + // ones are included, as they are absent from the compilation jobs of the roots that import them. + const npmRoots = new Map( + rootPathsToExpose + .filter(p => p.startsWith('npm:')) + .flatMap(p => + Array.from(compilationJobs.indexedIndividualJobs.get(p)!.dependencyGraph.getRoots().values(), f => [ + f.inputSourceName, + p.slice('npm:'.length), + ]), + ), + ); + // Roots of the compilation job, restricted to the ones being exposed. All of them are regenerated together. const rootPathsToExposeSet = new Set(rootPathsToExpose); const getExposedRoots = (compilationJob: CompilationJob) => - Array.from(compilationJob.dependencyGraph.getRoots().values(), f => f.fsPath).filter(p => - rootPathsToExposeSet.has(p), - ); + // Root paths are formatted as in `getRootFilePaths`: `npm:` for npm roots (see `npmFilesToBuild`). + Array.from(compilationJob.dependencyGraph.getRoots(), ([userSourceName, f]) => + f.type === ResolvedFileType.NPM_PACKAGE_FILE ? `npm:${userSourceName}` : f.fsPath, + ).filter(p => rootPathsToExposeSet.has(p)); const astOnlyBuildInfos = new Map(); const compilationJobIds = new Set(); @@ -101,22 +116,34 @@ export default async function generateExposedContracts( return errorResult(); } - const exposed = getExposed(buildInfo, buildOutput, hre.config); + const exposed = getExposed(buildInfo, buildOutput, hre.config, npmRoots); - for (const [exposedPath, exposedContent] of exposed) { + for (const [exposedPath, exposedContent] of exposed.files) { fs.mkdirSync(path.dirname(exposedPath), { recursive: true }); fs.writeFileSync(exposedPath, exposedContent); exposedPaths.add(exposedPath); } - // The exposed file of a root mirrors its path. Other exposed files (see the `imports` option) are attributed to - // all the roots of the job, as any of them may be the one importing it. + // The exposed file of a root mirrors its path (the name it was listed with for an npm root, see + // `npmFilesToBuild`). Exposed files needed by an import (see the `imports` option) are attributed to all the + // roots of the job, as any of them may be the one importing it. An npm root's exposed file can be both. const exposedPathToRoot = new Map( - roots.map(root => [path.join(hre.config.exposed.outDir, path.relative(hre.config.paths.root, root)), root]), + roots.map(root => [ + path.join( + hre.config.exposed.outDir, + root.startsWith('npm:') ? root.slice('npm:'.length) : path.relative(hre.config.paths.root, root), + ), + root, + ]), ); manifest.setGenerated( roots, - new Map(Array.from(exposed.keys(), p => [p, exposedPathToRoot.has(p) ? [exposedPathToRoot.get(p)!] : roots])), + new Map( + Array.from(new Set([...exposed.files.keys(), ...exposed.imported]), p => [ + p, + exposedPathToRoot.has(p) && !exposed.imported.has(p) ? [exposedPathToRoot.get(p)!] : roots, + ]), + ), ); } } finally { diff --git a/hardhat/hardhat-exposed/test/incremental-generation.test.js b/hardhat/hardhat-exposed/test/incremental-generation.test.js index f1c64fc49d1..f619cc03941 100644 --- a/hardhat/hardhat-exposed/test/incremental-generation.test.js +++ b/hardhat/hardhat-exposed/test/incremental-generation.test.js @@ -44,9 +44,14 @@ describe('hardhat-exposed: incremental generation', function () { }; this.manifest = () => path.join(this.outDir, 'manifest.json'); // A new environment per build mimics separate CLI invocations - this.build = async exposed => { + this.build = async (exposed, npmFilesToBuild = []) => { const hre = await createHardhatRuntimeEnvironment( - { plugins: [hardhatExposed], solidity: '0.8.35', paths: { sources: 'contracts' }, exposed }, + { + plugins: [hardhatExposed], + solidity: { version: '0.8.35', npmFilesToBuild }, + paths: { sources: 'contracts' }, + exposed, + }, {}, this.root, ); @@ -205,6 +210,108 @@ describe('hardhat-exposed: incremental generation', function () { }); }); + describe('npm files', function () { + beforeEach(function () { + const dependency = path.join(this.root, 'node_modules', 'dep'); + fs.mkdirSync(dependency, { recursive: true }); + fs.writeFileSync(path.join(dependency, 'package.json'), '{"name":"dep","version":"1.0.0"}'); + fs.writeFileSync(path.join(dependency, 'Dep.sol'), contract('Dep')); + this.write('A'); + }); + + it('generates a wrapper for an npm file to build that is included', async function () { + await this.build({ include: ['contracts/**/*.sol', 'npm:dep/**/*.sol'] }, ['dep/Dep.sol']); + expect(this.wrappers()).to.deep.equal(['contracts/A.sol', 'dep/Dep.sol']); + }); + + it('does not generate a wrapper for an npm file to build that is not included', async function () { + await this.build({ include: ['contracts/**/*.sol'] }, ['dep/Dep.sol']); + expect(this.wrappers()).to.deep.equal(['contracts/A.sol']); + }); + + it('does not generate a wrapper for an npm file to build that is excluded', async function () { + await this.build({ include: ['contracts/**/*.sol', 'npm:dep/**/*.sol'], exclude: ['npm:dep/Dep.sol'] }, [ + 'dep/Dep.sol', + ]); + expect(this.wrappers()).to.deep.equal(['contracts/A.sol']); + }); + + it('removes the wrapper of an npm file that is no longer built', async function () { + await this.build({ include: ['contracts/**/*.sol', 'npm:dep/**/*.sol'] }, ['dep/Dep.sol']); + await this.build({ include: ['contracts/**/*.sol', 'npm:dep/**/*.sol'] }); + expect(this.wrappers()).to.deep.equal(['contracts/A.sol']); + }); + + it('keeps the wrapper of an npm file when building from another directory', async function () { + const exposed = { include: ['contracts/**/*.sol', 'npm:dep/**/*.sol'] }; + await this.build(exposed, ['dep/Dep.sol']); + const cwd = process.cwd(); + try { + process.chdir(this.root); + await this.build(exposed, ['dep/Dep.sol']); + } finally { + process.chdir(cwd); + } + expect(this.wrappers()).to.deep.equal(['contracts/A.sol', 'dep/Dep.sol']); + }); + + it('keeps the wrapper of an npm file that is no longer built while a source still imports it', async function () { + fs.writeFileSync( + this.source('Importer'), + contract('Importer').replace('contract Importer', 'import {Dep} from "dep/Dep.sol";\ncontract Importer is Dep'), + ); + const exposed = { imports: true, include: ['contracts/**/*.sol', 'npm:dep/**/*.sol'] }; + await this.build(exposed, ['dep/Dep.sol']); + expect(this.wrappers()).to.deep.equal(['contracts/A.sol', 'contracts/Importer.sol', 'dep/Dep.sol']); + await this.build(exposed); + expect(this.wrappers()).to.deep.equal(['contracts/A.sol', 'contracts/Importer.sol', 'dep/Dep.sol']); + }); + + it('keeps the full wrapper of an npm file when only a source importing part of it changes', async function () { + const dependency = path.join(this.root, 'node_modules', 'dep'); + fs.writeFileSync(path.join(dependency, 'Dep.sol'), contract('Dep') + 'contract Extra {}\n'); + fs.writeFileSync( + this.source('Importer'), + contract('Importer').replace('contract Importer', 'import {Dep} from "dep/Dep.sol";\ncontract Importer is Dep'), + ); + const exposed = { imports: true, include: ['contracts/**/*.sol', 'npm:dep/**/*.sol'] }; + await this.build(exposed, ['dep/Dep.sol']); + const wrapper = path.join(this.outDir, 'dep', 'Dep.sol'); + expect(fs.readFileSync(wrapper, 'utf8')).to.include('contract $Extra'); + fs.appendFileSync(this.source('Importer'), '// modified\n'); + await this.build(exposed, ['dep/Dep.sol']); + expect(fs.readFileSync(wrapper, 'utf8')).to.include('contract $Extra'); + }); + + it('generates the wrappers of npm files whose exported paths are prefixes of one another', async function () { + const dependency = path.join(this.root, 'node_modules', 'dep'); + fs.mkdirSync(path.join(dependency, 'src')); + fs.renameSync(path.join(dependency, 'Dep.sol'), path.join(dependency, 'src', 'Dep.sol')); + fs.writeFileSync(path.join(dependency, 'src', 'Dep.solExtra.sol'), contract('Extra')); + fs.writeFileSync( + path.join(dependency, 'package.json'), + '{"name":"dep","version":"1.0.0","exports":{"./Dep.sol":"./src/Dep.sol","./Extra.sol":"./src/Dep.solExtra.sol"}}', + ); + await this.build({ include: ['contracts/**/*.sol', 'npm:dep/**/*.sol'] }, ['dep/Dep.sol', 'dep/Extra.sol']); + expect(this.wrappers()).to.deep.equal(['contracts/A.sol', 'dep/Dep.sol', 'dep/Extra.sol']); + }); + + it('generates the wrapper of an npm file at its exported path', async function () { + const dependency = path.join(this.root, 'node_modules', 'dep'); + fs.mkdirSync(path.join(dependency, 'src')); + fs.renameSync(path.join(dependency, 'Dep.sol'), path.join(dependency, 'src', 'Dep.sol')); + fs.writeFileSync( + path.join(dependency, 'package.json'), + '{"name":"dep","version":"1.0.0","exports":{"./Dep.sol":"./src/Dep.sol"}}', + ); + const exposed = { include: ['contracts/**/*.sol', 'npm:dep/**/*.sol'] }; + await this.build(exposed, ['dep/Dep.sol']); + expect(this.wrappers()).to.deep.equal(['contracts/A.sol', 'dep/Dep.sol']); + await this.build(exposed); + expect(this.wrappers()).to.deep.equal(['contracts/A.sol']); + }); + }); + describe('imports option', function () { beforeEach(function () { const dependency = path.join(this.root, 'node_modules', 'dep');