Support governance proposals/hotfixes in contractkit

packages/contractkit/src/explorer/base.ts

@@ -1,6 +1,7 @@
 import { Address } from '@celo/utils/lib/address'
 import { concurrentMap } from '@celo/utils/lib/async'
 import { ABIDefinition } from 'web3/eth/abi'
+import { Block, Transaction } from 'web3/eth/types'
 import { AllContracts } from '../base'
 import { ContractKit } from '../kit'
 
@@ -10,6 +11,23 @@ export interface ContractDetails {
   jsonInterface: ABIDefinition[]
 }
 
+export interface CallDetails {
+  contract: string
+  function: string
+  parameters: Record<string, any>
+  args: any[]
+}
+
+export interface ParsedTx {
+  callDetails: CallDetails
+  tx: Transaction
+}
+
+export interface ParsedBlock {
+  block: Block
+  parsedTx: ParsedTx[]
+}
+
 export async function obtainKitContractDetails(kit: ContractKit) {
   return concurrentMap(5, AllContracts, async (celoContract) => {
     const contract = await kit._web3Contracts.getContract(celoContract)

packages/contractkit/src/explorer/block-explorer.ts

@@ -2,23 +2,14 @@ import { Address } from '@celo/utils/lib/address'
 import abi, { ABIDefinition } from 'web3-eth-abi'
 import { Block, Transaction } from 'web3/eth/types'
 import { ContractKit } from '../kit'
-import { ContractDetails, mapFromPairs, obtainKitContractDetails } from './base'
-
-export interface CallDetails {
-  contract: string
-  function: string
-  parameters: Record<string, any>
-}
-
-export interface ParsedTx {
-  callDetails: CallDetails
-  tx: Transaction
-}
-
-export interface ParsedBlock {
-  block: Block
-  parsedTx: ParsedTx[]
-}
+import {
+  CallDetails,
+  ContractDetails,
+  mapFromPairs,
+  obtainKitContractDetails,
+  ParsedBlock,
+  ParsedTx,
+} from './base'
 
 interface ContractMapping {
   details: ContractDetails
@@ -93,23 +84,23 @@ export class BlockExplorer {
       return null
     }
 
-    const parameters: Record<string, any> = abi.decodeParameters(
-      matchedAbi.inputs!,
-      encodedParameters
-    )
+    const parameters = abi.decodeParameters(matchedAbi.inputs!, encodedParameters)
 
-    // remove number & number keys
+    // build args from number keys
+    // remove number keys from parameters
+    const argKeys = Array.from(Array(parameters.__length__).keys())
     delete parameters.__length__
-    Object.keys(parameters).forEach((key) => {
-      if (Number.parseInt(key, 10) >= 0) {
-        delete parameters[key]
-      }
+    const args = argKeys.map((argKey) => {
+      const arg = parameters[argKey]
+      delete parameters[argKey]
+      return arg
     })
 
     const callDetails: CallDetails = {
       contract: contractMapping.details.name,
       function: matchedAbi.name!,
       parameters,
+      args,
     }
 
     return {

packages/contractkit/src/explorer/log-explorer.ts

@@ -1,26 +1,9 @@
 import { Address } from '@celo/utils/lib/address'
 import abi, { ABIDefinition } from 'web3-eth-abi'
-import { Block, Transaction } from 'web3/eth/types'
 import { EventLog, Log, TransactionReceipt } from 'web3/types'
 import { ContractKit } from '../kit'
 import { ContractDetails, mapFromPairs, obtainKitContractDetails } from './base'
 
-export interface CallDetails {
-  contract: string
-  function: string
-  parameters: Record<string, any>
-}
-
-export interface ParsedTx {
-  callDetails: CallDetails
-  tx: Transaction
-}
-
-export interface ParsedBlock {
-  block: Block
-  parsedTx: ParsedTx[]
-}
-
 interface ContractMapping {
   details: ContractDetails
   logMapping: Map<string, ABIDefinition>

packages/contractkit/src/governance/index.ts

@@ -0,0 +1 @@
+export * from './proposals'

packages/contractkit/src/governance/proposals.ts

@@ -0,0 +1,96 @@
+import { concurrentMap } from '@celo/utils/lib/async'
+import { keccak256 } from 'ethereumjs-util'
+import Contract from 'web3/eth/contract'
+import { Transaction, TransactionObject } from 'web3/eth/types'
+import { AllContracts, CeloContract } from '../base'
+import { obtainKitContractDetails } from '../explorer/base'
+import { BlockExplorer } from '../explorer/block-explorer'
+import { ContractKit } from '../kit'
+import { CeloTransactionObject, valueToString } from '../wrappers/BaseWrapper'
+import { Proposal, ProposalTransaction } from '../wrappers/Governance'
+
+export interface ProposalTransactionJSON {
+  contract: CeloContract
+  function: string
+  args: any[]
+  value: string
+}
+
+export class ProposalUtility extends Proposal {
+  constructor(transactions: ProposalTransaction[], private readonly kit: ContractKit) {
+    super(transactions)
+  }
+
+  static fromProposalAndKit(proposal: Proposal, kit: ContractKit) {
+    return new ProposalUtility(proposal.transactions, kit)
+  }
+
+  get hash(): Buffer {
+    const paramsEncoded = this.kit.web3.eth.abi.encodeParameters(
+      ['uint256[]', 'address[]', 'bytes', 'uint256[]'],
+      this.params
+    )
+    return keccak256(paramsEncoded) as Buffer
+  }
+
+  async json(): Promise<ProposalTransactionJSON[]> {
+    const contractDetails = await obtainKitContractDetails(this.kit)
+    const blockExplorer = new BlockExplorer(this.kit, contractDetails)
+
+    return concurrentMap(1, this.transactions, async (transaction) => {
+      const parsedTx = blockExplorer.tryParseTx(transaction as Transaction)
+      if (parsedTx == null) {
+        throw new Error(`Unable to parse ${transaction} with block explorer`)
+      }
+      return {
+        contract: parsedTx.callDetails.contract as CeloContract,
+        function: parsedTx.callDetails.function,
+        args: parsedTx.callDetails.args,
+        value: parsedTx.tx.value,
+      }
+    })
+  }
+}
+
+type ProposalTxParams = Pick<ProposalTransaction, 'to' | 'value'>
+export function proposalTxFromWeb3Txo(
+  tx: TransactionObject<any>,
+  params: Required<ProposalTxParams>
+): ProposalTransaction {
+  return {
+    value: params.value,
+    to: params.to,
+    input: tx.encodeABI(),
+  }
+}
+
+export function proposalTxFromCeloTxo(
+  tx: CeloTransactionObject<any>,
+  params: Partial<ProposalTxParams> = {}
+) {
+  const to = tx.defaultParams && tx.defaultParams.to ? tx.defaultParams.to : params.to
+  const value = tx.defaultParams && tx.defaultParams.value ? tx.defaultParams.value : params.value
+  if (!to || !value) {
+    throw new Error("Transaction parameters 'to' and/or 'value' not provided")
+  }
+  return proposalTxFromWeb3Txo(tx.txo, { to, value: valueToString(value) })
+}
+
+export async function proposalTxFromJSONAndKit(tx: ProposalTransactionJSON, kit: ContractKit) {
+  const contractName = tx.contract
+  if (!AllContracts.includes(contractName)) {
+    throw new Error(`Contract ${contractName} not found`)
+  }
+
+  const contract = await kit._web3Contracts.getContract(contractName)
+  const methodName = tx.function
+  const method = (contract.methods as Contract['methods'])[methodName]
+  if (!method) {
+    throw new Error(`Method ${methodName} not found on ${contractName}`)
+  }
+  const txo = method(tx.args)
+  if (!txo) {
+    throw new Error(`Arguments ${tx.args} did not match ${methodName} signature`)
+  }
+  return proposalTxFromWeb3Txo(txo, { to: contract._address, value: tx.value })
+}

packages/contractkit/src/test-utils/ganache-test.ts

@@ -38,6 +38,10 @@ export function jsonRpcCall<O>(web3: Web3, method: string, params: any[]): Promi
     )
   })
 }
+export async function timeTravel(seconds: number, web3: Web3) {
+  await jsonRpcCall(web3, 'evm_increaseTime', [seconds])
+  await jsonRpcCall(web3, 'evm_mine', [])
+}
 
 export function evmRevert(web3: Web3, snapId: string): Promise<void> {
   return jsonRpcCall(web3, 'evm_revert', [snapId])

packages/contractkit/src/test-utils/migration-override.json

@@ -1,14 +1,53 @@
 {
   "stableToken": {
     "initialBalances": {
-      "addresses": ["0x5409ed021d9299bf6814279a6a1411a7e866a631"],
-      "values": ["10000000000000000000000"]
+      "addresses": [
+        "0x5409ED021D9299bf6814279A6A1411A7e866A631",
+        "0x6Ecbe1DB9EF729CBe972C83Fb886247691Fb6beb",
+        "0xE36Ea790bc9d7AB70C55260C66D52b1eca985f84",
+        "0xE834EC434DABA538cd1b9Fe1582052B880BD7e63",
+        "0x78dc5D2D739606d31509C31d654056A45185ECb6",
+        "0xA8dDa8d7F5310E4A9E24F8eBA77E091Ac264f872",
+        "0x06cEf8E666768cC40Cc78CF93d9611019dDcB628",
+        "0x4404ac8bd8F9618D27Ad2f1485AA1B2cFD82482D",
+        "0x7457d5E02197480Db681D3fdF256c7acA21bDc12",
+        "0x91c987bf62D25945dB517BDAa840A6c661374402"
+      ],
+      "values": [
+        "50000000000000000000000",
+        "50000000000000000000000",
+        "50000000000000000000000",
+        "50000000000000000000000",
+        "50000000000000000000000",
+        "50000000000000000000000",
+        "50000000000000000000000",
+        "50000000000000000000000",
+        "50000000000000000000000",
+        "50000000000000000000000"
+      ]
     },
     "oracles": [
       "0x5409ED021D9299bf6814279A6A1411A7e866A631",
       "0xE36Ea790bc9d7AB70C55260C66D52b1eca985f84",
       "0x06cEf8E666768cC40Cc78CF93d9611019dDcB628",
       "0x7457d5E02197480Db681D3fdF256c7acA21bDc12"
     ]
+  },
+  "validators": {
+    "validatorKeys": [
+      "0x83c6d2cc5ddcf9711a6d59b417dc20eb48afd58d45290099e5987e3d768f328f",
+      "0xbb2d3f7c9583780a7d3904a2f55d792707c345f21de1bacb2d389934d82796b2",
+      "0xb2fd4d29c1390b71b8795ae81196bfd60293adf99f9d32a0aff06288fcdac55f",
+      "0x23cb7121166b9a2f93ae0b7c05bde02eae50d64449b2cbb42bc84e9d38d6cc89"
+    ]
+  },
+  "governance": {
+    "dequeueFrequency": 30,
+    "queueExpiry": 101,
+    "approvalStageDuration": 103,
+    "referendumStageDuration": 104,
+    "executionStageDuration": 105,
+    "concurrentProposals": 2,
+    "minDeposit": 1
   }
 }

packages/contractkit/src/wrappers/Attestations.ts

@@ -11,11 +11,12 @@ import { ClaimTypes, IdentityMetadataWrapper } from '../identity'
 import {
   BaseWrapper,
   proxyCall,
-  toBigNumber,
-  toNumber,
   toTransactionObject,
   tupleParser,
+  valueToBigNumber,
+  valueToInt,
 } from './BaseWrapper'
+
 const parseSignature = SignatureUtils.parseSignature
 
 export interface AttestationStat {
@@ -68,11 +69,11 @@ interface GetCompletableAttestationsResponse {
 }
 function parseGetCompletableAttestations(response: GetCompletableAttestationsResponse) {
   const metadataURLs = parseSolidityStringArray(
-    response[2].map(toNumber),
+    response[2].map(valueToInt),
     (response[3] as unknown) as string
   )
 
-  return zip3(response[0].map(toNumber), response[1], metadataURLs).map(
+  return zip3(response[0].map(valueToInt), response[1], metadataURLs).map(
     ([blockNumber, issuer, metadataURL]) => ({ blockNumber, issuer, metadataURL })
   )
 }
@@ -85,7 +86,7 @@ export class AttestationsWrapper extends BaseWrapper<Attestations> {
   attestationExpiryBlocks = proxyCall(
     this.contract.methods.attestationExpiryBlocks,
     undefined,
-    toNumber
+    valueToInt
   )
 
   /**
@@ -96,13 +97,13 @@ export class AttestationsWrapper extends BaseWrapper<Attestations> {
   attestationRequestFees = proxyCall(
     this.contract.methods.attestationRequestFees,
     undefined,
-    toBigNumber
+    valueToBigNumber
   )
 
   selectIssuersWaitBlocks = proxyCall(
     this.contract.methods.selectIssuersWaitBlocks,
     undefined,
-    toNumber
+    valueToInt
   )
 
   /**
@@ -114,8 +115,8 @@ export class AttestationsWrapper extends BaseWrapper<Attestations> {
     this.contract.methods.getUnselectedRequest,
     tupleParser(PhoneNumberUtils.getPhoneHash, (x: string) => x),
     (res) => ({
-      blockNumber: toNumber(res[0]),
-      attestationsRequested: toNumber(res[1]),
+      blockNumber: valueToInt(res[0]),
+      attestationsRequested: valueToInt(res[1]),
       attestationRequestFeeToken: res[2],
     })
   )
@@ -180,7 +181,7 @@ export class AttestationsWrapper extends BaseWrapper<Attestations> {
   ) => Promise<AttestationStat> = proxyCall(
     this.contract.methods.getAttestationStats,
     tupleParser(PhoneNumberUtils.getPhoneHash, stringIdentity),
-    (stat) => ({ completed: toNumber(stat[0]), total: toNumber(stat[1]) })
+    (stat) => ({ completed: valueToInt(stat[0]), total: valueToInt(stat[1]) })
   )
 
   /**
@@ -314,11 +315,10 @@ export class AttestationsWrapper extends BaseWrapper<Attestations> {
     // Unfortunately can't be destructured
     const stats = await this.contract.methods.batchGetAttestationStats(phoneNumberHashes).call()
 
-    const toNum = (n: string) => new BigNumber(n).toNumber()
-    const matches = stats[0].map(toNum)
+    const matches = stats[0].map(valueToInt)
     const addresses = stats[1]
-    const completed = stats[2].map(toNum)
-    const total = stats[3].map(toNum)
+    const completed = stats[2].map(valueToInt)
+    const total = stats[3].map(valueToInt)
     // Map of phone hash -> (Map of address -> AttestationStat)
     const result: Record<string, Record<string, AttestationStat>> = {}