allow ethers or low-level providers

src/__tests__/data.ts

 import { Token, TokenReservesNormalized } from '../types'
 import { ETH as _ETH } from '../constants'
 import { getTokenReserves } from '../data'
+import { ethers } from 'ethers'
 
 const ETH: Token = {
   chainId: 1,
@@ -26,6 +27,13 @@ describe('getTokenReserves', (): void => {
   test('DAI', async (done: jest.DoneCallback): Promise<void> => {
     const tokenReserves: TokenReservesNormalized = await getTokenReserves(DAI.address as string)
 
+    const tokenReservesWithProvider: TokenReservesNormalized = await getTokenReserves(
+      DAI.address as string,
+      ethers.getDefaultProvider()
+    )
+
+    expect(tokenReserves.token).toEqual(tokenReservesWithProvider.token)
+
     expect(tokenReserves.token).toEqual(DAI)
     expect(tokenReserves.exchange).toEqual(DAI_EXCHANGE)
     expect(tokenReserves.ethReserve.token).toEqual(ETH)

src/data/index.ts

 import { ethers } from 'ethers'
 
-import { ChainIdOrProvider, isChainId, Token, TokenReservesNormalized, _ChainIdAndProvider } from '../types'
+import {
+  ChainIdOrProvider,
+  isChainId,
+  isLowLevelProvider,
+  Token,
+  TokenReservesNormalized,
+  _ChainIdAndProvider
+} from '../types'
 import { ETH, SUPPORTED_CHAIN_ID, FACTORY_ABI, FACTORY_ADDRESS, _CHAIN_ID_NAME, _ERC20_ABI } from '../constants'
 import { normalizeBigNumberish, normalizeAddress, getEthToken } from '../_utils'
 
-function getContract(address: string, ABI: string, provider: ethers.providers.BaseProvider): ethers.Contract {
+function getContract(address: string, ABI: string, provider: ethers.providers.Provider): ethers.Contract {
   return new ethers.Contract(address, ABI, provider)
 }
 
@@ -18,7 +25,9 @@ async function getChainIdAndProvider(chainIdOrProvider: ChainIdOrProvider): Prom
   }
   // if a provider is provided, fetch the chainId from it
   else {
-    const provider: ethers.providers.Web3Provider = new ethers.providers.Web3Provider(chainIdOrProvider)
+    const provider: ethers.providers.Provider = isLowLevelProvider(chainIdOrProvider)
+      ? new ethers.providers.Web3Provider(chainIdOrProvider)
+      : chainIdOrProvider
     const { chainId }: ethers.utils.Network = await provider.getNetwork()
 
     if (!(chainId in SUPPORTED_CHAIN_ID)) {

src/types.ts

@@ -6,7 +6,7 @@ import { SUPPORTED_CHAIN_ID, TRADE_TYPE, TRADE_EXACT, FIXED_UNDERFLOW_BEHAVIOR }
 export type BigNumberish = BigNumber | ethers.utils.BigNumber | string | number
 
 //// types for on-chain, submitted, and normalized data
-export type ChainIdOrProvider = SUPPORTED_CHAIN_ID | ethers.providers.AsyncSendable
+export type ChainIdOrProvider = SUPPORTED_CHAIN_ID | ethers.providers.AsyncSendable | ethers.providers.Provider
 
 // type guard for ChainIdOrProvider
 export function isChainId(chainIdOrProvider: ChainIdOrProvider): chainIdOrProvider is SUPPORTED_CHAIN_ID {
@@ -14,6 +14,18 @@ export function isChainId(chainIdOrProvider: ChainIdOrProvider): chainIdOrProvid
   return typeof chainId === 'number'
 }
 
+// type guard for ChainIdOrProvider
+export function isLowLevelProvider(
+  chainIdOrProvider: ChainIdOrProvider
+): chainIdOrProvider is ethers.providers.AsyncSendable {
+  if (isChainId(chainIdOrProvider)) {
+    return false
+  } else {
+    const provider: ethers.providers.AsyncSendable = chainIdOrProvider as ethers.providers.AsyncSendable
+    return 'send' in provider || 'sendAsync' in provider
+  }
+}
+
 export interface Token {
   chainId?: SUPPORTED_CHAIN_ID
   address?: string
@@ -138,7 +150,7 @@ export interface FormatFixedOptions {
 //// internal-only interfaces
 export interface _ChainIdAndProvider {
   chainId: number
-  provider: ethers.providers.Web3Provider | ethers.providers.BaseProvider
+  provider: ethers.providers.Provider
 }
 
 export interface _ParsedOptionalReserves {