Buidler

// Main runtime environment (auto-loaded when using require/import in Node.js context)
const hre = require("@nomiclabs/buidler");
// The main export is the BuidlerRuntimeEnvironment instance

import { task, internalTask, extendEnvironment, extendConfig, usePlugin, types } from "@nomiclabs/buidler/config";

import { BuidlerPluginError, saveArtifact, readArtifact, readArtifactSync, lazyObject, lazyFunction, ensurePluginLoadedWithUsePlugin, BUIDLEREVM_NETWORK_NAME } from "@nomiclabs/buidler/plugins";

import { resetBuidlerContext, loadPluginFile } from "@nomiclabs/buidler/plugins-testing";

import "@nomiclabs/buidler/register";

// buidler.config.ts
import { BuidlerConfig, usePlugin } from "@nomiclabs/buidler/config";

usePlugin("@nomiclabs/buidler-ethers");

const config: BuidlerConfig = {
  defaultNetwork: "buidlerevm",
  solc: {
    version: "0.5.15",
    optimizer: {
      enabled: true,
      runs: 200
    }
  },
  networks: {
    localhost: {
      url: "http://127.0.0.1:8545"
    }
  }
};

export default config;

function task<ArgsT extends TaskArguments>(
  name: string,
  description?: string,
  action?: ActionType<ArgsT>
): ConfigurableTaskDefinition;

function internalTask<ArgsT extends TaskArguments>(
  name: string,
  description?: string,
  action?: ActionType<ArgsT>
): ConfigurableTaskDefinition;

interface BuidlerRuntimeEnvironment {
  readonly config: ResolvedBuidlerConfig;
  readonly buidlerArguments: BuidlerArguments;
  readonly tasks: TasksMap;
  readonly run: RunTaskFunction;
  readonly network: Network;
  /** @deprecated Use network.provider instead */
  readonly ethereum: EthereumProvider;
}

interface BuidlerConfig {
  defaultNetwork?: string;
  networks?: Networks;
  paths?: Omit<Partial<ProjectPaths>, "configFile">;
  solc?: DeepPartial<SolcConfig>;
  mocha?: Mocha.MochaOptions;
  analytics?: Partial<AnalyticsConfig>;
}

function extendConfig(extender: ConfigExtender): void;
function extendEnvironment(extender: EnvironmentExtender): void;

interface EthereumProvider extends EventEmitter {
  send(method: string, params?: any[]): Promise<any>;
}

interface Network {
  name: string;
  config: NetworkConfig;
  provider: EthereumProvider;
}

function usePlugin(pluginName: string): void;

class BuidlerPluginError extends Error {
  constructor(
    pluginName: string,
    message: string,
    parent?: Error
  );
}

function ensurePluginLoadedWithUsePlugin(): void;

// Core task names
const TASK_CLEAN = "clean";
const TASK_COMPILE = "compile";
const TASK_CONSOLE = "console";
const TASK_HELP = "help";
const TASK_RUN = "run";
const TASK_TEST = "test";
const TASK_FLATTEN = "flatten";

interface Artifact {
  contractName: string;
  abi: any;
  bytecode: string;
  deployedBytecode: string;
  linkReferences: LinkReferences;
  deployedLinkReferences: LinkReferences;
}

function saveArtifact(artifactsPath: string, artifact: Artifact): Promise<void>;
function readArtifact(artifactsPath: string, contractName: string): Promise<Artifact>;
function readArtifactSync(artifactsPath: string, contractName: string): Artifact;

type TaskArguments = any;

type ActionType<ArgsT extends TaskArguments> = (
  taskArgs: ArgsT,
  env: BuidlerRuntimeEnvironment,
  runSuper: RunSuperFunction<ArgsT>
) => Promise<any>;

type RunTaskFunction = (
  name: string,
  taskArguments?: TaskArguments
) => Promise<any>;

interface RunSuperFunction<ArgT extends TaskArguments> {
  (taskArguments?: ArgT): Promise<any>;
  isDefined: boolean;
}

type EnvironmentExtender = (env: BuidlerRuntimeEnvironment) => void;

type ConfigExtender = (
  config: ResolvedBuidlerConfig,
  userConfig: DeepReadonly<BuidlerConfig>
) => void;

interface TasksMap {
  [name: string]: TaskDefinition;
}

interface TaskDefinition extends ConfigurableTaskDefinition {
  readonly name: string;
  readonly description?: string;
  readonly action: ActionType<TaskArguments>;
  readonly isInternal: boolean;
  readonly paramDefinitions: ParamDefinitionsMap;
  readonly positionalParamDefinitions: Array<ParamDefinition<any>>;
}

interface ParamDefinitionsMap {
  [paramName: string]: ParamDefinition<any>;
}

interface ParamDefinition<T> {
  name: string;
  defaultValue?: T;
  type: ArgumentType<T>;
  description?: string;
  isOptional: boolean;
  isFlag: boolean;
  isVariadic: boolean;
}

interface ArgumentType<T> {
  name: string;
  parse(argName: string, strValue: string): T;
}

interface LinkReferences {
  [libraryFileName: string]: {
    [libraryName: string]: Array<{ length: number; start: number }>;
  };
}

type NetworkConfig = BuidlerNetworkConfig | HttpNetworkConfig;

interface Networks {
  [networkName: string]: NetworkConfig;
}

type NetworkConfigAccounts =
  | "remote"
  | string[]
  | HDAccountsConfig
  | OtherAccountsConfig;

interface ProjectPaths {
  root: string;
  configFile: string;
  cache: string;
  artifacts: string;
  sources: string;
  tests: string;
}

interface BuidlerNetworkAccount {
  privateKey: string;
  balance: string;
}

interface HDAccountsConfig {
  mnemonic: string;
  initialIndex?: number;
  count?: number;
  path?: string;
}

interface OtherAccountsConfig {
  type: string;
}

interface SolcConfig {
  version: string;
  optimizer: SolcOptimizerConfig;
  evmVersion?: string;
}

interface SolcOptimizerConfig {
  enabled: boolean;
  runs: number;
}

interface AnalyticsConfig {
  enabled: boolean;
}

interface ResolvedBuidlerConfig extends BuidlerConfig {
  defaultNetwork: string;
  paths: ProjectPaths;
  networks: Networks;
  solc: SolcConfig;
  analytics: AnalyticsConfig;
}

interface BuidlerArguments {
  network?: string;
  showStackTraces: boolean;
  version: boolean;
  help: boolean;
  emoji: boolean;
  config?: string;
  verbose: boolean;
  maxMemory?: number;
}