cEUR ContractKit support

packages/dev-utils/src/migration-override.json

@@ -9,6 +9,10 @@
     "frozen": false,
     "minimumReports": 1
   },
+  "exchangeEUR": {
+    "frozen": false,
+    "minimumReports": 1
+  },
   "goldToken": {
     "frozen": false
   },
@@ -63,6 +67,30 @@
     ],
     "frozen": false
   },
+  "stableTokenEUR": {
+    "goldPrice": 1,
+    "initialBalances": {
+      "addresses": [
+        "0x5409ED021D9299bf6814279A6A1411A7e866A631",
+        "0x6Ecbe1DB9EF729CBe972C83Fb886247691Fb6beb",
+        "0xE36Ea790bc9d7AB70C55260C66D52b1eca985f84",
+        "0xE834EC434DABA538cd1b9Fe1582052B880BD7e63"
+      ],
+      "values": [
+        "50000000000000000000000",
+        "50000000000000000000000",
+        "50000000000000000000000",
+        "50000000000000000000000"
+      ]
+    },
+    "oracles": [
+      "0x5409ED021D9299bf6814279A6A1411A7e866A631",
+      "0xE36Ea790bc9d7AB70C55260C66D52b1eca985f84",
+      "0x06cEf8E666768cC40Cc78CF93d9611019dDcB628",
+      "0x7457d5E02197480Db681D3fdF256c7acA21bDc12"
+    ],
+    "frozen": false
+  },
   "validators": {
     "commissionUpdateDelay": 3
   }

packages/protocol/package.json

