Error: VoidSigner cannot sign transactions

[muhammet72]

I'm getting this error and I couldn't fix it

Contract

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

contract EtherWallet {
  address payable public owner;

  constructor() {
    owner = payable(msg.sender);
  }

  receive() external payable {}

  function withdraw(uint _amount) external {
    require(msg.sender == owner, "caller is not owner");
    payable(msg.sender).transfer(_amount);
  }

  function getBalance() external view returns (uint) {
    return address(this).balance;
  }
}

test

const { network, getNamedAccounts, deployments, ethers } = require("hardhat")
const { developmentChains, networkConfig } = require("../helper-hardhat-config")
const { assert, expect } = require("chai")

describe("EtherWallet", async () => {
  let etherWallet
  let accounts = []
  let sender
  beforeEach(async () => {
    ;[deployer, sender] = await ethers.getSigners()
    deployer = (await getNamedAccounts()).deployer
    await deployments.fixture(["all"])
    etherWallet = await ethers.getContract("EtherWallet", deployer)
  })
  describe("state variables", () => {
    it("should set coorrect owner", async () => {
      expect(await etherWallet.owner()).to.equal(deployer)
    })
  })

  describe("Receive Ether", async () => {
    it("should receive Ether using receive function", async function () {
      const initialBalance = await ethers.provider.getBalance(etherWallet.address)

      // Send Ether to the contract using a simple Ether transfer without data
      const amountToSend = ethers.utils.parseEther("1")
      await sender.sendTransaction({ to: etherWallet.address, value: amountToSend })

      // Check if the contract's balance increased by the sent amount
      const finalBalance = await ethers.provider.getBalance(etherWallet.address)
      expect(finalBalance).to.equal(initialBalance.add(amountToSend))
    })
  })

  describe("Witdraw ", async () => {
    it("should not allow non-owners to withdraw funds", async () => {
      const amountToSend = ethers.utils.parseEther("1")

      // Try to withdraw from the contract using a non-owner account (sender)
      try {
        await etherWallet.connect(sender).withdraw(amountToSend)
      } catch (error) {
        // Ensure that the transaction reverted with the expected error message
        expect(error.message).to.contain("caller is not owner")
        return
      }

      assert.fail("Expected the transaction to revert")
    })

    it("should allow the owner to withdraw funds", async function () {
      const initialBalance = await etherWallet.getBalance()

      // Send Ether to the contract using the owner's account (deployer)
      const amountToSend = ethers.utils.parseEther("1")

      // Use the deployer's signer to call withdraw
      await etherWallet.connect(deployer).withdraw(amountToSend)

      // Check if the receiver's balance increased by the sent amount
      const finalBalance = await etherWallet.getBalance()
      expect(finalBalance).to.equal(initialBalance.add(amountToSend))
    })
  })

  describe("get balance", async () => {
    it("should return the correct contract balance", async function () {
      // Get the contract's balance using the getBalance function
      const contractBalance = await etherWallet.getBalance()

      // Get the actual balance from the provider
      const actualBalance = await ethers.provider.getBalance(etherWallet.address)

      expect(contractBalance).to.equal(actualBalance)
    })
  })
})

error

 1) EtherWallet
       Witdraw 
         should allow the owner to withdraw funds:
     Error: VoidSigner cannot sign transactions (operation="signTransaction", code=UNSUPPORTED_OPERATION, version=abstract-signer/5.7.0)
      at Logger.makeError (node_modules/@ethersproject/logger/src.ts/index.ts:269:28)
      at Logger.throwError (node_modules/@ethersproject/logger/src.ts/index.ts:281:20)
      at /home/code/dapps-hardhat/node_modules/@ethersproject/abstract-signer/src.ts/index.ts:355:20
      at processTicksAndRejections (node:internal/process/task_queues:96:5)
      at runNextTicks (node:internal/process/task_queues:65:3)
      at listOnTimeout (node:internal/timers:528:9)
      at process timers (node:internal/timers:502:7)

could you help me about this error

[Nlferu]

Hi @muhammet72

Just remove below from your code.

[Nlferu]

