@0xsequence/provider 0.43.34 → 1.0.0

package/src/types.ts

@@ -1,4 +1,6 @@
-import { NetworkConfig, WalletContext, JsonRpcRequest, JsonRpcResponse, JsonRpcHandler } from '@0xsequence/network'
+import { ETHAuthProof as AuthETHAuthProof } from '@0xsequence/auth'
+import { commons } from '@0xsequence/core'
+import { JsonRpcHandler, JsonRpcRequest, JsonRpcResponse, NetworkConfig, ProviderRpcError as NetworkProviderRpcError } from '@0xsequence/network'
 import { TypedData } from '@0xsequence/utils'
 
 export interface ProviderTransport extends JsonRpcHandler, ProviderMessageTransport, ProviderMessageRequestHandler {
@@ -49,11 +51,7 @@ export type ProviderMessageResponse = ProviderMessage<JsonRpcResponse>
 // which may contain the result or an error payload from the wallet.
 export type ProviderMessageResponseCallback = (error?: ProviderRpcError, response?: ProviderMessageResponse) => void
 
-export interface ProviderRpcError extends Error {
-  message: string
-  code?: number
-  data?: { [key: string]: any }
-}
+export type ProviderRpcError = NetworkProviderRpcError
 
 export interface ProviderMessageRequestHandler {
   // sendMessageRequest sends a ProviderMessageRequest over the wire to the wallet.
@@ -116,7 +114,7 @@ export interface WalletEventTypes {
   chainChanged: (chainIdHex: string) => void
 
   networks: (networks: NetworkConfig[]) => void
-  walletContext: (walletContext: WalletContext) => void
+  walletContext: (walletContext: commons.context.VersionedContext) => void
 }
 
 export interface ProviderEventTypes extends WalletEventTypes {
@@ -156,6 +154,9 @@ export interface ConnectOptions {
   /** authorize will perform an ETHAuth eip712 signing and return the proof to the dapp. */
   authorize?: boolean
 
+  /** authorizeVersion is the version of the SDK that will validate the ETHAuth proof. */
+  authorizeVersion?: number
+
   /** askForEmail will prompt to give permission to the dapp to access email address */
   askForEmail?: boolean
 
@@ -263,19 +264,15 @@ export interface MessageToSign {
   message?: Uint8Array
   typedData?: TypedData
   chainId?: number
-}
 
-export interface ETHAuthProof {
-  // eip712 typed-data payload for ETHAuth domain as input
-  typedData: TypedData
-
-  // signature encoded in an ETHAuth proof string
-  proofString: string
+  eip6492?: boolean
 }
 
+export type ETHAuthProof = AuthETHAuthProof
+
 export interface WalletSession {
   // Wallet context
-  walletContext?: WalletContext
+  walletContext?: commons.context.VersionedContext
 
   // Account address of the wallet
   accountAddress?: string

package/src/utils/index.ts

@@ -1,10 +1,8 @@
-import { BigNumberish, BytesLike, TypedDataDomain, TypedDataField } from 'ethers'
-import { WalletContext, ChainIdLike } from '@0xsequence/network'
+import { BytesLike, TypedDataDomain, TypedDataField } from 'ethers'
+import { ChainIdLike } from '@0xsequence/network'
 import { encodeMessageDigest, TypedData, encodeTypedDataDigest } from '@0xsequence/utils'
-import { DecodedSignature, WalletConfig } from '@0xsequence/config'
 import { Wallet } from '../wallet'
-import { isValidSignature, prefixEIP191Message, recoverWalletConfig } from '../utils'
-import { isValidEIP712Signature, isValidEthSignSignature } from '@0xsequence/wallet'
+import { isValidSignature, prefixEIP191Message } from '../utils'
 
 export class WalletUtils {
   private wallet: Wallet
@@ -22,7 +20,7 @@ export class WalletUtils {
 
   // Sign message on the AuthChain
   async signAuthMessage(message: BytesLike, allSigners?: boolean): Promise<string> {
-    const signer = await this.wallet.getAuthSigner()
+    const signer = this.wallet.getSigner()
     if (!signer) throw new Error('unable to get AuthChain signer')
     return signer.signMessage(message, await signer.getChainId(), allSigners)
   }
@@ -47,7 +45,7 @@ export class WalletUtils {
     message: Record<string, any>,
     allSigners?: boolean
   ): Promise<string> {
-    const signer = await this.wallet.getAuthSigner()
+    const signer = this.wallet.getSigner()
     if (!signer) throw new Error('unable to get AuthChain signer')
     return signer.signTypedData(domain, types, message, await signer.getChainId(), allSigners)
   }
@@ -57,12 +55,11 @@ export class WalletUtils {
     address: string,
     digest: Uint8Array,
     signature: string,
-    chainId: number,
-    walletContext?: WalletContext
+    chainId: number
   ): Promise<boolean> {
     const provider = this.wallet.getProvider(chainId)
     if (!provider) throw new Error(`unable to get provider for chainId ${chainId}`)
-    return isValidSignature(address, digest, signature, provider, chainId, walletContext)
+    return isValidSignature(address, digest, signature, provider, await this.wallet.getWalletContext())
   }
 
   // Verify message signature
@@ -70,14 +67,13 @@ export class WalletUtils {
     address: string,
     message: string | Uint8Array,
     signature: string,
-    chainId: number,
-    walletContext?: WalletContext
+    chainId: number
   ): Promise<boolean> {
     const provider = this.wallet.getProvider(chainId)
     if (!provider) throw new Error(`unable to get provider for chainId ${chainId}`)
     const prefixed = prefixEIP191Message(message)
     const digest = encodeMessageDigest(prefixed)
-    return isValidSignature(address, digest, signature, provider, chainId, walletContext)
+    return isValidSignature(address, digest, signature, provider, await this.wallet.getWalletContext())
   }
 
   // Verify typedData signature
@@ -85,47 +81,46 @@ export class WalletUtils {
     address: string,
     typedData: TypedData,
     signature: string,
-    chainId: number,
-    walletContext?: WalletContext
+    chainId: number
   ): Promise<boolean> {
-    return this.isValidSignature(address, encodeTypedDataDigest(typedData), signature, chainId, walletContext)
-  }
-
-  // Recover the WalletConfig from a signature + digest combo
-  recoverWalletConfig = async (
-    address: string,
-    digest: BytesLike,
-    signature: string | DecodedSignature,
-    chainId: BigNumberish,
-    walletContext?: WalletContext
-  ): Promise<WalletConfig> => {
-    walletContext = walletContext || (await this.wallet.getWalletContext())
-    return recoverWalletConfig(address, digest, signature, chainId, walletContext)
-  }
-
-  // Recover the WalletConfig from a signature of a message
-  recoverWalletConfigFromMessage = async (
-    address: string,
-    message: string | Uint8Array,
-    signature: string | DecodedSignature,
-    chainId: BigNumberish,
-    walletContext?: WalletContext
-  ): Promise<WalletConfig> => {
-    walletContext = walletContext || (await this.wallet.getWalletContext())
-    return recoverWalletConfig(address, encodeMessageDigest(prefixEIP191Message(message)), signature, chainId, walletContext)
+    return this.isValidSignature(address, encodeTypedDataDigest(typedData), signature, chainId)
   }
 
-  // Recover the WalletConfig from a signature of a typedData object
-  recoverWalletConfigFromTypedData = async (
-    address: string,
-    typedData: TypedData,
-    signature: string | DecodedSignature,
-    chainId: BigNumberish,
-    walletContext?: WalletContext
-  ): Promise<WalletConfig> => {
-    walletContext = walletContext || (await this.wallet.getWalletContext())
-    return recoverWalletConfig(address, encodeTypedDataDigest(typedData), signature, chainId, walletContext)
-  }
+  // // Recover the WalletConfig from a signature + digest combo
+  // recoverWalletConfig = async (
+  //   address: string,
+  //   digest: BytesLike,
+  //   signature: string | DecodedSignature,
+  //   chainId: BigNumberish,
+  //   walletContext?: WalletContext
+  // ): Promise<WalletConfig> => {
+  //   walletContext = walletContext || (await this.wallet.getWalletContext())
+  //   return recoverWalletConfig(address, digest, signature, chainId, walletContext)
+  // }
+
+  // // Recover the WalletConfig from a signature of a message
+  // recoverWalletConfigFromMessage = async (
+  //   address: string,
+  //   message: string | Uint8Array,
+  //   signature: string | DecodedSignature,
+  //   chainId: BigNumberish,
+  //   walletContext?: WalletContext
+  // ): Promise<WalletConfig> => {
+  //   walletContext = walletContext || (await this.wallet.getWalletContext())
+  //   return recoverWalletConfig(address, encodeMessageDigest(prefixEIP191Message(message)), signature, chainId, walletContext)
+  // }
+
+  // // Recover the WalletConfig from a signature of a typedData object
+  // recoverWalletConfigFromTypedData = async (
+  //   address: string,
+  //   typedData: TypedData,
+  //   signature: string | DecodedSignature,
+  //   chainId: BigNumberish,
+  //   walletContext?: WalletContext
+  // ): Promise<WalletConfig> => {
+  //   walletContext = walletContext || (await this.wallet.getWalletContext())
+  //   return recoverWalletConfig(address, encodeTypedDataDigest(typedData), signature, chainId, walletContext)
+  // }
 
   // sendTransaction()
   // sendTransactions()

package/src/utils.ts

@@ -1,10 +1,8 @@
-import { ethers, BigNumberish, BytesLike } from 'ethers'
-import { WalletContext } from '@0xsequence/network'
-import { WalletConfig, addressOf, DecodedSignature, isConfigEqual } from '@0xsequence/config'
-import { packMessageData, encodeMessageDigest, TypedData, encodeTypedDataDigest } from '@0xsequence/utils'
+import { ethers, BytesLike } from 'ethers'
 import { Web3Provider } from './provider'
-import { isValidSignature as _isValidSignature, recoverConfig, Signer } from '@0xsequence/wallet'
 import { messageIsExemptFromEIP191Prefix } from './eip191exceptions'
+import { AccountStatus } from '@0xsequence/account'
+import { commons } from '@0xsequence/core'
 
 const eip191prefix = ethers.utils.toUtf8Bytes('\x19Ethereum Signed Message:\n')
 
@@ -25,112 +23,115 @@ export const prefixEIP191Message = (message: BytesLike): Uint8Array => {
   }
 }
 
-export const isValidSignature = async (
-  address: string,
-  digest: Uint8Array,
-  sig: string,
-  provider: Web3Provider | ethers.providers.Web3Provider | ethers.providers.Provider,
-  chainId?: number,
-  walletContext?: WalletContext
-): Promise<boolean> => {
-  if (!chainId) {
-    chainId = (await provider.getNetwork())?.chainId
+export const trimEIP191Prefix = (prefixedMessage: Uint8Array): Uint8Array => {
+  // If the message is not prefixed, we return the message as is.
+  if (JSON.stringify(prefixedMessage.slice(0, eip191prefix.length)) !== JSON.stringify(eip191prefix)) {
+    return prefixedMessage
   }
-  if (!walletContext && Web3Provider.isSequenceProvider(provider)) {
-    walletContext = await provider.getSigner().getWalletContext()
+
+  // We have two parts to remove.
+  // First is the EIP-191 prefix.
+  const ethereumSignedMessagePartSlicedArray = prefixedMessage.slice(eip191prefix.length)
+
+  // Second is the digits added which represent length of the message without the prefix
+  // and we need to find the prefix that will match this.
+  // Here first we take the max prefix char length, and check if as a number it is bigger
+  // than the length of the message (since prefix is added to represent length of original message),
+  // if it is we remove 1 from char length, if not we keep the max prefix char length.
+  // As an example for the case where , if the message is 123456789, the expected prefix char is 9, with starting value 9123456789
+  // the char length of the total message with the prefix is 10, so the max prefix char length we start is 2 from [1,0], and as a number 10, it is longer
+  // than the length of the message after removing prefix (10 - 2 = 8), so we slice 1 char less, which is 9, and we get the correct prefix.
+  const maxPrefixCharLength = String(ethereumSignedMessagePartSlicedArray.length).length
+
+  let prefixCharLenght: number
+  let prefixAsNumber: number
+
+  try {
+    prefixAsNumber = Number(ethers.utils.toUtf8String(ethereumSignedMessagePartSlicedArray.slice(0, maxPrefixCharLength)))
+  } catch {
+    prefixAsNumber = Number(ethers.utils.hexlify(ethereumSignedMessagePartSlicedArray.slice(0, maxPrefixCharLength)))
   }
-  return _isValidSignature(address, digest, sig, provider, walletContext, chainId)
-}
 
-export const isValidMessageSignature = async (
-  address: string,
-  message: string | Uint8Array,
-  signature: string,
-  provider: Web3Provider | ethers.providers.Web3Provider  | ethers.providers.Provider,
-  chainId?: number,
-  walletContext?: WalletContext
-): Promise<boolean> => {
-  const prefixed = prefixEIP191Message(message)
-  const digest = encodeMessageDigest(prefixed)
-  return isValidSignature(address, digest, signature, provider, chainId, walletContext)
+  if (prefixAsNumber > ethereumSignedMessagePartSlicedArray.length || !Number.isInteger(prefixAsNumber)) {
+    prefixCharLenght = maxPrefixCharLength - 1
+  } else {
+    prefixCharLenght = maxPrefixCharLength
+  }
+
+  const prefixRevertedMessage = ethereumSignedMessagePartSlicedArray.slice(prefixCharLenght)
+
+  return prefixRevertedMessage
 }
 
-export const isValidTypedDataSignature = (
+export const isValidSignature = async (
   address: string,
-  typedData: TypedData,
-  signature: string,
-  provider: Web3Provider | ethers.providers.Web3Provider  | ethers.providers.Provider,
-  chainId?: number,
-  walletContext?: WalletContext
+  digest: Uint8Array,
+  sig: string,
+  provider: Web3Provider | ethers.providers.Web3Provider,
+  contexts: { [key: number]: commons.context.WalletContext }
 ): Promise<boolean> => {
-  return isValidSignature(address, encodeTypedDataDigest(typedData), signature, provider, chainId, walletContext)
+  const reader = new commons.reader.OnChainReader(provider, contexts)
+  return reader.isValidSignature(address, digest, sig)
 }
 
-export const recoverWalletConfig = async (
-  address: string,
-  digest: BytesLike,
-  signature: string | DecodedSignature,
-  chainId: BigNumberish,
-  walletContext?: WalletContext
-): Promise<WalletConfig> => {
-  const subDigest = packMessageData(address, chainId, digest)
-  const config = await recoverConfig(subDigest, signature)
-
-  if (walletContext) {
-    const recoveredWalletAddress = addressOf(config, walletContext)
-    if (config.address && config.address !== recoveredWalletAddress) {
-      throw new Error('recovered address does not match the WalletConfig address, check the WalletContext')
-    } else {
-      config.address = recoveredWalletAddress
-    }
-  }
-
-  return config
-}
+// export const isValidMessageSignature = async (
+//   address: string,
+//   message: string | Uint8Array,
+//   signature: string,
+//   provider: Web3Provider | ethers.providers.Web3Provider,
+//   chainId?: number,
+//   walletContext?: WalletContext
+// ): Promise<boolean> => {
+//   const prefixed = prefixEIP191Message(message)
+//   const digest = encodeMessageDigest(prefixed)
+//   return isValidSignature(address, digest, signature, provider, chainId, walletContext)
+// }
+
+// export const isValidTypedDataSignature = (
+//   address: string,
+//   typedData: TypedData,
+//   signature: string,
+//   provider: Web3Provider | ethers.providers.Web3Provider,
+//   chainId?: number,
+//   walletContext?: WalletContext
+// ): Promise<boolean> => {
+//   return isValidSignature(address, encodeTypedDataDigest(typedData), signature, provider, chainId, walletContext)
+// }
+
+// export const recoverWalletConfig = async (
+//   address: string,
+//   digest: BytesLike,
+//   signature: string | commons.signature.UnrecoveredSignature | commons.signature.Signature<commons.config.Config>,
+//   chainId: BigNumberish,
+//   walletContext?: WalletContext
+// ): Promise<commons.config.Config> => {
+//   const subDigest = packMessageData(address, chainId, digest)
+//   const config = await recoverConfig(subDigest, signature)
+
+//   if (walletContext) {
+//     const recoveredWalletAddress = addressOf(config, walletContext)
+//     if (config.address && config.address !== recoveredWalletAddress) {
+//       throw new Error('recovered address does not match the WalletConfig address, check the WalletContext')
+//     } else {
+//       config.address = recoveredWalletAddress
+//     }
+//   }
+
+//   return config
+// }
 
 export const isBrowserExtension = (): boolean =>
   window.location.protocol === 'chrome-extension:' || window.location.protocol === 'moz-extension:'
 
 export const isUnityPlugin = (): boolean => !!navigator.userAgent.match(/UnitySequence/i)
 
-/**
- * Returns the status of a signer's wallet on given chain by checking wallet deployment and config status
- *
- * @param {Signer} signer
- * @param {number} chainId
- * @return {Promise<boolean>} Promise that returns true if the wallet is up to date, false otherwise
- */
-export const isWalletUpToDate = async (signer: Signer, chainId: number): Promise<boolean> => {
-  const walletState = await signer.getWalletState()
-  const networks = await signer.getNetworks()
-
-  const walletStateForRequiredChain = walletState.find(state => state.chainId === chainId)
-  if (!walletStateForRequiredChain) {
-    throw new Error(`WalletRequestHandler: could not find wallet state for chainId ${chainId}`)
-  }
-
-  const isDeployed = walletStateForRequiredChain.deployed
-
-  if (!networks) {
-    throw new Error(`isWalletUpToDate util: could not get networks from signer`)
-  }
-  const authChain = networks.find(network => network.isAuthChain)
-  if (!authChain) {
-    throw new Error(`isWalletUpToDate util: could not get auth chain network information`)
-  }
-  const authChainId = authChain.chainId
-  const authChainConfig = walletState.find(state => state.chainId === authChainId)?.config
-  if (!authChainConfig) {
-    throw new Error(`isWalletUpToDate util: could not get auth chain config`)
-  }
-  const requiredChainConfig = walletStateForRequiredChain.config
-  if (!requiredChainConfig) {
-    throw new Error(`isWalletUpToDate util: could not get config for chainId ${chainId}`)
-  }
-
-  const isUpToDate = isConfigEqual(authChainConfig, requiredChainConfig)
-
-  return isDeployed && isUpToDate
+// /**
+//  * Returns the status of a signer's wallet on given chain by checking wallet deployment and config status
+//  *
+//  * @param {Status} of the wallet
+//  */
+export const isWalletUpToDate = (status: AccountStatus): boolean => {
+  return status.onChain.deployed && status.fullyMigrated
 }
 
 export interface ItemStore {

package/src/wallet.ts

@@ -1,6 +1,5 @@
 import {
   NetworkConfig,
-  WalletContext,
   ChainIdLike,
   JsonRpcSender,
   JsonRpcRouter,
@@ -16,10 +15,10 @@ import {
   findNetworkConfig,
   updateNetworkConfig,
   ensureValidNetworks,
-  sortNetworks
+  sortNetworks,
+  findSupportedNetwork
 } from '@0xsequence/network'
-import { WalletConfig, WalletState } from '@0xsequence/config'
-import { logger } from '@0xsequence/utils'
+import { getDefaultConnectionInfo, logger } from '@0xsequence/utils'
 import { Web3Provider, Web3Signer } from './provider'
 import {
   MuxMessageProvider,
@@ -35,6 +34,10 @@ import { LocalStore, ItemStore, LocalStorage } from './utils'
 import { WalletUtils } from './utils/index'
 
 import { Runtime } from 'webextension-polyfill'
+import { commons } from '@0xsequence/core'
+import { AccountStatus } from '@0xsequence/account'
+
+export const SESSION_LOCALSTORE_KEY = '@sequence.session'
 
 export interface WalletProvider {
   connect(options?: ConnectOptions): Promise<ConnectDetails>
@@ -46,7 +49,6 @@ export interface WalletProvider {
   getAddress(): Promise<string>
   getNetworks(chainId?: ChainIdLike): Promise<NetworkConfig[]>
   getChainId(): Promise<number>
-  getAuthChainId(): Promise<number>
 
   isOpened(): boolean
   openWallet(path?: string, intent?: OpenWalletIntent, networkId?: string | number): Promise<boolean>
@@ -55,9 +57,9 @@ export interface WalletProvider {
   getProvider(chainId?: ChainIdLike): Web3Provider | undefined
   getSigner(chainId?: ChainIdLike): Web3Signer
 
-  getWalletContext(): Promise<WalletContext>
-  getWalletConfig(chainId?: ChainIdLike): Promise<WalletConfig[]>
-  getWalletState(chainId?: ChainIdLike): Promise<WalletState[]>
+  getWalletContext(): Promise<commons.context.VersionedContext>
+  getWalletConfig(chainId?: ChainIdLike): Promise<commons.config.Config>
+  getWalletState(chainId?: ChainIdLike): Promise<AccountStatus>
   isDeployed(chainId?: ChainIdLike): Promise<boolean>
 
   getProviderConfig(): ProviderConfig
@@ -177,7 +179,7 @@ export class Wallet implements WalletProvider {
       if (!this.networks || this.networks.length === 0) return 0
 
       // return the default chainId as we're connected
-      return this.networks.find(network => network.isDefaultChain)!.chainId
+      return findNetworkConfig(this.networks, this.config.defaultNetworkId!)!.chainId
     })
 
     // Provider proxy to support middleware stack of logging, caching and read-only rpc calls
@@ -200,7 +202,11 @@ export class Wallet implements WalletProvider {
       this.transport.messageProvider
     )
 
-    this.transport.provider = new Web3Provider(this.transport.router)
+    // TODO: Move finding this config to upper in the stack
+    this.transport.provider = new Web3Provider(
+      this.transport.router,
+      findSupportedNetwork(this.config.defaultNetworkId!)?.chainId
+    )
 
     // NOTE: we don't listen on 'connect' even here as we handle it within connect() method
     // in more synchronous flow.
@@ -244,13 +250,13 @@ export class Wallet implements WalletProvider {
     })
 
     // below will update the wallet context automatically
-    this.transport.messageProvider.on('walletContext', (walletContext: WalletContext) => {
+    this.transport.messageProvider.on('walletContext', (walletContext: commons.context.VersionedContext) => {
       this.useSession({ walletContext: walletContext }, true)
     })
   }
 
   loadSession = async (preferredNetwork?: string | number): Promise<WalletSession | undefined> => {
-    const data = await LocalStorage.getInstance().getItem('@sequence.session')
+    const data = await LocalStorage.getInstance().getItem(SESSION_LOCALSTORE_KEY)
     if (!data || data === '') {
       return undefined
     }
@@ -282,6 +288,11 @@ export class Wallet implements WalletProvider {
   }
 
   connect = async (options?: ConnectOptions): Promise<ConnectDetails> => {
+    if (options && options?.authorizeVersion === undefined) {
+      // Populate default authorize version if not provided
+      options.authorizeVersion = 2
+    }
+
     if (options?.refresh === true) {
       this.disconnect()
     }
@@ -301,8 +312,13 @@ export class Wallet implements WalletProvider {
     }
 
     if (options) {
-      if (options.authorize && (!options.app || options.app === '')) {
-        throw new Error(`connecting with 'authorize' option also requires 'app' to be set`)
+      if (options.authorize) {
+        if (!options.app) {
+          throw new Error(`connecting with 'authorize' option also requires 'app' to be set`)
+        }
+        if (options.authorizeVersion === undefined) {
+          options.authorizeVersion = 2
+        }
       }
     }
 
@@ -366,11 +382,11 @@ export class Wallet implements WalletProvider {
     return this.connect({ ...options, authorize: true })
   }
 
-  disconnect(): void {
+  disconnect(): Promise<void> {
     if (this.isOpened()) {
       this.closeWallet()
     }
-    this.clearSession()
+    return this.clearSession()
   }
 
   // TODO: add switchNetwork(network: string | number) which will call wallet_switchEthereumChain
@@ -429,7 +445,7 @@ export class Wallet implements WalletProvider {
       throw new Error('networks have not been set by session. connect first.')
     }
 
-    const network = this.networks.find(network => network.isDefaultChain)
+    const network = findNetworkConfig(this.networks, this.config.defaultNetworkId!)
 
     if (!network) {
       throw new Error('networks must have a default chain specified')
@@ -438,20 +454,6 @@ export class Wallet implements WalletProvider {
     return network.chainId
   }
 
-  getAuthChainId = async (): Promise<number> => {
-    if (!this.networks || this.networks.length < 1) {
-      throw new Error('networks have not been set by session. connect first.')
-    }
-
-    const network = this.networks.find(network => network.isAuthChain)
-
-    if (!network) {
-      throw new Error('networks must have an auth chain specified')
-    }
-
-    return network.chainId
-  }
-
   openWallet = async (path?: string, intent?: OpenWalletIntent, networkId?: string | number): Promise<boolean> => {
     if (intent?.type !== 'connect' && !this.isConnected()) {
       throw new Error('connect first')
@@ -486,7 +488,7 @@ export class Wallet implements WalletProvider {
       }
     }
 
-    let network: NetworkConfig | undefined = this.networks.find(network => network.isDefaultChain)!
+    let network: NetworkConfig | undefined = findNetworkConfig(this.networks, this.config.defaultNetworkId!)!
     if (chainId) {
       network = findNetworkConfig(this.networks, chainId)
       if (!network) {
@@ -503,7 +505,7 @@ export class Wallet implements WalletProvider {
     let provider: Web3Provider
 
     // network.provider may be set by the ProviderConfig override
-    const rpcProvider = network.provider ? network.provider : new providers.JsonRpcProvider(network.rpcUrl, network.chainId)
+    const rpcProvider = new providers.JsonRpcProvider(getDefaultConnectionInfo(network.rpcUrl), network.chainId)
 
     if (network.isDefaultChain) {
       // communicating with defaultChain will prioritize the wallet message transport
@@ -544,14 +546,6 @@ export class Wallet implements WalletProvider {
     return provider
   }
 
-  async getAuthProvider(): Promise<Web3Provider> {
-    return this.getProvider((await this.getAuthNetwork()).chainId)!
-  }
-
-  async getAuthNetwork(): Promise<NetworkConfig> {
-    return (await this.getNetworks()).find(n => n.isAuthChain)!
-  }
-
   getAllProviders(): { [chainId: number]: Web3Provider } {
     return this.providers
   }
@@ -560,19 +554,15 @@ export class Wallet implements WalletProvider {
     return this.getProvider(chainId)!.getSigner()
   }
 
-  async getAuthSigner(): Promise<Web3Signer> {
-    return (await this.getAuthProvider()).getSigner()
-  }
-
-  getWalletConfig(chainId?: ChainIdLike): Promise<WalletConfig[]> {
+  getWalletConfig(chainId?: ChainIdLike): Promise<commons.config.Config> {
     return this.getSigner().getWalletConfig(chainId)
   }
 
-  getWalletState(chainId?: ChainIdLike): Promise<WalletState[]> {
+  getWalletState(chainId?: ChainIdLike): Promise<AccountStatus> {
     return this.getSigner().getWalletState(chainId)
   }
 
-  getWalletContext(): Promise<WalletContext> {
+  getWalletContext(): Promise<commons.context.VersionedContext> {
     return this.getSigner().getWalletContext()
   }
 
@@ -596,7 +586,7 @@ export class Wallet implements WalletProvider {
   private saveSession = async (session: WalletSession) => {
     logger.debug('wallet provider: saving session')
     const data = JSON.stringify(session)
-    await LocalStorage.getInstance().setItem('@sequence.session', data)
+    await LocalStorage.getInstance().setItem(SESSION_LOCALSTORE_KEY, data)
   }
 
   private useSession = async (session: WalletSession, autoSave: boolean = true) => {
@@ -678,9 +668,9 @@ export class Wallet implements WalletProvider {
     }
   }
 
-  private clearSession(): void {
+  private async clearSession(): Promise<void> {
     logger.debug('wallet provider: clearing session')
-    LocalStorage.getInstance().removeItem('@sequence.session')
+    await LocalStorage.getInstance().removeItem(SESSION_LOCALSTORE_KEY)
     this.session = undefined
     this.networks = []
     this.providers = {}
@@ -741,7 +731,7 @@ export interface ProviderConfig {
   // WalletContext used the one returned by the wallet app upon login.
   //
   // NOTE: do not use this option unless you know what you're doing
-  walletContext?: WalletContext
+  walletContext?: commons.context.VersionedContext
 }
 
 export const DefaultProviderConfig: ProviderConfig = {