@0xsequence/provider 1.1.1 → 1.1.3

package/src/client.ts

@@ -1,10 +1,23 @@
-import { JsonRpcRequest, JsonRpcResponse, NetworkConfig } from "@0xsequence/network"
-import { ConnectDetails, ConnectOptions, ItemStore, MuxMessageProvider, MuxTransportTemplate, OpenWalletIntent, OptionalChainId, OptionalEIP6492, ProviderTransport, WalletEventTypes, WalletSession, isMuxTransportTemplate, isProviderTransport } from "."
-import { commons } from "@0xsequence/core"
-import { TypedData } from "@0xsequence/utils"
-import { toExtended } from "./extended"
-import { ethers } from "ethers"
-
+import { JsonRpcRequest, JsonRpcResponse, NetworkConfig } from '@0xsequence/network'
+import {
+  ConnectDetails,
+  ConnectOptions,
+  ItemStore,
+  MuxMessageProvider,
+  MuxTransportTemplate,
+  OpenWalletIntent,
+  OptionalChainId,
+  OptionalEIP6492,
+  ProviderTransport,
+  WalletEventTypes,
+  WalletSession,
+  isMuxTransportTemplate,
+  isProviderTransport
+} from '.'
+import { commons } from '@0xsequence/core'
+import { TypedData } from '@0xsequence/utils'
+import { toExtended } from './extended'
+import { ethers } from 'ethers'
 
 /**
  *  This session class is meant to persist the state of the wallet connection
@@ -14,19 +27,12 @@ import { ethers } from "ethers"
 export class SequenceClientSession {
   static readonly SESSION_LOCALSTORE_KEY = '@sequence.session'
 
-  constructor (
-    private store: ItemStore
-  ) {}
+  constructor(private store: ItemStore) {}
 
   connectedSession(): Required<WalletSession> {
     const session = this.getSession()
 
-    if (
-      session &&
-      session.accountAddress &&
-      session.walletContext &&
-      session.networks
-    ) {
+    if (session && session.accountAddress && session.walletContext && session.networks) {
       return {
         accountAddress: session.accountAddress!,
         walletContext: session.walletContext!,
@@ -41,7 +47,7 @@ export class SequenceClientSession {
     return this.getSession()?.accountAddress !== undefined
   }
 
- setSession(session: WalletSession) {
+  setSession(session: WalletSession) {
     return this.store.setItem(SequenceClientSession.SESSION_LOCALSTORE_KEY, JSON.stringify(session))
   }
 
@@ -109,21 +115,17 @@ export class DefaultChainIdTracker {
 /**
  *  This is a wallet client for sequence wallet-webapp. It connects using *some* transport
  *  and it allows to perform all sequence specific (or write) operations related to the wallet.
- * 
+ *
  *  It doesn't implement a full ethereum Provider, it doesn't include read-only methods.
  */
