@0xsequence/provider 1.10.15 → 2.0.0

package/dist/0xsequence-provider.esm.js

@@ -1,13 +1,13 @@
 import { walletContracts } from '@0xsequence/abi';
-import { commons } from '@0xsequence/core';
-import { ethers, BigNumber } from 'ethers';
+import { commons, VERSION } from '@0xsequence/core';
+import { ethers } from 'ethers';
 import { EventEmitter2 } from 'eventemitter2';
-import { logger, encodeMessageDigest, encodeTypedDataDigest, sanitizeNumberString, sanitizeHost, sanitizeAlphanumeric, base64EncodeObject, base64DecodeObject } from '@0xsequence/utils';
-import { findSupportedNetwork, ChainId, findNetworkConfig, allNetworks, JsonRpcRouter, loggingProviderMiddleware, exceptionProviderMiddleware, CachedProvider, JsonRpcSender } from '@0xsequence/network';
+import { logger, encodeMessageDigest, encodeTypedDataDigest, sanitizeNumberString, sanitizeHost, sanitizeAlphanumeric, base64EncodeObject, base64DecodeObject, toHexString } from '@0xsequence/utils';
+import { findSupportedNetwork, ChainId, findNetworkConfig, allNetworks, JsonRpcProvider, loggingProviderMiddleware, exceptionProviderMiddleware, CachedProvider } from '@0xsequence/network';
 import { signAuthorization } from '@0xsequence/auth';
 import { isBrowser, Databeat } from '@databeat/tracker';
 
