Brand new design for clr.fund dapp

contracts/contracts/userRegistry/BrightIdSponsor.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity ^0.6.12;
+
+contract BrightIdSponsor {
+    event Sponsor(address indexed addr);
+
+    /**
+     * @dev sponsor a BrightId user by emitting an event
+     * that a BrightId node is listening for
+     */
+    function sponsor(address addr) public {
+        emit Sponsor(addr);
+    }
+}

contracts/contracts/userRegistry/BrightIdUserRegistry.sol

@@ -3,6 +3,7 @@
 pragma solidity ^0.6.12;
 
 import './IUserRegistry.sol';
+import './BrightIdSponsor.sol';
 import '@openzeppelin/contracts/access/Ownable.sol';
 
 contract BrightIdUserRegistry is Ownable, IUserRegistry {
@@ -13,48 +14,52 @@ contract BrightIdUserRegistry is Ownable, IUserRegistry {
 
     bytes32 public context;
     address public verifier;
+    BrightIdSponsor public brightIdSponsor;
+
 
     struct Verification {
         uint256 time;
         bool isVerified;
     }
     mapping(address => Verification) public verifications;
 
-    event SetBrightIdSettings(bytes32 context, address verifier);
-    event Sponsor(address indexed addr);
+    event SetBrightIdSettings(bytes32 context, address verifier, address sponsor);
+    event Registered(address indexed addr, uint256 timestamp, bool isVerified);
 
     /**
      * @param _context BrightID context used for verifying users
      * @param _verifier BrightID verifier address that signs BrightID verifications
      */
-    constructor(bytes32 _context, address _verifier) public {
+    constructor(bytes32 _context, address _verifier, address _sponsor) public {
         // ecrecover returns zero on error
         require(_verifier != address(0), ERROR_INVALID_VERIFIER);
 
         context = _context;
         verifier = _verifier;
+        brightIdSponsor = BrightIdSponsor(_sponsor);
     }
 
     /**
      * @notice Sponsor a BrightID user by context id
      * @param addr BrightID context id
      */
     function sponsor(address addr) public {
-        emit Sponsor(addr);
+        brightIdSponsor.sponsor(addr);
     }
 
     /**
      * @notice Set BrightID settings
      * @param _context BrightID context used for verifying users
      * @param _verifier BrightID verifier address that signs BrightID verifications
      */
-    function setSettings(bytes32 _context, address _verifier) external onlyOwner {
+    function setSettings(bytes32 _context, address _verifier, address _sponsor) external onlyOwner {
         // ecrecover returns zero on error
         require(_verifier != address(0), ERROR_INVALID_VERIFIER);
 
         context = _context;
         verifier = _verifier;
-        emit SetBrightIdSettings(_context, _verifier);
+        brightIdSponsor = BrightIdSponsor(_sponsor);
+        emit SetBrightIdSettings(_context, _verifier, _sponsor);
     }
 
     /**
@@ -74,34 +79,32 @@ contract BrightIdUserRegistry is Ownable, IUserRegistry {
     /**
      * @notice Register a user by BrightID verification
      * @param _context The context used in the users verification
-     * @param _addrs The history of addresses used by this user in this context
+     * @param _addr The address used by this user in this context
+     * @param _verificationHash sha256 of the verification expression
      * @param _timestamp The BrightID node's verification timestamp
      * @param _v Component of signature
      * @param _r Component of signature
      * @param _s Component of signature
      */
     function register(
         bytes32 _context,
-        address[] calldata _addrs,
+        address _addr,
+        bytes32 _verificationHash,
         uint _timestamp,
         uint8 _v,
         bytes32 _r,
         bytes32 _s
     ) external {
         require(context == _context, ERROR_INVALID_CONTEXT);
-        require(verifications[_addrs[0]].time < _timestamp, ERROR_NEWER_VERIFICATION);
+        require(verifications[_addr].time < _timestamp, ERROR_NEWER_VERIFICATION);
 
-        bytes32 message = keccak256(abi.encodePacked(_context, _addrs, _timestamp));
+        bytes32 message = keccak256(abi.encodePacked(_context, _addr, _verificationHash, _timestamp));
         address signer = ecrecover(message, _v, _r, _s);
         require(verifier == signer, ERROR_NOT_AUTHORIZED);
 
-        verifications[_addrs[0]].time = _timestamp;
-        verifications[_addrs[0]].isVerified = true;
-        for(uint i = 1; i < _addrs.length; i++) {
-            // update time of all previous context ids to be sure no one can use old verifications again
-            verifications[_addrs[i]].time = _timestamp;
-            // set old verifications unverified
-            verifications[_addrs[i]].isVerified = false;
-        }
+        verifications[_addr].time = _timestamp;
+        verifications[_addr].isVerified = true;
+
+        emit Registered(_addr, _timestamp, true);
     }
 }

contracts/scripts/deployBrightIdSponsor.ts

@@ -0,0 +1,60 @@
+import { ethers } from 'hardhat'
+import { Contract, utils } from 'ethers'
+
+async function main() {
+  console.log('*******************')
+  console.log('Deploying a user registry!')
+  console.log('*******************')
+
+  if (!process.env.BRIGHTID_USER_REGISTRY) {
+    console.error('Missing BRIGHTID_USER_REGISTRY environment variable')
+    return
+  }
+  if (!process.env.BRIGHTID_CONTEXT) {
+    console.error('Missing BRIGHTID_CONTEXT environment variable')
+    return
+  }
+  if (!process.env.BRIGHTID_VERIFIER_ADDR) {
+    console.error('Missing BRIGHTID_VERIFIER_ADDR environment variable')
+    return
+  }
+
+  const [deployer] = await ethers.getSigners()
+  console.log('deployer.address: ', deployer.address)
+
+  console.log('deploying brightid sponsor contract')
+  const BrightIdSponsor = await ethers.getContractFactory(
+    'BrightIdSponsor',
+    deployer
+  )
+  const sponsor = await BrightIdSponsor.deploy()
+  const receipt = await sponsor.deployTransaction.wait()
+  console.log(`Deployed BrightId Sponsor Contract at ${sponsor.address}`)
+  console.log('transaction hash', receipt.transactionHash)
+
+  const userRegistry = await ethers.getContractAt(
+    'BrightIdUserRegistry',
+    process.env.BRIGHTID_USER_REGISTRY
+  )
+  const tx = await userRegistry.setSettings(
+    utils.formatBytes32String(process.env.BRIGHTID_CONTEXT),
+    process.env.BRIGHTID_VERIFIER_ADDR,
+    sponsor.address
+  )
+  const settingReceipt = await tx.wait()
+  console.log(
+    'Set user registry settings at hash',
+    settingReceipt.transactionHash
+  )
+
+  console.log('*******************')
+  console.log('Deploy complete!')
+  console.log('*******************')
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error)
+    process.exit(1)
+  })

contracts/scripts/deployUserRegistry.ts

@@ -0,0 +1,71 @@
+import { ethers } from 'hardhat'
+import { Contract, utils } from 'ethers'
+
+async function main() {
+  console.log('*******************')
+  console.log('Deploying a user registry!')
+  console.log('*******************')
+  const [deployer] = await ethers.getSigners()
+  console.log('deployer.address: ', deployer.address)
+
+  const fundingRoundFactoryAddress = process.env.FUNDING_ROUND_FACTORY_ADDRESS
+
+  if (!fundingRoundFactoryAddress) {
+    throw new Error(
+      'Environment variable FUNDING_ROUND_FACTORY_ADDRESS is not setup'
+    )
+  }
+  const fundingRoundFactory = await ethers.getContractAt(
+    'FundingRoundFactory',
+    fundingRoundFactoryAddress
+  )
+  console.log('funding round factory address ', fundingRoundFactory.address)
+
+  const userRegistryType = process.env.USER_REGISTRY_TYPE || 'simple'
+  let userRegistry: Contract
+  if (userRegistryType === 'simple') {
+    const SimpleUserRegistry = await ethers.getContractFactory(
+      'SimpleUserRegistry',
+      deployer
+    )
+    userRegistry = await SimpleUserRegistry.deploy()
+  } else if (userRegistryType === 'brightid') {
+    console.log('deploying brightid user registry')
+    const BrightIdUserRegistry = await ethers.getContractFactory(
+      'BrightIdUserRegistry',
+      deployer
+    )
+    userRegistry = await BrightIdUserRegistry.deploy(
+      utils.formatBytes32String(process.env.BRIGHTID_CONTEXT),
+      process.env.BRIGHTID_VERIFIER_ADDR,
+      process.env.BRIGHTID_SPONSOR
+    )
+  } else {
+    throw new Error('unsupported user registry type')
+  }
+  const receipt = await userRegistry.deployTransaction.wait()
+  console.log(
+    `Deployed ${userRegistryType} user registry at ${userRegistry.address}`
+  )
+  console.log('transaction hash', receipt.transactionHash)
+
+  const setUserRegistryTx = await fundingRoundFactory.setUserRegistry(
+    userRegistry.address
+  )
+  await setUserRegistryTx.wait()
+  console.log(
+    'set user registry in funding round factory',
+    setUserRegistryTx.hash
+  )
+
+  console.log('*******************')
+  console.log('Deploy complete!')
+  console.log('*******************')
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error)
+    process.exit(1)
+  })