Lesson 8 : Local node always show msg.value 0

[aviorn36]

Hi Community,
I am stumbling across a weird problem hoping if some-one could help me out of this one. I have a front-end deployed in local and back-end contract deployed in hard-hat local node as well as in Test Goerli network, when I send a transaction from front-end browser extension in hard-hat local the msg.value in fund function get always assigned to 0 (Check below screen-shot). But, when i send the transaction to Test Goerli network it works well. Not sure why this in-consistent behaviour across different network.

Surprisingly, when i run the tests in local node to test the fund function - it works well. If I trigger a fund transaction through script , it works well again. Observation-
Front end transaction with test goerli works well.
Unit-test and script call internally in local node works well
Front end transaction with local node has some issue.

Local node snip -

Test Goerli ether-scan -
https://goerli.etherscan.io/address/0xadd3c58237d374b16d09d358435c229cde1286b1

I request some-one to shed some light in this.

[aviorn36]

call from front-end -

async function fund() {
  //provider, connection
  if (
    connectionAddress !== undefined &&
    typeof window.ethereum !== "undefined"
  ) {
    const provider = new ethers.providers.Web3Provider(window.ethereum);
    const signer = provider.getSigner();
    const contract = new ethers.Contract(contractAddress, contractAbi, signer);
    console.log("wei");
    console.log(ethers.utils.parseEther("1"));
    let transactionResponse;
    try {
      transactionResponse = await contract.fund({
        value: ethers.utils.parseEther("0.1"),
      });
    } catch (error) {
      console.log(error);
    }

    console.log(transactionResponse);
    //await transactionResponse.wait(1);
  } else {
    console.log("connection not established");
  }
  //signer
  //abi, address
}

[alymurtazamemon]

@aviorn36 Do you mean you have a frontend website and it is working fine on the Goerli network but not working on the hardhat node?

[aviorn36]

@alymurtazamemon msg.value is always 0. And i guess it is ongoing issue , found some info in this thread - #315 , apparently there is no solution / fix for this.
If you look at snip in my question, fallback is actually triggered. So i guess there are multiple issue:-

1. Even though front-end triggers fund function, the fallback is first triggered in back-end which then calls fund function. (Fund should have been called and not fallback). The msg.value constraint in fund function than throws error (msg.value = 0 issue persists).
2. When withdraw function is called from front-end, it again calls fallback which again internally calls fund and since this call (withdraw) has no token value, 0 is added to smartcontract balance and when this gets executed somehow withdraw is actually called => withdraw then runs smoothly and transfers balance to deployer of contract.
3. Fund function is triggered (from fallback), msg.value is not passed correctly.

And from the thread it looks like some how PriceConverted is linked to this anomaly:-
If you set the MINIMUM_USD to "0 * e18" then what is observed is functions are called properly, meaning - if front-end calls fund function, fund function gets triggered directly (and not callback), similarly when withdraw is called from front-end, withdraws is triggered directly. Whats more weird here is, msg.value is populated correctly in this case. But since you have set MIMIMUM_USD as 0, all transaction gets passed from the require constraint. Everyone is following this workaround as seen from the thread.

[alymurtazamemon]

@aviorn36 I think, you are directly checking from the frontend side. I would suggest you first check the contract code and run the fund script and see the results. As you can see my provided result above it was working fine for me. You should also check the contract first and if it shows the correct result then your project is on frontend side.

[aviorn36]

@alymurtazamemon , bro I have already mentioned in my query, test shows correct result, running fund script also gives correct result. Only when triggered from some other client like front-end app, it behaves incorrectly. When you checked in your system, did you triggered from front-end locally hosted? If not, I suggest you do that once, you will then see the in-consistency.

I cloned patricks code separately and tried with it too, it is too failing with same error.

[PatrickAlphaC]

Thanks for bringing this up. It could be a front-end thing with hardhat. Can you check on the contracts side if the value is going through?

[aviorn36]

@PatrickAlphaC , msg.value when logged and seen in console at contract side is zero. But, different attribute in mgs like from address are logged properly. Also, it looks like the call from front-end does not trigger fund function at contract side implying it goes to fallback function from where it stores the balance in contract.
Behaviour observed is -

