Can Solidity view/pure 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 view/pure functions. Are view/pure 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

view/pure 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 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 view/pure 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 depends on the operations executed in the EVM, each opcode has its own price. You could check the list here (maybe outdated).

However, the "constant" keyword indicates that the function is not supposed to modify the states, and no gas will be used because it allows the function to be executed locally/off blockchain in your node.

Test:

Edit: let's try to execute a loop within a constant function to get an idea of the 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 without the constant type and with the same input, we get an error: Gas required exceeds limit

So even if we are using a constant function, we are still under gasLimit limitation. Think of it as if you are using the constant function you are just paying yourself within a gasLimit.