Is there a way to call a dynamic function name in solidity?

Question

My code

for ( uint256 index = 0; index < 5; index++) {
              string memory name = GetName_v1();
            }

GetName_v1 is a method name and it should be actually a dynamic method name like

GeName_v${index}

Is there a way in solidity to achieve such? Or what is the proper way of doing it?

Answer 1

I think that Mikko's way is the only way even if you want to call other methods of the same contract.

pragma solidity ^0.8.4;


contract Test {
    uint value;
    
    function set(uint n) external{
        value = n;
    }
    
    function get() external view returns(uint) {
        return value;
    }
    
    function callByName(string calldata functionSignature, bytes calldata parameters) external returns(bytes memory) {
        (bool success, bytes memory data) = address(this).delegatecall(
            abi.encodeWithSelector(
                bytes4(
                    keccak256(bytes(functionSignature))
                ),
                parameters
            )
        );
        require(success, 'Call failed');
        return data;
    }
}

Here for example you can call get() dynamically calling callByName('get()', '0x') instead. Note that the functionSignature parameter must include the paramters types e.g. for set() it should be set(uint256). Using this method you must provide the parameters encoding and return data decoding.

I used delegatecall since in this case it should be equivalent to call but I have seen that this way it needs slightly less gas.

However this solution isn't great for at least two reasons:

• All the functions you want to call dynamically must be public or external, you could make a bad work around adding a modifier like this:

modifier isPrivate() {
    require(msg.sender == address(this), 'This method is private');
    _;
}

• The compiler manages really differently externally callable methods (public/external) from internally callable (private/internal) and if you want to use this "trick" you must declare your methods externally callable. Internally callable methods are managed using the JUMP opcode, indeed my first idea was to write an inline assembly snippet to simply jump but unfortunately this is not possible using YUL. For this reason calling methods in this way will make your contract spend more gas since it needs an additional internal transaction.

Answer 2

Yes. You can manually construct calldata which contains the input function selector (4 bytes) and then arguments to the function.

Here is a post that covers the topic.

Answer 3

This is playing with fire, but it can be done:

    function execute(address _to, bytes calldata _data)
        public
        payable
        returns (bytes memory)
    {
        (bool success, bytes memory returnData) = _to.call{value: msg.value}(_data);
        require(success);
        return returnData;
    }

Note that "success" returns true any time there is no error... but there is no checking for whether the end address is a contract, or whether the function you are trying to call exists, etc.

Also, you shouldn't change any state after doing this call. You're asking for reentrancy hacks.

How to generate that _data param? Here's how you'd do it in a default hardhat test environment (using ethers js):

  function asExecuteArg(functionName, argTypes, ...args) {  
    let signature = `function ${functionName}(${argTypes})`
    let ABI = [signature];
    let interface = new ethers.utils.Interface(ABI);
    let output = interface.encodeFunctionData(functionName, args);
    return output;
  }

  const AccountForwarder = await ethers.getContractFactory("AccountForwarder");
  contractInstance = await AccountForwarder.deploy();

  const executeArg = asExecuteArg('existingFunction', "uint256", 12);

  await contractInstance.execute(contractAddress, executeArg);

contractAddress will be the address of the deployed contract that has existingFunction(uint256 _someArg) in it.