@0xsequence/provider 0.35.7 → 0.35.11

package/dist/declarations/src/transports/wallet-request-handler.d.ts

@@ -24,7 +24,7 @@ export declare class WalletRequestHandler implements ExternalProvider, JsonRpcHa
     signIn(signer: Signer | null, options?: WalletSignInOptions): Promise<void>;
     signOut(): void;
     signerReset(): void;
-    signerReady(): Promise<unknown>;
+    signerReady(timeout?: number): Promise<void>;
     connect(options?: ConnectOptions): Promise<ConnectDetails>;
     promptConnect: (options?: ConnectOptions | undefined) => Promise<ConnectDetails>;
     sendMessageRequest(message: ProviderMessageRequest): Promise<ProviderMessageResponse>;
@@ -46,8 +46,8 @@ export declare class WalletRequestHandler implements ExternalProvider, JsonRpcHa
     notifyNetworks(networks?: NetworkConfig[]): Promise<void>;
     notifyWalletContext(): Promise<void>;
     notifyClose(error?: ProviderRpcError): void;
-    isSignedIn(): boolean;
-    getSigner(): Signer | null | undefined;
+    isSignedIn: () => Promise<boolean>;
+    getSigner: () => Promise<Signer | null>;
     setSigner(signer: Signer | null | undefined): void;
     private handleConfirmWalletDeployPrompt;
 }

package/dist/declarations/src/utils.d.ts

@@ -1,9 +1,12 @@
-import { BigNumberish, BytesLike } from 'ethers';
+import { ethers, BigNumberish, BytesLike } from 'ethers';
 import { WalletContext } from '@0xsequence/network';
 import { WalletConfig, DecodedSignature } from '@0xsequence/config';
+import { TypedData } from '@0xsequence/utils';
 import { Web3Provider } from './provider';
 import { Signer } from '@0xsequence/wallet';
-export declare const isValidSignature: (address: string, digest: Uint8Array, sig: string, provider: Web3Provider, chainId?: number | undefined, walletContext?: WalletContext | undefined) => Promise<boolean | undefined>;
+export declare const isValidSignature: (address: string, digest: Uint8Array, sig: string, provider: Web3Provider | ethers.providers.Web3Provider, chainId?: number | undefined, walletContext?: WalletContext | undefined) => Promise<boolean | undefined>;
+export declare const isValidMessageSignature: (address: string, message: string | Uint8Array, signature: string, provider: Web3Provider | ethers.providers.Web3Provider, chainId?: number | undefined, walletContext?: WalletContext | undefined) => Promise<boolean | undefined>;
+export declare const isValidTypedDataSignature: (address: string, typedData: TypedData, signature: string, provider: Web3Provider | ethers.providers.Web3Provider, chainId?: number | undefined, walletContext?: WalletContext | undefined) => Promise<boolean | undefined>;
 export declare const recoverWalletConfig: (address: string, digest: BytesLike, signature: string | DecodedSignature, chainId: BigNumberish, walletContext?: WalletContext | undefined) => Promise<WalletConfig>;
 export declare const isBrowserExtension: () => boolean;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/provider",
-  "version": "0.35.7",
+  "version": "0.35.11",
   "description": "provider sub-package for Sequence",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/provider",
   "source": "src/index.ts",
@@ -13,13 +13,13 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@0xsequence/abi": "^0.35.7",
-    "@0xsequence/auth": "^0.35.7",
-    "@0xsequence/config": "^0.35.7",
-    "@0xsequence/network": "^0.35.7",
-    "@0xsequence/transactions": "^0.35.7",
-    "@0xsequence/utils": "^0.35.7",
-    "@0xsequence/wallet": "^0.35.7",
+    "@0xsequence/abi": "^0.35.11",
+    "@0xsequence/auth": "^0.35.11",
+    "@0xsequence/config": "^0.35.11",
+    "@0xsequence/network": "^0.35.11",
+    "@0xsequence/transactions": "^0.35.11",
+    "@0xsequence/utils": "^0.35.11",
+    "@0xsequence/wallet": "^0.35.11",
     "@ethersproject/abstract-signer": "^5.5.0",
     "@ethersproject/hash": "^5.5.0",
     "@ethersproject/providers": "^5.5.1",

package/src/commands/index.ts

