(Freature) Add ERC-735 claim generation + PoPA ERC-725 Contract

.env.example

@@ -1,3 +1,5 @@
 REACT_APP_POPA_CONTRACT_ADDRESS=0xc395234b5d14bed13eb69595da09d7795892087a
+REACT_APP_POPA_ERC725_CONTRACT_ADDRESS=0xd0a01db20de37853c02bd33619485ef1ab961929
 REACT_APP_PRICE=1
 REACT_APP_PRICE_SYMBOL=POA
+REACT_APP_POPA_ERC725_URI='http://popa.poa.network'

blockchain/.solcover.js

@@ -2,5 +2,5 @@ module.exports = {
   testrpcOptions: '-p 8555 --mnemonic "toddler weather rocket off sentence chat unlock flame organ shuffle treat awful"',
   compileCommand: '../node_modules/.bin/truffle compile',
   testCommand: '../node_modules/.bin/truffle test --network coverage',
-  skipFiles: ['ERC20.sol', 'TestERC20.sol'],
+  skipFiles: ['ERC20.sol', 'TestERC20.sol', 'ERC725.sol', 'mocks/PhysicalAddressClaimMock.sol'],
 };

blockchain/contracts/ERC20.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.4.19;
+pragma solidity 0.4.24;
 
 
 contract ERC20 {

blockchain/contracts/ERC725.sol

@@ -0,0 +1,30 @@
+// From: https://github.com/OriginProtocol/origin-playground/tree/0c9ba5c008d410e1ca82a2b1eed15705db49af0f/contracts
+pragma solidity 0.4.24;
+
+
+contract ERC725 {
+
+    uint256 constant MANAGEMENT_KEY = 1;
+    uint256 constant ACTION_KEY = 2;
+    uint256 constant CLAIM_SIGNER_KEY = 3;
+    uint256 constant ENCRYPTION_KEY = 4;
+
+    event KeyAdded(bytes32 indexed key, uint256 indexed purpose, uint256 indexed keyType);
+    event KeyRemoved(bytes32 indexed key, uint256 indexed purpose, uint256 indexed keyType);
+    event ExecutionRequested(uint256 indexed executionId, address indexed to, uint256 indexed value, bytes data);
+    event Executed(uint256 indexed executionId, address indexed to, uint256 indexed value, bytes data);
+    event Approved(uint256 indexed executionId, bool approved);
+
+    struct Key {
+        uint256 purpose; //e.g., MANAGEMENT_KEY = 1, ACTION_KEY = 2, etc.
+        uint256 keyType; // e.g. 1 = ECDSA, 2 = RSA, etc.
+        bytes32 key;
+    }
+
+    function getKey(bytes32 _key) public constant returns(uint256 purpose, uint256 keyType, bytes32 key);
+    function getKeyPurpose(bytes32 _key) public constant returns(uint256 purpose);
+    function getKeysByPurpose(uint256 _purpose) public constant returns(bytes32[] keys);
+    function addKey(bytes32 _key, uint256 _purpose, uint256 _keyType) public returns (bool success);
+    function execute(address _to, uint256 _value, bytes _data) public returns (uint256 executionId);
+    function approve(uint256 _id, bool _approve) public returns (bool success);
+}

blockchain/contracts/EthereumClaimsRegistry.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.4.19;
+pragma solidity 0.4.24;
 
 import "./EthereumClaimsRegistryInterface.sol";
 

blockchain/contracts/EthereumClaimsRegistryInterface.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.4.19;
+pragma solidity 0.4.24;
 
 
 contract EthereumClaimsRegistryInterface {

blockchain/contracts/KeyHolder.sol

@@ -0,0 +1,164 @@
+// From: https://github.com/OriginProtocol/origin-playground/tree/0c9ba5c008d410e1ca82a2b1eed15705db49af0f/contracts
+pragma solidity 0.4.24;
+
+import "./ERC725.sol";
+
+
+contract KeyHolder is ERC725 {
+
+    uint256 executionNonce;
+
+    struct Execution {
+        address to;
+        uint256 value;
+        bytes data;
+        bool approved;
+        bool executed;
+    }
+
+    mapping (bytes32 => Key) keys;
+    mapping (uint256 => bytes32[]) keysByPurpose;
+    mapping (uint256 => Execution) executions;
+
+    event ExecutionFailed(uint256 indexed executionId, address indexed to, uint256 indexed value, bytes data);
+
+    function KeyHolder() public {
+        bytes32 _key = keccak256(msg.sender);
+        keys[_key].key = _key;
+        keys[_key].purpose = 1;
+        keys[_key].keyType = 1;
+        keysByPurpose[1].push(_key);
+        emit KeyAdded(_key, keys[_key].purpose, 1);
+    }
+
+    function getKey(bytes32 _key)
+        public
+        view
+        returns(uint256 purpose, uint256 keyType, bytes32 key)
+    {
+        return (keys[_key].purpose, keys[_key].keyType, keys[_key].key);
+    }
+
+    function getKeyPurpose(bytes32 _key)
+        public
+        view
+        returns(uint256 purpose)
+    {
+        return (keys[_key].purpose);
+    }
+
+    function getKeysByPurpose(uint256 _purpose)
+        public
+        view
+        returns(bytes32[] _keys)
+    {
+        return keysByPurpose[_purpose];
+    }
+
+    function addKey(bytes32 _key, uint256 _purpose, uint256 _type)
+        public
+        returns (bool success)
+    {
+        require(keys[_key].key != _key, "Key already exists"); // Key should not already exist
+        if (msg.sender != address(this)) {
+            // Sender has MANAGEMENT_KEY
+            require(keyHasPurpose(keccak256(msg.sender), 1), "Sender does not have management key");
+        }
+
+        keys[_key].key = _key;
+        keys[_key].purpose = _purpose;
+        keys[_key].keyType = _type;
+
+        keysByPurpose[_purpose].push(_key);
+
+        emit KeyAdded(_key, _purpose, _type);
+
+        return true;
+    }
+
+    function approve(uint256 _id, bool _approve)
+        public
+        returns (bool success)
+    {
+        require(keyHasPurpose(keccak256(msg.sender), 2), "Sender does not have action key");
+
+        emit Approved(_id, _approve);
+
+        if (_approve == true) {
+            executions[_id].approved = true;
+            success = executions[_id].to.call(executions[_id].data, 0);
+            if (success) {
+                executions[_id].executed = true;
+                emit Executed(
+                    _id,
+                    executions[_id].to,
+                    executions[_id].value,
+                    executions[_id].data
+                );
+                return;
+            } else {
+                emit ExecutionFailed(
+                    _id,
+                    executions[_id].to,
+                    executions[_id].value,
+                    executions[_id].data
+                );
+                return;
+            }
+        } else {
+            executions[_id].approved = false;
+        }
+        return true;
+    }
+
+    function execute(address _to, uint256 _value, bytes _data)
+        public
+        returns (uint256 executionId)
+    {
+        require(!executions[executionNonce].executed, "Already executed");
+        executions[executionNonce].to = _to;
+        executions[executionNonce].value = _value;
+        executions[executionNonce].data = _data;
+
+        emit ExecutionRequested(executionNonce, _to, _value, _data);
+
+        if (keyHasPurpose(keccak256(msg.sender), 1) || keyHasPurpose(keccak256(msg.sender), 2)) {
+            approve(executionNonce, true);
+        }
+
+        executionNonce++;
+        return executionNonce-1;
+    }
+
+    function removeKey(bytes32 _key)
+        public
+        returns (bool success)
+    {
+        require(keys[_key].key == _key, "No such key");
+
+        bytes32 senderKey = keccak256(msg.sender);
+        require(keys[senderKey].purpose == 1, "MANAGEMENT_KEY purpose required for removeKey");
+
+        emit KeyRemoved(keys[_key].key, keys[_key].purpose, keys[_key].keyType);
+
+        /* uint index;
+        (index,) = keysByPurpose[keys[_key].purpose.indexOf(_key);
+        keysByPurpose[keys[_key].purpose.removeByIndex(index); */
+
+        delete keys[_key];
+
+        return true;
+    }
+
+    function keyHasPurpose(bytes32 _key, uint256 _purpose)
+        public
+        view
+        returns(bool result)
+    {
+        bool isThere;
+        if (keys[_key].key == 0) return false;
+        isThere = keys[_key].purpose <= _purpose;
+        return isThere;
+    }
+
+}

blockchain/contracts/Migrations.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.4.19;
+pragma solidity 0.4.24;
 
 
 contract Migrations {

blockchain/contracts/PhysicalAddressClaim.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.4.19;
+pragma solidity 0.4.24;
 
 
 library PhysicalAddressClaim {

blockchain/contracts/ProofOfPhysicalAddress.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.4.19;
+pragma solidity 0.4.24;
 
 import "./EthereumClaimsRegistryInterface.sol";
 import "./PhysicalAddressClaim.sol";

blockchain/contracts/ProofOfPhysicalAddressKeyHolder.sol

@@ -0,0 +1,32 @@
+pragma solidity 0.4.24;
+
+import "./KeyHolder.sol";
+
+
+contract ProofOfPhysicalAddressKeyHolder is KeyHolder {
+    address public owner;
+    address public signer;
+
+    constructor() public {
+        owner = msg.sender;
+        signer = owner;
+    }
+
+    // Events:
+    event LogSignerChanged(address newSigner);
+
+    // Modifiers:
+    modifier onlyOwner() {
+        require(msg.sender == owner);
+        _;
+    }
+
+    // Methods:
+    // set address that is used on server-side to calculate signatures
+    // and on contract-side to verify them
+    function setSigner(address newSigner) public onlyOwner {
+        signer = newSigner;
+        LogSignerChanged(newSigner);
+    }
+
+}

blockchain/contracts/TestERC20.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.4.19;
+pragma solidity 0.4.24;
 
 import "./ERC20.sol";
 

blockchain/contracts/mocks/PhysicalAddressClaimMock.sol

@@ -0,0 +1,32 @@
+pragma solidity 0.4.24;
+
+import "../PhysicalAddressClaim.sol";
+
+
+/**
+ * PhysicalAddressClaim "library mock contract", needed to make coverage work:
+ * https://github.com/sc-forks/solidity-coverage/issues/234
+ * Essentialy this is used only on tests, and JS tests files will use this
+ * contracts' methods instead of the ones from the library.
+ */
+contract PhysicalAddressClaimMock {
+
+    function encode(uint256 _confirmationBlockNumber) public pure returns(bytes32) {
+        return PhysicalAddressClaim.encode(_confirmationBlockNumber);
+    }
+
+    function decode(bytes32 _claim) public pure returns(
+        uint256 version,
+        uint256 confirmation
+    ) {
+        return PhysicalAddressClaim.decode(_claim);
+    }
+
+    function decodeVersion(bytes32 _claim) public pure returns(uint256 version) {
+        return PhysicalAddressClaim.decodeVersion(_claim);
+    }
+
+    function decodeConfirmation(bytes32 _claim) public pure returns(uint256 confirmation) {
+        return PhysicalAddressClaim.decodeConfirmation(_claim);
+    }
+}

blockchain/migrations/1522104575_popa.js

@@ -1,7 +1,9 @@
 var POPA = artifacts.require('ProofOfPhysicalAddress');
 var PhysicalAddressClaim = artifacts.require('PhysicalAddressClaim');
+var PhysicalAddressClaimMock = artifacts.require('mocks/PhysicalAddressClaimMock');
 var EthereumClaimsRegistry = artifacts.require('EthereumClaimsRegistry');
 var TestERC20 = artifacts.require('TestERC20');
+var POPAKeyHolder = artifacts.require('ProofOfPhysicalAddressKeyHolder');
 
 module.exports = function(deployer, network) {
     return deployer.then(async () => {
@@ -19,10 +21,13 @@ module.exports = function(deployer, network) {
 
         if (network === 'test' || network === 'coverage') {
             await deployer.deploy(TestERC20);
+            await deployer.link(PhysicalAddressClaim, PhysicalAddressClaimMock);
+            await deployer.deploy(PhysicalAddressClaimMock);
         }
 
         const gas = network === 'coverage' ? '0xfffffffffff' : '6000000';
 
         await deployer.deploy(POPA, ethereumClaimsRegistryAddress, { gas });
+        await deployer.deploy(POPAKeyHolder);
     });
 };