Unterschied zwischen CALL, CALLCODE und DELEGATECALL

DELEGATECALLsagt im Grunde, dass ich ein Vertrag bin und Ihnen erlaube (delegiere), mit meinem Speicher zu tun, was immer Sie wollen . DELEGATECALList ein Sicherheitsrisiko für den sendenden Vertrag, der darauf vertrauen muss, dass der empfangende Vertrag die Speicherung gut behandelt.

DELEGATECALLwar ein neuer Opcode, der eine Fehlerbehebung war, für CALLCODEdie nicht erhalten wurde msg.senderund msg.value. Wenn Alice Bob aufruft, der es DELEGATECALLmit Charlie tut, ist das msg.senderin DELEGATECALLAlice (während wenn CALLCODEverwendet msg.senderwürde, wäre das Bob).

Einzelheiten

Wenn D CALL auf E ausführt, läuft der Code im Kontext von E: die Speicherung von E wird verwendet.

Wenn D CALLCODE auf E ausführt, wird der Code im Kontext von D ausgeführt. Stellen Sie sich also vor, dass sich der Code von E in D befindet. Immer wenn der Code in den Speicher schreibt, schreibt er in den Speicher von Konto D und nicht in E.

contract D {
  uint public n;
  address public sender;

  function callSetN(address _e, uint _n) {
    _e.call(bytes4(sha3("setN(uint256)")), _n); // E's storage is set, D is not modified 
  }

  function callcodeSetN(address _e, uint _n) {
    _e.callcode(bytes4(sha3("setN(uint256)")), _n); // D's storage is set, E is not modified 
  }

  function delegatecallSetN(address _e, uint _n) {
    _e.delegatecall(bytes4(sha3("setN(uint256)")), _n); // D's storage is set, E is not modified 
  }
}

contract E {
  uint public n;
  address public sender;

  function setN(uint _n) {
    n = _n;
    sender = msg.sender;
    // msg.sender is D if invoked by D's callcodeSetN. None of E's storage is updated
    // msg.sender is C if invoked by C.foo(). None of E's storage is updated

    // the value of "this" is D, when invoked by either D's callcodeSetN or C.foo()
  }
}

contract C {
    function foo(D _d, E _e, uint _n) {
        _d.delegatecallSetN(_e, _n);
    }
}

Wenn D CALLCODE auf E ausführt, msg.senderist in E D , wie im obigen Code kommentiert.

Wenn ein Konto C D aufruft und D DELEGATECALL auf E ausführt, msg.senderbefindet sich in E C . Das heißt, E hat das gleiche msg.senderund msg.valuewie D.

Sie können oben im Solidity Browser schnell testen .

Um den Unterschied zwischen dem Anruf, dem Anrufcode und dem Delegiertenanruf zu zeigen, können wir das Beispiel des folgenden Codes betrachten:

Verträge können auf drei Arten interagieren

1. Anruf: Durch direkten Aufruf von einem Vertrag über eine Funktion, die nicht den Wert des Anrufers, sondern den Wert des Angerufenen festlegt. Und der Absender in diesem Fall ist nur der Anrufer

2. CallCode : Beim Aufruf über CallCode ruft der Aufrufer die Funktion des Aufgerufenen auf und sendet seinen eigenen Wert (oder ändert seinen eigenen Wert mit den aufgerufenen Parametern), aber es werden keine Änderungen im Speicher des Aufgerufenen widergespiegelt. Auch hier ist Absender der Anrufer selbst.

3. DelegateCall : Wenn ein dritter Vertrag einen Delegiertenaufruf an eine Funktion in callee im Namen des Aufrufers aufruft und Speicheränderungen am Wert des Aufrufers vorgenommen werden und nichts im Speicher des aufgerufenen widergespiegelt wird.

   Hier ist der Absender nicht mehr der Anrufer, sondern der dritte Vertragsanrufhelfer

Pragma Solidität ^0.4.0;

contract Caller {
uint public value;
address public sender;

function callSetValue(address _callee, uint _value) {
    _callee.call(bytes4(sha3("setValue(uint256)")), _value); // Callee's storage is set as given , Caller's is not modified 
}

function callcodeSetValue(address _callee, uint _value) {
    _callee.callcode(bytes4(sha3("setValue(uint256)")), _value); // Caller's storage is set, Calee is not modified 
}

function delegatecallSetValue(address _callee, uint _value) {
    _callee.delegatecall(bytes4(sha3("setValue(uint256)")), _value); // Caller's storage is set, Callee is not modified 
}
}

contract Callee {
uint public value;
address public sender;

function setValue(uint _value) {
    value = _value;
    sender = msg.sender;
    // msg.sender is Caller if invoked by Caller's callcodeSetValue. None of Callee's storage is updated
    // msg.sender is OnlyCaller if invoked by onlyCaller.justCall(). None of Callee's storage is updated

    // the value of "this" is Caller, when invoked by either Caller's callcodeSetValue or CallHelper.justCall()
}
}

contract CallHelper {
    function justCall(Caller _caller, Callee _callee, uint _value) {
        _caller.delegatecallSetValue(_callee, _value);
    }
}

Eine Aktualisierung des Beispiels von @eth für solidity v6:

• Funktionsdefinitionen müssen seinpublic

• keccak256anstelle vonsha3

• Anrufargumente verwendenabi.encode()

• address()Vertragsadresse zu bekommen

  pragma solidity ^0.6.0;
  contract D {
     uint public n;
     address public sender;
  
     function callSetN(address _e, uint _n) public {
       _e.call(abi.encode(bytes4(keccak256("setN(uint256)")), _n)); // E's storage is set, D is not modified 
     }
  
     /*
     callcode is depreciated
     function callcodeSetN(address _e, uint _n) public {
       _e.callcode(abi.encode(bytes4(keccak256("setN(uint256)")), _n)); // D's storage is set, E is not modified 
     }
     */
  
     function delegatecallSetN(address _e, uint _n) public {
       _e.delegatecall(abi.encode(bytes4(keccak256("setN(uint256)")), _n)); // D's storage is set, E is not modified 
     }
   }
  
   contract E {
     uint public n;
     address public sender;
  
     function setN(uint _n) public {
       n = _n;
       sender = msg.sender;
       // msg.sender is D if invoked by D's callcodeSetN. None of E's storage is updated
       // msg.sender is C if invoked by C.foo(). None of E's storage is updated
  
       // the value of "this" is D, when invoked by either D's callcodeSetN or C.foo()
     }
   }
  
   contract C {
       function foo(D _d, E _e, uint _n) public {
           _d.delegatecallSetN(address(_e), _n);
       }
   }
  

callcodewurde zugunsten von delegatecallVersion 0.8.4 verworfen

aktualisiere die Antwort von @atomh33ls

• Verwenden Sie abi.encodePacked

pragma solidity ^0.6.0;


contract E {
    uint256 public n;        
    address public sender;


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


contract D{
    uint256 public n;
    address public sender;


    function callSetN(address _e,uint256 _n) public {
         _e.call(abi.encodePacked(bytes4(keccak256("setN(uint256)")),_n));  
         
    }
}