[Ethereum] Use of delegatecall with msg.data

delegatecallsolidity

I'm trying to understand below code:

pragma solidity ^0.4.23;

contract Relay {
    address public currentVersion;
    address public owner;

    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    function Relay(address initAddr) {
        currentVersion = initAddr;
        owner = msg.sender; // this owner may be another contract with multisig, not a single contract owner
    }

    function changeContract(address newVersion) public onlyOwner(){
        currentVersion = newVersion;
    }

    function() {
        require(currentVersion.delegatecall(msg.data));
    }
}

This code is for maintaining version of a contract, but I'm not getting use of fallback function here.
I know that msg.data is complete calldata which is non-modifiable, but have no idea use of delegatecall here.

Best Answer

The fallback function gets called when no other function matches the calldata signature. In this code, the fallback functions is used as a universal function.

This is done by forwarding the calldata to the contract at currentVersion. Forwarding the calldata to another smart contract results in it running the proper funcion. There are two ways to do this: address.call and address.delegatecall. The difference between those is the context in which the receiving contract is going to run the code.

With delegatecall, the receiving contract accesses the Relay contract's storage. This way, the receiving contract can alter all fields of the Relay.

Effectively, by updating currentVersion, Relay can update it's code without changing it's address or migrating it's storage contents.

Docs:

Related Solutions

Solidity – How to Get Delegatecall to Return Data

The issue is that the response variable is not a memory pointer, it's a stack variable. When you use it as the pointer for your out data in the delegatecall, you're actually just writing the data to the 0 memory location. This doesn't cause errors because that space is reserved for "scratch space", but it also never loads the result into your return variable.

What you want to do is

assembly {
        let status := delegatecall(sub(gas,5000), dest, add(calldata, 0x20), mload(calldata), 0, 32)
        response := mload(0)
        jumpi(invalidJumpLabel, iszero(status))
}

Solidity – How to Resolve Remix Compilation Error: Invalid Array Length, Expected Integer Literal or Constant Expression

I changed your smart contract implementation with this smart contract.

I put notes just so you'd know your errors.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// NOTE: Import IERC20 contract
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

// NOTE: You must to implement IERC20 for override ERC20 methods!
contract NewToken is IERC20 {

  string public constant name = "NewToken";
  string public constant symbol = "NTKN";
  uint8 public constant decimals = 18;
  uint256 totalSupply_ = 10000000000000000000000000; 

  mapping(address => uint256) public balances;
  mapping(address => mapping (address => uint256)) allowed;

  // NOTE: I removed the events because it already defined into IERC20
  
  constructor() { 
    balances[msg.sender] = totalSupply_;
  }

  function totalSupply() public override view returns (uint256) {
    return totalSupply_;
  }

  // NOTE: You must to change signature function adding address parameter
  function balanceOf(address _address) public override view returns(uint256) {
    return balances[_address];
  }

  function transfer(address to, uint256 value) public override returns (bool) {
      require(value <= balances[msg.sender]);
      balances[msg.sender] = balances[msg.sender]-value;
      balances[to] = balances[to]+value;
      // NOTE: The event is called  Transfer not 'transfer'
      emit Transfer(msg.sender, to, value);
      return true;
  }

  function approve(address spender, uint256 value) public override returns (bool) {
      allowed[msg.sender][spender] = value;
      emit Approval(msg.sender, spender, value);
      return true;
  }

  function allowance(address owner, address spender) public override view returns (uint) {
      return allowed[owner][spender];
  }

  function transferFrom(address from, address to, uint256 value) public override returns (bool) {
      require(value <= balances[from]);
      require(value <= allowed[from][msg.sender]);

      balances[from] = balances[from]-value;
      allowed[from][msg.sender] = allowed[from][msg.sender]+value;
      balances[to] = balances[to]+value;
      emit Transfer(from, to, value);
      return true;
  }
}

Best Answer

Related Solutions

Solidity – How to Get Delegatecall to Return Data

Solidity – How to Resolve Remix Compilation Error: Invalid Array Length, Expected Integer Literal or Constant Expression

Related Topic