diff --git a/packages/instant/src/redux/async_data.ts b/packages/instant/src/redux/async_data.ts
index e1dd0a774a..55b8fead36 100644
--- a/packages/instant/src/redux/async_data.ts
+++ b/packages/instant/src/redux/async_data.ts
@@ -13,6 +13,7 @@ import { swapQuoteUpdater } from '../util/swap_quote_updater';
 
 import { actions } from './actions';
 import { State } from './reducer';
+import { providerStateFactory } from '../util/provider_state_factory';
 
 export const asyncData = {
     fetchEthPriceAndDispatchToStore: async (dispatch: Dispatch) => {
@@ -71,18 +72,19 @@ export const asyncData = {
         try {
             // TODO(bmillman): Add support at the web3Wrapper level for calling `eth_requestAccounts` instead of calling enable here
             const isPrivacyModeEnabled = (provider as any).enable !== undefined;
-            if (providerState.name !== 'Fortmatic') {
-                availableAddresses =
-                    isPrivacyModeEnabled && shouldAttemptUnlock
-                        ? await (provider as any).enable()
-                        : await web3Wrapper.getAvailableAddressesAsync();
-            } else {
-                availableAddresses = await web3Wrapper.getAvailableAddressesAsync();
-            }
+            availableAddresses =
+            isPrivacyModeEnabled && shouldAttemptUnlock
+                ? await (provider as any).enable()
+                : await web3Wrapper.getAvailableAddressesAsync();
+            console.log(availableAddresses);
         } catch (e) {
             analytics.trackAccountUnlockDenied();
             if (e.message.includes('Fortmatic: User denied account access.')) {
-                dispatch(actions.setAccountStateNone());
+                // If Fortmatic is not used, revert to injected provider
+                const initialProviderState = providerStateFactory.getInitialProviderStateWithCurrentProviderState(
+                    providerState,
+                );
+                dispatch(actions.setProviderState(initialProviderState));
             } else {
                 dispatch(actions.setAccountStateLocked());
             }
diff --git a/packages/instant/src/types.ts b/packages/instant/src/types.ts
index 0b3ef2223d..e1a9361a3e 100644
--- a/packages/instant/src/types.ts
+++ b/packages/instant/src/types.ts
@@ -115,6 +115,7 @@ export interface ProviderState {
     web3Wrapper: Web3Wrapper;
     account: Account;
     orderSource: OrderSource;
+    isProviderInjected: boolean;
 }
 
 export enum AccountState {
diff --git a/packages/instant/src/util/env.ts b/packages/instant/src/util/env.ts
index 412e24725c..fd5e36df22 100644
--- a/packages/instant/src/util/env.ts
+++ b/packages/instant/src/util/env.ts
@@ -51,6 +51,8 @@ export const envUtil = {
             return ProviderType.Parity;
         } else if (anyProvider.isMetaMask) {
             return ProviderType.MetaMask;
+        } else if (anyProvider.isFortmatic) {
+            return ProviderType.Fortmatic;
         } else if (_.get(window, 'SOFA') !== undefined) {
             return ProviderType.CoinbaseWallet;
         } else if (_.get(window, '__CIPHER__') !== undefined) {
@@ -58,8 +60,7 @@ export const envUtil = {
         } else if (envUtil.getBrowser() === Browser.Opera && !anyProvider.isMetaMask) {
             return ProviderType.Opera;
         }
-        // If the provider is not supported by 0x, use fortmatic
-        return ProviderType.Fortmatic;
+        return undefined;
     },
     getProviderName(provider: ZeroExProvider): string {
         const providerTypeIfExists = envUtil.getProviderType(provider);
diff --git a/packages/instant/src/util/heartbeater_factory.ts b/packages/instant/src/util/heartbeater_factory.ts
index 737ae1764d..c80eccd8b2 100644
--- a/packages/instant/src/util/heartbeater_factory.ts
+++ b/packages/instant/src/util/heartbeater_factory.ts
@@ -11,7 +11,6 @@ export interface HeartbeatFactoryOptions {
 export const generateAccountHeartbeater = (options: HeartbeatFactoryOptions): Heartbeater => {
     const { store, shouldPerformImmediatelyOnStart } = options;
     return new Heartbeater(async () => {
-        console.log('beat');
         await asyncData.fetchAccountInfoAndDispatchToStore(store.getState().providerState, store.dispatch, false);
     }, shouldPerformImmediatelyOnStart);
 };
diff --git a/packages/instant/src/util/provider_state_factory.ts b/packages/instant/src/util/provider_state_factory.ts
index 8e006d6dea..0b42bce3ef 100644
--- a/packages/instant/src/util/provider_state_factory.ts
+++ b/packages/instant/src/util/provider_state_factory.ts
@@ -52,6 +52,7 @@ export const providerStateFactory = {
             swapQuoteConsumer: assetSwapperFactory.getSwapQuoteConsumer(provider, network),
             account: LOADING_ACCOUNT,
             orderSource,
+            isProviderInjected: false,
         };
         return providerState;
     },
@@ -71,6 +72,7 @@ export const providerStateFactory = {
                 swapQuoteConsumer: assetSwapperFactory.getSwapQuoteConsumer(injectedProviderIfExists, network),
                 account: LOADING_ACCOUNT,
                 orderSource,
+                isProviderInjected: true,
             };
             return providerState;
         } else {
@@ -83,7 +85,6 @@ export const providerStateFactory = {
         walletDisplayName?: string,
     ): ProviderState => {
         const provider = providerFactory.getFallbackNoSigningProvider(network);
-        console.log(walletDisplayName, envUtil.getProviderDisplayName(provider));
         const providerState: ProviderState = {
             name: 'Fallback',
             displayName: walletDisplayName || envUtil.getProviderDisplayName(provider),
@@ -93,9 +94,32 @@ export const providerStateFactory = {
             swapQuoteConsumer: assetSwapperFactory.getSwapQuoteConsumer(provider, network),
             account: NO_ACCOUNT,
             orderSource,
+            isProviderInjected: true,
         };
         return providerState;
     },
+    // function to call getInitialProviderState with parameters retreived from a provided ProviderState
+    getInitialProviderStateWithCurrentProviderState: (
+        currentProviderState: ProviderState,
+    ): ProviderState => {
+        const orderSource = currentProviderState.orderSource;
+        const chainId = currentProviderState.swapQuoter.chainId;
+        // If provider is provided to instant, use that and the displayName
+        if (!currentProviderState.isProviderInjected) {
+            return providerStateFactory.getInitialProviderState(
+                orderSource,
+                chainId,
+                currentProviderState.provider,
+                currentProviderState.displayName,
+            );
+        }
+        const newProviderState = providerStateFactory.getInitialProviderState(
+            orderSource,
+            chainId,
+        );
+        newProviderState.account = NO_ACCOUNT;
+        return newProviderState;
+    },
     getProviderStateBasedOnProviderType: (
         currentProviderState: ProviderState,
         providerType: ProviderType,
@@ -115,6 +139,7 @@ export const providerStateFactory = {
                     swapQuoteConsumer: assetSwapperFactory.getSwapQuoteConsumer(provider, chainId),
                     account: LOADING_ACCOUNT,
                     orderSource,
+                    isProviderInjected: true,
                 };
             }
         }
@@ -130,6 +155,7 @@ export const providerStateFactory = {
                 swapQuoteConsumer: assetSwapperFactory.getSwapQuoteConsumer(fmProvider, chainId),
                 account: LOADING_ACCOUNT,
                 orderSource,
+                isProviderInjected: true,
             };
         }
         return providerStateFactory.getInitialProviderState(