Merge branch 'development' into feature/updateReadmes

* development: (35 commits)
  Remove etherToken from smart contract docs
  Update new WETH addresses and localStorage clearance key
  Fix merge
  Remove re-assignment
  Fix scrolling topBar on Portal
  Fix overflow issue on calculated fillAmount
  Fix faulty import
  Refactor remaining _.assign to spread operator
  Move muiTheme into it's own module
  Add WETH
  remove extra space
  Remove binding on prop passed callbacks
  Add airtable tasks to TODO's
  Refactor configs and constants, standardize on uppercase/snakecase, alphebetize, rename for logical grouping
  Sort colors into color spectrum
  remove unused style
  standarize on `grey` over `gray` spelling and other color related fixes
  Standardize colors to always be in uppercase hex and consolidate material-ui greys
  Consolidate all custom colors and material-ui colors into a colors module
  Remove unused `location` prop
  ...

1 files changed, 160 insertions, 134 deletions

diff --git a/packages/website/ts/redux/reducer.ts b/packages/website/ts/redux/reducer.ts
index da69a9d00..ccf87ae18 100644
--- a/packages/website/ts/redux/reducer.ts
+++ b/packages/website/ts/redux/reducer.ts
@@ -5,8 +5,6 @@ import {
     Action,
     ActionTypes,
     BlockchainErrs,
-    Direction,
-    GenerateOrderSteps,
     Order,
     ProviderType,
     ScreenWidths,
@@ -28,7 +26,6 @@ export interface State {
     // Portal
     blockchainErr: BlockchainErrs;
     blockchainIsLoaded: boolean;
-    generateOrderStep: GenerateOrderSteps;
     networkId: number;
     orderExpiryTimestamp: BigNumber;
     orderFillAmount: BigNumber;
@@ -58,9 +55,8 @@ export interface State {
 
 const INITIAL_STATE: State = {
     // Portal
-    blockchainErr: '',
+    blockchainErr: BlockchainErrs.NoError,
     blockchainIsLoaded: false,
-    generateOrderStep: GenerateOrderSteps.ChooseAssets,
     networkId: undefined,
     orderExpiryTimestamp: utils.initialOrderExpiryUnixTimestampSec(),
     orderFillAmount: undefined,
@@ -76,8 +72,8 @@ const INITIAL_STATE: State = {
     screenWidth: utils.getScreenWidth(),
     shouldBlockchainErrDialogBeOpen: false,
     sideToAssetToken: {
-        [Side.deposit]: {},
-        [Side.receive]: {},
+        [Side.Deposit]: {},
+        [Side.Receive]: {},
     },
     tokenByAddress: {},
     tokenStateByAddress: {},
@@ -91,270 +87,300 @@ const INITIAL_STATE: State = {
 
     // Shared
     flashMessage: undefined,
-    providerType: ProviderType.INJECTED,
+    providerType: ProviderType.Injected,
     injectedProviderName: '',
 };
 
 export function reducer(state: State = INITIAL_STATE, action: Action) {
     switch (action.type) {
         // Portal
-        case ActionTypes.RESET_STATE:
+        case ActionTypes.ResetState:
             return INITIAL_STATE;
 
-        case ActionTypes.UPDATE_ORDER_SALT: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateOrderSalt: {
+            return {
+                ...state,
                 orderSalt: action.data,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_NODE_VERSION: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateNodeVersion: {
+            return {
+                ...state,
                 nodeVersion: action.data,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_ORDER_FILL_AMOUNT: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateOrderFillAmount: {
+            return {
+                ...state,
                 orderFillAmount: action.data,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_SHOULD_BLOCKCHAIN_ERR_DIALOG_BE_OPEN: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateShouldBlockchainErrDialogBeOpen: {
+            return {
+                ...state,
                 shouldBlockchainErrDialogBeOpen: action.data,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_USER_ETHER_BALANCE: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateUserEtherBalance: {
+            return {
+                ...state,
                 userEtherBalance: action.data,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_USER_SUPPLIED_ORDER_CACHE: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateUserSuppliedOrderCache: {
+            return {
+                ...state,
                 userSuppliedOrderCache: action.data,
-            });
+            };
         }
 
-        case ActionTypes.CLEAR_TOKEN_BY_ADDRESS: {
-            return _.assign({}, state, {
+        case ActionTypes.ClearTokenByAddress: {
+            return {
+                ...state,
                 tokenByAddress: {},
-            });
+            };
         }
 
-        case ActionTypes.ADD_TOKEN_TO_TOKEN_BY_ADDRESS: {
+        case ActionTypes.AddTokenToTokenByAddress: {
             const newTokenByAddress = state.tokenByAddress;
             newTokenByAddress[action.data.address] = action.data;
-            return _.assign({}, state, {
+            return {
+                ...state,
                 tokenByAddress: newTokenByAddress,
-            });
+            };
         }
 
-        case ActionTypes.REMOVE_TOKEN_TO_TOKEN_BY_ADDRESS: {
+        case ActionTypes.RemoveTokenFromTokenByAddress: {
             const newTokenByAddress = state.tokenByAddress;
             delete newTokenByAddress[action.data.address];
-            return _.assign({}, state, {
+            return {
+                ...state,
                 tokenByAddress: newTokenByAddress,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_TOKEN_BY_ADDRESS: {
+        case ActionTypes.UpdateTokenByAddress: {
             const tokenByAddress = state.tokenByAddress;
             const tokens = action.data;
             _.each(tokens, token => {
-                const updatedToken = _.assign({}, tokenByAddress[token.address], token);
+                const updatedToken = {
+                    ...tokenByAddress[token.address],
+                    ...token,
+                };
                 tokenByAddress[token.address] = updatedToken;
             });
-            return _.assign({}, state, {
+            return {
+                ...state,
                 tokenByAddress,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_TOKEN_STATE_BY_ADDRESS: {
+        case ActionTypes.UpdateTokenStateByAddress: {
             const tokenStateByAddress = state.tokenStateByAddress;
             const updatedTokenStateByAddress = action.data;
             _.each(updatedTokenStateByAddress, (tokenState: TokenState, address: string) => {
-                const updatedTokenState = _.assign({}, tokenStateByAddress[address], tokenState);
+                const updatedTokenState = {
+                    ...tokenStateByAddress[address],
+                    ...tokenState,
+                };
                 tokenStateByAddress[address] = updatedTokenState;
             });
-            return _.assign({}, state, {
+            return {
+                ...state,
                 tokenStateByAddress,
-            });
+            };
         }
 
-        case ActionTypes.REMOVE_FROM_TOKEN_STATE_BY_ADDRESS: {
+        case ActionTypes.RemoveFromTokenStateByAddress: {
             const tokenStateByAddress = state.tokenStateByAddress;
             const tokenAddress = action.data;
             delete tokenStateByAddress[tokenAddress];
-            return _.assign({}, state, {
+            return {
+                ...state,
                 tokenStateByAddress,
-            });
+            };
         }
 
-        case ActionTypes.REPLACE_TOKEN_ALLOWANCE_BY_ADDRESS: {
+        case ActionTypes.ReplaceTokenAllowanceByAddress: {
             const tokenStateByAddress = state.tokenStateByAddress;
             const allowance = action.data.allowance;
             const tokenAddress = action.data.address;
-            tokenStateByAddress[tokenAddress] = _.assign({}, tokenStateByAddress[tokenAddress], {
+            tokenStateByAddress[tokenAddress] = {
+                ...tokenStateByAddress[tokenAddress],
                 allowance,
-            });
-            return _.assign({}, state, {
+            };
+            return {
+                ...state,
                 tokenStateByAddress,
-            });
+            };
         }
 
-        case ActionTypes.REPLACE_TOKEN_BALANCE_BY_ADDRESS: {
+        case ActionTypes.ReplaceTokenBalanceByAddress: {
             const tokenStateByAddress = state.tokenStateByAddress;
             const balance = action.data.balance;
             const tokenAddress = action.data.address;
-            tokenStateByAddress[tokenAddress] = _.assign({}, tokenStateByAddress[tokenAddress], {
+            tokenStateByAddress[tokenAddress] = {
+                ...tokenStateByAddress[tokenAddress],
                 balance,
-            });
-            return _.assign({}, state, {
+            };
+            return {
+                ...state,
                 tokenStateByAddress,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_TOKEN_BALANCE_BY_ADDRESS: {
+        case ActionTypes.UpdateTokenBalanceByAddress: {
             const tokenStateByAddress = state.tokenStateByAddress;
             const balanceDelta = action.data.balanceDelta;
             const tokenAddress = action.data.address;
             const currBalance = tokenStateByAddress[tokenAddress].balance;
-            tokenStateByAddress[tokenAddress] = _.assign({}, tokenStateByAddress[tokenAddress], {
+            tokenStateByAddress[tokenAddress] = {
+                ...tokenStateByAddress[tokenAddress],
                 balance: currBalance.plus(balanceDelta),
-            });
-            return _.assign({}, state, {
+            };
+            return {
+                ...state,
                 tokenStateByAddress,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_ORDER_SIGNATURE_DATA: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateOrderSignatureData: {
+            return {
+                ...state,
                 orderSignatureData: action.data,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_SCREEN_WIDTH: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateScreenWidth: {
+            return {
+                ...state,
                 screenWidth: action.data,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_BLOCKCHAIN_IS_LOADED: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateBlockchainIsLoaded: {
+            return {
+                ...state,
                 blockchainIsLoaded: action.data,
-            });
+            };
         }
 
-        case ActionTypes.BLOCKCHAIN_ERR_ENCOUNTERED: {
-            return _.assign({}, state, {
+        case ActionTypes.BlockchainErrEncountered: {
+            return {
+                ...state,
                 blockchainErr: action.data,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_NETWORK_ID: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateNetworkId: {
+            return {
+                ...state,
                 networkId: action.data,
-            });
-        }
-
-        case ActionTypes.UPDATE_GENERATE_ORDER_STEP: {
-            const direction = action.data;
-            let nextGenerateOrderStep = state.generateOrderStep;
-            if (direction === Direction.forward) {
-                nextGenerateOrderStep += 1;
-            } else if (state.generateOrderStep !== 0) {
-                nextGenerateOrderStep -= 1;
-            }
-            return _.assign({}, state, {
-                generateOrderStep: nextGenerateOrderStep,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_CHOSEN_ASSET_TOKEN: {
-            const newSideToAssetToken = _.assign({}, state.sideToAssetToken, {
+        case ActionTypes.UpdateChosenAssetToken: {
+            const newSideToAssetToken = {
+                ...state.sideToAssetToken,
                 [action.data.side]: action.data.token,
-            });
-            return _.assign({}, state, {
+            };
+            return {
+                ...state,
                 sideToAssetToken: newSideToAssetToken,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_CHOSEN_ASSET_TOKEN_ADDRESS: {
+        case ActionTypes.UpdateChosenAssetTokenAddress: {
             const newAssetToken = state.sideToAssetToken[action.data.side];
             newAssetToken.address = action.data.address;
-            const newSideToAssetToken = _.assign({}, state.sideToAssetToken, {
+            const newSideToAssetToken = {
+                ...state.sideToAssetToken,
                 [action.data.side]: newAssetToken,
-            });
-            return _.assign({}, state, {
+            };
+            return {
+                ...state,
                 sideToAssetToken: newSideToAssetToken,
-            });
+            };
         }
 
-        case ActionTypes.SWAP_ASSET_TOKENS: {
-            const newSideToAssetToken = _.assign({}, state.sideToAssetToken, {
-                [Side.deposit]: state.sideToAssetToken[Side.receive],
-                [Side.receive]: state.sideToAssetToken[Side.deposit],
-            });
-            return _.assign({}, state, {
+        case ActionTypes.SwapAssetTokens: {
+            const newSideToAssetToken = {
+                [Side.Deposit]: state.sideToAssetToken[Side.Receive],
+                [Side.Receive]: state.sideToAssetToken[Side.Deposit],
+            };
+            return {
+                ...state,
                 sideToAssetToken: newSideToAssetToken,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_ORDER_EXPIRY: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateOrderExpiry: {
+            return {
+                ...state,
                 orderExpiryTimestamp: action.data,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_ORDER_TAKER_ADDRESS: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateOrderTakerAddress: {
+            return {
+                ...state,
                 orderTakerAddress: action.data,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_USER_ADDRESS: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateUserAddress: {
+            return {
+                ...state,
                 userAddress: action.data,
-            });
+            };
         }
 
         // Docs
-        case ActionTypes.UPDATE_LIBRARY_VERSION: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateLibraryVersion: {
+            return {
+                ...state,
                 docsVersion: action.data,
-            });
+            };
         }
-        case ActionTypes.UPDATE_AVAILABLE_LIBRARY_VERSIONS: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateAvailableLibraryVersions: {
+            return {
+                ...state,
                 availableDocVersions: action.data,
-            });
+            };
         }
 
         // Shared
-        case ActionTypes.SHOW_FLASH_MESSAGE: {
-            return _.assign({}, state, {
+        case ActionTypes.ShowFlashMessage: {
+            return {
+                ...state,
                 flashMessage: action.data,
-            });
+            };
         }
 
-        case ActionTypes.HIDE_FLASH_MESSAGE: {
-            return _.assign({}, state, {
+        case ActionTypes.HideFlashMessage: {
+            return {
+                ...state,
                 flashMessage: undefined,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_PROVIDER_TYPE: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateProviderType: {
+            return {
+                ...state,
                 providerType: action.data,
-            });
+            };
         }
 
-        case ActionTypes.UPDATE_INJECTED_PROVIDER_NAME: {
-            return _.assign({}, state, {
+        case ActionTypes.UpdateInjectedProviderName: {
+            return {
+                ...state,
                 injectedProviderName: action.data,
-            });
+            };
         }
 
         default: