[Ethereum] Maximum gas consumption of calling a contract method

contract-developmentgas-estimategas-limitsolidity

I want to evaluate the maximum gas consumption (minimum safe gas limit that will not fail) that calling a specific contract method would consume given that I have the contract source code / byte code.

I remember a few months ago seeing a website where you can enter the solidity code and it calculates how much gas this code would consume, but I can't find this website anywhere.

Just to clarify – I know there's a method in the API that can estimate gas consumption of transaction which is only an estimate since it's based on the variables that can change (such as block number etc), but I'm talking about maximum gas consumption given the contract source code / byte code is known.

Is there a website that calculates this?

UPDATE WITH USE CASE:

For EtherDelta's contract (link) how can I determine what would be the maximum possible gas consumption for calling a specific method (say: the 'approve' method), so that I can tell what is the minimum safe gas limit that would never fail?

Best Answer

I think you may be alluding to the online remix compiler for Solidity. This will allow you to see easily how much gas a transaction to a function will need/spent.

If you execute a state changing function then inspect the details of the transaction you'll get more information. Please see the example below:

Here we can see trasaction cost & execution cost. Everything you need. Hope this helps.

Related Solutions

[Ethereum] How to minimize gas consumption during contract creation

The reason why geth refuses to send the transaction is because the block gas limit varies. On a private testnet, it can be anything, but by default it'll be 5.5 million. On the mainnet, it's currently only 2 million--so a 3 million gas transaction just wouldn't fit at all. This is because of the recent spam attacks on the network--the developers asked miners to reduce the limit, and they did. Hopefully, the miners will increase it back to the default after the incoming hardfork. (I say "hopefully" because it's the miners' decision, the devs can only suggest.)

The only things that use gas at creation time are what happens in the constructor, and the size of the compiled code itself. You might be able to reduce the size by turning on the optimizer, but it's quite possible it's already on.

I'm not that surprised at the figure it's giving, though. 264 LoC is actually a lot in Ethereum. I have a 400~ LoC contract that is 3~ million gas optimized.

There's three ways of reducing gas cost:

Simplify the contract. This might be impossible, depending on what exactly you're doing.
Split it into multiple contracts.
Refactor it to use libraries. If you're using lots of structs and mappings, this may make your code remarkably more readable.

The simplest way may be just to wait. You're not the only one who is stuck with big contracts, so the miners have an incentive to raise the gas limit again, and soon.

[Ethereum] Default gas limit set by web3 is unreasonably high

Not sure why the default gas estimate from web3 -> metamask was so high, but I have gotten around this by using the estimated gas from estimateGas() + a buffer to manually set the gas sent in the depositAll transaction.

Here is the code:

const depositHelper = new web3.eth.Contract(
    DepositHelper.abi, // abi for DepositHelper contract
    '0x4681ae82f6f575da63b77a6735f44c13fdc2e4df'
);

// construct depositAll method parameters
const amount = 40; // 40 DAI
const weiAmount = window.web3.utils.toWei(amount, 'ether'); // convert to wei
const amounts = [weiAmount];
const vaults = ['0x3EE8bD22Df6605c6a7074c56Abb0f3Fc1FA6a069'];

depositHelper.methods
    .depositAll([amount], vaults)
    .estimateGas({ from: account, gas: 50000000 })
    .then(gasEstimate => {
        // not sure if there is a best practice for adding a gas buffer
        // so I just set it to 450k as a default
        return depositHelper.methods
            .depositAll(amounts, vaults).send({ from: account, gas: gasEstimate + 450000 })
        })
    .catch(error => {});

Related Topic