@0xsequence/provider 0.35.10 → 0.36.1

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

@@ -1,12 +1,12 @@
 import { EventEmitter2 } from 'eventemitter2';
-import { logger, packMessageData, sanitizeNumberString, sanitizeHost, sanitizeAlphanumeric, base64EncodeObject, base64DecodeObject, shallowCopy, resolveProperties, encodeMessageDigest, encodeTypedDataDigest } from '@0xsequence/utils';
+import { logger, shallowCopy, resolveProperties, encodeMessageDigest, encodeTypedDataDigest, packMessageData, sanitizeNumberString, sanitizeHost, sanitizeAlphanumeric, base64EncodeObject, base64DecodeObject } from '@0xsequence/utils';
 import { ethers, BigNumber } from 'ethers';
 import { addressOf, isConfigEqual } from '@0xsequence/config';
-import { isValidSignature as isValidSignature$1, recoverConfig, Signer, resolveArrayProperties } from '@0xsequence/wallet';
+import { Web3Provider as Web3Provider$1, JsonRpcProvider } from '@ethersproject/providers';
+import { JsonRpcSender, maybeChainId, allowProviderMiddleware, networkProviderMiddleware, CachedProvider, JsonRpcRouter, loggingProviderMiddleware, exceptionProviderMiddleware, findNetworkConfig, EagerProvider, SigningProvider, updateNetworkConfig, ensureValidNetworks } from '@0xsequence/network';
+import { Signer, resolveArrayProperties, isValidSignature as isValidSignature$1, isValidEIP712Signature, isValidEthSignSignature, recoverConfig } from '@0xsequence/wallet';
 import { isSignedTransactions } from '@0xsequence/transactions';
 import { signAuthorization } from '@0xsequence/auth';