@@ -92,7 +92,7 @@
   "devDependencies": {
     "@celo/flake-tracker": "0.0.1-dev",
     "@celo/typescript": "0.0.1",
-    "@celo/typechain-target-web3-v1-celo": "0.1.0-beta3",
+    "@celo/typechain-target-web3-v1-celo": "0.2.0",
     "@types/bn.js": "^4.11.0",
     "@types/chai": "^4.1.3",
     "@types/mathjs": "^4.4.1",

packages/protocol/scripts/build.ts

@@ -18,6 +18,7 @@ export const ProxyContracts = [
   'ElectionProxy',
   'EpochRewardsProxy',
   'EscrowProxy',
+  'ExchangeEURProxy',
   'ExchangeProxy',
   'FeeCurrencyWhitelistProxy',
   'GasPriceMinimumProxy',
@@ -30,6 +31,7 @@ export const ProxyContracts = [
   'RegistryProxy',
   'ReserveProxy',
   'ReserveSpenderMultiSigProxy',
+  'StableTokenEURProxy',
   'StableTokenProxy',
   'SortedOraclesProxy',
 ]
@@ -66,9 +68,11 @@ export const CoreContracts = [
 
   // stability
   'Exchange',
+  'ExchangeEUR',
   'Reserve',
   'ReserveSpenderMultiSig',
   'StableToken',
+  'StableTokenEUR',
   'SortedOracles',
 ]
 
@@ -79,6 +83,9 @@ const OtherContracts = [
   'Initializable',
   'UsingRegistry',
 ]
+
+const Interfaces = ['ICeloToken', 'IERC20']
+
 export const ImplContracts = OtherContracts.concat(ProxyContracts).concat(CoreContracts)
 
 // const TruffleTestContracts = ['Ownable'].concat(OtherContracts).concat(CoreContracts)
@@ -128,7 +135,7 @@ async function generateFilesForContractKit() {
   exec(`rm -rf ${CONTRACTKIT_GEN_DIR}`)
   const relativePath = path.relative(ROOT_DIR, CONTRACTKIT_GEN_DIR)
 
-  const contractKitContracts = CoreContracts.concat('Proxy')
+  const contractKitContracts = CoreContracts.concat('Proxy').concat(Interfaces)
 
   const globPattern = `${BUILD_DIR}/contracts/@(${contractKitContracts.join('|')}).json`
 

packages/sdk/contractkit/src/base.ts

@@ -8,6 +8,7 @@ export enum CeloContract {
   EpochRewards = 'EpochRewards',
   Escrow = 'Escrow',
   Exchange = 'Exchange',
+  ExchangeEUR = 'ExchangeEUR',
   FeeCurrencyWhitelist = 'FeeCurrencyWhitelist',
   Freezer = 'Freezer',
   GasPriceMinimum = 'GasPriceMinimum',
@@ -22,13 +23,23 @@ export enum CeloContract {
   Reserve = 'Reserve',
   SortedOracles = 'SortedOracles',
   StableToken = 'StableToken',
+  StableTokenEUR = 'StableTokenEUR',
   TransferWhitelist = 'TransferWhitelist',
   Validators = 'Validators',
 }
 
 export const ProxyContracts = Object.keys(CeloContract).map((c) => `${c}Proxy`)
 
-export type CeloToken = CeloContract.GoldToken | CeloContract.StableToken
+export type StableTokenContract = CeloContract.StableToken | CeloContract.StableTokenEUR
+
+export type ExchangeContract = CeloContract.Exchange | CeloContract.ExchangeEUR
+
+export type CeloTokenContract = StableTokenContract | CeloContract.GoldToken
+/**
+ * Deprecated alias for CeloTokenContract.
+ * @deprecated Use CeloTokenContract instead
+ */
+export type CeloToken = CeloTokenContract
 
 export const AllContracts = Object.keys(CeloContract) as CeloContract[]
 const AuxiliaryContracts = [

packages/sdk/contractkit/src/celo-tokens.test.ts

@@ -0,0 +1,52 @@
+import Web3 from 'web3'
+import { CeloContract } from './base'
+import { CeloTokenInfo, CeloTokens, StableToken, Token } from './celo-tokens'
+import { ContractKit, newKitFromWeb3 } from './kit'
+
+describe('CeloTokens', () => {
+  let kit: ContractKit
+  let celoTokens: CeloTokens
+
+  beforeEach(() => {
+    kit = newKitFromWeb3(new Web3('http://localhost:8545'))
+    celoTokens = kit.celoTokens
+  })
+
+  describe('forEachCeloToken()', () => {
+    it('returns an object with a key for each celo token and the value from a provided async fn', async () => {
+      const result = await celoTokens.forEachCeloToken(async (info: CeloTokenInfo) =>
+        Promise.resolve(info.symbol)
+      )
+      for (const [key, value] of Object.entries(result)) {
+        expect(key).toEqual(value)
+      }
+    })
+
+    it('returns an object with a key for each celo token and the value from a provided non-async fn', async () => {
+      const result = await celoTokens.forEachCeloToken(async (info: CeloTokenInfo) => info.symbol)
+      for (const [key, value] of Object.entries(result)) {
+        expect(key).toEqual(value)
+      }
+    })
+  })
+
+  describe('isStableToken()', () => {
+    it('returns true if the token is a stable token', () => {
+      expect(celoTokens.isStableToken(StableToken.cUSD)).toEqual(true)
+    })
+
+    it('returns false if the token is not a stable token', () => {
+      expect(celoTokens.isStableToken(Token.CELO)).toEqual(false)
+    })
+  })
+
+  describe('isStableTokenContract()', () => {
+    it('returns true if the contract is a stable token contract', () => {
+      expect(celoTokens.isStableTokenContract(CeloContract.StableToken)).toEqual(true)
+    })
+
+    it('returns false if the contract is not a stable token contract', () => {
+      expect(celoTokens.isStableTokenContract(CeloContract.Exchange)).toEqual(false)
+    })
+  })
+})

packages/sdk/contractkit/src/celo-tokens.ts

@@ -0,0 +1,201 @@
+import { BigNumber } from 'bignumber.js'
+import { CeloContract, CeloTokenContract, ExchangeContract, StableTokenContract } from './base'
+import { ContractKit } from './kit'
+import { GoldTokenWrapper } from './wrappers/GoldTokenWrapper'
+import { StableTokenWrapper } from './wrappers/StableTokenWrapper'
+
+export enum StableToken {
+  cUSD = 'cUSD',
+  cEUR = 'cEUR',
+}
+
+export enum Token {
+  CELO = 'CELO',
+}
+
+export type CeloToken = StableToken | Token
+
+type CeloTokenWrapper = GoldTokenWrapper | StableTokenWrapper
+
+export type EachCeloToken<T> = {
+  [key in CeloToken]: T
+}
+
+export interface CeloTokenInfo {
+  contract: CeloTokenContract
+  symbol: CeloToken
+}
+
+export interface StableTokenInfo extends CeloTokenInfo {
+  contract: StableTokenContract
+  exchangeContract: ExchangeContract
+}
+
+/** Basic info for each stable token */
+const stableTokenInfos: {
+  [key in StableToken]: StableTokenInfo
+} = {
+  [StableToken.cUSD]: {
+    contract: CeloContract.StableToken,
+    exchangeContract: CeloContract.Exchange,
+    symbol: StableToken.cUSD,
+  },
+  [StableToken.cEUR]: {
+    contract: CeloContract.StableTokenEUR,
+    exchangeContract: CeloContract.ExchangeEUR,
+    symbol: StableToken.cEUR,
+  },
+}
+
+/** Basic info for each supported celo token, including stable tokens */
+const celoTokenInfos: {
+  [key in CeloToken]: CeloTokenInfo
+} = {
+  [Token.CELO]: {
+    contract: CeloContract.GoldToken,
+    symbol: Token.CELO,
+  },
+  ...stableTokenInfos,
+}
+
+/**
+ * A helper class to interact with all Celo tokens, ie CELO and stable tokens
+ */
+export class CeloTokens {
+  constructor(readonly kit: ContractKit) {}
+
+  /**
+   * Gets an address's balance for each celo token.
+   * @param address the address to look up the balances for
+   * @return a promise resolving to an object containing the address's balance
+   *  for each celo token
+   */
+  balancesOf(address: string): Promise<EachCeloToken<BigNumber>> {
+    return this.forEachCeloToken(async (info: CeloTokenInfo) => {
+      const wrapper = await this.kit.contracts.getContract(info.contract)
+      return wrapper.balanceOf(address)
+    })
+  }
+
+  /**
+   * Gets the wrapper for each celo token.
+   * @return an promise resolving to an object containing the wrapper for each celo token.
+   */
+  getWrappers(): Promise<EachCeloToken<CeloTokenWrapper>> {
+    return this.forEachCeloToken((info: CeloTokenInfo) =>
+      this.kit.contracts.getContract(info.contract)
+    )
+  }
+
+  /**
+   * Gets the address for each celo token proxy contract.
+   * @return an promise resolving to an object containing the address for each celo token proxy.
+   */
+  getAddresses(): Promise<EachCeloToken<string>> {
+    return this.forEachCeloToken((info: CeloTokenInfo) =>
+      this.kit.registry.addressFor(info.contract)
+    )
+  }
+
+  /**
+   * Runs fn for each celo token found in celoTokenInfos, and returns the
+   * value of each call in an object keyed by the token.
+   * @param fn the function to be called for each CeloTokenInfo.
+   * @return an object containing the resolved value the call to fn for each
+   *  celo token.
+   */
+  async forEachCeloToken<T>(
+    fn: (info: CeloTokenInfo) => T | Promise<T>
+  ): Promise<EachCeloToken<T>> {
+    const wrapperInfos = await Promise.all(
+      Object.values(celoTokenInfos).map(async (info: CeloTokenInfo) => {
+        const fnResult = fn(info)
+        return {
+          symbol: info.symbol,
+          data: fnResult instanceof Promise ? await fnResult : fnResult,
+        }
+      })
+    )
+    return wrapperInfos.reduce(
+      (
+        obj: {
+          [key in CeloToken]?: T
+        },
+        wrapperInfo
+      ) => ({
+        ...obj,
+        [wrapperInfo.symbol]: wrapperInfo.data,
+      }),
+      {}
+    ) as EachCeloToken<T>
+  }
+
+  /**
+   * Gets the wrapper for a given celo token.
+   * @param token the token to get the appropriate wrapper for
+   * @return an promise resolving to the wrapper for the token
+   */
+  getWrapper(token: StableToken): Promise<StableTokenWrapper>
+  getWrapper(token: CeloToken): Promise<CeloTokenWrapper> {
+    return this.kit.contracts.getContract(celoTokenInfos[token].contract)
+  }
+
+  /**
+   * Gets the contract for the provided token
+   * @param token the token to get the contract of
+   * @return The contract for the token
+   */
+  getContract(token: StableToken): StableTokenContract
+  getContract(token: CeloToken): CeloTokenContract {
+    return celoTokenInfos[token].contract
+  }
+
+  /**
+   * Gets the exchange contract for the provided stable token
+   * @param token the stable token to get exchange contract of
+   * @return The exchange contract for the token
+   */
+  getExchangeContract(token: StableToken) {
+    return stableTokenInfos[token].exchangeContract
+  }
+
+  /**
+   * Gets the address of the contract for the provided token.
+   * @param token the token to get the (proxy) contract address for
+   * @return A promise resolving to the address of the token's contract
+   */
+  getAddress(token: CeloToken) {
+    return this.kit.registry.addressFor(celoTokenInfos[token].contract)
+  }
+
+  /**
+   * Gets the address to use as the feeCurrency when paying for gas with the
+   *  provided token.
+   * @param token the token to get the feeCurrency address for
+   * @return If not CELO, the address of the token's contract. If CELO, undefined.
+   */
+  getFeeCurrencyAddress(token: CeloToken) {
+    if (token === Token.CELO) {
+      return undefined
+    }
+    return this.getAddress(token)
+  }
+
+  /**
+   * Returns if the provided token is a StableToken
+   * @param token the token
+   * @return if token is a StableToken
+   */
+  isStableToken(token: CeloToken) {
+    // We cast token as StableToken to make typescript happy
+    return Object.values(StableToken).includes(token as StableToken)
+  }
+
+  isStableTokenContract(contract: CeloContract) {
+    const allStableTokenContracts = Object.values(StableToken).map(
+      (token) => stableTokenInfos[token].contract
+    )
+    // We cast token as StableTokenContract to make typescript happy
+    return allStableTokenContracts.includes(contract as StableTokenContract)
+  }
+}

packages/sdk/contractkit/src/contract-cache.test.ts

@@ -6,7 +6,9 @@ import { newKitFromWeb3 } from './kit'
 const TestedWrappers: ValidWrappers[] = [
   CeloContract.GoldToken,
   CeloContract.StableToken,
+  CeloContract.StableTokenEUR,
   CeloContract.Exchange,
+  CeloContract.ExchangeEUR,
   CeloContract.Validators,
   CeloContract.LockedGold,
 ]