-export class SequenceClient {  
+export class SequenceClient {
   private readonly session: SequenceClientSession
   private readonly defaultChainId: DefaultChainIdTracker
   private readonly callbacks: { [K in keyof WalletEventTypes]?: WalletEventTypes[K][] } = {}
 
   public readonly transport: ProviderTransport
 
-  constructor (
-    transport: ProviderTransport | MuxTransportTemplate,
-    store: ItemStore,
-    defaultChainId?: number
-  ) {
+  constructor(transport: ProviderTransport | MuxTransportTemplate, store: ItemStore, defaultChainId?: number) {
     if (isMuxTransportTemplate(transport)) {
       this.transport = MuxMessageProvider.new(transport)
     } else if (isProviderTransport(transport)) {
@@ -144,39 +146,41 @@ export class SequenceClient {
     })
 
     this.transport.on('connect', (response: ConnectDetails) => {
-      const chainIdHex = ethers.BigNumber.from(this.getChainId()).toHexString()
-      this.callbacks.connect?.forEach(cb => cb({
-        ...response,
-        // Ignore the full connect response
-        // use the chainId defined locally
-        chainId: chainIdHex
-      }))
+      const chainIdHex = ethers.utils.hexValue(this.getChainId())
+      this.callbacks.connect?.forEach(cb =>
+        cb({
+          ...response,
+          // Ignore the full connect response
+          // use the chainId defined locally
+          chainId: chainIdHex
+        })
+      )
     })
 
-    this.transport.on('disconnect', (error) => {
+    this.transport.on('disconnect', error => {
       this.callbacks.disconnect?.forEach(cb => cb(error))
     })
 
-    this.transport.on('networks', (networks) => {
+    this.transport.on('networks', networks => {
       this.callbacks.networks?.forEach(cb => cb(networks))
     })
 
-    this.transport.on('walletContext', (context) => {
+    this.transport.on('walletContext', context => {
       this.callbacks.walletContext?.forEach(cb => cb(context))
     })
 
-    this.transport.on('open', (info) => {
+    this.transport.on('open', info => {
       this.callbacks.open?.forEach(cb => cb(info))
     })
 
     this.transport.on('close', () => {
       this.callbacks.close?.forEach(cb => cb())
     })
-  
+
     // We don't listen for the transport chainChanged event
     // instead we handle it locally, so we listen for changes in the store
     this.defaultChainId.onDefaultChainIdChanged((chainId: number) => {
-      const chainIdHex = ethers.BigNumber.from(chainId).toHexString()
+      const chainIdHex = ethers.utils.hexValue(chainId)
       this.callbacks.chainChanged?.forEach(cb => cb(chainIdHex))
     })
   }
@@ -187,9 +191,9 @@ export class SequenceClient {
     if (!this.callbacks[eventName]) {
       this.callbacks[eventName] = []
     }
-  
+
     this.callbacks[eventName]!.push(callback)
-  
+
     return () => {
       this.callbacks[eventName] = this.callbacks[eventName]!.filter(c => c !== callback) as any
     }
@@ -212,7 +216,7 @@ export class SequenceClient {
   onDisconnect(callback: WalletEventTypes['disconnect']) {
     return this.registerCallback('disconnect', callback)
   }
-  
+
   onNetworks(callback: WalletEventTypes['networks']) {
     return this.registerCallback('networks', callback)
   }
@@ -310,7 +314,7 @@ export class SequenceClient {
       if (!connectDetails.session) {
         throw new Error('impossible state, connect response is missing session')
       }
-  
+
       this.session.setSession(connectDetails.session)
     }
 
@@ -331,19 +335,23 @@ export class SequenceClient {
   // but transport uses it instead of send, so we wrap it
   send(request: JsonRpcRequest, chainId?: number): Promise<any> {
     return new Promise((resolve, reject) => {
-      this.transport.sendAsync(request, (error, response) => {
-        if (error) {
-          reject(error)
-        } else if (response === undefined) {
-          reject(new Error(`Got undefined response for request: ${request}`))
-        } else if (typeof response === 'object' && response.error) {
-          reject(response.error)
-        } else if (typeof response === 'object' && response.result) {
-          resolve(response.result)
-        } else {
-          reject(new Error(`Got invalid response for request: ${request}`))
-        }
-      }, chainId || this.getChainId())
+      this.transport.sendAsync(
+        request,
+        (error, response) => {
+          if (error) {
+            reject(error)
+          } else if (response === undefined) {
+            reject(new Error(`Got undefined response for request: ${request}`))
+          } else if (typeof response === 'object' && response.error) {
+            reject(response.error)
+          } else if (typeof response === 'object' && response.result) {
+            resolve(response.result)
+          } else {
+            reject(new Error(`Got invalid response for request: ${request}`))
+          }
+        },
+        chainId || this.getChainId()
+      )
     })
   }
 
@@ -358,52 +366,41 @@ export class SequenceClient {
     return connectedSession.networks
   }
 
-  async signMessage(
-    message: ethers.BytesLike,
-    options?: OptionalEIP6492 & OptionalChainId
-  ): Promise<string> {
+  async signMessage(message: ethers.BytesLike, options?: OptionalEIP6492 & OptionalChainId): Promise<string> {
     const method = options?.eip6492 ? 'sequence_sign' : 'personal_sign'
 
     // Address is ignored by the wallet webapp
     return this.send({ method, params: [message, this.getAddress()] }, options?.chainId)
   }
 
-  async signTypedData(
-    typedData: TypedData,
-    options?: OptionalEIP6492 & OptionalChainId
-  ): Promise<string> {
+  async signTypedData(typedData: TypedData, options?: OptionalEIP6492 & OptionalChainId): Promise<string> {
     const method = options?.eip6492 ? 'sequence_signTypedData_v4' : 'eth_signTypedData_v4'
 
     // TODO: Stop using ethers for this, this is the only place where we use it
     // and it makes the client depend on ethers.
-    const encoded =  ethers.utils._TypedDataEncoder.getPayload(typedData.domain, typedData.types, typedData.message)
+    const encoded = ethers.utils._TypedDataEncoder.getPayload(typedData.domain, typedData.types, typedData.message)
 
     // The sign typed data will use one of the following chainIds, in order:
     // - The one provided in the options
     // - The one provided in the typedData.domain.chainId
     // - The default chainId
 
-    return this.send({ method, params: [this.getAddress(), encoded] }, (
+    return this.send(
+      { method, params: [this.getAddress(), encoded] },
       options?.chainId ||
-      (
-        typedData.domain.chainId &&
-        ethers.BigNumber.from(typedData.domain.chainId).toNumber()
-      ) ||
-      this.getChainId()
-    ))
+        (typedData.domain.chainId && ethers.BigNumber.from(typedData.domain.chainId).toNumber()) ||
+        this.getChainId()
+    )
   }
 
   async sendTransaction(
-    tx: (
-      ethers.providers.TransactionRequest[] |
-      ethers.providers.TransactionRequest
-    ),
+    tx: ethers.providers.TransactionRequest[] | ethers.providers.TransactionRequest,
     options?: OptionalChainId
   ): Promise<string> {
     const sequenceTxs = Array.isArray(tx) ? tx : [tx]
     const extendedTxs = toExtended(sequenceTxs)
 
-    return this.send({ method: 'eth_sendTransaction', params: [extendedTxs] }, options?.chainId )
+    return this.send({ method: 'eth_sendTransaction', params: [extendedTxs] }, options?.chainId)
   }
 
   async getWalletContext(): Promise<commons.context.VersionedContext> {
@@ -412,7 +409,10 @@ export class SequenceClient {
 
   async getOnchainWalletConfig(options?: OptionalChainId): Promise<commons.config.Config> {
     // NOTICE: sequence_getWalletConfig sends the chainId as a param
-    const res = await this.send({ method: 'sequence_getWalletConfig', params: [options?.chainId || this.getChainId()] }, options?.chainId)
+    const res = await this.send(
+      { method: 'sequence_getWalletConfig', params: [options?.chainId || this.getChainId()] },
+      options?.chainId
+    )
     return Array.isArray(res) ? res[0] : res
   }
 

package/src/extended.ts

@@ -1,5 +1,4 @@
-
-import { ethers } from "ethers"
+import { ethers } from 'ethers'
 
 export type ExtendedTransactionRequest = ethers.providers.TransactionRequest & {
   auxiliary?: ethers.providers.TransactionRequest[]
@@ -7,14 +6,14 @@ export type ExtendedTransactionRequest = ethers.providers.TransactionRequest & {
 
 export function toExtended(transactions: ethers.providers.TransactionRequest[]): ExtendedTransactionRequest {
   if (transactions.length === 0) {
-    throw new Error("No transaction provided")
+    throw new Error('No transaction provided')
   }
 
   const [first, ...rest] = transactions
 
   return {
     ...first,
-    auxiliary: rest,
+    auxiliary: rest
   }
 }
 

package/src/init.ts

@@ -1,10 +1,19 @@
-import { CachedProvider, ChainIdLike, JsonRpcRouter, JsonRpcSender, NetworkConfig, allNetworks, exceptionProviderMiddleware, findNetworkConfig, loggingProviderMiddleware } from "@0xsequence/network"
-import { MuxTransportTemplate } from "./transports"
-import { ItemStore, useBestStore } from "./utils"
-import { ethers } from "ethers"
-import { SequenceClient } from "./client"
-import { SequenceProvider } from "./provider"
-
+import {
+  CachedProvider,
+  ChainIdLike,
+  JsonRpcRouter,
+  JsonRpcSender,
+  NetworkConfig,
+  allNetworks,
+  exceptionProviderMiddleware,
+  findNetworkConfig,
+  loggingProviderMiddleware
+} from '@0xsequence/network'
+import { MuxTransportTemplate } from './transports'
+import { ItemStore, useBestStore } from './utils'
+import { ethers } from 'ethers'
+import { SequenceClient } from './client'
+import { SequenceProvider } from './provider'
 
 export interface ProviderConfig {
   // The local storage dependency for the wallet provider, defaults to window.localStorage.
@@ -37,14 +46,12 @@ export const DefaultProviderConfig = {
     proxyTransport: { enabled: false }
   },
 
-  defaultNetwork: 1,
+  defaultNetwork: 1
 }
 
 let sequenceWalletProvider: SequenceProvider | undefined
 
-export const initWallet = (
-  partialConfig?: Partial<ProviderConfig>
-) => {
+export const initWallet = (partialConfig?: Partial<ProviderConfig>) => {
   if (sequenceWalletProvider) {
     return sequenceWalletProvider
   }
@@ -55,7 +62,7 @@ export const initWallet = (
     ...partialConfig,
     transports: {
       ...DefaultProviderConfig.transports,
-      ...partialConfig?.transports,
+      ...partialConfig?.transports
     }
   }
 
@@ -63,37 +70,33 @@ export const initWallet = (
 
   // Find any new networks that aren't already defined in sequence.js
   // and add them to the list of networks, (they must have a rpcUrl and chainId)
-  const newNetworks = (config.networks?.filter((n) => {
-    n.rpcUrl !== undefined &&
-    n.chainId !== undefined &&
-    !allNetworks.find((an) => an.chainId === n.chainId)
+  const newNetworks = (config.networks?.filter(n => {
+    n.rpcUrl !== undefined && n.chainId !== undefined && !allNetworks.find(an => an.chainId === n.chainId)
   }) ?? []) as NetworkConfig[]
 
   // Override any information about the networks using the config
-  const combinedNetworks = allNetworks.map((n) => {
-    const network = config.networks?.find((cn) => cn.chainId === n.chainId)
-    return network ? { ...n, ...network } : n
-  }).concat(newNetworks)
+  const combinedNetworks = allNetworks
+    .map(n => {
+      const network = config.networks?.find(cn => cn.chainId === n.chainId)
+      return network ? { ...n, ...network } : n
+    })
+    .concat(newNetworks)
 
   // This build a "public rpc" on demand, we build them on demand because we don't want to
   // generate a bunch of providers for networks that aren't used.
   const providerForChainId = (chainId: number) => {
     if (!rpcProviders[chainId]) {
-      const rpcUrl = combinedNetworks.find((n) => n.chainId === chainId)?.rpcUrl
+      const rpcUrl = combinedNetworks.find(n => n.chainId === chainId)?.rpcUrl
       if (!rpcUrl) {
         throw new Error(`no rpcUrl found for chainId: ${chainId}`)
       }
 
       const baseProvider = new ethers.providers.JsonRpcProvider(rpcUrl)
       const router = new JsonRpcRouter(
-        [
-          loggingProviderMiddleware,
-          exceptionProviderMiddleware,
-          new CachedProvider()
-        ],
+        [loggingProviderMiddleware, exceptionProviderMiddleware, new CachedProvider()],
         new JsonRpcSender(baseProvider)
       )
-  
+
       rpcProviders[chainId] = new ethers.providers.Web3Provider(router, chainId)
     }
 

package/src/provider.ts

@@ -1,11 +1,10 @@
-
-import { ethers } from "ethers"
-import { SequenceClient } from "./client"
-import { ChainIdLike, NetworkConfig, allNetworks, findNetworkConfig } from "@0xsequence/network"
-import { ConnectDetails, ConnectOptions, EIP1193Provider, OpenWalletIntent, OptionalChainIdLike, WalletSession } from "./types"
-import { commons } from "@0xsequence/core"
-import { WalletUtils } from "./utils/index"
-import { SequenceSigner, SingleNetworkSequenceSigner } from "./signer"
+import { ethers } from 'ethers'
+import { SequenceClient } from './client'
+import { ChainIdLike, NetworkConfig, allNetworks, findNetworkConfig } from '@0xsequence/network'
+import { ConnectDetails, ConnectOptions, EIP1193Provider, OpenWalletIntent, OptionalChainIdLike, WalletSession } from './types'
+import { commons } from '@0xsequence/core'
+import { WalletUtils } from './utils/index'
+import { SequenceSigner, SingleNetworkSequenceSigner } from './signer'
 
 export interface ISequenceProvider {
   readonly _isSequenceProvider: true
@@ -55,7 +54,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
 
   readonly signer: SequenceSigner
 
-  constructor (
+  constructor(
     public readonly client: SequenceClient,
     private readonly providerFor: (networkId: number) => ethers.providers.JsonRpcProvider,
     public readonly networks: NetworkConfig[] = allNetworks
@@ -65,19 +64,19 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     super(client.getChainId())
 
     // Emit events as defined by EIP-1193
-    client.onConnect((details) => {
+    client.onConnect(details => {
       this.emit('connect', details)
     })
 
-    client.onDisconnect((error) => {
+    client.onDisconnect(error => {
       this.emit('disconnect', error)
     })
 
-    client.onDefaultChainIdChanged((chainId) => {
+    client.onDefaultChainIdChanged(chainId => {
       this.emit('chainChanged', chainId)
     })
 
-    client.onAccountsChanged((accounts) => {
+    client.onAccountsChanged(accounts => {
       this.emit('accountsChanged', accounts)
     })
 
@@ -164,10 +163,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     return this.client.connect({ ...options, authorize: true })
   }
 
-  async openWallet(
-    path?: string,
-    intent?: OpenWalletIntent
-  ) {
+  async openWallet(path?: string, intent?: OpenWalletIntent) {
     await this.client.openWallet(path, intent)
     return true
   }
@@ -179,13 +175,13 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     if (chainId === undefined) {
       return undefined
     }
-  
+
     const resolved = findNetworkConfig(this.networks, chainId as ChainIdLike)
-  
+
     if (!resolved) {
       throw new Error(`Unsupported network ${chainId}`)
     }
-  
+
     return resolved.chainId
   }
 
@@ -216,11 +212,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     const useChainId = this.toChainId(chainId)
 
     if (!this.singleNetworkProviders[useChainId]) {
-      this.singleNetworkProviders[useChainId] = new SingleNetworkSequenceProvider(
-        this.client,
-        this.providerFor,
-        useChainId
-      )
+      this.singleNetworkProviders[useChainId] = new SingleNetworkSequenceProvider(this.client, this.providerFor, useChainId)
     }
 
     return this.singleNetworkProviders[useChainId]
@@ -247,7 +239,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
   async perform(method: string, params: any): Promise<any> {
     // First we check if the method should be handled by the client
     if (method === 'eth_chainId') {
-      return this.useChainId()
+      return ethers.utils.hexValue(await this.useChainId())
     }
 
     if (method === 'eth_accounts') {
@@ -282,15 +274,15 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     // Forward call to the corresponding provider
     // we use the provided chainId, or the default one provided by the client
     const provider = await this._getSubprovider()
-    const prepared = provider.prepareRequest(method, params) ?? [method, params]    
+    const prepared = provider.prepareRequest(method, params) ?? [method, params]
     return provider.send(prepared[0], prepared[1])
   }
 
-  send (method: string, params: any): Promise<any> {
+  send(method: string, params: any): Promise<any> {
     return this.perform(method, params)
   }
 
-  request (request: { method: string; params?: any[] | undefined }) {
+  request(request: { method: string; params?: any[] | undefined }) {
     return this.perform(request.method, request.params)
   }
 
@@ -312,14 +304,9 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
   // but this would make the code harder to read, and it's not worth it
   // since we only have a few methods to override.
 
-  async waitForTransaction(
-    transactionHash: string,
-    confirmations?: number,
-    timeout?: number,
-    optionals?: OptionalChainIdLike
-  ) {
+  async waitForTransaction(transactionHash: string, confirmations?: number, timeout?: number, optionals?: OptionalChainIdLike) {
     const provider = await this._getSubprovider(optionals?.chainId)
-    return provider.waitForTransaction(transactionHash, confirmations, timeout) 
+    return provider.waitForTransaction(transactionHash, confirmations, timeout)
   }
 
   async getBlockNumber(optionals?: OptionalChainIdLike) {
@@ -378,10 +365,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     return provider.call(transaction, blockTag)
   }
 
-  async estimateGas(
-    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>,
-    optionals?: OptionalChainIdLike
-  ) {
+  async estimateGas(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>, optionals?: OptionalChainIdLike) {
     const provider = await this._getSubprovider(optionals?.chainId)
     return provider.estimateGas(transaction)
   }
@@ -394,18 +378,12 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     return provider.getBlock(blockHashOrBlockTag)
   }
 
-  async getTransaction(
-    transactionHash: string | Promise<string>,
-    optionals?: OptionalChainIdLike
-  ) {
+  async getTransaction(transactionHash: string | Promise<string>, optionals?: OptionalChainIdLike) {
     const provider = await this._getSubprovider(optionals?.chainId)
     return provider.getTransaction(transactionHash)
   }
 
-  async getLogs(
-    filter: ethers.providers.Filter | Promise<ethers.providers.Filter>,
-    optionals?: OptionalChainIdLike
-  ) {
+  async getLogs(filter: ethers.providers.Filter | Promise<ethers.providers.Filter>, optionals?: OptionalChainIdLike) {
     const provider = await this._getSubprovider(optionals?.chainId)
     return provider.getLogs(filter)
   }
@@ -418,7 +396,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
   }
 
   async getResolver(name: string) {
-    if (!await this.supportsENS()) {
+    if (!(await this.supportsENS())) {
       return null
     }
 
@@ -432,7 +410,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
       return name
     }
 
-    if (!await this.supportsENS()) {
+    if (!(await this.supportsENS())) {
       return null
     }
 
@@ -442,7 +420,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
   }
 
   async lookupAddress(address: string | Promise<string>) {
-    if (!await this.supportsENS()) {
+    if (!(await this.supportsENS())) {
       return null
     }
 
@@ -452,7 +430,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
   }
 
   async getAvatar(nameOrAddress: string) {
-    if (!await this.supportsENS()) {
+    if (!(await this.supportsENS())) {
       return null
     }
 
@@ -461,11 +439,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
   }
 
   static is = (provider: any): provider is SequenceProvider => {
-    return (
-      provider &&
-      typeof provider === 'object' &&
-      provider._isSequenceProvider === true
-    )
+    return provider && typeof provider === 'object' && provider._isSequenceProvider === true
   }
 }
 
@@ -477,10 +451,10 @@ function normalizeChainId(chainId: string | number | bigint | { chainId: string
 /**
  *  This is the same provider, but it only allows a single network at a time.
  *  the network defined by the constructor is the only one that can be used.
- * 
+ *
  *  Attempting to call any method with a different network will throw an error.
  *  Attempting to change the network of this provider will throw an error.
- * 
+ *
  *  NOTICE: These networks won't support ENS unless they are the mainnet.
  */
 export class SingleNetworkSequenceProvider extends SequenceProvider {
@@ -532,7 +506,7 @@ export class SingleNetworkSequenceProvider extends SequenceProvider {
     if (this._useChainId(chainId) !== this.chainId) {
       throw new Error(`Unreachable code`)
     }
-  
+
     return this
   }
 
@@ -543,12 +517,8 @@ export class SingleNetworkSequenceProvider extends SequenceProvider {
   setDefaultChainId(_chainId: ChainIdLike): void {
     throw new Error(`This provider only supports the network ${this.chainId}; use the parent provider to switch networks.`)
   }
-  
+
   static is(cand: any): cand is SingleNetworkSequenceProvider {
-    return (
-      cand &&
-      typeof cand === 'object' &&
-      cand._isSingleNetworkSequenceProvider === true
-    )
+    return cand && typeof cand === 'object' && cand._isSingleNetworkSequenceProvider === true
   }
 }