hardhat/dist/src/internal/builtin-plugins/solidity/type-extensions.d.ts

Hardhat is an extensible developer tool that helps smart contract developers increase productivity by reliably bringing together the tools they want.

import type { SolidityCompilerConfig } from "../../../types/config.js";
import type { BuildOptions, CompilationJobCreationError, FileBuildResult, SolidityBuildSystem } from "../../../types/solidity/build-system.js";
import type { Compiler, CompilerInput, CompilerOutput } from "../../../types/solidity.js";
import "../../../types/config.js";
declare module "../../../types/config.js" {
    /**
     * An interface with a key per compiler type.
     * The types of the values don't matter; we use `true` as a convention.
     *
     * By default, only "solc" is provided. Plugins can extend this via
     * declaration merging to add new compiler types (e.g. "solx").
     */
    interface SolidityCompilerTypeDefinitions {
        solc: true;
    }
    /**
     * The different Solidity compiler types, derived from
     * SolidityCompilerTypeDefinitions. Extensible via declaration merging.
     */
    type SolidityCompilerType = keyof SolidityCompilerTypeDefinitions;
    /**
     * The type of `userConfig.solidity`.
     */
    type SolidityUserConfig = string | string[] | SingleVersionSolidityUserConfig | MultiVersionSolidityUserConfig | BuildProfilesSolidityUserConfig;
    /**
     * Fields that all the object-typed variants of SolidityUserConfig share.
     *
     * Note: All the variants of SolidityUserConfig except for the string and
     * array of strings MUST extend this interface. For plugins creating their
     * own `SingleVersionSolidityUserConfig` variant, see
     * {@link CommonSingleVersionSolidityUserConfig}.
     */
    interface CommonSolidityUserConfig {
        isolated?: boolean;
        npmFilesToBuild?: string[];
        /**
         * Controls whether Solidity test files are compiled in a separate pass
         * from contract files.
         *
         * When `false` (the default), contracts and tests are compiled together
         * in a single pass.
         *
         * When `true`, contracts and tests are compiled separately.
         */
        splitTestsCompilation?: boolean;
    }
    /**
     * Common fields for every SingleVersionSolidityUserConfig variant.
     *
     * NOTE: All the variants of SingleVersionSolidityUserConfig must extend this
     * interface.
     */
    interface CommonSingleVersionSolidityUserConfig extends CommonSolidityUserConfig {
        toolVersionsInBuildInfo?: boolean;
    }
    /**
     * Fields that all the SolidityCompilerUserConfig variants share.
     *
     * Note: All the types of SolidityCompilerUserConfig MUST extend this
     * interface. This is especially relevant for plugins creating their own
     * `SolidityCompilerUserConfig` variant.
     */
    interface CommonSolidityCompilerUserConfig {
        type?: SolidityCompilerType;
        version: string;
        settings?: any;
        path?: string;
    }
    /**
     * Deprecated: Use `SolcSolidityCompilerUserConfig` instead.
     * @deprecated
     */
    interface SolcUserConfig extends CommonSolidityCompilerUserConfig {
        type?: "solc";
        preferWasm?: boolean;
    }
    /**
     * Solc-specific SolidityCompilerUserConfig.
     */
    interface SolcSolidityCompilerUserConfig extends SolcUserConfig {
    }
    /**
     * A map from compiler type to its SolidityCompilerUserConfig type.
     *
     * Note: The types MUST extend `CommonSolidityCompilerUserConfig`.
     */
    interface SolidityCompilerUserConfigPerType {
        solc: SolcSolidityCompilerUserConfig;
    }
    /**
     * The type of all the compiler user configs.
     */
    type SolidityCompilerUserConfig = {
        [type in keyof SolidityCompilerUserConfigPerType]: SolidityCompilerUserConfigPerType[type];
    }[keyof SolidityCompilerUserConfigPerType] | (Omit<SolcSolidityCompilerUserConfig, "type"> & Partial<Pick<SolcSolidityCompilerUserConfig, "type">>);
    /**
     * Deprecated: Use `SolcSingleVersionSolidityUserConfig` instead.
     * @deprecated
     */
    interface SingleVersionSolcUserConfig extends SolcSolidityCompilerUserConfig, CommonSingleVersionSolidityUserConfig {
    }
    /**
     * Solc-specific SingleVersionSolidityUserConfig.
     */
    interface SolcSingleVersionSolidityUserConfig extends SingleVersionSolcUserConfig {
    }
    /**
     * A map from compiler type to its SingleVersionSolidityUserConfig type.
     *
     * Note: The types MUST extend `CommonSingleVersionSolidityUserConfig`.
     */
    interface SingleVersionSolidityUserConfigPerType {
        solc: SolcSingleVersionSolidityUserConfig;
    }
    /**
     * The type of all the single version user configs.
     */
    type SingleVersionSolidityUserConfig = {
        [type in keyof SingleVersionSolidityUserConfigPerType]: SingleVersionSolidityUserConfigPerType[type];
    }[keyof SingleVersionSolidityUserConfigPerType] | (Omit<SolcSingleVersionSolidityUserConfig, "type"> & Partial<Pick<SolcSingleVersionSolidityUserConfig, "type">>);
    /**
     * Deprecated: Use `MultiVersionSolidityUserConfig` or
     * `MultiVersionBuildProfileUserConfig` instead.
     * @deprecated
     */
    interface MultiVersionSolcUserConfig {
        preferWasm?: boolean;
        isolated?: boolean;
        compilers: SolidityCompilerUserConfig[];
        overrides?: Record<string, SolidityCompilerUserConfig>;
    }
    /**
     * The type of a multi-version SolidityUserConfig.
     *
     * Partially defined in `MultiVersionSolcUserConfig` for backwards
     * compatibility.
     */
    interface MultiVersionSolidityUserConfig extends MultiVersionSolcUserConfig, CommonSolidityUserConfig {
        toolVersionsInBuildInfo?: boolean;
    }
    /**
     * The type of a single-version build profile user config.
     */
    type SingleVersionBuildProfileUserConfig = SolidityCompilerUserConfig & {
        isolated?: boolean;
        toolVersionsInBuildInfo?: boolean;
    };
    /**
     * The type of a multi-version build profile user config.
     * Mostly defined in `MultiVersionSolcUserConfig` for backwards compatibility
     */
    interface MultiVersionBuildProfileUserConfig extends MultiVersionSolcUserConfig {
        toolVersionsInBuildInfo?: boolean;
    }
    /**
     * The type of the build profile version of the SolidityUserConfig.
     */
    interface BuildProfilesSolidityUserConfig extends CommonSolidityUserConfig {
        profiles: Record<string, SingleVersionBuildProfileUserConfig | MultiVersionBuildProfileUserConfig>;
    }
    /**
     * Extension of HardhatUserConfig with the `solidity` property.
     */
    interface HardhatUserConfig {
        solidity?: SolidityUserConfig;
    }
    /**
     * Common fields of a SolidityCompilerConfig.
     *
     * Note: All the types of SolidityCompiler config MUST extend this interface.
     * This is especially relevant for plugins creating their own
     * `SolidityCompilerConfig` variant.
     */
    interface CommonSolidityCompilerConfig {
        type?: SolidityCompilerType;
        version: string;
        settings: any;
        path?: string;
    }
    /**
     * Deprecated: Use `SolcSolidityCompilerConfig` instead.
     * @deprecated
     */
    interface SolcConfig extends CommonSolidityCompilerConfig {
        type?: "solc";
        preferWasm?: boolean;
    }
    /**
     * The type of a solc-specific SolidityCompilerConfig.
     */
    interface SolcSolidityCompilerConfig extends SolcConfig {
    }
    /**
     * A map from compiler type to its `SolidityCompilerConfig` type. Note that
     * the types MUST extend `CommonSolidityCompilerConfig`.
     */
    interface SolidityCompilerConfigPerType {
        solc: SolcSolidityCompilerConfig;
    }
    /**
     * The type of all the compiler configs.
     */
    type SolidityCompilerConfig = {
        [type in keyof SolidityCompilerConfigPerType]: SolidityCompilerConfigPerType[type] & {
            type: type;
        };
    }[keyof SolidityCompilerConfigPerType] | (Omit<SolcSolidityCompilerConfig, "type"> & Partial<Pick<SolcSolidityCompilerConfig, "type">>);
    /**
     * The type of a resolved build profile config.
     */
    interface SolidityBuildProfileConfig {
        isolated: boolean;
        preferWasm: boolean;
        toolVersionsInBuildInfo?: boolean;
        compilers: SolidityCompilerConfig[];
        overrides: Record<string, SolidityCompilerConfig>;
    }
    /**
     * Resolved Solidity config.
     */
    interface SolidityConfig {
        profiles: Record<string, SolidityBuildProfileConfig>;
        npmFilesToBuild: string[];
        registeredCompilerTypes: SolidityCompilerType[];
        splitTestsCompilation: boolean;
    }
    /**
     * An extension of HardhatConfig with the `solidity` property.
     */
    interface HardhatConfig {
        solidity: SolidityConfig;
    }
    interface SourcePathsUserConfig {
        solidity?: string | string[];
    }
    interface SourcePathsConfig {
        solidity: string[];
    }
}
import "../../../types/hre.js";
declare module "../../../types/hre.js" {
    interface HardhatRuntimeEnvironment {
        solidity: SolidityBuildSystem;
    }
}
import "../../../types/global-options.js";
declare module "../../../types/global-options.js" {
    interface GlobalOptions {
        buildProfile: string;
    }
}
import "../../../types/hooks.js";
declare module "../../../types/hooks.js" {
    interface HardhatHooks {
        solidity: SolidityHooks;
    }
    interface SolidityHooks {
        /**
         * Hook triggered to download compilers needed for compilation.
         * Each handler should download compilers it is responsible for.
         * Runs in parallel — all registered handlers execute concurrently.
         *
         * @param context The hook context.
         * @param compilerConfigs All compiler configurations from all build profiles.
         * @param quiet Whether to suppress download progress output.
         */
        downloadCompilers: (context: HookContext, compilerConfigs: SolidityCompilerConfig[], quiet: boolean) => Promise<void>;
        /**
         * Hook to obtain a Compiler instance for a given compiler configuration.
         * The default handler returns a solc compiler. Plugins can intercept to
         * return their own compiler (e.g. SolxCompiler for type: "solx").
         *
         * @param context The hook context.
         * @param compilerConfig The compiler configuration to get a compiler for.
         * @param next A function to call the next handler for this hook.
         * @returns A Compiler instance.
         */
        getCompiler: (context: HookContext, compilerConfig: SolidityCompilerConfig, next: (nextContext: HookContext, nextCompilerConfig: SolidityCompilerConfig) => Promise<Compiler>) => Promise<Compiler>;
        /**
         * Hook triggered during the cleanup process of Solidity compilation artifacts.
         * This hook runs after unused artifacts and build-info files have been removed.
         *
         * @param context The hook context.
         * @param artifactPaths The file paths of artifacts that remain after cleanup.
         * @param next A function to call the next handler for this hook, or the
         * default implementation if no more handlers exist.
         */
        onCleanUpArtifacts: (context: HookContext, artifactPaths: string[], next: (nextContext: HookContext, artifactPaths: string[]) => Promise<void>) => Promise<void>;
        /**
         * Hook triggered to preprocess a Solidity file and manipulate its contents
         * before it is passed along for compilation. Only files directly under
         * the Hardhat project are preprocessed, Solidity files from npm
         * dependencies are not included.
         *
         * @param context The hook context.
         * @param inputSourceName The input source name of the project file.
         * @param fsPath The absolute path to the project file.
         * @param fileContent The content of the project file.
         * @param solcVersion The solc version that will be used to compile the project file.
         * @param next A function to call the next handler for this hook, or the
         * default implementation if no more handlers exist.
         *
         * @returns The modified file content.
         */
        preprocessProjectFileBeforeBuilding(context: HookContext, inputSourceName: string, fsPath: string, fileContent: string, solcVersion: string, next: (nextContext: HookContext, nextInputSourceName: string, nextFsPath: string, nextFileContent: string, nextSolcVersion: string) => Promise<string>): Promise<string>;
        /**
         * Hook triggered within the compilation job when its solc input is first constructed.
         *
         * @param context The hook context.
         * @param solcInput The solc input that will be passed to solc.
         * @param next A function to call the next handler for this hook, or the
         * default implementation if no more handlers exist.
         *
         * @returns The modified solc input.
         */
        preprocessSolcInputBeforeBuilding(context: HookContext, solcInput: CompilerInput, next: (nextContext: HookContext, nextSolcInput: CompilerInput) => Promise<CompilerInput>): Promise<CompilerInput>;
        readSourceFile: (context: HookContext, absolutePath: string, next: (nextContext: HookContext, nextAbsolutePath: string) => Promise<string>) => Promise<string>;
        /**
         * Hook triggered when a Solidity build process is run using the `build`
         * method of the Solidity build system.
         *
         * @param context The hook context.
         * @param rootFilePaths The files to build, which can be either absolute
         * paths or `npm:<package-name>/<file-path>` URIs.
         * @param options The options to use when building the files.
         * @param next A function to call the next handler for this hook.
         */
        build: (context: HookContext, rootFilePaths: string[], options: BuildOptions | undefined, next: (nextContext: HookContext, nextRootFilePaths: string[], nextOptions: BuildOptions | undefined) => Promise<CompilationJobCreationError | Map<string, FileBuildResult>>) => Promise<CompilationJobCreationError | Map<string, FileBuildResult>>;
        /**
         * Hook triggered to invoke a compiler on the standard-json input
         * generated for a given compilation job.
         * This hook allows for manipulating the input passed into the compiler
         * Hardhat has selected for the compilation job, and similarly to
         * manipulate the output.
         *
         * @param context The hook context.
         * @param compiler The compiler selected by Hardhat for this compilation
         * job.
         * @param solcInput The standard-json input constructed from the
         * compilation job.
         * @param solcConfig The compiler configuration (version, type, etc.).
         * @param next A function to call the next handler for this hook, or the
         * default implementation if no more handlers exist.
         */
        invokeSolc(context: HookContext, compiler: Compiler, solcInput: CompilerInput, solcConfig: SolidityCompilerConfig, next: (nextContext: HookContext, nextCompiler: Compiler, nextSolcInput: CompilerInput, nextSolcConfig: SolidityCompilerConfig) => Promise<CompilerOutput>): Promise<CompilerOutput>;
        /**
         * Provide a handler for this hook to supply remappings for npm packages.
         *
         * This hook is called when the resolver needs to read remappings for a package.
         * Handlers can provide remappings from alternative sources (e.g., foundry.toml)
         * in addition to the default remappings.txt files.
         *
         * @param context The hook context.
         * @param packageName The name of the npm package.
         * @param packageVersion The version of the npm package.
         * @param packagePath The absolute filesystem path to the package root.
         * @param next A function to get remappings from other sources (including default behavior).
         * @returns An array of remapping sources, each containing an array of remapping strings
         *   and the source path they came from.
         */
        readNpmPackageRemappings: (context: HookContext, packageName: string, packageVersion: string, packagePath: string, next: (nextContext: HookContext, nextPackageName: string, nextPackageVersion: string, nextPackagePath: string) => Promise<Array<{
            remappings: string[];
            source: string;
        }>>) => Promise<Array<{
            remappings: string[];
            source: string;
        }>>;
    }
}
//# sourceMappingURL=type-extensions.d.ts.map