@0xsequence/provider 0.0.0-20240408185635 → 0.0.0-20240428001038

package/dist/0xsequence-provider.cjs.dev.js

@@ -2,15 +2,53 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var abi = require('@0xsequence/abi');
+var core = require('@0xsequence/core');
+var ethers = require('ethers');
 var eventemitter2 = require('eventemitter2');
 var utils = require('@0xsequence/utils');
-var ethers = require('ethers');
-var core = require('@0xsequence/core');
 var network = require('@0xsequence/network');
 var auth = require('@0xsequence/auth');
-var abi = require('@0xsequence/abi');
 var tracker = require('@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.ethers.utils.keccak256(ethers.ethers.utils.toUtf8Bytes(signature)).slice(0, 10), signature]));
+function validateTransactionRequest(wallet, transaction) {
+  const transactions = core.commons.transaction.fromTransactionish(wallet, transaction);
+  const unwound = core.commons.transaction.unwind(wallet, transactions);
+  unwound.forEach(transaction => validateTransaction(wallet, transaction));
+}
+function validateTransaction(wallet, transaction) {
+  if (transaction.to.toLowerCase() === wallet.toLowerCase()) {
+    if (transaction.data) {
+      const data = ethers.ethers.utils.arrayify(transaction.data);
+      if (data.length >= 4 && !isCreateContractCall(data)) {
+        throw new Error('self calls are forbidden');
+      }
+    }
+  }
+  if (transaction.delegateCall) {
+    throw new Error('delegate calls are forbidden');
+  }
+  if (transaction.data) {
+    const data = ethers.ethers.utils.hexlify(transaction.data);
+    const selector = data.slice(0, 10);
+    const signature = PROHIBITED_FUNCTIONS.get(selector);
+    if (signature) {
+      const name = signature.slice(0, signature.indexOf('('));
+      throw new Error(`${name} calls are forbidden`);
+    }
+  }
+}
+function isCreateContractCall(data) {
+  const walletInterface = new ethers.ethers.utils.Interface(abi.walletContracts.mainModule.abi);
+  try {
+    walletInterface.decodeFunctionData('createContract', data);
+    return true;
+  } catch (_unused) {
+    return false;
+  }
+}
+
 function _extends() {
   _extends = Object.assign ? Object.assign.bind() : function (target) {
     for (var i = 1; i < arguments.length; i++) {
@@ -30,8 +68,6 @@ 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.
@@ -89,6 +125,8 @@ 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;
@@ -109,6 +147,42 @@ 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) => {
@@ -218,36 +292,6 @@ 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: core.VERSION
-    });
-    return response.data;
-  }
-
   // handleMessage will handle message received from the remote wallet
   handleMessage(message) {
     var _this2 = this;
@@ -269,8 +313,7 @@ class BaseProviderTransport {
         data: {
           sessionId: this._sessionId,
           nonce: nonce
-        },
-        clientVersion: core.VERSION
+        }
       });
     }
     if (this._init !== InitState.OK) {
@@ -355,7 +398,7 @@ class BaseProviderTransport {
       };
       if (message.data && message.data.length > 0) {
         this.accountsChangedPayload = {
-          accounts: [ethers.ethers.getAddress(message.data[0])],
+          accounts: [ethers.ethers.utils.getAddress(message.data[0])],
           origin: message.origin
         };
         this.events.emit('accountsChanged', this.accountsChangedPayload.accounts, this.accountsChangedPayload.origin);
@@ -460,7 +503,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.ethers.toUtf8String(bytes);
+    const stringified = ethers.ethers.utils.toUtf8String(bytes);
     return DCL_REGEX.test(stringified);
   } catch (_unused) {
     return false;
@@ -470,7 +513,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.ethers.Interface(ZeroXV3EIP1271OrderWithHashAbi);
+  const abi = new ethers.ethers.utils.Interface(ZeroXV3EIP1271OrderWithHashAbi);
   try {
     abi.decodeFunctionData('OrderWithHash', bytes);
     return true;
@@ -552,19 +595,19 @@ const ZeroXV3EIP1271OrderWithHashAbi = [{
   type: 'function'
 }];
 
-const eip191prefix = ethers.ethers.toUtf8Bytes('\x19Ethereum Signed Message:\n');
+const eip191prefix = ethers.ethers.utils.toUtf8Bytes('\x19Ethereum Signed Message:\n');
 const messageToBytes = message => {
-  if (ethers.ethers.isBytesLike(message)) {
-    return ethers.ethers.getBytes(message);
+  if (ethers.ethers.utils.isBytesLike(message)) {
+    return ethers.ethers.utils.arrayify(message);
   }
-  return ethers.ethers.toUtf8Bytes(message);
+  return ethers.ethers.utils.toUtf8Bytes(message);
 };
 const prefixEIP191Message = message => {
   const messageBytes = messageToBytes(message);
   if (messageIsExemptFromEIP191Prefix(messageBytes)) {
     return messageBytes;
   } else {
-    return ethers.ethers.getBytes(ethers.ethers.concat([eip191prefix, ethers.ethers.toUtf8Bytes(String(messageBytes.length)), messageBytes]));
+    return ethers.ethers.utils.concat([eip191prefix, ethers.ethers.utils.toUtf8Bytes(String(messageBytes.length)), messageBytes]);
   }
 };
 const trimEIP191Prefix = prefixedMessage => {
@@ -589,9 +632,9 @@ const trimEIP191Prefix = prefixedMessage => {
   let prefixCharLenght;
   let prefixAsNumber;
   try {
-    prefixAsNumber = Number(ethers.ethers.toUtf8String(ethereumSignedMessagePartSlicedArray.slice(0, maxPrefixCharLength)));
+    prefixAsNumber = Number(ethers.ethers.utils.toUtf8String(ethereumSignedMessagePartSlicedArray.slice(0, maxPrefixCharLength)));
   } catch (_unused) {
-    prefixAsNumber = Number(ethers.ethers.hexlify(ethereumSignedMessagePartSlicedArray.slice(0, maxPrefixCharLength)));
+    prefixAsNumber = Number(ethers.ethers.utils.hexlify(ethereumSignedMessagePartSlicedArray.slice(0, maxPrefixCharLength)));
   }
   if (prefixAsNumber > ethereumSignedMessagePartSlicedArray.length || !Number.isInteger(prefixAsNumber)) {
     prefixCharLenght = maxPrefixCharLength - 1;
@@ -706,9 +749,9 @@ function useBestStore() {
 async function resolveArrayProperties(object) {
   if (Array.isArray(object)) {
     // T must include array type
-    return Promise.all(object.map(o => ethers.ethers.resolveProperties(o)));
+    return Promise.all(object.map(o => ethers.ethers.utils.resolveProperties(o)));
   }
-  return ethers.ethers.resolveProperties(object);
+  return ethers.ethers.utils.resolveProperties(object);
 }
 
 const TRANSPORT_SESSION_LS_KEY = '@sequence.transportSession';
@@ -725,6 +768,9 @@ 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;
 
@@ -960,7 +1006,7 @@ class BaseWalletTransport {
       if (!networks || networks.length === 0) {
         this.notifyChainChanged('0x0');
       } else {
-        this.notifyChainChanged(ethers.ethers.toQuantity(networks.find(network => network.isDefaultChain).chainId));
+        this.notifyChainChanged(ethers.ethers.utils.hexValue(networks.find(network => network.isDefaultChain).chainId));
       }
     });
     this.walletRequestHandler.on('chainChanged', (chainIdHex, origin) => {
@@ -984,9 +1030,6 @@ class BaseWalletTransport {
   unregister() {
     throw new Error('abstract method');
   }
-  request(request) {
-    throw new Error('abstract method');
-  }
   sendMessage(message) {
     throw new Error('abstract method');
   }
@@ -1005,8 +1048,7 @@ class BaseWalletTransport {
         sessionId,
         session,
         error
-      },
-      clientVersion: core.VERSION
+      }
     });
   }
   notifyClose(error) {
@@ -1015,16 +1057,14 @@ class BaseWalletTransport {
       type: EventType.CLOSE,
       data: error ? {
         error
-      } : null,
-      clientVersion: core.VERSION
+      } : null
     });
   }
   notifyConnect(connectDetails) {
     this.sendMessage({
       idx: -1,
       type: EventType.CONNECT,
-      data: connectDetails,
-      clientVersion: core.VERSION
+      data: connectDetails
     });
   }
   notifyDisconnect(error, origin) {
@@ -1034,8 +1074,7 @@ class BaseWalletTransport {
       data: error ? {
         error
       } : null,
-      origin,
-      clientVersion: core.VERSION
+      origin
     });
   }
   notifyAccountsChanged(accounts, origin) {
@@ -1043,8 +1082,7 @@ class BaseWalletTransport {
       idx: -1,
       type: EventType.ACCOUNTS_CHANGED,
       data: accounts,
-      origin,
-      clientVersion: core.VERSION
+      origin
     });
   }
   notifyChainChanged(chainIdHex, origin) {
@@ -1052,24 +1090,21 @@ class BaseWalletTransport {
       idx: -1,
       type: EventType.CHAIN_CHANGED,
       data: chainIdHex,
-      origin,
-      clientVersion: core.VERSION
+      origin
     });
   }
   notifyNetworks(networks) {
     this.sendMessage({
       idx: -1,
       type: EventType.NETWORKS,
-      data: networks,
-      clientVersion: core.VERSION
+      data: networks
     });
   }
   notifyWalletContext(walletContext) {
     this.sendMessage({
       idx: -1,
       type: EventType.WALLET_CONTEXT,
-      data: walletContext,
-      clientVersion: core.VERSION
+      data: walletContext
     });
   }
   isValidInitAck(message) {
@@ -1140,8 +1175,7 @@ class BaseWalletTransport {
         type: EventType.INIT,
         data: {
           nonce: this._initNonce
-        },
-        clientVersion: core.VERSION
+        }
       });
       this._init = InitState.SENT_NONCE;
 
