Solidity vs Assembly – Using delegatecall for Optimized Smart Contracts

assemblydelegatecallsolidity

Is there a real difference nowadays, performance-wise, between using assembly delegatecall and the high-level solidity version?

I know that in the past assembly was used so you could get the returned value of the call, but that's no longer case since the high-level delegatecall already provides that in the newer solidity versions.

Best Answer

If by "performance-wise" you mean gas optimization, then yes, I believe there are some that are actually used in the context of proxy contracts such as OpenZeppelin's implementation for example as after the delegatecall they either return or revert.

The memory gas cost computation is explained in this answer, "allocating" a new byte array at the free memory pointer location (which pure solidity would do) could lead to a non-zero memory expansion cost. While it might not matter that much (if at all) for a single contract, if your implementation is to be used by thousands of developers, you might as well take full memory control and try to avoid unnecessary potential extra cost by using the lowest possible offset (0) as in the implementation linked above both for sent and received data.

However, doing this will have unwanted effects on the solidity generated bytecode following your delegatecall as it overwrites the solidity reserved memory slots. But since in that use case, there should be no logic following the delegatecall, it's perfectly fine to do it.

For other use cases, I must say that I don't see any relevant advantages of assembly over plain solidity...

I hope that answers your question.

Related Solutions

Solidity – Problem Using Created Array from Assembly

The author of the github page that you referenced didn't update the free memory pointer after allocating the memory. Also as Tjaden Hess noted in the comments

return as an opcode and return as a Solidity statement are very different. The opcode causes the entire contract execution to return at that point, with the return value that you designate in memory. The Solidity return just pops off the call frame and returns to the calling function

Below is the correct code:

contract C {
    function f(uint a, uint b) pure public returns (uint[] memory memOffset) {
        assembly {
             // Create an dynamic sized array manually.
             // Don't need to define the data type here as the EVM will prefix it
             memOffset := msize() // Get the highest available block of memory
             mstore(add(memOffset, 0x00), 2) // Set size to 2
             mstore(add(memOffset, 0x20), a) // array[0] = a
             mstore(add(memOffset, 0x40), b) // array[1] = b
             mstore(0x40, add(memOffset, 0x60)) // Update the msize offset to be our memory reference plus the amount of bytes we're using
        }
    }

    function get_f(uint a, uint b) public returns(uint){
        uint[] memory ret = f(a,b);
        return ret[0];
    }
}

I created a pull request to fix this on Github https://github.com/androlo/solidity-workshop/pull/5

[Ethereum] Using a high level delegate call in upgradable contracts since Byzantium

One issue is that you copy your data into memory starting at address 0. This will work for return sizes less than 64 bytes, but will start overwriting other memory at that point.

Instead you should do something more like

let m := mload(0x40)
returndatacopy(m, 0, returndatasize)
return(0, returndatasize)

Best Answer

Related Solutions

Solidity – Problem Using Created Array from Assembly

[Ethereum] Using a high level delegate call in upgradable contracts since Byzantium

Related Topic