EVM Functions – If Not in the EVM, Where Do Internal Functions Execute?

evmfunctioninternal-transactions

The Ethereum documentation says that internal functions are not executed in the EVM, while external ones are:

If not in the EVM, where are internal functions executed? Does this simply mean that internal functions are executed wholly within the one node the call is made within, while external functions end up being broadcast to the entire network (all nodes)?

Best Answer

internal functions are called through a JUMP / JUMPI instruction, simply jumping to another point of the current code. This makes sense because internal functions do not change context (i.e., they stay inside the same contract). To make things clearer, you can only call an internal function if you are running a contract's code, which imply that a call was made to that contract to begin with, it's just that calling an internal function doesn't require (nor allow) an EVM call to reach it directly, only jumps.

external functions on the other hand can only be called through an internal EVM call.

You can read more about it in the solidity documentation.

I hope that answers your question.

Related Solutions

Solidity – Understanding Internal Function Type Variables

Internal functions which accept function type as an argument can take internal, public and private functions when called. For example:

library L {
    function ops(
        uint256 _a,
        uint256 _b,
        function(uint256, uint256) pure returns (uint256) add
    ) internal pure returns(uint256 sum){
        sum = add(_a, _b);
    }
}

contract C {
    using L for *;

    uint256 public sum;

    function calculate(uint256 _a, uint256 _b) external {
        (sum) = L.ops(_a, _b, add);
    }

    // add can be internal, private or public but not external
    function add(uint256 _a, uint256 _b) internal/private/public pure returns(uint256){
        return _a + _b;
    }
}

similarly for external functions accepting function type as an argument can take public and external functions when called. For example:

contract C1 {
    uint256 num;
    function foo(function(uint256) external returns(uint256) f) external {
        num = f(num);
    }
}

contract C2 {
    uint256 num;
    C1 c;
    function foo() external {
        c.foo(this.bar);
    }

    // bar can be external/public but not private/internal.
    function bar(uint256 _num) external/public returns(uint256){
        num = _num;
        return _num + num + 1;
    }
}

Best Answer

Related Solutions

Solidity – Understanding Internal Function Type Variables

Related Topic