@0xsequence/provider 1.1.0 → 1.1.2

package/src/signer.ts

@@ -1,12 +1,12 @@
-import { ethers } from "ethers"
+import { ethers } from 'ethers'
 
-import { SequenceProvider, SingleNetworkSequenceProvider } from "./provider"
-import { SequenceClient } from "./client"
-import { commons } from "@0xsequence/core"
-import { ChainIdLike, NetworkConfig } from "@0xsequence/network"
-import { resolveArrayProperties } from "./utils"
-import { WalletUtils } from "./utils/index"
-import { OptionalChainIdLike, OptionalEIP6492 } from "./types"
+import { SequenceProvider, SingleNetworkSequenceProvider } from './provider'
+import { SequenceClient } from './client'
+import { commons } from '@0xsequence/core'
+import { ChainIdLike, NetworkConfig } from '@0xsequence/network'
+import { resolveArrayProperties } from './utils'
+import { WalletUtils } from './utils/index'
+import { OptionalChainIdLike, OptionalEIP6492 } from './types'
 
 export interface ISequenceSigner extends ethers.Signer {
   getProvider(): SequenceProvider
@@ -20,10 +20,7 @@ export interface ISequenceSigner extends ethers.Signer {
   getWalletConfig(chainId?: ChainIdLike): Promise<commons.config.Config>
   getNetworks(): Promise<NetworkConfig[]>
 
-  signMessage(
-    message: ethers.BytesLike,
-    options?: OptionalChainIdLike & OptionalEIP6492
-  ): Promise<string>
+  signMessage(message: ethers.BytesLike, options?: OptionalChainIdLike & OptionalEIP6492): Promise<string>
 
   signTypedData(
     domain: ethers.TypedDataDomain,
@@ -36,10 +33,9 @@ export interface ISequenceSigner extends ethers.Signer {
   // the signer, and finally sends it to the relayer for submission to an Ethereum network.
   // It supports any kind of transaction, including regular ethers transactions, and Sequence transactions.
   sendTransaction(
-    transaction: (
-      ethers.utils.Deferrable<ethers.providers.TransactionRequest>[] |
-      ethers.utils.Deferrable<ethers.providers.TransactionRequest>
-    ),
+    transaction:
+      | ethers.utils.Deferrable<ethers.providers.TransactionRequest>[]
+      | ethers.utils.Deferrable<ethers.providers.TransactionRequest>,
     options?: OptionalChainIdLike
   ): Promise<commons.transaction.TransactionResponse>
 
@@ -56,10 +52,10 @@ export class SequenceSigner implements ISequenceSigner {
     return this.provider.utils
   }
 
-  constructor (
+  constructor(
     public client: SequenceClient,
     public provider: SequenceProvider
-  ) { }
+  ) {}
 
   async getAddress(): Promise<string> {
     return this.client.getAddress()
@@ -69,7 +65,7 @@ export class SequenceSigner implements ISequenceSigner {
   // it exists to maintain compatibility with ethers.Signer
   connect(provider: ethers.providers.Provider): SequenceSigner {
     if (!SequenceProvider.is(provider)) {
-      throw new Error("SequenceSigner can only be connected to a SequenceProvider")
+      throw new Error('SequenceSigner can only be connected to a SequenceProvider')
     }
 
     return new SequenceSigner(this.client, provider)
@@ -90,7 +86,7 @@ export class SequenceSigner implements ISequenceSigner {
     if (!this.singleNetworkSigners[useChainId]) {
       this.singleNetworkSigners[useChainId] = new SingleNetworkSequenceSigner(this.client, this.provider, useChainId)
     }
-  
+
     return this.singleNetworkSigners[useChainId]
   }
 
@@ -103,10 +99,7 @@ export class SequenceSigner implements ISequenceSigner {
     return this.provider.toChainId(chainId) || this.client.getChainId()
   }
 
-  async signMessage(
-    message: ethers.BytesLike,
-    options?: OptionalChainIdLike & OptionalEIP6492
-  ): Promise<string> {
+  async signMessage(message: ethers.BytesLike, options?: OptionalChainIdLike & OptionalEIP6492): Promise<string> {
     const { eip6492 = true } = options || {}
     const chainId = this.useChainId(options?.chainId)
     return this.client.signMessage(message, { eip6492, chainId })
@@ -132,10 +125,9 @@ export class SequenceSigner implements ISequenceSigner {
   }
 
   async sendTransaction(
-    transaction: (
-      ethers.utils.Deferrable<ethers.providers.TransactionRequest>[] |
-      ethers.utils.Deferrable<ethers.providers.TransactionRequest>
-    ),
+    transaction:
+      | ethers.utils.Deferrable<ethers.providers.TransactionRequest>[]
+      | ethers.utils.Deferrable<ethers.providers.TransactionRequest>,
     options?: OptionalChainIdLike
   ) {
     const chainId = this.useChainId(options?.chainId)
@@ -144,10 +136,13 @@ export class SequenceSigner implements ISequenceSigner {
     const provider = this.getProvider(chainId)
 
     try {
-      return await ethers.utils.poll(async () => {
-        const tx = await provider.getTransaction(txHash)
-        return tx ? provider._wrapTransaction(tx, txHash) : undefined
-      }, { onceBlock: provider }) as ethers.providers.TransactionResponse
+      return (await ethers.utils.poll(
+        async () => {
+          const tx = await provider.getTransaction(txHash)
+          return tx ? provider._wrapTransaction(tx, txHash) : undefined
+        },
+        { onceBlock: provider }
+      )) as ethers.providers.TransactionResponse
     } catch (err) {
       err.transactionHash = txHash
       throw err
@@ -163,10 +158,7 @@ export class SequenceSigner implements ISequenceSigner {
     return this.client.getNetworks()
   }
 
-  async getBalance(
-    blockTag?: ethers.providers.BlockTag | undefined,
-    optionals?: OptionalChainIdLike
-  ): Promise<ethers.BigNumber> {
+  async getBalance(blockTag?: ethers.providers.BlockTag | undefined, optionals?: OptionalChainIdLike): Promise<ethers.BigNumber> {
     const provider = this.getProvider(optionals?.chainId)
     return provider.getBalance(this.getAddress(), blockTag)
   }
@@ -219,19 +211,19 @@ export class SequenceSigner implements ISequenceSigner {
   populateTransaction(
     _transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>
   ): Promise<ethers.providers.TransactionRequest> {
-    throw new Error("SequenceSigner does not support populateTransaction")
+    throw new Error('SequenceSigner does not support populateTransaction')
   }
 
   checkTransaction(
     _transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>
   ): ethers.utils.Deferrable<ethers.providers.TransactionRequest> {
-    throw new Error("SequenceSigner does not support checkTransaction")
+    throw new Error('SequenceSigner does not support checkTransaction')
   }
 
   getTransactionCount(_blockTag?: ethers.providers.BlockTag | undefined): Promise<number> {
     // We could try returning the sequence nonce here
     // but we aren't sure how ethers will use this nonce
-    throw new Error("SequenceSigner does not support getTransactionCount")
+    throw new Error('SequenceSigner does not support getTransactionCount')
   }
 
   signTransaction(_transaction: ethers.utils.Deferrable<commons.transaction.Transactionish>): Promise<string> {
@@ -239,31 +231,27 @@ export class SequenceSigner implements ISequenceSigner {
     // but first we need a way of serializing these signed transactions
     // and it could lead to more trouble, because the dapp could try to send this transaction
     // using a different provider, which would fail.
-    throw new Error("SequenceWallet does not support signTransaction, use sendTransaction instead.")
+    throw new Error('SequenceWallet does not support signTransaction, use sendTransaction instead.')
   }
 
   static is(cand: any): cand is SequenceSigner {
-    return (
-      cand &&
-      typeof cand === "object" &&
-      cand._isSequenceSigner === true
-    )
+    return cand && typeof cand === 'object' && cand._isSequenceSigner === true
   }
 }
 
 /**
  *  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 SingleNetworkSequenceSigner extends SequenceSigner {
   readonly _isSingleNetworkSequenceSigner = true
 
-  constructor (
+  constructor(
     client: SequenceClient,
     provider: SequenceProvider,
     public readonly chainId: ChainIdLike
@@ -302,15 +290,11 @@ export class SingleNetworkSequenceSigner extends SequenceSigner {
     if (this._useChainId(chainId) !== this.chainId) {
       throw new Error(`Unreachable code`)
     }
-  
+
     return this
   }
 
   static is(cand: any): cand is SingleNetworkSequenceSigner {
-    return (
-      cand &&
-      typeof cand === "object" &&
-      cand._isSingleNetworkSequenceSigner === true
-    )
+    return cand && typeof cand === 'object' && cand._isSingleNetworkSequenceSigner === true
   }
 }

package/src/transactions.ts

@@ -0,0 +1,23 @@
+import { commons } from '@0xsequence/core'
+import { ethers } from 'ethers'
+
+export function validateTransactionRequest(wallet: string, transaction: commons.transaction.Transactionish) {
+  const transactions = commons.transaction.fromTransactionish(wallet, transaction)
+  const unwound = commons.transaction.unwind(wallet, transactions)
+  unwound.forEach(transaction => validateTransaction(wallet, transaction))
+}
+
+function validateTransaction(wallet: string, transaction: commons.transaction.Transaction) {
+  if (transaction.to.toLowerCase() === wallet.toLowerCase()) {
+    if (transaction.data) {
+      const data = ethers.utils.arrayify(transaction.data)
+      if (data.length >= 4) {
+        throw new Error('self calls are forbidden')
+      }
+    }
+  }
+
+  if (transaction.delegateCall) {
+    throw new Error('delegate calls are forbidden')
+  }
+}

package/src/transports/extension-transport/extension-message-handler.ts

@@ -9,7 +9,10 @@ export const CHANNEL_ID = 'sequence-extension-message-handler'
 export class ExtensionMessageHandler extends BaseWalletTransport {
   private port: any
 
-  constructor(walletRequestHandler: WalletRequestHandler, public runtime: Runtime.Static) {
+  constructor(
+    walletRequestHandler: WalletRequestHandler,
+    public runtime: Runtime.Static
+  ) {
     super(walletRequestHandler)
     this._init = InitState.OK
   }

package/src/transports/extension-transport/index.ts

@@ -1,3 +1,3 @@
 export * from './extension-message-handler'
 export * from './extension-message-provider'
-export * from './base-injected-transport'
+export * from './base-injected-transport'

package/src/transports/mux-transport/mux-message-provider.ts

@@ -1,6 +1,12 @@
 import {
-  ProviderMessage, ProviderTransport,
-  ProviderEventTypes, ProviderMessageRequest, ProviderMessageResponse, WalletSession, OpenWalletIntent, ConnectDetails
+  ProviderMessage,
+  ProviderTransport,
+  ProviderEventTypes,
+  ProviderMessageRequest,
+  ProviderMessageResponse,
+  WalletSession,
+  OpenWalletIntent,
+  ConnectDetails
 } from '../../types'
 
 import { JsonRpcRequest, JsonRpcResponseCallback } from '@0xsequence/network'
@@ -40,19 +46,15 @@ export function isMuxTransportTemplate(obj: any): obj is MuxTransportTemplate {
   return (
     obj &&
     typeof obj === 'object' &&
-    (
-      (obj.windowTransport && typeof obj.windowTransport === 'object') ||
+    ((obj.windowTransport && typeof obj.windowTransport === 'object') ||
       (obj.proxyTransport && typeof obj.proxyTransport === 'object') ||
       (obj.extensionTransport && typeof obj.extensionTransport === 'object') ||
-      (obj.unrealTransport && typeof obj.unrealTransport === 'object')
-    ) &&
-    (
-      // One of the transports must be enabled
-      (obj.windowTransport && obj.windowTransport.enabled) ||
+      (obj.unrealTransport && typeof obj.unrealTransport === 'object')) &&
+    // One of the transports must be enabled
+    ((obj.windowTransport && obj.windowTransport.enabled) ||
       (obj.proxyTransport && obj.proxyTransport.enabled) ||
       (obj.extensionTransport && obj.extensionTransport.enabled) ||
-      (obj.unrealTransport && obj.unrealTransport.enabled)
-    )
+      (obj.unrealTransport && obj.unrealTransport.enabled))
   )
 }
 
@@ -81,7 +83,7 @@ export class MuxMessageProvider implements ProviderTransport {
     if (template.extensionTransport?.enabled) {
       const extensionMessageProvider = new ExtensionMessageProvider(template.extensionTransport.runtime)
       muxMessageProvider.add(extensionMessageProvider)
-  
+
       // NOTE/REVIEW: see note in mux-message-provider
       //
       // We don't add the extensionMessageProvider here because we don't send requests to it anyways, we seem to
@@ -190,7 +192,7 @@ export class MuxMessageProvider implements ProviderTransport {
     if (this.provider) {
       return this.provider.emit(event, ...args)
     }
-    for (let i=0; i < this.messageProviders.length; i++) {
+    for (let i = 0; i < this.messageProviders.length; i++) {
       this.messageProviders[i].emit(event, ...args)
     }
     return true
@@ -244,5 +246,4 @@ export class MuxMessageProvider implements ProviderTransport {
     }
     throw new Error('impossible state, wallet must be opened first')
   }
-
 }

package/src/transports/proxy-transport/proxy-message-channel.ts

@@ -21,7 +21,6 @@ export class ProxyMessageChannelPort implements ProviderMessageTransport {
   conn: ProviderMessageTransport
   events: TypedEventEmitter<ProxyEventTypes> = new EventEmitter() as TypedEventEmitter<ProxyEventTypes>
 
-
   // handle messages which hit this port
   handleMessage = (message: ProviderMessage<any>): void => {
     throw new Error('ProxyMessageChannelPort is not registered')

package/src/transports/proxy-transport/proxy-message-provider.ts

@@ -1,15 +1,12 @@
 import { BaseProviderTransport } from '../base-provider-transport'
 
-import {
-  ProviderMessage, OpenState, OpenWalletIntent, EventType, InitState
-} from '../../types'
+import { ProviderMessage, OpenState, OpenWalletIntent, EventType, InitState } from '../../types'
 
 import { ProxyMessageChannelPort, ProxyEventTypes } from './proxy-message-channel'
 
 export class ProxyMessageProvider extends BaseProviderTransport {
-
   private port: ProxyMessageChannelPort
-  
+
   constructor(port: ProxyMessageChannelPort) {
     super()
     this.state = OpenState.CLOSED
@@ -58,8 +55,13 @@ export class ProxyMessageProvider extends BaseProviderTransport {
       const sessionId = `${performance.now()}`
       this._sessionId = sessionId
       this.sendMessage({
-        idx: -1, type: EventType.OPEN, data: {
-          path, intent, networkId, sessionId
+        idx: -1,
+        type: EventType.OPEN,
+        data: {
+          path,
+          intent,
+          networkId,
+          sessionId
         }
       })
     }
@@ -67,7 +69,9 @@ export class ProxyMessageProvider extends BaseProviderTransport {
 
   closeWallet() {
     this.sendMessage({
-      idx: -1, type: EventType.CLOSE, data: null
+      idx: -1,
+      type: EventType.CLOSE,
+      data: null
     })
     this.close()
   }

package/src/transports/unreal-transport/index.ts

@@ -1,2 +1,2 @@
 export * from './unreal-message-provider'
-export * from './unreal-message-handler'
+export * from './unreal-message-handler'

package/src/transports/unreal-transport/overridelogs.ts

@@ -30,7 +30,5 @@ export function overrideLogs(side: 'dapp' | 'wallet') {
 }
 
 function stringify(things: unknown[]): string {
-  return things
-    .map(a => (typeof a === 'object' ? (a instanceof Error ? a.message : JSON.stringify(a)) : String(a)))
-    .join(' ')
+  return things.map(a => (typeof a === 'object' ? (a instanceof Error ? a.message : JSON.stringify(a)) : String(a))).join(' ')
 }

package/src/transports/wallet-request-handler.ts

@@ -1,12 +1,20 @@
 import { Account, AccountStatus } from '@0xsequence/account'
 import { signAuthorization, AuthorizationOptions } from '@0xsequence/auth'
 import { commons } from '@0xsequence/core'
-import { NetworkConfig, JsonRpcHandler, JsonRpcRequest, JsonRpcResponseCallback, JsonRpcResponse, getChainId } from '@0xsequence/network'
+import {
+  NetworkConfig,
+  JsonRpcHandler,
+  JsonRpcRequest,
+  JsonRpcResponseCallback,
+  JsonRpcResponse,
+  getChainId
+} from '@0xsequence/network'
 import { logger, TypedData } from '@0xsequence/utils'
 import { BigNumber, ethers, providers } from 'ethers'
 import { EventEmitter2 as EventEmitter } from 'eventemitter2'
 
 import { fromExtended } from '../extended'
+import { validateTransactionRequest } from '../transactions'
 import {
   ProviderMessageRequest,
   ProviderMessageResponse,
@@ -50,11 +58,7 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
 
   onConnectOptionsChange: ((connectOptions: ConnectOptions | undefined) => void) | undefined = undefined
 
-  constructor(
-    account: Account | null | undefined,
-    prompter: WalletUserPrompter | null,
-    networks: NetworkConfig[]
-  ) {
+  constructor(account: Account | null | undefined, prompter: WalletUserPrompter | null, networks: NetworkConfig[]) {
     this.account = account
     this.prompter = prompter
     this.networks = networks
@@ -95,7 +99,7 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
         this.notifyClose()
       }
     }
-  
+
     if (defaultNetworkId && this.defaultChainId() !== defaultNetworkId) {
       await this.prompter?.promptChangeNetwork(defaultNetworkId)
     }
@@ -141,7 +145,7 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
 
     const connectDetails: ConnectDetails = {
       connected: true,
-      chainId: ethers.BigNumber.from(chainId).toHexString()
+      chainId: ethers.utils.hexValue(chainId)
     }
 
     if (options && options.authorize) {
@@ -316,13 +320,20 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
           const sequenceVerified = request.method === 'sequence_sign'
           if (this.prompter === null) {
             // prompter is null, so we'll sign from here
-            sig = await account.signMessage(prefixedMessage, chainId ?? this.defaultChainId(), sequenceVerified ? 'eip6492' : 'ignore')
+            sig = await account.signMessage(
+              prefixedMessage,
+              chainId ?? this.defaultChainId(),
+              sequenceVerified ? 'eip6492' : 'ignore'
+            )
           } else {
-            sig = await this.prompter.promptSignMessage({
-              chainId: chainId,
-              message: prefixedMessage,
-              eip6492: sequenceVerified
-            }, this.connectOptions)
+            sig = await this.prompter.promptSignMessage(
+              {
+                chainId: chainId,
+                message: prefixedMessage,
+                eip6492: sequenceVerified
+              },
+              this.connectOptions
+            )
           }
 
           if (sig && sig.length > 0) {
@@ -361,13 +372,22 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
           const sequenceVerified = request.method === 'sequence_signTypedData_v4'
           if (this.prompter === null) {
             // prompter is null, so we'll sign from here
-            sig = await account.signTypedData(typedData.domain, typedData.types, typedData.message, chainId ?? this.defaultChainId(), sequenceVerified ? 'eip6492' : 'ignore')
+            sig = await account.signTypedData(
+              typedData.domain,
+              typedData.types,
+              typedData.message,
+              chainId ?? this.defaultChainId(),
+              sequenceVerified ? 'eip6492' : 'ignore'
+            )
           } else {
-            sig = await this.prompter.promptSignMessage({
-              chainId: chainId,
-              typedData: typedData,
-              eip6492: sequenceVerified
-            }, this.connectOptions)
+            sig = await this.prompter.promptSignMessage(
+              {
+                chainId: chainId,
+                typedData: typedData,
+                eip6492: sequenceVerified
+              },
+              this.connectOptions
+            )
           }
 
           if (sig && sig.length > 0) {
@@ -381,17 +401,18 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
 
         case 'eth_sendTransaction': {
           // https://eth.wiki/json-rpc/API#eth_sendtransaction
-          const transactionParams = fromExtended(request.params![0])
-            .map((tx) => {
-              // eth_sendTransaction uses 'gas'
-              // ethers and sequence use 'gasLimit'
-              if ('gas' in tx && tx.gasLimit === undefined) {
-                tx.gasLimit = tx.gas as any
-                delete tx.gas
-              }
-
-              return tx
-            })
+          const transactionParams = fromExtended(request.params![0]).map(tx => {
+            // eth_sendTransaction uses 'gas'
+            // ethers and sequence use 'gasLimit'
+            if ('gas' in tx && tx.gasLimit === undefined) {
+              tx.gasLimit = tx.gas as any
+              delete tx.gas
+            }
+
+            return tx
+          })
+
+          validateTransactionRequest(account.address, transactionParams)
 
           let txnHash = ''
           if (this.prompter === null) {
@@ -421,6 +442,8 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
             throw new Error('sender address does not match wallet')
           }
 
+          validateTransactionRequest(account.address, transaction)
+
           if (this.prompter === null) {
             // The eth_signTransaction method expects a `string` return value we instead return a `SignedTransactions` object,
             // this can only be broadcasted using an RPC provider with support for signed Sequence transactions, like this one.
@@ -534,10 +557,12 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
           if (chainId) {
             response.result = [(await account.status(chainId)).onChain.config]
           } else {
-            response.result = await Promise.all(account.networks.map(async network => {
-              const status = await account.status(network.chainId)
-              return status.onChain.config
-            }))
+            response.result = await Promise.all(
+              account.networks.map(async network => {
+                const status = await account.status(network.chainId)
+                return status.onChain.config
+              })
+            )
           }
           break
         }
@@ -549,10 +574,12 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
           if (chainId) {
             response.result = [getLegacyWalletState(chainId, await account.status(chainId))]
           } else {
-            response.result = await Promise.all(account.networks.map(async network => {
-              const status = await account.status(network.chainId)
-              return getLegacyWalletState(network.chainId, status)
-            }))
+            response.result = await Promise.all(
+              account.networks.map(async network => {
+                const status = await account.status(network.chainId)
+                return getLegacyWalletState(network.chainId, status)
+              })
+            )
           }
           break
         }
@@ -704,7 +731,7 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
       walletContext: this.account.contexts,
       accountAddress: this.account.address,
       // The dapp shouldn't access the relayer directly, and the provider (as an object) is not serializable.
-      networks: this.account.networks.map((n) => ({ ...n, provider: undefined, relayer: undefined }))
+      networks: this.account.networks.map(n => ({ ...n, provider: undefined, relayer: undefined }))
     }
   }
 

package/src/transports/window-transport/window-message-provider.ts

@@ -88,9 +88,10 @@ export class WindowMessageProvider extends BaseProviderTransport {
       // when connecting to the wallet, however, this will be verified and enforced
       // on the wallet-side, so if a dapp provides the wrong origin, it will be dropped.
       if (intent.type === 'connect') {
-        if (!intent.options) intent.options = {
-          app: window.location.origin
-        }
+        if (!intent.options)
+          intent.options = {
+            app: window.location.origin
+          }
 
         // skip setting origin host if we're in an browser extension execution context
         // allow origin that is passed in

package/src/types.ts

@@ -1,6 +1,13 @@
 import { ETHAuthProof as AuthETHAuthProof } from '@0xsequence/auth'
 import { commons } from '@0xsequence/core'
-import { ChainIdLike, JsonRpcHandler, JsonRpcRequest, JsonRpcResponse, NetworkConfig, ProviderRpcError as NetworkProviderRpcError } from '@0xsequence/network'
+import {
+  ChainIdLike,
+  JsonRpcHandler,
+  JsonRpcRequest,
+  JsonRpcResponse,
+  NetworkConfig,
+  ProviderRpcError as NetworkProviderRpcError
+} from '@0xsequence/network'
 import { TypedData } from '@0xsequence/utils'
 
 export interface ProviderTransport extends JsonRpcHandler, ProviderMessageTransport, ProviderMessageRequestHandler {
@@ -185,7 +192,7 @@ export interface NetworkedConnectOptions extends ConnectOptions {
   /** chainId is the chainId to connect to. If not specified, the default chainId
    * will be used. This does not define a default chain id, it is only used for the connect
    * authorization signature. */
-  networkId?: string | number;
+  networkId?: string | number
 }
 
 /** Options to further customize the wallet experience. */
@@ -329,19 +336,25 @@ export interface TypedEventEmitter<Events> {
 
 type Arguments<T> = [T] extends [(...args: infer U) => any] ? U : [T] extends [void] ? [] : [T]
 
-export type OptionalChainIdLike = {
-  chainId?: ChainIdLike
-} | undefined
+export type OptionalChainIdLike =
+  | {
+      chainId?: ChainIdLike
+    }
+  | undefined
 
-export type OptionalChainId = {
-  chainId?: number
-} | undefined
+export type OptionalChainId =
+  | {
+      chainId?: number
+    }
+  | undefined
 
-export type OptionalEIP6492 = {
-  eip6492?: boolean
-} | undefined
+export type OptionalEIP6492 =
+  | {
+      eip6492?: boolean
+    }
+  | undefined
 
 // This is required by viem, it expects a provider to have an EIP-1193 compliant `request` attribute.
 export interface EIP1193Provider {
-  request: (request: { method: string, params?: Array<any> }) => Promise<any>
+  request: (request: { method: string; params?: Array<any> }) => Promise<any>
 }