Update solidity 0.5.0 compatibility

Author: wanseob

contracts/Migrations.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.4.23;
+pragma solidity >=0.5.0 <0.6.0;
 
 contract Migrations {
   address public owner;

contracts/data.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.4.0;
+pragma solidity >=0.5.0 <0.6.0;
 
 /**
  MIT License
@@ -21,11 +21,11 @@ library D {
         Edge[2] children;
     }
 
-    function isEmpty(Edge edge) internal pure returns (bool) {
+    function isEmpty(Edge memory edge) internal pure returns (bool) {
         return (edge.header == bytes32(0) && edge.node == bytes32(0));
     }
 
-    function hasNode(Edge edge) internal pure returns (bool) {
+    function hasNode(Edge memory edge) internal pure returns (bool) {
         return (edge.node != bytes32(0));
     }
-}
+}

contracts/implementation.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.4.24;
+pragma solidity >=0.5.0 <0.6.0;
 
 import {PartialMerkleTree} from "./tree.sol";
 
@@ -13,56 +13,56 @@ contract PartialMerkleTreeImplementation {
         tree.initialize(initialRoot);
     }
 
-    function insert(bytes key, bytes value) public {
+    function insert(bytes memory key, bytes memory value) public {
         tree.insert(key, value);
     }
 
-    function commitBranch(bytes key, bytes value, uint branchMask, bytes32[] siblings) public {
+    function commitBranch(bytes memory key, bytes memory value, uint branchMask, bytes32[] memory siblings) public {
         return tree.commitBranch(key, value, branchMask, siblings);
     }
 
-    function commitBranchOfNonInclusion(bytes key, bytes32 potentialSiblingLabel, bytes32 potentialSiblingValue, uint branchMask, bytes32[] siblings) public {
+    function commitBranchOfNonInclusion(bytes memory key, bytes32 potentialSiblingLabel, bytes32 potentialSiblingValue, uint branchMask, bytes32[] memory siblings) public {
         return tree.commitBranchOfNonInclusion(key, potentialSiblingLabel, potentialSiblingValue, branchMask, siblings);
     }
 
-    function get(bytes key) public view returns (bytes) {
+    function get(bytes memory key) public view returns (bytes memory) {
         return tree.get(key);
     }
 
-    function safeGet(bytes key) public view returns (bytes) {
+    function safeGet(bytes memory key) public view returns (bytes memory) {
         return tree.safeGet(key);
     }
 
-    function doesInclude(bytes key) public view returns (bool) {
+    function doesInclude(bytes memory key) public view returns (bool) {
         return tree.doesInclude(key);
     }
 
-    function getValue(bytes32 hash) public view returns (bytes) {
+    function getValue(bytes32 hash) public view returns (bytes memory) {
         return tree.values[hash];
     }
 
     function getRootHash() public view returns (bytes32) {
         return tree.getRootHash();
     }
 
-    function getProof(bytes key) public view returns (uint branchMask, bytes32[] _siblings) {
+    function getProof(bytes memory key) public view returns (uint branchMask, bytes32[] memory _siblings) {
         return tree.getProof(key);
     }
 
-    function getNonInclusionProof(bytes key) public view returns (
+    function getNonInclusionProof(bytes memory key) public view returns (
         bytes32 leafLabel,
         bytes32 leafNode,
         uint branchMask,
-        bytes32[] _siblings
+        bytes32[] memory _siblings
     ) {
         return tree.getNonInclusionProof(key);
     }
 
-    function verifyProof(bytes32 rootHash, bytes key, bytes value, uint branchMask, bytes32[] siblings) public pure {
+    function verifyProof(bytes32 rootHash, bytes memory key, bytes memory value, uint branchMask, bytes32[] memory siblings) public pure {
         PartialMerkleTree.verifyProof(rootHash, key, value, branchMask, siblings);
     }
 
-    function verifyNonInclusionProof(bytes32 rootHash, bytes key, bytes32 leafLabel, bytes32 leafNode, uint branchMask, bytes32[] siblings) public pure {
+    function verifyNonInclusionProof(bytes32 rootHash, bytes memory key, bytes32 leafLabel, bytes32 leafNode, uint branchMask, bytes32[] memory siblings) public pure {
         PartialMerkleTree.verifyNonInclusionProof(rootHash, key, leafLabel, leafNode, branchMask, siblings);
     }
-}
+}

contracts/tree.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.4.24;
+pragma solidity >=0.5.0 <0.6.0;
 
 import {Utils} from "./utils.sol";
 import {D} from "./data.sol";
@@ -27,7 +27,13 @@ library PartialMerkleTree {
         tree.root = root;
     }
 
-    function commitBranch(Tree storage tree, bytes key, bytes value, uint branchMask, bytes32[] siblings) internal {
+    function commitBranch(
+        Tree storage tree, 
+        bytes memory key, 
+        bytes memory value, 
+        uint branchMask, 
+        bytes32[] memory siblings
+    ) internal {
         D.Label memory k = D.Label(keccak256(key), 256);
         D.Edge memory e;
         e.node = keccak256(value);
@@ -66,11 +72,11 @@ library PartialMerkleTree {
 
     function commitBranchOfNonInclusion(
         Tree storage tree,
-        bytes key,
+        bytes memory key,
         bytes32 potentialSiblingLabel,
         bytes32 potentialSiblingValue,
         uint branchMask,
-        bytes32[] siblings
+        bytes32[] memory siblings
     ) internal {
         D.Label memory k = D.Label(keccak256(key), 256);
         D.Edge memory e;
@@ -114,7 +120,11 @@ library PartialMerkleTree {
         tree.rootEdge = e;
     }
 
-    function insert(Tree storage tree, bytes key, bytes value) internal {
+    function insert(
+        Tree storage tree, 
+        bytes memory key, 
+        bytes memory value
+    ) internal {
         D.Label memory k = D.Label(keccak256(key), 256);
         bytes32 valueHash = keccak256(value);
         tree.values[valueHash] = value;
@@ -134,18 +144,18 @@ library PartialMerkleTree {
         tree.rootEdge = e;
     }
 
-    function get(Tree storage tree, bytes key) internal view returns (bytes) {
+    function get(Tree storage tree, bytes memory key) internal view returns (bytes memory) {
         return getValue(tree, _findNode(tree, key));
     }
 
-    function safeGet(Tree storage tree, bytes key) internal view returns (bytes value) {
+    function safeGet(Tree storage tree, bytes memory key) internal view returns (bytes memory value) {
         bytes32 valueHash = _findNode(tree, key);
         require(valueHash != bytes32(0));
         value = getValue(tree, valueHash);
         require(valueHash == keccak256(value));
     }
 
-    function doesInclude(Tree storage tree, bytes key) internal view returns (bool) {
+    function doesInclude(Tree storage tree, bytes memory key) internal view returns (bool) {
         return doesIncludeHashedKey(tree, keccak256(key));
     }
 
@@ -154,7 +164,7 @@ library PartialMerkleTree {
         return (valueHash != bytes32(0));
     }
 
-    function getValue(Tree storage tree, bytes32 valueHash) internal view returns (bytes) {
+    function getValue(Tree storage tree, bytes32 valueHash) internal view returns (bytes memory) {
         return tree.values[valueHash];
     }
 
@@ -181,11 +191,11 @@ library PartialMerkleTree {
     //  - uint branchMask - bitmask with high bits at the positions in the key
     //                    where we have branch nodes (bit in key denotes direction)
     //  - bytes32[] hashes - hashes of sibling edges
-    function getProof(Tree storage tree, bytes key) internal view returns (uint branchMask, bytes32[] _siblings) {
+    function getProof(Tree storage tree, bytes memory key) internal view returns (uint branchMask, bytes32[] memory _siblings) {
         return getProofWithHashedKey(tree, keccak256(key));
     }
 
-    function getProofWithHashedKey(Tree storage tree, bytes32 hashedKey) internal view returns (uint branchMask, bytes32[] _siblings) {
+    function getProofWithHashedKey(Tree storage tree, bytes32 hashedKey) internal view returns (uint branchMask, bytes32[] memory _siblings) {
         D.Label memory k = D.Label(hashedKey, 256);
         D.Edge memory e = tree.rootEdge;
         bytes32[256] memory siblings;
@@ -218,11 +228,11 @@ library PartialMerkleTree {
         }
     }
 
-    function getNonInclusionProof(Tree storage tree, bytes key) internal view returns (
+    function getNonInclusionProof(Tree storage tree, bytes memory key) internal view returns (
         bytes32 potentialSiblingLabel,
         bytes32 potentialSiblingValue,
         uint branchMask,
-        bytes32[] _siblings
+        bytes32[] memory _siblings
     ) {
         return getNonInclusionProofWithHashedKey(tree, keccak256(key));
     }
@@ -231,7 +241,7 @@ library PartialMerkleTree {
         bytes32 potentialSiblingLabel,
         bytes32 potentialSiblingValue,
         uint branchMask,
-        bytes32[] _siblings
+        bytes32[] memory _siblings
     ){
         uint length;
         uint numSiblings;
@@ -275,7 +285,13 @@ library PartialMerkleTree {
         }
     }
 
-    function verifyProof(bytes32 rootHash, bytes key, bytes value, uint branchMask, bytes32[] siblings) public pure {
+    function verifyProof(
+        bytes32 rootHash, 
+        bytes memory key, 
+        bytes memory value, 
+        uint branchMask, 
+        bytes32[] memory siblings
+    ) public pure {
         D.Label memory k = D.Label(keccak256(key), 256);
         D.Edge memory e;
         e.node = keccak256(value);
@@ -294,7 +310,14 @@ library PartialMerkleTree {
         require(rootHash == edgeHash(e));
     }
 
-    function verifyNonInclusionProof(bytes32 rootHash, bytes key, bytes32 potentialSiblingLabel, bytes32 potentialSiblingValue, uint branchMask, bytes32[] siblings) public pure {
+    function verifyNonInclusionProof(
+        bytes32 rootHash, 
+        bytes memory key, 
+        bytes32 potentialSiblingLabel, 
+        bytes32 potentialSiblingValue, 
+        uint branchMask, 
+        bytes32[] memory siblings
+    ) public pure {
         D.Label memory k = D.Label(keccak256(key), 256);
         D.Edge memory e;
         for (uint i = 0; branchMask != 0; i++) {
@@ -317,12 +340,12 @@ library PartialMerkleTree {
         require(rootHash == edgeHash(e));
     }
 
-    function newEdge(bytes32 node, D.Label label) internal pure returns (D.Edge memory e){
+    function newEdge(bytes32 node, D.Label memory label) internal pure returns (D.Edge memory e){
         e.node = node;
         e.label = label;
     }
 
-    function _insertAtNode(Tree storage tree, bytes32 nodeHash, D.Label key, bytes32 value) private returns (bytes32) {
+    function _insertAtNode(Tree storage tree, bytes32 nodeHash, D.Label memory key, bytes32 value) private returns (bytes32) {
         //        require(key.length > 1);
         D.Node memory n = tree.nodes[nodeHash];
         uint head;
@@ -332,7 +355,7 @@ library PartialMerkleTree {
         return _replaceNode(tree, nodeHash, n);
     }
 
-    function _insertAtEdge(Tree storage tree, D.Edge e, D.Label key, bytes32 value) private returns (D.Edge) {
+    function _insertAtEdge(Tree storage tree, D.Edge memory e, D.Label memory key, bytes32 value) private returns (D.Edge memory) {
         //        require(e.hasNode());
         require(key.length >= e.label.length);
         D.Label memory prefix;
@@ -370,7 +393,7 @@ library PartialMerkleTree {
         return _insertNode(tree, n);
     }
 
-    function _findNode(Tree storage tree, bytes key) private view returns (bytes32) {
+    function _findNode(Tree storage tree, bytes memory key) private view returns (bytes32) {
         return _findNodeWithHashedKey(tree, keccak256(key));
     }
 
@@ -383,7 +406,7 @@ library PartialMerkleTree {
         }
     }
 
-    function _findAtNode(Tree storage tree, bytes32 nodeHash, D.Label key) private view returns (bytes32) {
+    function _findAtNode(Tree storage tree, bytes32 nodeHash, D.Label memory key) private view returns (bytes32) {
         require(key.length > 1);
         D.Node memory n = tree.nodes[nodeHash];
         uint head;
@@ -392,7 +415,7 @@ library PartialMerkleTree {
         return _findAtEdge(tree, n.children[head], tail);
     }
 
-    function _findAtEdge(Tree storage tree, D.Edge e, D.Label key) private view returns (bytes32){
+    function _findAtEdge(Tree storage tree, D.Edge memory e, D.Label memory key) private view returns (bytes32){
         require(key.length >= e.label.length);
         D.Label memory prefix;
         D.Label memory suffix;

contracts/utils.sol

@@ -1,23 +1,22 @@
-pragma solidity ^0.4.24;
+pragma solidity >=0.5.0 <0.6.0;
 
 /**
  MIT License
  Original author: chriseth
- Refactored by Wanseob Lim
  */
 
 import {D} from "./data.sol";
 
 library Utils {
     /// Returns a label containing the longest common prefix of `check` and `label`
     /// and a label consisting of the remaining part of `label`.
-    function splitCommonPrefix(D.Label label, D.Label check) internal pure returns (D.Label prefix, D.Label labelSuffix) {
+    function splitCommonPrefix(D.Label memory label, D.Label memory check) internal pure returns (D.Label memory prefix, D.Label memory labelSuffix) {
         return splitAt(label, commonPrefix(check, label));
     }
     /// Splits the label at the given position and returns prefix and suffix,
     /// i.e. prefix.length == pos and prefix.data . suffix.data == l.data.
-    function splitAt(D.Label l, uint pos) internal pure returns (D.Label prefix, D.Label suffix) {
-        require(pos <= l.length && pos <= 256);
+    function splitAt(D.Label memory l, uint pos) internal pure returns (D.Label memory prefix, D.Label memory suffix) {
+        require(pos <= l.length && pos <= 256, "Bad pos");
         prefix.length = pos;
         if (pos == 0) {
             prefix.data = bytes32(0);
@@ -28,7 +27,7 @@ library Utils {
         suffix.data = l.data << pos;
     }
     /// Returns the length of the longest common prefix of the two labels.
-    function commonPrefix(D.Label a, D.Label b) internal pure returns (uint prefix) {
+    function commonPrefix(D.Label memory a, D.Label memory b) internal pure returns (uint prefix) {
         uint length = a.length < b.length ? a.length : b.length;
         // TODO: This could actually use a "highestBitSet" helper
         uint diff = uint(a.data ^ b.data);
@@ -42,26 +41,27 @@ library Utils {
     }
     /// Returns the result of removing a prefix of length `prefix` bits from the
     /// given label (i.e. shifting its data to the left).
-    function removePrefix(D.Label l, uint prefix) internal pure returns (D.Label r) {
-        require(prefix <= l.length);
+    function removePrefix(D.Label memory l, uint prefix) internal pure returns (D.Label memory r) {
+        require(prefix <= l.length, "Bad lenght");
         r.length = l.length - prefix;
         r.data = l.data << prefix;
     }
     /// Removes the first bit from a label and returns the bit and a
     /// label containing the rest of the label (i.e. shifted to the left).
-    function chopFirstBit(D.Label l) internal pure returns (uint firstBit, D.Label tail) {
-        require(l.length > 0);
+    function chopFirstBit(D.Label memory l) internal pure returns (uint firstBit, D.Label memory tail) {
+        require(l.length > 0, "Empty element");
         return (uint(l.data >> 255), D.Label(l.data << 1, l.length - 1));
     }
     /// Returns the first bit set in the bitfield, where the 0th bit
     /// is the least significant.
     /// Throws if bitfield is zero.
     /// More efficient the smaller the result is.
     function lowestBitSet(uint bitfield) internal pure returns (uint bit) {
-        require(bitfield != 0);
+        require(bitfield != 0, "Bad bitfield");
         bytes32 bitfieldBytes = bytes32(bitfield);
         // First, find the lowest byte set
-        for (uint byteSet = 0; byteSet < 32; byteSet++) {
+        uint byteSet = 0;
+        for (; byteSet < 32; byteSet++) {
             if (bitfieldBytes[31 - byteSet] != 0)
                 break;
         }
@@ -82,5 +82,3 @@ library Utils {
     }
 }
 
-
-