delegate call - msg.sender wrong value

Question

pragma solidity >=0.4.22 <0.7.0;
contract D {
  uint public n;
  address public sender;

  function delegatecallSetN(address _e, uint _n) public {
    _e.delegatecall(abi.encode(bytes4(keccak256("setN(uint256)")), _n));
  }
}

contract E {
  uint public n;
  address public sender;
  uint test = 10;

  function setN(uint256 _n) public {
    n = _n;
    sender = msg.sender;
  }
}

Question 1:

I have this contract. Now, when I call a delegatecallSetN from remix with the address of E, it successfully calls E contract's setN function. as we know how delegatecall works, it sets my passed _n value on D contract. Now, what about sender value on D contract ? It still is 0x000000...000 . Why doesn't it set msg.sender on it ?

---

Question 2:

Let's say in contract E's setN function, I add test = 50. As we know, the code of setN will be executed in the context of Contract D which doesn't have test variable at all. Why doesn't it result in exception or error at all and why does the transaction still succeed ?

UPDATED CODE:

pragma solidity >=0.4.22 <0.7.0;

contract D {
  uint public n;
  address public sender;


  function delegatecallSetN(address _e, uint _n) public {
    _e.delegatecall(abi.encodeWithSignature("setN(uint256)", _n));
  }
  
  
}

contract E {
  uint public n;
  uint public test;
  address public sender;

  function setN(uint256 _n) public {
    n = _n;
    sender = msg.sender;
    test = 20;
  }
}

Answer 1

For delegatecall to work correctly both contracts should have compatible storage layout. Having the same variables in the same order. If variables are reordered the storage layout will be incompatible and it will not work as expected.

---

The compiler assigns storage slots in the same order the variables are defined.

contract D {
  uint public n;              // <-- slot 0
  address public sender       // <-- slot 1

and

contract E {
  uint public n;              // <-- slot 0
  uint public test;           // <-- slot 1
  address public sender;      // <-- slot 2

When contract E modifies sender it modifies slot 2, similarly for n it modifies slot 0 and for test slot 1.

• n has the same slot in D and E so its modification by E will be reflected in D.
• sender for E has slot 2, so any modification is not visible from D because there's no variable assigned slot 2.
• test has slot 1 for E, so it will store 0x0000000000000000000000000000000000000000000000000000000000000014 in slot 1. For D slot 1 is sender an address so it will interpret as 0x0000000000000000000000000000000000000014.

Answer 2

About Question 1:

The state of contract E is not getting updated, because your deletecall in contract D is not working.

Replace:

_e.delegatecall(abi.encode(bytes4(keccak256("setN(uint256)")), _n));

with

(bool success,) = address(_e).call(abi.encodeWithSignature("setN(uint256)", _n));

About question 2:

I got a bit confused, when you're making delegatecall from contract D to contract E, you're referring to method setN and now inside this method you can access the state of contract where this method is defined ( contract E ). I don't see where is the issue here, that's how it should be working.