Dynamic External Contract Calls in Solidity

• Introduction
• Step-by-Step Guide
• Code Example
• Additional Notes
• Summary
• Conclusion
• References

Solidity doesn't directly support calling functions by their names dynamically. However, you can interact with other contracts and achieve dynamic behavior using interfaces, function selectors, and the low-level call function. While these techniques offer flexibility, they require careful consideration of security implications and error handling.

Solidity doesn't directly support calling functions by their names dynamically. However, you can interact with other contracts and achieve dynamic behavior using these techniques:

1. Interfaces and Known Function Signatures:

• Define an interface for the external contract, specifying the function you want to call:

interface MyExternalContract {
    function myFunction(uint256 _param) external returns (string memory);
}

• In your contract, use the interface to interact with the external contract:

MyExternalContract externalContract = MyExternalContract(externalContractAddress);
string memory result = externalContract.myFunction(123);

2. Low-Level call Function (Use with Caution):

• Obtain the function selector (first 4 bytes of the Keccak-256 hash of the function signature):

bytes4 selector = bytes4(keccak256("myFunction(uint256)"));

• Use the call function with the selector and encoded arguments:

(bool success, bytes memory data) = externalContractAddress.call(abi.encodeWithSelector(selector, 123));

Important Considerations:

• Security: Using call directly is powerful but risky. Ensure you understand the potential vulnerabilities like reentrancy attacks.
• ABI Encoding: When using call, you need to encode function arguments according to the Contract ABI Specification.
• Error Handling: The call function returns a boolean indicating success. You need to handle potential errors and decode return values from the data bytes.

Example: Dynamically Calling Functions Based on Conditions:

function dynamicCall(address _contract, uint256 _param, bool _useFirstFunction) external {
    if (_useFirstFunction) {
        MyExternalContract(_contract).myFunction(_param);
    } else {
        MyExternalContract(_contract).anotherFunction(_param);
    }
}

Remember that while Solidity doesn't allow calling functions by dynamic names directly, you can achieve dynamic behavior by leveraging interfaces, function selectors, and conditional logic. Always prioritize security and thoroughly test your contracts.

This code demonstrates dynamic function calls in Solidity. It features two contracts: MyContract with functions 'setMyValue' and 'doubleMyValue', and DynamicCaller which interacts with MyContract. DynamicCaller showcases two methods: 'callFunctionByName' using a function name string and interface, and 'callFunctionBySelector' using a function selector and low-level 'call'. The example highlights techniques for interacting with external contracts dynamically but emphasizes the importance of security considerations and best practices when using low-level functions like 'call'.

This example demonstrates the techniques mentioned in the article to interact with an external contract and achieve dynamic function calls.

1. External Contract (MyContract.sol):

pragma solidity ^0.8.0;

contract MyContract {

    event ValueSet(uint256 value);

    uint256 public myValue;

    function setMyValue(uint256 _newValue) public {
        myValue = _newValue;
        emit ValueSet(_newValue);
    }

    function doubleMyValue() public {
        myValue = myValue * 2;
        emit ValueSet(myValue);
    }
}

2. Contract with Dynamic Calls (DynamicCaller.sol):

pragma solidity ^0.8.0;

interface MyContractInterface {
    function setMyValue(uint256 _newValue) external;
    function doubleMyValue() external;
}

contract DynamicCaller {

    event FunctionCalled(string functionName, bool success);

    // Call function by name using interface
    function callFunctionByName(address _contract, string memory _functionName, uint256 _value) public {
        MyContractInterface myContract = MyContractInterface(_contract);

        if (keccak256(bytes(_functionName)) == keccak256(bytes("setMyValue"))) {
            myContract.setMyValue(_value);
            emit FunctionCalled(_functionName, true);
        } else if (keccak256(bytes(_functionName)) == keccak256(bytes("doubleMyValue"))) {
            myContract.doubleMyValue();
            emit FunctionCalled(_functionName, true);
        } else {
            emit FunctionCalled(_functionName, false);
        }
    }

    // Call function using low-level 'call'
    function callFunctionBySelector(address _contract, bytes4 _selector, uint256 _value) public {
        (bool success, ) = _contract.call(abi.encodeWithSelector(_selector, _value));
        emit FunctionCalled(string(abi.encodePacked(_selector)), success);
    }
}

Explanation:

• MyContract.sol: This contract defines two functions: setMyValue and doubleMyValue.
• DynamicCaller.sol: This contract demonstrates two ways to call functions dynamically:
  • callFunctionByName: This function takes the function name as a string and uses an interface (MyContractInterface) to interact with the external contract. It compares the input function name with known function names and calls the corresponding function using the interface.
  • callFunctionBySelector: This function takes the function selector (obtained using bytes4(keccak256("functionName(arguments)"))) and uses the low-level call function to interact with the external contract.

Important Notes:

• This example is for demonstration purposes only.
• Using the low-level call function requires extra caution and thorough testing to avoid potential security vulnerabilities.
• Always prioritize security and follow best practices when interacting with external contracts.

General:

