@0xsequence/provider 1.0.5 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/provider",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "provider sub-package for Sequence",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/provider",
   "source": "src/index.ts",
@@ -11,21 +11,22 @@
   "dependencies": {
     "eventemitter2": "^6.4.5",
     "webextension-polyfill": "^0.10.0",
-    "@0xsequence/abi": "1.0.5",
-    "@0xsequence/account": "1.0.5",
-    "@0xsequence/auth": "1.0.5",
-    "@0xsequence/core": "1.0.5",
-    "@0xsequence/migration": "1.0.5",
-    "@0xsequence/relayer": "1.0.5",
-    "@0xsequence/network": "1.0.5",
-    "@0xsequence/utils": "1.0.5",
-    "@0xsequence/wallet": "1.0.5"
+    "@0xsequence/abi": "1.1.0",
+    "@0xsequence/account": "1.1.0",
+    "@0xsequence/auth": "1.1.0",
+    "@0xsequence/relayer": "1.1.0",
+    "@0xsequence/migration": "1.1.0",
+    "@0xsequence/core": "1.1.0",
+    "@0xsequence/network": "1.1.0",
+    "@0xsequence/wallet": "1.1.0",
+    "@0xsequence/utils": "1.1.0"
   },
   "peerDependencies": {
     "ethers": ">=5.5 < 6"
   },
   "devDependencies": {
     "@types/webextension-polyfill": "^0.10.0",
+    "hardhat": "^2.12.2",
     "ethers": "^5.7.2"
   },
   "files": [
@@ -33,8 +34,14 @@
     "dist"
   ],
   "scripts": {
-    "test": "pnpm test:file tests/**/*.spec.ts",
+    "test": "pnpm test:concurrently 'pnpm test:run'",
+    "test:run": "pnpm test:file tests/**/*.spec.ts",
     "test:file": "NODE_OPTIONS='--loader tsx' mocha --timeout 30000",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test:concurrently": "concurrently -k --success first 'pnpm start:hardhat1' 'pnpm start:hardhat2'",
+    "start:hardhat1": "pnpm start:hardhat1:verbose > /dev/null 2>&1",
+    "start:hardhat2": "pnpm start:hardhat2:verbose > /dev/null 2>&1",
+    "start:hardhat1:verbose": "hardhat node --config hardhat1.config.js --hostname 0.0.0.0 --port 9595",
+    "start:hardhat2:verbose": "hardhat node --config hardhat2.config.js --hostname 0.0.0.0 --port 8595"
   }
 }

package/src/client.ts

