Typescript error while attempting stage testing using hardhat on Sepolia testnet

[emeka-richard]

I'm running into an error trying to execute a stage test (with TypeScript) for the contract I deployed on the Sepolia test network.

Stage test file code (FundMe.staging.test.ts):

import { ethers, network } from "hardhat"
import { FundMe } from '../../typechain-types/contracts/FundMe';
import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
import { Addressable, Contract, ContractTransactionReceipt, ContractTransactionResponse } from "ethers";
import { developmentChain } from "../../helper-hardhat-config";
import {assert, expect} from "chai"
import { FundMe__factory } from "../../typechain-types/factories/contracts/FundMe__factory";

developmentChain.includes(network.config.chainId!) ? describe.skip :
    describe("FundMe", async function () {

        type FundMeContract = FundMe & Contract;

        let fundMeContract: FundMe;
        let fundMeContractAddress: string | Addressable;
        let signers: HardhatEthersSigner[];
        let deployer: HardhatEthersSigner;
        const sendValue: bigint = ethers.parseEther("0.1")


        beforeEach(async function () {
            signers = await ethers.getSigners();
            deployer = signers[0];

            const contract = await ethers.getContractAt("FundMe", deployer.address, deployer);
            fundMeContract = FundMe__factory.connect(
                await contract.getAddress(),
                deployer
            );
            fundMeContractAddress = await fundMeContract.getAddress();
        })

        it("fund and withdraw ETH", async function(){
            const initialDeployerBalance = await ethers.provider.getBalance(deployer.address, "latest");
            const initialContractBalance = await ethers.provider.getBalance(fundMeContractAddress, "latest");
            console.log("Initial contract balance:", initialContractBalance.toString());
            console.log("Initial deployer balance:", initialDeployerBalance.toString());


            const fundTx = await fundMeContract.fund({ value: sendValue });
            await fundTx.wait(1);

            const withdrawTx: ContractTransactionResponse = await fundMeContract.connect(deployer).withdraw();
            const withdrawTxReceipt: ContractTransactionReceipt = await withdrawTx.wait() as ContractTransactionReceipt;

            const { gasPrice, gasUsed } = withdrawTxReceipt;
            const totalGasPrice = gasUsed * gasPrice;

            const txDeployerBalance = await ethers.provider.getBalance(deployer.address, "latest");
            const finalDeployerBalance = txDeployerBalance + totalGasPrice
            const expectedDeployerBalance = initialDeployerBalance + sendValue;

            const finalContractBalance = await ethers.provider.getBalance(fundMeContractAddress, "latest");

            console.log("expected:", expectedDeployerBalance.toString())
            console.log("final:", finalDeployerBalance.toString())


            assert.equal(expectedDeployerBalance.toString(), finalDeployerBalance.toString());
            assert.equal(finalContractBalance.toString(), "0")
        })
    })

Issues:

1. It Seems ethers.provider.getBalance() for both the contract and deployer aren't returning the supposed correct figures; I think the same issue is with the contract's fund and withdraw function
2. I am getting the below error when I run tsc && npx hardhat test --network sepolia

FundMe
       fund and withdraw ETH:

      AssertionError: expected '433117153555555657' to equal '332765197365219489'
      + expected - actual

      -433117153555555657
      +332765197365219489
      
      at Context.<anonymous> (test/staging/FundMe.staging.test.ts:59:20)
      at processTicksAndRejections (node:internal/process/task_queues:95:5)

Please I wish someone could help me identify where I got it wrong.

Additionally, my package.json 👇

