Can Solidity constant functions be arbitrarily complex?

Question

Non-constant functions are limited in computational complexity by the block gas limit. I assume, but am not sure, that this does not apply to constant functions. Are constant functions in any way limited in computational complexity other than the fact that I'd have to wait for quite a while until e.g. a long loop is executed?

Answer 1

Constant functions are limited by the gas provided to it. They still "use" gas, even though the sender (from account) doesn't get "charged" for the gas.

view, pure, constant are Solidity keywords but currently only an indicator for Javascript web3.js to use JSON-RPC eth_call instead of eth_sendTransaction.

https://github.com/ethereum/wiki/wiki/JavaScript-API#contract-methods

// Automatically determines the use of call or sendTransaction based on the method type (constant keyword exists or not?)
myContractInstance.myMethod(param1 [, param2, ...] [, transactionObject] [, defaultBlock] [, callback]);

// Explicitly calling this method
myContractInstance.myMethod.call(param1 [, param2, ...] [, transactionObject] [, defaultBlock] [, callback]);

// Explicitly sending a transaction to this method
myContractInstance.myMethod.sendTransaction(param1 [, param2, ...] [, transactionObject] [, callback]);

call and sendTransaction are very similar (under the hood), with the main difference being the former is a simulation. But the simulation still "uses" gas, and understandably can cause confusion. To perform a complex computation in a constant function, you may need to explicitly specify plenty of gas like: myContractInstance.myMethod.call(param1, {gas:990000000})

For example, Geth "only" provides 50 million gas:

if msg.gas == nil {
    msg.gas = big.NewInt(50000000)
}

As @Tjaden commented, there are basically no specs about eth_call, so other clients and browser-solidity may behave differently from Geth.

Answer 2

The computational work needed by a constant or non-constant function is the same when you create your contract or if you execute the function. The initial cost is depending on the operations excuted in the EVM, each opcode has its own price you could check the list (maybe outdated). However, "constant" keyword indicates that the function is not supposed to modifiy the states, and no gas will be used because it allows to the function to be excuted locally/off blockchain in your node.

Test:

Edit : let's try to excute a loop within a constant function to get an idea computational work :

pragma solidity ^0.4.0;

contract test_compexity{


 function f(uint256 n) constant  returns (uint256)  {
    uint256 j=0;
     while(j<n){
         j=j+1;
     }

 return j;
 }
}

if we run this constant function with the input 1001 we get the result 0X

if we run the same function whithout the constant type and with the same input we get the error : Gas required exceeds limit

so even if we are using constant function we are still under gaslimit limitation. Think of it as if you are using the constant function you are just paying yourself withing a gaslimit.