@@ -0,0 +1,423 @@
+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
+ *  whitin the dapp. This enables the client to retain the wallet address (and some more)
+ *  even if the user refreshes the page. Otherwise we would have to open the popup again.
+ */
+export class SequenceClientSession {
+  static readonly SESSION_LOCALSTORE_KEY = '@sequence.session'
+
+  constructor (
+    private store: ItemStore
+  ) {}
+
+  connectedSession(): Required<WalletSession> {
+    const session = this.getSession()
+
+    if (
+      session &&
+      session.accountAddress &&
+      session.walletContext &&
+      session.networks
+    ) {
+      return {
+        accountAddress: session.accountAddress!,
+        walletContext: session.walletContext!,
+        networks: session.networks!
+      }
+    }
+
+    throw new Error('Sequence session not connected')
+  }
+
+  hasSession(): boolean {
+    return this.getSession()?.accountAddress !== undefined
+  }
+
+ setSession(session: WalletSession) {
+    return this.store.setItem(SequenceClientSession.SESSION_LOCALSTORE_KEY, JSON.stringify(session))
+  }
+
+  getSession(): WalletSession | undefined {
+    const session = this.store.getItem(SequenceClientSession.SESSION_LOCALSTORE_KEY)
+
+    if (session) {
+      return JSON.parse(session)
+    }
+
+    return undefined
+  }
+
+  async clearSession() {
+    return this.store.removeItem(SequenceClientSession.SESSION_LOCALSTORE_KEY)
+  }
+}
+
+/**
+ *  The wallet webapp doesn't really care what's the "default chain" for the user.
+ *  so we don't even bother to send this information to the wallet. Instead, we
+ *  track it locally using storage, that way the data stays always in sync.
+ */
+export class DefaultChainIdTracker {
+  static readonly SESSION_CHAIN_ID_KEY = '@sequence.session.defaultChainId'
+
+  callbacks: ((chainId: number) => void)[] = []
+
+  constructor(
+    private store: ItemStore,
+    private startingChainId: number = 1
+  ) {
+    store.onItemChange(DefaultChainIdTracker.SESSION_CHAIN_ID_KEY, (value: string | null) => {
+      if (value) {
+        const chainId = parseInt(value)
+        this.callbacks.forEach(cb => cb(chainId))
+      }
+    })
+  }
+
+  onDefaultChainIdChanged(callback: (chainId: number) => void) {
+    this.callbacks.push(callback)
+    return () => {
+      this.callbacks = this.callbacks.filter(cb => cb !== callback)
+    }
+  }
+
+  setDefaultChainId(chainId: number) {
+    if (chainId !== this.getDefaultChainId()) {
+      this.store.setItem(DefaultChainIdTracker.SESSION_CHAIN_ID_KEY, chainId.toString())
+    }
+  }
+
+  getDefaultChainId(): number {
+    const read = this.store.getItem(DefaultChainIdTracker.SESSION_CHAIN_ID_KEY)
+
+    if (!read || read.length === 0) {
+      return this.startingChainId
+    }
+
+    return parseInt(read)
+  }
+}
+
+/**
+ *  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 {  
+  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
+  ) {
+    if (isMuxTransportTemplate(transport)) {
+      this.transport = MuxMessageProvider.new(transport)
+    } else if (isProviderTransport(transport)) {
+      this.transport = transport
+    } else {
+      throw new Error('Invalid transport')
+    }
+
+    this.session = new SequenceClientSession(store)
+    this.defaultChainId = new DefaultChainIdTracker(store, defaultChainId)
+
+    this.transport.on('accountsChanged', (accounts: string[]) => {
+      if (accounts.length > 1) {
+        console.warn('SequenceClient: wallet-webapp returned more than one account')
+      }
+
+      this.callbacks.accountsChanged?.forEach(cb => cb(accounts))
+    })
+
+    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
+      }))
+    })
+
+    this.transport.on('disconnect', (error) => {
+      this.callbacks.disconnect?.forEach(cb => cb(error))
+    })
+
+    this.transport.on('networks', (networks) => {
+      this.callbacks.networks?.forEach(cb => cb(networks))
+    })
+
+    this.transport.on('walletContext', (context) => {
+      this.callbacks.walletContext?.forEach(cb => cb(context))
+    })
+
+    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()
+      this.callbacks.chainChanged?.forEach(cb => cb(chainIdHex))
+    })
+  }
+
+  // Callbacks
+
+  registerCallback<K extends keyof WalletEventTypes>(eventName: K, callback: WalletEventTypes[K]) {
+    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
+    }
+  }
+
+  // Individual callbacks lead to more idiomatic code
+
+  onOpen(callback: WalletEventTypes['open']) {
+    return this.registerCallback('open', callback)
+  }
+
+  onClose(callback: WalletEventTypes['close']) {
+    return this.registerCallback('close', callback)
+  }
+
+  onConnect(callback: WalletEventTypes['connect']) {
+    return this.registerCallback('connect', callback)
+  }
+
+  onDisconnect(callback: WalletEventTypes['disconnect']) {
+    return this.registerCallback('disconnect', callback)
+  }
+  
+  onNetworks(callback: WalletEventTypes['networks']) {
+    return this.registerCallback('networks', callback)
+  }
+
+  onAccountsChanged(callback: WalletEventTypes['accountsChanged']) {
+    return this.registerCallback('accountsChanged', callback)
+  }
+
+  // @deprecated
+  onWalletContext(callback: WalletEventTypes['walletContext']) {
+    return this.registerCallback('walletContext', callback)
+  }
+
+  onDefaultChainIdChanged(callback: WalletEventTypes['chainChanged']) {
+    return this.registerCallback('chainChanged', callback)
+  }
+
+  getChainId(): number {
+    return this.defaultChainId.getDefaultChainId()
+  }
+
+  setDefaultChainId(chainId: number) {
+    return this.defaultChainId.setDefaultChainId(chainId)
+  }
+
+  // Proxy transport methods
+
+  async openWallet(path?: string, intent?: OpenWalletIntent) {
+    this.transport.openWallet(path, intent, this.getChainId())
+    await this.transport.waitUntilOpened()
+    return this.isOpened()
+  }
+
+  closeWallet() {
+    return this.transport.closeWallet()
+  }
+
+  isOpened(): boolean {
+    return this.transport.isOpened()
+  }
+
+  isConnected(): boolean {
+    return this.session.hasSession()
+  }
+
+  getSession(): WalletSession | undefined {
+    return this.session.getSession()
+  }
+
+  // Basic API
+  getAddress(): string {
+    const session = this.session.connectedSession()
+    return session.accountAddress
+  }
+
+  async connect(options: ConnectOptions): Promise<ConnectDetails> {
+    if (options?.authorizeVersion === undefined) {
+      // Populate default authorize version if not provided
+      options.authorizeVersion = 2
+    }
+
+    if (options?.refresh === true) {
+      this.disconnect()
+    }
+
+    if (options) {
+      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
+        }
+      }
+    }
+
+    await this.openWallet(undefined, { type: 'connect', options: { ...options, networkId: this.getChainId() } })
+
+    const connectDetails = await this.transport.waitUntilConnected().catch((error): ConnectDetails => {
+      if (error instanceof Error) {
+        return { connected: false, error: error.message }
+      } else {
+        return { connected: false, error: JSON.stringify(error) }
+      }
+    })
+
+    // Normalize chainId into a decimal string
+    // TODO: Remove this once wallet-webapp returns chainId as a string
+    if (connectDetails.chainId) {
+      connectDetails.chainId = ethers.BigNumber.from(connectDetails.chainId).toString()
+    }
+
+    if (connectDetails.connected) {
+      if (!connectDetails.session) {
+        throw new Error('impossible state, connect response is missing session')
+      }
+  
+      this.session.setSession(connectDetails.session)
+    }
+
+    return connectDetails
+  }
+
+  disconnect() {
+    if (this.isOpened()) {
+      this.closeWallet()
+    }
+
+    return this.session.clearSession()
+  }
+
+  // Higher level API
+
+  // Working with sendAsync is less idiomatic
+  // 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())
+    })
+  }
+
+  async getNetworks(pull?: boolean): Promise<NetworkConfig[]> {
+    const connectedSession = this.session.connectedSession()
+
+    if (pull) {
+      connectedSession.networks = await this.send({ method: 'sequence_getNetworks' })
+      this.session.setSession(connectedSession)
+    }
+
+    return connectedSession.networks
+  }
+
+  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> {
+    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)
+
+    // 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] }, (
+      options?.chainId ||
+      (
+        typedData.domain.chainId &&
+        ethers.BigNumber.from(typedData.domain.chainId).toNumber()
+      ) ||
+      this.getChainId()
+    ))
+  }
+
+  async sendTransaction(
+    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 )
+  }
+
+  async getWalletContext(): Promise<commons.context.VersionedContext> {
+    return this.send({ method: 'sequence_getWalletContext' })
+  }
+
+  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)
+    return Array.isArray(res) ? res[0] : res
+  }
+
+  // NOTICE: We are leaving out all the "regular" methods os a tipical
+  // JSON RPC Provider (eth_getBlockByNumber, eth_call, etc)
+  // wallet-webapp does implement them, but this client is meant to be
+  // exclusively used for Sequence specific methods
+}

package/src/extended.ts

@@ -21,3 +21,7 @@ export function toExtended(transactions: ethers.providers.TransactionRequest[]):
 export function fromExtended(transaction: ExtendedTransactionRequest): ethers.providers.TransactionRequest[] {
   return [transaction, ...(transaction.auxiliary || [])]
 }
+
+export function isExtended(transaction: ethers.providers.TransactionRequest): transaction is ExtendedTransactionRequest {
+  return (transaction as any).auxiliary !== undefined
+}

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from './transports'
 export * from './types'
-export * from './wallet'
 export * from './provider'
 export * from './utils'
+export * from './client'
+export * from './signer'
+export * from './init'

package/src/init.ts

@@ -0,0 +1,134 @@
+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.
+  // For example, this option should be used when using React Native since window.localStorage is not available.
+  localStorage?: ItemStore
+
+  // defaultNetwork is the primary network of a dapp and the default network a
+  // provider will communicate. Note: this setting is also configurable from the
+  // Wallet constructor's first argument. If both are specified, then they
+  // need to match
+  defaultNetwork?: ChainIdLike
+
+  // networks is a configuration list of networks used by the wallet. This list
+  // is combined with the network list specified by sequence.js.
+  // notice that this can only replace the rpc urls on the dapp side,
+  // the networks on wallet-webapp side remain the same.
+  //
+  // NOTICE: It's not possible to define networks that aren't already
+  // defined in sequence.js.
+  networks?: Partial<NetworkConfig>[]
+
+  // transports for dapp to wallet jron-rpc communication
+  transports?: MuxTransportTemplate
+}
+
+export const DefaultProviderConfig = {
+  transports: {
+    walletAppURL: 'https://sequence.app',
+    windowTransport: { enabled: true },
+    proxyTransport: { enabled: false }
+  },
+
+  defaultNetwork: 1,
+}
+
+let sequenceWalletProvider: SequenceProvider | undefined
+
+export const initWallet = (
+  partialConfig?: Partial<ProviderConfig>
+) => {
+  if (sequenceWalletProvider) {
+    return sequenceWalletProvider
+  }
+
+  // Combine both the provided config and the default config
+  const config = {
+    ...DefaultProviderConfig,
+    ...partialConfig,
+    transports: {
+      ...DefaultProviderConfig.transports,
+      ...partialConfig?.transports,
+    }
+  }
+
+  const rpcProviders: Record<number, ethers.providers.JsonRpcProvider> = {}
+
+  // 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)
+  }) ?? []) 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)
+
+  // 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
+      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()
+        ],
+        new JsonRpcSender(baseProvider)
+      )
+  
+      rpcProviders[chainId] = new ethers.providers.Web3Provider(router, chainId)
+    }
+
+    return rpcProviders[chainId]
+  }
+
+  // This is the starting default network (as defined by the config)
+  // it can be later be changed using `wallet_switchEthereumChain` or some
+  // of the other methods on the provider.
+  const defaultNetwork = config.defaultNetwork ? findNetworkConfig(combinedNetworks, config.defaultNetwork)?.chainId : undefined
+  if (!defaultNetwork && config.defaultNetwork) {
+    throw new Error(`defaultNetwork not found for chainId: ${config.defaultNetwork}`)
+  }
+
+  // Generate ItemStore
+  const itemStore = config.localStorage || useBestStore()
+
+  // Create client, provider and return signer
+  const client = new SequenceClient(config.transports, itemStore, defaultNetwork)
+  sequenceWalletProvider = new SequenceProvider(client, providerForChainId)
+
+  return sequenceWalletProvider
+}
+
+export const unregisterWallet = () => {
+  if (!sequenceWalletProvider) return
+  sequenceWalletProvider.client.closeWallet()
+  sequenceWalletProvider.client.transport.unregister()
+  sequenceWalletProvider = undefined
+}
+
+export const getWallet = () => {
+  if (!sequenceWalletProvider) {
+    throw new Error('Wallet has not been initialized, call sequence.initWallet(config) first.')
+  }
+
+  return sequenceWalletProvider
+}