{
  "name": "hardhat-simple-storage",
  "version": "1.0.0",
  "description": "Hardhat-Simple-Storage",
  "scripts": {
    "start": "tsc && npx hardhat deploy --network sepolia",
    "dev": "tsc && npx hardhat deploy",
    "test-local": "tsc && npx hardhat test",
    "test-testnet": "tsc && npx hardhat test --network sepolia",
    "compile": "tsc && npx hardhat compile"
  },
  "author": "",
  "license": "MIT",
  "devDependencies": {
    "@chainlink/contracts": "^1.1.1",
    "@nomicfoundation/hardhat-chai-matchers": "^2.0.7",
    "@nomicfoundation/hardhat-toolbox": "^5.0.0",
    "@nomicfoundation/hardhat-verify": "^2.0.8",
    "@nomiclabs/hardhat-ethers": "npm:hardhat-deploy-ethers@^0.4.2",
    "ethers": "^6.13.1",
    "hardhat": "^2.22.6",
    "hardhat-deploy": "^0.12.4"
  }
}

My contract code 👇

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./PriceConverterLib.sol";

error FundMe__NotOwner();

// Interfaces or Libraries are imported here...

/**
 * @title A contract for crowdfunding
 * @author Emeka Richard
 * @notice This contract is to demo a sample funding contracts
 * @dev This implements price feeds as our library
 */

contract FundMe {
    //transaction cost = 756595 | 736638
    using PriceConverterLib for uint256;
    address[] private s_funders;
    mapping(address => uint256) private s_addressToAmountFunded;

    uint256 public constant MINMUM_USD = 50 * 1e18; //1 * 10 ** 18
    address private immutable i_owner;

    AggregatorV3Interface private s_priceFeed;

    /**
     * @notice This function funds this contract
     */
    function fund() public payable {
        //Want to be able to set a minimum fund
        //1. how do we send ETH to this contract?
        require(
            msg.value.getConversionRate(s_priceFeed) > MINMUM_USD,
            "Didn't send enough"
        ); //1e18 == 1 * 10 ** 18 == 1000000000000000000
        s_funders.push(msg.sender);
        s_addressToAmountFunded[msg.sender] = msg.value;
    }

    function withdraw() public payable onlyowner {
        // call
        (
            bool callSuccess, // bytes memory dataReturned

        ) = payable(msg.sender).call{value: address(this).balance}("");
        require(callSuccess, "Call failed!");

        for (
            uint256 funderIndex = 0;
            funderIndex < s_funders.length;
            funderIndex++
        ) {
            address fundAddress = s_funders[funderIndex];
            s_addressToAmountFunded[fundAddress] = 0;
        }

        // reset the array
        s_funders = new address[](0);

        // withdraw the funds: There are 3 diff ways to do this -
        // transfer
        // send
    }

    function cheaperWithdraw() public payable onlyowner {
        (bool success, ) = payable(i_owner).call{value: address(this).balance}("");
        require(success, "Call failed!");

        address[] memory funders = s_funders; //mapping can't be in memory..

        for (
            uint256 funderIndex = 0;
            funderIndex < funders.length;
            funderIndex++
        ) {
            address funderAddress = funders[funderIndex];
            s_addressToAmountFunded[funderAddress] = 0;
        }

        s_funders = new address[](0);
    }

    function getOwner() public view returns (address) {
        return i_owner;
    }

    function getFunder(uint256 index) public view returns (address) {
        return s_funders[index];
    }

    function getAddressToAmountFunded(
        address funder
    ) public view returns (uint256) {
        return s_addressToAmountFunded[funder];
    }

    function getPriceFeed() public view returns (AggregatorV3Interface) {
        return s_priceFeed;
    }

    constructor(address s_priceFeedAddress) {
        i_owner = msg.sender;
        s_priceFeed = AggregatorV3Interface(s_priceFeedAddress);
    }

    receive() external payable {
        fund();
    }
    fallback() external payable {
        fund();
    }

    // This is a modifier...
    modifier onlyowner() {
        // require(msg.sender == i_owner, "Sender is not owner!"); //this is a string revert, it's not gas efficient.
        if (msg.sender != i_owner) {
            revert FundMe__NotOwner();
        } //this method optimizes gas by chaning from string revert to function revert
        _;
    }
}

[kanej]

I am unsure as there is a lot going on there, but one line that looks suspicious to me is:

const contract = await ethers.getContractAt("FundMe", deployer.address, deployer)

I expected the second arg to getContractAt be the address of the deployed contract on the testnet, not the address of the account used to deploy the contract.