@@ -1240,8 +1274,7 @@ class ProxyMessageProvider extends BaseProviderTransport {
             intent,
             networkId,
             sessionId
-          },
-          clientVersion: core.VERSION
+          }
         });
       }
     };
@@ -1259,8 +1292,7 @@ class ProxyMessageProvider extends BaseProviderTransport {
     this.sendMessage({
       idx: -1,
       type: EventType.CLOSE,
-      data: null,
-      clientVersion: core.VERSION
+      data: null
     });
     this.close();
   }
@@ -1848,13 +1880,7 @@ class WindowMessageHandler extends BaseWalletTransport {
       // Wallet always expects json-rpc request messages from a dapp
       let request;
       try {
-        request = JSON.parse(event.data, (key, value) => {
-          // BigNumber compatibility with older versions of sequence.js
-          if (isBigNumberSerialized(value)) {
-            return BigInt(value.hex);
-          }
-          return value;
-        });
+        request = JSON.parse(event.data);
       } catch (err) {
         // event is not a ProviderMessage JSON object, skip
         return;
@@ -1893,6 +1919,7 @@ 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);
@@ -1976,9 +2003,6 @@ class WindowMessageHandler extends BaseWalletTransport {
     }
   }
 }
-const isBigNumberSerialized = value => {
-  return typeof value === 'object' && 'type' in value && value.type === 'BigNumber' && 'hex' in value && ethers.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') && (
@@ -2029,6 +2053,13 @@ 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);
@@ -2125,12 +2156,6 @@ 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');
@@ -2163,37 +2188,9 @@ function fromExtended(transaction) {
   return [transaction, ...(transaction.auxiliary || [])];
 }
 
