Internal JSON-RPC error #5013

Mayank-Pandey1 · 2023-03-05T13:33:39Z

Mayank-Pandey1
Mar 5, 2023

I am not able to withdraw eth from the contract using withdraw button:

I get this error:

My index.js script is as follows:

import { ethers } from "./ethers-6.0.2.esm.min.js";
import { abi, contractAddress } from "./constants.js";

const connectButton = document.getElementById("connectButton");
const fundButton = document.getElementById("fundButton");
const balanceButton = document.getElementById("balanceButton");
const withdrawButton = document.getElementById("withdrawButton");

connectButton.onclick = connect;
fundButton.onclick = fund;
balanceButton.onclick = getBalance;
withdrawButton.onclick = withdraw;

async function connect() {
    if (typeof window.ethereum !== "undefined") {
        window.ethereum.request({ method: "eth_requestAccounts" }); //way of connecting our website to metamask wallet
        connectButton.innerHTML = "Connected!";
    } else {
        connectButton.innerHTML = "Please install Metamask";
    }
}

async function fund() {
    const ethAmount = document.getElementById("ethAmount").value;
    console.log(`Funding with amount: ${ethAmount}`);
    //we need somethings to fund our contract
    //1. provider/ connection to the blockchain
    //2. signer/ wallet/ someone with some gas to pay
    //3. Contract that we are interacting with: ABI and contract address
    if (typeof window.ethereum !== "undefined") {
        const provider = new ethers.providers.Web3Provider(window.ethereum);
        const signer = provider.getSigner();
        console.log(signer);
        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);
        }
    }
}
//fund function

async function getBalance() {
    if (typeof window.ethereum !== "undefined") {
        const provider = new ethers.providers.Web3Provider(window.ethereum);
        const balance = await provider.getBalance(contractAddress);
        console.log(ethers.utils.formatEther(balance));
    }
}

async function withdraw() {
    console.log(`Withdrawing...`);
    if (typeof window.ethereum !== "undefined") {
        const provider = new ethers.providers.Web3Provider(window.ethereum);
        await provider.send("eth_requestAccounts", []);
        const signer = provider.getSigner();
        const contract = new ethers.Contract(contractAddress, abi, signer);
        try {
            const transactionResponse = await contract.withdraw();
            await listenForTransactionMine(transactionResponse, provider);
            // await transactionResponse.wait(1)
        } catch (error) {
            console.log(error);
        }
    } else {
        withdrawButton.innerHTML = "Please install MetaMask";
    }
}

function listenForTransactionMine(transactionResponse, provider) {
    console.log(`Mining ${transactionResponse.hash}...`);
    return new Promise((resolve, reject) => {
        provider.once(transactionResponse.hash, (transactionReceipt) => {
            //linker function
            console.log(
                `Completed with ${transactionReceipt.confirmations} confirmations.`
            );
            resolve();
        });
    });
}

and here is the contract:

//Send native token to this contract and withdraw from this contract

//contracts like metamask wallets can also hold tokens (a contract is deployed at an address in the blockchain)

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

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "./PriceConvertor.sol"; //PriceConvertor library
import "hardhat/console.sol";

error FundMe__NotOwner();

//NatSpec: Ethereum Natural Language Specification Format
/** @author Mayank Pandey
 *  @title A contract for crowdfunding
 *  @notice The contract demonstrates how people can fund to this contract and only the owner can withdraw the donated funds
 */

contract FundMe {
    using PriceConvertor for uint256;

    address[] private s_funders;
    mapping(address => uint256) s_addressToAmountFunded;

    address private immutable i_owner;
    AggregatorV3Interface private s_priceFeed;
    //752,749 without constant
    //733,435 with constant
    //710,472 with immutable

    uint256 public constant MINIMUM_USD = 50 * 1e18;

    //view functions: cost only applies when called by a contract
    //23,471 * 20000000000 = $0.75 without constant
    //21,371 * 20000000000 = $0.69 with constant

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

    modifier onlyOwner() {
        // require(msg.sender == i_owner, "You are not the owner");
        if (msg.sender != i_owner) revert FundMe__NotOwner();
        _;
    }

    function fund() public payable {
        //we can send tokens to this function or to the contract
        //using this function
        require(
            msg.value.getConversionRate(s_priceFeed) >= MINIMUM_USD,
            "Didn't send enough"
        ); //1e18 is in wei 1*10^18 wei = 1 ether
        //18 decimals
        s_funders.push(msg.sender);
        s_addressToAmountFunded[msg.sender] += msg.value;
    }

    function withdraw() public onlyOwner {
        for (uint256 i = 0; i < s_funders.length; i++) {
            s_addressToAmountFunded[s_funders[i]] = 0;
        }

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

        //withdrawing the total amount of eth funded to this contract
        //whosoever will press the withdraw button(call the withdraw function) will get all the ethers
        //payable(msg.sender).transfer(address(this).balance);

        //bool sendSuccess = payable(msg.sender).send(address(this).balance);
        // require(sendSuccess, " Transaction failed");

        (bool callSuccess /*bytes memory functionReturnedData*/, ) = payable(
            msg.sender
        ).call{value: address(this).balance}("");
        require(callSuccess, "Withdraw failed");
    }

    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;
    }

    fallback() external payable {
        console.log("----- fallback:", msg.value);
    }

    receive() external payable {
        console.log("----- receive:", msg.value);
    }
}

imertschool · 2023-03-05T17:08:32Z

imertschool
Mar 5, 2023

window.ethereum.enable() is deprecated.

You should use:

ethereum.request({ method: 'eth_requestAccounts' })

3 replies

Mayank-Pandey1 Mar 5, 2023
Author

I have used requestAccounts method only

paulcoffee85 Mar 5, 2023

What worked for me was using more than 1 browser to test code. Brave browser showed no errors when using withdraw() button when chrome did, happened on other occasions as well.

Mayank-Pandey1 Mar 10, 2023
Author

@paulcoffee85 It's now working on any browser

imertschool · 2023-03-11T15:27:36Z

imertschool
Mar 11, 2023

Can you please downgrade the ethers.js and try again?
Because the course has been recorded while ethers.js at around [email protected] and ethers@6 is still on beta and has lack of documentation.

Run this in your terminal to downgrade the ethers.js
npm install [email protected] --save