Preserving visibility "view" of a method using delegate call to a view method

Question

I am using a delegate call inside a view function to a view function in the implementation contract

The compiler throws an error meaning that the delegate call can change the state, therefore, can not be declared as "view".

I am using an upgradeable contract, so I prefer not to use the fallback() function. What would then be the alternative to preserve state visibility when using a delegate.call to a view function? Thank you very much!

Answer 1

Easiest way to resolve this issue would be writing a fallback() method considering first 4 bytes of calldata as a selector and matching it with necessary view functions. And you can freely use delegatecall inside fallback():

fallback() external {
    bytes4 selector = bytes4(msg.data);
    if (selector == IActor.power.selector) {
        // ...
    }
    if (selector == IActor.height.selector) {
        // ...
    }
    // ...
}

One more solution:

interface IDelegatedFoo {
    function delegatedPower() external view returns(uint256);
}

contract Foo {
    address impl;
   
    function power() external view returns(uint256) {
        return IDelegatedFoo(address(this)).delegatedPower();
    }

    function delegatedPower() external /* view */ returns(uint256) {
        (bool success, bytes memory res) = impl.delegatecall(abi.encodePacked(this.power.selector, msg.data[4:]));
        require(success, "Failed delegatecall");
        return abi.decode(res, (uint256));
    }
}

Answer 2

When calling another smart contract using the standard way by specifying the interface of the smart contract being called and then calling that function as follows: contract.functionName(params), the Solidity compiler checks if the target function is marked as "view" or "pure" in its interface. However, when using delegatecall, Solidity does not have knowledge of the exact function being called or whether it modifies the state or not.

A possible workaround would be to use the staticcall function instead of delegatecall. This would work as long as staticcall is not invoking a function where the calling context (storage/state-variables, msg.sender, msg.value, etc..) needs to be preserved. Since delegatecall preserves the calling context, while staticcall doesn't. staticcall works exactly the same as call with only difference that it cannot modify state of the contract being called.