1. call to fund() in contract is not identified. So, it triggers fallback.
2. Though msg.value is 0, the fallback still stores the token sent to it implying the token value is/might be referred from some-other attribute in transaction by the fallback.

I have re-compiled contract and used fresh byte-code, also, I have cloned front-end and back-end from fcc repos and deloyed. Still the same.

[aviorn36]

Hi @PatrickAlphaC , sir , can you please help me in this issue. I have tried this in two different system (laptop) but still facing same issue with the local hardhat node. Stuck for almost 2 days.

[schaable]

I'm running into the same issue. On the hardhat network the transaction is reverted with the message "You need to spend more ETH!". On the Goerli network the transaction is successful.

Console log (hardhat node):

Contract in goerli (see last tx): https://goerli.etherscan.io/address/0x3C12dca4B41Dc007d052d15bB6ca2D82836D0487

Github repos:
https://github.com/schaable/hardhat-fund-me-fcc
https://github.com/schaable/html-fund-me-fcc

[JamesMckenna]

@schaable

In your FundMe.sol you declare and initialize uint256 public constant MINIMUM_USD = 50 * 10**18;

  function fund() public payable {
    console.log(msg.value);
    console.log(MINIMUM_USD);
    require(msg.value.getConversionRate(s_priceFeed) >= MINIMUM_USD, "You need to spend more ETH!"); <-- your UI isn't sending enough eth
    // require(PriceConverter.getConversionRate(msg.value) >= MINIMUM_USD, "You need to spend more ETH!");
    s_addressToAmountFunded[msg.sender] += msg.value;
    s_funders.push(msg.sender);
  }

In the index.js file for the UI you declare and initialize const ethAmount = '0.04';

async function fund() {
  const ethAmount = '0.04'; <--- this value should be >= 50 * 10**18
  if (typeof window.ethereum !== 'undefined') {

So your UI code isn't sending enough eth to the contract.

EDIT: actually....that may not be it. cloning you repo now to try it out.

@schaable Okay, so after cloning and testing locally on the hardhat testnet (not goerli) I can fund the contract

eth_sendRawTransaction
Contract call:
Transaction: 0xc613a16f8ea4dac49b0542c2d2b8dac81ef98a22ad9aa96c1ef9cd63f93e34f4
From: 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
To: 0xe7f1725e7734ce288f8367e1bb143e90bb3f0512
Value: 51 ETH
Gas used: 73704 of 73704
Block #5: 0x9a0105eaf831734e01cdbd4a5f37cd20594617f3e32fcfe77943d8b0daf7c6c3

console.log:
51000000000000000000
50000000000000000000

[schaable]

Hmm, weird. In my local it's 0 no matter the ethAmount I send. Can you send me the steps you followed?

[JamesMckenna]

@schaable

async function fund() {
  //const ethAmount = '0.04'; <---- you are only sending                                                   40000000000000000 wei 
  const ethAmount = '51.0'; <---- in your contract, you set to >= 50 Eth, so you have to send more then 49999999999999999999 wei
  if (typeof window.ethereum !== 'undefined') {
    const provider = new ethers.providers.Web3Provider(window.ethereum);
    const signer = provider.getSigner();
    const contract = new ethers.Contract(contractAddress, abi, signer);
    try {
      const transactionResponse = await contract.fund({ value: ethers.utils.parseEther(ethAmount) });
      await listenForTransactionMine(transactionResponse, provider);
      console.log('Done');
    } catch (error) {
      console.log(error);
    }
  }
}

There is a Metamask bug #315

When I click the fund button on the ui, Metamask pops up to confirm transaction. Before I can confirm, Metamask, for some reason calls the contract function many times. After I click the confirm button, 1 transaction goes through properly and funds the contract, but then Metamask makes more calls after the 1 successful call. For me, when I scroll up through the terminal output, I see about 6 failed calls before I click confirm, 1 success call when I click confirm, and 6 failed calls after the successful call.

[techybolek]

I'm having the same issue. Has anyone been able to resolve it or at least work around it?