Add selectIssuers Transaction

packages/celotool/src/cmds/account/verify.ts

@@ -1,8 +1,11 @@
 import { AccountArgv } from '@celo/celotool/src/cmds/account'
 import { portForwardAnd } from '@celo/celotool/src/lib/port_forward'
 import { newKit } from '@celo/contractkit'
-import { AttestationsWrapper } from '@celo/contractkit/lib/wrappers/Attestations'
-import { ActionableAttestation, decodeAttestationCode } from '@celo/walletkit'
+import {
+  ActionableAttestation,
+  AttestationsWrapper,
+} from '@celo/contractkit/lib/wrappers/Attestations'
+import { base64ToHex } from '@celo/utils/lib/attestations'
 import prompts from 'prompts'
 import { switchToClusterFromEnv } from 'src/lib/cluster'
 import * as yargs from 'yargs'
@@ -59,7 +62,8 @@ async function verifyCmd(argv: VerifyArgv) {
     await requestMoreAttestations(
       attestations,
       argv.phone,
-      argv.num - attestationsToComplete.length
+      argv.num - attestationsToComplete.length,
+      account
     )
   }
 
@@ -97,14 +101,17 @@ export async function printCurrentCompletedAttestations(
 async function requestMoreAttestations(
   attestations: AttestationsWrapper,
   phoneNumber: string,
-  attestationsRequested: number
+  attestationsRequested: number,
+  account: string
 ) {
   await attestations
     .approveAttestationFee(attestationsRequested)
     .then((txo) => txo.sendAndWaitForReceipt())
   await attestations
     .request(phoneNumber, attestationsRequested)
     .then((txo) => txo.sendAndWaitForReceipt())
+  await attestations.waitForSelectingIssuers(phoneNumber, account)
+  await attestations.selectIssuers(phoneNumber).then((txo) => txo.sendAndWaitForReceipt())
 }
 
 async function revealAttestations(
@@ -128,7 +135,7 @@ async function verifyCode(
   account: string,
   attestationsToComplete: ActionableAttestation[]
 ) {
-  const code = decodeAttestationCode(base64Code)
+  const code = base64ToHex(base64Code)
   const matchingIssuer = attestations.findMatchingIssuer(
     phoneNumber,
     account,

packages/celotool/src/e2e-tests/attestations_tests.ts

@@ -49,11 +49,16 @@ describe('governance tests', () => {
 
     it('requests an attestation', async function(this: any) {
       this.timeout(10000)
+
       const approve = await Attestations.approveAttestationFee(2)
       await approve.sendAndWaitForReceipt()
       const request = await Attestations.request(phoneNumber, 2)
       await request.sendAndWaitForReceipt()
 
+      await Attestations.waitForSelectingIssuers(phoneNumber, validatorAddress)
+      const selectIssuers = await Attestations.selectIssuers(phoneNumber)
+      await selectIssuers.sendAndWaitForReceipt()
+
       const stats = await Attestations.getAttestationStat(phoneNumber, validatorAddress)
       assert.equal(stats.total, 2)
       const actionable = await Attestations.getActionableAttestations(phoneNumber, validatorAddress)

packages/contractkit/src/wrappers/Attestations.ts

@@ -1,4 +1,5 @@
 import { ECIES, PhoneNumberUtils, SignatureUtils } from '@celo/utils'
+import { sleep } from '@celo/utils/lib/async'
 import { zip3 } from '@celo/utils/lib/collections'
 import BigNumber from 'bignumber.js'
 import * as Web3Utils from 'web3-utils'
@@ -30,7 +31,7 @@ export interface AttestationsToken {
 }
 
 export interface AttestationsConfig {
-  attestationExpirySeconds: number
+  attestationExpiryBlocks: number
   attestationRequestFees: AttestationsToken[]
 }
 
@@ -46,13 +47,13 @@ export enum AttestationState {
 export interface ActionableAttestation {
   issuer: Address
   attestationState: AttestationState
-  time: number
+  blockNumber: number
   publicKey: string
 }
 
 const parseAttestationInfo = (rawState: { 0: string; 1: string }) => ({
   attestationState: parseInt(rawState[0], 10),
-  time: parseInt(rawState[1], 10),
+  blockNumber: parseInt(rawState[1], 10),
 })
 
 function attestationMessageToSign(phoneHash: string, account: Address) {
@@ -68,8 +69,8 @@ export class AttestationsWrapper extends BaseWrapper<Attestations> {
   /**
    *  Returns the time an attestation can be completable before it is considered expired
    */
-  attestationExpirySeconds = proxyCall(
-    this.contract.methods.attestationExpirySeconds,
+  attestationExpiryBlocks = proxyCall(
+    this.contract.methods.attestationExpiryBlocks,
     undefined,
     toNumber
   )
@@ -85,6 +86,50 @@ export class AttestationsWrapper extends BaseWrapper<Attestations> {
     toBigNumber
   )
 
+  selectIssuersWaitBlocks = proxyCall(
+    this.contract.methods.selectIssuersWaitBlocks,
+    undefined,
+    toNumber
+  )
+
+  /**
+   * @notice Returns the unselected attestation request for an identifier/account pair, if any.
+   * @param identifier Hash of the identifier.
+   * @param account Address of the account.
+   */
+  getUnselectedRequest = proxyCall(
+    this.contract.methods.getUnselectedRequest,
+    tupleParser(PhoneNumberUtils.getPhoneHash, (x: string) => x),
+    (res) => ({
+      blockNumber: toNumber(res[0]),
+      attestationsRequested: toNumber(res[1]),
+      attestationRequestFeeToken: res[2],
+    })
+  )
+
+  waitForSelectingIssuers = async (
+    phoneNumber: string,
+    account: Address,
+    timeoutSeconds = 120,
+    pollDurationSeconds = 1
+  ) => {
+    const startTime = Date.now()
+    const unselectedRequest = await this.getUnselectedRequest(phoneNumber, account)
+    const waitBlocks = await this.selectIssuersWaitBlocks()
+
+    if (unselectedRequest.blockNumber === 0) {
+      throw new Error('No unselectedRequest to wait for')
+    }
+    // Technically should use subscriptions here but not all providers support it.
+    // TODO: Use subscription if provider supports
+    while (Date.now() - startTime < timeoutSeconds * 1000) {
+      const blockNumber = await this.kit.web3.eth.getBlockNumber()
+      if (blockNumber >= unselectedRequest.blockNumber + waitBlocks) {
+        return
+      }
+      await sleep(pollDurationSeconds * 1000)
+    }
+  }
   /**
    * Returns the attestation stats of a phone number/account pair
    * @param phoneNumber Phone Number
@@ -95,7 +140,7 @@ export class AttestationsWrapper extends BaseWrapper<Attestations> {
     account: Address
   ) => Promise<AttestationStat> = proxyCall(
     this.contract.methods.getAttestationStats,
-    tupleParser(PhoneNumberUtils.getPhoneHash, (x: string) => x),
+    tupleParser(PhoneNumberUtils.getPhoneHash, stringIdentity),
     (stat) => ({ completed: toNumber(stat[0]), total: toNumber(stat[1]) })
   )
 
@@ -177,8 +222,8 @@ export class AttestationsWrapper extends BaseWrapper<Attestations> {
     account: Address
   ): Promise<ActionableAttestation[]> {
     const phoneHash = PhoneNumberUtils.getPhoneHash(phoneNumber)
-    const expirySeconds = await this.attestationExpirySeconds()
-    const nowInUnixSeconds = Math.floor(new Date().getTime() / 1000)
+    const expiryBlocks = await this.attestationExpiryBlocks()
+    const currentBlockNumber = await this.kit.web3.eth.getBlockNumber()
 
     const issuers = await this.contract.methods.getAttestationIssuers(phoneHash, account).call()
     const issuerState = Promise.all(
@@ -196,14 +241,14 @@ export class AttestationsWrapper extends BaseWrapper<Attestations> {
     )
 
     const isIncomplete = (status: AttestationState) => status === AttestationState.Incomplete
-    const hasNotExpired = (time: number) => nowInUnixSeconds < time + expirySeconds
+    const hasNotExpired = (blockNumber: number) => currentBlockNumber < blockNumber + expiryBlocks
     const isValidKey = (key: string) => key !== null && key !== '0x0'
 
     return zip3(issuers, await issuerState, await publicKeys)
       .filter(
         ([_issuer, attestation, publicKey]) =>
           isIncomplete(attestation.attestationState) &&
-          hasNotExpired(attestation.time) &&
+          hasNotExpired(attestation.blockNumber) &&
           isValidKey(publicKey)
       )
       .map(([issuer, attestation, publicKey]) => ({
@@ -266,7 +311,7 @@ export class AttestationsWrapper extends BaseWrapper<Attestations> {
       })
     )
     return {
-      attestationExpirySeconds: await this.attestationExpirySeconds(),
+      attestationExpiryBlocks: await this.attestationExpiryBlocks(),
       attestationRequestFees: fees,
     }
   }
@@ -328,6 +373,16 @@ export class AttestationsWrapper extends BaseWrapper<Attestations> {
     )
   }
 
+  /**
+   * Selects the issuers for previously requested attestations for a phone number
+   * @param phoneNumber The phone number for which to request attestations for
+   * @param token The token with which to pay for the attestation fee
+   */
+  async selectIssuers(phoneNumber: string) {
+    const phoneHash = PhoneNumberUtils.getPhoneHash(phoneNumber)
+    return toTransactionObject(this.kit, this.contract.methods.selectIssuers(phoneHash))
+  }
+
   /**
    * Reveals the phone number to the issuer of the attestation on-chain
    * @param phoneNumber The phone number which requested attestation

packages/protocol/contracts/common/SafeCast.sol

@@ -0,0 +1,88 @@
+pragma solidity ^0.5.0;
+// TODO: Remove this and use upstream when
+// https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1926/files gets merged
+
+/**
+ * @dev Wrappers over Solidity's uintXX casting operators with added overflow
+ * checks.
+ *
+ * Downcasting from uint256 in Solidity does not revert by default on overflow.
+ * This can easily result in undesired exploitation or bugs, since developers
+ * usually assume that overflows raise errors. `SafeCast` restores this intuition
+ * by reverting the transaction when such an operation overflows.
+ *
+ * Using this library instead of the unchecked operations eliminates an entire
+ * class of bugs, so it's recommended to use it always.
+ */
+library SafeCast {
+
+  /**
+    * @dev Returns the downcasted uint128 from uint256, reverting on
+    * overflow (when the input is greater than largest uint128).
+    *
+    * Counterpart to Solidity's `uint128` operator.
+    *
+    * Requirements:
+    * - input must fit into 128 bits
+    */
+  function toUint128(uint256 value) internal pure returns (uint128) {
+    require(value < 2**128, "SafeCast: value doesn\'t fit in 128 bits");
+    return uint128(value);
+  }
+
+  /**
+    * @dev Returns the downcasted uint64 from uint256, reverting on
+    * overflow (when the input is greater than largest uint64).
+    *
+    * Counterpart to Solidity's `uint64` operator.
+    *
+    * Requirements:
+    * - input must fit into 64 bits
+    */
+  function toUint64(uint256 value) internal pure returns (uint64) {
+    require(value < 2**64, "SafeCast: value doesn\'t fit in 64 bits");
+    return uint64(value);
+  }
+
+  /**
+    * @dev Returns the downcasted uint32 from uint256, reverting on
+    * overflow (when the input is greater than largest uint32).
+    *
+    * Counterpart to Solidity's `uint32` operator.
+    *
+    * Requirements:
+    * - input must fit into 32 bits
+    */
+  function toUint32(uint256 value) internal pure returns (uint32) {
+    require(value < 2**32, "SafeCast: value doesn\'t fit in 32 bits");
+    return uint32(value);
+  }
+
+  /**
+    * @dev Returns the downcasted uint16 from uint256, reverting on
+    * overflow (when the input is greater than largest uint16).
+    *
+    * Counterpart to Solidity's `uint16` operator.
+    *
+    * Requirements:
+    * - input must fit into 16 bits
+    */
+  function toUint16(uint256 value) internal pure returns (uint16) {
+    require(value < 2**16, "SafeCast: value doesn\'t fit in 16 bits");
+    return uint16(value);
+  }
+
+  /**
+    * @dev Returns the downcasted uint8 from uint256, reverting on
+    * overflow (when the input is greater than largest uint8).
+    *
+    * Counterpart to Solidity's `uint8` operator.
+    *
+    * Requirements:
+    * - input must fit into 8 bits.
+    */
+  function toUint8(uint256 value) internal pure returns (uint8) {
+    require(value < 2**8, "SafeCast: value doesn\'t fit in 8 bits");
+    return uint8(value);
+  }
+}

packages/protocol/contracts/common/SafeCastTest.sol

@@ -0,0 +1,30 @@
+
+pragma solidity ^0.5.0;
+// TODO: Remove this and use upstream when
+// https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1926/files gets merged
+
+import "./SafeCast.sol";
+
+contract SafeCastTest {
+  using SafeCast for uint;
+
+  function toUint128(uint a) public pure returns (uint128) {
+    return a.toUint128();
+  }
+
+  function toUint64(uint a) public pure returns (uint64) {
+    return a.toUint64();
+  }
+
+  function toUint32(uint a) public pure returns (uint32) {
+    return a.toUint32();
+  }
+
+  function toUint16(uint a) public pure returns (uint16) {
+    return a.toUint16();
+  }
+
+  function toUint8(uint a) public pure returns (uint8) {
+    return a.toUint8();
+  }
+}

packages/protocol/contracts/governance/Election.sol

@@ -909,7 +909,7 @@ contract Election is
    * @return The permuted array.
    */
   function shuffleArray(address[] memory array) private view returns (address[] memory) {
-    bytes32 r = getRandom().random();
+    bytes32 r = getRandom().getBlockRandomness(block.number);
     for (uint256 i = array.length - 1; i > 0; i = i.sub(1)) {
       uint256 j = uint256(r) % (i + 1);
       (array[i], array[j]) = (array[j], array[i]);