Konvertieren von Bytes in 0.5.x?

Soweit ich weiß, benötigen Sie eine Inline-Montage. Jemand hat bereits Code gepostet, der zumindest für frühere Solidity-Versionen gilt, obwohl im Allgemeinen eine kurze und korrekte Inline-Assemblierung ziemlich universell sein sollte.

Hier ist ein Code, der einige Bytes aus dem Speicher in Bytes20 konvertiert (nur die ersten 20, es wird natürlich abgeschnitten, wenn darüber hinaus).

contract t {
    function tb20(bytes memory _b) 
    public
    pure
    returns (bytes20 _result) {
        assembly {
            _result := mload(add(_b, 0x20))
        }
    }

    function bytesToAddress(bytes memory _b) 
    public 
    returns (address) {
        return address(tb20(_b));
    }
}

Keine Garantien oder Gewährleistungen auf den Code, aber es scheint zu funktionieren. Kann natürlich tb20 ändern, um stattdessen eine Adresse zurückzugeben, obwohl Sie dann Verschiebungen benötigen.

Meine frühere Antwort hat mit der Konvertierung eines Bytes-Typs aus dem Speicher in bytes20 zu tun, denn so habe ich die Frage aus dem Titel verstanden, dynamische Bytes in statisch große 1-32 Bytes und danach in andere Derivate konvertiert.

In Bezug auf die eigentliche Frage in Ihrem Körper soll diese Antwort bestätigen, dass Sie Ihre vorhandene Funktion tatsächlich bytesToUIntfür solc 0.5.x verwenden können. Sie können weiterhin explizite Konvertierungen zwischen anderen statischen Bytes durchführen, solange ihre entsprechenden Längen gleich sind. Wenn Sie also etwas Bytes32 haben und möchten, dass es uint128 ist, müssen Sie es zuerst explizit in Bytes16 konvertieren und können es dann über reguläre Solidity in uint128 konvertieren. Natürlich sollten Sie selbst debuggen/testen, um zu sehen, welche Teile dieser Bytes32 möglicherweise abgeschnitten werden, bevor Sie damit fortfahren, da es umgekehrte Fälle gibt, in denen es sinnvoller sein kann, sie zuerst in uint256 zu konvertieren und dann auf uint128 zu reduzieren .

Einfach gesagt, Sie können Ihre vorhandene Funktion zum Laufen bringen, indem Sie zuerst bytes1in umwandeln uint8.

function bytesToUInt(string memory _b) public returns (uint256){
  bytes memory b = bytes(_b);
  uint256 number;
  for(uint i=0;i<b.length;i++){
    number = number + uint256(uint8(b[i]))*(2**(8*(b.length-(i+1))));
  }
  return number;
}

Der uint256 wurde zur Deutlichkeit hinzugefügt, was wahrscheinlich immer eine gute Idee ist, aber nicht benötigt wird

Der Fehler, den ich machte, kam von der anfänglichen Konvertierung in Bytes. Da Sie mit alles an sie übergeben können bytes(), nahm ich an, dass dies mir etwas gab, das ich in die anderen Funktionen übertragen konnte, das war es nicht.

Mein Problem war überhaupt nicht mit 0.5.x, wenn Sie richtig in Bytes konvertieren, funktioniert der Rest des Codes wie erwartet. Sie müssen im Vergleich zu 0.4.x nur ein paar zusätzliche Konvertierungen durchführen. Die Serialitätsbibliothek funktioniert hervorragend.

Hier ist ein Beispiel für eine Konvertierung von einem Int in Bytes und zurück zu diesem Int:

function intToBytesToInt(int256 _input) public pure returns (int256) {
  bytes memory buffer = new bytes(32);
  uint offset = 32;

  assembly{
    mstore(add(buffer, offset), _input)
  }

  //b is the converted input
  bytes memory b = buffer;

  //Post 0.5.0 you must remember to convert to the appropriate size. For int256, that's bytes32.

  bytes32 preI;

  assembly {
    preI := mload(add(buffer, offset))
  }

  //i is b converted back to an int256
  int256 i = int256(preI);

  return i;
}