rewrite active tokens logic to use updateSafe action

src/routes/safe/store/actions/fetchSafe.js

@@ -46,7 +46,6 @@ export default (safeAddress: string, update: boolean = false) => async (dispatch
     const safeProps: SafeProps = await buildSafe(safeAddress, safeName)
 
     if (update) {
-      console.log(safeProps)
       dispatch(updateSafe(safeProps))
     } else {
       dispatch(addSafe(safeProps))

src/routes/safe/store/actions/updateActiveTokens.js

@@ -1,30 +1,38 @@
 // @flow
-import { createAction } from 'redux-actions'
-import type { Dispatch as ReduxDispatch } from 'redux'
+import { List } from 'immutable'
+import type { Dispatch as ReduxDispatch, GetState } from 'redux'
 import { type GlobalState } from '~/store'
 import type { SafeToken } from '~/routes/safe/store/models/safeToken'
 import SafeTokenRecord from '~/routes/safe/store/models/safeToken'
+import { safeTokensSelector } from '~/routes/safe/store/selectors/index'
+import { SAFE_PARAM_ADDRESS } from '~/routes/routes'
+import updateSafe from './updateSafe'
 
-export const UPDATE_SAFE_TOKENS = 'UPDATE_SAFE_TOKENS'
-
-type ActionReturn = {
-  token: SafeToken,
-}
-
-export const updateTokenAction = createAction<string, Function, ActionReturn>(
-  UPDATE_SAFE_TOKENS,
-  (safeAddress: string, token: SafeToken): ActionReturn => ({
-    safeAddress,
-    token,
-  }),
-)
+const generateMatchProps = (safeAddress: string) => ({
+  match: {
+    params: {
+      [SAFE_PARAM_ADDRESS]: safeAddress,
+    },
+  },
+})
 
 const updateActiveTokens = (safeAddress: string, tokenAddress: string) => async (
   dispatch: ReduxDispatch<GlobalState>,
+  getState: GetState<GlobalState>,
 ) => {
   const token: SafeToken = SafeTokenRecord({ address: tokenAddress })
+  const state = getState()
+  const safeTokens: List<SafeToken> = safeTokensSelector(state, generateMatchProps(safeAddress))
+  const index = safeTokens.findIndex(safeToken => safeToken.address === token.address)
 
-  dispatch(updateTokenAction(safeAddress, token))
+  let updatedTokens
+  if (index !== -1) {
+    updatedTokens = safeTokens.delete(index)
+  } else {
+    updatedTokens = safeTokens.push(token)
+  }
+
+  dispatch(updateSafe({ address: safeAddress, tokens: updatedTokens }))
 }
 
 export default updateActiveTokens

src/routes/safe/store/reducer/safe.js

@@ -8,7 +8,6 @@ import type { SafeToken } from '~/routes/safe/store/models/safeToken'
 import { loadFromStorage } from '~/utils/storage'
 import { SAFES_KEY } from '~/logic/safe/utils'
 import { UPDATE_SAFE } from '~/routes/safe/store/actions/updateSafe'
-import { UPDATE_SAFE_TOKENS } from '~/routes/safe/store/actions/updateActiveTokens'
 
 export const SAFE_REDUCER_ID = 'safes'
 
@@ -72,21 +71,6 @@ export default handleActions<State, *>(
 
       return state.set(safe.address, SafeRecord(safe))
     },
-    [UPDATE_SAFE_TOKENS]: (state: State, action: ActionType<Function>): State => {
-      const { safeAddress, token: updatedToken } = action.payload
-
-      const tokens: List<SafeToken> = state.getIn([safeAddress, 'tokens'])
-      const index = tokens.findIndex(token => token.address === updatedToken.address)
-
-      let newState
-      if (index !== -1) {
-        newState = state.setIn([safeAddress, 'tokens'], tokens.delete(index))
-      } else {
-        newState = state.setIn([safeAddress, 'tokens'], tokens.push(updatedToken))
-      }
-
-      return newState
-    },
   },
   Map(),
 )

src/routes/safeList/store/selectors/index.js

@@ -3,9 +3,6 @@ import { List, Map } from 'immutable'
 import { createSelector, type Selector } from 'reselect'
 import { type GlobalState } from '~/store/index'
 import { type Safe } from '~/routes/safe/store/models/safe'
-import { userAccountSelector } from '~/logic/wallets/store/selectors'
-import { type Owner } from '~/routes/safe/store/models/owner'
-import { sameAddress } from '~/logic/wallets/ethAddresses'
 import { SAFE_REDUCER_ID } from '~/routes/safe/store/reducer/safe'
 
 export const safesMapSelector = (state: GlobalState): Map<string, Safe> => state[SAFE_REDUCER_ID]
@@ -14,11 +11,3 @@ export const safesListSelector: Selector<GlobalState, {}, List<Safe>> = createSe
   safesMapSelector,
   (safes: Map<string, Safe>): List<Safe> => safes.toList(),
 )
-
-// export const safesByOwnerSelector: Selector<GlobalState, {}, List<Safe>> = createSelector(
-//   userAccountSelector,
-//   safesListSelector,
-//   (userAddress: string, safes: List<Safe>): List<Safe> => safes.filter(
-//     (safe: Safe) => safe.owners.filter((owner: Owner) => sameAddress(owner.get('address'), userAddress)).count() > 0,
-//   ),
-// )