@0xsequence/provider 1.0.5 → 1.1.1

package/src/signer.ts

@@ -0,0 +1,316 @@
+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"
+
+export interface ISequenceSigner extends ethers.Signer {
+  getProvider(): SequenceProvider
+  getProvider(chainId: ChainIdLike): SingleNetworkSequenceProvider
+  getProvider(chainId?: ChainIdLike): SequenceProvider | SingleNetworkSequenceProvider
+
+  getSigner(): SequenceSigner
+  getSigner(chainId: ChainIdLike): SingleNetworkSequenceSigner
+  getSigner(chainId?: ChainIdLike): SequenceSigner | SingleNetworkSequenceSigner
+
+  getWalletConfig(chainId?: ChainIdLike): Promise<commons.config.Config>
+  getNetworks(): Promise<NetworkConfig[]>
+
+  signMessage(
+    message: ethers.BytesLike,
+    options?: OptionalChainIdLike & OptionalEIP6492
+  ): Promise<string>
+
+  signTypedData(
+    domain: ethers.TypedDataDomain,
+    types: Record<string, Array<ethers.TypedDataField>>,
+    message: Record<string, any>,
+    options?: OptionalChainIdLike & OptionalEIP6492
+  ): Promise<string>
+
+  // sendTransaction takes an unsigned transaction, or list of unsigned transactions, and then has it signed by
+  // 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>
+    ),
+    options?: OptionalChainIdLike
+  ): Promise<commons.transaction.TransactionResponse>
+
+  utils: WalletUtils
+}
+
+export class SequenceSigner implements ISequenceSigner {
+  private readonly singleNetworkSigners: { [chainId: number]: SingleNetworkSequenceSigner } = {}
+
+  readonly _isSigner: boolean = true
+  readonly _isSequenceSigner: boolean = true
+
+  get utils(): WalletUtils {
+    return this.provider.utils
+  }
+
+  constructor (
+    public client: SequenceClient,
+    public provider: SequenceProvider
+  ) { }
+
+  async getAddress(): Promise<string> {
+    return this.client.getAddress()
+  }
+
+  // This method shouldn't be used directly
+  // 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")
+    }
+
+    return new SequenceSigner(this.client, provider)
+  }
+
+  getSigner(): SequenceSigner
+  getSigner(chainId: ChainIdLike): SingleNetworkSequenceSigner
+  getSigner(chainId?: ChainIdLike): SingleNetworkSequenceSigner | SequenceSigner
+
+  getSigner(chainId?: ChainIdLike): SingleNetworkSequenceSigner | SequenceSigner {
+    // The signer for the default network is this signer
+    if (!chainId) {
+      return this
+    }
+
+    const useChainId = this.provider.toChainId(chainId)
+
+    if (!this.singleNetworkSigners[useChainId]) {
+      this.singleNetworkSigners[useChainId] = new SingleNetworkSequenceSigner(this.client, this.provider, useChainId)
+    }
+  
+    return this.singleNetworkSigners[useChainId]
+  }
+
+  /**
+   *  Resolves the chainId to use for the given request. If no chainId is provided,
+   *  it uses the chainId defined by the client (default chainId). This can be
+   *  overriden to build a single-network SequenceProvider.
+   */
+  protected useChainId(chainId?: ChainIdLike): number {
+    return this.provider.toChainId(chainId) || this.client.getChainId()
+  }
+
+  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 })
+  }
+
+  async signTypedData(
+    domain: ethers.TypedDataDomain,
+    types: Record<string, Array<ethers.TypedDataField>>,
+    message: Record<string, any>,
+    options?: OptionalChainIdLike & OptionalEIP6492
+  ): Promise<string> {
+    const { eip6492 = true } = options || {}
+    const chainId = this.useChainId(options?.chainId)
+    return this.client.signTypedData({ domain, types, message }, { eip6492, chainId })
+  }
+
+  getProvider(): SequenceProvider
+  getProvider(chainId: ChainIdLike): SingleNetworkSequenceProvider
+  getProvider(chainId?: ChainIdLike): SingleNetworkSequenceProvider | SequenceProvider
+
+  getProvider(chainId?: ChainIdLike): SingleNetworkSequenceProvider | SequenceProvider {
+    return this.provider.getProvider(chainId)
+  }
+
+  async sendTransaction(
+    transaction: (
+      ethers.utils.Deferrable<ethers.providers.TransactionRequest>[] |
+      ethers.utils.Deferrable<ethers.providers.TransactionRequest>
+    ),
+    options?: OptionalChainIdLike
+  ) {
+    const chainId = this.useChainId(options?.chainId)
+    const resolved = await resolveArrayProperties(transaction)
+    const txHash = await this.client.sendTransaction(resolved, { chainId })
+    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
+    } catch (err) {
+      err.transactionHash = txHash
+      throw err
+    }
+  }
+
+  async getWalletConfig(chainId?: ChainIdLike | undefined): Promise<commons.config.Config> {
+    const useChainId = this.useChainId(chainId)
+    return this.client.getOnchainWalletConfig({ chainId: useChainId })
+  }
+
+  getNetworks(): Promise<NetworkConfig[]> {
+    return this.client.getNetworks()
+  }
+
+  async getBalance(
+    blockTag?: ethers.providers.BlockTag | undefined,
+    optionals?: OptionalChainIdLike
+  ): Promise<ethers.BigNumber> {
+    const provider = this.getProvider(optionals?.chainId)
+    return provider.getBalance(this.getAddress(), blockTag)
+  }
+
+  async estimateGas(
+    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>,
+    optionals?: OptionalChainIdLike
+  ): Promise<ethers.BigNumber> {
+    return this.getProvider(optionals?.chainId).estimateGas(transaction)
+  }
+
+  async call(
+    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>,
+    blockTag?: ethers.providers.BlockTag | undefined,
+    optionals?: OptionalChainIdLike
+  ): Promise<string> {
+    return this.getProvider(optionals?.chainId).call(transaction, blockTag)
+  }
+
+  getChainId(): Promise<number> {
+    return Promise.resolve(this.client.getChainId())
+  }
+
+  async getGasPrice(optionals?: OptionalChainIdLike): Promise<ethers.BigNumber> {
+    return this.getProvider(optionals?.chainId).getGasPrice()
+  }
+
+  async getFeeData(optionals?: OptionalChainIdLike): Promise<ethers.providers.FeeData> {
+    return this.getProvider(optionals?.chainId).getFeeData()
+  }
+
+  async resolveName(name: string): Promise<string> {
+    const res = await this.provider.resolveName(name)
+
+    // For some reason ethers.Signer expects this to return `string`
+    // but ethers.providers.Provider expects this to return `string | null`.
+    // The signer doesn't have any other source of information, so we'll
+    // fail if the provider doesn't return a result.
+    if (res === null) {
+      throw new Error(`ENS name not found: ${name}`)
+    }
+
+    return res
+  }
+
+  _checkProvider(_operation?: string | undefined): void {
+    // We always have a provider, so this is a noop
+  }
+
+  populateTransaction(
+    _transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>
+  ): Promise<ethers.providers.TransactionRequest> {
+    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")
+  }
+
+  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")
+  }
+
+  signTransaction(_transaction: ethers.utils.Deferrable<commons.transaction.Transactionish>): Promise<string> {
+    // We could implement signTransaction/sendTransaction here
+    // 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.")
+  }
+
+  static is(cand: any): cand is SequenceSigner {
+    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 (
+    client: SequenceClient,
+    provider: SequenceProvider,
+    public readonly chainId: ChainIdLike
+  ) {
+    super(client, provider.getProvider(chainId))
+  }
+
+  private _useChainId(chainId?: ChainIdLike): number {
+    const provided = this.provider.toChainId(chainId)
+
+    if (provided && provided !== this.chainId) {
+      throw new Error(`This signer only supports the network ${this.chainId}, but ${provided} was requested.`)
+    }
+
+    return provided || this.provider.toChainId(this.chainId)
+  }
+
+  protected useChainId(chainId?: ChainIdLike): number {
+    return this._useChainId(chainId)
+  }
+
+  getChainId(): Promise<number> {
+    return Promise.resolve(this.provider.toChainId(this.chainId))
+  }
+
+  /**
+   *  Override getProvider and getSigner so they always use `useChainId`
+   *  this way they can't return providers and signers that can switch networks,
+   *  or that don't match the chainId of this signer.
+   */
+  getProvider(chainId?: ChainIdLike): SingleNetworkSequenceProvider {
+    return super.getProvider(this._useChainId(chainId))
+  }
+
+  getSigner(chainId?: ChainIdLike | undefined): SingleNetworkSequenceSigner {
+    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
+    )
+  }
+}

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/base-wallet-transport.ts