-function validateTransactionRequest(wallet, transaction) {
-  const transactions = core.commons.transaction.fromTransactionish(wallet, transaction);
-  const unwound = core.commons.transaction.unwind(wallet, transactions);
-  unwound.forEach(transaction => validateTransaction(wallet, transaction));
-}
-function validateTransaction(wallet, transaction) {
-  if (transaction.to.toLowerCase() === wallet.toLowerCase()) {
-    if (transaction.data) {
-      const data = ethers.ethers.getBytes(transaction.data);
-      if (data.length >= 4 && !isCreateContractCall(data)) {
-        throw new Error('self calls are forbidden');
-      }
-    }
-  }
-  if (transaction.delegateCall) {
-    throw new Error('delegate calls are forbidden');
-  }
-}
-function isCreateContractCall(data) {
-  const walletInterface = new ethers.ethers.Interface(abi.walletContracts.mainModule.abi);
-  try {
-    walletInterface.decodeFunctionData('createContract', data);
-    return true;
-  } catch (_unused) {
-    return false;
-  }
-}
-
 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
@@ -2226,6 +2223,417 @@ 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.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.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 (core.commons.transaction.isSignedTransactionBundle(request.params[0])) {
+                const txChainId = ethers.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.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.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.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) {
+        utils.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;
@@ -2237,7 +2645,7 @@ class WalletRequestHandler {
       }
       return _this.account;
     };
