feat: support calling connect with no arguments

src/ConnectionManager.ts

@@ -5,6 +5,7 @@ import {
   InjectedConnector,
   WalletConnectConnector
 } from './connectors'
+import { LocalStorage, Storage } from './storage'
 import {
   RequestArguments,
   ProviderType,
@@ -14,18 +15,28 @@ import {
   ClosableConnector,
   LegacyProvider
 } from './types'
+import { getConfiguration } from './configuration'
 import './declarations'
 
 export class ConnectionManager {
   providerType?: ProviderType
   connector?: AbstractConnector
 
+  constructor(public storage: Storage) {}
+
   async connect(
-    providerType: ProviderType,
+    providerType?: ProviderType,
     chainId: ChainId = ChainId.MAINNET
   ): Promise<ConnectResponse> {
-    this.providerType = providerType
-    this.connector = this.getConnector(providerType, chainId)
+    const { storageKey } = getConfiguration()
+
+    this.providerType = providerType || this.storage.get(storageKey)
+    if (!this.providerType) {
+      throw new Error('connect called without a provider and none was stored')
+    }
+
+    this.storage.set(storageKey, providerType)
+    this.connector = this.getConnector(this.providerType!, chainId)
 
     const {
       provider,
@@ -114,4 +125,4 @@ export class ConnectionManager {
   }
 }
 
-export const connection = new ConnectionManager()
+export const connection = new ConnectionManager(new LocalStorage())

src/storage/LocalStorage.ts

@@ -0,0 +1,12 @@
+import { Storage } from './Storage'
+
+export class LocalStorage extends Storage {
+  get(key: string): any | undefined {
+    const result = window.localStorage.getItem(key)
+    return result === null ? undefined : result
+  }
+
+  set(key: string, value: any): void {
+    window.localStorage.setItem(key, value)
+  }
+}

src/storage/Storage.ts

@@ -0,0 +1,4 @@
+export abstract class Storage {
+  abstract get(key: string): any | undefined
+  abstract set(key: string, value: any): void
+}

src/storage/index.ts

@@ -0,0 +1,2 @@
+export * from './Storage'
+export * from './LocalStorage'

test/ConnectionManager.spec.ts

@@ -3,20 +3,23 @@ import chaiAsPromised from 'chai-as-promised'
 import sinon from 'sinon'
 import { ConnectionManager } from '../src/ConnectionManager'
 import { ChainId, ClosableConnector, ProviderType } from '../src/types'
-import { StubClosableConnector, StubConnector } from './utils'
+import { StubClosableConnector, StubConnector, StubStorage } from './utils'
 
 chai.use(chaiAsPromised)
 const { expect } = chai
 
 describe('ConnectionManager', () => {
+  let storage: StubStorage
   let connectionManager: ConnectionManager
 
   beforeEach(() => {
-    connectionManager = new ConnectionManager()
+    storage = new StubStorage()
+    connectionManager = new ConnectionManager(storage)
   })
 
   afterEach(() => {
     sinon.restore()
+    storage.clean()
   })
 
   describe('#connect', () => {
@@ -76,29 +79,66 @@ describe('ConnectionManager', () => {
     it('should not patch the provider with the request method if it already exists', async () => {
       const stubConnector = new StubConnector()
       sinon.stub(connectionManager, 'getConnector').returns(stubConnector)
-      sinon.stub(stubConnector, 'activate').resolves({
-        account: '0x123123',
-        provider: { request: () => {} }
-      })
 
       const result = await connectionManager.connect(
         ProviderType.INJECTED,
         ChainId.ROPSTEN
       )
-      const activateResult = await stubConnector.activate()
+      const { account } = await stubConnector.activate()
 
       expect(JSON.stringify(result)).to.eq(
         JSON.stringify({
           provider: {
             request: () => {}
           },
-          account: activateResult.account,
+          account,
           chainId: ChainId.ROPSTEN
         })
       )
     })
 
-    it('should store the last provider and chain')
+    it('should throw if called wihtout provider type and none is found on storage', () => {
+      expect(connectionManager.connect()).to.eventually.throw(
+        new Error('connect called without a provider and none was stored')
+      )
+    })
+
+    it('should store the last provider and chain', async () => {
+      const stubConnector = new StubConnector()
+      sinon.stub(connectionManager, 'getConnector').returns(stubConnector)
+
+      await connectionManager.connect(ProviderType.INJECTED)
+
+      expect(storage.get()).to.eq(ProviderType.INJECTED)
+    })
+
+    it('should connect to the last supplied provider', async () => {
+      const stubConnector = new StubConnector()
+      const getConnectorStub = sinon
+        .stub(connectionManager, 'getConnector')
+        .returns(stubConnector)
+
+      await connectionManager.connect(ProviderType.FORTMATIC)
+      const result = await connectionManager.connect()
+      const { account } = await stubConnector.activate()
+
+      expect(
+        getConnectorStub.firstCall.calledWith(ProviderType.FORTMATIC)
+      ).to.eq(true)
+      expect(
+        getConnectorStub.secondCall.calledWith(ProviderType.FORTMATIC)
+      ).to.eq(true)
+
+      expect(JSON.stringify(result)).to.eq(
+        JSON.stringify({
+          provider: {
+            request: () => {}
+          },
+          account,
+          chainId: ChainId.MAINNET
+        })
+      )
+    })
   })
 
   describe('#disconnect', () => {

test/utils.ts

@@ -1,12 +1,15 @@
-import { AbstractConnector } from '../src/connectors/AbstractConnector'
 import { ConnectorUpdate } from '@web3-react/types'
+import { AbstractConnector } from '../src/connectors/AbstractConnector'
 import { ChainId } from '../src/types'
+import { Storage } from '../src/storage'
 
 export class StubConnector extends AbstractConnector {
   async activate(): Promise<ConnectorUpdate> {
     return {
       provider: {
-        send: () => {}
+        send: () => {
+          // no-op
+        }
       },
       account: '0xdeadbeef'
     }
@@ -34,3 +37,19 @@ export class StubClosableConnector extends StubConnector {
     // no-op
   }
 }
+
+export class StubStorage extends Storage {
+  value: any
+
+  get() {
+    return this.value
+  }
+
+  set(_key: string, value: any) {
+    this.value = value
+  }
+
+  clean() {
+    this.value = undefined
+  }
+}