How is the type definition for custom contract supported?

[introom]

Given the following code:

import { ethers } from "hardhat";

async function main() {
  const contractName = "Simple";
  let factory = await ethers.getContractFactory(contractName);
  let contract = await factory.deploy();
  // the name .someFunction will be hinted.
  contract.functions.someFunction;
}

main();

I wonder how typescript definition is enabled for the contract name with literal "Simple".
Note that, when I change the modifier of "contractName" from "const" to "let", then I lose the auto completion on "contract".

[alcuadrado]

This is done by typechain's Hardhat plugin which creates a file overriding the type definition of hre.ethers.getContractFactory.

[introom]

Hi @alcuadrado ,

Given the following code.

import { ethers } from "hardhat";
import { Contract } from "ethers";

export async function deployContract(
  contractName: string,
  ...args: Array<any>
): Promise<Contract> {
  const contractFactory = await ethers.getContractFactory(contractName);
  const contract = await contractFactory.deploy(...args);
  console.log(`Contract ${contractName} deployed to ${contract.address}`);
  const c = await contract.deployed();
  return c;
}

async function example() {
  const contractName = "Simple";
  const c = await deployContract(contractName);
  // no type support (auto completion) here.
  c.functions.xxx;
  
}

The issue I am facing is that, there is no type support on c.functions inside the example funciton. I wonder how to type annotate on the deployContract to make typescript get aware of the type of the return contract.

This is more of a typescript question instead of hardhat question though.

[alcuadrado]

I don't think there's a way to type that automatically in typescript.

Take a look at how typechain works in the sample project:

typechain-types/hardhat.d.ts:

/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import { ethers } from "ethers";
import {
  FactoryOptions,
  HardhatEthersHelpers as HardhatEthersHelpersBase,
} from "@nomiclabs/hardhat-ethers/types";

import * as Contracts from ".";

declare module "hardhat/types/runtime" {
  interface HardhatEthersHelpers extends HardhatEthersHelpersBase {
    getContractFactory(
      name: "Lock",
      signerOrOptions?: ethers.Signer | FactoryOptions
    ): Promise<Contracts.Lock__factory>;

    getContractAt(
      name: "Lock",
      address: string,
      signer?: ethers.Signer
    ): Promise<Contracts.Lock>;

    // default types
    getContractFactory(
      name: string,
      signerOrOptions?: ethers.Signer | FactoryOptions
    ): Promise<ethers.ContractFactory>;
    getContractFactory(
      abi: any[],
      bytecode: ethers.utils.BytesLike,
      signer?: ethers.Signer
    ): Promise<ethers.ContractFactory>;
    getContractAt(
      nameOrAbi: string | any[],
      address: string,
      signer?: ethers.Signer
    ): Promise<ethers.Contract>;
  }
}

It explicitly defines every overload.

[introom]

Looking at the definition, yes, it even defines the overload for my contract, e.g., "Simple" in the picture.