-    this.account = account;
+    this.account = _account;
     this.prompter = prompter;
     this.networks = networks;
   }
@@ -2321,7 +2729,7 @@ class WalletRequestHandler {
     const chainId = network.findSupportedNetwork(networkId).chainId;
     const connectDetails = {
       connected: true,
-      chainId: ethers.ethers.toQuantity(chainId)
+      chainId: ethers.ethers.utils.hexValue(chainId)
     };
     if (options && options.authorize) {
       // Perform ethauth eip712 request and construct the ConnectDetails response
@@ -2356,414 +2764,20 @@ 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
-  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;
-      }
-
-      // 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((_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.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 utils.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.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.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 (core.commons.transaction.isSignedTransactionBundle(request.params[0])) {
-              const txChainId = Number(BigInt(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.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 utils.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 && utils.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;
-          }
+  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?
 
-        // 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`);
-            }
+        const responseMessage = _extends({}, message, {
+          data: response
+        });
 
-            // NOTE: provider here will be chain-bound if chainId is provided
-            return await jsonRpcProvider.send(request.method, request.params);
-          }
-      }
-    } catch (err) {
-      throw {
-        message: err == null ? void 0 : err.message,
-        code: 4001
-      };
-    }
+        // 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);
+    });
   }
   on(event, fn) {
     this.events.on(event, fn);
@@ -2851,7 +2865,7 @@ class WalletRequestHandler {
     this.events.emit('disconnect', undefined, origin);
   }
   notifyChainChanged(chainId, origin) {
-    this.events.emit('chainChanged', ethers.ethers.toQuantity(chainId), origin);
+    this.events.emit('chainChanged', ethers.ethers.utils.hexValue(chainId), origin);
   }
   async notifyNetworks(networks) {
     const n = networks || (await this.getNetworks(true));
@@ -2859,7 +2873,7 @@ class WalletRequestHandler {
     if (n.length > 0) {
       const defaultNetwork = n.find(network => network.chainId === this.defaultChainId());
       if (defaultNetwork) {
-        this.events.emit('chainChanged', ethers.ethers.toQuantity(defaultNetwork.chainId));
+        this.events.emit('chainChanged', ethers.ethers.utils.hexValue(defaultNetwork.chainId));
       }
     } else {
       this.events.emit('chainChanged', '0x0');
@@ -2928,19 +2942,6 @@ 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;
@@ -2949,6 +2950,7 @@ class SequenceSigner {
     this.client = client;
     this.provider = provider;
     this.singleNetworkSigners = {};
+    this._isSigner = true;
     this._isSequenceSigner = true;
   }
   async getAddress() {
@@ -3018,19 +3020,12 @@ class SequenceSigner {
     });
     const provider = this.getProvider(chainId);
     try {
-      const result = await new Promise(resolve => {
-        let attempts = 0;
-        const check = async function check() {
-          attempts++;
-          const tx = await provider.getTransaction(txHash);
-          if (tx !== null) {
-            return resolve(tx);
-          }
-          await provider.once('block', check);
-        };
-        check();
+      return await ethers.ethers.utils.poll(async function () {
+        const tx = await provider.getTransaction(txHash);
+        return tx ? provider._wrapTransaction(tx, txHash) : undefined;
+      }, {
+        onceBlock: provider
       });
-      return result;
     } catch (err) {
       err.transactionHash = txHash;
       throw err;
@@ -3052,12 +3047,15 @@ class SequenceSigner {
   async estimateGas(transaction, optionals) {
     return this.getProvider(optionals == null ? void 0 : optionals.chainId).estimateGas(transaction);
   }
-  async call(transaction, optionals) {
-    return this.getProvider(optionals == null ? void 0 : optionals.chainId).call(transaction);
+  async call(transaction, blockTag, optionals) {
+    return this.getProvider(optionals == null ? void 0 : optionals.chainId).call(transaction, blockTag);
   }
   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();
   }
@@ -3065,7 +3063,7 @@ class SequenceSigner {
     const res = await this.provider.resolveName(name);
 
     // For some reason ethers.Signer expects this to return `string`
-    // but ethers.Provider expects this to return `string | null`.
+    // but ethers.providers.Provider expects this to return `string | null`.
     // The signer doesn't have any other source of information, so we'll
     // fail if the provider doesn't return a result.
     if (res === null) {
@@ -3076,17 +3074,6 @@ class SequenceSigner {
   _checkProvider(_operation) {
     // We always have a provider, so this is a noop
   }
-
-  // populateCall(transaction: ethers.PopulatedTransaction): Promise<ethers.PopulatedTransaction> {
-  //   return this.provider.populateCall(transaction)
-  // }
-
-  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');
   }
@@ -3224,43 +3211,31 @@ class WalletUtils {
   // recoverAddress()
 }
 
-const _excluded = ["method"];
-const EIP1193EventTypes = ['connect', 'disconnect', 'chainChanged', 'accountsChanged'];
-class SequenceProvider extends ethers.ethers.AbstractProvider {
-  constructor(client, providerFor, networks = network.allNetworks, options) {
+class SequenceProvider extends ethers.ethers.providers.BaseProvider {
+  constructor(client, providerFor, networks = network.allNetworks) {
     // We support a lot of networks
     // but we start with the default one
-    super(client.getChainId(), options);
+    super(client.getChainId());
 
     // 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 => {
-      var _this$eip1193EventLis;
-      //this.emit('connect', details)
-      (_this$eip1193EventLis = this.eip1193EventListeners.get('connect')) == null || _this$eip1193EventLis.forEach(listener => listener(details));
+      this.emit('connect', details);
     });
     client.onDisconnect(error => {
-      var _this$eip1193EventLis2;
-      //this.emit('disconnect', error)
-      (_this$eip1193EventLis2 = this.eip1193EventListeners.get('disconnect')) == null || _this$eip1193EventLis2.forEach(listener => listener(error));
+      this.emit('disconnect', error);
     });
     client.onDefaultChainIdChanged(chainId => {
-      var _this$eip1193EventLis3;
-      //this.emit('chainChanged', chainId)
-      (_this$eip1193EventLis3 = this.eip1193EventListeners.get('chainChanged')) == null || _this$eip1193EventLis3.forEach(listener => listener(chainId));
+      this.emit('chainChanged', chainId);
     });
     client.onAccountsChanged(accounts => {
-      var _this$eip1193EventLis4;
-      //this.emit('accountsChanged', accounts)
-      (_this$eip1193EventLis4 = this.eip1193EventListeners.get('accountsChanged')) == null || _this$eip1193EventLis4.forEach(listener => listener(accounts));
+      this.emit('accountsChanged', accounts);
     });
 
     // NOTICE: We don't emit 'open' and 'close' events
@@ -3277,29 +3252,6 @@ class SequenceProvider extends ethers.ethers.AbstractProvider {
     // 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);
   }
@@ -3392,7 +3344,7 @@ class SequenceProvider extends ethers.ethers.AbstractProvider {
     }
     const useChainId = this.toChainId(chainId);
     if (!this.singleNetworkProviders[useChainId]) {
-      this.singleNetworkProviders[useChainId] = new SingleNetworkSequenceProvider(this.client, this.providerFor, useChainId, this.options);
+      this.singleNetworkProviders[useChainId] = new SingleNetworkSequenceProvider(this.client, this.providerFor, useChainId);
     }
     return this.singleNetworkProviders[useChainId];
   }
@@ -3412,26 +3364,11 @@ class SequenceProvider extends ethers.ethers.AbstractProvider {
     }
     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.ethers.toQuantity(await this.useChainId());
+      return ethers.ethers.utils.hexValue(await this.useChainId());
     }
     if (method === 'eth_accounts') {
       return [this.client.getAddress()];
@@ -3451,15 +3388,17 @@ class SequenceProvider extends ethers.ethers.AbstractProvider {
     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.request({
+      return this.client.send({
         method,
-        params,
-        chainId: this.getChainId()
-      });
+        params
+      }, this.getChainId());
     }
-    return this._perform(_extends({
-      method
-    }, params));
+
+    // 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]);
   }
   send(method, params) {
     return this.perform(method, params);
@@ -3467,18 +3406,14 @@ class SequenceProvider extends ethers.ethers.AbstractProvider {
   request(request) {
     return this.perform(request.method, request.params);
   }
-  async _detectNetwork() {
+  async detectNetwork() {
     const chainId = this.client.getChainId();
-    const found = network.findNetworkConfig(this.networks, chainId);
-    if (!found) {
+    const network$1 = network.findNetworkConfig(this.networks, chainId);
+    if (!network$1) {
       throw new Error(`Unknown network ${chainId}`);
     }
-    const network$1 = new ethers.ethers.Network(found.name, found.chainId);
     return network$1;
   }
-  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.
@@ -3495,9 +3430,9 @@ class SequenceProvider extends ethers.ethers.AbstractProvider {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
     return provider.getBlockNumber();
   }
-  async getFeeData(optionals) {
+  async getGasPrice(optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
-    return await provider.getFeeData();
+    return provider.getGasPrice();
   }
   async getBalance(addressOrName, blockTag, optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
@@ -3511,21 +3446,21 @@ class SequenceProvider extends ethers.ethers.AbstractProvider {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
     return provider.getCode(addressOrName, blockTag);
   }
-  async getStorage(addressOrName, position, blockTag, optionals) {
+  async getStorageAt(addressOrName, position, blockTag, optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
-    return provider.getStorage(addressOrName, position, blockTag);
+    return provider.getStorageAt(addressOrName, position, blockTag);
   }
-  async call(transaction, optionals) {
+  async call(transaction, blockTag, optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
-    return provider.call(transaction);
+    return provider.call(transaction, blockTag);
   }
   async estimateGas(transaction, optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
     return provider.estimateGas(transaction);
   }
-  async getBlock(blockHashOrBlockTag, prefetchTxs, optionals) {
+  async getBlock(blockHashOrBlockTag, optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
-    return provider.getBlock(blockHashOrBlockTag, prefetchTxs);
+    return provider.getBlock(blockHashOrBlockTag);
   }
   async getTransaction(transactionHash, optionals) {
     const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
@@ -3552,7 +3487,7 @@ class SequenceProvider extends ethers.ethers.AbstractProvider {
     return provider.getResolver(name);
   }
   async resolveName(name) {
-    if (ethers.ethers.isAddress(await name)) {
+    if (ethers.ethers.utils.isAddress(await name)) {
       return name;
     }
     if (!(await this.supportsENS())) {
@@ -3585,7 +3520,7 @@ SequenceProvider.is = provider => {
 };
 function normalizeChainId(chainId) {
   if (typeof chainId === 'object') return normalizeChainId(chainId.chainId);
-  return Number(BigInt(chainId));
+  return ethers.ethers.BigNumber.from(chainId).toNumber();
 }
 
 /**
@@ -3598,8 +3533,8 @@ function normalizeChainId(chainId) {
  *  NOTICE: These networks won't support ENS unless they are the mainnet.
  */
 class SingleNetworkSequenceProvider extends SequenceProvider {
-  constructor(client, providerFor, chainId, options) {
-    super(client, providerFor, undefined, options);
+  constructor(client, providerFor, chainId) {
+    super(client, providerFor);
     this.chainId = chainId;
     this._isSingleNetworkSequenceProvider = true;
   }
@@ -3618,12 +3553,11 @@ class SingleNetworkSequenceProvider extends SequenceProvider {
   }
   async getNetwork() {
     const networks = await this.client.getNetworks();
-    const found = network.findNetworkConfig(networks, this.chainId);
-    if (!found) {
+    const res = network.findNetworkConfig(networks, this.chainId);
+    if (!res) {
       throw new Error(`Unsupported network ${this.chainId}`);
     }
-    const network$1 = new ethers.ethers.Network(found.name, found.chainId);
-    return network$1;
+    return res;
   }
 
   /**
@@ -3686,6 +3620,55 @@ const setupAnalytics = (projectAccessKey, server) => {
   });
 };
 
+var packageJson = {
+	name: "@0xsequence/provider",
+	version: "0.0.0-20240428001038",
+	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)
@@ -3801,7 +3784,7 @@ class SequenceClient {
     });
     this.transport.on('connect', response => {
       var _this$callbacks$conne;
-      const chainIdHex = ethers.ethers.toQuantity(this.getChainId());
+      const chainIdHex = ethers.ethers.utils.hexValue(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
@@ -3837,7 +3820,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.ethers.toQuantity(chainId);
+      const chainIdHex = ethers.ethers.utils.hexValue(chainId);
       (_this$callbacks$chain2 = this.callbacks.chainChanged) == null || _this$callbacks$chain2.forEach(cb => cb(chainIdHex));
     });
     if (options != null && options.projectAccessKey) {
@@ -3950,7 +3933,7 @@ class SequenceClient {
       type: 'connect',
       options: _extends({}, options, {
         networkId: this.getChainId(),
-        clientVersion: core.VERSION
+        clientVersion: packageJson.version
       })
     });
     const connectDetails = await this.transport.waitUntilConnected().catch(error => {
@@ -3970,7 +3953,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 = BigInt(connectDetails.chainId).toString();
+      connectDetails.chainId = ethers.ethers.BigNumber.from(connectDetails.chainId).toString();
     }
     if (connectDetails.connected) {
       var _connectDetails$sessi;
@@ -3996,17 +3979,33 @@ class SequenceClient {
 
   // Higher level API
 
-  async request(request) {
+  // Working with sendAsync is less idiomatic
+  // but transport uses it instead of send, so we wrap it
+  send(request, chainId) {
     // 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 this.transport.request(request);
+    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) {
     const connectedSession = this.session.connectedSession();
     if (pull) {
-      connectedSession.networks = await this.request({
+      connectedSession.networks = await this.send({
         method: 'sequence_getNetworks'
       });
       this.session.setSession(connectedSession);
@@ -4063,16 +4062,14 @@ class SequenceClient {
       }
     });
 
-    // If the message is a string, even if it looks like a BytesLike string we need to represent it as utf8 bytes.
-    // ie. '0x1234' is a string, '0x1234' is a bytesLike string which is 2 bytes but we must sign the full '0x1234' as 6 utf8 bytes
-    message = ethers.ethers.hexlify(typeof message === 'string' ? ethers.ethers.toUtf8Bytes(message) : message);
+    // Serialize a BytesLike or string message into a hex string before sending
+    message = ethers.ethers.utils.hexlify(messageToBytes(message));
 
     // Address is ignored by the wallet webapp
-    return this.request({
+    return this.send({
       method,
-      params: [message, this.getAddress()],
-      chainId: options == null ? void 0 : options.chainId
-    });
+      params: [message, this.getAddress()]
+    }, options == null ? void 0 : options.chainId);
   }
   async signTypedData(typedData, options) {
     var _this$analytics5;
@@ -4080,7 +4077,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.ethers.TypedDataEncoder.getPayload(typedData.domain, typedData.types, typedData.message);
+    const encoded = ethers.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
@@ -4093,11 +4090,10 @@ class SequenceClient {
         chainId: `${(options == null ? void 0 : options.chainId) || this.getChainId()}`
       }
     });
-    return this.request({
+    return this.send({
       method,
-      params: [this.getAddress(), encoded],
-      chainId: (options == null ? void 0 : options.chainId) || typedData.domain.chainId && Number(BigInt(typedData.domain.chainId)) || this.getChainId()
-    });
+      params: [this.getAddress(), encoded]
+    }, (options == null ? void 0 : options.chainId) || typedData.domain.chainId && ethers.ethers.BigNumber.from(typedData.domain.chainId).toNumber() || this.getChainId());
   }
   async sendTransaction(tx, options) {
     var _this$analytics6;
@@ -4109,24 +4105,22 @@ class SequenceClient {
         chainId: `${(options == null ? void 0 : options.chainId) || this.getChainId()}`
       }
     });
-    return this.request({
+    return this.send({
       method: 'eth_sendTransaction',
-      params: [extendedTxs],
-      chainId: options == null ? void 0 : options.chainId
-    });
+      params: [extendedTxs]
+    }, options == null ? void 0 : options.chainId);
   }
   async getWalletContext() {
-    return this.request({
+    return this.send({
       method: 'sequence_getWalletContext'
     });
   }
   async getOnchainWalletConfig(options) {
     // NOTICE: sequence_getWalletConfig sends the chainId as a param
-    const res = await this.request({
+    const res = await this.send({
       method: 'sequence_getWalletConfig',
-      params: [(options == null ? void 0 : options.chainId) || this.getChainId()],
-      chainId: options == null ? void 0 : options.chainId
-    });
+      params: [(options == null ? void 0 : options.chainId) || this.getChainId()]
+    }, options == null ? void 0 : options.chainId);
     return Array.isArray(res) ? res[0] : res;
   }
 
@@ -4205,11 +4199,9 @@ const initWallet = (projectAccessKey, partialConfig) => {
       if (!rpcUrl) {
         throw new Error(`no rpcUrl found for chainId: ${chainId}`);
       }
-      rpcProviders[chainId] = new network.JsonRpcProvider(rpcUrl, {
-        middlewares: [network.loggingProviderMiddleware, network.exceptionProviderMiddleware, new network.CachedProvider()]
-      }, {
-        cacheTimeout: -1
-      });
+      const baseProvider = new ethers.ethers.providers.JsonRpcProvider(rpcUrl);
+      const router = new network.JsonRpcRouter([network.loggingProviderMiddleware, network.exceptionProviderMiddleware, new network.CachedProvider()], new network.JsonRpcSender(baseProvider));
+      rpcProviders[chainId] = new ethers.ethers.providers.Web3Provider(router, chainId);
     }
     return rpcProviders[chainId];
   };
@@ -4298,3 +4290,4 @@ exports.resolveArrayProperties = resolveArrayProperties;
 exports.trimEIP191Prefix = trimEIP191Prefix;
 exports.unregisterWallet = unregisterWallet;
 exports.useBestStore = useBestStore;
+exports.validateTransactionRequest = validateTransactionRequest;