@@ -19,7 +19,7 @@ import { logger, sanitizeAlphanumeric, sanitizeHost, sanitizeNumberString } from
 import { AuthorizationOptions } from '@0xsequence/auth'
 
 import { PROVIDER_OPEN_TIMEOUT } from './base-provider-transport'
-import { isBrowserExtension, LocalStorage } from '../utils'
+import { isBrowserExtension, useBestStore } from '../utils'
 import { commons } from '@0xsequence/core'
 
 const TRANSPORT_SESSION_LS_KEY = '@sequence.transportSession'
@@ -375,11 +375,6 @@ export abstract class BaseWalletTransport implements WalletTransport {
       // Set connect options on the walletRequestHandler as our primary
       // wallet controller, and fall back to networkId if necessary
       this.walletRequestHandler.setConnectOptions(connectOptions)
-      if (connectOptions.networkId) {
-        networkId = connectOptions.networkId
-      } else if (networkId) {
-        connectOptions.networkId = networkId
-      }
     } else {
       this.walletRequestHandler.setConnectOptions(undefined)
     }
@@ -452,11 +447,11 @@ export abstract class BaseWalletTransport implements WalletTransport {
   }
 
   private saveTransportSession = (session: TransportSession) => {
-    LocalStorage.getInstance().setItem(TRANSPORT_SESSION_LS_KEY, JSON.stringify(session))
+    useBestStore().setItem(TRANSPORT_SESSION_LS_KEY, JSON.stringify(session))
   }
 
   protected getCachedTransportSession = async (): Promise<TransportSession | null> => {
-    const session = await LocalStorage.getInstance().getItem(TRANSPORT_SESSION_LS_KEY)
+    const session = useBestStore().getItem(TRANSPORT_SESSION_LS_KEY)
 
     try {
       return session ? (JSON.parse(session) as TransportSession) : null

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

@@ -1,12 +1,62 @@
 import {
-  ProviderMessage, EventType, ProviderTransport,
+  ProviderMessage, ProviderTransport,
   ProviderEventTypes, ProviderMessageRequest, ProviderMessageResponse, WalletSession, OpenWalletIntent, ConnectDetails
 } from '../../types'
 
 import { JsonRpcRequest, JsonRpcResponseCallback } from '@0xsequence/network'
+import { ProxyMessageChannelPort, ProxyMessageProvider } from '../proxy-transport'
+import { Runtime } from 'webextension-polyfill'
+import { UnrealMessageProvider } from '../unreal-transport'
+import { ExtensionMessageProvider } from '../extension-transport'
+import { WindowMessageProvider } from '../window-transport'
 
-export class MuxMessageProvider implements ProviderTransport {
+export type MuxTransportTemplate = {
+  walletAppURL?: string
+
+  // WindowMessage transport (optional)
+  windowTransport?: {
+    enabled: boolean
+  }
+
+  // ProxyMessage transport (optional)
+  proxyTransport?: {
+    enabled: boolean
+    appPort?: ProxyMessageChannelPort
+  }
+
+  // Extension transport (optional)
+  extensionTransport?: {
+    enabled: boolean
+    runtime: Runtime.Static
+  }
 
+  // Unreal Engine transport (optional)
+  unrealTransport?: {
+    enabled: boolean
+  }
+}
+
+export function isMuxTransportTemplate(obj: any): obj is MuxTransportTemplate {
+  return (
+    obj &&
+    typeof obj === '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.proxyTransport && obj.proxyTransport.enabled) ||
+      (obj.extensionTransport && obj.extensionTransport.enabled) ||
+      (obj.unrealTransport && obj.unrealTransport.enabled)
+    )
+  )
+}
+
+export class MuxMessageProvider implements ProviderTransport {
   private messageProviders: ProviderTransport[]
   private provider: ProviderTransport | undefined
 
@@ -15,6 +65,40 @@ export class MuxMessageProvider implements ProviderTransport {
     this.provider = undefined
   }
 
+  static new(template: MuxTransportTemplate): MuxMessageProvider {
+    const muxMessageProvider = new MuxMessageProvider()
+
+    if (template.windowTransport?.enabled && typeof window === 'object' && template.walletAppURL) {
+      const windowMessageProvider = new WindowMessageProvider(template.walletAppURL)
+      muxMessageProvider.add(windowMessageProvider)
+    }
+
+    if (template.proxyTransport?.enabled) {
+      const proxyMessageProvider = new ProxyMessageProvider(template.proxyTransport.appPort!)
+      muxMessageProvider.add(proxyMessageProvider)
+    }
+
+    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
+      // send all requests to the WindowMessageProvider anyways. By allowing it, if browser restarts, it will break
+      // the entire extension because messageProvider.provider will be undefined. So this is a hack to fix it.
+    }
+
+    if (template.unrealTransport?.enabled && template.windowTransport && template.walletAppURL) {
+      const unrealMessageProvider = new UnrealMessageProvider(template.walletAppURL)
+      muxMessageProvider.add(unrealMessageProvider)
+    }
+
+    muxMessageProvider.register()
+
+    return muxMessageProvider
+  }
+
   add(...messageProviders: ProviderTransport[]) {
     this.messageProviders.push(...messageProviders)
   }

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

@@ -13,7 +13,7 @@ export class ProxyMessageProvider extends BaseProviderTransport {
   constructor(port: ProxyMessageChannelPort) {
     super()
     this.state = OpenState.CLOSED
-    this.port = port    
+    this.port = port
     if (!port) {
       throw new Error('port argument cannot be empty')
     }

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

@@ -7,6 +7,7 @@ import { BigNumber, ethers, providers } from 'ethers'
 import { EventEmitter2 as EventEmitter } from 'eventemitter2'
 
 import { fromExtended } from '../extended'
+import { validateTransactionRequest } from '../transactions'
 import {
   ProviderMessageRequest,
   ProviderMessageResponse,
@@ -22,7 +23,7 @@ import {
   ProviderEventTypes,
   TypedEventEmitter
 } from '../types'
-import { isWalletUpToDate, prefixEIP191Message } from '../utils'
+import { prefixEIP191Message } from '../utils'
 
 type ExternalProvider = providers.ExternalProvider
 
@@ -64,19 +65,6 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
     return this.prompter?.getDefaultChainId() ?? this.networks[0].chainId
   }
 
-  private findNetworkID(network: string | number) {
-    const lnet = typeof network === 'string' ? network.toLowerCase() : network
-    const networkId = this.networks.find(n => {
-      return n.name.toLowerCase() === lnet || n.chainId.toString() === lnet || n.chainId === lnet
-    })
-
-    if (!networkId) {
-      throw new Error(`Network ${network} not found`)
-    }
-
-    return networkId.chainId
-  }
-
   async signIn(account: Account | null, options: WalletSignInOptions = {}) {
     this.setAccount(account)
 
@@ -150,25 +138,7 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
       }
     }
 
-    let chainId: number | string
-    switch (typeof options?.networkId) {
-      case 'string':
-        // First see if it matches the name of a network
-        try {
-          chainId = this.findNetworkID(options.networkId)
-        } catch (err) {
-          // If not, try to parse it as a big number
-          chainId = getChainId(options.networkId)
-        }
-
-        break
-      case 'number':
-        chainId = options.networkId
-        break
-      default:
-        chainId = this.prompter?.getDefaultChainId() ?? 1
-        break
-    }
+    const chainId: number | string = this.prompter?.getDefaultChainId() ?? 1
 
     const connectDetails: ConnectDetails = {
       connected: true,
@@ -424,6 +394,8 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
               return tx
             })
 
+          validateTransactionRequest(account.address, transactionParams)
+
           let txnHash = ''
           if (this.prompter === null) {
             // prompter is null, so we'll send from here
@@ -452,6 +424,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.
@@ -740,6 +714,7 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
   }
 
   notifyConnect(connectDetails: ConnectDetails, origin?: string) {
+    console.log('emit connect', connectDetails)
     this.events.emit('connect', connectDetails)
     if (connectDetails.session?.accountAddress) {
       this.events.emit('accountsChanged', [connectDetails.session?.accountAddress], origin)

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

@@ -88,11 +88,13 @@ 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 = {}
+        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
-        if (!isBrowserExtension() && !isUnityPlugin()) {
+        if (!isBrowserExtension() && !isUnityPlugin() && intent.options) {
           intent.options.origin = window.location.origin
         }
       }

package/src/types.ts

@@ -1,6 +1,6 @@
 import { ETHAuthProof as AuthETHAuthProof } from '@0xsequence/auth'
 import { commons } from '@0xsequence/core'
-import { 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 {
@@ -21,6 +21,20 @@ export interface ProviderTransport extends JsonRpcHandler, ProviderMessageTransp
   waitUntilConnected(): Promise<ConnectDetails>
 }
 
+export function isProviderTransport(transport: any): transport is ProviderTransport {
+  return (
+    transport &&
+    typeof transport === 'object' &&
+    typeof transport.register === 'function' &&
+    typeof transport.unregister === 'function' &&
+    typeof transport.openWallet === 'function' &&
+    typeof transport.closeWallet === 'function' &&
+    typeof transport.isOpened === 'function' &&
+    typeof transport.isConnected === 'function' &&
+    typeof transport.on === 'function'
+  )
+}
+
 export interface WalletTransport extends JsonRpcHandler, ProviderMessageTransport, ProviderMessageRequestHandler {
   register(): void
   unregister(): void
@@ -134,12 +148,8 @@ export enum InitState {
 }
 
 export interface ConnectOptions {
-  /** Specifies the default network a dapp would like to connect to. This field
-   * is optional as it can be provided a number of different ways. */
-  networkId?: string | number
-
   /** app name of the dapp which will be announced to user on connect screen */
-  app?: string
+  app: string
 
   /** custom protocol for auth redirect (unity/unreal) */
   appProtocol?: string
@@ -171,6 +181,13 @@ export interface ConnectOptions {
   settings?: Settings
 }
 
+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;
+}
+
 /** Options to further customize the wallet experience. */
 export interface Settings {
   /** Specify a wallet theme. `light` and `dark` are the main themes, to use other available
@@ -256,7 +273,7 @@ export interface ConnectDetails {
 export type PromptConnectDetails = Pick<ConnectDetails, 'chainId' | 'error' | 'connected' | 'proof' | 'email'>
 
 export type OpenWalletIntent =
-  | { type: 'connect'; options?: ConnectOptions }
+  | { type: 'connect'; options?: NetworkedConnectOptions }
   | { type: 'openWithOptions'; options?: ConnectOptions }
   | { type: 'jsonRpcRequest'; method: string }
 
@@ -280,9 +297,6 @@ export interface WalletSession {
   // Networks in use for the session. The default/dapp network will show
   // up as the first one in the list as the "main chain"
   networks?: NetworkConfig[]
-
-  // Caching provider responses for things such as account and chainId
-  providerCache?: { [key: string]: any }
 }
 
 export class ProviderError extends Error {
@@ -314,3 +328,20 @@ 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 OptionalChainId = {
+  chainId?: number
+} | 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>
+}