LESSON 5: Ethers v6.10.1 Unable to call custom methods on contracts after they are deployed

[S0mt0]

Hi, I noticed that a lot of things have changed since ethers v6. When I log SimpleStorage contract to the console, it doesn't show all the contract methods that are in the ABI, and I also can't call any of the methods or properties as typescript would warn that such properties don't exist on type BaseContract.

Here's a snippet of the code:

  const contractFactory = new ethers.ContractFactory(ABI, BIN, wallet);
  console.log("Deploying, please wait...");
  const contract = await contractFactory.deploy();

  const deploymentReceipt = (await contract.waitForDeployment())
    .deploymentTransaction()
    ?.wait(1);

  console.log("[CONTRACT]: ", contract);

Here's what the contract looks like when logged to the console:

[CONTRACT]:  BaseContract {
  target: '0x35392C5e5bd3048602635B6De67933E40c2732FB',
  interface: Interface {
    fragments: [
      [FunctionFragment],
      [FunctionFragment],
      [FunctionFragment],
      [FunctionFragment],
      [FunctionFragment]
    ],
    deploy: ConstructorFragment {
      type: 'constructor',
      inputs: [],
      payable: false,
      gas: null
    },
    fallback: null,
    receive: false
  },
  runner: Wallet {
    provider: JsonRpcProvider {},
    address: '0xb5Bb8689D089e603017A0586C8A1D229294081aD'
  },
  filters: {},
  fallback: null,
  [Symbol(_ethersInternal_contract)]: {}
}

And I get the following error when I try to use the "retrieve" method:

Property 'retrieve' does not exist on type 'BaseContract & { deploymentTransaction(): ContractTransactionResponse; } & Omit<BaseContract, keyof BaseContract>'.ts(2339)
any

Please how do I proceed from here?

[S0mt0]

I've just figured right now that the only way to safely interact with the deployed contract using typescript and ethers v6 (no hardhat) is to make use of typechain just like Patrick did but with hardhat.
Use the following command to generate contract Interface (ethers v6):

yarn typechain --target ethers-v6 --out-dir .

And the code looks something like:

import { ethers } from "ethers";
import { env, abi } from "./constants";

import fs from "fs";
import { SimpleStorage_sol_SimpleStorage } from "./SimpleStorage_sol_SimpleStorage";

async function main() {
  const ABI = fs.readFileSync("./SimpleStorage_sol_SimpleStorage.abi", "utf8");
  const PRIVATE_KEY = env.privateKey;
  const provider = new ethers.JsonRpcProvider(env.rpcUrl);
  const wallet = new ethers.Wallet(PRIVATE_KEY, provider);

  const ct = new ethers.Contract(
    "0xE390BA08b14020CCAf3a18d272AC0f52824b54A7",
    ABI
  );

  const contract = ct.connect(wallet) as SimpleStorage_sol_SimpleStorage;

  const addPerson = await contract.addPerson("Sewkito", "2024");

  console.log("Please wait...");
  await addPerson.wait(1);
  console.log("PERSON", await contract.people("0"));

  console.log("\nplease wait, getting favorite number...");
  console.log("\n[FAVORITE NUMBER]: ", (await contract.retrieve()).toString());
}

main()
  .then(() => {
    process.exit(0);
  })
  .catch((e) => {
    console.log("[ERROR]: ", e);
    process.exit(1);
  });

It worked for me.

[abhigit-saha]

As @S0mt0 replied, it is indeed recommended to use typechain. However (if like me) you are struggling with implementing it, the .getFunction() method also works.

const favoriteNumber = await contract.getFunction("retrieve")();
console.log("Favorite Number: ", favoriteNumber.toString());

works for me.

[TatyOko28]

In Ethers v6, when you deploy a contract using:
const contractFactory = new ethers.ContractFactory(ABI, BIN, wallet);
const contract = await contractFactory.deploy();

The returned object is a BaseContract, which does not automatically expose methods defined in the ABI.

2. Fix: Use TypeChain to Generate Type-Safe Interfaces
   yarn add --dev typechain @typechain/ethers-v6

Generate TypeScript Types for Contracts
yarn typechain --target ethers-v6 --out-dir ./types

Update Code to Use the Generated Interface After running the command, TypeChain will create a TypeScript interface like:
import { SimpleStorage } from "./types/SimpleStorage";

Now use this interface when interacting with the contract:
import { ethers } from "ethers";
import { SimpleStorage } from "./types/SimpleStorage";

async function main() {
const provider = new ethers.JsonRpcProvider("http://127.0.0.1:8545");
const wallet = new ethers.Wallet("YOUR_PRIVATE_KEY", provider);

// Use the ABI and contract address to create an instance
const contract = new ethers.Contract(
    "0xYourContractAddress",
    SimpleStorage.abi, // Use generated ABI
    wallet
) as SimpleStorage; // Use generated TypeChain type

// Now you can safely call methods
const addPersonTx = await contract.addPerson("JohnDoe", "1995");
await addPersonTx.wait();

console.log("Person Added:", await contract.people("0"));
console.log("Favorite Number:", await contract.retrieve());

}

main().catch(console.error);

Key Takeaways
Ethers v6 requires explicit typing for contract instances, unlike v5.
Use TypeChain to generate TypeScript interfaces for your smart contracts.
Always cast your contract instance with as ContractType to access contract methods in a type-safe way