fix: update compiler version and remove deprecated entities (#45)

nichonien · web-flow · commit c90638361a76 · 2021-12-07T21:31:29.000+01:00
* update compiler version and remove deprecated entities

* used abi.encodePacked for hashing
diff --git a/contracts/EthereumDIDRegistry.sol b/contracts/EthereumDIDRegistry.sol
@@ -1,4 +1,4 @@
-pragma solidity ^0.4.4;
+pragma solidity ^0.8.6;
 
 contract EthereumDIDRegistry {
 
@@ -36,7 +36,7 @@ contract EthereumDIDRegistry {
 
   function identityOwner(address identity) public view returns(address) {
      address owner = owners[identity];
-     if (owner != 0x0) {
+     if (owner != 0x0000000000000000000000000000000000000000) {
        return owner;
      }
      return identity;
@@ -50,8 +50,8 @@ contract EthereumDIDRegistry {
   }
 
   function validDelegate(address identity, bytes32 delegateType, address delegate) public view returns(bool) {
-    uint validity = delegates[identity][keccak256(delegateType)][delegate];
-    return (validity > now);
+    uint validity = delegates[identity][keccak256(abi.encode(delegateType))][delegate];
+    return (validity > block.timestamp);
   }
 
   function changeOwner(address identity, address actor, address newOwner) internal onlyOwner(identity, actor) {
@@ -65,13 +65,13 @@ contract EthereumDIDRegistry {
   }
 
   function changeOwnerSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, address newOwner) public {
-    bytes32 hash = keccak256(byte(0x19), byte(0), this, nonce[identityOwner(identity)], identity, "changeOwner", newOwner);
+    bytes32 hash = keccak256(abi.encodePacked(bytes1(0x19), bytes1(0), this, nonce[identityOwner(identity)], identity, "changeOwner", newOwner));
     changeOwner(identity, checkSignature(identity, sigV, sigR, sigS, hash), newOwner);
   }
 
   function addDelegate(address identity, address actor, bytes32 delegateType, address delegate, uint validity) internal onlyOwner(identity, actor) {
-    delegates[identity][keccak256(delegateType)][delegate] = now + validity;
-    emit DIDDelegateChanged(identity, delegateType, delegate, now + validity, changed[identity]);
+    delegates[identity][keccak256(abi.encode(delegateType))][delegate] = block.timestamp + validity;
+    emit DIDDelegateChanged(identity, delegateType, delegate, block.timestamp + validity, changed[identity]);
     changed[identity] = block.number;
   }
 
@@ -80,13 +80,13 @@ contract EthereumDIDRegistry {
   }
 
   function addDelegateSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 delegateType, address delegate, uint validity) public {
-    bytes32 hash = keccak256(byte(0x19), byte(0), this, nonce[identityOwner(identity)], identity, "addDelegate", delegateType, delegate, validity);
+    bytes32 hash = keccak256(abi.encodePacked(bytes1(0x19), bytes1(0), this, nonce[identityOwner(identity)], identity, "addDelegate", delegateType, delegate, validity));
     addDelegate(identity, checkSignature(identity, sigV, sigR, sigS, hash), delegateType, delegate, validity);
   }
 
   function revokeDelegate(address identity, address actor, bytes32 delegateType, address delegate) internal onlyOwner(identity, actor) {
-    delegates[identity][keccak256(delegateType)][delegate] = now;
-    emit DIDDelegateChanged(identity, delegateType, delegate, now, changed[identity]);
+    delegates[identity][keccak256(abi.encode(delegateType))][delegate] = block.timestamp;
+    emit DIDDelegateChanged(identity, delegateType, delegate, block.timestamp, changed[identity]);
     changed[identity] = block.number;
   }
 
@@ -95,36 +95,36 @@ contract EthereumDIDRegistry {
   }
 
   function revokeDelegateSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 delegateType, address delegate) public {
-    bytes32 hash = keccak256(byte(0x19), byte(0), this, nonce[identityOwner(identity)], identity, "revokeDelegate", delegateType, delegate);
+    bytes32 hash = keccak256(abi.encodePacked(bytes1(0x19), bytes1(0), this, nonce[identityOwner(identity)], identity, "revokeDelegate", delegateType, delegate));
     revokeDelegate(identity, checkSignature(identity, sigV, sigR, sigS, hash), delegateType, delegate);
   }
 
-  function setAttribute(address identity, address actor, bytes32 name, bytes value, uint validity ) internal onlyOwner(identity, actor) {
-    emit DIDAttributeChanged(identity, name, value, now + validity, changed[identity]);
+  function setAttribute(address identity, address actor, bytes32 name, bytes memory value, uint validity ) internal onlyOwner(identity, actor) {
+    emit DIDAttributeChanged(identity, name, value, block.timestamp + validity, changed[identity]);
     changed[identity] = block.number;
   }
 
-  function setAttribute(address identity, bytes32 name, bytes value, uint validity) public {
+  function setAttribute(address identity, bytes32 name, bytes memory value, uint validity) public {
     setAttribute(identity, msg.sender, name, value, validity);
   }
 
-  function setAttributeSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 name, bytes value, uint validity) public {
-    bytes32 hash = keccak256(byte(0x19), byte(0), this, nonce[identityOwner(identity)], identity, "setAttribute", name, value, validity);
+  function setAttributeSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 name, bytes memory value, uint validity) public {
+    bytes32 hash = keccak256(abi.encodePacked(bytes1(0x19), bytes1(0), this, nonce[identityOwner(identity)], identity, "setAttribute", name, value, validity));
     setAttribute(identity, checkSignature(identity, sigV, sigR, sigS, hash), name, value, validity);
   }
 
-  function revokeAttribute(address identity, address actor, bytes32 name, bytes value ) internal onlyOwner(identity, actor) {
+  function revokeAttribute(address identity, address actor, bytes32 name, bytes memory value ) internal onlyOwner(identity, actor) {
     emit DIDAttributeChanged(identity, name, value, 0, changed[identity]);
     changed[identity] = block.number;
   }
 
-  function revokeAttribute(address identity, bytes32 name, bytes value) public {
+  function revokeAttribute(address identity, bytes32 name, bytes memory value) public {
     revokeAttribute(identity, msg.sender, name, value);
   }
 
- function revokeAttributeSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 name, bytes value) public {
-    bytes32 hash = keccak256(byte(0x19), byte(0), this, nonce[identityOwner(identity)], identity, "revokeAttribute", name, value); 
+ function revokeAttributeSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 name, bytes memory value) public {
+    bytes32 hash = keccak256(abi.encodePacked(bytes1(0x19), bytes1(0), this, nonce[identityOwner(identity)], identity, "revokeAttribute", name, value)); 
     revokeAttribute(identity, checkSignature(identity, sigV, sigR, sigS, hash), name, value);
   }
 
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-pragma solidity ^0.4.4;`
	`1`	`+pragma solidity ^0.8.6;`
`2`	`2`
`3`	`3`	`contract EthereumDIDRegistry {`
`4`	`4`
`@@ -36,7 +36,7 @@ contract EthereumDIDRegistry {`
`36`	`36`
`37`	`37`	`function identityOwner(address identity) public view returns(address) {`
`38`	`38`	`address owner = owners[identity];`
`39`		`- if (owner != 0x0) {`
	`39`	`+ if (owner != 0x0000000000000000000000000000000000000000) {`
`40`	`40`	`return owner;`
`41`	`41`	`}`
`42`	`42`	`return identity;`
`@@ -50,8 +50,8 @@ contract EthereumDIDRegistry {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`function validDelegate(address identity, bytes32 delegateType, address delegate) public view returns(bool) {`
`53`		`- uint validity = delegates[identity][keccak256(delegateType)][delegate];`
`54`		`- return (validity > now);`
	`53`	`+ uint validity = delegates[identity][keccak256(abi.encode(delegateType))][delegate];`
	`54`	`+ return (validity > block.timestamp);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`function changeOwner(address identity, address actor, address newOwner) internal onlyOwner(identity, actor) {`
`@@ -65,13 +65,13 @@ contract EthereumDIDRegistry {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`function changeOwnerSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, address newOwner) public {`
`68`		`- bytes32 hash = keccak256(byte(0x19), byte(0), this, nonce[identityOwner(identity)], identity, "changeOwner", newOwner);`
	`68`	`+ bytes32 hash = keccak256(abi.encodePacked(bytes1(0x19), bytes1(0), this, nonce[identityOwner(identity)], identity, "changeOwner", newOwner));`
`69`	`69`	`changeOwner(identity, checkSignature(identity, sigV, sigR, sigS, hash), newOwner);`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`function addDelegate(address identity, address actor, bytes32 delegateType, address delegate, uint validity) internal onlyOwner(identity, actor) {`
`73`		`- delegates[identity][keccak256(delegateType)][delegate] = now + validity;`
`74`		`- emit DIDDelegateChanged(identity, delegateType, delegate, now + validity, changed[identity]);`
	`73`	`+ delegates[identity][keccak256(abi.encode(delegateType))][delegate] = block.timestamp + validity;`
	`74`	`+ emit DIDDelegateChanged(identity, delegateType, delegate, block.timestamp + validity, changed[identity]);`
`75`	`75`	`changed[identity] = block.number;`
`76`	`76`	`}`
`77`	`77`
`@@ -80,13 +80,13 @@ contract EthereumDIDRegistry {`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`function addDelegateSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 delegateType, address delegate, uint validity) public {`
`83`		`- bytes32 hash = keccak256(byte(0x19), byte(0), this, nonce[identityOwner(identity)], identity, "addDelegate", delegateType, delegate, validity);`
	`83`	`+ bytes32 hash = keccak256(abi.encodePacked(bytes1(0x19), bytes1(0), this, nonce[identityOwner(identity)], identity, "addDelegate", delegateType, delegate, validity));`
`84`	`84`	`addDelegate(identity, checkSignature(identity, sigV, sigR, sigS, hash), delegateType, delegate, validity);`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`function revokeDelegate(address identity, address actor, bytes32 delegateType, address delegate) internal onlyOwner(identity, actor) {`
`88`		`- delegates[identity][keccak256(delegateType)][delegate] = now;`
`89`		`- emit DIDDelegateChanged(identity, delegateType, delegate, now, changed[identity]);`
	`88`	`+ delegates[identity][keccak256(abi.encode(delegateType))][delegate] = block.timestamp;`
	`89`	`+ emit DIDDelegateChanged(identity, delegateType, delegate, block.timestamp, changed[identity]);`
`90`	`90`	`changed[identity] = block.number;`
`91`	`91`	`}`
`92`	`92`
`@@ -95,36 +95,36 @@ contract EthereumDIDRegistry {`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`function revokeDelegateSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 delegateType, address delegate) public {`
`98`		`- bytes32 hash = keccak256(byte(0x19), byte(0), this, nonce[identityOwner(identity)], identity, "revokeDelegate", delegateType, delegate);`
	`98`	`+ bytes32 hash = keccak256(abi.encodePacked(bytes1(0x19), bytes1(0), this, nonce[identityOwner(identity)], identity, "revokeDelegate", delegateType, delegate));`
`99`	`99`	`revokeDelegate(identity, checkSignature(identity, sigV, sigR, sigS, hash), delegateType, delegate);`
`100`	`100`	`}`
`101`	`101`
`102`		`- function setAttribute(address identity, address actor, bytes32 name, bytes value, uint validity ) internal onlyOwner(identity, actor) {`
`103`		`- emit DIDAttributeChanged(identity, name, value, now + validity, changed[identity]);`
	`102`	`+ function setAttribute(address identity, address actor, bytes32 name, bytes memory value, uint validity ) internal onlyOwner(identity, actor) {`
	`103`	`+ emit DIDAttributeChanged(identity, name, value, block.timestamp + validity, changed[identity]);`
`104`	`104`	`changed[identity] = block.number;`
`105`	`105`	`}`
`106`	`106`
`107`		`- function setAttribute(address identity, bytes32 name, bytes value, uint validity) public {`
	`107`	`+ function setAttribute(address identity, bytes32 name, bytes memory value, uint validity) public {`
`108`	`108`	`setAttribute(identity, msg.sender, name, value, validity);`
`109`	`109`	`}`
`110`	`110`
`111`		`- function setAttributeSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 name, bytes value, uint validity) public {`
`112`		`- bytes32 hash = keccak256(byte(0x19), byte(0), this, nonce[identityOwner(identity)], identity, "setAttribute", name, value, validity);`
	`111`	`+ function setAttributeSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 name, bytes memory value, uint validity) public {`
	`112`	`+ bytes32 hash = keccak256(abi.encodePacked(bytes1(0x19), bytes1(0), this, nonce[identityOwner(identity)], identity, "setAttribute", name, value, validity));`
`113`	`113`	`setAttribute(identity, checkSignature(identity, sigV, sigR, sigS, hash), name, value, validity);`
`114`	`114`	`}`
`115`	`115`
`116`		`- function revokeAttribute(address identity, address actor, bytes32 name, bytes value ) internal onlyOwner(identity, actor) {`
	`116`	`+ function revokeAttribute(address identity, address actor, bytes32 name, bytes memory value ) internal onlyOwner(identity, actor) {`
`117`	`117`	`emit DIDAttributeChanged(identity, name, value, 0, changed[identity]);`
`118`	`118`	`changed[identity] = block.number;`
`119`	`119`	`}`
`120`	`120`
`121`		`- function revokeAttribute(address identity, bytes32 name, bytes value) public {`
	`121`	`+ function revokeAttribute(address identity, bytes32 name, bytes memory value) public {`
`122`	`122`	`revokeAttribute(identity, msg.sender, name, value);`
`123`	`123`	`}`
`124`	`124`
`125`		`- function revokeAttributeSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 name, bytes value) public {`
`126`		`- bytes32 hash = keccak256(byte(0x19), byte(0), this, nonce[identityOwner(identity)], identity, "revokeAttribute", name, value);`
	`125`	`+ function revokeAttributeSigned(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 name, bytes memory value) public {`
	`126`	`+ bytes32 hash = keccak256(abi.encodePacked(bytes1(0x19), bytes1(0), this, nonce[identityOwner(identity)], identity, "revokeAttribute", name, value));`
`127`	`127`	`revokeAttribute(identity, checkSignature(identity, sigV, sigR, sigS, hash), name, value);`
`128`	`128`	`}`
`129`	`129`
`130`		`-}`
	`130`	`+}`