-import { JsonRpcSender, maybeChainId, allowProviderMiddleware, networkProviderMiddleware, CachedProvider, JsonRpcRouter, loggingProviderMiddleware, exceptionProviderMiddleware, findNetworkConfig, EagerProvider, SigningProvider, updateNetworkConfig, ensureValidNetworks } from '@0xsequence/network';
-import { Web3Provider as Web3Provider$1, JsonRpcProvider } from '@ethersproject/providers';
 
 function _extends() {
   _extends = Object.assign || function (target) {
@@ -469,1835 +469,1817 @@ class BaseProviderTransport {
 
 }
 
-const isValidSignature = async (address, digest, sig, provider, chainId, walletContext) => {
-  chainId = chainId || (await provider.getChainId());
-  walletContext = walletContext || (await provider.getSigner().getWalletContext());
-  return isValidSignature$1(address, digest, sig, provider, walletContext, chainId);
-};
-const recoverWalletConfig = async (address, digest, signature, chainId, walletContext) => {
-  const subDigest = packMessageData(address, chainId, digest);
-  const config = await recoverConfig(subDigest, signature);
-
-  if (walletContext) {
-    const recoveredWalletAddress = addressOf(config, walletContext);
+const SIGNER_READY_TIMEOUT = 10000;
+class WalletRequestHandler {
+  // 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
+  // a Signer value is the actually interface to a signed-in account
+  constructor(_signer, prompter, mainnetNetworks, testnetNetworks = []) {
+    var _this = this;
 
-    if (config.address && config.address !== recoveredWalletAddress) {
-      throw new Error('recovered address does not match the WalletConfig address, check the WalletContext');
-    } else {
-      config.address = recoveredWalletAddress;
-    }
-  }
+    this.signer = void 0;
+    this.signerReadyCallbacks = [];
+    this.prompter = void 0;
+    this.mainnetNetworks = void 0;
+    this.testnetNetworks = void 0;
+    this._openIntent = void 0;
+    this._connectOptions = void 0;
+    this._defaultNetworkId = void 0;
+    this._chainId = void 0;
+    this.events = new EventEmitter2();
 
-  return config;
-};
-const isBrowserExtension = () => window.location.protocol === 'chrome-extension:' || window.location.protocol === 'moz-extension:';
-/**
- * Returns the status of a signer's wallet on given chain by checking wallet deployment and config status
- *
- * @param {Signer} signer
- * @param {number} chainId
- * @return {Promise<boolean>} Promise that returns true if the wallet is up to date, false otherwise
- */
+    this.promptConnect = async function (options) {
+      if (!options && !_this._connectOptions) {
+        // this is an unexpected state and should not happen
+        throw new Error('prompter connect options are empty');
+      }
 
-const isWalletUpToDate = async (signer, chainId) => {
-  var _walletState$find;
+      if (!_this.prompter) {
+        // if prompter is null, we'll auto connect
+        return _this.connect(options);
+      }
 
-  const walletState = await signer.getWalletState();
-  const networks = await signer.getNetworks();
-  const walletStateForRequiredChain = walletState.find(state => state.chainId === chainId);
+      const promptConnectDetails = await _this.prompter.promptConnect(options || _this._connectOptions).catch(_ => {
+        return {
+          connected: false
+        };
+      });
+      const connectDetails = promptConnectDetails;
 
-  if (!walletStateForRequiredChain) {
-    throw new Error(`WalletRequestHandler: could not find wallet state for chainId ${chainId}`);
-  }
+      if (connectDetails.connected && !connectDetails.session) {
+        connectDetails.session = await _this.walletSession();
+      }
 
-  const isDeployed = walletStateForRequiredChain.deployed;
+      return promptConnectDetails;
+    };
 
-  if (!networks) {
-    throw new Error(`isWalletUpToDate util: could not get networks from signer`);
-  }
+    this.sendAsync = async function (request, callback, chainId) {
+      const response = {
+        jsonrpc: '2.0',
+        id: request.id,
+        result: null
+      };
+      await _this.getSigner();
 
-  const authChain = networks.find(network => network.isAuthChain);
+      try {
+        // only allow public json rpc method to the provider when user is not logged in, aka signer is not set
+        if ((!_this.signer || _this.signer === null) && !permittedJsonRpcMethods.includes(request.method)) {
+          // throw new Error(`not logged in. ${request.method} is unavailable`)
+          throw ErrSignedInRequired;
+        } // wallet signer
 
-  if (!authChain) {
-    throw new Error(`isWalletUpToDate util: could not get auth chain network information`);
-  }
 
-  const authChainId = authChain.chainId;
-  const authChainConfig = (_walletState$find = walletState.find(state => state.chainId === authChainId)) == null ? void 0 : _walletState$find.config;
+        const signer = _this.signer;
+        if (!signer) throw new Error('WalletRequestHandler: wallet signer is not configured'); // fetch the provider for the specific chain, or undefined will select defaultChain
 
-  if (!authChainConfig) {
-    throw new Error(`isWalletUpToDate util: could not get auth chain config`);
-  }
+        const provider = await signer.getProvider(chainId);
+        if (!provider) throw new Error(`WalletRequestHandler: wallet provider is not configured for chainId ${chainId}`);
 
-  const requiredChainConfig = walletStateForRequiredChain.config;
+        switch (request.method) {
+          case 'net_version':
+            {
+              const result = await provider.send('net_version', []);
+              response.result = result;
+              break;
+            }
 
-  if (!requiredChainConfig) {
-    throw new Error(`isWalletUpToDate util: could not get config for chainId ${chainId}`);
-  }
+          case 'eth_chainId':
+            {
+              const result = await provider.send('eth_chainId', []);
+              response.result = result;
+              break;
+            }
 
-  const isUpToDate = isConfigEqual(authChainConfig, requiredChainConfig);
-  return isDeployed && isUpToDate;
-}; // window.localstorage helper
+          case 'eth_accounts':
+            {
+              const walletAddress = await signer.getAddress();
+              response.result = [walletAddress];
+              break;
+            }
 
-class LocalStore {
-  constructor(key, def) {
-    this.def = def;
-    this.key = void 0;
-    this.key = key;
-  }
+          case 'eth_getBalance':
+            {
+              const [accountAddress, blockTag] = request.params;
+              const walletBalance = await provider.getBalance(accountAddress, blockTag);
+              response.result = walletBalance.toHexString();
+              break;
+            }
 
-  get() {
-    const val = window.localStorage.getItem(this.key);
+          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:
+              // personal_sign: [data, address]
+              // eth_sign: [address, data]
 
-    if (val === null) {
-      return this.def;
-    }
+              if (request.method === 'personal_sign') {
+                const [data, address] = request.params;
+                message = data;
+              } else {
+                const [address, data] = request.params;
+                message = data;
+              }
 
-    try {
-      return JSON.parse(val);
-    } catch (err) {
-      console.error(err);
-    }
+              let sig = ''; // TODO:
+              // if (process.env.TEST_MODE === 'true' && this.prompter === null) {
 
-    return;
-  }
+              if (_this.prompter === null) {
+                // prompter is null, so we'll sign from here
+                sig = await signer.signMessage(ethers.utils.arrayify(message), chainId);
+              } else {
+                const promptResultForDeployment = await _this.handleConfirmWalletDeployPrompt(_this.prompter, signer, chainId);
 
-  set(val) {
-    val ? window.localStorage.setItem(this.key, JSON.stringify(val)) : window.localStorage.removeItem(this.key);
-  }
+                if (promptResultForDeployment) {
+                  sig = await _this.prompter.promptSignMessage({
+                    chainId: chainId,
+                    message: message
+                  });
+                }
+              }
 
-  del() {
-    window.localStorage.removeItem(this.key);
-  }
+              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;
+            }
 
-const TRANSPORT_SESSION_LS_KEY = '@sequence.transportSession';
-class BaseWalletTransport {
-  // appOrigin identifies the dapp's origin which opened the app. A transport
-  // will auto-detect and set this value if it can. This is determined
-  // as the parent app/window which opened the wallet.
-  constructor(walletRequestHandler) {
-    var _this = this;
+          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;
 
-    this.walletRequestHandler = void 0;
-    this._sessionId = void 0;
-    this._registered = void 0;
-    this._init = void 0;
-    this._initNonce = void 0;
-    this._initCallback = void 0;
-    this.appOrigin = void 0;
+              if (typeof typedDataObject === 'string') {
+                try {
+                  typedData = JSON.parse(typedDataObject);
+                } catch (e) {}
+              } else {
+                typedData = typedDataObject;
+              }
 
-    this.sendAsync = async function (request, callback, chainId) {
-      throw new Error('abstract method');
-    };
+              if (!typedData || !typedData.domain || !typedData.types || !typedData.message) {
+                throw new Error('invalid typedData object');
+              }
 
-    this.handleMessage = async function (message) {
-      const request = message; // ensure initial handshake is complete before accepting
-      // other kinds of messages.
+              let sig = '';
 
-      if (_this._init !== InitState.OK) {
-        if (request.type === EventType.INIT) {
-          if (_this.isValidInitAck(message)) {
-            // successful init
-            if (_this._initCallback) _this._initCallback();
-          } else {
-            // failed init
-            if (_this._initCallback) _this._initCallback('invalid init');
-            return;
-          }
-        }
-
-        return;
-      } // ensure signer is ready to handle requests
-      // if (this.walletRequestHandler.getSigner() === undefined) {
-      //   await this.walletRequestHandler.signerReady()
-      // }
-      // handle request
+              if (_this.prompter === null) {
+                // prompter is null, so we'll sign from here
+                sig = await signer.signTypedData(typedData.domain, typedData.types, typedData.message, chainId);
+              } else {
+                const promptResultForDeployment = await _this.handleConfirmWalletDeployPrompt(_this.prompter, signer, chainId);
 
+                if (promptResultForDeployment) {
+                  sig = await _this.prompter.promptSignMessage({
+                    chainId: chainId,
+                    typedData: typedData
+                  });
+                }
+              }
 
-      switch (request.type) {
-        case EventType.OPEN:
-          {
-            if (_this._init !== InitState.OK) return;
-            const session = {
-              sessionId: request.data.sessionId,
-              intent: request.data.intent,
-              networkId: request.data.networkId
-            };
-            await _this.open(session);
-            return;
-          }
+              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');
+              }
 
-        case EventType.CLOSE:
-          {
-            if (_this._init !== InitState.OK) return; // noop. just here to capture the message so event emitters may be notified
+              break;
+            }
 
-            return;
-          }
+          case 'eth_sendTransaction':
+            {
+              // https://eth.wiki/json-rpc/API#eth_sendtransaction
+              const [transactionParams] = request.params;
+              let txnHash = '';
 
-        case EventType.MESSAGE:
-          {
-            const response = await _this.walletRequestHandler.sendMessageRequest(request);
+              if (_this.prompter === null) {
+                // prompter is null, so we'll send from here
+                const txnResponse = await signer.sendTransaction(transactionParams, chainId);
+                txnHash = txnResponse.hash;
+              } else {
+                // prompt user to provide the response
+                txnHash = await _this.prompter.promptSendTransaction(transactionParams, chainId);
+              }
 
-            _this.sendMessage(response);
+              if (txnHash) {
+                response.result = txnHash;
+              } else {
+                // The user has declined the request when value is null
+                throw new Error('declined by user');
+              }
 
-            if (response.data.error) ;
+              break;
+            }
 
-            return;
-          }
+          case 'eth_signTransaction':
+            {
+              // https://eth.wiki/json-rpc/API#eth_signTransaction
+              const [transaction] = request.params;
+              const sender = ethers.utils.getAddress(transaction.from);
 
-        default:
-          {
-            logger.error(`unexpected payload type ${request.type}`);
-          }
-      }
-    };
+              if (sender !== (await signer.getAddress())) {
+                throw new Error('sender address does not match wallet');
+              }
 
-    this.sendMessageRequest = async function (message) {
-      return _this.walletRequestHandler.sendMessageRequest(message);
-    };
+              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 bignumber values to hex strings
+                response.result = await signer.signTransactions(transaction, chainId);
+              } else {
+                response.result = await _this.prompter.promptSignTransaction(transaction, chainId);
+              }
 
-    this.open = async function ({
-      sessionId,
-      intent,
-      networkId
-    }) {
-      if (sessionId) {
-        _this._sessionId = sanitizeNumberString(sessionId); // persist transport session in localstorage for restoring after redirect/reload
+              break;
+            }
 
-        _this.saveTransportSession({
-          sessionId,
-          intent,
-          networkId
-        });
-      }
+          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 (isSignedTransactions(request.params[0])) {
+                const txChainId = BigNumber.from(request.params[0].chainId).toNumber();
+                const tx = await (await signer.getRelayer(txChainId)).relay(request.params[0]);
+                response.result = (await tx).hash;
+              } else {
+                const tx = await provider.sendTransaction(request.params[0]);
+                response.result = tx.hash;
+              }
 
-      _this.walletRequestHandler.setOpenIntent(intent); // init handshake for certain transports, before we can open the communication.
-      //
-      // for example, with the window-transport, we have to exchange messages to determine the
-      // origin host of the dapp.
+              break;
+            }
 
+          case 'eth_getTransactionCount':
+            {
+              const address = ethers.utils.getAddress(request.params[0]);
+              const tag = request.params[1];
+              const walletAddress = ethers.utils.getAddress(await signer.getAddress());
 
-      await _this.init(); // Prepare connect options from intent
+              if (address === walletAddress) {
+                const count = await signer.getTransactionCount(tag);
+                response.result = ethers.BigNumber.from(count).toHexString();
+              } else {
+                const count = await provider.getTransactionCount(address, tag);
+                response.result = ethers.BigNumber.from(count).toHexString();
+              }
 
-      if (intent && intent.type === 'connect' && intent.options) {
-        const connectOptions = intent.options;
-        const authorizeOptions = connectOptions; // overlapping types
-        // Sanity/integrity check the intent payload, and set authorization origin
-        // if its been determined as part of the init handshake from earlier.
+              break;
+            }
 
-        if (_this.appOrigin && authorizeOptions != null && authorizeOptions.origin) {
-          if (!isBrowserExtension()) {
-            if (authorizeOptions.origin !== _this.appOrigin) {
-              throw new Error('origin is invalid');
+          case 'eth_blockNumber':
+            {
+              response.result = await provider.getBlockNumber();
+              break;
             }
-          }
-        } else if (!_this.appOrigin && authorizeOptions != null && authorizeOptions.origin) {
-          // ie. when we can't determine the origin in our transport, but dapp provides it to us.
-          // we just sanitize the origin host.
-          connectOptions.origin = sanitizeHost(authorizeOptions.origin);
-        } else if (_this.appOrigin) {
-          // ie. when we auto-determine the origin such as in window-transport
-          connectOptions.origin = _this.appOrigin;
-        }
 
-        if (connectOptions.app) {
-          connectOptions.app = sanitizeAlphanumeric(connectOptions.app);
-        } // Set connect options on the walletRequestHandler as our primary
-        // wallet controller
+          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;
+            }
 
-        _this.walletRequestHandler.setConnectOptions(connectOptions);
+          case 'eth_getTransactionByHash':
+            {
+              response.result = await provider.getTransaction(request.params[0]);
+              break;
+            }
 
-        if (connectOptions.networkId) {
-          networkId = connectOptions.networkId;
-        }
-      } else {
-        _this.walletRequestHandler.setConnectOptions(undefined);
-      } // ensure signer is ready
+          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;
+            }
 
-      await _this.walletRequestHandler.getSigner(); // Notify open and proceed to prompt for connection if intended
+          case 'eth_estimateGas':
+            {
+              const [transactionObject] = request.params;
+              response.result = await provider.estimateGas(transactionObject);
+              break;
+            }
 
-      if (!(await _this.walletRequestHandler.isSignedIn())) {
-        // open wallet without a specific connected chainId, as the user is not signed in
-        _this.notifyOpen({
-          sessionId: _this._sessionId
-        });
+          case 'eth_gasPrice':
+            {
+              const gasPrice = await provider.getGasPrice();
+              response.result = gasPrice.toHexString();
+              break;
+            }
+          // smart wallet method
 
-        return true;
-      } else {
-        // Set default network, in case of error chainId will be undefined or 0
-        let chainId = undefined;
+          case 'sequence_getWalletContext':
+            {
+              response.result = await signer.getWalletContext();
+              break;
+            }
+          // smart wallet method
 
-        try {
-          if (networkId) {
-            chainId = await _this.walletRequestHandler.setDefaultNetwork(networkId, false);
-          } else {
-            chainId = await _this.walletRequestHandler.getChainId();
-          }
-        } catch (err) {
-          console.error(err);
-        } // Failed to set default network on open -- quit + close
+          case 'sequence_getWalletConfig':
+            {
+              const [_chainId] = request.params;
+              response.result = await signer.getWalletConfig(_chainId);
+              break;
+            }
+          // smart wallet method
 
+          case 'sequence_getWalletState':
+            {
+              const [_chainId2] = request.params;
+              response.result = await signer.getWalletState(_chainId2);
+              break;
+            }
+          // smart wallet method
 
-        if (!chainId || chainId <= 0) {
-          _this.notifyOpen({
-            sessionId: _this._sessionId,
-            error: `failed to open wallet on network ${networkId}`
-          });
+          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;
+            }
+          // smart wallet method
 
-          return false;
-        } // prompt user with a connect request. the options will be used as previously set above.
-        // upon success, the walletRequestHandler will notify the dapp with the ConnectDetails.
-        // upon cancellation by user, the walletRequestHandler will throw an error
+          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
 
-        if (intent && intent.type === 'connect') {
-          // notify wallet is opened, without session details
-          _this.notifyOpen({
-            sessionId: _this._sessionId
-          });
+          case 'sequence_publishConfig':
+            {
+              throw new Error('sequence_publishConfig method is not allowed from a dapp');
+              break;
+            }
+          // relayer method
 
-          try {
-            const connectDetails = await _this.walletRequestHandler.promptConnect(intent.options);
+          case 'sequence_estimateGasLimits':
+            {
+              // TODO
+              break;
+            }
+          // relayer method
 
-            if (connectDetails.connected) {
-              _this.walletRequestHandler.notifyConnect(connectDetails);
+          case 'sequence_gasRefundOptions':
+            {
+              // TODO
+              break;
             }
-          } catch (err) {
-            logger.warn('promptConnect not connected:', err);
-          } finally {
-            // auto-close by default, unless intent is to keep open
-            if (!intent.options || intent.options.keepWalletOpened !== true) {
-              _this.notifyClose();
+          // relayer method
+
+          case 'sequence_getNonce':
+            {
+              // TODO
+              break;
+            }
+          // relayer method
+
+          case 'sequence_relay':
+            {
+              // TODO
+              break;
+            }
+          // set default network of wallet
+
+          case 'sequence_setDefaultNetwork':
+            {
+              const [defaultNetworkId] = request.params;
+
+              if (!defaultNetworkId) {
+                throw new Error('invalid request, method argument defaultNetworkId cannot be empty');
+              }
+
+              const ok = await _this.setDefaultNetwork(defaultNetworkId);
+
+              if (!ok) {
+                throw new Error(`unable to set default network ${defaultNetworkId}`);
+              }
+
+              response.result = await _this.getNetworks(true);
+              break;
+            }
+
+          default:
+            {
+              // NOTE: provider here will be chain-bound if chainId is provided
+              const providerResponse = await provider.send(request.method, request.params);
+              response.result = providerResponse;
             }
-          }
-        } else {
-          // user is already connected, notify session details.
-          // TODO: in future, keep list if 'connected' dapps / sessions in the session
-          // controller, and only sync with allowed apps
-          _this.notifyOpen({
-            sessionId: _this._sessionId,
-            chainId: `${chainId}`,
-            session: await _this.walletRequestHandler.walletSession()
-          });
         }
+      } 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
+        });
       }
 
-      return true;
+      callback(undefined, response);
     };
 
-    this.saveTransportSession = session => {
-      window.localStorage.setItem(TRANSPORT_SESSION_LS_KEY, JSON.stringify(session));
+    this.isSignedIn = async function () {
+      await _this.signerReady();
+      return !!_this.signer;
     };
 
-    this.getCachedTransportSession = () => {
-      const session = window.localStorage.getItem(TRANSPORT_SESSION_LS_KEY);
+    this.getSigner = async function () {
+      await _this.signerReady();
 
-      try {
-        return session ? JSON.parse(session) : null;
-      } catch (err) {
-        console.error(`unable to parse transport session: ${session}`);
-        return null;
+      if (_this.signer === undefined) {
+        throw new Error('signerReady failed resolve');
       }
+
+      return _this.signer;
     };
 
-    this.walletRequestHandler = walletRequestHandler;
-    this._init = InitState.NIL;
-    this.walletRequestHandler.on('connect', connectDetails => {
-      if (!this.registered) return; // means user has logged in and wallet is connected to the app
+    this.signer = _signer;
+    this.prompter = prompter;
+    this.mainnetNetworks = mainnetNetworks;
+    this.testnetNetworks = testnetNetworks;
+  }
 
-      this.notifyConnect(connectDetails);
-    });
-    this.walletRequestHandler.on('disconnect', error => {
-      if (!this.registered) return; // means user has logged out the app / disconnected wallet from the app
+  async signIn(signer, options = {}) {
+    this.setSigner(signer);
+    const {
+      connect,
+      mainnetNetworks,
+      testnetNetworks,
+      defaultNetworkId
+    } = options;
 
-      this.notifyDisconnect(error);
-    });
-    this.walletRequestHandler.on('accountsChanged', accounts => {
-      if (!this.registered) return;
-      this.notifyAccountsChanged(accounts);
-    });
-    this.walletRequestHandler.on('networks', networks => {
-      if (!this.registered) return;
-      this.notifyNetworks(networks);
+    if (mainnetNetworks && mainnetNetworks.length > 0) {
+      this.mainnetNetworks = mainnetNetworks;
+    }
 
-      if (!networks || networks.length === 0) {
-        this.notifyChainChanged('0x0');
-      } else {
-        this.notifyChainChanged(ethers.utils.hexlify(networks[0].chainId));
+    if (testnetNetworks && testnetNetworks.length > 0) {
+      this.testnetNetworks = testnetNetworks;
+    }
+
+    if ((!this.mainnetNetworks || this.mainnetNetworks.length === 0) && (!this.testnetNetworks || this.testnetNetworks.length === 0)) {
+      throw new Error('signIn failed as network configuration is empty');
+    }
+
+    const networkId = defaultNetworkId || this._defaultNetworkId;
+
+    if (networkId) {
+      if (!(await this.setDefaultNetwork(networkId, false))) {
+        throw new Error(`WalletRequestHandler setup unable to set defaultNetworkId ${networkId}`);
       }
-    });
-    this.walletRequestHandler.on('walletContext', walletContext => {
-      if (!this.registered || !walletContext) return;
-      this.notifyWalletContext(walletContext);
-    });
-    this.walletRequestHandler.on('close', error => {
-      if (!this.registered) return;
-      this.notifyClose(error);
-    });
-  }
+    } // Optionally, connect the dapp and wallet. In case connectOptions are provided, we will perform
+    // necessary auth request, and then notify the dapp of the 'connect' details.
+    //
+    // NOTE: if a user is signing into a dapp from a fresh state, and and auth request is made
+    // we don't trigger the promptConnect flow, as we consider the user just authenticated
+    // for this dapp, so its safe to authorize in the connect() method without the prompt.
+    //
+    // NOTE: signIn can optionally connect and notify dapp at this time for new signIn flows
 
-  get registered() {
-    return this._registered;
-  }
 
-  register() {
-    throw new Error('abstract method');
+    if (connect) {
+      const connectOptions = this._connectOptions;
+      const connectDetails = await this.connect(connectOptions);
+      this.notifyConnect(connectDetails);
+
+      if (!connectOptions || connectOptions.keepWalletOpened !== true) {
+        this.notifyClose();
+      }
+    }
   }
 
-  unregister() {
-    throw new Error('abstract method');
+  signOut() {
+    // signed out state
+    this.setSigner(null);
   }
 
-  sendMessage(message) {
-    throw new Error('abstract method');
+  signerReset() {
+    // resetting signer puts the wallet in an uninitialized state, which requires the app to
+    // re-initiatize and set the signer either as "null" (ie. no signer) or "Signer" (ie. signed in).
+    this.signer = undefined;
   }
 
-  notifyOpen(openInfo) {
-    const {
-      chainId,
-      sessionId,
-      session,
-      error
-    } = openInfo;
-    this.sendMessage({
-      idx: -1,
-      type: EventType.OPEN,
-      data: {
-        chainId,
-        sessionId,
-        session,
-        error
+  signerReady(timeout = SIGNER_READY_TIMEOUT) {
+    return new Promise((resolve, reject) => {
+      if (this.signer !== undefined) {
+        resolve();
+      } else {
+        setTimeout(() => {
+          if (this.signer === undefined) {
+            this.signerReadyCallbacks = [];
+            reject(`signerReady timed out`);
+          }
+        }, timeout);
+        this.signerReadyCallbacks.push(resolve);
       }
     });
   }
 
-  notifyClose(error) {
-    this.sendMessage({
-      idx: -1,
-      type: EventType.CLOSE,
-      data: error ? {
-        error
-      } : null
-    });
-  }
+  async connect(options) {
+    if (!this.signer) {
+      return {
+        connected: false,
+        chainId: '0x0',
+        error: 'unable to connect without signed in account'
+      };
+    }
 
-  notifyConnect(connectDetails) {
-    this.sendMessage({
-      idx: -1,
-      type: EventType.CONNECT,
-      data: connectDetails
-    });
-  }
+    const connectDetails = {
+      connected: true,
+      chainId: ethers.utils.hexlify(await this.getChainId())
+    };
 
-  notifyDisconnect(error) {
-    this.sendMessage({
-      idx: -1,
-      type: EventType.DISCONNECT,
-      data: error ? {
-        error
-      } : null
-    });
-  }
+    if (options && options.authorize) {
+      // Perform ethauth eip712 request and construct the ConnectDetails response
+      // including the auth proof
+      const authOptions = {
+        app: options.app,
+        origin: options.origin,
+        expiry: options.expiry
+      }; // if (typeof(options.authorize) === 'object') {
+      //   authOptions = { ...authOptions, ...options.authorize }
+      // }
 
-  notifyAccountsChanged(accounts) {
-    this.sendMessage({
-      idx: -1,
-      type: EventType.ACCOUNTS_CHANGED,
-      data: accounts
-    });
-  }
+      try {
+        connectDetails.proof = await signAuthorization(this.signer, authOptions);
+      } catch (err) {
+        logger.warn(`connect, signAuthorization failed for options: ${JSON.stringify(options)}, due to: ${err.message}`);
+        return {
+          connected: false,
+          chainId: '0x0',
+          error: `signAuthorization failed: ${err.message}`
+        };
+      }
+    } // Build session response for connect details
 
-  notifyChainChanged(chainIdHex) {
-    this.sendMessage({
-      idx: -1,
-      type: EventType.CHAIN_CHANGED,
-      data: chainIdHex
-    });
-  }
 
-  notifyNetworks(networks) {
-    this.sendMessage({
-      idx: -1,
-      type: EventType.NETWORKS,
-      data: networks
-    });
+    connectDetails.session = await this.walletSession();
+    return connectDetails;
   }
 
-  notifyWalletContext(walletContext) {
-    this.sendMessage({
-      idx: -1,
-      type: EventType.WALLET_CONTEXT,
-      data: walletContext
+  // 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?
+        const responseMessage = _extends({}, message, {
+          data: response
+        }); // 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);
     });
+  } // sendAsync implements the JsonRpcHandler interface for sending JsonRpcRequests to the wallet
+
+
+  on(event, fn) {
+    this.events.on(event, fn);
   }
 
-  isValidInitAck(message) {
-    if (this._init === InitState.OK) {
-      // we're already in init state, we shouldn't handle this message
-      logger.warn("isValidInitAck, already in init'd state, so inquiry is invalid.");
-      return false;
-    }
+  once(event, fn) {
+    this.events.once(event, fn);
+  }
 
-    if (message.type !== EventType.INIT) {
-      logger.warn('isValidInitAck, invalid message type, expecting init');
-      return false;
+  async getAddress() {
+    if (!this.signer) {
+      return '';
+    } else {
+      return this.signer.getAddress();
     }
+  }
 
-    const {
-      sessionId,
-      nonce
-    } = message.data;
+  async getChainId() {
+    if (!this.signer) {
+      return 0;
+    } else {
+      if (this._chainId) return this._chainId; // memoized
 
-    if (!sessionId || sessionId.length === 0 || !nonce || nonce.length === 0) {
-      logger.error('invalid init ack');
-      return false;
+      this._chainId = await this.signer.getChainId();
+      return this._chainId;
     }
+  }
 
-    if (sessionId !== this._sessionId || nonce !== this._initNonce) {
-      logger.error('invalid init ack match');
-      return false;
-    } // all checks pass, its true
+  get openIntent() {
+    return this._openIntent;
+  }
 
+  setOpenIntent(intent) {
+    this._openIntent = intent;
+  }
 
-    return true;
+  get connectOptions() {
+    return this._connectOptions;
   }
 
-  init() {
-    return new Promise((resolve, reject) => {
-      // avoid re-init`ing, or if there is a transport which doesn't require
-      // it, then it may set this._init to OK in its constructor.
-      if (this._init === InitState.OK) {
-        resolve();
-        return;
-      }
+  setConnectOptions(options) {
+    this._connectOptions = options;
+  }
 
-      if (this._init !== InitState.NIL || this._initCallback) {
-        reject('transport init is in progress');
-        return;
-      } // start init timeout, if we don't receive confirmation
-      // from provider within this amount of time, then we timeout
+  get defaultNetworkId() {
+    return this._defaultNetworkId;
+  }
 
+  async setDefaultNetwork(chainId, notifyNetworks = true) {
+    if (!chainId) return undefined;
+    this._defaultNetworkId = chainId;
+    this._chainId = undefined;
 
-      const initTimeout = setTimeout(() => {
-        logger.warn('transport init timed out');
+    if (this.signer && this.signer.setNetworks) {
+      const defaultChainId = this.signer.setNetworks(this.mainnetNetworks, this.testnetNetworks, chainId);
 
-        if (this._initCallback) {
-          this._initCallback('transport init timed out');
-        }
-      }, PROVIDER_OPEN_TIMEOUT / 2); // setup callback as we receive the init message async in the handleMessage function
+      if (defaultChainId && notifyNetworks) {
+        await this.notifyNetworks();
+      }
 
-      this._initCallback = error => {
-        this._initCallback = undefined; // reset
+      return defaultChainId;
+    } else {
+      return undefined;
+    }
+  }
 
-        clearTimeout(initTimeout);
+  async getNetworks(jsonRpcResponse) {
+    if (!this.signer) {
+      logger.warn('signer not set: getNetworks is returning an empty list');
+      return [];
+    }
 
-        if (error) {
-          reject(error);
-        } else {
-          this._init = InitState.OK;
-          resolve();
-        }
-      }; // send init request with random nonce to the provider, where we expect
-      // for the provider to echo it back to us as complete handshake
+    const networks = await this.signer.getNetworks();
 
+    if (jsonRpcResponse) {
+      // omit provider and relayer objects as they are not serializable
+      return networks.map(n => {
+        const network = _extends({}, n);
 
-      this._initNonce = `${performance.now()}`;
-      this.sendMessage({
-        idx: -1,
-        type: EventType.INIT,
-        data: {
-          nonce: this._initNonce
-        }
+        network.provider = undefined;
+        network.relayer = undefined;
+        return network;
       });
-      this._init = InitState.SENT_NONCE; // NOTE: the promise will resolve in the _initCallback method
-      // which will be called from either handleMessage or the initTimeout
-    });
+    } else {
+      return networks;
+    }
   }
 
-}
-
-class ProxyMessageChannel {
-  constructor() {
-    this.app = void 0;
-    this.wallet = void 0;
-    const port1 = new ProxyMessageChannelPort();
-    const port2 = new ProxyMessageChannelPort();
-    port1.conn = port2;
-    port2.conn = port1;
-    this.app = port1;
-    this.wallet = port2;
+  async walletSession() {
+    return !this.signer ? undefined : {
+      walletContext: await this.signer.getWalletContext(),
+      accountAddress: await this.signer.getAddress(),
+      networks: await this.getNetworks(true)
+    };
   }
 
-}
-class ProxyMessageChannelPort {
-  constructor() {
-    this.conn = void 0;
-    this.events = new EventEmitter2();
+  notifyConnect(connectDetails) {
+    var _connectDetails$sessi;
 
-    this.handleMessage = message => {
-      throw new Error('ProxyMessageChannelPort is not registered');
-    };
+    this.events.emit('connect', connectDetails);
 
-    this.sendMessage = message => {
-      this.conn.handleMessage(message); // trigger events
+    if ((_connectDetails$sessi = connectDetails.session) != null && _connectDetails$sessi.accountAddress) {
+      var _connectDetails$sessi2;
 
-      if (message.type === 'open') {
-        this.events.emit('open', message);
-      }
+      this.events.emit('accountsChanged', [(_connectDetails$sessi2 = connectDetails.session) == null ? void 0 : _connectDetails$sessi2.accountAddress]);
+    }
+  }
 
-      if (message.type === 'close') {
-        this.events.emit('close', message);
-      }
+  notifyDisconnect() {
+    this.events.emit('accountsChanged', []);
+    this.events.emit('networks', []);
+    this.events.emit('disconnect');
+  }
 
-      if (message.type === 'connect') {
-        this.events.emit('connect', message);
-      }
+  async notifyNetworks(networks) {
+    const n = networks || (await this.getNetworks(true));
+    this.events.emit('networks', n);
 
-      if (message.type === 'disconnect') {
-        this.events.emit('disconnect', message);
-      }
-    };
+    if (n && n.length > 0) {
+      this.events.emit('chainChanged', ethers.utils.hexlify(n[0].chainId));
+    } else {
+      this.events.emit('chainChanged', '0x0');
+    }
   }
 
-  on(event, fn) {
-    this.events.on(event, fn);
+  async notifyWalletContext() {
+    if (!this.signer) {
+      logger.warn('signer not set: skipping to notify wallet context');
+      return;
+    }
+
+    const walletContext = await this.signer.getWalletContext();
+    this.events.emit('walletContext', walletContext);
   }
 
-  once(event, fn) {
-    this.events.once(event, fn);
+  notifyClose(error) {
+    this.events.emit('close', error);
   }
 
-}
+  setSigner(signer) {
+    this.signer = signer;
 
-class ProxyMessageProvider extends BaseProviderTransport {
-  constructor(port) {
-    super();
-    this.port = void 0;
+    if (signer !== undefined) {
+      for (let i = 0; i < this.signerReadyCallbacks.length; i++) {
+        this.signerReadyCallbacks[i]();
+      }
 
-    this.register = () => {
-      this.port.handleMessage = message => {
-        this.handleMessage(message);
-      };
+      this.signerReadyCallbacks = [];
+    }
+  }
 
-      this.on('open', (...args) => {
-        this.port.events.emit('open', ...args);
-      });
-      this.on('close', (...args) => {
-        this.port.events.emit('close', ...args);
-      });
-      this.on('connect', (...args) => {
-        this.port.events.emit('connect', ...args);
-      });
-      this.on('disconnect', (...args) => {
-        this.port.events.emit('disconnect', ...args);
-      });
-      this._registered = true;
-    };
+  async handleConfirmWalletDeployPrompt(prompter, signer, chainId) {
+    // check if wallet is deployed and up to date, if not, prompt user to deploy
+    // if no chainId is provided, we'll assume the wallet is auth chain wallet and is up to date
+    if (!chainId) {
+      return true;
+    }
 
-    this.unregister = () => {
-      this._registered = false;
-      this.closeWallet();
-      this.events.removeAllListeners(); // @ts-ignore
+    const isUpToDate = await isWalletUpToDate(signer, chainId);
 
-      this.port.handleMessage = undefined;
-    };
+    if (isUpToDate) {
+      return true;
+    }
 
-    this.openWallet = (path, intent, networkId) => {
-      if (this.state === OpenState.CLOSED) {
-        this.state = OpenState.OPENING;
-        const sessionId = `${performance.now()}`;
-        this._sessionId = sessionId;
-        this.sendMessage({
-          idx: -1,
-          type: EventType.OPEN,
-          data: {
-            path,
-            intent,
-            networkId,
-            sessionId
-          }
-        });
+    const promptResult = await prompter.promptConfirmWalletDeploy(chainId); // if client returned true, check again to make sure wallet is deployed and up to date
+
+    if (promptResult) {
+      const isPromptResultCorrect = await isWalletUpToDate(signer, chainId);
+
+      if (!isPromptResultCorrect) {
+        logger.error('WalletRequestHandler: result for promptConfirmWalletDeploy is not correct');
+        return false;
+      } else {
+        return true;
       }
-    };
+    }
 
-    this.state = OpenState.CLOSED;
-    this.port = port;
+    return false;
+  }
 
-    if (!port) {
-      throw new Error('port argument cannot be empty');
-    } // disable init handshake for proxy-transport, we set it to OK, to
-    // consider it in completed state.
+}
+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'];
 
+class Web3Provider extends Web3Provider$1 {
+  static isSequenceProvider(cand) {
+    return isSequenceProvider(cand);
+  }
 
-    this._init = InitState.OK;
+  constructor(provider, defaultChainId) {
+    const sender = new JsonRpcSender(provider, maybeChainId(defaultChainId));
+    provider = sender;
+    super(provider, 'any');
+    this._sender = void 0;
+    this._isSequenceProvider = void 0;
+    this._defaultChainId = void 0;
+    this._sender = sender;
+    this._isSequenceProvider = true;
+    this._defaultChainId = maybeChainId(defaultChainId);
   }
 
-  closeWallet() {
-    this.sendMessage({
-      idx: -1,
-      type: EventType.CLOSE,
-      data: null
-    });
-    this.close();
+  sendAsync(request, callback, chainId) {
+    this._sender.sendAsync(request, callback, chainId);
   }
 
-  sendMessage(message) {
-    if (!message.idx) {
-      throw new Error('message idx is empty');
+  send(method, params, chainId) {
+    return this._sender.send(method, params, chainId);
+  }
+
+  getSigner() {
+    return new Web3Signer(this, this._defaultChainId);
+  }
+
+  async getChainId() {
+    // TODO: is it safe to memoize this?
+    const result = await this.send('eth_chainId', []);
+    const chainId = ethers.BigNumber.from(result).toNumber();
+
+    if (this._defaultChainId && this._defaultChainId !== chainId) {
+      throw new Error(`provider chainId (${chainId}) does not match provider-bound chainId ${this._defaultChainId}`);
     }
 
-    this.port.sendMessage(message);
+    return chainId;
   }
 
 }
-
-class ProxyMessageHandler extends BaseWalletTransport {
-  constructor(walletRequestHandler, port) {
+function isSequenceProvider(provider) {
+  const cand = provider;
+  return cand && cand.send !== undefined && cand._isSequenceProvider === true;
+}
+class LocalWeb3Provider extends Web3Provider {
+  constructor(signer, networks) {
+    const walletRequestHandler = new WalletRequestHandler(signer, null, networks || []);
     super(walletRequestHandler);
-    this.port = void 0;
-    this.port = port;
-    this._init = InitState.OK;
   }
 
-  register() {
-    this.port.handleMessage = message => {
-      this.handleMessage(message);
-    };
-
-    this._registered = true;
-  } // note: we can't decide whether to restore the session within register(), because session info is
-  // received asyncronously via EventType.OPEN after register() is executed.
-  // And in the case of a redirect/reload, EventType.OPEN is not sent at all, 
-  // because the wallet is already open.
-  //
-  // call this method from wallet redirect hander when a session restore is needed
-
-
-  restoreSession() {
-    const cachedSession = this.getCachedTransportSession();
+}
+class Web3Signer extends Signer {
+  constructor(provider, defaultChainId) {
+    super();
+    this.provider = void 0;
+    this.defaultChainId = void 0;
+    this._address = void 0;
+    this._index = void 0;
+    this._context = void 0;
+    this._networks = void 0;
+    this._providers = {};
+    this.provider = provider;
+    this.defaultChainId = defaultChainId;
+  } // memoized
 
-    if (cachedSession) {
-      this.open(cachedSession);
-    }
-  }
 
-  unregister() {
-    // @ts-ignore
-    this.port.handleMessage = undefined;
-    this._registered = false;
+  //
+  // ethers AbstractSigner methods
+  //
+  async getAddress() {
+    if (this._address) return this._address;
+    const accounts = await this.provider.send('eth_accounts', []);
+    this._address = accounts[0];
+    this._index = 0;
+    return ethers.utils.getAddress(this._address);
   }
 
-  sendMessage(message) {
-    this.port.sendMessage(message);
+  signTransaction(transaction) {
+    // TODO .. since ethers isn't using this method, perhaps we will?
+    throw new Error('signTransaction is unsupported, use signTransactions instead');
   }
 
-}
+  connect(provider) {
+    throw new Error('unsupported: cannot alter JSON-RPC Signer connection');
+  } //
+  // Sequence Signer methods
+  //
+  // getProvider returns a Web3Provider instance for the current chain. Note that this method
+  // and signer is bound to a particular chain to prevent misuse. If you'd like a provider
+  // for a specific chain, try getSender(chainId), or wallet.getProvider(chainId).
 
-class MuxMessageProvider {
-  constructor(...messageProviders) {
-    var _this = this;
 
-    this.messageProviders = void 0;
-    this.provider = void 0;
+  async getProvider(chainId) {
+    if (chainId) {
+      const currentChainId = await this.getChainId();
 
-    this.register = () => {
-      if (this.messageProviders.length === 1) {
-        this.provider = this.messageProviders[0];
-        this.provider.register();
-        return;
-      }
-
-      this.messageProviders.forEach(m => {
-        m.register();
-        m.once('open', () => {
-          // the first one to open is the winner, and others will be unregistered
-          if (!this.provider) {
-            this.provider = m; // unregister other providers
-
-            this.messageProviders.forEach(m => {
-              if (this.provider !== m) {
-                m.unregister();
-              }
-            });
-          }
-        });
-      });
-    };
-
-    this.unregister = () => {
-      this.messageProviders.forEach(m => m.unregister());
-      this.provider = undefined;
-    };
-
-    this.openWallet = (path, intent, networkId) => {
-      if (this.provider) {
-        this.provider.openWallet(path, intent, networkId);
-        return;
-      }
-
-      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);
-      }
-
-      throw new Error('impossible state, wallet must be opened first');
-    };
-
-    this.waitUntilOpened = async function () {
-      if (_this.provider) {
-        return _this.provider.waitUntilOpened();
+      if (currentChainId !== chainId) {
+        throw new Error(`signer is attempting to access chain ${chainId}, but is already bound to chain ${currentChainId}`);
       }
+    }
 
-      return Promise.race(_this.messageProviders.map(p => p.waitUntilOpened()));
-    };
+    return this.provider;
+  } // getSender returns a Web3Provider instance via the signer transport. Note: for our case
+  // the of sequence wallet, this will bring up the wallet window whenever using it, as the json-rpc
+  // requests are sent to the window transport. Therefore, for anything non-signing related
+  // you can write a higher-order JsonRpcRouter sender to route to the public provider endpoints
+  // as we do in the WalletProvider.
+  //
+  // This method is primarily utilized internally when routing requests to a particular chainId.
 
-    this.waitUntilConnected = async function () {
-      if (_this.provider) {
-        return _this.provider.waitUntilConnected();
-      }
 
-      throw new Error('impossible state, wallet must be opened first');
-    };
+  async getSender(chainId) {
+    if (!chainId || chainId && chainId === this.defaultChainId) {
+      return this.provider;
+    }
 
-    this.messageProviders = messageProviders;
-    this.provider = undefined;
-  }
+    if (!this._providers[chainId]) {
+      this._providers[chainId] = new Web3Provider(new JsonRpcSender(this.provider, chainId), chainId);
+    }
 
-  add(...messageProviders) {
-    this.messageProviders.push(...messageProviders);
+    return this._providers[chainId];
   }
 
-  closeWallet() {
-    if (this.provider) {
-      this.provider.closeWallet();
-    }
+  getRelayer(chainId) {
+    // TODO: JsonRpcRelayer ......? or, Web3Relayer.. or SequenceRelayer?
+    // sequence_estimateGasLimits
+    // sequence_gasRefundOptions
+    // sequence_getNonce
+    // sequence_relay
+    throw new Error('TODO');
   }
 
-  isOpened() {
-    if (this.provider) {
-      return this.provider.isOpened();
+  async getWalletContext() {
+    if (!this._context) {
+      this._context = await this.provider.send('sequence_getWalletContext', []);
     }
 
-    return false;
+    return this._context;
   }
 
-  isConnected() {
-    if (this.provider) {
-      return this.provider.isConnected();
-    }
-
-    return false;
+  async getWalletConfig(chainId) {
+    return await this.provider.send('sequence_getWalletConfig', [maybeChainId(chainId)], maybeChainId(chainId) || this.defaultChainId);
   }
 
-  on(event, fn) {
-    if (this.provider) {
-      this.provider.on(event, fn);
-      return;
-    }
-
-    this.messageProviders.forEach(m => {
-      m.on(event, fn);
-    });
+  async getWalletState(chainId) {
+    return await this.provider.send('sequence_getWalletState', [maybeChainId(chainId)], maybeChainId(chainId) || this.defaultChainId);
   }
 
-  once(event, fn) {
-    if (this.provider) {
-      this.provider.once(event, fn);
-      return;
+  async getNetworks() {
+    if (!this._networks) {
+      this._networks = await this.provider.send('sequence_getNetworks', []);
     }
 
-    this.messageProviders.forEach(m => {
-      m.once(event, fn);
-    });
+    return this._networks;
   }
 
-  emit(event, ...args) {
-    if (this.provider) {
-      return this.provider.emit(event, ...args);
-    }
+  async getSigners() {
+    const networks = await this.getNetworks();
+    const authChainId = networks.find(n => n.isAuthChain);
 
-    for (let i = 0; i < this.messageProviders.length; i++) {
-      this.messageProviders[i].emit(event, ...args);
+    if (!authChainId) {
+      throw new Error('authChainId could not be determined from network list');
     }
 
-    return true;
-  }
-
-  sendMessage(message) {
-    if (!message.idx || message.idx <= 0) {
-      throw new Error('message idx is empty');
-    }
+    const walletConfig = await this.getWalletConfig(authChainId);
 
-    if (this.provider) {
-      this.provider.sendMessage(message);
-    } else {
-      throw new Error('impossible state, wallet must be opened first');
+    if (!walletConfig || walletConfig.length === 0) {
+      throw new Error(`walletConfig returned zero results for authChainId {authChainId}`);
     }
-  }
 
-  handleMessage(message) {
-    if (this.provider) {
-      this.provider.handleMessage(message);
-      return;
-    }
+    return walletConfig[0].signers.map(s => s.address);
+  } // signMessage matches implementation from ethers JsonRpcSigner for compatibility, but with
+  // multi-chain support.
 
-    throw new Error('impossible state, wallet must be opened first');
-  }
 
-}
+  async signMessage(message, chainId, allSigners) {
+    const provider = await this.getSender(maybeChainId(chainId) || this.defaultChainId);
+    const data = typeof message === 'string' ? ethers.utils.toUtf8Bytes(message) : message;
+    const address = await this.getAddress(); // NOTE: as of ethers v5.5, it switched to using personal_sign, see
+    // https://github.com/ethers-io/ethers.js/pull/1542 and see
+    // https://github.com/WalletConnect/walletconnect-docs/issues/32 for additional info.
 
-let registeredWindowMessageProvider;
-class WindowMessageProvider extends BaseProviderTransport {
-  constructor(walletAppURL) {
-    super();
-    this.walletURL = void 0;
-    this.walletWindow = void 0;
+    return await provider.send('personal_sign', [ethers.utils.hexlify(data), address]);
+  } // signTypedData matches implementation from ethers JsonRpcSigner for compatibility, but with
+  // multi-chain support.
 
-    this.register = () => {
-      if (registeredWindowMessageProvider) {
-        // overriding the registered message provider
-        registeredWindowMessageProvider.unregister();
-        registeredWindowMessageProvider = this;
-      } // listen for incoming messages from wallet
 
+  async signTypedData(domain, types, message, chainId, allSigners) {
+    // Populate any ENS names (in-place)
+    // const populated = await ethers.utils._TypedDataEncoder.resolveNames(domain, types, message, (name: string) => {
+    //   return this.provider.resolveName(name)
+    // })
+    return await this.provider.send('eth_signTypedData_v4', [await this.getAddress(), ethers.utils._TypedDataEncoder.getPayload(domain, types, message)], maybeChainId(chainId) || this.defaultChainId);
+  } // sendTransaction matches implementation from ethers JsonRpcSigner for compatibility, but with
+  // multi-chain support.
 
-      window.addEventListener('message', this.onWindowEvent);
-      registeredWindowMessageProvider = this; // open heartbeat
 
-      this.on('open', () => {
-        // Heartbeat to track if window closed
-        const popup = this.walletWindow;
-        const interval = setInterval(() => {
-          if (popup && popup.closed) {
-            clearInterval(interval);
-            this.close();
+  async sendTransaction(transaction, chainId, allSigners) {
+    const provider = await this.getSender(maybeChainId(chainId) || this.defaultChainId);
+    const tx = this.sendUncheckedTransaction(transaction, chainId).then(hash => {
+      return ethers.utils.poll(() => {
+        return provider.getTransaction(hash).then(tx => {
+          if (tx === null) {
+            return undefined;
           }
-        }, 500);
-      }); // close clean up
 
-      this.on('close', () => {
-        if (this.walletWindow) {
-          this.walletWindow.close();
-          this.walletWindow = null;
-        }
+          return provider._wrapTransaction(tx, hash);
+        });
+      }, {
+        onceBlock: this.provider
+      }).catch(error => {
+        error.transactionHash = hash;
+        throw error;
       });
-      this._registered = true;
-    };
+    }); // @ts-ignore
 
-    this.unregister = () => {
-      this._registered = false;
-      this.closeWallet(); // disable message listener
+    return tx;
+  } // sendTransactionBatch is a convenience method to call sendTransaction in a batch format, allowing you to
+  // send multiple transaction as a single payload and just one on-chain transaction.
 
-      if (registeredWindowMessageProvider === this) {
-        registeredWindowMessageProvider = undefined;
-      }
 
-      window.removeEventListener('message', this.onWindowEvent); // clear event listeners
+  async sendTransactionBatch(transactions, chainId, allSigners) {
+    const batch = await resolveArrayProperties(transactions);
 
-      this.events.removeAllListeners();
-    };
+    if (!batch || batch.length === 0) {
+      throw new Error('cannot send empty batch');
+    } // sendTransactionBatch only accepts TransactionRequest, not TransactionResponses
 
-    this.openWallet = (path, intent, networkId) => {
-      if (this.walletWindow && this.isOpened()) {
-        // TODO: update the location of window to path
-        this.walletWindow.focus();
-        return;
-      } // Instantiate new walletURL for this call
-
-
-      const walletURL = new URL(this.walletURL.href);
-      const windowSessionParams = new WindowSessionParams();
 
-      if (path && path !== '') {
-        walletURL.pathname = path.toLowerCase();
-      } // Set session, intent and network id on walletURL
+    if (batch.find(v => v.wait !== undefined && v.wait !== null)) {
+      throw new Error('transaction request expected for sendTransactionBatch, transaction response found');
+    }
 
+    const tx = _extends({}, batch[0]);
 
-      this._init = InitState.NIL;
-      this._sessionId = `${performance.now()}`;
-      windowSessionParams.set('sid', this._sessionId);
+    if (batch.length > 1) {
+      tx.auxiliary = batch.splice(1);
+    }
 
-      if (intent) {
-        // for the window-transport, we eagerly/optimistically set the origin host
-        // when connecting to the wallet, however, this will be verified and enforced
-        // on the wallet-side, so if a dapp provides the wrong origin, it will be dropped.
-        if (intent.type === 'connect') {
-          if (!intent.options) intent.options = {}; // skip setting origin host if we're in an browser extension execution context
-          // allow origin that is passed in
+    return this.sendTransaction(tx, chainId, allSigners);
+  }
 
-          if (!isBrowserExtension()) {
-            intent.options.origin = window.location.origin;
-          }
-        } // encode intent as base6 url-encoded param
+  signTransactions(transaction, chainId, allSigners) {
+    transaction = shallowCopy(transaction); // TODO: transaction argument..? make sure to resolve any properties and serialize property before sending over
+    // the wire.. see sendUncheckedTransaction and resolveProperties
 
+    return this.provider.send('eth_signTransaction', [transaction], maybeChainId(chainId) || this.defaultChainId);
+  }
 
-        windowSessionParams.set('intent', base64EncodeObject(intent));
-      }
+  sendSignedTransactions(signedTxs, chainId) {
+    // sequence_relay
+    throw new Error('TODO');
+  } // updateConfig..
+  // NOTE: this is not supported by the remote wallet by default.
 
-      if (networkId) {
-        windowSessionParams.set('net', `${networkId}`);
-      } // Open popup window on center of the app window
 
+  async updateConfig(newConfig) {
+    // sequence_updateConfig
+    const [config, tx] = await this.provider.send('sequence_updateConfig', [newConfig], this.defaultChainId);
 
-      let windowSize;
-      let windowPos;
+    if (tx === null) {
+      return [config, undefined];
+    }
 
-      if (isBrowserExtension()) {
-        windowSize = [450, 750];
-        windowPos = [Math.abs(window.screen.width / 2 - windowSize[0] / 2), Math.abs(window.screen.height / 2 - windowSize[1] / 2)];
-      } else {
-        windowSize = [450, 750];
-        windowPos = [Math.abs(window.screenX + window.innerWidth / 2 - windowSize[0] / 2), Math.abs(window.screenY + window.innerHeight / 2 - windowSize[1] / 2)];
-      }
+    const provider = await this.getSender(this.defaultChainId);
+    return [config, provider._wrapTransaction(tx, tx.hash)];
+  } // publishConfig..
+  // NOTE: this is not supported by the remote wallet by default.
 
-      const windowFeatures = `toolbar=0,location=0,menubar=0,scrollbars=yes,status=yes` + `,width=${windowSize[0]},height=${windowSize[1]}` + `,left=${windowPos[0]},top=${windowPos[1]}`; // serialize params
 
-      walletURL.search = windowSessionParams.toString();
-      this.walletWindow = window.open(walletURL.href, 'sequence.app', windowFeatures); // TODO: move this somewhere else
-      // TODO: perhaps we trigger a .on('openTimeout') event..? maybe.. could help.
-      // Popup blocking detection and notice
-      // let warned = false
-      // const warnPopupBlocked = () => {
-      //   if (warned) return
-      //   warned = true
-      //   // alert('popup is blocked! hey yo') // NOTE: for debug purposes only
-      //   throw new Error('popup is blocked')
-      // }
-      // const popupCheck = setTimeout(() => {
-      //   if (!popup || popup.closed || typeof popup.closed === 'undefined') {
-      //     // popup is definitely blocked if we reach here.
-      //     warnPopupBlocked()
-      //   }
-      // }, 1000)
-      // const popupBlocked = popup === null || popup === undefined
-      // if (popupBlocked) {
-      //   warnPopupBlocked()
-      //   return
-      // }
-    };
+  async publishConfig() {
+    const provider = await this.getSender(this.defaultChainId);
+    const tx = await provider.send('sequence_publishConfig', []);
 
-    this.onWindowEvent = event => {
-      // Security check, ensure message is coming from wallet origin url
-      if (event.origin !== this.walletURL.origin) {
-        // Safetly can skip events not from the wallet
-        return;
-      }
+    if (tx === null) {
+      return undefined;
+    }
 
-      let message;
+    return provider._wrapTransaction(tx, tx.hash);
+  }
 
-      try {
-        message = JSON.parse(event.data);
-      } catch (err) {
-        // event is not a ProviderMessage JSON object, skip
-        return;
-      }
+  async isDeployed(chainId) {
+    const provider = await this.getSender(maybeChainId(chainId));
+    const walletCode = await provider.getCode(await this.getAddress());
+    return !!walletCode && walletCode !== '0x';
+  } //
+  // ethers JsonRpcSigner methods
+  //
 
-      if (!message) {
-        throw new Error('ProviderMessage object is empty');
-      } // handle message with base message provider
 
+  async _legacySignMessage(message, chainId, allSigners) {
+    const provider = await this.getSender(maybeChainId(chainId) || this.defaultChainId);
+    const data = typeof message === 'string' ? ethers.utils.toUtf8Bytes(message) : message;
+    const address = await this.getAddress(); // https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign
+    // NOTE: ethers since 5.5 has switched to using personal_sign, we should review, etc.
 
-      this.handleMessage(message);
-    };
+    return await provider.send('eth_sign', [address, ethers.utils.hexlify(data)]);
+  }
 
-    this.walletURL = new URL(walletAppURL);
+  async _signTypedData(domain, types, message, chainId, allSigners) {
+    return this.signTypedData(domain, types, message, chainId, allSigners);
   }
 
-  closeWallet() {
-    var _this$walletWindow;
+  async sendUncheckedTransaction(transaction, chainId) {
+    transaction = shallowCopy(transaction);
+    const fromAddress = this.getAddress(); // NOTE: we do not use provider estimation, and instead rely on our relayer to determine the gasLimit and gasPrice
+    //
+    // TODO: alternatively/one day, we could write a provider middleware to eth_estimateGas
+    // and send it to our relayer url instead for estimation..
+    //
+    // if (!transaction.gasLimit) {
+    //   const estimate = shallowCopy(transaction)
+    //   estimate.from = fromAddress
+    //   transaction.gasLimit = this.provider.estimateGas(estimate)
+    // }
 
-    this.close();
-    (_this$walletWindow = this.walletWindow) == null ? void 0 : _this$walletWindow.close();
-  } // onmessage, receives ProviderMessageResponse from the wallet post-message transport
+    const provider = await this.getSender(maybeChainId(chainId) || this.defaultChainId);
+    return resolveProperties({
+      tx: resolveProperties(transaction),
+      sender: await fromAddress
+    }).then(({
+      tx,
+      sender
+    }) => {
+      if (tx.from != null) {
+        if (ethers.utils.getAddress(tx.from) !== sender) {
+          // logger.throwArgumentError("from address mismatch", "transaction", transaction)
+          throw new Error(`from address mismatch for transaction ${transaction}`);
+        }
+      } else {
+        tx.from = sender;
+      }
 
+      const hexTx = hexlifyTransaction(tx);
+      return provider.send('eth_sendTransaction', [hexTx]).then(hash => {
+        return hash;
+      }, error => {
+        // return checkError("sendTransaction", error, hexTx)
+        throw new Error(`sendTransaction ${error}`);
+      });
+    });
+  }
 
-  sendMessage(message) {
-    if (!this.walletWindow) {
-      logger.warn('WindowMessageProvider: sendMessage failed as walletWindow is unavailable');
-      return;
-    }
+  connectUnchecked() {
+    throw new Error('connectUnchecked is unsupported');
+  }
 
-    const postedMessage = typeof message !== 'string' ? JSON.stringify(message) : message;
-    this.walletWindow.postMessage(postedMessage, this.walletURL.origin);
+  async unlock(password) {
+    const address = await this.getAddress();
+    return this.provider.send('personal_unlockAccount', [address, password, null]);
   }
 
-}
+} // NOTE: method has been copied + modified from ethers.js JsonRpcProvider
+// Convert an ethers.js transaction into a JSON-RPC transaction
 
-class WindowMessageHandler extends BaseWalletTransport {
-  constructor(walletRequestHandler) {
-    var _this;
+const allowedTransactionKeys = {
+  chainId: true,
+  data: true,
+  gasLimit: true,
+  gasPrice: true,
+  nonce: true,
+  to: true,
+  value: true,
+  from: true,
+  auxiliary: true,
+  expiration: true,
+  afterNonce: true,
+  delegateCall: true,
+  revertOnError: true
+};
 
-    super(walletRequestHandler);
-    _this = this;
-    this.parentWindow = void 0;
-    this._isPopup = false;
+const hexlifyTransaction = (transaction, allowExtra) => {
+  // Check only allowed properties are given
+  const allowed = shallowCopy(allowedTransactionKeys);
 
-    this.onWindowEvent = async function (event) {
-      if (!event.origin || event.origin === '') {
-        // skip same-origin or when event.origin is empty/undefined
-        return;
+  if (allowExtra) {
+    for (const key in allowExtra) {
+      if (allowExtra[key]) {
+        allowed[key] = true;
       }
+    }
+  }
 
-      if (_this.appOrigin && event.origin !== _this.appOrigin) {
-        // skip message as not from expected app origin
-        return;
-      } // Wallet always expects json-rpc request messages from a dapp
-
-
-      let request;
+  ethers.utils.checkProperties(transaction, allowed);
+  const result = {} // Some nodes (INFURA ropsten; INFURA mainnet is fine) do not like leading zeros.
+  ;
+  ['gasLimit', 'gasPrice', 'nonce', 'value'].forEach(key => {
+    if (!transaction[key]) {
+      return;
+    }
 
-      try {
-        request = JSON.parse(event.data);
-      } catch (err) {
-        // event is not a ProviderMessage JSON object, skip
-        return;
-      }
+    const value = ethers.utils.hexValue(transaction[key]);
 
-      logger.debug('RECEIVED MESSAGE', request); // Record event origin for valid init ack
+    if (key === 'gasLimit') {
+      key = 'gas';
+    }
 
-      if (_this._init !== InitState.OK && _this.isValidInitAck(request)) {
-        _this.appOrigin = event.origin;
-      }
+    result[key] = value;
+  });
+  ['from', 'to', 'data'].forEach(key => {
+    if (!transaction[key]) {
+      return;
+    }
 
-      if (_this._init === InitState.OK && (!_this.appOrigin || _this.appOrigin.length < 8)) {
-        // impossible state
-        logger.error('impossible state, init.OK and appOrigin required');
-        return;
-      } // Handle message via the base transport
+    result[key] = ethers.utils.hexlify(transaction[key]);
+  });
+  const auxiliary = transaction['auxiliary'];
 
+  if (auxiliary && auxiliary.length > 0) {
+    result['auxiliary'] = [];
+    auxiliary.forEach(a => {
+      result['auxiliary'].push(hexlifyTransaction(a));
+    });
+  }
 
-      _this.handleMessage(request);
-    };
+  return result;
+};
 
-    this.getWindowTransportSession = windowParams => {
-      const params = new WindowSessionParams(windowParams);
-      return {
-        sessionId: params.get('sid'),
-        networkId: params.get('net'),
-        intent: base64DecodeObject(params.get('intent'))
-      };
-    };
+const isValidSignature = async (address, digest, sig, provider, chainId, walletContext) => {
+  if (!chainId) {
+    var _await$provider$getNe;
 
-    this._init = InitState.NIL;
+    chainId = (_await$provider$getNe = await provider.getNetwork()) == null ? void 0 : _await$provider$getNe.chainId;
   }
 
-  register(windowHref) {
-    const isPopup = parent.window.opener !== null;
-    this._isPopup = isPopup;
-
-    if (isPopup !== true) {
-      return;
-    } // record open details (sessionId + default network) from the window url
-
+  if (!walletContext && Web3Provider.isSequenceProvider(provider)) {
+    walletContext = await provider.getSigner().getWalletContext();
+  }
 
-    const {
-      pathname,
-      search: rawParams
-    } = new URL(windowHref || window.location.href);
-    let session = this.getWindowTransportSession(rawParams); // provider should always include sid when opening a new window
+  return isValidSignature$1(address, digest, sig, provider, walletContext, chainId);
+};
+const isValidMessageSignature = async (address, message, signature, provider, chainId, walletContext) => {
+  const msgDigest = ethers.utils.arrayify(ethers.utils.hashMessage(message));
+  if (isValidEIP712Signature(address, msgDigest, signature) || isValidEthSignSignature(address, msgDigest, signature)) return true;
+  return isValidSignature(address, encodeMessageDigest(message), signature, provider, chainId, walletContext);
+};
+const isValidTypedDataSignature = (address, typedData, signature, provider, chainId, walletContext) => {
+  return isValidSignature(address, encodeTypedDataDigest(typedData), signature, provider, chainId, walletContext);
+};
+const recoverWalletConfig = async (address, digest, signature, chainId, walletContext) => {
+  const subDigest = packMessageData(address, chainId, digest);
+  const config = await recoverConfig(subDigest, signature);
 
-    const isNewWindowSession = !!session.sessionId; // attempt to restore previous session in the case of a redirect or window reload
+  if (walletContext) {
+    const recoveredWalletAddress = addressOf(config, walletContext);
 
-    if (!isNewWindowSession) {
-      session = this.getCachedTransportSession();
+    if (config.address && config.address !== recoveredWalletAddress) {
+      throw new Error('recovered address does not match the WalletConfig address, check the WalletContext');
+    } else {
+      config.address = recoveredWalletAddress;
     }
+  }
 
-    if (!session) {
-      logger.error('window session is undefined');
-      return;
-    } // record parent window instance for communication
+  return config;
+};
+const isBrowserExtension = () => window.location.protocol === 'chrome-extension:' || window.location.protocol === 'moz-extension:';
+/**
+ * Returns the status of a signer's wallet on given chain by checking wallet deployment and config status
+ *
+ * @param {Signer} signer
+ * @param {number} chainId
+ * @return {Promise<boolean>} Promise that returns true if the wallet is up to date, false otherwise
+ */
 
+const isWalletUpToDate = async (signer, chainId) => {
+  var _walletState$find;
 
-    this.parentWindow = parent.window.opener; // listen for window-transport requests
+  const walletState = await signer.getWalletState();
+  const networks = await signer.getNetworks();
+  const walletStateForRequiredChain = walletState.find(state => state.chainId === chainId);
 
-    window.addEventListener('message', this.onWindowEvent, false);
-    this._registered = true; // send open event to the app which opened us
+  if (!walletStateForRequiredChain) {
+    throw new Error(`WalletRequestHandler: could not find wallet state for chainId ${chainId}`);
+  }
 
-    this.open(session).then(opened => {
-      if (!opened) {
-        var _session;
+  const isDeployed = walletStateForRequiredChain.deployed;
 
-        const err = `failed to open to network ${(_session = session) == null ? void 0 : _session.networkId}`;
-        logger.error(err);
-        this.notifyClose({
-          message: err
-        });
-        window.close();
-      }
-    }).catch(e => {
-      var _session2;
+  if (!networks) {
+    throw new Error(`isWalletUpToDate util: could not get networks from signer`);
+  }
 
-      const err = `failed to open to network ${(_session2 = session) == null ? void 0 : _session2.networkId}, due to: ${e}`;
-      logger.error(err);
-      this.notifyClose({
-        message: err
-      });
-      window.close();
-    });
+  const authChain = networks.find(network => network.isAuthChain);
+
+  if (!authChain) {
+    throw new Error(`isWalletUpToDate util: could not get auth chain network information`);
   }
 
-  unregister() {
-    window.removeEventListener('message', this.onWindowEvent);
-    this._registered = false;
-  } // onmessage is called when (the wallet) receives request messages from the dapp
-  // over the window post-messaging transport
+  const authChainId = authChain.chainId;
+  const authChainConfig = (_walletState$find = walletState.find(state => state.chainId === authChainId)) == null ? void 0 : _walletState$find.config;
 
+  if (!authChainConfig) {
+    throw new Error(`isWalletUpToDate util: could not get auth chain config`);
+  }
 
-  // postMessage sends message to the dapp window
-  sendMessage(message) {
-    // prepare payload
-    const payload = JSON.stringify(message); // post-message to app.
-    // only for init requests, we send to '*' origin
+  const requiredChainConfig = walletStateForRequiredChain.config;
 
-    if (message.type === EventType.INIT) {
-      this.postMessage(payload, true);
-    } else {
-      this.postMessage(payload);
-    }
+  if (!requiredChainConfig) {
+    throw new Error(`isWalletUpToDate util: could not get config for chainId ${chainId}`);
   }
 
-  get isPopup() {
-    return this._isPopup;
+  const isUpToDate = isConfigEqual(authChainConfig, requiredChainConfig);
+  return isDeployed && isUpToDate;
+}; // window.localstorage helper
+
+class LocalStore {
+  constructor(key, def) {
+    this.def = def;
+    this.key = void 0;
+    this.key = key;
   }
 
-  postMessage(message, init = false) {
-    if (init !== true && this._init !== InitState.OK) {
-      logger.error('impossible state, should not be calling postMessage until inited');
-      return;
-    }
+  get() {
+    const val = window.localStorage.getItem(this.key);
 
-    if (init) {
-      // init message transmission to global target -- for 'init' payloads only
-      this.parentWindow.postMessage(message, '*');
-    } else {
-      // open message transmission
-      if (this.appOrigin && this.appOrigin.length > 4) {
-        // just above '.com'
-        this.parentWindow.postMessage(message, this.appOrigin);
-      } else {
-        logger.error('unable to postMessage as parentOrigin is invalid');
-      }
+    if (val === null) {
+      return this.def;
     }
-  }
 
-}
+    try {
+      return JSON.parse(val);
+    } catch (err) {
+      console.error(err);
+    }
 
-const SIGNER_READY_TIMEOUT = 10000;
-class WalletRequestHandler {
-  // 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
-  // a Signer value is the actually interface to a signed-in account
-  constructor(_signer, prompter, mainnetNetworks, testnetNetworks = []) {
-    var _this = this;
+    return;
+  }
 
-    this.signer = void 0;
-    this.signerReadyCallbacks = [];
-    this.prompter = void 0;
-    this.mainnetNetworks = void 0;
-    this.testnetNetworks = void 0;
-    this._openIntent = void 0;
-    this._connectOptions = void 0;
-    this._defaultNetworkId = void 0;
-    this._chainId = void 0;
-    this.events = new EventEmitter2();
+  set(val) {
+    val ? window.localStorage.setItem(this.key, JSON.stringify(val)) : window.localStorage.removeItem(this.key);
+  }
 
-    this.promptConnect = async function (options) {
-      if (!options && !_this._connectOptions) {
-        // this is an unexpected state and should not happen
-        throw new Error('prompter connect options are empty');
-      }
+  del() {
+    window.localStorage.removeItem(this.key);
+  }
 
-      if (!_this.prompter) {
-        // if prompter is null, we'll auto connect
-        return _this.connect(options);
-      }
+}
 
-      const promptConnectDetails = await _this.prompter.promptConnect(options || _this._connectOptions).catch(_ => {
-        return {
-          connected: false
-        };
-      });
-      const connectDetails = promptConnectDetails;
+const TRANSPORT_SESSION_LS_KEY = '@sequence.transportSession';
+class BaseWalletTransport {
+  // appOrigin identifies the dapp's origin which opened the app. A transport
+  // will auto-detect and set this value if it can. This is determined
+  // as the parent app/window which opened the wallet.
+  constructor(walletRequestHandler) {
+    var _this = this;
 
-      if (connectDetails.connected && !connectDetails.session) {
-        connectDetails.session = await _this.walletSession();
-      }
+    this.walletRequestHandler = void 0;
+    this._sessionId = void 0;
+    this._registered = void 0;
+    this._init = void 0;
+    this._initNonce = void 0;
+    this._initCallback = void 0;
+    this.appOrigin = void 0;
 
-      return promptConnectDetails;
+    this.sendAsync = async function (request, callback, chainId) {
+      throw new Error('abstract method');
     };
 
-    this.sendAsync = async function (request, callback, chainId) {
-      const response = {
-        jsonrpc: '2.0',
-        id: request.id,
-        result: null
-      };
-      await _this.getSigner();
+    this.handleMessage = async function (message) {
+      const request = message; // ensure initial handshake is complete before accepting
+      // other kinds of messages.
 
-      try {
-        // only allow public json rpc method to the provider when user is not logged in, aka signer is not set
-        if ((!_this.signer || _this.signer === null) && !permittedJsonRpcMethods.includes(request.method)) {
-          // throw new Error(`not logged in. ${request.method} is unavailable`)
-          throw ErrSignedInRequired;
-        } // wallet signer
-
-
-        const signer = _this.signer;
-        if (!signer) throw new Error('WalletRequestHandler: wallet signer is not configured'); // fetch the provider for the specific chain, or undefined will select defaultChain
-
-        const provider = await signer.getProvider(chainId);
-        if (!provider) throw new Error(`WalletRequestHandler: wallet provider is not configured for chainId ${chainId}`);
-
-        switch (request.method) {
-          case 'net_version':
-            {
-              const result = await provider.send('net_version', []);
-              response.result = result;
-              break;
-            }
-
-          case 'eth_chainId':
-            {
-              const result = await provider.send('eth_chainId', []);
-              response.result = result;
-              break;
-            }
-
-          case 'eth_accounts':
-            {
-              const walletAddress = await signer.getAddress();
-              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 '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:
-              // personal_sign: [data, address]
-              // eth_sign: [address, data]
-
-              if (request.method === 'personal_sign') {
-                const [data, address] = request.params;
-                message = data;
-              } else {
-                const [address, data] = request.params;
-                message = data;
-              }
-
-              let sig = ''; // TODO:
-              // if (process.env.TEST_MODE === 'true' && this.prompter === null) {
-
-              if (_this.prompter === null) {
-                // prompter is null, so we'll sign from here
-                sig = await signer.signMessage(ethers.utils.arrayify(message), chainId);
-              } else {
-                const promptResultForDeployment = await _this.handleConfirmWalletDeployPrompt(_this.prompter, signer, chainId);
-
-                if (promptResultForDeployment) {
-                  sig = await _this.prompter.promptSignMessage({
-                    chainId: chainId,
-                    message: message
-                  });
-                }
-              }
+      if (_this._init !== InitState.OK) {
+        if (request.type === EventType.INIT) {
+          if (_this.isValidInitAck(message)) {
+            // successful init
+            if (_this._initCallback) _this._initCallback();
+          } else {
+            // failed init
+            if (_this._initCallback) _this._initCallback('invalid init');
+            return;
+          }
+        }
 
-              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');
-              }
+        return;
+      } // ensure signer is ready to handle requests
+      // if (this.walletRequestHandler.getSigner() === undefined) {
+      //   await this.walletRequestHandler.signerReady()
+      // }
+      // handle request
 
-              break;
-            }
 
-          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;
+      switch (request.type) {
+        case EventType.OPEN:
+          {
+            if (_this._init !== InitState.OK) return;
+            const session = {
+              sessionId: request.data.sessionId,
+              intent: request.data.intent,
+              networkId: request.data.networkId
+            };
+            await _this.open(session);
+            return;
+          }
 
-              if (typeof typedDataObject === 'string') {
-                try {
-                  typedData = JSON.parse(typedDataObject);
-                } catch (e) {}
-              } else {
-                typedData = typedDataObject;
-              }
+        case EventType.CLOSE:
+          {
+            if (_this._init !== InitState.OK) return; // noop. just here to capture the message so event emitters may be notified
 
-              if (!typedData || !typedData.domain || !typedData.types || !typedData.message) {
-                throw new Error('invalid typedData object');
-              }
+            return;
+          }
 
-              let sig = '';
+        case EventType.MESSAGE:
+          {
+            const response = await _this.walletRequestHandler.sendMessageRequest(request);
 
-              if (_this.prompter === null) {
-                // prompter is null, so we'll sign from here
-                sig = await signer.signTypedData(typedData.domain, typedData.types, typedData.message, chainId);
-              } else {
-                const promptResultForDeployment = await _this.handleConfirmWalletDeployPrompt(_this.prompter, signer, chainId);
+            _this.sendMessage(response);
 
-                if (promptResultForDeployment) {
-                  sig = await _this.prompter.promptSignMessage({
-                    chainId: chainId,
-                    typedData: typedData
-                  });
-                }
-              }
+            if (response.data.error) ;
 
-              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');
-              }
+            return;
+          }
 
-              break;
-            }
+        default:
+          {
+            logger.error(`unexpected payload type ${request.type}`);
+          }
+      }
+    };
 
-          case 'eth_sendTransaction':
-            {
-              // https://eth.wiki/json-rpc/API#eth_sendtransaction
-              const [transactionParams] = request.params;
-              let txnHash = '';
+    this.sendMessageRequest = async function (message) {
+      return _this.walletRequestHandler.sendMessageRequest(message);
+    };
 
-              if (_this.prompter === null) {
-                // prompter is null, so we'll send from here
-                const txnResponse = await signer.sendTransaction(transactionParams, chainId);
-                txnHash = txnResponse.hash;
-              } else {
-                // prompt user to provide the response
-                txnHash = await _this.prompter.promptSendTransaction(transactionParams, chainId);
-              }
+    this.open = async function ({
+      sessionId,
+      intent,
+      networkId
+    }) {
+      if (sessionId) {
+        _this._sessionId = sanitizeNumberString(sessionId); // persist transport session in localstorage for restoring after redirect/reload
 
-              if (txnHash) {
-                response.result = txnHash;
-              } else {
-                // The user has declined the request when value is null
-                throw new Error('declined by user');
-              }
+        _this.saveTransportSession({
+          sessionId,
+          intent,
+          networkId
+        });
+      }
 
-              break;
-            }
+      _this.walletRequestHandler.setOpenIntent(intent); // init handshake for certain transports, before we can open the communication.
+      //
+      // for example, with the window-transport, we have to exchange messages to determine the
+      // origin host of the dapp.
 
-          case 'eth_signTransaction':
-            {
-              // https://eth.wiki/json-rpc/API#eth_signTransaction
-              const [transaction] = request.params;
-              const sender = ethers.utils.getAddress(transaction.from);
 
-              if (sender !== (await signer.getAddress())) {
-                throw new Error('sender address does not match wallet');
-              }
+      await _this.init(); // Prepare connect options from intent
 
-              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 bignumber values to hex strings
-                response.result = await signer.signTransactions(transaction, chainId);
-              } else {
-                response.result = await _this.prompter.promptSignTransaction(transaction, chainId);
-              }
+      if (intent && intent.type === 'connect' && intent.options) {
+        const connectOptions = intent.options;
+        const authorizeOptions = connectOptions; // overlapping types
+        // Sanity/integrity check the intent payload, and set authorization origin
+        // if its been determined as part of the init handshake from earlier.
 
-              break;
+        if (_this.appOrigin && authorizeOptions != null && authorizeOptions.origin) {
+          if (!isBrowserExtension()) {
+            if (authorizeOptions.origin !== _this.appOrigin) {
+              throw new Error('origin is invalid');
             }
+          }
+        } else if (!_this.appOrigin && authorizeOptions != null && authorizeOptions.origin) {
+          // ie. when we can't determine the origin in our transport, but dapp provides it to us.
+          // we just sanitize the origin host.
+          connectOptions.origin = sanitizeHost(authorizeOptions.origin);
+        } else if (_this.appOrigin) {
+          // ie. when we auto-determine the origin such as in window-transport
+          connectOptions.origin = _this.appOrigin;
+        }
 
-          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 (isSignedTransactions(request.params[0])) {
-                const txChainId = BigNumber.from(request.params[0].chainId).toNumber();
-                const tx = await (await signer.getRelayer(txChainId)).relay(request.params[0]);
-                response.result = (await tx).hash;
-              } else {
-                const tx = await provider.sendTransaction(request.params[0]);
-                response.result = tx.hash;
-              }
+        if (connectOptions.app) {
+          connectOptions.app = sanitizeAlphanumeric(connectOptions.app);
+        } // Set connect options on the walletRequestHandler as our primary
+        // wallet controller
 
-              break;
-            }
 
-          case 'eth_getTransactionCount':
-            {
-              const address = ethers.utils.getAddress(request.params[0]);
-              const tag = request.params[1];
-              const walletAddress = ethers.utils.getAddress(await signer.getAddress());
+        _this.walletRequestHandler.setConnectOptions(connectOptions);
 
-              if (address === walletAddress) {
-                const count = await signer.getTransactionCount(tag);
-                response.result = ethers.BigNumber.from(count).toHexString();
-              } else {
-                const count = await provider.getTransactionCount(address, tag);
-                response.result = ethers.BigNumber.from(count).toHexString();
-              }
+        if (connectOptions.networkId) {
+          networkId = connectOptions.networkId;
+        }
+      } else {
+        _this.walletRequestHandler.setConnectOptions(undefined);
+      } // ensure signer is ready
 
-              break;
-            }
 
-          case 'eth_blockNumber':
-            {
-              response.result = await provider.getBlockNumber();
-              break;
-            }
+      await _this.walletRequestHandler.getSigner(); // Notify open and proceed to prompt for connection if intended
 
-          case 'eth_getBlockByNumber':
-            {
-              response.result = await provider.getBlock(request.params[0]
-              /* , jsonRpcRequest.params[1] */
-              );
-              break;
-            }
+      if (!(await _this.walletRequestHandler.isSignedIn())) {
+        // open wallet without a specific connected chainId, as the user is not signed in
+        _this.notifyOpen({
+          sessionId: _this._sessionId
+        });
 
-          case 'eth_getBlockByHash':
-            {
-              response.result = await provider.getBlock(request.params[0]
-              /* , jsonRpcRequest.params[1] */
-              );
-              break;
-            }
+        return true;
+      } else {
+        // Set default network, in case of error chainId will be undefined or 0
+        let chainId = undefined;
 
-          case 'eth_getTransactionByHash':
-            {
-              response.result = await provider.getTransaction(request.params[0]);
-              break;
-            }
+        try {
+          if (networkId) {
+            chainId = await _this.walletRequestHandler.setDefaultNetwork(networkId, false);
+          } else {
+            chainId = await _this.walletRequestHandler.getChainId();
+          }
+        } catch (err) {
+          console.error(err);
+        } // Failed to set default network on open -- quit + close
 
-          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;
-            }
+        if (!chainId || chainId <= 0) {
+          _this.notifyOpen({
+            sessionId: _this._sessionId,
+            error: `failed to open wallet on network ${networkId}`
+          });
 
-          case 'eth_estimateGas':
-            {
-              const [transactionObject] = request.params;
-              response.result = await provider.estimateGas(transactionObject);
-              break;
-            }
+          return false;
+        } // prompt user with a connect request. the options will be used as previously set above.
+        // upon success, the walletRequestHandler will notify the dapp with the ConnectDetails.
+        // upon cancellation by user, the walletRequestHandler will throw an error
 
-          case 'eth_gasPrice':
-            {
-              const gasPrice = await provider.getGasPrice();
-              response.result = gasPrice.toHexString();
-              break;
-            }
-          // smart wallet method
 
-          case 'sequence_getWalletContext':
-            {
-              response.result = await signer.getWalletContext();
-              break;
-            }
-          // smart wallet method
+        if (intent && intent.type === 'connect') {
+          // notify wallet is opened, without session details
+          _this.notifyOpen({
+            sessionId: _this._sessionId
+          });
 
-          case 'sequence_getWalletConfig':
-            {
-              const [_chainId] = request.params;
-              response.result = await signer.getWalletConfig(_chainId);
-              break;
-            }
-          // smart wallet method
+          try {
+            const connectDetails = await _this.walletRequestHandler.promptConnect(intent.options);
 
-          case 'sequence_getWalletState':
-            {
-              const [_chainId2] = request.params;
-              response.result = await signer.getWalletState(_chainId2);
-              break;
+            if (connectDetails.connected) {
+              _this.walletRequestHandler.notifyConnect(connectDetails);
             }
-          // 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;
+          } catch (err) {
+            logger.warn('promptConnect not connected:', err);
+          } finally {
+            // auto-close by default, unless intent is to keep open
+            if (!intent.options || intent.options.keepWalletOpened !== true) {
+              _this.notifyClose();
             }
-          // 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)
+          }
+        } else {
+          // user is already connected, notify session details.
+          // TODO: in future, keep list if 'connected' dapps / sessions in the session
+          // controller, and only sync with allowed apps
+          _this.notifyOpen({
+            sessionId: _this._sessionId,
+            chainId: `${chainId}`,
+            session: await _this.walletRequestHandler.walletSession()
+          });
+        }
+      }
 
-              break;
-            }
-          // smart wallet method
+      return true;
+    };
 
-          case 'sequence_publishConfig':
-            {
-              throw new Error('sequence_publishConfig method is not allowed from a dapp');
-              break;
-            }
-          // relayer method
+    this.saveTransportSession = session => {
+      window.localStorage.setItem(TRANSPORT_SESSION_LS_KEY, JSON.stringify(session));
+    };
 
-          case 'sequence_estimateGasLimits':
-            {
-              // TODO
-              break;
-            }
-          // relayer method
+    this.getCachedTransportSession = () => {
+      const session = window.localStorage.getItem(TRANSPORT_SESSION_LS_KEY);
 
-          case 'sequence_gasRefundOptions':
-            {
-              // TODO
-              break;
-            }
-          // relayer method
+      try {
+        return session ? JSON.parse(session) : null;
+      } catch (err) {
+        console.error(`unable to parse transport session: ${session}`);
+        return null;
+      }
+    };
 
-          case 'sequence_getNonce':
-            {
-              // TODO
-              break;
-            }
-          // relayer method
+    this.walletRequestHandler = walletRequestHandler;
+    this._init = InitState.NIL;
+    this.walletRequestHandler.on('connect', connectDetails => {
+      if (!this.registered) return; // means user has logged in and wallet is connected to the app
 
-          case 'sequence_relay':
-            {
-              // TODO
-              break;
-            }
-          // set default network of wallet
+      this.notifyConnect(connectDetails);
+    });
+    this.walletRequestHandler.on('disconnect', error => {
+      if (!this.registered) return; // means user has logged out the app / disconnected wallet from the app
 
-          case 'sequence_setDefaultNetwork':
-            {
-              const [defaultNetworkId] = request.params;
+      this.notifyDisconnect(error);
+    });
+    this.walletRequestHandler.on('accountsChanged', accounts => {
+      if (!this.registered) return;
+      this.notifyAccountsChanged(accounts);
+    });
+    this.walletRequestHandler.on('networks', networks => {
+      if (!this.registered) return;
+      this.notifyNetworks(networks);
 
-              if (!defaultNetworkId) {
-                throw new Error('invalid request, method argument defaultNetworkId cannot be empty');
-              }
+      if (!networks || networks.length === 0) {
+        this.notifyChainChanged('0x0');
+      } else {
+        this.notifyChainChanged(ethers.utils.hexlify(networks[0].chainId));
+      }
+    });
+    this.walletRequestHandler.on('walletContext', walletContext => {
+      if (!this.registered || !walletContext) return;
+      this.notifyWalletContext(walletContext);
+    });
+    this.walletRequestHandler.on('close', error => {
+      if (!this.registered) return;
+      this.notifyClose(error);
+    });
+  }
 
-              const ok = await _this.setDefaultNetwork(defaultNetworkId);
+  get registered() {
+    return this._registered;
+  }
 
-              if (!ok) {
-                throw new Error(`unable to set default network ${defaultNetworkId}`);
-              }
+  register() {
+    throw new Error('abstract method');
+  }
 
-              response.result = await _this.getNetworks(true);
-              break;
-            }
+  unregister() {
+    throw new Error('abstract method');
+  }
 
-          default:
-            {
-              // NOTE: provider here will be chain-bound if chainId is provided
-              const providerResponse = await provider.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
+  sendMessage(message) {
+    throw new Error('abstract method');
+  }
 
-        response.result = null;
-        response.error = _extends({}, new Error(err), {
-          code: 4001
-        });
+  notifyOpen(openInfo) {
+    const {
+      chainId,
+      sessionId,
+      session,
+      error
+    } = openInfo;
+    this.sendMessage({
+      idx: -1,
+      type: EventType.OPEN,
+      data: {
+        chainId,
+        sessionId,
+        session,
+        error
       }
+    });
+  }
 
-      callback(undefined, response);
-    };
+  notifyClose(error) {
+    this.sendMessage({
+      idx: -1,
+      type: EventType.CLOSE,
+      data: error ? {
+        error
+      } : null
+    });
+  }
 
-    this.isSignedIn = async function () {
-      await _this.signerReady();
-      return !!_this.signer;
-    };
+  notifyConnect(connectDetails) {
+    this.sendMessage({
+      idx: -1,
+      type: EventType.CONNECT,
+      data: connectDetails
+    });
+  }
 
-    this.getSigner = async function () {
-      await _this.signerReady();
+  notifyDisconnect(error) {
+    this.sendMessage({
+      idx: -1,
+      type: EventType.DISCONNECT,
+      data: error ? {
+        error
+      } : null
+    });
+  }
 
-      if (_this.signer === undefined) {
-        throw new Error('signerReady failed resolve');
-      }
+  notifyAccountsChanged(accounts) {
+    this.sendMessage({
+      idx: -1,
+      type: EventType.ACCOUNTS_CHANGED,
+      data: accounts
+    });
+  }
 
-      return _this.signer;
-    };
+  notifyChainChanged(chainIdHex) {
+    this.sendMessage({
+      idx: -1,
+      type: EventType.CHAIN_CHANGED,
+      data: chainIdHex
+    });
+  }
 
-    this.signer = _signer;
-    this.prompter = prompter;
-    this.mainnetNetworks = mainnetNetworks;
-    this.testnetNetworks = testnetNetworks;
+  notifyNetworks(networks) {
+    this.sendMessage({
+      idx: -1,
+      type: EventType.NETWORKS,
+      data: networks
+    });
   }
 
-  async signIn(signer, options = {}) {
-    this.setSigner(signer);
-    const {
-      connect,
-      mainnetNetworks,
-      testnetNetworks,
-      defaultNetworkId
-    } = options;
+  notifyWalletContext(walletContext) {
+    this.sendMessage({
+      idx: -1,
+      type: EventType.WALLET_CONTEXT,
+      data: walletContext
+    });
+  }
 
-    if (mainnetNetworks && mainnetNetworks.length > 0) {
-      this.mainnetNetworks = mainnetNetworks;
+  isValidInitAck(message) {
+    if (this._init === InitState.OK) {
+      // we're already in init state, we shouldn't handle this message
+      logger.warn("isValidInitAck, already in init'd state, so inquiry is invalid.");
+      return false;
     }
 
-    if (testnetNetworks && testnetNetworks.length > 0) {
-      this.testnetNetworks = testnetNetworks;
+    if (message.type !== EventType.INIT) {
+      logger.warn('isValidInitAck, invalid message type, expecting init');
+      return false;
     }
 
-    if ((!this.mainnetNetworks || this.mainnetNetworks.length === 0) && (!this.testnetNetworks || this.testnetNetworks.length === 0)) {
-      throw new Error('signIn failed as network configuration is empty');
+    const {
+      sessionId,
+      nonce
+    } = message.data;
+
+    if (!sessionId || sessionId.length === 0 || !nonce || nonce.length === 0) {
+      logger.error('invalid init ack');
+      return false;
     }
 
-    const networkId = defaultNetworkId || this._defaultNetworkId;
+    if (sessionId !== this._sessionId || nonce !== this._initNonce) {
+      logger.error('invalid init ack match');
+      return false;
+    } // all checks pass, its true
 
-    if (networkId) {
-      if (!(await this.setDefaultNetwork(networkId, false))) {
-        throw new Error(`WalletRequestHandler setup unable to set defaultNetworkId ${networkId}`);
+
+    return true;
+  }
+
+  init() {
+    return new Promise((resolve, reject) => {
+      // avoid re-init`ing, or if there is a transport which doesn't require
+      // it, then it may set this._init to OK in its constructor.
+      if (this._init === InitState.OK) {
+        resolve();
+        return;
       }
-    } // Optionally, connect the dapp and wallet. In case connectOptions are provided, we will perform
-    // necessary auth request, and then notify the dapp of the 'connect' details.
-    //
-    // NOTE: if a user is signing into a dapp from a fresh state, and and auth request is made
-    // we don't trigger the promptConnect flow, as we consider the user just authenticated
-    // for this dapp, so its safe to authorize in the connect() method without the prompt.
-    //
-    // NOTE: signIn can optionally connect and notify dapp at this time for new signIn flows
 
+      if (this._init !== InitState.NIL || this._initCallback) {
+        reject('transport init is in progress');
+        return;
+      } // start init timeout, if we don't receive confirmation
+      // from provider within this amount of time, then we timeout
 
-    if (connect) {
-      const connectOptions = this._connectOptions;
-      const connectDetails = await this.connect(connectOptions);
-      this.notifyConnect(connectDetails);
 
-      if (!connectOptions || connectOptions.keepWalletOpened !== true) {
-        this.notifyClose();
-      }
-    }
-  }
+      const initTimeout = setTimeout(() => {
+        logger.warn('transport init timed out');
+
+        if (this._initCallback) {
+          this._initCallback('transport init timed out');
+        }
+      }, PROVIDER_OPEN_TIMEOUT / 2); // setup callback as we receive the init message async in the handleMessage function
+
+      this._initCallback = error => {
+        this._initCallback = undefined; // reset
+
+        clearTimeout(initTimeout);
+
+        if (error) {
+          reject(error);
+        } else {
+          this._init = InitState.OK;
+          resolve();
+        }
+      }; // send init request with random nonce to the provider, where we expect
+      // for the provider to echo it back to us as complete handshake
 
-  signOut() {
-    // signed out state
-    this.setSigner(null);
-  }
 
-  signerReset() {
-    // resetting signer puts the wallet in an uninitialized state, which requires the app to
-    // re-initiatize and set the signer either as "null" (ie. no signer) or "Signer" (ie. signed in).
-    this.signer = undefined;
+      this._initNonce = `${performance.now()}`;
+      this.sendMessage({
+        idx: -1,
+        type: EventType.INIT,
+        data: {
+          nonce: this._initNonce
+        }
+      });
+      this._init = InitState.SENT_NONCE; // NOTE: the promise will resolve in the _initCallback method
+      // which will be called from either handleMessage or the initTimeout
+    });
   }
 
-  signerReady(timeout = SIGNER_READY_TIMEOUT) {
-    return new Promise((resolve, reject) => {
-      if (this.signer !== undefined) {
-        resolve();
-      } else {
-        setTimeout(() => {
-          if (this.signer === undefined) {
-            this.signerReadyCallbacks = [];
-            reject(`signerReady timed out`);
-          }
-        }, timeout);
-        this.signerReadyCallbacks.push(resolve);
-      }
-    });
+}
+
+class ProxyMessageChannel {
+  constructor() {
+    this.app = void 0;
+    this.wallet = void 0;
+    const port1 = new ProxyMessageChannelPort();
+    const port2 = new ProxyMessageChannelPort();
+    port1.conn = port2;
+    port2.conn = port1;
+    this.app = port1;
+    this.wallet = port2;
   }
 
-  async connect(options) {
-    if (!this.signer) {
-      return {
-        connected: false,
-        chainId: '0x0',
-        error: 'unable to connect without signed in account'
-      };
-    }
+}
+class ProxyMessageChannelPort {
+  constructor() {
+    this.conn = void 0;
+    this.events = new EventEmitter2();
 
-    const connectDetails = {
-      connected: true,
-      chainId: ethers.utils.hexlify(await this.getChainId())
+    this.handleMessage = message => {
+      throw new Error('ProxyMessageChannelPort is not registered');
     };
 
-    if (options && options.authorize) {
-      // Perform ethauth eip712 request and construct the ConnectDetails response
-      // including the auth proof
-      const authOptions = {
-        app: options.app,
-        origin: options.origin,
-        expiry: options.expiry
-      }; // if (typeof(options.authorize) === 'object') {
-      //   authOptions = { ...authOptions, ...options.authorize }
-      // }
+    this.sendMessage = message => {
+      this.conn.handleMessage(message); // trigger events
 
-      try {
-        connectDetails.proof = await signAuthorization(this.signer, authOptions);
-      } catch (err) {
-        logger.warn(`connect, signAuthorization failed for options: ${JSON.stringify(options)}, due to: ${err.message}`);
-        return {
-          connected: false,
-          chainId: '0x0',
-          error: `signAuthorization failed: ${err.message}`
-        };
+      if (message.type === 'open') {
+        this.events.emit('open', message);
       }
-    } // Build session response for connect details
-
-
-    connectDetails.session = await this.walletSession();
-    return connectDetails;
-  }
-
-  // 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?
-        const responseMessage = _extends({}, message, {
-          data: response
-        }); // 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
 
+      if (message.type === 'close') {
+        this.events.emit('close', message);
+      }
 
-        resolve(responseMessage);
-      }, message.chainId);
-    });
-  } // sendAsync implements the JsonRpcHandler interface for sending JsonRpcRequests to the wallet
+      if (message.type === 'connect') {
+        this.events.emit('connect', message);
+      }
 
+      if (message.type === 'disconnect') {
+        this.events.emit('disconnect', message);
+      }
+    };
+  }
 
   on(event, fn) {
     this.events.on(event, fn);
@@ -2307,750 +2289,785 @@ class WalletRequestHandler {
     this.events.once(event, fn);
   }
 
-  async getAddress() {
-    if (!this.signer) {
-      return '';
-    } else {
-      return this.signer.getAddress();
-    }
-  }
+}
 
-  async getChainId() {
-    if (!this.signer) {
-      return 0;
-    } else {
-      if (this._chainId) return this._chainId; // memoized
+class ProxyMessageProvider extends BaseProviderTransport {
+  constructor(port) {
+    super();
+    this.port = void 0;
 
-      this._chainId = await this.signer.getChainId();
-      return this._chainId;
-    }
-  }
+    this.register = () => {
+      this.port.handleMessage = message => {
+        this.handleMessage(message);
+      };
 
-  get openIntent() {
-    return this._openIntent;
-  }
+      this.on('open', (...args) => {
+        this.port.events.emit('open', ...args);
+      });
+      this.on('close', (...args) => {
+        this.port.events.emit('close', ...args);
+      });
+      this.on('connect', (...args) => {
+        this.port.events.emit('connect', ...args);
+      });
+      this.on('disconnect', (...args) => {
+        this.port.events.emit('disconnect', ...args);
+      });
+      this._registered = true;
+    };
 
-  setOpenIntent(intent) {
-    this._openIntent = intent;
-  }
+    this.unregister = () => {
+      this._registered = false;
+      this.closeWallet();
+      this.events.removeAllListeners(); // @ts-ignore
 
-  get connectOptions() {
-    return this._connectOptions;
-  }
+      this.port.handleMessage = undefined;
+    };
 
-  setConnectOptions(options) {
-    this._connectOptions = options;
-  }
+    this.openWallet = (path, intent, networkId) => {
+      if (this.state === OpenState.CLOSED) {
+        this.state = OpenState.OPENING;
+        const sessionId = `${performance.now()}`;
+        this._sessionId = sessionId;
+        this.sendMessage({
+          idx: -1,
+          type: EventType.OPEN,
+          data: {
+            path,
+            intent,
+            networkId,
+            sessionId
+          }
+        });
+      }
+    };
 
-  get defaultNetworkId() {
-    return this._defaultNetworkId;
-  }
+    this.state = OpenState.CLOSED;
+    this.port = port;
 
-  async setDefaultNetwork(chainId, notifyNetworks = true) {
-    if (!chainId) return undefined;
-    this._defaultNetworkId = chainId;
-    this._chainId = undefined;
+    if (!port) {
+      throw new Error('port argument cannot be empty');
+    } // disable init handshake for proxy-transport, we set it to OK, to
+    // consider it in completed state.
 
-    if (this.signer && this.signer.setNetworks) {
-      const defaultChainId = this.signer.setNetworks(this.mainnetNetworks, this.testnetNetworks, chainId);
 
-      if (defaultChainId && notifyNetworks) {
-        await this.notifyNetworks();
-      }
+    this._init = InitState.OK;
+  }
 
-      return defaultChainId;
-    } else {
-      return undefined;
-    }
+  closeWallet() {
+    this.sendMessage({
+      idx: -1,
+      type: EventType.CLOSE,
+      data: null
+    });
+    this.close();
   }
 
-  async getNetworks(jsonRpcResponse) {
-    if (!this.signer) {
-      logger.warn('signer not set: getNetworks is returning an empty list');
-      return [];
+  sendMessage(message) {
+    if (!message.idx) {
+      throw new Error('message idx is empty');
     }
 
-    const networks = await this.signer.getNetworks();
-
-    if (jsonRpcResponse) {
-      // omit provider and relayer objects as they are not serializable
-      return networks.map(n => {
-        const network = _extends({}, n);
-
-        network.provider = undefined;
-        network.relayer = undefined;
-        return network;
-      });
-    } else {
-      return networks;
-    }
+    this.port.sendMessage(message);
   }
 
-  async walletSession() {
-    return !this.signer ? undefined : {
-      walletContext: await this.signer.getWalletContext(),
-      accountAddress: await this.signer.getAddress(),
-      networks: await this.getNetworks(true)
-    };
+}
+
+class ProxyMessageHandler extends BaseWalletTransport {
+  constructor(walletRequestHandler, port) {
+    super(walletRequestHandler);
+    this.port = void 0;
+    this.port = port;
+    this._init = InitState.OK;
   }
 
-  notifyConnect(connectDetails) {
-    var _connectDetails$sessi;
+  register() {
+    this.port.handleMessage = message => {
+      this.handleMessage(message);
+    };
 
-    this.events.emit('connect', connectDetails);
+    this._registered = true;
+  } // note: we can't decide whether to restore the session within register(), because session info is
+  // received asyncronously via EventType.OPEN after register() is executed.
+  // And in the case of a redirect/reload, EventType.OPEN is not sent at all, 
+  // because the wallet is already open.
+  //
+  // call this method from wallet redirect hander when a session restore is needed
 
-    if ((_connectDetails$sessi = connectDetails.session) != null && _connectDetails$sessi.accountAddress) {
-      var _connectDetails$sessi2;
 
-      this.events.emit('accountsChanged', [(_connectDetails$sessi2 = connectDetails.session) == null ? void 0 : _connectDetails$sessi2.accountAddress]);
+  restoreSession() {
+    const cachedSession = this.getCachedTransportSession();
+
+    if (cachedSession) {
+      this.open(cachedSession);
     }
   }
 
-  notifyDisconnect() {
-    this.events.emit('accountsChanged', []);
-    this.events.emit('networks', []);
-    this.events.emit('disconnect');
+  unregister() {
+    // @ts-ignore
+    this.port.handleMessage = undefined;
+    this._registered = false;
   }
 
-  async notifyNetworks(networks) {
-    const n = networks || (await this.getNetworks(true));
-    this.events.emit('networks', n);
-
-    if (n && n.length > 0) {
-      this.events.emit('chainChanged', ethers.utils.hexlify(n[0].chainId));
-    } else {
-      this.events.emit('chainChanged', '0x0');
-    }
+  sendMessage(message) {
+    this.port.sendMessage(message);
   }
 
-  async notifyWalletContext() {
-    if (!this.signer) {
-      logger.warn('signer not set: skipping to notify wallet context');
-      return;
-    }
+}
 
-    const walletContext = await this.signer.getWalletContext();
-    this.events.emit('walletContext', walletContext);
-  }
+class MuxMessageProvider {
+  constructor(...messageProviders) {
+    var _this = this;
 
-  notifyClose(error) {
-    this.events.emit('close', error);
-  }
+    this.messageProviders = void 0;
+    this.provider = void 0;
 
-  setSigner(signer) {
-    this.signer = signer;
+    this.register = () => {
+      if (this.messageProviders.length === 1) {
+        this.provider = this.messageProviders[0];
+        this.provider.register();
+        return;
+      }
 
-    if (signer !== undefined) {
-      for (let i = 0; i < this.signerReadyCallbacks.length; i++) {
-        this.signerReadyCallbacks[i]();
+      this.messageProviders.forEach(m => {
+        m.register();
+        m.once('open', () => {
+          // the first one to open is the winner, and others will be unregistered
+          if (!this.provider) {
+            this.provider = m; // unregister other providers
+
+            this.messageProviders.forEach(m => {
+              if (this.provider !== m) {
+                m.unregister();
+              }
+            });
+          }
+        });
+      });
+    };
+
+    this.unregister = () => {
+      this.messageProviders.forEach(m => m.unregister());
+      this.provider = undefined;
+    };
+
+    this.openWallet = (path, intent, networkId) => {
+      if (this.provider) {
+        this.provider.openWallet(path, intent, networkId);
+        return;
       }
 
-      this.signerReadyCallbacks = [];
-    }
-  }
+      this.messageProviders.forEach(m => m.openWallet(path, intent, networkId));
+    };
 
-  async handleConfirmWalletDeployPrompt(prompter, signer, chainId) {
-    // check if wallet is deployed and up to date, if not, prompt user to deploy
-    // if no chainId is provided, we'll assume the wallet is auth chain wallet and is up to date
-    if (!chainId) {
-      return true;
-    }
+    this.sendAsync = async function (request, callback, chainId) {
+      if (_this.provider) {
+        _this.provider.sendAsync(request, callback, chainId);
 
-    const isUpToDate = await isWalletUpToDate(signer, chainId);
+        return;
+      }
 
-    if (isUpToDate) {
-      return true;
-    }
+      throw new Error('impossible state, wallet must be opened first');
+    };
 
-    const promptResult = await prompter.promptConfirmWalletDeploy(chainId); // if client returned true, check again to make sure wallet is deployed and up to date
+    this.sendMessageRequest = async function (message) {
+      if (_this.provider) {
+        return _this.provider.sendMessageRequest(message);
+      }
 
-    if (promptResult) {
-      const isPromptResultCorrect = await isWalletUpToDate(signer, chainId);
+      throw new Error('impossible state, wallet must be opened first');
+    };
 
-      if (!isPromptResultCorrect) {
-        logger.error('WalletRequestHandler: result for promptConfirmWalletDeploy is not correct');
-        return false;
-      } else {
-        return true;
+    this.waitUntilOpened = async function () {
+      if (_this.provider) {
+        return _this.provider.waitUntilOpened();
       }
-    }
 
-    return false;
-  }
+      return Promise.race(_this.messageProviders.map(p => p.waitUntilOpened()));
+    };
 
-}
-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'];
+    this.waitUntilConnected = async function () {
+      if (_this.provider) {
+        return _this.provider.waitUntilConnected();
+      }
 
-const CHANNEL_ID = 'sequence-extension-message-handler';
-class ExtensionMessageHandler extends BaseWalletTransport {
-  constructor(walletRequestHandler, runtime) {
-    super(walletRequestHandler);
-    this.runtime = runtime;
-    this.port = void 0;
-    this._init = InitState.OK;
+      throw new Error('impossible state, wallet must be opened first');
+    };
+
+    this.messageProviders = messageProviders;
+    this.provider = undefined;
   }
 
-  register() {
-    this._registered = true;
-    this.port = this.runtime.connect({
-      name: CHANNEL_ID
-    });
+  add(...messageProviders) {
+    this.messageProviders.push(...messageProviders);
   }
 
-  sendMessage(message) {
-    console.log('[ExtensionMessageHandler send]', message);
-    this.port.postMessage(message);
+  closeWallet() {
+    if (this.provider) {
+      this.provider.closeWallet();
+    }
   }
 
-}
+  isOpened() {
+    if (this.provider) {
+      return this.provider.isOpened();
+    }
 
-class ExtensionMessageProvider extends BaseProviderTransport {
-  constructor(runtime) {
-    super();
+    return false;
+  }
 
-    this.register = () => {
-      this._registered = true;
-    };
+  isConnected() {
+    if (this.provider) {
+      return this.provider.isConnected();
+    }
 
-    runtime.onConnect.addListener(port => {
-      if (port.name === CHANNEL_ID) {
-        this._init = InitState.OK;
-        port.onMessage.addListener(message => {
-          this.handleMessage(message);
-        });
-      }
-    });
+    return false;
   }
 
-  sendMessage(message) {//noop
-  }
+  on(event, fn) {
+    if (this.provider) {
+      this.provider.on(event, fn);
+      return;
+    }
 
-  unregister() {//noop
+    this.messageProviders.forEach(m => {
+      m.on(event, fn);
+    });
   }
 
-  openWallet(path, intent, networkId) {//noop
+  once(event, fn) {
+    if (this.provider) {
+      this.provider.once(event, fn);
+      return;
+    }
+
+    this.messageProviders.forEach(m => {
+      m.once(event, fn);
+    });
   }
 
-  closeWallet() {//noop
+  emit(event, ...args) {
+    if (this.provider) {
+      return this.provider.emit(event, ...args);
+    }
+
+    for (let i = 0; i < this.messageProviders.length; i++) {
+      this.messageProviders[i].emit(event, ...args);
+    }
+
+    return true;
   }
 
-}
+  sendMessage(message) {
+    if (!message.idx || message.idx <= 0) {
+      throw new Error('message idx is empty');
+    }
 
-// to be used on injected window.ethereum EIP1193 proxy
-class BaseInjectedTransport extends EventEmitter2 {
-  constructor(stream) {
-    var _this;
+    if (this.provider) {
+      this.provider.sendMessage(message);
+    } else {
+      throw new Error('impossible state, wallet must be opened first');
+    }
+  }
 
-    super();
-    _this = this;
-    this.stream = stream;
-    this.responseCallbacks = new Map();
-    this._messageIdx = 0;
+  handleMessage(message) {
+    if (this.provider) {
+      this.provider.handleMessage(message);
+      return;
+    }
+
+    throw new Error('impossible state, wallet must be opened first');
+  }
 
-    this.nextMessageIdx = () => ++this._messageIdx;
+}
 
-    this.handleMessage = message => {
-      if (!message.type || !message.data) {
-        return;
-      }
+let registeredWindowMessageProvider;
+class WindowMessageProvider extends BaseProviderTransport {
+  constructor(walletAppURL) {
+    super();
+    this.walletURL = void 0;
+    this.walletWindow = void 0;
 
-      console.log('[received message]', message);
-      const requestIdx = message.idx;
-      const responseCallback = this.responseCallbacks.get(requestIdx);
+    this.register = () => {
+      if (registeredWindowMessageProvider) {
+        // overriding the registered message provider
+        registeredWindowMessageProvider.unregister();
+        registeredWindowMessageProvider = this;
+      } // listen for incoming messages from wallet
 
-      if (requestIdx) {
-        this.responseCallbacks.delete(requestIdx);
-      }
 
-      switch (message.type) {
-        case EventType.MESSAGE:
-          if (responseCallback) {
-            this.emit(EventType.MESSAGE, message);
-            responseCallback(message.data.error, message);
-          } else {
-            // NOTE: this would occur if 'idx' isn't set, which should never happen
-            // or when we register two handler, or duplicate messages with the same idx are sent,
-            // all of which should be prevented prior to getting to this point
-            throw new Error('impossible state');
+      window.addEventListener('message', this.onWindowEvent);
+      registeredWindowMessageProvider = this; // open heartbeat
+
+      this.on('open', () => {
+        // Heartbeat to track if window closed
+        const popup = this.walletWindow;
+        const interval = setInterval(() => {
+          if (popup && popup.closed) {
+            clearInterval(interval);
+            this.close();
           }
+        }, 500);
+      }); // close clean up
 
-          break;
+      this.on('close', () => {
+        if (this.walletWindow) {
+          this.walletWindow.close();
+          this.walletWindow = null;
+        }
+      });
+      this._registered = true;
+    };
 
-        case EventType.DISCONNECT:
-        case EventType.ACCOUNTS_CHANGED:
-        case EventType.CHAIN_CHANGED:
-          this.emit(message.type, message.data);
-          break;
+    this.unregister = () => {
+      this._registered = false;
+      this.closeWallet(); // disable message listener
 
-        default:
-          console.error('unknown message type', message);
-          break;
+      if (registeredWindowMessageProvider === this) {
+        registeredWindowMessageProvider = undefined;
       }
+
+      window.removeEventListener('message', this.onWindowEvent); // clear event listeners
+
+      this.events.removeAllListeners();
     };
 
-    this.sendMessageRequest = async function (message) {
-      return new Promise((resolve, reject) => {
-        if (!message.idx || message.idx <= 0) {
-          reject(new Error('message idx not set'));
-        }
+    this.openWallet = (path, intent, networkId) => {
+      if (this.walletWindow && this.isOpened()) {
+        // TODO: update the location of window to path
+        this.walletWindow.focus();
+        return;
+      } // Instantiate new walletURL for this call
 
-        const responseCallback = (error, response) => {
-          if (error) {
-            reject(error);
-          } else if (response) {
-            resolve(response);
-          } else {
-            throw new Error('no valid response to return');
-          }
-        };
 
-        const {
-          idx
-        } = message;
+      const walletURL = new URL(this.walletURL.href);
+      const windowSessionParams = new WindowSessionParams();
 
-        if (!_this.responseCallbacks.get(idx)) {
-          _this.responseCallbacks.set(idx, responseCallback);
-        } else {
-          reject(new Error('duplicate message idx, should never happen'));
-        }
+      if (path && path !== '') {
+        walletURL.pathname = path.toLowerCase();
+      } // Set session, intent and network id on walletURL
 
-        _this.sendMessage(message);
-      });
-    };
 
-    this.stream.on('data', this.handleMessage);
-  }
+      this._init = InitState.NIL;
+      this._sessionId = `${performance.now()}`;
+      windowSessionParams.set('sid', this._sessionId);
 
-  sendMessage(message) {
-    if (!this.stream.writable) {
-      console.error('window post message stream is not writable');
-    }
+      if (intent) {
+        // for the window-transport, we eagerly/optimistically set the origin host
+        // when connecting to the wallet, however, this will be verified and enforced
+        // on the wallet-side, so if a dapp provides the wrong origin, it will be dropped.
+        if (intent.type === 'connect') {
+          if (!intent.options) intent.options = {}; // skip setting origin host if we're in an browser extension execution context
+          // allow origin that is passed in
 
-    this.stream.write(message);
-  }
+          if (!isBrowserExtension()) {
+            intent.options.origin = window.location.origin;
+          }
+        } // encode intent as base6 url-encoded param
 
-}
 
-class Web3Provider extends Web3Provider$1 {
-  static isSequenceProvider(cand) {
-    return isSequenceProvider(cand);
-  }
+        windowSessionParams.set('intent', base64EncodeObject(intent));
+      }
 
-  constructor(provider, defaultChainId) {
-    const sender = new JsonRpcSender(provider, maybeChainId(defaultChainId));
-    provider = sender;
-    super(provider, 'any');
-    this._sender = void 0;
-    this._isSequenceProvider = void 0;
-    this._defaultChainId = void 0;
-    this._sender = sender;
-    this._isSequenceProvider = true;
-    this._defaultChainId = maybeChainId(defaultChainId);
-  }
+      if (networkId) {
+        windowSessionParams.set('net', `${networkId}`);
+      } // Open popup window on center of the app window
 
-  sendAsync(request, callback, chainId) {
-    this._sender.sendAsync(request, callback, chainId);
-  }
 
-  send(method, params, chainId) {
-    return this._sender.send(method, params, chainId);
-  }
+      let windowSize;
+      let windowPos;
 
-  getSigner() {
-    return new Web3Signer(this, this._defaultChainId);
-  }
+      if (isBrowserExtension()) {
+        windowSize = [450, 750];
+        windowPos = [Math.abs(window.screen.width / 2 - windowSize[0] / 2), Math.abs(window.screen.height / 2 - windowSize[1] / 2)];
+      } else {
+        windowSize = [450, 750];
+        windowPos = [Math.abs(window.screenX + window.innerWidth / 2 - windowSize[0] / 2), Math.abs(window.screenY + window.innerHeight / 2 - windowSize[1] / 2)];
+      }
 
-  async getChainId() {
-    const result = await this.send('eth_chainId', []);
-    const chainId = ethers.BigNumber.from(result).toNumber();
+      const windowFeatures = `toolbar=0,location=0,menubar=0,scrollbars=yes,status=yes` + `,width=${windowSize[0]},height=${windowSize[1]}` + `,left=${windowPos[0]},top=${windowPos[1]}`; // serialize params
 
-    if (this._defaultChainId && this._defaultChainId !== chainId) {
-      throw new Error(`provider chainId (${chainId}) does not match provider-bound chainId ${this._defaultChainId}`);
-    }
+      walletURL.search = windowSessionParams.toString();
+      this.walletWindow = window.open(walletURL.href, 'sequence.app', windowFeatures); // TODO: move this somewhere else
+      // TODO: perhaps we trigger a .on('openTimeout') event..? maybe.. could help.
+      // Popup blocking detection and notice
+      // let warned = false
+      // const warnPopupBlocked = () => {
+      //   if (warned) return
+      //   warned = true
+      //   // alert('popup is blocked! hey yo') // NOTE: for debug purposes only
+      //   throw new Error('popup is blocked')
+      // }
+      // const popupCheck = setTimeout(() => {
+      //   if (!popup || popup.closed || typeof popup.closed === 'undefined') {
+      //     // popup is definitely blocked if we reach here.
+      //     warnPopupBlocked()
+      //   }
+      // }, 1000)
+      // const popupBlocked = popup === null || popup === undefined
+      // if (popupBlocked) {
+      //   warnPopupBlocked()
+      //   return
+      // }
+    };
 
-    return chainId;
-  }
+    this.onWindowEvent = event => {
+      // Security check, ensure message is coming from wallet origin url
+      if (event.origin !== this.walletURL.origin) {
+        // Safetly can skip events not from the wallet
+        return;
+      }
 
-}
-function isSequenceProvider(provider) {
-  const cand = provider;
-  return cand && cand.send !== undefined && cand._isSequenceProvider === true;
-}
-class LocalWeb3Provider extends Web3Provider {
-  constructor(signer, networks) {
-    const walletRequestHandler = new WalletRequestHandler(signer, null, networks || []);
-    super(walletRequestHandler);
-  }
+      let message;
 
-}
-class Web3Signer extends Signer {
-  constructor(provider, defaultChainId) {
-    super();
-    this.provider = void 0;
-    this.defaultChainId = void 0;
-    this._address = void 0;
-    this._index = void 0;
-    this._context = void 0;
-    this._networks = void 0;
-    this._providers = {};
-    this.provider = provider;
-    this.defaultChainId = defaultChainId;
-  } // memoized
+      try {
+        message = JSON.parse(event.data);
+      } catch (err) {
+        // event is not a ProviderMessage JSON object, skip
+        return;
+      }
+
+      if (!message) {
+        throw new Error('ProviderMessage object is empty');
+      } // handle message with base message provider
 
 
-  //
-  // ethers AbstractSigner methods
-  //
-  async getAddress() {
-    if (this._address) return this._address;
-    const accounts = await this.provider.send('eth_accounts', []);
-    this._address = accounts[0];
-    this._index = 0;
-    return ethers.utils.getAddress(this._address);
+      this.handleMessage(message);
+    };
+
+    this.walletURL = new URL(walletAppURL);
   }
 
-  signTransaction(transaction) {
-    // TODO .. since ethers isn't using this method, perhaps we will?
-    throw new Error('signTransaction is unsupported, use signTransactions instead');
+  closeWallet() {
+    var _this$walletWindow;
+
+    this.close();
+    (_this$walletWindow = this.walletWindow) == null ? void 0 : _this$walletWindow.close();
+  } // onmessage, receives ProviderMessageResponse from the wallet post-message transport
+
+
+  sendMessage(message) {
+    if (!this.walletWindow) {
+      logger.warn('WindowMessageProvider: sendMessage failed as walletWindow is unavailable');
+      return;
+    }
+
+    const postedMessage = typeof message !== 'string' ? JSON.stringify(message) : message;
+    this.walletWindow.postMessage(postedMessage, this.walletURL.origin);
   }
 
-  connect(provider) {
-    throw new Error('unsupported: cannot alter JSON-RPC Signer connection');
-  } //
-  // Sequence Signer methods
-  //
-  // getProvider returns a Web3Provider instance for the current chain. Note that this method
-  // and signer is bound to a particular chain to prevent misuse. If you'd like a provider
-  // for a specific chain, try getSender(chainId), or wallet.getProvider(chainId).
+}
 
+class WindowMessageHandler extends BaseWalletTransport {
+  constructor(walletRequestHandler) {
+    var _this;
 
-  async getProvider(chainId) {
-    if (chainId) {
-      const currentChainId = await this.getChainId();
+    super(walletRequestHandler);
+    _this = this;
+    this.parentWindow = void 0;
+    this._isPopup = false;
 
-      if (currentChainId !== chainId) {
-        throw new Error(`signer is attempting to access chain ${chainId}, but is already bound to chain ${currentChainId}`);
+    this.onWindowEvent = async function (event) {
+      if (!event.origin || event.origin === '') {
+        // skip same-origin or when event.origin is empty/undefined
+        return;
       }
-    }
-
-    return this.provider;
-  } // getSender returns a Web3Provider instance via the signer transport. Note: for our case
-  // the of sequence wallet, this will bring up the wallet window whenever using it, as the json-rpc
-  // requests are sent to the window transport. Therefore, for anything non-signing related
-  // you can write a higher-order JsonRpcRouter sender to route to the public provider endpoints
-  // as we do in the WalletProvider.
-  //
-  // This method is primarily utilized internally when routing requests to a particular chainId.
 
+      if (_this.appOrigin && event.origin !== _this.appOrigin) {
+        // skip message as not from expected app origin
+        return;
+      } // Wallet always expects json-rpc request messages from a dapp
 
-  async getSender(chainId) {
-    if (!chainId || chainId && chainId === this.defaultChainId) {
-      return this.provider;
-    }
 
-    if (!this._providers[chainId]) {
-      this._providers[chainId] = new Web3Provider(new JsonRpcSender(this.provider, chainId), chainId);
-    }
+      let request;
 
-    return this._providers[chainId];
-  }
+      try {
+        request = JSON.parse(event.data);
+      } catch (err) {
+        // event is not a ProviderMessage JSON object, skip
+        return;
+      }
 
-  getRelayer(chainId) {
-    // TODO: JsonRpcRelayer ......? or, Web3Relayer.. or SequenceRelayer?
-    // sequence_estimateGasLimits
-    // sequence_gasRefundOptions
-    // sequence_getNonce
-    // sequence_relay
-    throw new Error('TODO');
-  }
+      logger.debug('RECEIVED MESSAGE', request); // Record event origin for valid init ack
 
-  async getWalletContext() {
-    if (!this._context) {
-      this._context = await this.provider.send('sequence_getWalletContext', []);
-    }
+      if (_this._init !== InitState.OK && _this.isValidInitAck(request)) {
+        _this.appOrigin = event.origin;
+      }
 
-    return this._context;
-  }
+      if (_this._init === InitState.OK && (!_this.appOrigin || _this.appOrigin.length < 8)) {
+        // impossible state
+        logger.error('impossible state, init.OK and appOrigin required');
+        return;
+      } // Handle message via the base transport
 
-  async getWalletConfig(chainId) {
-    return await this.provider.send('sequence_getWalletConfig', [maybeChainId(chainId)], maybeChainId(chainId) || this.defaultChainId);
-  }
 
-  async getWalletState(chainId) {
-    return await this.provider.send('sequence_getWalletState', [maybeChainId(chainId)], maybeChainId(chainId) || this.defaultChainId);
-  }
+      _this.handleMessage(request);
+    };
 
-  async getNetworks() {
-    if (!this._networks) {
-      this._networks = await this.provider.send('sequence_getNetworks', []);
-    }
+    this.getWindowTransportSession = windowParams => {
+      const params = new WindowSessionParams(windowParams);
+      return {
+        sessionId: params.get('sid'),
+        networkId: params.get('net'),
+        intent: base64DecodeObject(params.get('intent'))
+      };
+    };
 
-    return this._networks;
+    this._init = InitState.NIL;
   }
 
-  async getSigners() {
-    const networks = await this.getNetworks();
-    const authChainId = networks.find(n => n.isAuthChain);
-
-    if (!authChainId) {
-      throw new Error('authChainId could not be determined from network list');
-    }
+  register(windowHref) {
+    const isPopup = parent.window.opener !== null;
+    this._isPopup = isPopup;
 
-    const walletConfig = await this.getWalletConfig(authChainId);
+    if (isPopup !== true) {
+      return;
+    } // record open details (sessionId + default network) from the window url
 
-    if (!walletConfig || walletConfig.length === 0) {
-      throw new Error(`walletConfig returned zero results for authChainId {authChainId}`);
-    }
 
-    return walletConfig[0].signers.map(s => s.address);
-  } // signMessage matches implementation from ethers JsonRpcSigner for compatibility, but with
-  // multi-chain support.
+    const {
+      pathname,
+      search: rawParams
+    } = new URL(windowHref || window.location.href);
+    let session = this.getWindowTransportSession(rawParams); // provider should always include sid when opening a new window
 
+    const isNewWindowSession = !!session.sessionId; // attempt to restore previous session in the case of a redirect or window reload
 
-  async signMessage(message, chainId, allSigners) {
-    const provider = await this.getSender(maybeChainId(chainId) || this.defaultChainId);
-    const data = typeof message === 'string' ? ethers.utils.toUtf8Bytes(message) : message;
-    const address = await this.getAddress(); // NOTE: as of ethers v5.5, it switched to using personal_sign, see
-    // https://github.com/ethers-io/ethers.js/pull/1542 and see
-    // https://github.com/WalletConnect/walletconnect-docs/issues/32 for additional info.
+    if (!isNewWindowSession) {
+      session = this.getCachedTransportSession();
+    }
 
-    return await provider.send('personal_sign', [ethers.utils.hexlify(data), address]);
-  } // signTypedData matches implementation from ethers JsonRpcSigner for compatibility, but with
-  // multi-chain support.
+    if (!session) {
+      logger.error('window session is undefined');
+      return;
+    } // record parent window instance for communication
 
 
-  async signTypedData(domain, types, message, chainId, allSigners) {
-    // Populate any ENS names (in-place)
-    // const populated = await ethers.utils._TypedDataEncoder.resolveNames(domain, types, message, (name: string) => {
-    //   return this.provider.resolveName(name)
-    // })
-    return await this.provider.send('eth_signTypedData_v4', [await this.getAddress(), ethers.utils._TypedDataEncoder.getPayload(domain, types, message)], maybeChainId(chainId) || this.defaultChainId);
-  } // sendTransaction matches implementation from ethers JsonRpcSigner for compatibility, but with
-  // multi-chain support.
+    this.parentWindow = parent.window.opener; // listen for window-transport requests
 
+    window.addEventListener('message', this.onWindowEvent, false);
+    this._registered = true; // send open event to the app which opened us
 
-  async sendTransaction(transaction, chainId, allSigners) {
-    const provider = await this.getSender(maybeChainId(chainId) || this.defaultChainId);
-    const tx = this.sendUncheckedTransaction(transaction, chainId).then(hash => {
-      return ethers.utils.poll(() => {
-        return provider.getTransaction(hash).then(tx => {
-          if (tx === null) {
-            return undefined;
-          }
+    this.open(session).then(opened => {
+      if (!opened) {
+        var _session;
 
-          return provider._wrapTransaction(tx, hash);
+        const err = `failed to open to network ${(_session = session) == null ? void 0 : _session.networkId}`;
+        logger.error(err);
+        this.notifyClose({
+          message: err
         });
-      }, {
-        onceBlock: this.provider
-      }).catch(error => {
-        error.transactionHash = hash;
-        throw error;
-      });
-    }); // @ts-ignore
-
-    return tx;
-  } // sendTransactionBatch is a convenience method to call sendTransaction in a batch format, allowing you to
-  // send multiple transaction as a single payload and just one on-chain transaction.
+        window.close();
+      }
+    }).catch(e => {
+      var _session2;
 
+      const err = `failed to open to network ${(_session2 = session) == null ? void 0 : _session2.networkId}, due to: ${e}`;
+      logger.error(err);
+      this.notifyClose({
+        message: err
+      });
+      window.close();
+    });
+  }
 
-  async sendTransactionBatch(transactions, chainId, allSigners) {
-    const batch = await resolveArrayProperties(transactions);
+  unregister() {
+    window.removeEventListener('message', this.onWindowEvent);
+    this._registered = false;
+  } // onmessage is called when (the wallet) receives request messages from the dapp
+  // over the window post-messaging transport
 
-    if (!batch || batch.length === 0) {
-      throw new Error('cannot send empty batch');
-    } // sendTransactionBatch only accepts TransactionRequest, not TransactionResponses
 
+  // postMessage sends message to the dapp window
+  sendMessage(message) {
+    // prepare payload
+    const payload = JSON.stringify(message); // post-message to app.
+    // only for init requests, we send to '*' origin
 
-    if (batch.find(v => v.wait !== undefined && v.wait !== null)) {
-      throw new Error('transaction request expected for sendTransactionBatch, transaction response found');
+    if (message.type === EventType.INIT) {
+      this.postMessage(payload, true);
+    } else {
+      this.postMessage(payload);
     }
+  }
 
-    const tx = _extends({}, batch[0]);
+  get isPopup() {
+    return this._isPopup;
+  }
 
-    if (batch.length > 1) {
-      tx.auxiliary = batch.splice(1);
+  postMessage(message, init = false) {
+    if (init !== true && this._init !== InitState.OK) {
+      logger.error('impossible state, should not be calling postMessage until inited');
+      return;
     }
 
-    return this.sendTransaction(tx, chainId, allSigners);
+    if (init) {
+      // init message transmission to global target -- for 'init' payloads only
+      this.parentWindow.postMessage(message, '*');
+    } else {
+      // open message transmission
+      if (this.appOrigin && this.appOrigin.length > 4) {
+        // just above '.com'
+        this.parentWindow.postMessage(message, this.appOrigin);
+      } else {
+        logger.error('unable to postMessage as parentOrigin is invalid');
+      }
+    }
   }
 
-  signTransactions(transaction, chainId, allSigners) {
-    transaction = shallowCopy(transaction); // TODO: transaction argument..? make sure to resolve any properties and serialize property before sending over
-    // the wire.. see sendUncheckedTransaction and resolveProperties
+}
 
-    return this.provider.send('eth_signTransaction', [transaction], maybeChainId(chainId) || this.defaultChainId);
+const CHANNEL_ID = 'sequence-extension-message-handler';
+class ExtensionMessageHandler extends BaseWalletTransport {
+  constructor(walletRequestHandler, runtime) {
+    super(walletRequestHandler);
+    this.runtime = runtime;
+    this.port = void 0;
+    this._init = InitState.OK;
   }
 
-  sendSignedTransactions(signedTxs, chainId) {
-    // sequence_relay
-    throw new Error('TODO');
-  } // updateConfig..
-  // NOTE: this is not supported by the remote wallet by default.
+  register() {
+    this._registered = true;
+    this.port = this.runtime.connect({
+      name: CHANNEL_ID
+    });
+  }
 
+  sendMessage(message) {
+    console.log('[ExtensionMessageHandler send]', message);
+    this.port.postMessage(message);
+  }
 
-  async updateConfig(newConfig) {
-    // sequence_updateConfig
-    const [config, tx] = await this.provider.send('sequence_updateConfig', [newConfig], this.defaultChainId);
+}
 
-    if (tx === null) {
-      return [config, undefined];
-    }
+class ExtensionMessageProvider extends BaseProviderTransport {
+  constructor(runtime) {
+    super();
 
-    const provider = await this.getSender(this.defaultChainId);
-    return [config, provider._wrapTransaction(tx, tx.hash)];
-  } // publishConfig..
-  // NOTE: this is not supported by the remote wallet by default.
+    this.register = () => {
+      this._registered = true;
+    };
 
+    runtime.onConnect.addListener(port => {
+      if (port.name === CHANNEL_ID) {
+        this._init = InitState.OK;
+        port.onMessage.addListener(message => {
+          this.handleMessage(message);
+        });
+      }
+    });
+  }
 
-  async publishConfig() {
-    const provider = await this.getSender(this.defaultChainId);
-    const tx = await provider.send('sequence_publishConfig', []);
+  sendMessage(message) {//noop
+  }
 
-    if (tx === null) {
-      return undefined;
-    }
+  unregister() {//noop
+  }
 
-    return provider._wrapTransaction(tx, tx.hash);
+  openWallet(path, intent, networkId) {//noop
   }
 
-  async isDeployed(chainId) {
-    const provider = await this.getSender(maybeChainId(chainId));
-    const walletCode = await provider.getCode(await this.getAddress());
-    return !!walletCode && walletCode !== '0x';
-  } //
-  // ethers JsonRpcSigner methods
-  //
+  closeWallet() {//noop
+  }
 
+}
 
-  async _legacySignMessage(message, chainId, allSigners) {
-    const provider = await this.getSender(maybeChainId(chainId) || this.defaultChainId);
-    const data = typeof message === 'string' ? ethers.utils.toUtf8Bytes(message) : message;
-    const address = await this.getAddress(); // https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign
-    // NOTE: ethers since 5.5 has switched to using personal_sign, we should review, etc.
+// to be used on injected window.ethereum EIP1193 proxy
+class BaseInjectedTransport extends EventEmitter2 {
+  constructor(stream) {
+    var _this;
 
-    return await provider.send('eth_sign', [address, ethers.utils.hexlify(data)]);
-  }
+    super();
+    _this = this;
+    this.stream = stream;
+    this.responseCallbacks = new Map();
+    this._messageIdx = 0;
 
-  async _signTypedData(domain, types, message, chainId, allSigners) {
-    return this.signTypedData(domain, types, message, chainId, allSigners);
-  }
+    this.nextMessageIdx = () => ++this._messageIdx;
 
-  async sendUncheckedTransaction(transaction, chainId) {
-    transaction = shallowCopy(transaction);
-    const fromAddress = this.getAddress(); // NOTE: we do not use provider estimation, and instead rely on our relayer to determine the gasLimit and gasPrice
-    //
-    // TODO: alternatively/one day, we could write a provider middleware to eth_estimateGas
-    // and send it to our relayer url instead for estimation..
-    //
-    // if (!transaction.gasLimit) {
-    //   const estimate = shallowCopy(transaction)
-    //   estimate.from = fromAddress
-    //   transaction.gasLimit = this.provider.estimateGas(estimate)
-    // }
+    this.handleMessage = message => {
+      if (!message.type || !message.data) {
+        return;
+      }
 
-    const provider = await this.getSender(maybeChainId(chainId) || this.defaultChainId);
-    return resolveProperties({
-      tx: resolveProperties(transaction),
-      sender: await fromAddress
-    }).then(({
-      tx,
-      sender
-    }) => {
-      if (tx.from != null) {
-        if (ethers.utils.getAddress(tx.from) !== sender) {
-          // logger.throwArgumentError("from address mismatch", "transaction", transaction)
-          throw new Error(`from address mismatch for transaction ${transaction}`);
-        }
-      } else {
-        tx.from = sender;
+      console.log('[received message]', message);
+      const requestIdx = message.idx;
+      const responseCallback = this.responseCallbacks.get(requestIdx);
+
+      if (requestIdx) {
+        this.responseCallbacks.delete(requestIdx);
       }
 
-      const hexTx = hexlifyTransaction(tx);
-      return provider.send('eth_sendTransaction', [hexTx]).then(hash => {
-        return hash;
-      }, error => {
-        // return checkError("sendTransaction", error, hexTx)
-        throw new Error(`sendTransaction ${error}`);
-      });
-    });
-  }
+      switch (message.type) {
+        case EventType.MESSAGE:
+          if (responseCallback) {
+            this.emit(EventType.MESSAGE, message);
+            responseCallback(message.data.error, message);
+          } else {
+            // NOTE: this would occur if 'idx' isn't set, which should never happen
+            // or when we register two handler, or duplicate messages with the same idx are sent,
+            // all of which should be prevented prior to getting to this point
+            throw new Error('impossible state');
+          }
 
-  connectUnchecked() {
-    throw new Error('connectUnchecked is unsupported');
-  }
+          break;
 
-  async unlock(password) {
-    const address = await this.getAddress();
-    return this.provider.send('personal_unlockAccount', [address, password, null]);
-  }
+        case EventType.DISCONNECT:
+        case EventType.ACCOUNTS_CHANGED:
+        case EventType.CHAIN_CHANGED:
+          this.emit(message.type, message.data);
+          break;
 
-} // NOTE: method has been copied + modified from ethers.js JsonRpcProvider
-// Convert an ethers.js transaction into a JSON-RPC transaction
+        default:
+          console.error('unknown message type', message);
+          break;
+      }
+    };
 
-const allowedTransactionKeys = {
-  chainId: true,
-  data: true,
-  gasLimit: true,
-  gasPrice: true,
-  nonce: true,
-  to: true,
-  value: true,
-  from: true,
-  auxiliary: true,
-  expiration: true,
-  afterNonce: true,
-  delegateCall: true,
-  revertOnError: true
-};
+    this.sendMessageRequest = async function (message) {
+      return new Promise((resolve, reject) => {
+        if (!message.idx || message.idx <= 0) {
+          reject(new Error('message idx not set'));
+        }
 
-const hexlifyTransaction = (transaction, allowExtra) => {
-  // Check only allowed properties are given
-  const allowed = shallowCopy(allowedTransactionKeys);
+        const responseCallback = (error, response) => {
+          if (error) {
+            reject(error);
+          } else if (response) {
+            resolve(response);
+          } else {
+            throw new Error('no valid response to return');
+          }
+        };
 
-  if (allowExtra) {
-    for (const key in allowExtra) {
-      if (allowExtra[key]) {
-        allowed[key] = true;
-      }
-    }
-  }
+        const {
+          idx
+        } = message;
 
-  ethers.utils.checkProperties(transaction, allowed);
-  const result = {} // Some nodes (INFURA ropsten; INFURA mainnet is fine) do not like leading zeros.
-  ;
-  ['gasLimit', 'gasPrice', 'nonce', 'value'].forEach(key => {
-    if (!transaction[key]) {
-      return;
-    }
+        if (!_this.responseCallbacks.get(idx)) {
+          _this.responseCallbacks.set(idx, responseCallback);
+        } else {
+          reject(new Error('duplicate message idx, should never happen'));
+        }
 
-    const value = ethers.utils.hexValue(transaction[key]);
+        _this.sendMessage(message);
+      });
+    };
 
-    if (key === 'gasLimit') {
-      key = 'gas';
-    }
+    this.stream.on('data', this.handleMessage);
+  }
 
-    result[key] = value;
-  });
-  ['from', 'to', 'data'].forEach(key => {
-    if (!transaction[key]) {
-      return;
+  sendMessage(message) {
+    if (!this.stream.writable) {
+      console.error('window post message stream is not writable');
     }
 
-    result[key] = ethers.utils.hexlify(transaction[key]);
-  });
-  const auxiliary = transaction['auxiliary'];
-
-  if (auxiliary && auxiliary.length > 0) {
-    result['auxiliary'] = [];
-    auxiliary.forEach(a => {
-      result['auxiliary'].push(hexlifyTransaction(a));
-    });
+    this.stream.write(message);
   }
 
-  return result;
-};
+}
 
-class WalletCommands {
+class WalletUtils {
   constructor(walletProvider) {
     var _this = this;
 
@@ -3110,7 +3127,9 @@ class WalletCommands {
   } // Verify message signature
 
 
-  isValidMessageSignature(address, message, signature, chainId, walletContext) {
+  async isValidMessageSignature(address, message, signature, chainId, walletContext) {
+    const msgDigest = ethers.utils.arrayify(ethers.utils.hashMessage(message));
+    if (isValidEIP712Signature(address, msgDigest, signature) || isValidEthSignSignature(address, msgDigest, signature)) return true;
     return this.isValidSignature(address, encodeMessageDigest(message), signature, chainId, walletContext);
   } // Verify typedData signature
 
@@ -3142,7 +3161,7 @@ class Wallet {
   constructor(defaultNetworkId, config) {
     var _this = this;
 
-    this.commands = void 0;
+    this.utils = void 0;
     this.config = void 0;
     this.session = void 0;
     this.connectedSites = void 0;
@@ -3468,7 +3487,7 @@ class Wallet {
     this.networks = [];
     this.providers = {};
     this.connectedSites = new LocalStore('@sequence.connectedSites', []);
-    this.commands = new WalletCommands(this);
+    this.utils = new WalletUtils(this);
     this.init();
   }
 
@@ -3685,4 +3704,4 @@ const DefaultProviderConfig = {
   }
 };
 
-export { BaseInjectedTransport, BaseProviderTransport, BaseWalletTransport, CHANNEL_ID, DefaultProviderConfig, ErrSignedInRequired, EventType, ExtensionMessageHandler, ExtensionMessageProvider, InitState, LocalStore, LocalWeb3Provider, MuxMessageProvider, OpenState, PROVIDER_OPEN_TIMEOUT, ProviderError, ProxyMessageChannel, ProxyMessageChannelPort, ProxyMessageHandler, ProxyMessageProvider, Wallet, WalletRequestHandler, Web3Provider, Web3Signer, WindowMessageHandler, WindowMessageProvider, WindowSessionParams, isBrowserExtension, isSequenceProvider, isValidSignature, isWalletUpToDate, nextMessageIdx, recoverWalletConfig };
+export { BaseInjectedTransport, BaseProviderTransport, BaseWalletTransport, CHANNEL_ID, DefaultProviderConfig, ErrSignedInRequired, EventType, ExtensionMessageHandler, ExtensionMessageProvider, InitState, LocalStore, LocalWeb3Provider, MuxMessageProvider, OpenState, PROVIDER_OPEN_TIMEOUT, ProviderError, ProxyMessageChannel, ProxyMessageChannelPort, ProxyMessageHandler, ProxyMessageProvider, Wallet, WalletRequestHandler, Web3Provider, Web3Signer, WindowMessageHandler, WindowMessageProvider, WindowSessionParams, isBrowserExtension, isSequenceProvider, isValidMessageSignature, isValidSignature, isValidTypedDataSignature, isWalletUpToDate, nextMessageIdx, recoverWalletConfig };