hi @muhammet72

      // This part of code is wrong
      describe("EtherWallet", async () => {
        let etherWallet
        let accounts = []
        let sender
        beforeEach(async () => {
          ;[deployer, sender] = await ethers.getSigners()
          deployer = (await getNamedAccounts()).deployer
          await deployments.fixture(["all"])
          etherWallet = await ethers.getContract("EtherWallet", deployer)
        })

      // Change it to below to define signers correct
      describe("EtherWallet", async () => {
        let etherWallet
        let accounts
        let sender
        beforeEach(async () => {
          accounts = await ethers.getSigners()
          sender = accounts[1]
          deployer = (await getNamedAccounts()).deployer
          await deployments.fixture(["all"])
          etherWallet = await ethers.getContract("EtherWallet", deployer)
        })

[muhammet72]

still doesn't work

here is the last update of the test

const { network, getNamedAccounts, deployments, ethers } = require("hardhat")
const { developmentChains, networkConfig } = require("../helper-hardhat-config")
const { assert, expect } = require("chai")

describe("EtherWallet", async () => {
  let etherWallet
  let accounts
  let sender
  beforeEach(async () => {
    accounts = await ethers.getSigners()
    sender = accounts[1]
    deployer = (await getNamedAccounts()).deployer
    await deployments.fixture(["all"])
    etherWallet = await ethers.getContract("EtherWallet", deployer)
  })

  describe("state variables", () => {
    it("should set coorrect owner", async () => {
      expect(await etherWallet.owner()).to.equal(deployer)
    })
  })

  describe("Receive Ether", async () => {
    it("should receive Ether using receive function", async function () {
      const initialBalance = await ethers.provider.getBalance(etherWallet.address)

      // Send Ether to the contract using a simple Ether transfer without data
      const amountToSend = ethers.utils.parseEther("1")
      await sender.sendTransaction({ to: etherWallet.address, value: amountToSend })

      // Check if the contract's balance increased by the sent amount
      const finalBalance = await ethers.provider.getBalance(etherWallet.address)
      expect(finalBalance).to.equal(initialBalance.add(amountToSend))
    })
  })

  describe("Witdraw ", async () => {
    it("should not allow non-owners to withdraw funds", async () => {
      const amountToSend = ethers.utils.parseEther("1")

      // Try to withdraw from the contract using a non-owner account (sender)
      try {
        await etherWallet.connect(sender).withdraw(amountToSend)
      } catch (error) {
        // Ensure that the transaction reverted with the expected error message
        expect(error.message).to.contain("caller is not owner")
        return
      }

      assert.fail("Expected the transaction to revert")
    })

    it("should allow the owner to withdraw funds", async function () {
      const initialBalance = await etherWallet.getBalance()

      // Send Ether to the contract using the owner's account (deployer)
      const amountToSend = ethers.utils.parseEther("1")

      // Use the deployer's signer to call withdraw
      await etherWallet.connect(deployer).withdraw(amountToSend)

      // Check if the receiver's balance increased by the sent amount
      const finalBalance = await etherWallet.getBalance()
      expect(finalBalance).to.equal(initialBalance.add(amountToSend))
    })
  })

  describe("get balance", async () => {
    it("should return the correct contract balance", async function () {
      // Get the contract's balance using the getBalance function
      const contractBalance = await etherWallet.getBalance()

      // Get the actual balance from the provider
      const actualBalance = await ethers.provider.getBalance(etherWallet.address)

      expect(contractBalance).to.equal(actualBalance)
    })
  })
})

and this is the error " should allow the owner to withdraw funds:
Error: VoidSigner cannot sign transactions (operation="signTransaction", code=UNSUPPORTED_OPERATION, version=abstract-signer/5.7.0)"

[Nlferu]

Hi @muhammet72

Try using below code:

const { network, getNamedAccounts, deployments, ethers } = require("hardhat")
const { developmentChains, networkConfig } = require("../helper-hardhat-config")
const { assert, expect } = require("chai")

describe("EtherWallet", async () => {
  let etherWallet, accounts, deployer, sender

  beforeEach(async () => {
    accounts = await ethers.getSigners()
    sender = accounts[1]
    deployer = (await getNamedAccounts()).deployer
    await deployments.fixture(["all"])
    etherWallet = await ethers.getContract("EtherWallet", deployer)
  })

  describe("state variables", () => {
    it("should set coorrect owner", async () => {
      expect(await etherWallet.owner()).to.equal(deployer)
    })
  })

  describe("Receive Ether", async () => {
    it("should receive Ether using receive function", async function () {
      const initialBalance = await ethers.provider.getBalance(etherWallet.address)

      // Send Ether to the contract using a simple Ether transfer without data
      const amountToSend = ethers.utils.parseEther("1")
      await sender.sendTransaction({ to: etherWallet.address, value: amountToSend })

      // Check if the contract's balance increased by the sent amount
      const finalBalance = await ethers.provider.getBalance(etherWallet.address)
      expect(finalBalance).to.equal(initialBalance.add(amountToSend))
    })
  })

  describe("Witdraw ", async () => {
    it("should not allow non-owners to withdraw funds", async () => {
      const amountToSend = ethers.utils.parseEther("1")

      // Try to withdraw from the contract using a non-owner account (sender)
      try {
        await etherWallet.connect(sender).withdraw(amountToSend)
      } catch (error) {
        // Ensure that the transaction reverted with the expected error message
        expect(error.message).to.contain("caller is not owner")
        return
      }

      assert.fail("Expected the transaction to revert")
    })

    it("should allow the owner to withdraw funds", async function () {
      const initialBalance = await etherWallet.getBalance()

      // Send Ether to the contract using the owner's account (deployer)
      const amountToSend = ethers.utils.parseEther("1")

      // Use the deployer's signer to call withdraw
      await etherWallet.connect(deployer).withdraw(amountToSend)

      // Check if the receiver's balance increased by the sent amount
      const finalBalance = await etherWallet.getBalance()
      expect(finalBalance).to.equal(initialBalance.add(amountToSend))
    })
  })

  describe("get balance", async () => {
    it("should return the correct contract balance", async function () {
      // Get the contract's balance using the getBalance function
      const contractBalance = await etherWallet.getBalance()

      // Get the actual balance from the provider
      const actualBalance = await ethers.provider.getBalance(etherWallet.address)

      expect(contractBalance).to.equal(actualBalance)
    })
  })
})

If it doesnt work I cannot help you as I recreated your code to test it (and it worked), but your code has TONS of errors and logical bugs like for example this below where you are connecting deployer to contract which has been deployed by deployer it is just a total mess. Only thing I can recommend you is to repeat this lesson carefully with Patrick video and write your test step by step testing and running code every single time you add something with console.log printing everything to get better understanding of it and see results.

 await etherWallet.connect(deployer).withdraw(amountToSend)

[muhammet72]

I'll repeat the lesson

I think maybe the error is caused by dependencies or hardhat.config.js
could you provide yours

thank you for your help

[Nlferu]

Hi @muhammet72

This error is caused by incorrectly described signer.

In your hardhat.config.js use below:

require("@nomiclabs/hardhat-waffle")
require("hardhat-gas-reporter")
require("@nomiclabs/hardhat-etherscan")
require("dotenv").config()
require("solidity-coverage")
require("hardhat-deploy")

const COINMARKETCAP_API_KEY = process.env.COINMARKETCAP_API_KEY || ""
const GOERLI_RPC_URL = process.env.GOERLI_RPC_URL || "https://eth-mainnet.alchemyapi.io/v2/your-api-key"
const SEPOLIA_RPC_URL = process.env.SEPOLIA_RPC_URL || ""
const PRIVATE_KEY = process.env.PRIVATE_KEY || ""
const ETHERSCAN_API_KEY = process.env.ETHERSCAN_API_KEY || ""

module.exports = {
    defaultNetwork: "hardhat",
    networks: {
        hardhat: {
            chainId: 31337,
            // gasPrice: 130000000000,
        },
        goerli: {
            url: GOERLI_RPC_URL,
            accounts: [PRIVATE_KEY],
            chainId: 5,
            blockConfirmations: 6,
        },
        sepolia: {
            url: SEPOLIA_RPC_URL,
            accounts: [PRIVATE_KEY],
            chainId: 11155111,
            blockConfirmations: 6,
        },
    },
    solidity: {
        compilers: [
            {
                version: "0.8.7",
            },
            {
                version: "0.6.6",
            },
        ],
    },
    etherscan: {
        apiKey: ETHERSCAN_API_KEY,
    },
    gasReporter: {
        enabled: true,
        currency: "USD",
        outputFile: "gas-report.txt",
        noColors: true,
        coinmarketcap: COINMARKETCAP_API_KEY,
        token: "ETH",
    },
    namedAccounts: {
        deployer: {
            default: 0, // here this will by default take the first account as deployer
            1: 0, // similarly on mainnet it will take the first account as deployer. Note though that depending on how hardhat network are configured, the account 0 on one network can be different than on another
        },
    },
    mocha: {
        timeout: 500000,
    },
}

Especially look at this line:

    namedAccounts: {
        deployer: {
            default: 0, // here this will by default take the first account as deployer
            1: 0, // similarly on mainnet it will take the first account as deployer. Note though that depending on how hardhat network are configured, the account 0 on one network can be different than on another
        },
    },