-const PROHIBITED_FUNCTIONS = new Map(['addHook(bytes4,address)', 'clearExtraImageHashes(bytes32[])', 'removeHook(bytes4)', 'setExtraImageHash(bytes32,uint256)', 'updateIPFSRoot(bytes32)', 'updateImageHash(bytes32)', 'updateImageHashAndIPFS(bytes32,bytes32)', 'updateImplementation(address)'].map(signature => [ethers.utils.keccak256(ethers.utils.toUtf8Bytes(signature)).slice(0, 10), signature]));
+const PROHIBITED_FUNCTIONS = new Map(['addHook(bytes4,address)', 'clearExtraImageHashes(bytes32[])', 'removeHook(bytes4)', 'setExtraImageHash(bytes32,uint256)', 'updateIPFSRoot(bytes32)', 'updateImageHash(bytes32)', 'updateImageHashAndIPFS(bytes32,bytes32)', 'updateImplementation(address)'].map(signature => [ethers.id(signature).slice(0, 10), signature]));
 function validateTransactionRequest(wallet, transaction) {
   const transactions = commons.transaction.fromTransactionish(wallet, transaction);
   const unwound = commons.transaction.unwind(wallet, transactions);
@@ -16,7 +16,7 @@ function validateTransactionRequest(wallet, transaction) {
 function validateTransaction(wallet, transaction) {
   if (transaction.to.toLowerCase() === wallet.toLowerCase()) {
     if (transaction.data) {
-      const data = ethers.utils.arrayify(transaction.data);
+      const data = ethers.getBytes(transaction.data);
       if (data.length >= 4 && !isCreateContractCall(data)) {
         throw new Error('self calls are forbidden');
       }
@@ -26,7 +26,7 @@ function validateTransaction(wallet, transaction) {
     throw new Error('delegate calls are forbidden');
   }
   if (transaction.data) {
-    const data = ethers.utils.hexlify(transaction.data);
+    const data = ethers.hexlify(transaction.data);
     const selector = data.slice(0, 10);
     const signature = PROHIBITED_FUNCTIONS.get(selector);
     if (signature) {
@@ -36,7 +36,7 @@ function validateTransaction(wallet, transaction) {
   }
 }
 function isCreateContractCall(data) {
-  const walletInterface = new ethers.utils.Interface(walletContracts.mainModule.abi);
+  const walletInterface = new ethers.Interface(walletContracts.mainModule.abi);
   try {
     walletInterface.decodeFunctionData('createContract', data);
     return true;
@@ -64,6 +64,8 @@ function isProviderTransport(transport) {
   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';
 }
 
+// Older versions of sequence.js will require a JsonRpcResponse result type, but newer versions use raw EIP1193 results
+
 // ProviderMessageCallback is used to respond to ProviderMessage requests. The error
 // argument is for exceptions during the execution, and response is the response payload
 // which may contain the result or an error payload from the wallet.
@@ -121,8 +123,6 @@ const ErrSignedInRequired = new ProviderError('Wallet is not signed in. Connect
 
 // TODO: lets build some nice error handling tools, prob in /utils ...
 
-// This is required by viem, it expects a provider to have an EIP-1193 compliant `request` attribute.
-
 const PROVIDER_OPEN_TIMEOUT = 30000; // in ms
 
 let _messageIdx = 0;
@@ -143,42 +143,6 @@ class BaseProviderTransport {
     this._sessionId = void 0;
     this._init = void 0;
     this._registered = void 0;
-    this.sendAsync = async function (request, callback, chainId) {
-      // here, we receive the message from the dapp provider call
-
-      if (_this.state === OpenState.CLOSED) {
-        // flag the wallet to auto-close once user submits input. ie.
-        // prompting to sign a message or transaction
-        _this.confirmationOnly = true;
-      }
-
-      // open/focus the wallet.
-      // automatically open the wallet when a provider request makes it here.
-      //
-      // NOTE: if we're not signed in, then the provider will fail, users must first connect+sign in.
-      //
-      // TODO: how does this behave with a session has expired?
-      _this.openWallet(undefined, {
-        type: 'jsonRpcRequest',
-        method: request.method
-      }, chainId);
-
-      // send message request, await, and then execute callback after receiving the response
-      try {
-        if (!_this.isOpened()) {
-          await _this.waitUntilOpened(); // will throw on timeout
-        }
-        const response = await _this.sendMessageRequest({
-          idx: nextMessageIdx(),
-          type: EventType.MESSAGE,
-          data: request,
-          chainId: chainId
-        });
-        callback(undefined, response.data);
-      } catch (err) {
-        callback(err);
-      }
-    };
     // sendMessageRequest sends a ProviderMessageRequest over the wire to the wallet
     this.sendMessageRequest = async function (message) {
       return new Promise((resolve, reject) => {
@@ -288,6 +252,36 @@ class BaseProviderTransport {
     const session = (_this$openPayload2 = this.openPayload) == null ? void 0 : _this$openPayload2.session;
     return this.registered && session !== undefined && !!session.accountAddress && session.accountAddress.length === 42 && !!session.networks && session.networks.length > 0;
   }
+  async request(request) {
+    if (this.state === OpenState.CLOSED) {
+      // flag the wallet to auto-close once user submits input. ie.
+      // prompting to sign a message or transaction
+      this.confirmationOnly = true;
+    }
+
+    // open/focus the wallet.
+    // automatically open the wallet when a provider request makes it here.
+    //
+    // NOTE: if we're not signed in, then the provider will fail, users must first connect+sign in.
+    //
+    // TODO: how does this behave with a session has expired?
+    this.openWallet(undefined, {
+      type: 'jsonRpcRequest',
+      method: request.method
+    }, request.chainId);
+    if (!this.isOpened()) {
+      await this.waitUntilOpened(); // will throw on timeout
+    }
+    const response = await this.sendMessageRequest({
+      idx: nextMessageIdx(),
+      type: EventType.MESSAGE,
+      data: request,
+      chainId: request.chainId,
+      clientVersion: VERSION
+    });
+    return response.data;
+  }
+
   // handleMessage will handle message received from the remote wallet
   handleMessage(message) {
     var _this2 = this;
@@ -309,7 +303,8 @@ class BaseProviderTransport {
         data: {
           sessionId: this._sessionId,
           nonce: nonce
-        }
+        },
+        clientVersion: VERSION
       });
     }
     if (this._init !== InitState.OK) {
@@ -394,7 +389,7 @@ class BaseProviderTransport {
       };
       if (message.data && message.data.length > 0) {
         this.accountsChangedPayload = {
-          accounts: [ethers.utils.getAddress(message.data[0])],
+          accounts: [ethers.getAddress(message.data[0])],
           origin: message.origin
         };
         this.events.emit('accountsChanged', this.accountsChangedPayload.accounts, this.accountsChangedPayload.origin);
@@ -499,7 +494,7 @@ const EIP_191_PREFIX_EXCEPTIONS = [
 const DCL_REGEX = /^Decentraland Login\nEphemeral address: 0x[a-fA-F0-9]{40}\nExpiration: (\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)((-(\d{2}):(\d{2})|Z)?)$/;
 function isDecentralandLoginMessage(bytes) {
   try {
-    const stringified = ethers.utils.toUtf8String(bytes);
+    const stringified = ethers.toUtf8String(bytes);
     return DCL_REGEX.test(stringified);
   } catch (_unused) {
     return false;
@@ -509,7 +504,7 @@ function isDecentralandLoginMessage(bytes) {
 // try to interpret bytes as abi-encoded 0x v3 OrderWithHash -
 // see https://github.com/0xProject/0x-protocol-specification/blob/master/v3/v3-specification.md
 function isZeroExV3Order(bytes) {
-  const abi = new ethers.utils.Interface(ZeroXV3EIP1271OrderWithHashAbi);
+  const abi = new ethers.Interface(ZeroXV3EIP1271OrderWithHashAbi);
   try {
     abi.decodeFunctionData('OrderWithHash', bytes);
     return true;
@@ -591,19 +586,19 @@ const ZeroXV3EIP1271OrderWithHashAbi = [{
   type: 'function'
 }];
 
-const eip191prefix = ethers.utils.toUtf8Bytes('\x19Ethereum Signed Message:\n');
+const eip191prefix = ethers.toUtf8Bytes('\x19Ethereum Signed Message:\n');
 const messageToBytes = message => {
-  if (ethers.utils.isBytesLike(message)) {
-    return ethers.utils.arrayify(message);
+  if (ethers.isBytesLike(message)) {
+    return ethers.getBytes(message);
   }
-  return ethers.utils.toUtf8Bytes(message);
+  return ethers.toUtf8Bytes(message);
 };
 const prefixEIP191Message = message => {
   const messageBytes = messageToBytes(message);
   if (messageIsExemptFromEIP191Prefix(messageBytes)) {
     return messageBytes;
   } else {
-    return ethers.utils.concat([eip191prefix, ethers.utils.toUtf8Bytes(String(messageBytes.length)), messageBytes]);
+    return ethers.getBytes(ethers.concat([eip191prefix, ethers.toUtf8Bytes(String(messageBytes.length)), messageBytes]));
   }
 };
 const trimEIP191Prefix = prefixedMessage => {
@@ -628,9 +623,9 @@ const trimEIP191Prefix = prefixedMessage => {
   let prefixCharLenght;
   let prefixAsNumber;
   try {
-    prefixAsNumber = Number(ethers.utils.toUtf8String(ethereumSignedMessagePartSlicedArray.slice(0, maxPrefixCharLength)));
+    prefixAsNumber = Number(ethers.toUtf8String(ethereumSignedMessagePartSlicedArray.slice(0, maxPrefixCharLength)));
   } catch (_unused) {
-    prefixAsNumber = Number(ethers.utils.hexlify(ethereumSignedMessagePartSlicedArray.slice(0, maxPrefixCharLength)));
+    prefixAsNumber = Number(ethers.hexlify(ethereumSignedMessagePartSlicedArray.slice(0, maxPrefixCharLength)));
   }
   if (prefixAsNumber > ethereumSignedMessagePartSlicedArray.length || !Number.isInteger(prefixAsNumber)) {
     prefixCharLenght = maxPrefixCharLength - 1;
@@ -745,9 +740,9 @@ function useBestStore() {
 async function resolveArrayProperties(object) {
   if (Array.isArray(object)) {
     // T must include array type
-    return Promise.all(object.map(o => ethers.utils.resolveProperties(o)));
+    return Promise.all(object.map(o => ethers.resolveProperties(o)));
   }
-  return ethers.utils.resolveProperties(object);
+  return ethers.resolveProperties(object);
 }
 
 const TRANSPORT_SESSION_LS_KEY = '@sequence.transportSession';
@@ -764,9 +759,6 @@ class BaseWalletTransport {
     // will auto-detect and set this value if it can. This is determined
     // as the parent app/window which opened the wallet.
     this.appOrigin = void 0;
-    this.sendAsync = async function (request, callback, chainId) {
-      throw new Error('abstract method');
-    };
     this.handleMessage = async function (message) {
       const request = message;
 
@@ -1002,7 +994,7 @@ class BaseWalletTransport {
       if (!networks || networks.length === 0) {
         this.notifyChainChanged('0x0');
       } else {
-        this.notifyChainChanged(ethers.utils.hexValue(networks.find(network => network.isDefaultChain).chainId));
+        this.notifyChainChanged(ethers.toQuantity(networks.find(network => network.isDefaultChain).chainId));
       }
     });
     this.walletRequestHandler.on('chainChanged', (chainIdHex, origin) => {
@@ -1026,6 +1018,9 @@ class BaseWalletTransport {
   unregister() {
     throw new Error('abstract method');
   }
+  request(request) {
+    throw new Error('abstract method');
+  }
   sendMessage(message) {
     throw new Error('abstract method');
   }
@@ -1044,7 +1039,8 @@ class BaseWalletTransport {
         sessionId,
         session,
         error
-      }
+      },
+      clientVersion: VERSION
     });
   }
   notifyClose(error) {
@@ -1053,14 +1049,16 @@ class BaseWalletTransport {
       type: EventType.CLOSE,
       data: error ? {
         error
-      } : null
+      } : null,
+      clientVersion: VERSION
     });
   }
   notifyConnect(connectDetails) {
     this.sendMessage({
       idx: -1,
       type: EventType.CONNECT,
-      data: connectDetails
+      data: connectDetails,
+      clientVersion: VERSION
     });
   }
   notifyDisconnect(error, origin) {
@@ -1070,7 +1068,8 @@ class BaseWalletTransport {
       data: error ? {
         error
       } : null,
-      origin
+      origin,
+      clientVersion: VERSION
     });
   }
   notifyAccountsChanged(accounts, origin) {
@@ -1078,7 +1077,8 @@ class BaseWalletTransport {
       idx: -1,
       type: EventType.ACCOUNTS_CHANGED,
       data: accounts,
-      origin
+      origin,
+      clientVersion: VERSION
     });
   }
   notifyChainChanged(chainIdHex, origin) {
@@ -1086,21 +1086,24 @@ class BaseWalletTransport {
       idx: -1,
       type: EventType.CHAIN_CHANGED,
       data: chainIdHex,
-      origin
+      origin,
+      clientVersion: VERSION
     });
   }
   notifyNetworks(networks) {
     this.sendMessage({
       idx: -1,
       type: EventType.NETWORKS,
-      data: networks
+      data: networks,
+      clientVersion: VERSION
     });
   }
   notifyWalletContext(walletContext) {
     this.sendMessage({
       idx: -1,
       type: EventType.WALLET_CONTEXT,
-      data: walletContext
+      data: walletContext,
+      clientVersion: VERSION
     });
   }
   isValidInitAck(message) {
@@ -1171,7 +1174,8 @@ class BaseWalletTransport {
         type: EventType.INIT,
         data: {
           nonce: this._initNonce
-        }
+        },
+        clientVersion: VERSION
       });
       this._init = InitState.SENT_NONCE;
 
@@ -1270,7 +1274,8 @@ class ProxyMessageProvider extends BaseProviderTransport {
             intent,
             networkId,
             sessionId
-          }
+          },
+          clientVersion: VERSION
         });
       }
     };
@@ -1288,7 +1293,8 @@ class ProxyMessageProvider extends BaseProviderTransport {
     this.sendMessage({
       idx: -1,
       type: EventType.CLOSE,
-      data: null
+      data: null,
+      clientVersion: VERSION
     });
     this.close();
   }
@@ -1876,7 +1882,13 @@ class WindowMessageHandler extends BaseWalletTransport {
       // Wallet always expects json-rpc request messages from a dapp
       let request;
       try {
-        request = JSON.parse(event.data);
+        request = JSON.parse(event.data, (key, value) => {
+          // BigNumber compatibility with older versions of sequence.js
+          if (isBigNumberSerialized(value)) {
+            return BigInt(value.hex);
+          }
+          return value;
+        });
       } catch (err) {
         // event is not a ProviderMessage JSON object, skip
         return;
@@ -1915,7 +1927,6 @@ class WindowMessageHandler extends BaseWalletTransport {
 
     // record open details (sessionId + default network) from the window url
     const {
-      pathname,
       search: rawParams
     } = new URL(windowHref || window.location.href);
     let session = this.getWindowTransportSession(rawParams);
@@ -1999,6 +2010,9 @@ class WindowMessageHandler extends BaseWalletTransport {
     }
   }
 }
+const isBigNumberSerialized = value => {
+  return typeof value === 'object' && value.type === 'BigNumber' && ethers.isHexString(value.hex);
+};
 
 function isMuxTransportTemplate(obj) {
   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') && (
@@ -2049,13 +2063,6 @@ class MuxMessageProvider {
       }
       this.messageProviders.forEach(m => m.openWallet(path, intent, networkId));
     };
-    this.sendAsync = async function (request, callback, chainId) {
-      if (_this.provider) {
-        _this.provider.sendAsync(request, callback, chainId);
-        return;
-      }
-      throw new Error('impossible state, wallet must be opened first');
-    };
     this.sendMessageRequest = async function (message) {
       if (_this.provider) {
         return _this.provider.sendMessageRequest(message);
@@ -2152,6 +2159,12 @@ class MuxMessageProvider {
     }
     return true;
   }
+  request(request) {
+    if (!this.provider) {
+      throw new Error('impossible state, wallet must be opened first');
+    }
+    return this.provider.request(request);
+  }
   sendMessage(message) {
     if (!message.idx || message.idx <= 0) {
       throw new Error('message idx is empty');
@@ -2186,7 +2199,7 @@ function fromExtended(transaction) {
 
 const SIGNER_READY_TIMEOUT = 10000;
 class WalletRequestHandler {
-  constructor(_account, prompter, networks) {
+  constructor(account, prompter, networks) {
     var _this = this;
     // signer interface of the wallet. A null value means there is no signer (ie. user not signed in). An undefined
     // value means the signer state is unknown, usually meaning the wallet app is booting up and initializing. Of course
@@ -2219,417 +2232,6 @@ class WalletRequestHandler {
       }
       return promptConnectDetails;
     };
-    // sendAsync implements the JsonRpcHandler interface for sending JsonRpcRequests to the wallet
-    this.sendAsync = async function (request, callback, chainId) {
-      const response = {
-        jsonrpc: '2.0',
-        id: request.id,
-        result: null
-      };
-      await _this.getAccount();
-      try {
-        var _this$account;
-        // only allow public json rpc method to the provider when user is not logged in, aka signer is not set
-        if ((!_this.account || _this.account === null) && !permittedJsonRpcMethods.includes(request.method)) {
-          // throw new Error(`not logged in. ${request.method} is unavailable`)
-          throw ErrSignedInRequired;
-        }
-
-        // wallet account
-        const account = _this.account;
-        if (!account) throw new Error('WalletRequestHandler: wallet account is not configured');
-
-        // fetch the provider for the specific chain, or undefined will select defaultChain
-        const provider = (_this$account = _this.account) == null ? void 0 : _this$account.providerFor(chainId != null ? chainId : _this.defaultChainId());
-        if (!provider) throw new Error(`WalletRequestHandler: wallet provider is not configured for chainId ${chainId}`);
-        const jsonRpcProvider = provider instanceof ethers.providers.JsonRpcProvider ? provider : undefined;
-        switch (request.method) {
-          case 'net_version':
-            {
-              if (!jsonRpcProvider) {
-                throw new Error(`Account provider doesn't support send method`);
-              }
-              const result = await jsonRpcProvider.send('net_version', []);
-              response.result = result;
-              break;
-            }
-          case 'eth_chainId':
-            {
-              if (!jsonRpcProvider) {
-                throw new Error(`Account provider doesn't support send method`);
-              }
-              const result = await jsonRpcProvider.send('eth_chainId', []);
-              response.result = result;
-              break;
-            }
-          case 'eth_accounts':
-            {
-              const walletAddress = account.address;
-              response.result = [walletAddress];
-              break;
-            }
-          case 'eth_getBalance':
-            {
-              const [accountAddress, blockTag] = request.params;
-              const walletBalance = await provider.getBalance(accountAddress, blockTag);
-              response.result = walletBalance.toHexString();
-              break;
-            }
-          case 'sequence_sign':
-          case 'personal_sign':
-          case 'eth_sign':
-            {
-              // note: message from json-rpc input is in hex format
-              let message;
-
-              // there is a difference in the order of the params:
-              // sequence_sign, personal_sign: [data, address]
-              // eth_sign: [address, data]
-              switch (request.method) {
-                case 'sequence_sign':
-                case 'personal_sign':
-                  {
-                    const [data, _address] = request.params;
-                    message = data;
-                    break;
-                  }
-                case 'eth_sign':
-                  {
-                    const [_address, data] = request.params;
-                    message = data;
-                    break;
-                  }
-              }
-              let sig = '';
-
-              // Message must be prefixed with "\x19Ethereum Signed Message:\n"
-              // as defined by EIP-191
-              const prefixedMessage = prefixEIP191Message(message);
-
-              // TODO:
-              // if (process.env.TEST_MODE === 'true' && this.prompter === null) {
-              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 != null ? chainId : _this.defaultChainId(), sequenceVerified ? 'eip6492' : 'ignore');
-              } else {
-                sig = await _this.prompter.promptSignMessage({
-                  chainId: chainId,
-                  message: prefixedMessage,
-                  eip6492: sequenceVerified
-                }, _this.connectOptions);
-              }
-              if (sig && sig.length > 0) {
-                response.result = sig;
-              } else {
-                // The user has declined the request when value is null
-                throw new Error('declined by user');
-              }
-              break;
-            }
-          case 'sequence_signTypedData_v4':
-          case 'eth_signTypedData':
-          case 'eth_signTypedData_v4':
-            {
-              // note: signingAddress from json-rpc input is in hex format, and typedDataObject
-              // should be an object, but in some instances may be double string encoded
-              const [signingAddress, typedDataObject] = request.params;
-              let typedData = undefined;
-              if (typeof typedDataObject === 'string') {
-                try {
-                  typedData = JSON.parse(typedDataObject);
-                } catch (e) {
-                  console.warn('walletRequestHandler: error parsing typedData', e);
-                }
-              } else {
-                typedData = typedDataObject;
-              }
-              if (!typedData || !typedData.domain || !typedData.types || !typedData.message) {
-                throw new Error('invalid typedData object');
-              }
-              let sig = '';
-              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 != null ? chainId : _this.defaultChainId(), sequenceVerified ? 'eip6492' : 'ignore');
-              } else {
-                sig = await _this.prompter.promptSignMessage({
-                  chainId: chainId,
-                  typedData: typedData,
-                  eip6492: sequenceVerified
-                }, _this.connectOptions);
-              }
-              if (sig && sig.length > 0) {
-                response.result = sig;
-              } else {
-                // The user has declined the request when value is null
-                throw new Error('declined by user');
-              }
-              break;
-            }
-          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;
-                  delete tx.gas;
-                }
-                return tx;
-              });
-              validateTransactionRequest(account.address, transactionParams);
-              let txnHash = '';
-              if (_this.prompter === null) {
-                var _txnResponse$hash;
-                // prompter is null, so we'll send from here
-                const txnResponse = await account.sendTransaction(transactionParams, chainId != null ? chainId : _this.defaultChainId());
-                txnHash = (_txnResponse$hash = txnResponse == null ? void 0 : txnResponse.hash) != null ? _txnResponse$hash : '';
-              } else {
-                // prompt user to provide the response
-                txnHash = await _this.prompter.promptSendTransaction(transactionParams, chainId, _this.connectOptions);
-              }
-              if (txnHash) {
-                response.result = txnHash;
-              } else {
-                // The user has declined the request when value is null
-                throw new Error('declined by user');
-              }
-              break;
-            }
-          case 'eth_signTransaction':
-            {
-              // https://eth.wiki/json-rpc/API#eth_signTransaction
-              const [transaction] = request.params;
-              const sender = ethers.utils.getAddress(transaction.from);
-              if (sender !== account.address) {
-                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.
-                //
-                // TODO: verify serializing / transporting the SignedTransaction object works as expected, most likely however
-                // we will want to resolveProperties the big number values to hex strings
-                response.result = await account.signTransactions(transaction, chainId != null ? chainId : _this.defaultChainId());
-              } else {
-                response.result = await _this.prompter.promptSignTransaction(transaction, chainId, _this.connectOptions);
-              }
-              break;
-            }
-          case 'eth_sendRawTransaction':
-            {
-              // NOTE: we're not using a prompter here as the transaction is already signed
-              // and would have prompted the user upon signing.
-
-              // https://eth.wiki/json-rpc/API#eth_sendRawTransaction
-              if (commons.transaction.isSignedTransactionBundle(request.params[0])) {
-                const txChainId = BigNumber.from(request.params[0].chainId).toNumber();
-                const tx = await account.relayer(txChainId).relay(request.params[0]);
-                response.result = tx.hash;
-              } else {
-                const tx = await provider.sendTransaction(request.params[0]);
-                response.result = tx.hash;
-              }
-              break;
-            }
-          case 'eth_getTransactionCount':
-            {
-              const address = ethers.utils.getAddress(request.params[0]);
-              const tag = request.params[1];
-
-              // TODO: Maybe we should fetch this data from the relayer or from the reader
-              // but for now we keep it simple and just use the provider
-
-              const count = await provider.getTransactionCount(address, tag);
-              response.result = ethers.BigNumber.from(count).toHexString();
-              break;
-            }
-          case 'eth_blockNumber':
-            {
-              response.result = await provider.getBlockNumber();
-              break;
-            }
-          case 'eth_getBlockByNumber':
-            {
-              response.result = await provider.getBlock(request.params[0] /* , jsonRpcRequest.params[1] */);
-              break;
-            }
-          case 'eth_getBlockByHash':
-            {
-              response.result = await provider.getBlock(request.params[0] /* , jsonRpcRequest.params[1] */);
-              break;
-            }
-          case 'eth_getTransactionByHash':
-            {
-              response.result = await provider.getTransaction(request.params[0]);
-              break;
-            }
-          case 'eth_call':
-            {
-              const [transactionObject, blockTag] = request.params;
-              response.result = await provider.call(transactionObject, blockTag);
-              break;
-            }
-          case 'eth_getCode':
-            {
-              const [contractAddress, blockTag] = request.params;
-              response.result = await provider.getCode(contractAddress, blockTag);
-              break;
-            }
-          case 'eth_estimateGas':
-            {
-              const [transactionObject] = request.params;
-              response.result = await provider.estimateGas(transactionObject);
-              break;
-            }
-          case 'eth_gasPrice':
-            {
-              const gasPrice = await provider.getGasPrice();
-              response.result = gasPrice.toHexString();
-              break;
-            }
-          case 'wallet_switchEthereumChain':
-            {
-              const [switchParams] = request.params;
-              if (!switchParams.chainId || switchParams.chainId.length === 0) {
-                throw new Error('invalid chainId');
-              }
-              const _chainId = ethers.BigNumber.from(switchParams.chainId);
-              _this.setDefaultChainId(_chainId.toNumber());
-              response.result = null; // success
-              break;
-            }
-
-          // smart wallet method
-          case 'sequence_getWalletContext':
-            {
-              response.result = account.contexts;
-              break;
-            }
-
-          // smart wallet method
-          case 'sequence_getWalletConfig':
-            {
-              const [_chainId2] = request.params;
-              if (_chainId2) {
-                response.result = [(await account.status(_chainId2)).onChain.config];
-              } else {
-                response.result = await Promise.all(account.networks.map(async function (network) {
-                  const status = await account.status(network.chainId);
-                  return status.onChain.config;
-                }));
-              }
-              break;
-            }
-
-          // smart wallet method
-          case 'sequence_getWalletState':
-            {
-              const [_chainId3] = request.params;
-              // TODO: Add getWalletState to the Signer interface
-              if (_chainId3) {
-                response.result = [getLegacyWalletState(_chainId3, await account.status(_chainId3))];
-              } else {
-                response.result = await Promise.all(account.networks.map(async function (network) {
-                  const status = await account.status(network.chainId);
-                  return getLegacyWalletState(network.chainId, status);
-                }));
-              }
-              break;
-            }
-
-          // smart wallet method
-          case 'sequence_getNetworks':
-            {
-              // NOTE: must ensure that the response result below returns clean serialized data, which is to omit
-              // the provider and relayer objects and only return the urls so can be reinstantiated on dapp side.
-              // This is handled by this.getNetworks() but noted here for future readers.
-              response.result = await _this.getNetworks(true);
-              break;
-            }
-          case 'sequence_isSequence':
-            {
-              response.result = true;
-              break;
-            }
-
-          // smart wallet method
-          case 'sequence_updateConfig':
-            {
-              throw new Error('sequence_updateConfig method is not allowed from a dapp');
-              // NOTE: method is disabled as we don't need a dapp to request to update a config.
-              // However, if we ever want this, we can enable it but must also use the prompter
-              // for confirmation.
-              //
-              // const [newConfig] = request.params
-              // response.result = await signer.updateConfig(newConfig)
-              break;
-            }
-
-          // smart wallet method
-          case 'sequence_publishConfig':
-            {
-              throw new Error('sequence_publishConfig method is not allowed from a dapp');
-              break;
-            }
-
-          // relayer method
-          case 'sequence_gasRefundOptions':
-            {
-              // TODO
-              break;
-            }
-
-          // relayer method
-          case 'sequence_getNonce':
-            {
-              // TODO
-              break;
-            }
-
-          // relayer method
-          case 'sequence_relay':
-            {
-              // TODO
-              break;
-            }
-
-          // set default network of wallet
-          case 'sequence_setDefaultNetwork':
-            {
-              const [defaultChainId] = request.params;
-              if (!defaultChainId) {
-                throw new Error('invalid request, method argument defaultChainId cannot be empty');
-              }
-              _this.setDefaultChainId(defaultChainId);
-              response.result = await _this.getNetworks(true);
-              break;
-            }
-          default:
-            {
-              if (!jsonRpcProvider) {
-                throw new Error(`Account provider doesn't support send method`);
-              }
-
-              // NOTE: provider here will be chain-bound if chainId is provided
-              const providerResponse = await jsonRpcProvider.send(request.method, request.params);
-              response.result = providerResponse;
-            }
-        }
-      } catch (err) {
-        logger.error(err);
-
-        // See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1193.md#rpc-errors
-        response.result = null;
-        response.error = _extends({}, new Error(err), {
-          code: 4001
-        });
-      }
-      callback(undefined, response);
-    };
     this.isSignedIn = async function () {
       await _this.signerReady();
       return !!_this.account;
@@ -2641,7 +2243,7 @@ class WalletRequestHandler {
       }
       return _this.account;
     };
-    this.account = _account;
+    this.account = account;
     this.prompter = prompter;
     this.networks = networks;
   }
@@ -2725,7 +2327,7 @@ class WalletRequestHandler {
     const chainId = findSupportedNetwork(networkId).chainId;
     const connectDetails = {
       connected: true,
-      chainId: ethers.utils.hexValue(chainId)
+      chainId: ethers.toQuantity(chainId)
     };
     if (options && options.authorize) {
       // Perform ethauth eip712 request and construct the ConnectDetails response
@@ -2760,20 +2362,415 @@ class WalletRequestHandler {
   // sendMessageRequest will unwrap the ProviderMessageRequest and send it to the JsonRpcHandler
   // (aka, the signer in this instance) and then responds with a wrapped response of
   // ProviderMessageResponse to be sent over the transport
-  sendMessageRequest(message) {
-    return new Promise(resolve => {
-      this.sendAsync(message.data, (error, response) => {
-        // TODO: if response includes data.error, why do we need a separate error argument here?
+  async sendMessageRequest(message) {
+    var _message$clientVersio;
+    // Older versions of the client require the response to be jsonrpc wrapped
+    const majorVersion = Number(((_message$clientVersio = message.clientVersion) == null ? void 0 : _message$clientVersio.split('.')[0]) || '0');
+    const isJsonRpcResponse = majorVersion < 2;
+    const jsonRpcResponse = {
+      id: message.data.id,
+      jsonrpc: '2.0',
+      result: null,
+      error: undefined
+    };
+    try {
+      const result = await this.request({
+        method: message.data.method,
+        params: message.data.params,
+        chainId: message.chainId
+      });
+      return _extends({}, message, {
+        data: isJsonRpcResponse ? _extends({}, jsonRpcResponse, {
+          result
+        }) : result
+      });
+    } catch (error) {
+      return _extends({}, message, {
+        data: isJsonRpcResponse ? _extends({}, jsonRpcResponse, {
+          error
+        }) : error
+      });
+    }
+  }
+  async request(request) {
+    await this.getAccount();
+    try {
+      var _this$account, _request$chainId;
+      // only allow public json rpc method to the provider when user is not logged in, aka signer is not set
+      if ((!this.account || this.account === null) && !permittedJsonRpcMethods.includes(request.method)) {
+        // throw new Error(`not logged in. ${request.method} is unavailable`)
+        throw ErrSignedInRequired;
+      }
 
-        const responseMessage = _extends({}, message, {
-          data: response
-        });
+      // wallet account
+      const account = this.account;
+      if (!account) {
+        throw new Error('WalletRequestHandler: wallet account is not configured');
+      }
 
-        // NOTE: we always resolve here, are the sendAsync call will wrap any exceptions
-        // in the error field of the response to ensure we send back to the user
-        resolve(responseMessage);
-      }, message.chainId);
-    });
+      // fetch the provider for the specific chain, or undefined will select defaultChain
+      const provider = (_this$account = this.account) == null ? void 0 : _this$account.providerFor((_request$chainId = request.chainId) != null ? _request$chainId : this.defaultChainId());
+      if (!provider) {
+        throw new Error(`WalletRequestHandler: wallet provider is not configured for chainId ${request.chainId}`);
+      }
+      const jsonRpcProvider = provider instanceof ethers.JsonRpcProvider ? provider : undefined;
+      switch (request.method) {
+        case 'net_version':
+          {
+            if (!jsonRpcProvider) {
+              throw new Error(`Account provider doesn't support send method`);
+            }
+            return await jsonRpcProvider.send('net_version', []);
+          }
+        case 'eth_chainId':
+          {
+            if (!jsonRpcProvider) {
+              throw new Error(`Account provider doesn't support send method`);
+            }
+            return await jsonRpcProvider.send('eth_chainId', []);
+          }
+        case 'eth_accounts':
+          {
+            return [account.address];
+          }
+        case 'eth_getBalance':
+          {
+            const [accountAddress, blockTag] = request.params;
+            const walletBalance = await provider.getBalance(accountAddress, blockTag);
+            return toHexString(walletBalance);
+          }
+        case 'sequence_sign':
+        case 'personal_sign':
+        case 'eth_sign':
+          {
+            // note: message from json-rpc input is in hex format
+            let message;
+
+            // there is a difference in the order of the params:
+            // sequence_sign, personal_sign: [data, address]
+            // eth_sign: [address, data]
+            switch (request.method) {
+              case 'sequence_sign':
+              case 'personal_sign':
+                {
+                  const [data, _address] = request.params;
+                  message = data;
+                  break;
+                }
+              case 'eth_sign':
+                {
+                  const [_address, data] = request.params;
+                  message = data;
+                  break;
+                }
+            }
+            let sig = '';
+
+            // Message must be prefixed with "\x19Ethereum Signed Message:\n"
+            // as defined by EIP-191
+            const prefixedMessage = prefixEIP191Message(message);
+
+            // TODO:
+            // if (process.env.TEST_MODE === 'true' && this.prompter === null) {
+            const sequenceVerified = request.method === 'sequence_sign';
+            if (this.prompter === null) {
+              var _request$chainId2;
+              // prompter is null, so we'll sign from here
+              sig = await account.signMessage(prefixedMessage, (_request$chainId2 = request.chainId) != null ? _request$chainId2 : this.defaultChainId(), sequenceVerified ? 'eip6492' : 'ignore');
+            } else {
+              sig = await this.prompter.promptSignMessage({
+                chainId: request.chainId,
+                message: ethers.getBytes(prefixedMessage),
+                eip6492: sequenceVerified
+              }, this.connectOptions);
+            }
+            if (sig && sig.length > 0) {
+              return sig;
+            } else {
+              // The user has declined the request when value is null
+              throw new Error('declined by user');
+            }
+          }
+        case 'sequence_signTypedData_v4':
+        case 'eth_signTypedData':
+        case 'eth_signTypedData_v4':
+          {
+            // note: signingAddress from json-rpc input is in hex format, and typedDataObject
+            // should be an object, but in some instances may be double string encoded
+            const [signingAddress, typedDataObject] = request.params;
+            let typedData = undefined;
+            if (typeof typedDataObject === 'string') {
+              try {
+                typedData = JSON.parse(typedDataObject);
+              } catch (e) {
+                console.warn('walletRequestHandler: error parsing typedData', e);
+              }
+            } else {
+              typedData = typedDataObject;
+            }
+            if (!typedData || !typedData.domain || !typedData.types || !typedData.message) {
+              throw new Error('invalid typedData object');
+            }
+            let sig = '';
+            const sequenceVerified = request.method === 'sequence_signTypedData_v4';
+            if (this.prompter === null) {
+              var _request$chainId3;
+              // prompter is null, so we'll sign from here
+              sig = await account.signTypedData(typedData.domain, typedData.types, typedData.message, (_request$chainId3 = request.chainId) != null ? _request$chainId3 : this.defaultChainId(), sequenceVerified ? 'eip6492' : 'ignore');
+            } else {
+              sig = await this.prompter.promptSignMessage({
+                chainId: request.chainId,
+                typedData: typedData,
+                eip6492: sequenceVerified
+              }, this.connectOptions);
+            }
+            if (sig && sig.length > 0) {
+              return sig;
+            } else {
+              // The user has declined the request when value is null
+              throw new Error('declined by user');
+            }
+          }
+        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;
+                delete tx.gas;
+              }
+              return tx;
+            });
+            validateTransactionRequest(account.address, transactionParams);
+            let txnHash = '';
+            if (this.prompter === null) {
+              var _request$chainId4, _txnResponse$hash;
+              // prompter is null, so we'll send from here
+              const txnResponse = await account.sendTransaction(transactionParams, (_request$chainId4 = request.chainId) != null ? _request$chainId4 : this.defaultChainId());
+              txnHash = (_txnResponse$hash = txnResponse == null ? void 0 : txnResponse.hash) != null ? _txnResponse$hash : '';
+            } else {
+              // prompt user to provide the response
+              txnHash = await this.prompter.promptSendTransaction(transactionParams, request.chainId, this.connectOptions);
+            }
+            if (txnHash) {
+              return txnHash;
+            } else {
+              // The user has declined the request when value is null
+              throw new Error('declined by user');
+            }
+          }
+        case 'eth_signTransaction':
+          {
+            // https://eth.wiki/json-rpc/API#eth_signTransaction
+            const [transaction] = request.params;
+            const sender = ethers.getAddress(transaction.from);
+            if (sender !== account.address) {
+              throw new Error('sender address does not match wallet');
+            }
+            validateTransactionRequest(account.address, transaction);
+            if (this.prompter === null) {
+              var _request$chainId5;
+              // 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.
+              //
+              // TODO: verify serializing / transporting the SignedTransaction object works as expected, most likely however
+              // we will want to resolveProperties the big number values to hex strings
+              return await account.signTransactions(transaction, (_request$chainId5 = request.chainId) != null ? _request$chainId5 : this.defaultChainId());
+            } else {
+              return await this.prompter.promptSignTransaction(transaction, request.chainId, this.connectOptions);
+            }
+          }
+        case 'eth_sendRawTransaction':
+          {
+            // NOTE: we're not using a prompter here as the transaction is already signed
+            // and would have prompted the user upon signing.
+
+            // https://eth.wiki/json-rpc/API#eth_sendRawTransaction
+            if (commons.transaction.isSignedTransactionBundle(request.params[0])) {
+              const txChainId = Number(request.params[0].chainId);
+              const tx = await account.relayer(txChainId).relay(request.params[0]);
+              return tx.hash;
+            } else {
+              const tx = await provider.broadcastTransaction(request.params[0]);
+              return tx.hash;
+            }
+          }
+        case 'eth_getTransactionCount':
+          {
+            const address = ethers.getAddress(request.params[0]);
+            const tag = request.params[1];
+
+            // TODO: Maybe we should fetch this data from the relayer or from the reader
+            // but for now we keep it simple and just use the provider
+
+            const count = await provider.getTransactionCount(address, tag);
+            return toHexString(BigInt(count));
+          }
+        case 'eth_blockNumber':
+          {
+            return await provider.getBlockNumber();
+          }
+        case 'eth_getBlockByNumber':
+          {
+            return await provider.getBlock(request.params[0] /* , jsonRpcRequest.params[1] */);
+          }
+        case 'eth_getBlockByHash':
+          {
+            return await provider.getBlock(request.params[0] /* , jsonRpcRequest.params[1] */);
+          }
+        case 'eth_getTransactionByHash':
+          {
+            return await provider.getTransaction(request.params[0]);
+          }
+        case 'eth_call':
+          {
+            const [transactionObject, blockTag] = request.params;
+            return await provider.call(_extends({}, transactionObject, {
+              blockTag
+            }));
+          }
+        case 'eth_getCode':
+          {
+            const [contractAddress, blockTag] = request.params;
+            return await provider.getCode(contractAddress, blockTag);
+          }
+        case 'eth_estimateGas':
+          {
+            const [transactionObject] = request.params;
+            return await provider.estimateGas(transactionObject);
+          }
+        case 'eth_gasPrice':
+          {
+            const feeData = await provider.getFeeData();
+            return feeData.gasPrice === null ? null : toHexString(feeData.gasPrice);
+          }
+        case 'wallet_switchEthereumChain':
+          {
+            const [switchParams] = request.params;
+            if (!switchParams.chainId || switchParams.chainId.length === 0) {
+              throw new Error('invalid chainId');
+            }
+            const chainId = BigInt(switchParams.chainId);
+            this.setDefaultChainId(Number(chainId));
+            return null; // success
+          }
+
+        // smart wallet method
+        case 'sequence_getWalletContext':
+          {
+            return account.contexts;
+          }
+
+        // smart wallet method
+        case 'sequence_getWalletConfig':
+          {
+            const [chainId] = request.params;
+            if (chainId) {
+              return [(await account.status(chainId)).onChain.config];
+            } else {
+              return await Promise.all(account.networks.map(async function (network) {
+                const status = await account.status(network.chainId);
+                return status.onChain.config;
+              }));
+            }
+          }
+
+        // smart wallet method
+        case 'sequence_getWalletState':
+          {
+            const [chainId] = request.params;
+            // TODO: Add getWalletState to the Signer interface
+            if (chainId) {
+              return [getLegacyWalletState(chainId, await account.status(chainId))];
+            } else {
+              return await Promise.all(account.networks.map(async function (network) {
+                const status = await account.status(network.chainId);
+                return getLegacyWalletState(network.chainId, status);
+              }));
+            }
+          }
+
+        // smart wallet method
+        case 'sequence_getNetworks':
+          {
+            // NOTE: must ensure that the response result below returns clean serialized data, which is to omit
+            // the provider and relayer objects and only return the urls so can be reinstantiated on dapp side.
+            // This is handled by this.getNetworks() but noted here for future readers.
+            return await this.getNetworks(true);
+          }
+        case 'sequence_isSequence':
+          {
+            return true;
+          }
+
+        // smart wallet method
+        case 'sequence_updateConfig':
+          {
+            throw new Error('sequence_updateConfig method is not allowed from a dapp');
+            // NOTE: method is disabled as we don't need a dapp to request to update a config.
+            // However, if we ever want this, we can enable it but must also use the prompter
+            // for confirmation.
+            //
+            // const [newConfig] = request.params
+            // return await signer.updateConfig(newConfig)
+          }
+
+        // smart wallet method
+        case 'sequence_publishConfig':
+          {
+            throw new Error('sequence_publishConfig method is not allowed from a dapp');
+          }
+
+        // relayer method
+        case 'sequence_gasRefundOptions':
+          {
+            // TODO
+            break;
+          }
+
+        // relayer method
+        case 'sequence_getNonce':
+          {
+            // TODO
+            break;
+          }
+
+        // relayer method
+        case 'sequence_relay':
+          {
+            // TODO
+            break;
+          }
+
+        // set default network of wallet
+        case 'sequence_setDefaultNetwork':
+          {
+            const [defaultChainId] = request.params;
+            if (!defaultChainId) {
+              throw new Error('invalid request, method argument defaultChainId cannot be empty');
+            }
+            this.setDefaultChainId(defaultChainId);
+            return await this.getNetworks(true);
+          }
+        default:
+          {
+            if (!jsonRpcProvider) {
+              throw new Error(`Account provider doesn't support send method`);
+            }
+
+            // NOTE: provider here will be chain-bound if chainId is provided
+            return await jsonRpcProvider.send(request.method, request.params);
+          }
+      }
+    } catch (err) {
+      logger.error(err);
+      throw {
+        message: err == null ? void 0 : err.message,
+        code: 4001
+      };
+    }
   }
   on(event, fn) {
     this.events.on(event, fn);
@@ -2861,7 +2858,7 @@ class WalletRequestHandler {
     this.events.emit('disconnect', undefined, origin);
   }
   notifyChainChanged(chainId, origin) {
-    this.events.emit('chainChanged', ethers.utils.hexValue(chainId), origin);
+    this.events.emit('chainChanged', ethers.toQuantity(chainId), origin);
   }
   async notifyNetworks(networks) {
     const n = networks || (await this.getNetworks(true));
@@ -2869,7 +2866,7 @@ class WalletRequestHandler {
     if (n.length > 0) {
       const defaultNetwork = n.find(network => network.chainId === this.defaultChainId());
       if (defaultNetwork) {
-        this.events.emit('chainChanged', ethers.utils.hexValue(defaultNetwork.chainId));
+        this.events.emit('chainChanged', ethers.toQuantity(defaultNetwork.chainId));
       }
     } else {
       this.events.emit('chainChanged', '0x0');
@@ -2938,6 +2935,19 @@ function getLegacyWalletState(chainId, status) {
 }
 const permittedJsonRpcMethods = ['net_version', 'eth_chainId', 'eth_getBalance', 'eth_getTransactionCount', 'eth_blockNumber', 'eth_getBlockByNumber', 'eth_getBlockByHash', 'eth_getTransactionByHash', 'eth_getCode', 'eth_estimateGas', 'eth_gasPrice', 'sequence_getWalletContext', 'sequence_getNetworks', 'sequence_setDefaultNetwork'];
 
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+
 class SequenceSigner {
   get utils() {
     return this.provider.utils;
@@ -2946,7 +2956,6 @@ class SequenceSigner {
     this.client = client;
     this.provider = provider;
     this.singleNetworkSigners = {};
-    this._isSigner = true;
     this._isSequenceSigner = true;
   }
   async getAddress() {
@@ -3016,12 +3025,17 @@ class SequenceSigner {
     });
     const provider = this.getProvider(chainId);
     try {
-      return await ethers.utils.poll(async function () {
-        const tx = await provider.getTransaction(txHash);
-        return tx ? provider._wrapTransaction(tx, txHash) : undefined;
-      }, {
-        onceBlock: provider
+      const result = await new Promise(resolve => {
+        const check = async function check() {
+          const tx = await provider.getTransaction(txHash);
+          if (tx !== null) {
+            return resolve(tx);
+          }
+          await provider.once('block', check);
+        };
+        check();
       });
+      return result;
     } catch (err) {
       err.transactionHash = txHash;
       throw err;
@@ -3043,15 +3057,12 @@ class SequenceSigner {
   async estimateGas(transaction, optionals) {
     return this.getProvider(optionals == null ? void 0 : optionals.chainId).estimateGas(transaction);
   }
-  async call(transaction, blockTag, optionals) {
-    return this.getProvider(optionals == null ? void 0 : optionals.chainId).call(transaction, blockTag);
+  async call(transaction, optionals) {
+    return this.getProvider(optionals == null ? void 0 : optionals.chainId).call(transaction);
   }
   getChainId() {
     return Promise.resolve(this.client.getChainId());
   }
-  async getGasPrice(optionals) {
-    return this.getProvider(optionals == null ? void 0 : optionals.chainId).getGasPrice();
-  }
   async getFeeData(optionals) {
     return this.getProvider(optionals == null ? void 0 : optionals.chainId).getFeeData();
   }
@@ -3059,7 +3070,7 @@ class SequenceSigner {
     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`.
+    // but ethers.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) {
@@ -3070,6 +3081,12 @@ class SequenceSigner {
   _checkProvider(_operation) {
     // We always have a provider, so this is a noop
   }
+  getNonce(_blockTag) {
+    throw new Error('SequenceSigner does not support getNonce');
+  }
+  populateCall(_transaction) {
+    throw new Error('SequenceSigner does not support populateCall');
+  }
   populateTransaction(_transaction) {
     throw new Error('SequenceSigner does not support populateTransaction');
   }
@@ -3207,31 +3224,43 @@ class WalletUtils {
   // recoverAddress()
 }
 
-class SequenceProvider extends ethers.providers.BaseProvider {
-  constructor(client, providerFor, networks = allNetworks) {
+const _excluded = ["method"];
+const EIP1193EventTypes = ['connect', 'disconnect', 'chainChanged', 'accountsChanged'];
+class SequenceProvider extends ethers.AbstractProvider {
+  constructor(client, providerFor, networks = allNetworks, options) {
     // We support a lot of networks
     // but we start with the default one
-    super(client.getChainId());
+    super(client.getChainId(), options);
 
     // Emit events as defined by EIP-1193
     this.client = client;
     this.providerFor = providerFor;
     this.networks = networks;
+    this.options = options;
     this.singleNetworkProviders = {};
     this._isSequenceProvider = true;
     this.utils = void 0;
     this.signer = void 0;
+    this.eip1193EventListeners = new Map();
     client.onConnect(details => {
-      this.emit('connect', details);
+      var _this$eip1193EventLis;
+      //this.emit('connect', details)
+      (_this$eip1193EventLis = this.eip1193EventListeners.get('connect')) == null || _this$eip1193EventLis.forEach(listener => listener(details));
     });
     client.onDisconnect(error => {
-      this.emit('disconnect', error);
+      var _this$eip1193EventLis2;
+      //this.emit('disconnect', error)
+      (_this$eip1193EventLis2 = this.eip1193EventListeners.get('disconnect')) == null || _this$eip1193EventLis2.forEach(listener => listener(error));
     });
     client.onDefaultChainIdChanged(chainId => {
-      this.emit('chainChanged', chainId);
+      var _this$eip1193EventLis3;
+      //this.emit('chainChanged', chainId)
+      (_this$eip1193EventLis3 = this.eip1193EventListeners.get('chainChanged')) == null || _this$eip1193EventLis3.forEach(listener => listener(chainId));
     });
     client.onAccountsChanged(accounts => {
-      this.emit('accountsChanged', accounts);
+      var _this$eip1193EventLis4;
+      //this.emit('accountsChanged', accounts)
+      (_this$eip1193EventLis4 = this.eip1193EventListeners.get('accountsChanged')) == null || _this$eip1193EventLis4.forEach(listener => listener(accounts));
     });
 
     // NOTICE: We don't emit 'open' and 'close' events
@@ -3248,6 +3277,29 @@ class SequenceProvider extends ethers.providers.BaseProvider {
     // Create a utils instance
     this.utils = new WalletUtils(this.signer);
   }
+  async on(event, listener) {
+    if (EIP1193EventTypes.includes(event)) {
+      const listeners = this.eip1193EventListeners.get(event) || new Set();
+      listeners.add(listener);
+      this.eip1193EventListeners.set(event, listeners);
+      return this;
+    }
+    return super.on(event, listener);
+  }
+  async off(event, listener) {
+    if (EIP1193EventTypes.includes(event)) {
+      const listeners = this.eip1193EventListeners.get(event);
+      if (listeners) {
+        if (listener) {
+          listeners.delete(listener);
+        } else {
+          listeners.clear();
+        }
+      }
+      return this;
+    }
+    return super.off(event, listener);
+  }
   getSigner(chainId) {
     return this.signer.getSigner(chainId);
   }
@@ -3340,7 +3392,7 @@ class SequenceProvider extends ethers.providers.BaseProvider {
     }
     const useChainId = this.toChainId(chainId);
     if (!this.singleNetworkProviders[useChainId]) {
-      this.singleNetworkProviders[useChainId] = new SingleNetworkSequenceProvider(this.client, this.providerFor, useChainId);
+      this.singleNetworkProviders[useChainId] = new SingleNetworkSequenceProvider(this.client, this.providerFor, useChainId, this.options);
     }
     return this.singleNetworkProviders[useChainId];
   }
@@ -3360,11 +3412,26 @@ class SequenceProvider extends ethers.providers.BaseProvider {
     }
     return provider;
   }
+  async _perform(req) {
+    var _provider$getRpcReque;
+    const {
+        method
+      } = req,
+      args = _objectWithoutPropertiesLoose(req, _excluded);
+    const provider = await this._getSubprovider();
+    const prepared = (_provider$getRpcReque = provider.getRpcRequest(req)) != null ? _provider$getRpcReque : {
+      method,
+      args: Object.values(args)
+    };
+    if (!prepared) {
+      throw new Error(`Unsupported method ${req.method}`);
+    }
+    return provider.send(prepared.method, prepared.args);
+  }
   async perform(method, params) {
-    var _provider$prepareRequ;
     // First we check if the method should be handled by the client
     if (method === 'eth_chainId') {
-      return ethers.utils.hexValue(await this.useChainId());
+      return ethers.toQuantity(await this.useChainId());
     }
     if (method === 'eth_accounts') {
       return [this.client.getAddress()];
@@ -3384,17 +3451,15 @@ class SequenceProvider extends ethers.providers.BaseProvider {
     method === 'sequence_sign' || method === 'sequence_signTypedData_v4') {
       // We pass the chainId to the client, if we don't pass one
       // the client will use its own default chainId
-      return this.client.send({
+      return this.client.request({
         method,
-        params
-      }, this.getChainId());
+        params,
+        chainId: this.getChainId()
+      });
     }
-
-    // Forward call to the corresponding provider
-    // we use the provided chainId, or the default one provided by the client
-    const provider = await this._getSubprovider();
-    const prepared = (_provider$prepareRequ = provider.prepareRequest(method, params)) != null ? _provider$prepareRequ : [method, params];
-    return provider.send(prepared[0], prepared[1]);
+    return this._perform(_extends({
+      method
+    }, params));
   }
   send(method, params) {
     return this.perform(method, params);
@@ -3402,14 +3467,18 @@ class SequenceProvider extends ethers.providers.BaseProvider {
   request(request) {
     return this.perform(request.method, request.params);
   }
-  async detectNetwork() {
+  async _detectNetwork() {
     const chainId = this.client.getChainId();
-    const network = findNetworkConfig(this.networks, chainId);
-    if (!network) {
+    const found = findNetworkConfig(this.networks, chainId);
+    if (!found) {
       throw new Error(`Unknown network ${chainId}`);
     }
+    const network = new ethers.Network(found.name, found.chainId);
     return network;
   }
+  async detectNetwork() {
+    return this._detectNetwork();
+  }
 
   // Override most of the methods, so we add support for an optional chainId
   // argument, which is used to select the provider to use.
@@ -3426,9 +3495,9 @@ class SequenceProvider extends ethers.providers.BaseProvider {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
     return provider.getBlockNumber();
   }
-  async getGasPrice(optionals) {
+  async getFeeData(optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
-    return provider.getGasPrice();
+    return provider.getFeeData();
   }
   async getBalance(addressOrName, blockTag, optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
@@ -3442,21 +3511,21 @@ class SequenceProvider extends ethers.providers.BaseProvider {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
     return provider.getCode(addressOrName, blockTag);
   }
-  async getStorageAt(addressOrName, position, blockTag, optionals) {
+  async getStorage(addressOrName, position, blockTag, optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
-    return provider.getStorageAt(addressOrName, position, blockTag);
+    return provider.getStorage(addressOrName, position, blockTag);
   }
-  async call(transaction, blockTag, optionals) {
+  async call(transaction, optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
-    return provider.call(transaction, blockTag);
+    return provider.call(transaction);
   }
   async estimateGas(transaction, optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
     return provider.estimateGas(transaction);
   }
-  async getBlock(blockHashOrBlockTag, optionals) {
+  async getBlock(blockHashOrBlockTag, prefetchTxs, optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
-    return provider.getBlock(blockHashOrBlockTag);
+    return provider.getBlock(blockHashOrBlockTag, prefetchTxs);
   }
   async getTransaction(transactionHash, optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
@@ -3483,7 +3552,7 @@ class SequenceProvider extends ethers.providers.BaseProvider {
     return provider.getResolver(name);
   }
   async resolveName(name) {
-    if (ethers.utils.isAddress(await name)) {
+    if (ethers.isAddress(name)) {
       return name;
     }
     if (!(await this.supportsENS())) {
@@ -3516,7 +3585,7 @@ SequenceProvider.is = provider => {
 };
 function normalizeChainId(chainId) {
   if (typeof chainId === 'object') return normalizeChainId(chainId.chainId);
-  return ethers.BigNumber.from(chainId).toNumber();
+  return Number(chainId);
 }
 
 /**
@@ -3529,8 +3598,8 @@ function normalizeChainId(chainId) {
  *  NOTICE: These networks won't support ENS unless they are the mainnet.
  */
 class SingleNetworkSequenceProvider extends SequenceProvider {
-  constructor(client, providerFor, chainId) {
-    super(client, providerFor);
+  constructor(client, providerFor, chainId, options) {
+    super(client, providerFor, undefined, options);
     this.chainId = chainId;
     this._isSingleNetworkSequenceProvider = true;
   }
@@ -3549,11 +3618,11 @@ class SingleNetworkSequenceProvider extends SequenceProvider {
   }
   async getNetwork() {
     const networks = await this.client.getNetworks();
-    const res = findNetworkConfig(networks, this.chainId);
-    if (!res) {
+    const found = findNetworkConfig(networks, this.chainId);
+    if (!found) {
       throw new Error(`Unsupported network ${this.chainId}`);
     }
-    return res;
+    return new ethers.Network(found.name, found.chainId);
   }
 
   /**
@@ -3616,55 +3685,6 @@ const setupAnalytics = (projectAccessKey, server) => {
   });
 };
 
-var packageJson = {
-	name: "@0xsequence/provider",
-	version: "1.10.15",
-	description: "provider sub-package for Sequence",
-	repository: "https://github.com/0xsequence/sequence.js/tree/master/packages/provider",
-	source: "src/index.ts",
-	main: "dist/0xsequence-provider.cjs.js",
-	module: "dist/0xsequence-provider.esm.js",
-	author: "Horizon Blockchain Games",
-	license: "Apache-2.0",
-	scripts: {
-		test: "pnpm test:concurrently 'pnpm test:run'",
-		"test:run": "pnpm test:file tests/**/*.spec.ts",
-		"test:file": "NODE_OPTIONS='--import tsx' mocha --timeout 30000",
-		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"
-	},
-	dependencies: {
-		"@0xsequence/abi": "workspace:*",
-		"@0xsequence/account": "workspace:*",
-		"@0xsequence/auth": "workspace:*",
-		"@0xsequence/core": "workspace:*",
-		"@0xsequence/migration": "workspace:*",
-		"@0xsequence/network": "workspace:*",
-		"@0xsequence/relayer": "workspace:*",
-		"@0xsequence/utils": "workspace:*",
-		"@0xsequence/wallet": "workspace:*",
-		"@databeat/tracker": "^0.9.1",
-		eventemitter2: "^6.4.5",
-		"webextension-polyfill": "^0.10.0"
-	},
-	peerDependencies: {
-		ethers: ">=5.5 < 6"
-	},
-	devDependencies: {
-		"@types/webextension-polyfill": "^0.10.0",
-		ethers: "^5.7.2",
-		hardhat: "^2.20.1"
-	},
-	files: [
-		"src",
-		"dist"
-	]
-};
-
 /**
  *  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)
@@ -3780,7 +3800,7 @@ class SequenceClient {
     });
     this.transport.on('connect', response => {
       var _this$callbacks$conne;
-      const chainIdHex = ethers.utils.hexValue(this.getChainId());
+      const chainIdHex = ethers.toQuantity(this.getChainId());
       (_this$callbacks$conne = this.callbacks.connect) == null || _this$callbacks$conne.forEach(cb => cb(_extends({}, response, {
         // Ignore the full connect response
         // use the chainId defined locally
@@ -3816,7 +3836,7 @@ class SequenceClient {
     // instead we handle it locally, so we listen for changes in the store
     this.defaultChainId.onDefaultChainIdChanged(chainId => {
       var _this$callbacks$chain2;
-      const chainIdHex = ethers.utils.hexValue(chainId);
+      const chainIdHex = ethers.toQuantity(chainId);
       (_this$callbacks$chain2 = this.callbacks.chainChanged) == null || _this$callbacks$chain2.forEach(cb => cb(chainIdHex));
     });
     if (options != null && options.projectAccessKey) {
@@ -3929,7 +3949,7 @@ class SequenceClient {
       type: 'connect',
       options: _extends({}, options, {
         networkId: this.getChainId(),
-        clientVersion: packageJson.version
+        clientVersion: VERSION
       })
     });
     const connectDetails = await this.transport.waitUntilConnected().catch(error => {
@@ -3949,7 +3969,7 @@ class SequenceClient {
     // 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();
+      connectDetails.chainId = BigInt(connectDetails.chainId).toString();
     }
     if (connectDetails.connected) {
       var _connectDetails$sessi;
@@ -3975,33 +3995,17 @@ class SequenceClient {
 
   // Higher level API
 
-  // Working with sendAsync is less idiomatic
-  // but transport uses it instead of send, so we wrap it
-  send(request, chainId) {
+  async request(request) {
     // Internally when sending requests we use `legacy_sign`
     // to avoid the default EIP6492 behavior overriding an explicit
     // "legacy sign" request, so we map the method here.
     request.method = this.mapSignMethod(request.method);
-    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());
-    });
+    return this.transport.request(request);
   }
   async getNetworks(pull) {
     const connectedSession = this.session.connectedSession();
     if (pull) {
-      connectedSession.networks = await this.send({
+      connectedSession.networks = await this.request({
         method: 'sequence_getNetworks'
       });
       this.session.setSession(connectedSession);
@@ -4057,15 +4061,14 @@ class SequenceClient {
         chainId: `${(options == null ? void 0 : options.chainId) || this.getChainId()}`
       }
     });
-
-    // Serialize a BytesLike or string message into a hex string before sending
-    message = ethers.utils.hexlify(messageToBytes(message));
+    message = ethers.hexlify(messageToBytes(message));
 
     // Address is ignored by the wallet webapp
-    return this.send({
+    return this.request({
       method,
-      params: [message, this.getAddress()]
-    }, options == null ? void 0 : options.chainId);
+      params: [message, this.getAddress()],
+      chainId: options == null ? void 0 : options.chainId
+    });
   }
   async signTypedData(typedData, options) {
     var _this$analytics5;
@@ -4073,7 +4076,7 @@ class SequenceClient {
 
     // 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);
+    const encoded = ethers.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
@@ -4086,10 +4089,11 @@ class SequenceClient {
         chainId: `${(options == null ? void 0 : options.chainId) || this.getChainId()}`
       }
     });
-    return this.send({
+    return this.request({
       method,
-      params: [this.getAddress(), encoded]
-    }, (options == null ? void 0 : options.chainId) || typedData.domain.chainId && ethers.BigNumber.from(typedData.domain.chainId).toNumber() || this.getChainId());
+      params: [this.getAddress(), encoded],
+      chainId: (options == null ? void 0 : options.chainId) || typedData.domain.chainId && Number(typedData.domain.chainId) || this.getChainId()
+    });
   }
   async sendTransaction(tx, options) {
     var _this$analytics6;
@@ -4101,22 +4105,24 @@ class SequenceClient {
         chainId: `${(options == null ? void 0 : options.chainId) || this.getChainId()}`
       }
     });
-    return this.send({
+    return this.request({
       method: 'eth_sendTransaction',
-      params: [extendedTxs]
-    }, options == null ? void 0 : options.chainId);
+      params: [extendedTxs],
+      chainId: options == null ? void 0 : options.chainId
+    });
   }
   async getWalletContext() {
-    return this.send({
+    return this.request({
       method: 'sequence_getWalletContext'
     });
   }
   async getOnchainWalletConfig(options) {
     // NOTICE: sequence_getWalletConfig sends the chainId as a param
-    const res = await this.send({
+    const res = await this.request({
       method: 'sequence_getWalletConfig',
-      params: [(options == null ? void 0 : options.chainId) || this.getChainId()]
-    }, options == null ? void 0 : options.chainId);
+      params: [(options == null ? void 0 : options.chainId) || this.getChainId()],
+      chainId: options == null ? void 0 : options.chainId
+    });
     return Array.isArray(res) ? res[0] : res;
   }
 
@@ -4195,9 +4201,11 @@ const initWallet = (projectAccessKey, partialConfig) => {
       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);
+      rpcProviders[chainId] = new JsonRpcProvider(rpcUrl, {
+        middlewares: [loggingProviderMiddleware, exceptionProviderMiddleware, new CachedProvider()]
+      }, {
+        cacheTimeout: -1
+      });
     }
     return rpcProviders[chainId];
   };