• Gas Efficiency: Calling functions dynamically can be more gas-expensive than static calls. Consider the trade-off between flexibility and gas costs.
• Code Readability: While dynamic calls offer flexibility, they can make the code harder to read and understand. Use clear comments and documentation.
• Alternatives: Explore alternative design patterns that might eliminate the need for dynamic calls, such as using multiple contracts with specific roles or implementing a strategy pattern.

Interfaces:

• Flexibility: Interfaces provide a more structured and type-safe way to interact with external contracts compared to using call directly.
• Versioning: Interfaces can help with contract versioning. If the external contract's interface changes, your contract will still compile, but it will throw an error at runtime if the function signatures don't match.

Low-Level call Function:

• Function Selectors: The first 4 bytes of a function's keccak256 hash act as a unique identifier for that function.
• ABI Encoding/Decoding: Understanding ABI encoding and decoding is crucial when using call. You need to encode the function arguments before sending them and decode the return data.
• Error Handling with call:
  • Check the success boolean returned by call to determine if the function call was successful.
  • Use try/catch blocks (Solidity >= 0.6.0) to handle exceptions thrown by the called function.
  • Consider using libraries like SafeERC20 for interacting with external tokens to handle potential error cases.

Security:

• Reentrancy Attacks: When using call, be aware of the potential for reentrancy attacks. An attacker could create a malicious contract that calls back into your contract and manipulates its state. Use reentrancy guards (e.g., using a mutex pattern) to mitigate this risk.
• Untrusted Contracts: Be extremely cautious when interacting with untrusted external contracts. Validate the contract address and function selector carefully.

Example Use Cases:

• Plugin Systems: Dynamic function calls can be used to create plugin systems where different contracts can extend the functionality of a base contract.
• Upgradable Contracts: While not a replacement for proper upgradeability patterns, dynamic calls can be used to interact with newly deployed versions of a contract.
• Conditional Logic: Execute different functions based on specific conditions or data available at runtime.

Additional Resources:

• Solidity Documentation on call: https://docs.soliditylang.org/en/latest/control-structures.html#external-function-calls
• Solidity Documentation on Interfaces: https://docs.soliditylang.org/en/latest/contracts.html#interfaces
• OpenZeppelin's Address library for safe contract interactions: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol

While Solidity doesn't natively support calling functions by name dynamically, you can achieve similar behavior using these techniques:

Example: You can dynamically choose which function to call based on conditions within your contract, as shown in the "Dynamically Calling Functions Based on Conditions" example in the original text.

Key Takeaways:

• Prioritize security when using the call function.
• Understand ABI encoding and error handling when interacting with contracts at a low level.
• Thoroughly test your contracts to ensure they behave as expected.

In conclusion, while Solidity doesn't natively support calling functions by their names dynamically, developers can achieve dynamic behavior using interfaces for type-safe interactions and function selectors with the low-level call function. While these techniques offer flexibility, they require careful consideration of security implications, especially when using the call function. Developers must prioritize security by understanding ABI encoding, implementing robust error handling, and mitigating potential vulnerabilities like reentrancy attacks. Thorough testing is crucial to ensure the contract's security and desired functionality. By understanding these techniques and their implications, developers can create more dynamic and versatile smart contracts.

• On dynamic interface (Basic design - Contract ABI Specification ... | I’m bit of a puzzled by following phrase reading Contract ABI Specification. “This specification does not address contracts whose interface is dynamic or otherwise known only at run-time.” Are there contracts with dynamic interface in Eth? Or is it added to those who want adapt Solidity to another block-chain systems? In any case it would help to have some comment on this in the docs. And I couldn’t find any additional relevant info in that chapter.
• blockchain - Call solidity function dynamically, based on its bytes4 ... | Apr 7, 2022 ... In a smart contract, let's say I have a function which wants to invoke another function dynamically, based on some internal logic.
• Is there a way to call a dynamic function name in solidity ... | Jul 15, 2021 ... 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 ...
• Contract ABI Specification — Solidity 0.8.29 documentation | Use of Dynamic Types ... A call to a function with the signature f(uint256,uint32[],bytes10,bytes) with values (0x123, [0x456, 0x789], "1234567890", "Hello, ...
• Can external solidity functions get called within the same contract ... | Apr 28, 2022 ... As you can see, mooz is an external function, but we need to call it within bademjoon function in the same contract dynamically (for whatever ...
• Sam Blackshear on X: "I would be a lot less worried about this for ... | I would be a lot less worried about this for Solidity -> Move porting. In fact, I think you'll get safer code in most cases. If I look at the smart contract OWASP top 10 https://t.co/LhV36vvu4N, 5 are are not possible in Move + Sui, and 3 are partially mitigated:

1. Re-entrancy:

• solidity - Accessing dynamic variable name - external contract ... | Sep 3, 2020 ... The easiest solution for this would be to create a getter function in the other contracts, that share the same name. Then you can just call ...
• immutable for libraries / dynamic libraries / high-level delegatecall ... | I'm pretty sure there are issues about this scattered across the project, but this has come up recently, so I'll create a new one. Since linking is a bit cumbersome, it has been brought up that lib...
• solidity - Call a function from different contract - Ethereum Stack ... | Dec 7, 2022 ... I want to achieve is to call an external function from dynamically created smart contracts as different owners, but restrict to call that function direct in a ...