msgSender() in ContextMixin

[mudgen]

@arthcp can you explain this code: https://github.com/maticnetwork/pos-portal/blob/master/contracts/common/ContextMixin.sol

Specifically why do you expect there to be an address at add(array, index) in memory?

Also, why are you using a mask there? I don't see a need to use a mask there to clean bits because the value is going into a 20 byte address variable.

[arthcp]

@mudgen Meta transactions are executed by calling the executeMetaTransaction function of NativeMetaTransaction contract.

This function calls self contract with calldata and userAddress as can be seen here: https://github.com/maticnetwork/pos-portal/blob/master/contracts/common/NativeMetaTransaction.sol#L59-L61

Due to how it is being called, we expect the user address to be at add(array, index).

Thanks for pointing out that masking is not needed here. I think you are correct about that. I will run some tests to verify it and raise a PR.

[mudgen]

@arthcp I see, cool.

Instead of copying calldata to memory and dropping to assembly you can use calldata slices. For example:

sender = abi.decode(msg.data[msg.data.length-32:], (address));

Array slices info here: https://solidity.readthedocs.io/en/v0.7.1/types.html#array-slices

[mudgen]

Nevermind, you won't be able to decode it that way because it is encoded with abi.encodePacked. But if you encoded it with abi.encode instead then you could.

[mudgen]

Since the address is encoded with abi.encodePacked, you could do it like this:

pragma solidity 0.6.6;

abstract contract ContextMixin {
    function msgSender()
        internal
        view
        returns (address payable sender)
    {
        if (msg.sender == address(this)) {
            uint256 index = msg.data.length - 20;
            assembly {
                // Load the 32 bytes word from calldata with the address on the lower 20 bytes.
                sender := calldataload(index)
            }
        } else {
            sender = msg.sender;
        }
        return sender;
    }
}

Saves some gas from having to copy calldata to memory.