@@ -1,10 +1,11 @@
-import { BigNumberish, BytesLike } from 'ethers'
+import { ethers, BigNumberish, BytesLike } from 'ethers'
 import { TypedDataDomain, TypedDataField, TypedDataSigner } from '@ethersproject/abstract-signer'
 import { WalletContext, ChainIdLike } from '@0xsequence/network'
 import { encodeMessageDigest, TypedData, encodeTypedDataDigest } from '@0xsequence/utils'
 import { DecodedSignature, WalletConfig } from '@0xsequence/config'
 import { Wallet } from '../wallet'
 import { isValidSignature, recoverWalletConfig } from '../utils'
+import { isValidEIP712Signature, isValidEthSignSignature } from '@0xsequence/wallet'
 
 export class WalletCommands {
   private wallet: Wallet
@@ -66,13 +67,19 @@ export class WalletCommands {
   }
 
   // Verify message signature
-  isValidMessageSignature(
+  async isValidMessageSignature(
     address: string,
     message: string | Uint8Array,
     signature: string,
     chainId: number,
     walletContext?: WalletContext
   ): Promise<boolean | undefined> {
+    const msgDigest = ethers.utils.arrayify(ethers.utils.hashMessage(message))
+    if (
+      isValidEIP712Signature(address, msgDigest, signature) ||
+      isValidEthSignSignature(address, msgDigest, signature)
+    ) return true
+
     return this.isValidSignature(address, encodeMessageDigest(message), signature, chainId, walletContext)
   }
 

package/src/provider.ts

@@ -72,6 +72,7 @@ export class Web3Provider extends EthersWeb3Provider implements JsonRpcHandler {
   }
 
   async getChainId(): Promise<number> {
+    // TODO: is it safe to memoize this?
     const result = await this.send('eth_chainId', [])
     const chainId = ethers.BigNumber.from(result).toNumber()
 

package/src/transports/base-wallet-transport.ts

@@ -100,11 +100,6 @@ export abstract class BaseWalletTransport implements WalletTransport {
   handleMessage = async (message: ProviderMessage<any>) => {
     const request = message
 
-    // ensure signer is ready to handle requests
-    if (this.walletRequestHandler.getSigner() === undefined) {
-      await this.walletRequestHandler.signerReady()
-    }
-
     // ensure initial handshake is complete before accepting
     // other kinds of messages.
     if (this._init !== InitState.OK) {
@@ -123,6 +118,11 @@ export abstract class BaseWalletTransport implements WalletTransport {
       return
     }
 
+    // ensure signer is ready to handle requests
+    // if (this.walletRequestHandler.getSigner() === undefined) {
+    //   await this.walletRequestHandler.signerReady()
+    // }
+
     // handle request
     switch (request.type) {
       case EventType.OPEN: {
@@ -321,11 +321,6 @@ export abstract class BaseWalletTransport implements WalletTransport {
 
     this.walletRequestHandler.setOpenIntent(intent)
 
-    // ensure signer is ready
-    if (this.walletRequestHandler.getSigner() === undefined) {
-      await this.walletRequestHandler.signerReady()
-    }
-
     // init handshake for certain transports, before we can open the communication.
     //
     // for example, with the window-transport, we have to exchange messages to determine the
@@ -369,8 +364,11 @@ export abstract class BaseWalletTransport implements WalletTransport {
       this.walletRequestHandler.setConnectOptions(undefined)
     }
 
+    // ensure signer is ready
+    await this.walletRequestHandler.getSigner()
+
     // Notify open and proceed to prompt for connection if intended
-    if (!this.walletRequestHandler.isSignedIn()) {
+    if (!(await this.walletRequestHandler.isSignedIn())) {
       // open wallet without a specific connected chainId, as the user is not signed in
       this.notifyOpen({
         sessionId: this._sessionId

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

@@ -34,6 +34,8 @@ import { logger, TypedData } from '@0xsequence/utils'
 
 import { isWalletUpToDate } from '../utils'
 
+const SIGNER_READY_TIMEOUT = 10000
+
 export interface WalletSignInOptions {
   connect?: boolean
   mainnetNetworks?: Networks
@@ -118,7 +120,7 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
 
   signOut() {
     // signed out state
-    this.signer = null
+    this.setSigner(null)
   }
 
   signerReset() {
@@ -127,14 +129,18 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
     this.signer = undefined
   }
 
-  signerReady() {
+  signerReady(timeout: number = SIGNER_READY_TIMEOUT): Promise<void> {
     return new Promise((resolve, reject) => {
       if (this.signer !== undefined) {
-        resolve(undefined)
+        resolve()
       } else {
-        this.signerReadyCallbacks.push(() => {
-          resolve(undefined)
-        })
+        setTimeout(() => {
+          if (this.signer === undefined) {
+            this.signerReadyCallbacks = []
+            reject(`signerReady timed out`)
+          }
+        }, timeout)
+        this.signerReadyCallbacks.push(resolve)
       }
     })
   }
@@ -238,9 +244,7 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
       result: null
     }
 
-    if (this.signer === undefined) {
-      await this.signerReady()
-    }
+    await this.getSigner()
 
     try {
       // only allow public json rpc method to the provider when user is not logged in, aka signer is not set
@@ -720,11 +724,16 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
     this.events.emit('close', error)
   }
 
-  isSignedIn(): boolean {
+  isSignedIn = async (): Promise<boolean> => {
+    await this.signerReady()
     return !!this.signer
   }
 
-  getSigner(): Signer | null | undefined {
+  getSigner = async (): Promise<Signer | null> => {
+    await this.signerReady()
+    if (this.signer === undefined) {
+      throw new Error('signerReady failed resolve')
+    }
     return this.signer
   }
 

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

@@ -17,7 +17,9 @@ export class WindowMessageProvider extends BaseProviderTransport {
 
   register = () => {
     if (registeredWindowMessageProvider) {
-      throw new Error('A WindowMessageProvider is already registered. There can only be one.')
+      // overriding the registered message provider
+      registeredWindowMessageProvider.unregister()
+      registeredWindowMessageProvider = this
     }
 
     // listen for incoming messages from wallet
@@ -80,6 +82,7 @@ export class WindowMessageProvider extends BaseProviderTransport {
     this._init = InitState.NIL
     this._sessionId = `${performance.now()}`
     windowSessionParams.set('sid', this._sessionId)
+    
     if (intent) {
       // for the window-transport, we eagerly/optimistically set the origin host
       // when connecting to the wallet, however, this will be verified and enforced

package/src/utils.ts

@@ -1,23 +1,55 @@
-import { BigNumberish, BytesLike } from 'ethers'
+import { ethers, BigNumberish, BytesLike } from 'ethers'
 import { WalletContext } from '@0xsequence/network'
 import { WalletConfig, addressOf, DecodedSignature, isConfigEqual } from '@0xsequence/config'
-import { packMessageData } from '@0xsequence/utils'
+import { packMessageData, encodeMessageDigest, TypedData, encodeTypedDataDigest } from '@0xsequence/utils'
 import { Web3Provider } from './provider'
-import { isValidSignature as _isValidSignature, recoverConfig, Signer } from '@0xsequence/wallet'
+import { isValidSignature as _isValidSignature, recoverConfig, Signer, isValidEIP712Signature, isValidEthSignSignature } from '@0xsequence/wallet'
 
 export const isValidSignature = async (
   address: string,
   digest: Uint8Array,
   sig: string,
-  provider: Web3Provider,
+  provider: Web3Provider | ethers.providers.Web3Provider,
   chainId?: number,
   walletContext?: WalletContext
 ): Promise<boolean | undefined> => {
-  chainId = chainId || (await provider.getChainId())
-  walletContext = walletContext || (await provider.getSigner().getWalletContext())
+  if (!chainId) {
+    chainId = (await provider.getNetwork())?.chainId
+  }
+  if (!walletContext && Web3Provider.isSequenceProvider(provider)) {
+    walletContext = await provider.getSigner().getWalletContext()
+  }
   return _isValidSignature(address, digest, sig, provider, walletContext, chainId)
 }
 
+export const isValidMessageSignature = async (
+  address: string,
+  message: string | Uint8Array,
+  signature: string,
+  provider: Web3Provider | ethers.providers.Web3Provider,
+  chainId?: number,
+  walletContext?: WalletContext
+): Promise<boolean | undefined> => {
+  const msgDigest = ethers.utils.arrayify(ethers.utils.hashMessage(message))
+  if (
+    isValidEIP712Signature(address, msgDigest, signature) ||
+    isValidEthSignSignature(address, msgDigest, signature)
+  ) return true
+
+  return isValidSignature(address, encodeMessageDigest(message), signature, provider, chainId, walletContext)
+}
+
+export const isValidTypedDataSignature = (
+  address: string,
+  typedData: TypedData,
+  signature: string,
+  provider: Web3Provider | ethers.providers.Web3Provider,
+  chainId?: number,
+  walletContext?: WalletContext
+): Promise<boolean | undefined> => {
+  return isValidSignature(address, encodeTypedDataDigest(typedData), signature, provider, chainId, walletContext)
+}
+
 export const recoverWalletConfig = async (
   address: string,
   digest: BytesLike,