Merge pull request #53 from gnosis/refactor/dutchX

Refactor/dutch x

Author: Velenir

package.json

@@ -64,6 +64,7 @@
     ]
   },
   "dependencies": {
+    "@types/bignumber.js": "^4.0.3",
     "autobind-decorator": "^2.1.0",
     "await-delay": "^1.0.0",
     "babel-polyfill": "^6.23.0",

src/actions/balance.ts

@@ -1,19 +1,15 @@
 /* eslint no-console: 0 */
 // import thunk from 'redux-thunk'
 import { createAction } from 'redux-actions'
-import { getDutchXConnection } from '../api/dutchx'
+import { getCurrentBalance } from '../api'
 
 export const getBalanceBase: Function = createAction('GET_CONTRACT_BALANCE')
 
-export const getBalance = (contract: string, address: string) => async (dispatch: Function) => {
+export const getBalance = (address: string) => async (dispatch: Function) => {
   // console.log(contract)
-  let inst
-  let dutchX
 
   try {
-    dutchX = await getDutchXConnection()
-    inst = await dutchX[contract]
-    const reqBalance = await inst.getBalance.call(address)
+    const reqBalance = (await getCurrentBalance(address)).toString()
     console.log(`Success! Balance for ${address} = `, reqBalance)
     dispatch(getBalanceBase({ success: true, reqBalance }))
   } catch (err) {

src/actions/blockchain.ts

@@ -2,24 +2,27 @@
 import {
   getCurrentBalance,
   getCurrentAccount,
-  initDutchXConnection,
+  // initDutchXConnection,
   getTokenBalances,
   // tokenPairSelect,
   postSellOrder,
   closingPrice,
-} from 'api/dutchx'
+} from 'api'
 
 import { setClosingPrice } from 'actions/ratioPairs'
 import { setTokenBalance } from 'actions/tokenBalances'
 import { setSellTokenAmount } from 'actions/tokenPair'
 
-import { timeoutCondition, getDutchXOptions } from '../utils/helpers'
+import {
+  timeoutCondition,
+  // getDutchXOptions,
+} from '../utils/helpers'
 // import { GAS_COST } from 'utils/constants'
 import { createAction } from 'redux-actions'
 import { push } from 'connected-react-router'
 import { findDefaultProvider } from 'selectors/blockchain'
 
-import { TokenBalances } from 'types'
+import { TokenBalances, Account, Balance, TokenCode } from 'types'
 
 export enum TypeKeys {
   SET_GNOSIS_CONNECTION = 'SET_GNOSIS_CONNECTION',
@@ -39,7 +42,7 @@ export const setConnectionStatus = createAction<{ connected?: boolean }>('SET_CO
 export const setActiveProvider = createAction<{ provider?: string }>('SET_ACTIVE_PROVIDER')
 export const registerProvider = createAction<{ provider?: string, data?: Object }>('REGISTER_PROVIDER')
 export const updateProvider = createAction<{ provider?: string, data?: Object }>('UPDATE_PROVIDER')
-export const setCurrentBalance = createAction<{ provider?: string, currentBalance?: number }>('SET_CURRENT_BALANCE')
+export const setCurrentBalance = createAction<{ provider?: string, currentBalance?: Balance }>('SET_CURRENT_BALANCE')
 export const setCurrentAccountAddress =
   createAction<{ provider?: string, currentAccount?: Object }>('SET_CURRENT_ACCOUNT_ADDRESS')
 export const fetchTokens = createAction<{ tokens?: TokenBalances }>('FETCH_TOKENS')
@@ -59,13 +62,13 @@ export const initDutchX = () => async (dispatch: Function, getState: any) => {
     const state = getState()
 
     // determine new provider
-    const newProvider = findDefaultProvider(state)
+    const newProvider: any = findDefaultProvider(state)
     if (newProvider) {
       await dispatch(setActiveProvider(newProvider.name))
 
       // init DutchX connection
-      const opts = getDutchXOptions(newProvider)
-      await initDutchXConnection(opts)
+      // const opts = getDutchXOptions(newProvider)
+      // await initDutchXConnection(opts)
       dispatch(setDutchXInitialized({ initialized: true }))
       // await requestEtherTokens()
     }
@@ -76,16 +79,19 @@ export const initDutchX = () => async (dispatch: Function, getState: any) => {
 
   // connect
   try {
-    let account: any
-    let currentBalance: any
-    let tokenBalance: any
+    let account: Account
+    let currentBalance: Balance
+    let tokenBalances: { name: TokenCode, balance: Balance }[]
 
     // runs test executions on gnosisjs
     const getConnection = async () => {
       try {
         account = await getCurrentAccount()
-        currentBalance = await getCurrentBalance(account)
-        tokenBalance = await getTokenBalances(account)
+        currentBalance = (await getCurrentBalance(account)).toString()
+        // TODO: pass a list of tokens from state or globals, for now ['ETH', 'GNO'] is default
+        tokenBalances = (await getTokenBalances(undefined, account))
+          .map(({ name, balance }) => ({ name, balance: balance.toString() }))
+        console.log(tokenBalances)
         await dispatch(getClosingPrice())
       } catch (e) {
         console.log(e)
@@ -98,7 +104,7 @@ export const initDutchX = () => async (dispatch: Function, getState: any) => {
     await dispatch(setCurrentBalance({ currentBalance }))
 
     // Grab each TokenBalance and dispatch
-    tokenBalance.forEach(async (token: any) =>
+    tokenBalances.forEach(async token =>
       await dispatch(setTokenBalance({ tokenName: token.name, balance: token.balance })))
 
     return dispatch(setConnectionStatus({ connected: true }))
@@ -132,12 +138,12 @@ export const submitSellOrder = (proceedTo: string) => async (dispatch: Function,
 
     console.log('Submit order receipt', receipt)
 
-    // TODO: function to get specific Token's balance, also actions for such functions
-    const tokenBalances = await getTokenBalances(currentAccount)
+    // TODO: pass a list of tokens from state or globals, for now ['ETH', 'GNO'] is default
+    const tokenBalances = await getTokenBalances(undefined, currentAccount)
     const { name, balance } = tokenBalances.find(({ name }) => name === sell)
 
     // new balance for the token just sold
-    dispatch(setTokenBalance({ tokenName: name, balance }))
+    dispatch(setTokenBalance({ tokenName: name, balance: balance.toString() }))
 
     // proceed to /auction/0x03494929349594
     dispatch(push(proceedTo))

src/actions/tokenOverlay.ts

@@ -1,7 +1,7 @@
 import { createAction } from 'redux-actions'
 import { TokenMod, TokenCode, TokenPair } from 'types'
 
-import { closingPrice } from 'api/dutchx' 
+import { closingPrice } from 'api/'
 import { setClosingPrice } from 'actions/ratioPairs'
 
 export const openOverlay = createAction<{ mod: TokenMod }>('OPEN_OVERLAY')
@@ -13,7 +13,7 @@ export const selectTokenPairAndRatioPair = (props: any) => async (dispatch: Func
   const { tokenPair } = getState()
   const { code, mod } = props
   const { sell, buy }: TokenPair = { ...tokenPair, [mod]: code }
-  
+
   try {
     const price = (await closingPrice(sell, buy)).toString()
 

src/actions/tokenPair.ts

@@ -1,7 +1,7 @@
 import { createAction } from 'redux-actions'
 import { TokenPair } from 'types'
 
-import { closingPrice } from 'api/dutchx'
+import { closingPrice } from 'api/'
 import { setClosingPrice } from 'actions/ratioPairs'
 
 export const selectTokenPair = createAction<TokenPair>('SELECT_TOKEN_PAIR')

src/api/DutchX.ts

@@ -0,0 +1,124 @@
+import { promisedContractsMap } from './contracts'
+import { promisedWeb3 } from './web3Provider'
+import { DutchExchange } from './types'
+import { TokenPair, Account, Balance } from 'types'
+
+export const promisedDutchX = init()
+
+const getCurrentAccount = async () => {
+  const web3 = await promisedWeb3
+
+  return web3.getCurrentAccount()
+}
+
+async function init(): Promise<DutchExchange> {
+  const contractsMap = await promisedContractsMap
+
+  const getExchange = ({ sell, buy }: TokenPair) => {
+    const exchange = contractsMap[`DutchExchange${sell}${buy}`]
+
+    if (!exchange) throw new Error(`No DutchExchange contract for ${sell}->${buy} token pair`)
+
+    return exchange
+  }
+
+  const fillDefaultIndexAndAccount = (pair: TokenPair, index: number, account: Account) => Promise.all([
+    index === undefined ? getAuctionIndex(pair) : index,
+    account === undefined ? getCurrentAccount() : account,
+  ])
+
+  const getAddress = (pair: TokenPair) => getExchange(pair).address
+
+  const getAuctionIndex = async (pair: TokenPair) => getExchange(pair).auctionIndex()
+
+  const getAuctionStart = async (pair: TokenPair) => getExchange(pair).auctionStart()
+
+  const getClosingPrice = async (pair: TokenPair, index?: number) => {
+    if (index === undefined) index = await getAuctionIndex(pair) - 1
+
+    return getExchange(pair).closingPrices(index)
+  }
+
+  const getPrice = async (pair: TokenPair, index?: number) => {
+    if (index === undefined) index = await getAuctionIndex(pair)
+
+    return getExchange(pair).getPrice(index)
+  }
+
+  const getSellVolumeCurrent = async (pair: TokenPair) => getExchange(pair).sellVolumeCurrent()
+
+  const getSellVolumeNext = (pair: TokenPair) => getExchange(pair).sellVolumeNext()
+
+  const getBuyVolume = async (pair: TokenPair, index?: number) => {
+    if (index === undefined) index = await getAuctionIndex(pair)
+
+    return getExchange(pair).buyVolumes(index)
+  }
+
+  const getSellerBalance = async (pair: TokenPair, index?: number, account?: Account) => {
+    [index, account] = await fillDefaultIndexAndAccount(pair, index, account)
+
+    return getExchange(pair).sellerBalances(index, account)
+  }
+
+  const getBuyerBalance = async (pair: TokenPair, index?: number, account?: Account) => {
+    [index, account] = await fillDefaultIndexAndAccount(pair, index, account)
+
+    return getExchange(pair).buyerBalances(index, account)
+  }
+
+  const getClaimedAmount = async (pair: TokenPair, index?: number, account?: Account) => {
+    [index, account] = await fillDefaultIndexAndAccount(pair, index, account)
+
+    return getExchange(pair).claimedAmounts(index, account)
+  }
+
+  const postSellOrder = async (pair: TokenPair, amount: Balance, account?: Account) => {
+    if (account === undefined) account = await getCurrentAccount()
+
+    return getExchange(pair).postSellOrder(amount, { from: account, gas: 4712388 })
+  }
+
+  const postBuyOrder = async (pair: TokenPair, amount: Balance, index?: number, account?: Account) => {
+    [index, account] = await fillDefaultIndexAndAccount(pair, index, account)
+
+    return getExchange(pair).postBuyOrder(amount, index, { from: account, gas: 4712388 })
+  }
+
+  const postBuyOrderAndClaim = async (pair: TokenPair, amount: Balance, index?: number, account?: Account) => {
+    [index, account] = await fillDefaultIndexAndAccount(pair, index, account)
+
+    return getExchange(pair).postBuyorderAndClaim(amount, index, { from: account, gas: 4712388 })
+  }
+
+  const claimSellerFunds = async (pair: TokenPair, index?: number, account?: Account) => {
+    [index, account] = await fillDefaultIndexAndAccount(pair, index, account)
+
+    return getExchange(pair).claimSellerFunds(index, { from: account })
+  }
+
+  const claimBuyerFunds = async (pair: TokenPair, index?: number, account?: Account) => {
+    [index, account] = await fillDefaultIndexAndAccount(pair, index, account)
+
+    return getExchange(pair).claimBuyerFunds(index, { from: account })
+  }
+
+  return {
+    getAddress,
+    getAuctionIndex,
+    getAuctionStart,
+    getClosingPrice,
+    getPrice,
+    getSellVolumeCurrent,
+    getSellVolumeNext,
+    getBuyVolume,
+    getSellerBalance,
+    getBuyerBalance,
+    getClaimedAmount,
+    postSellOrder,
+    postBuyOrder,
+    postBuyOrderAndClaim,
+    claimSellerFunds,
+    claimBuyerFunds,
+  }
+}

src/api/Tokens.ts

@@ -0,0 +1,43 @@
+import { TokensInterface, TransactionObject } from './types'
+import { Account, Balance, TokenCode } from 'types'
+import { promisedContractsMap } from './contracts'
+
+export const promisedTokens = init()
+
+async function init(): Promise<TokensInterface> {
+
+  const contractsMap = await promisedContractsMap
+
+  const getToken = (code: TokenCode) => {
+    const token = contractsMap[`Token${code}`]
+
+    if (!token) throw new Error(`No Token contract for ${code} token`)
+
+    return token
+  }
+
+  const getTokenBalance = async (code: TokenCode, account: Account) => getToken(code).balanceOf(account)
+
+  const getTotalSupply = async (code: TokenCode) => getToken(code).getTotalSupply()
+
+  const transfer = (code: TokenCode, to: Account, value: Balance, tx: TransactionObject) =>
+    getToken(code).transfer(to, value, tx)
+
+  const transferFrom = (code: TokenCode, from: Account, to: Account, value: Balance, tx: TransactionObject) =>
+    getToken(code).transferFrom(from, to, value, tx)
+
+  const approve = (code: TokenCode, spender: Account, value: Balance, tx: TransactionObject) =>
+    getToken(code).approve(spender, value, tx)
+
+  const allowance = async (code: TokenCode, owner: Account, spender: Account) =>
+    getToken(code).allowance(owner, spender)
+
+  return {
+    getTokenBalance,
+    getTotalSupply,
+    transfer,
+    transferFrom,
+    approve,
+    allowance,
+  }
+}

src/api/contracts.ts

@@ -0,0 +1,50 @@
+import TruffleContract from 'truffle-contract'
+import { promisedWeb3 } from './web3Provider'
+
+const contractNames = [
+  'DutchExchange',
+  'DutchExchangeETHGNO',
+  'DutchExchangeGNOETH',
+  'Token',
+  'TokenETH',
+  'TokenGNO',
+]
+
+type ContractName = 'DutchExchange' |
+  'DutchExchangeETHGNO' |
+  'DutchExchangeGNOETH' |
+  'Token' |
+  'TokenETH' |
+  'TokenGNO'
+
+type ContractsMap = {[P in ContractName]: any}
+
+const Contracts = contractNames.map(name => TruffleContract(require(`../../build/contracts/${name}.json`)))
+
+// name => contract mapping
+export const contractsMap = contractNames.reduce((acc, name, i) => {
+  acc[name] = Contracts[i]
+  return acc
+}, {}) as ContractsMap
+
+export const setProvider = (provider: any) => Contracts.forEach((contract) => {
+  contract.setProvider(provider)
+})
+
+const getPromisedIntances = () => Promise.all(Contracts.map(contr => contr.deployed()))
+
+export const promisedContractsMap = init()
+
+async function init() {
+  const { currentProvider } = await promisedWeb3
+  setProvider(currentProvider)
+
+  const instances = await getPromisedIntances()
+
+  // name => contract instance mapping
+  // e.g. TokenETH => deployed TokenETH contract
+  return contractNames.reduce((acc, name, i) => {
+    acc[name] = instances[i]
+    return acc
+  }, {}) as ContractsMap
+}