The gas limit for a view function call not made from a contract

gasgas-limitout-of-gassolidity

So this question seems trivial but I can't find any comprehensive answer, though reading through:

My question is as follows:

I can call estimateGas to estimate the gas needed to call one of my functions from ethers.js
What is the limit gas for my function?

Context: I am working on a on-chain NFT project and the tokenURI method is a bit complex. I don't understand if this is a problem. And how much gas maximum it should have?

Best Answer

What is the limit gas for my function?

estimateGas will return a reasonably accurate value for your tokenURI method.

(If your tokenURI method is very contrived/variable, be aware of What are the limitations to estimateGas and when would its estimate be considerably wrong?)

tokenURI method is a bit complex. I don't understand if this is a problem.

Users generally do not invoke the tokenURI method so you are usually OK.

The effect of any expensive smart contract function (including tokenURI) is less on-chain composability/interoperability with that function, possibly the whole contract.

A web2 analogy might be calling a slow, unreliable, or paid API: developers will avoid calling those APIs in preference for something faster and reliable.

And how much gas maximum it should have?

We can say that a very expensive tokenURI method would be one that consumes half the block gas limit. Even 10% of the block gas limit seems high, so I would aim for lower than 10%.

Even though tokenURIis usually only called off-chain so that its gas usage doesn't matter as much, I would not underestimate the chances that there may be creative uses of tokenURI on-chain in the future, so I would still try to be reasonable about its gas consumption.

Related Solutions

[Ethereum] Using web3.eth.estimateGas cause “gas required exceeds allowance or always failing transaction”

After looking at the source code for this, you'll notice that it's failing because the gas allowance does not result in an executable transaction. EstimateGas function executes the requested code against the currently pending block/state and returns the used amount of gas (or error in your case). But, it can also fail if the transaction is ill-formed.

var errGasEstimationFailed = errors.New("gas required exceeds allowance or always failing transaction")

// Reject the transaction as invalid if it still fails at the highest allowance
if hi == cap {
    if !executable(hi) {
        return nil, errGasEstimationFailed
    }
}

It looks like you may be incorrectly passing arguments to getData and thus in turn estimateGas.

Update: Please try below code.

let call_data_phase = this.contract.addPhase.getData(
        companies[i].phases[j].start_time,
        companies[i].phases[j].prices_in_wei,
        companies[i].phases[j].prices_in_wei_ends,
        companies[i].phases[j].tokens_count,
        companies[i].phases[j].min_tokens_to_sell,
        {from: sender, gas: 10000000000}

    );

web3.eth.estimateGas({data: call_data_phase, from: sender})

Hope this helps.

What happens if a view function has gas cost above the block gas limit

Yes, the view function should fail.

view/pure functions are limited by the gas provided to it. They still "use" gas, even though the sender doesn't get "charged" for the gas.

For more, including how a version of Geth was providing 50 million gas for view functions, see Can Solidity view/pure functions be arbitrarily complex?

I remember reading that ETH nodes do not accept functions with such complexity

Nodes accept any bytecode that is paid for (even if it is an infinite loop). Basically the only way that a node can tell how much computation the code does, is by running the code (related is the Halting problem).

Best Answer

Related Solutions

[Ethereum] Using web3.eth.estimateGas cause “gas required exceeds allowance or always failing transaction”

What happens if a view function has gas cost above the block gas limit

Related Topic