@0xsequence/provider 1.0.5 → 1.1.1

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

@@ -8,7 +8,6 @@ var ethers = require('ethers');
 var network = require('@0xsequence/network');
 var core = require('@0xsequence/core');
 var auth = require('@0xsequence/auth');
-var wallet = require('@0xsequence/wallet');
 
 function _extends() {
   _extends = Object.assign ? Object.assign.bind() : function (target) {
@@ -25,6 +24,10 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
+function isProviderTransport(transport) {
+  return transport && typeof transport === 'object' && typeof transport.register === 'function' && typeof transport.unregister === 'function' && typeof transport.openWallet === 'function' && typeof transport.closeWallet === 'function' && typeof transport.isOpened === 'function' && typeof transport.isConnected === 'function' && typeof transport.on === 'function';
+}
+
 // ProviderMessageCallback is used to respond to ProviderMessage requests. The error
 // argument is for exceptions during the execution, and response is the response payload
 // which may contain the result or an error payload from the wallet.
@@ -76,6 +79,8 @@ const ErrSignedInRequired = new ProviderError('Wallet is not signed in. Connect
 
 // TODO: lets build some nice error handling tools, prob in /utils ...
 
+// This is required by viem, it expects a provider to have an EIP-1193 compliant `request` attribute.
+
 const PROVIDER_OPEN_TIMEOUT = 30000; // in ms
 
 let _messageIdx = 0;
@@ -613,59 +618,87 @@ const isUnityPlugin = () => !!navigator.userAgent.match(/UnitySequence/i);
 const isWalletUpToDate = status => {
   return status.onChain.deployed && status.fullyMigrated;
 };
+class MemoryItemStore {
+  constructor() {
+    this.callbacks = [];
+    this.store = {};
+  }
+  getItem(key) {
+    return this.store[key] || null;
+  }
+  setItem(key, value) {
+    this.store[key] = value;
+    this.callbacks.filter(c => c.key === key).forEach(c => c.cb(value));
+  }
+  removeItem(key) {
+    delete this.store[key];
+  }
+  onItemChange(key, cb) {
+    this.callbacks.push({
+      key,
+      cb
+    });
+    return () => {
+      this.callbacks = this.callbacks.filter(c => c.cb !== cb);
+    };
+  }
+}
 class LocalStorage {
-  constructor() {}
-  static getInstance() {
-    if (typeof window === 'object') {
-      if (!LocalStorage._instance) {
-        LocalStorage._instance = {
-          getItem: key => Promise.resolve(window.localStorage.getItem(key)),
-          setItem: (key, value) => Promise.resolve(window.localStorage.setItem(key, value)),
-          removeItem: key => Promise.resolve(window.localStorage.removeItem(key))
-        };
-      }
-    } else {
-      // noop local storage if window is not defined
-      // TODO: perhaps add an in-memory local storage if we need?
-      if (!LocalStorage._instance) {
-        LocalStorage._instance = {
-          getItem: key => Promise.resolve(null),
-          setItem: (key, value) => Promise.resolve(),
-          removeItem: key => Promise.resolve()
-        };
-      }
+  static isAvailable() {
+    return typeof window === 'object' && typeof window.localStorage === 'object';
+  }
+  constructor() {
+    this.callbacks = [];
+    if (!LocalStorage.isAvailable()) {
+      throw new Error('LocalStorage is not available');
     }
-    return this._instance;
+    window.addEventListener('storage', e => {
+      const {
+        key
+      } = e;
+      const cb = this.callbacks.filter(c => c.key === key);
+      cb.forEach(c => c.cb(this.getItem(key)));
+    });
   }
-  static use(instance) {
-    LocalStorage._instance = instance;
+  getItem(key) {
+    return window.localStorage.getItem(key);
   }
-}
+  setItem(key, value) {
+    window.localStorage.setItem(key, value);
 
-// window.localstorage helper
-class LocalStore {
-  constructor(key, def) {
-    this.def = def;
-    this.key = key;
+    // Trigger callbacks
+    // NOTICE: the event is not triggered on the same window
+    this.callbacks.filter(c => c.key === key).forEach(c => c.cb(value));
   }
-  async get() {
-    const val = await LocalStorage.getInstance().getItem(this.key);
-    if (val === null) {
-      return this.def;
-    }
-    try {
-      return JSON.parse(val);
-    } catch (err) {
-      console.error(err);
-    }
-    return;
+  removeItem(key) {
+    window.localStorage.removeItem(key);
+
+    // Trigger callbacks
+    // NOTICE: the event is not triggered on the same window
+    this.callbacks.filter(c => c.key === key).forEach(c => c.cb(null));
+  }
+  onItemChange(key, cb) {
+    this.callbacks.push({
+      key,
+      cb
+    });
+    return () => {
+      this.callbacks = this.callbacks.filter(c => c.cb !== cb);
+    };
   }
-  set(val) {
-    val ? LocalStorage.getInstance().setItem(this.key, JSON.stringify(val)) : LocalStorage.getInstance().removeItem(this.key);
+}
+function useBestStore() {
+  if (LocalStorage.isAvailable()) {
+    return new LocalStorage();
   }
-  del() {
-    LocalStorage.getInstance().removeItem(this.key);
+  return new MemoryItemStore();
+}
+async function resolveArrayProperties(object) {
+  if (Array.isArray(object)) {
+    // T must include array type
+    return Promise.all(object.map(o => ethers.ethers.utils.resolveProperties(o)));
   }
+  return ethers.ethers.utils.resolveProperties(object);
 }
 
 const TRANSPORT_SESSION_LS_KEY = '@sequence.transportSession';
@@ -806,11 +839,6 @@ class BaseWalletTransport {
         // Set connect options on the walletRequestHandler as our primary
         // wallet controller, and fall back to networkId if necessary
         _this.walletRequestHandler.setConnectOptions(connectOptions);
-        if (connectOptions.networkId) {
-          networkId = connectOptions.networkId;
-        } else if (networkId) {
-          connectOptions.networkId = networkId;
-        }
       } else {
         _this.walletRequestHandler.setConnectOptions(undefined);
       }
@@ -880,10 +908,10 @@ class BaseWalletTransport {
       return true;
     };
     this.saveTransportSession = session => {
-      LocalStorage.getInstance().setItem(TRANSPORT_SESSION_LS_KEY, JSON.stringify(session));
+      useBestStore().setItem(TRANSPORT_SESSION_LS_KEY, JSON.stringify(session));
     };
     this.getCachedTransportSession = async function () {
-      const session = await LocalStorage.getInstance().getItem(TRANSPORT_SESSION_LS_KEY);
+      const session = useBestStore().getItem(TRANSPORT_SESSION_LS_KEY);
       try {
         return session ? JSON.parse(session) : null;
       } catch (err) {
@@ -1237,203 +1265,84 @@ class ProxyMessageHandler extends BaseWalletTransport {
   }
 }
 
-class MuxMessageProvider {
-  constructor(...messageProviders) {
-    var _this = this;
-    this.register = () => {
-      if (this.messageProviders.length === 1) {
-        this.provider = this.messageProviders[0];
-        this.provider.register();
-        return;
-      }
-
-      // REVIEW/NOTE: ........ this method does not work for the chrome-extension. The issue becomes
-      // when the browser quits or restarts, the "open" event is never triggered. Perhaps the code here is fine,
-      // or maybe its not. What should happen is when a dapp makes a request, it will call openWallet
-      // below, in which case one of the events will register. So perhaps this is fine.
-      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 will redirect console logs from Sequence.js & the wallet to the Unreal console, for debugging purposes.
+ */
+function overrideLogs(side) {
+  var _window$ue;
+  if ((_window$ue = window.ue) != null && _window$ue.sequencewallettransport && !window.logsOverriddenForUnreal) {
+    var _window$ue2;
+    const t = (_window$ue2 = window.ue) == null ? void 0 : _window$ue2.sequencewallettransport;
+    console.log = (...args) => {
+      t.logfromjs(`${side}: ${stringify(args)}`);
     };
-    this.waitUntilOpened = async function () {
-      if (_this.provider) {
-        return _this.provider.waitUntilOpened();
-      }
-      return Promise.race(_this.messageProviders.map(p => p.waitUntilOpened()));
+    console.warn = (...args) => {
+      t.warnfromjs(`${side}: ${stringify(args)}`);
     };
-    this.waitUntilConnected = async function () {
-      if (_this.provider) {
-        return _this.provider.waitUntilConnected();
-      }
-      throw new Error('impossible state, wallet must be opened first');
+    console.error = (...args) => {
+      t.errorfromjs(`${side}: ${stringify(args)}`);
     };
-    this.messageProviders = messageProviders;
-    this.provider = undefined;
-  }
-  add(...messageProviders) {
-    this.messageProviders.push(...messageProviders);
-  }
-  closeWallet() {
-    if (this.provider) {
-      this.provider.closeWallet();
-    }
-  }
-  isOpened() {
-    if (this.provider) {
-      return this.provider.isOpened();
-    }
-    return false;
-  }
-  isConnected() {
-    if (this.provider) {
-      return this.provider.isConnected();
-    }
-    return false;
-  }
-  on(event, fn) {
-    if (this.provider) {
-      this.provider.on(event, fn);
-      return;
-    }
-    this.messageProviders.forEach(m => {
-      m.on(event, fn);
-    });
-  }
-  once(event, fn) {
-    if (this.provider) {
-      this.provider.once(event, fn);
-      return;
-    }
-    this.messageProviders.forEach(m => {
-      m.once(event, fn);
-    });
-  }
-  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');
-    }
-    if (this.provider) {
-      this.provider.sendMessage(message);
-    } else {
-      throw new Error('impossible state, wallet must be opened first');
-    }
-  }
-  handleMessage(message) {
-    if (this.provider) {
-      this.provider.handleMessage(message);
-      return;
-    }
-    throw new Error('impossible state, wallet must be opened first');
+    window.logsOverriddenForUnreal = true;
   }
 }
+function stringify(things) {
+  return things.map(a => typeof a === 'object' ? a instanceof Error ? a.message : JSON.stringify(a) : String(a)).join(' ');
+}
 
-// ..
-let registeredWindowMessageProvider;
-class WindowMessageProvider extends BaseProviderTransport {
+let registeredUnrealMessageProvider;
+
+// all lowercase is an annoying limitation of Unreal CEF BindUObject
+
+/**
+ * Initialized on dApp side
+ */
+class UnrealMessageProvider extends BaseProviderTransport {
   constructor(walletAppURL) {
     super();
     this.register = () => {
-      if (registeredWindowMessageProvider) {
+      var _window$ue;
+      overrideLogs('dapp');
+      if (registeredUnrealMessageProvider) {
         // overriding the registered message provider
-        registeredWindowMessageProvider.unregister();
-        registeredWindowMessageProvider = this;
+        registeredUnrealMessageProvider.unregister();
+        registeredUnrealMessageProvider = this;
       }
 
       // listen for incoming messages from wallet
-      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
-      this.on('close', () => {
-        if (this.walletWindow) {
-          this.walletWindow.close();
-          this.walletWindow = null;
-        }
-      });
+      if ((_window$ue = window.ue) != null && _window$ue.sequencewallettransport) {
+        window.ue.sequencewallettransport.onmessagefromwallet = this.onUnrealCallback;
+      }
+      registeredUnrealMessageProvider = this;
       this._registered = true;
+      console.log('registering transport!');
     };
     this.unregister = () => {
+      var _window$ue2, _window$ue2$sequencew;
       this._registered = false;
       this.closeWallet();
 
       // disable message listener
-      if (registeredWindowMessageProvider === this) {
-        registeredWindowMessageProvider = undefined;
+      if (registeredUnrealMessageProvider === this) {
+        registeredUnrealMessageProvider = undefined;
+      }
+      if (((_window$ue2 = window.ue) == null ? void 0 : (_window$ue2$sequencew = _window$ue2.sequencewallettransport) == null ? void 0 : _window$ue2$sequencew.onmessagefromwallet) === this.onUnrealCallback) {
+        delete window.ue.sequencewallettransport.onmessagefromwallet;
       }
-      window.removeEventListener('message', this.onWindowEvent);
 
       // clear event listeners
       this.events.removeAllListeners();
     };
     this.openWallet = (path, intent, networkId) => {
-      if (this.walletWindow && this.isOpened()) {
-        // TODO: update the location of window to path
-        this.walletWindow.focus();
+      if (this.isOpened()) {
+        // TODO focus wallet
+        console.log('wallet already open!');
         return;
       }
-
+      console.log('opening wallet!');
       // Instantiate new walletURL for this call
       const walletURL = new URL(this.walletURL.href);
       const windowSessionParams = new WindowSessionParams();
-      if (path && path !== '') {
+      if (path) {
         walletURL.pathname = path.toLowerCase();
       }
 
@@ -1442,80 +1351,19 @@ class WindowMessageProvider extends BaseProviderTransport {
       this._sessionId = `${performance.now()}`;
       windowSessionParams.set('sid', this._sessionId);
       if (intent) {
-        // for the window-transport, we eagerly/optimistically set the origin host
-        // when connecting to the wallet, however, this will be verified and enforced
-        // 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
-          if (!isBrowserExtension() && !isUnityPlugin()) {
-            intent.options.origin = window.location.origin;
-          }
-        }
         // encode intent as base64 url-encoded param
         windowSessionParams.set('intent', utils.base64EncodeObject(intent));
       }
       if (networkId) {
         windowSessionParams.set('net', `${networkId}`);
       }
-
-      // Open popup window on center of the app window
-      let windowSize;
-      let windowPos;
-      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 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
-      // }
+      console.log('opening wallet to', walletURL.href);
+      window.open(walletURL.href);
     };
-    // onmessage, receives ProviderMessageResponse from the wallet post-message transport
-    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;
-      }
-      let message;
-      try {
-        message = JSON.parse(event.data);
-      } catch (err) {
-        // event is not a ProviderMessage JSON object, skip
-        return;
-      }
+    // onmessage, receives ProviderMessageResponse from the wallet unreal transport
+    this.onUnrealCallback = message => {
       if (!message) {
         throw new Error('ProviderMessage object is empty');
       }
@@ -1526,62 +1374,36 @@ class WindowMessageProvider extends BaseProviderTransport {
     this.walletURL = new URL(walletAppURL);
   }
   closeWallet() {
-    var _this$walletWindow;
     this.close();
-    (_this$walletWindow = this.walletWindow) == null ? void 0 : _this$walletWindow.close();
   }
+  // all lowercase is an annoying limitation of Unreal CEF BindUObject
   sendMessage(message) {
-    if (!this.walletWindow) {
-      utils.logger.warn('WindowMessageProvider: sendMessage failed as walletWindow is unavailable');
-      return;
-    }
+    var _window$ue3, _window$ue3$sequencew;
     const postedMessage = typeof message !== 'string' ? JSON.stringify(message) : message;
-    this.walletWindow.postMessage(postedMessage, this.walletURL.origin);
+    console.log('Sending message to wallet:', postedMessage);
+    (_window$ue3 = window.ue) == null ? void 0 : (_window$ue3$sequencew = _window$ue3.sequencewallettransport) == null ? void 0 : _window$ue3$sequencew.sendmessagetowallet(postedMessage);
   }
 }
 
-class WindowMessageHandler extends BaseWalletTransport {
+// all lowercase is an annoying limitation of Unreal CEF BindUObject
+
+/**
+ * Initialized on Wallet side
+ */
+class UnrealMessageHandler extends BaseWalletTransport {
   constructor(walletRequestHandler) {
-    var _this;
     super(walletRequestHandler);
-    _this = this;
-    this._isPopup = false;
     // onmessage is called when (the wallet) receives request messages from the dapp
-    // over the window post-messaging transport
-    this.onWindowEvent = async function (event) {
-      if (!event.origin || event.origin === '') {
-        // skip same-origin or when event.origin is empty/undefined
-        return;
-      }
-      if (_this.appOrigin && event.origin !== _this.appOrigin) {
-        // skip message as not from expected app origin
-        return;
-      }
-
+    // over the unreal json-messaging transport
+    this.onMessageFromUnreal = request => {
       // Wallet always expects json-rpc request messages from a dapp
-      let request;
-      try {
-        request = JSON.parse(event.data);
-      } catch (err) {
-        // event is not a ProviderMessage JSON object, skip
-        return;
-      }
-      utils.logger.debug('RECEIVED MESSAGE', request);
 
-      // Record event origin for valid init ack
-      if (_this._init !== InitState.OK && _this.isValidInitAck(request)) {
-        _this.appOrigin = event.origin;
-      }
-      if (_this._init === InitState.OK && (!_this.appOrigin || _this.appOrigin.length < 8)) {
-        // impossible state
-        utils.logger.error('impossible state, init.OK and appOrigin required');
-        return;
-      }
+      utils.logger.debug('RECEIVED MESSAGE', request);
 
       // Handle message via the base transport
-      _this.handleMessage(request);
+      this.handleMessage(request);
     };
-    this.getWindowTransportSession = windowParams => {
+    this.getUnrealTransportSession = windowParams => {
       const params = new WindowSessionParams(windowParams);
       return {
         sessionId: params.get('sid'),
@@ -1592,18 +1414,17 @@ class WindowMessageHandler extends BaseWalletTransport {
     this._init = InitState.NIL;
   }
   async register(windowHref) {
-    const isPopup = parent.window.opener !== null;
-    this._isPopup = isPopup;
-    if (isPopup !== true) {
+    var _window$ue;
+    if (((_window$ue = window.ue) == null ? void 0 : _window$ue.sequencewallettransport) === undefined) {
       return;
     }
+    overrideLogs('wallet');
 
     // record open details (sessionId + default network) from the window url
     const {
-      pathname,
       search: rawParams
     } = new URL(windowHref || window.location.href);
-    let session = this.getWindowTransportSession(rawParams);
+    let session = this.getUnrealTransportSession(rawParams);
 
     // provider should always include sid when opening a new window
     const isNewWindowSession = !!session.sessionId;
@@ -1613,15 +1434,12 @@ class WindowMessageHandler extends BaseWalletTransport {
       session = await this.getCachedTransportSession();
     }
     if (!session) {
-      utils.logger.error('window session is undefined');
+      utils.logger.error('unreal session is undefined');
       return;
     }
 
-    // record parent window instance for communication
-    this.parentWindow = parent.window.opener;
-
     // listen for window-transport requests
-    window.addEventListener('message', this.onWindowEvent, false);
+    window.ue.sequencewallettransport.onmessagefromsequencejs = this.onMessageFromUnreal;
     this._registered = true;
 
     // send open event to the app which opened us
@@ -1646,79 +1464,689 @@ class WindowMessageHandler extends BaseWalletTransport {
     });
   }
   unregister() {
-    window.removeEventListener('message', this.onWindowEvent);
+    var _window$ue2, _window$ue2$sequencew;
+    if (((_window$ue2 = window.ue) == null ? void 0 : (_window$ue2$sequencew = _window$ue2.sequencewallettransport) == null ? void 0 : _window$ue2$sequencew.onmessagefromsequencejs) === this.onMessageFromUnreal) {
+      delete window.ue.sequencewallettransport.onmessagefromsequencejs;
+    }
     this._registered = false;
   }
-  // postMessage sends message to the dapp window
+  // sendMessage sends message to the dapp window
   sendMessage(message) {
+    var _window$ue3, _window$ue3$sequencew;
+    if (message.type !== EventType.INIT && this._init !== InitState.OK) {
+      utils.logger.error('impossible state, should not be calling postMessage until inited');
+      return;
+    }
     // prepare payload
     const payload = JSON.stringify(message);
 
     // post-message to app.
-    // only for init requests, we send to '*' origin
-    if (message.type === EventType.INIT) {
-      this.postMessage(payload, true);
-    } else {
-      this.postMessage(payload);
-    }
+    (_window$ue3 = window.ue) == null ? void 0 : (_window$ue3$sequencew = _window$ue3.sequencewallettransport) == null ? void 0 : _window$ue3$sequencew.sendmessagetosequencejs(payload);
   }
-  get isPopup() {
-    return this._isPopup;
+}
+
+const CHANNEL_ID = 'sequence-extension-message-handler';
+class ExtensionMessageHandler extends BaseWalletTransport {
+  constructor(walletRequestHandler, runtime) {
+    super(walletRequestHandler);
+    this.runtime = runtime;
+    this._init = InitState.OK;
   }
-  postMessage(message, init = false) {
-    if (init !== true && this._init !== InitState.OK) {
-      utils.logger.error('impossible state, should not be calling postMessage until inited');
-      return;
-    }
-    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 {
-        utils.logger.error('unable to postMessage as parentOrigin is invalid');
-      }
-    }
+  register() {
+    this._registered = true;
+    this.port = this.runtime.connect({
+      name: CHANNEL_ID
+    });
+  }
+  sendMessage(message) {
+    utils.logger.info('[ExtensionMessageHandler send]', message);
+    this.port.postMessage(message);
   }
 }
 
-function toExtended(transactions) {
-  if (transactions.length === 0) {
-    throw new Error("No transaction provided");
+class ExtensionMessageProvider extends BaseProviderTransport {
+  constructor(runtime) {
+    super();
+    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);
+        });
+      }
+    });
+  }
+  sendMessage(message) {
+    //noop
+  }
+  unregister() {
+    //noop
+  }
+  openWallet(path, intent, networkId) {
+    //noop
+  }
+  closeWallet() {
+    //noop
   }
-  const [first, ...rest] = transactions;
-  return _extends({}, first, {
-    auxiliary: rest
-  });
-}
-function fromExtended(transaction) {
-  return [transaction, ...(transaction.auxiliary || [])];
 }
 
-const SIGNER_READY_TIMEOUT = 10000;
-class WalletRequestHandler {
-  constructor(_account, prompter, networks) {
-    var _this = this;
-    // signer interface of the wallet. A null value means there is no signer (ie. user not signed in). An undefined
-    // value means the signer state is unknown, usually meaning the wallet app is booting up and initializing. Of course
-    // a Signer value is the actually interface to a signed-in account
-    this.signerReadyCallbacks = [];
-    this.events = new eventemitter2.EventEmitter2();
-    this.onConnectOptionsChange = undefined;
-    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');
+// to be used on injected window.ethereum EIP1193 proxy
+class BaseInjectedTransport extends eventemitter2.EventEmitter2 {
+  constructor(stream) {
+    var _this;
+    super();
+    _this = this;
+    this.responseCallbacks = new Map();
+    this._messageIdx = 0;
+    this.nextMessageIdx = () => ++this._messageIdx;
+    this.handleMessage = message => {
+      if (!message.type || !message.data) {
+        return;
       }
-      if (!_this.prompter) {
-        // if prompter is null, we'll auto connect
-        return _this.connect(options);
+      utils.logger.info('[received message]', message);
+      const requestIdx = message.idx;
+      const responseCallback = this.responseCallbacks.get(requestIdx);
+      if (requestIdx) {
+        this.responseCallbacks.delete(requestIdx);
       }
-      const promptConnectDetails = await _this.prompter.promptConnect(options || _this._connectOptions).catch(_ => {
-        return {
+      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');
+          }
+          break;
+        case EventType.DISCONNECT:
+        case EventType.ACCOUNTS_CHANGED:
+        case EventType.CHAIN_CHANGED:
+          this.emit(message.type, message.data);
+          break;
+        default:
+          console.error('unknown message type', message);
+          break;
+      }
+    };
+    this.sendMessageRequest = async function (message) {
+      return new Promise((resolve, reject) => {
+        if (!message.idx || message.idx <= 0) {
+          reject(new Error('message idx not set'));
+        }
+        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;
+        if (!_this.responseCallbacks.get(idx)) {
+          _this.responseCallbacks.set(idx, responseCallback);
+        } else {
+          reject(new Error('duplicate message idx, should never happen'));
+        }
+        _this.sendMessage(message);
+      });
+    };
+    this.stream = stream;
+    this.stream.on('data', this.handleMessage);
+  }
+  sendMessage(message) {
+    if (!this.stream.writable) {
+      console.error('window post message stream is not writable');
+    }
+    this.stream.write(message);
+  }
+}
+
+// ..
+let registeredWindowMessageProvider;
+class WindowMessageProvider extends BaseProviderTransport {
+  constructor(walletAppURL) {
+    super();
+    this.register = () => {
+      if (registeredWindowMessageProvider) {
+        // overriding the registered message provider
+        registeredWindowMessageProvider.unregister();
+        registeredWindowMessageProvider = this;
+      }
+
+      // listen for incoming messages from wallet
+      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
+      this.on('close', () => {
+        if (this.walletWindow) {
+          this.walletWindow.close();
+          this.walletWindow = null;
+        }
+      });
+      this._registered = true;
+    };
+    this.unregister = () => {
+      this._registered = false;
+      this.closeWallet();
+
+      // disable message listener
+      if (registeredWindowMessageProvider === this) {
+        registeredWindowMessageProvider = undefined;
+      }
+      window.removeEventListener('message', this.onWindowEvent);
+
+      // clear event listeners
+      this.events.removeAllListeners();
+    };
+    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
+      this._init = InitState.NIL;
+      this._sessionId = `${performance.now()}`;
+      windowSessionParams.set('sid', this._sessionId);
+      if (intent) {
+        // for the window-transport, we eagerly/optimistically set the origin host
+        // when connecting to the wallet, however, this will be verified and enforced
+        // 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 = {
+            app: window.location.origin
+          };
+
+          // skip setting origin host if we're in an browser extension execution context
+          // allow origin that is passed in
+          if (!isBrowserExtension() && !isUnityPlugin() && intent.options) {
+            intent.options.origin = window.location.origin;
+          }
+        }
+        // encode intent as base64 url-encoded param
+        windowSessionParams.set('intent', utils.base64EncodeObject(intent));
+      }
+      if (networkId) {
+        windowSessionParams.set('net', `${networkId}`);
+      }
+
+      // Open popup window on center of the app window
+      let windowSize;
+      let windowPos;
+      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 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
+      // }
+    };
+    // onmessage, receives ProviderMessageResponse from the wallet post-message transport
+    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;
+      }
+      let message;
+      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
+      this.handleMessage(message);
+    };
+    this.walletURL = new URL(walletAppURL);
+  }
+  closeWallet() {
+    var _this$walletWindow;
+    this.close();
+    (_this$walletWindow = this.walletWindow) == null ? void 0 : _this$walletWindow.close();
+  }
+  sendMessage(message) {
+    if (!this.walletWindow) {
+      utils.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);
+  }
+}
+
+class WindowMessageHandler extends BaseWalletTransport {
+  constructor(walletRequestHandler) {
+    var _this;
+    super(walletRequestHandler);
+    _this = this;
+    this._isPopup = false;
+    // onmessage is called when (the wallet) receives request messages from the dapp
+    // over the window post-messaging transport
+    this.onWindowEvent = async function (event) {
+      if (!event.origin || event.origin === '') {
+        // skip same-origin or when event.origin is empty/undefined
+        return;
+      }
+      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;
+      try {
+        request = JSON.parse(event.data);
+      } catch (err) {
+        // event is not a ProviderMessage JSON object, skip
+        return;
+      }
+      utils.logger.debug('RECEIVED MESSAGE', request);
+
+      // Record event origin for valid init ack
+      if (_this._init !== InitState.OK && _this.isValidInitAck(request)) {
+        _this.appOrigin = event.origin;
+      }
+      if (_this._init === InitState.OK && (!_this.appOrigin || _this.appOrigin.length < 8)) {
+        // impossible state
+        utils.logger.error('impossible state, init.OK and appOrigin required');
+        return;
+      }
+
+      // Handle message via the base transport
+      _this.handleMessage(request);
+    };
+    this.getWindowTransportSession = windowParams => {
+      const params = new WindowSessionParams(windowParams);
+      return {
+        sessionId: params.get('sid'),
+        networkId: params.get('net'),
+        intent: utils.base64DecodeObject(params.get('intent'))
+      };
+    };
+    this._init = InitState.NIL;
+  }
+  async 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
+    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
+    if (!isNewWindowSession) {
+      session = await this.getCachedTransportSession();
+    }
+    if (!session) {
+      utils.logger.error('window session is undefined');
+      return;
+    }
+
+    // record parent window instance for communication
+    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
+    this.open(session).then(opened => {
+      if (!opened) {
+        var _session;
+        const err = `failed to open to network ${(_session = session) == null ? void 0 : _session.networkId}`;
+        utils.logger.error(err);
+        this.notifyClose({
+          message: err
+        });
+        window.close();
+      }
+    }).catch(e => {
+      var _session2;
+      const err = `failed to open to network ${(_session2 = session) == null ? void 0 : _session2.networkId}, due to: ${e}`;
+      utils.logger.error(err);
+      this.notifyClose({
+        message: err
+      });
+      window.close();
+    });
+  }
+  unregister() {
+    window.removeEventListener('message', this.onWindowEvent);
+    this._registered = false;
+  }
+  // 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 (message.type === EventType.INIT) {
+      this.postMessage(payload, true);
+    } else {
+      this.postMessage(payload);
+    }
+  }
+  get isPopup() {
+    return this._isPopup;
+  }
+  postMessage(message, init = false) {
+    if (init !== true && this._init !== InitState.OK) {
+      utils.logger.error('impossible state, should not be calling postMessage until inited');
+      return;
+    }
+    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 {
+        utils.logger.error('unable to postMessage as parentOrigin is invalid');
+      }
+    }
+  }
+}
+
+function isMuxTransportTemplate(obj) {
+  return obj && typeof obj === 'object' && (obj.windowTransport && typeof obj.windowTransport === 'object' || obj.proxyTransport && typeof obj.proxyTransport === 'object' || obj.extensionTransport && typeof obj.extensionTransport === 'object' || obj.unrealTransport && typeof obj.unrealTransport === 'object') && (
+  // One of the transports must be enabled
+  obj.windowTransport && obj.windowTransport.enabled || obj.proxyTransport && obj.proxyTransport.enabled || obj.extensionTransport && obj.extensionTransport.enabled || obj.unrealTransport && obj.unrealTransport.enabled);
+}
+class MuxMessageProvider {
+  constructor(...messageProviders) {
+    var _this = this;
+    this.register = () => {
+      if (this.messageProviders.length === 1) {
+        this.provider = this.messageProviders[0];
+        this.provider.register();
+        return;
+      }
+
+      // REVIEW/NOTE: ........ this method does not work for the chrome-extension. The issue becomes
+      // when the browser quits or restarts, the "open" event is never triggered. Perhaps the code here is fine,
+      // or maybe its not. What should happen is when a dapp makes a request, it will call openWallet
+      // below, in which case one of the events will register. So perhaps this is fine.
+      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();
+      }
+      return Promise.race(_this.messageProviders.map(p => p.waitUntilOpened()));
+    };
+    this.waitUntilConnected = async function () {
+      if (_this.provider) {
+        return _this.provider.waitUntilConnected();
+      }
+      throw new Error('impossible state, wallet must be opened first');
+    };
+    this.messageProviders = messageProviders;
+    this.provider = undefined;
+  }
+  static new(template) {
+    var _template$windowTrans, _template$proxyTransp, _template$extensionTr, _template$unrealTrans;
+    const muxMessageProvider = new MuxMessageProvider();
+    if ((_template$windowTrans = template.windowTransport) != null && _template$windowTrans.enabled && typeof window === 'object' && template.walletAppURL) {
+      const windowMessageProvider = new WindowMessageProvider(template.walletAppURL);
+      muxMessageProvider.add(windowMessageProvider);
+    }
+    if ((_template$proxyTransp = template.proxyTransport) != null && _template$proxyTransp.enabled) {
+      const proxyMessageProvider = new ProxyMessageProvider(template.proxyTransport.appPort);
+      muxMessageProvider.add(proxyMessageProvider);
+    }
+    if ((_template$extensionTr = template.extensionTransport) != null && _template$extensionTr.enabled) {
+      const extensionMessageProvider = new ExtensionMessageProvider(template.extensionTransport.runtime);
+      muxMessageProvider.add(extensionMessageProvider);
+
+      // NOTE/REVIEW: see note in mux-message-provider
+      //
+      // We don't add the extensionMessageProvider here because we don't send requests to it anyways, we seem to
+      // send all requests to the WindowMessageProvider anyways. By allowing it, if browser restarts, it will break
+      // the entire extension because messageProvider.provider will be undefined. So this is a hack to fix it.
+    }
+
+    if ((_template$unrealTrans = template.unrealTransport) != null && _template$unrealTrans.enabled && template.windowTransport && template.walletAppURL) {
+      const unrealMessageProvider = new UnrealMessageProvider(template.walletAppURL);
+      muxMessageProvider.add(unrealMessageProvider);
+    }
+    muxMessageProvider.register();
+    return muxMessageProvider;
+  }
+  add(...messageProviders) {
+    this.messageProviders.push(...messageProviders);
+  }
+  closeWallet() {
+    if (this.provider) {
+      this.provider.closeWallet();
+    }
+  }
+  isOpened() {
+    if (this.provider) {
+      return this.provider.isOpened();
+    }
+    return false;
+  }
+  isConnected() {
+    if (this.provider) {
+      return this.provider.isConnected();
+    }
+    return false;
+  }
+  on(event, fn) {
+    if (this.provider) {
+      this.provider.on(event, fn);
+      return;
+    }
+    this.messageProviders.forEach(m => {
+      m.on(event, fn);
+    });
+  }
+  once(event, fn) {
+    if (this.provider) {
+      this.provider.once(event, fn);
+      return;
+    }
+    this.messageProviders.forEach(m => {
+      m.once(event, fn);
+    });
+  }
+  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');
+    }
+    if (this.provider) {
+      this.provider.sendMessage(message);
+    } else {
+      throw new Error('impossible state, wallet must be opened first');
+    }
+  }
+  handleMessage(message) {
+    if (this.provider) {
+      this.provider.handleMessage(message);
+      return;
+    }
+    throw new Error('impossible state, wallet must be opened first');
+  }
+}
+
+function toExtended(transactions) {
+  if (transactions.length === 0) {
+    throw new Error("No transaction provided");
+  }
+  const [first, ...rest] = transactions;
+  return _extends({}, first, {
+    auxiliary: rest
+  });
+}
+function fromExtended(transaction) {
+  return [transaction, ...(transaction.auxiliary || [])];
+}
+
+function validateTransactionRequest(wallet, transaction) {
+  const transactions = core.commons.transaction.fromTransactionish(wallet, transaction);
+  const unwound = core.commons.transaction.unwind(wallet, transactions);
+  unwound.forEach(transaction => validateTransaction(wallet, transaction));
+}
+function validateTransaction(wallet, transaction) {
+  if (transaction.to.toLowerCase() === wallet.toLowerCase()) {
+    if (transaction.data) {
+      const data = ethers.ethers.utils.arrayify(transaction.data);
+      if (data.length >= 4) {
+        throw new Error('self calls are forbidden');
+      }
+    }
+  }
+  if (transaction.delegateCall) {
+    throw new Error('delegate calls are forbidden');
+  }
+}
+
+const SIGNER_READY_TIMEOUT = 10000;
+class WalletRequestHandler {
+  constructor(_account, prompter, networks) {
+    var _this = this;
+    // signer interface of the wallet. A null value means there is no signer (ie. user not signed in). An undefined
+    // value means the signer state is unknown, usually meaning the wallet app is booting up and initializing. Of course
+    // a Signer value is the actually interface to a signed-in account
+    this.signerReadyCallbacks = [];
+    this.events = new eventemitter2.EventEmitter2();
+    this.onConnectOptionsChange = undefined;
+    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');
+      }
+      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
         };
       });
@@ -1888,6 +2316,7 @@ class WalletRequestHandler {
                 }
                 return tx;
               });
+              validateTransactionRequest(account.address, transactionParams);
               let txnHash = '';
               if (_this.prompter === null) {
                 // prompter is null, so we'll send from here
@@ -1913,6 +2342,7 @@ class WalletRequestHandler {
               if (sender !== account.address) {
                 throw new Error('sender address does not match wallet');
               }
+              validateTransactionRequest(account.address, transaction);
               if (_this.prompter === null) {
                 // The eth_signTransaction method expects a `string` return value we instead return a `SignedTransactions` object,
                 // this can only be broadcasted using an RPC provider with support for signed Sequence transactions, like this one.
@@ -2155,16 +2585,6 @@ class WalletRequestHandler {
     var _this$prompter$getDef, _this$prompter;
     return (_this$prompter$getDef = (_this$prompter = this.prompter) == null ? void 0 : _this$prompter.getDefaultChainId()) != null ? _this$prompter$getDef : this.networks[0].chainId;
   }
-  findNetworkID(network) {
-    const lnet = typeof network === 'string' ? network.toLowerCase() : network;
-    const networkId = this.networks.find(n => {
-      return n.name.toLowerCase() === lnet || n.chainId.toString() === lnet || n.chainId === lnet;
-    });
-    if (!networkId) {
-      throw new Error(`Network ${network} not found`);
-    }
-    return networkId.chainId;
-  }
   async signIn(account, options = {}) {
     this.setAccount(account);
     const {
@@ -2233,24 +2653,7 @@ class WalletRequestHandler {
         error: 'unable to connect without signed in account'
       };
     }
-    let chainId;
-    switch (typeof (options == null ? void 0 : options.networkId)) {
-      case 'string':
-        // First see if it matches the name of a network
-        try {
-          chainId = this.findNetworkID(options.networkId);
-        } catch (err) {
-          // If not, try to parse it as a big number
-          chainId = network.getChainId(options.networkId);
-        }
-        break;
-      case 'number':
-        chainId = options.networkId;
-        break;
-      default:
-        chainId = (_this$prompter$getDef2 = (_this$prompter4 = this.prompter) == null ? void 0 : _this$prompter4.getDefaultChainId()) != null ? _this$prompter$getDef2 : 1;
-        break;
-    }
+    const chainId = (_this$prompter$getDef2 = (_this$prompter4 = this.prompter) == null ? void 0 : _this$prompter4.getDefaultChainId()) != null ? _this$prompter$getDef2 : 1;
     const connectDetails = {
       connected: true,
       chainId: ethers.ethers.BigNumber.from(chainId).toHexString()
@@ -2362,6 +2765,7 @@ class WalletRequestHandler {
   }
   notifyConnect(connectDetails, origin) {
     var _connectDetails$sessi;
+    console.log('emit connect', connectDetails);
     this.events.emit('connect', connectDetails);
     if ((_connectDetails$sessi = connectDetails.session) != null && _connectDetails$sessi.accountAddress) {
       var _connectDetails$sessi2;
@@ -2447,1412 +2851,1089 @@ function getLegacyWalletState(chainId, status) {
 }
 const permittedJsonRpcMethods = ['net_version', 'eth_chainId', 'eth_getBalance', 'eth_getTransactionCount', 'eth_blockNumber', 'eth_getBlockByNumber', 'eth_getBlockByHash', 'eth_getTransactionByHash', 'eth_getCode', 'eth_estimateGas', 'eth_gasPrice', 'sequence_getWalletContext', 'sequence_getNetworks', 'sequence_setDefaultNetwork'];
 
-const CHANNEL_ID = 'sequence-extension-message-handler';
-class ExtensionMessageHandler extends BaseWalletTransport {
-  constructor(walletRequestHandler, runtime) {
-    super(walletRequestHandler);
-    this.runtime = runtime;
-    this._init = InitState.OK;
+class SequenceSigner {
+  get utils() {
+    return this.provider.utils;
+  }
+  constructor(client, provider) {
+    this.singleNetworkSigners = {};
+    this._isSigner = true;
+    this._isSequenceSigner = true;
+    this.client = client;
+    this.provider = provider;
+  }
+  async getAddress() {
+    return this.client.getAddress();
+  }
+
+  // This method shouldn't be used directly
+  // it exists to maintain compatibility with ethers.Signer
+  connect(provider) {
+    if (!SequenceProvider.is(provider)) {
+      throw new Error("SequenceSigner can only be connected to a SequenceProvider");
+    }
+    return new SequenceSigner(this.client, provider);
+  }
+  getSigner(chainId) {
+    // The signer for the default network is this signer
+    if (!chainId) {
+      return this;
+    }
+    const useChainId = this.provider.toChainId(chainId);
+    if (!this.singleNetworkSigners[useChainId]) {
+      this.singleNetworkSigners[useChainId] = new SingleNetworkSequenceSigner(this.client, this.provider, useChainId);
+    }
+    return this.singleNetworkSigners[useChainId];
+  }
+
+  /**
+   *  Resolves the chainId to use for the given request. If no chainId is provided,
+   *  it uses the chainId defined by the client (default chainId). This can be
+   *  overriden to build a single-network SequenceProvider.
+   */
+  useChainId(chainId) {
+    return this.provider.toChainId(chainId) || this.client.getChainId();
+  }
+  async signMessage(message, options) {
+    const {
+      eip6492 = true
+    } = options || {};
+    const chainId = this.useChainId(options == null ? void 0 : options.chainId);
+    return this.client.signMessage(message, {
+      eip6492,
+      chainId
+    });
+  }
+  async signTypedData(domain, types, message, options) {
+    const {
+      eip6492 = true
+    } = options || {};
+    const chainId = this.useChainId(options == null ? void 0 : options.chainId);
+    return this.client.signTypedData({
+      domain,
+      types,
+      message
+    }, {
+      eip6492,
+      chainId
+    });
+  }
+  getProvider(chainId) {
+    return this.provider.getProvider(chainId);
+  }
+  async sendTransaction(transaction, options) {
+    const chainId = this.useChainId(options == null ? void 0 : options.chainId);
+    const resolved = await resolveArrayProperties(transaction);
+    const txHash = await this.client.sendTransaction(resolved, {
+      chainId
+    });
+    const provider = this.getProvider(chainId);
+    try {
+      return await ethers.ethers.utils.poll(async function () {
+        const tx = await provider.getTransaction(txHash);
+        return tx ? provider._wrapTransaction(tx, txHash) : undefined;
+      }, {
+        onceBlock: provider
+      });
+    } catch (err) {
+      err.transactionHash = txHash;
+      throw err;
+    }
   }
-  register() {
-    this._registered = true;
-    this.port = this.runtime.connect({
-      name: CHANNEL_ID
+  async getWalletConfig(chainId) {
+    const useChainId = this.useChainId(chainId);
+    return this.client.getOnchainWalletConfig({
+      chainId: useChainId
     });
   }
-  sendMessage(message) {
-    utils.logger.info('[ExtensionMessageHandler send]', message);
-    this.port.postMessage(message);
+  getNetworks() {
+    return this.client.getNetworks();
   }
-}
-
-class ExtensionMessageProvider extends BaseProviderTransport {
-  constructor(runtime) {
-    super();
-    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 getBalance(blockTag, optionals) {
+    const provider = this.getProvider(optionals == null ? void 0 : optionals.chainId);
+    return provider.getBalance(this.getAddress(), blockTag);
   }
-  sendMessage(message) {
-    //noop
+  async estimateGas(transaction, optionals) {
+    return this.getProvider(optionals == null ? void 0 : optionals.chainId).estimateGas(transaction);
   }
-  unregister() {
-    //noop
+  async call(transaction, blockTag, optionals) {
+    return this.getProvider(optionals == null ? void 0 : optionals.chainId).call(transaction, blockTag);
   }
-  openWallet(path, intent, networkId) {
-    //noop
+  getChainId() {
+    return Promise.resolve(this.client.getChainId());
   }
-  closeWallet() {
-    //noop
+  async getGasPrice(optionals) {
+    return this.getProvider(optionals == null ? void 0 : optionals.chainId).getGasPrice();
   }
-}
-
-// to be used on injected window.ethereum EIP1193 proxy
-class BaseInjectedTransport extends eventemitter2.EventEmitter2 {
-  constructor(stream) {
-    var _this;
-    super();
-    _this = this;
-    this.responseCallbacks = new Map();
-    this._messageIdx = 0;
-    this.nextMessageIdx = () => ++this._messageIdx;
-    this.handleMessage = message => {
-      if (!message.type || !message.data) {
-        return;
-      }
-      utils.logger.info('[received message]', message);
-      const requestIdx = message.idx;
-      const responseCallback = this.responseCallbacks.get(requestIdx);
-      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');
-          }
-          break;
-        case EventType.DISCONNECT:
-        case EventType.ACCOUNTS_CHANGED:
-        case EventType.CHAIN_CHANGED:
-          this.emit(message.type, message.data);
-          break;
-        default:
-          console.error('unknown message type', message);
-          break;
-      }
-    };
-    this.sendMessageRequest = async function (message) {
-      return new Promise((resolve, reject) => {
-        if (!message.idx || message.idx <= 0) {
-          reject(new Error('message idx not set'));
-        }
-        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;
-        if (!_this.responseCallbacks.get(idx)) {
-          _this.responseCallbacks.set(idx, responseCallback);
-        } else {
-          reject(new Error('duplicate message idx, should never happen'));
-        }
-        _this.sendMessage(message);
-      });
-    };
-    this.stream = stream;
-    this.stream.on('data', this.handleMessage);
+  async getFeeData(optionals) {
+    return this.getProvider(optionals == null ? void 0 : optionals.chainId).getFeeData();
   }
-  sendMessage(message) {
-    if (!this.stream.writable) {
-      console.error('window post message stream is not writable');
+  async resolveName(name) {
+    const res = await this.provider.resolveName(name);
+
+    // For some reason ethers.Signer expects this to return `string`
+    // but ethers.providers.Provider expects this to return `string | null`.
+    // The signer doesn't have any other source of information, so we'll
+    // fail if the provider doesn't return a result.
+    if (res === null) {
+      throw new Error(`ENS name not found: ${name}`);
     }
-    this.stream.write(message);
+    return res;
   }
-}
-
-/**
- * This will redirect console logs from Sequence.js & the wallet to the Unreal console, for debugging purposes.
- */
-function overrideLogs(side) {
-  var _window$ue;
-  if ((_window$ue = window.ue) != null && _window$ue.sequencewallettransport && !window.logsOverriddenForUnreal) {
-    var _window$ue2;
-    const t = (_window$ue2 = window.ue) == null ? void 0 : _window$ue2.sequencewallettransport;
-    console.log = (...args) => {
-      t.logfromjs(`${side}: ${stringify(args)}`);
-    };
-    console.warn = (...args) => {
-      t.warnfromjs(`${side}: ${stringify(args)}`);
-    };
-    console.error = (...args) => {
-      t.errorfromjs(`${side}: ${stringify(args)}`);
-    };
-    window.logsOverriddenForUnreal = true;
+  _checkProvider(_operation) {
+    // We always have a provider, so this is a noop
   }
-}
-function stringify(things) {
-  return things.map(a => typeof a === 'object' ? a instanceof Error ? a.message : JSON.stringify(a) : String(a)).join(' ');
-}
-
-let registeredUnrealMessageProvider;
-
-// all lowercase is an annoying limitation of Unreal CEF BindUObject
-
-/**
- * Initialized on dApp side
- */
-class UnrealMessageProvider extends BaseProviderTransport {
-  constructor(walletAppURL) {
-    super();
-    this.register = () => {
-      var _window$ue;
-      overrideLogs('dapp');
-      if (registeredUnrealMessageProvider) {
-        // overriding the registered message provider
-        registeredUnrealMessageProvider.unregister();
-        registeredUnrealMessageProvider = this;
-      }
-
-      // listen for incoming messages from wallet
-      if ((_window$ue = window.ue) != null && _window$ue.sequencewallettransport) {
-        window.ue.sequencewallettransport.onmessagefromwallet = this.onUnrealCallback;
-      }
-      registeredUnrealMessageProvider = this;
-      this._registered = true;
-      console.log('registering transport!');
-    };
-    this.unregister = () => {
-      var _window$ue2, _window$ue2$sequencew;
-      this._registered = false;
-      this.closeWallet();
-
-      // disable message listener
-      if (registeredUnrealMessageProvider === this) {
-        registeredUnrealMessageProvider = undefined;
-      }
-      if (((_window$ue2 = window.ue) == null ? void 0 : (_window$ue2$sequencew = _window$ue2.sequencewallettransport) == null ? void 0 : _window$ue2$sequencew.onmessagefromwallet) === this.onUnrealCallback) {
-        delete window.ue.sequencewallettransport.onmessagefromwallet;
-      }
-
-      // clear event listeners
-      this.events.removeAllListeners();
-    };
-    this.openWallet = (path, intent, networkId) => {
-      if (this.isOpened()) {
-        // TODO focus wallet
-        console.log('wallet already open!');
-        return;
-      }
-      console.log('opening wallet!');
-      // Instantiate new walletURL for this call
-      const walletURL = new URL(this.walletURL.href);
-      const windowSessionParams = new WindowSessionParams();
-      if (path) {
-        walletURL.pathname = path.toLowerCase();
-      }
-
-      // Set session, intent and network id on walletURL
-      this._init = InitState.NIL;
-      this._sessionId = `${performance.now()}`;
-      windowSessionParams.set('sid', this._sessionId);
-      if (intent) {
-        // encode intent as base64 url-encoded param
-        windowSessionParams.set('intent', utils.base64EncodeObject(intent));
-      }
-      if (networkId) {
-        windowSessionParams.set('net', `${networkId}`);
-      }
-      // serialize params
-      walletURL.search = windowSessionParams.toString();
-      console.log('opening wallet to', walletURL.href);
-      window.open(walletURL.href);
-    };
-    // onmessage, receives ProviderMessageResponse from the wallet unreal transport
-    this.onUnrealCallback = message => {
-      if (!message) {
-        throw new Error('ProviderMessage object is empty');
-      }
-
-      // handle message with base message provider
-      this.handleMessage(message);
-    };
-    this.walletURL = new URL(walletAppURL);
+  populateTransaction(_transaction) {
+    throw new Error("SequenceSigner does not support populateTransaction");
   }
-  closeWallet() {
-    this.close();
+  checkTransaction(_transaction) {
+    throw new Error("SequenceSigner does not support checkTransaction");
   }
-  // all lowercase is an annoying limitation of Unreal CEF BindUObject
-  sendMessage(message) {
-    var _window$ue3, _window$ue3$sequencew;
-    const postedMessage = typeof message !== 'string' ? JSON.stringify(message) : message;
-    console.log('Sending message to wallet:', postedMessage);
-    (_window$ue3 = window.ue) == null ? void 0 : (_window$ue3$sequencew = _window$ue3.sequencewallettransport) == null ? void 0 : _window$ue3$sequencew.sendmessagetowallet(postedMessage);
+  getTransactionCount(_blockTag) {
+    // We could try returning the sequence nonce here
+    // but we aren't sure how ethers will use this nonce
+    throw new Error("SequenceSigner does not support getTransactionCount");
   }
-}
-
-// all lowercase is an annoying limitation of Unreal CEF BindUObject
-
-/**
- * Initialized on Wallet side
- */
-class UnrealMessageHandler extends BaseWalletTransport {
-  constructor(walletRequestHandler) {
-    super(walletRequestHandler);
-    // onmessage is called when (the wallet) receives request messages from the dapp
-    // over the unreal json-messaging transport
-    this.onMessageFromUnreal = request => {
-      // Wallet always expects json-rpc request messages from a dapp
-
-      utils.logger.debug('RECEIVED MESSAGE', request);
-
-      // Handle message via the base transport
-      this.handleMessage(request);
-    };
-    this.getUnrealTransportSession = windowParams => {
-      const params = new WindowSessionParams(windowParams);
-      return {
-        sessionId: params.get('sid'),
-        networkId: params.get('net'),
-        intent: utils.base64DecodeObject(params.get('intent'))
-      };
-    };
-    this._init = InitState.NIL;
+  signTransaction(_transaction) {
+    // We could implement signTransaction/sendTransaction here
+    // but first we need a way of serializing these signed transactions
+    // and it could lead to more trouble, because the dapp could try to send this transaction
+    // using a different provider, which would fail.
+    throw new Error("SequenceWallet does not support signTransaction, use sendTransaction instead.");
+  }
+  static is(cand) {
+    return cand && typeof cand === "object" && cand._isSequenceSigner === true;
   }
-  async register(windowHref) {
-    var _window$ue;
-    if (((_window$ue = window.ue) == null ? void 0 : _window$ue.sequencewallettransport) === undefined) {
-      return;
-    }
-    overrideLogs('wallet');
-
-    // record open details (sessionId + default network) from the window url
-    const {
-      search: rawParams
-    } = new URL(windowHref || window.location.href);
-    let session = this.getUnrealTransportSession(rawParams);
+}
 
-    // provider should always include sid when opening a new window
-    const isNewWindowSession = !!session.sessionId;
+/**
+ *  This is the same provider, but it only allows a single network at a time.
+ *  the network defined by the constructor is the only one that can be used.
+ * 
+ *  Attempting to call any method with a different network will throw an error.
+ *  Attempting to change the network of this provider will throw an error.
+ * 
+ *  NOTICE: These networks won't support ENS unless they are the mainnet.
+ */
+class SingleNetworkSequenceSigner extends SequenceSigner {
+  constructor(client, provider, chainId) {
+    super(client, provider.getProvider(chainId));
+    this._isSingleNetworkSequenceSigner = true;
+    this.chainId = chainId;
+  }
+  _useChainId(chainId) {
+    const provided = this.provider.toChainId(chainId);
+    if (provided && provided !== this.chainId) {
+      throw new Error(`This signer only supports the network ${this.chainId}, but ${provided} was requested.`);
+    }
+    return provided || this.provider.toChainId(this.chainId);
+  }
+  useChainId(chainId) {
+    return this._useChainId(chainId);
+  }
+  getChainId() {
+    return Promise.resolve(this.provider.toChainId(this.chainId));
+  }
 
-    // attempt to restore previous session in the case of a redirect or window reload
-    if (!isNewWindowSession) {
-      session = await this.getCachedTransportSession();
+  /**
+   *  Override getProvider and getSigner so they always use `useChainId`
+   *  this way they can't return providers and signers that can switch networks,
+   *  or that don't match the chainId of this signer.
+   */
+  getProvider(chainId) {
+    return super.getProvider(this._useChainId(chainId));
+  }
+  getSigner(chainId) {
+    if (this._useChainId(chainId) !== this.chainId) {
+      throw new Error(`Unreachable code`);
     }
-    if (!session) {
-      utils.logger.error('unreal session is undefined');
-      return;
+    return this;
+  }
+  static is(cand) {
+    return cand && typeof cand === "object" && cand._isSingleNetworkSequenceSigner === true;
+  }
+}
+
+/**
+ *  This class is redundant with the SequenceSigner class, but it is here for now to
+ *  maintain compatibility with the old wallet API. Eventually we should move these
+ *  methods to the SequenceSigner class and deprecate this class.
+ */
+class WalletUtils {
+  constructor(signer) {
+    this.signer = signer;
+    if (SingleNetworkSequenceSigner.is(signer)) {
+      throw new Error('WalletUtils does not support SingleNetworkSequenceSigner');
     }
+  }
 
-    // listen for window-transport requests
-    window.ue.sequencewallettransport.onmessagefromsequencejs = this.onMessageFromUnreal;
-    this._registered = true;
+  // Sign message on a specified chain, or DefaultChain by default
+  signMessage(message, chainId, eip6492) {
+    return this.signer.signMessage(message, {
+      chainId,
+      eip6492
+    });
+  }
 
-    // send open event to the app which opened us
-    this.open(session).then(opened => {
-      if (!opened) {
-        var _session;
-        const err = `failed to open to network ${(_session = session) == null ? void 0 : _session.networkId}`;
-        utils.logger.error(err);
-        this.notifyClose({
-          message: err
-        });
-        window.close();
-      }
-    }).catch(e => {
-      var _session2;
-      const err = `failed to open to network ${(_session2 = session) == null ? void 0 : _session2.networkId}, due to: ${e}`;
-      utils.logger.error(err);
-      this.notifyClose({
-        message: err
-      });
-      window.close();
+  // Sign EIP-712 TypedData on a specified chain, or DefaultChain by default
+  signTypedData(domain, types, message, chainId, eip6492) {
+    return this.signer.signTypedData(domain, types, message, {
+      chainId,
+      eip6492
     });
   }
-  unregister() {
-    var _window$ue2, _window$ue2$sequencew;
-    if (((_window$ue2 = window.ue) == null ? void 0 : (_window$ue2$sequencew = _window$ue2.sequencewallettransport) == null ? void 0 : _window$ue2$sequencew.onmessagefromsequencejs) === this.onMessageFromUnreal) {
-      delete window.ue.sequencewallettransport.onmessagefromsequencejs;
-    }
-    this._registered = false;
+
+  // Verify signature of a digest, one of a message, typedData or other
+  async isValidSignature(address, digest, signature, chainId) {
+    return isValidSignature(address, digest, signature, this.signer.getProvider(chainId));
   }
-  // sendMessage sends message to the dapp window
-  sendMessage(message) {
-    var _window$ue3, _window$ue3$sequencew;
-    if (message.type !== EventType.INIT && this._init !== InitState.OK) {
-      utils.logger.error('impossible state, should not be calling postMessage until inited');
-      return;
-    }
-    // prepare payload
-    const payload = JSON.stringify(message);
 
-    // post-message to app.
-    (_window$ue3 = window.ue) == null ? void 0 : (_window$ue3$sequencew = _window$ue3.sequencewallettransport) == null ? void 0 : _window$ue3$sequencew.sendmessagetosequencejs(payload);
+  // Verify message signature
+  async isValidMessageSignature(address, message, signature, chainId) {
+    const provider = this.signer.getProvider(chainId);
+    const prefixed = prefixEIP191Message(message);
+    const digest = utils.encodeMessageDigest(prefixed);
+    return isValidSignature(address, digest, signature, provider);
   }
-}
 
-class Web3Provider extends ethers.providers.Web3Provider {
-  static isSequenceProvider(cand) {
-    return isSequenceProvider(cand);
+  // Verify typedData signature
+  isValidTypedDataSignature(address, typedData, signature, chainId) {
+    return this.isValidSignature(address, utils.encodeTypedDataDigest(typedData), signature, chainId);
   }
 
-  // defaultChainId is the default chainId to use with requests, but may be
-  // overridden by passing chainId argument to a specific request
-  constructor(provider, defaultChainId) {
-    const sender = new network.JsonRpcSender(provider, network.maybeChainId(defaultChainId));
-    provider = sender;
-    super(provider, 'any');
-    this._sender = sender;
+  // sendTransaction()
+  // sendTransactions()
+
+  // sendETH()
+  // sendToken()
+  // sendCoin() -- sugar for sendToken()
+  // sendCollectible() -- sugar for sendToken()
+  // callContract()
+
+  // transactionHistory()
+  // getReceipt()
+  // getLogs()
+  // // ..
+
+  // validateSignature()
+  // recoverWalletConfig()
+  // recoverAddress()
+}
+
+class SequenceProvider extends ethers.ethers.providers.BaseProvider {
+  constructor(client, providerFor, networks = network.allNetworks) {
+    // We support a lot of networks
+    // but we start with the default one
+    super(client.getChainId());
+
+    // Emit events as defined by EIP-1193
+    this.singleNetworkProviders = {};
     this._isSequenceProvider = true;
-    this._defaultChainId = network.maybeChainId(defaultChainId);
+    this.client = client;
+    this.providerFor = providerFor;
+    this.networks = networks;
+    client.onConnect(details => {
+      this.emit('connect', details);
+    });
+    client.onDisconnect(error => {
+      this.emit('disconnect', error);
+    });
+    client.onDefaultChainIdChanged(chainId => {
+      this.emit('chainChanged', chainId);
+    });
+    client.onAccountsChanged(accounts => {
+      this.emit('accountsChanged', accounts);
+    });
+
+    // NOTICE: We don't emit 'open' and 'close' events
+    // because these are handled by the library, and they
+    // are not part of EIP-1193
+
+    // devs can still access them using
+    //   client.onOpen()
+    //   client.onClose()
+
+    // Create a Sequence signer too
+    this.signer = new SequenceSigner(this.client, this);
+
+    // Create a utils instance
+    this.utils = new WalletUtils(this.signer);
   }
-  sendAsync(request, callback, chainId) {
-    this._sender.sendAsync(request, callback, chainId);
+  getSigner(chainId) {
+    return this.signer.getSigner(chainId);
   }
-  send(method, params, chainId) {
-    return this._sender.send(method, params, chainId);
+  connect(options) {
+    return this.client.connect(options);
   }
-  request(request) {
-    return this.send(request.method, request.params || [], request.chainId);
+  disconnect() {
+    return this.client.disconnect();
   }
-  getSigner() {
-    return new Web3Signer(this, this._defaultChainId);
+  isConnected() {
+    return this.client.isConnected();
+  }
+  getSession() {
+    return this.client.getSession();
+  }
+  listAccounts() {
+    return [this.client.getAddress()];
   }
-  async getChainId() {
-    // If we already have a default chainId, then we can just return it
-    const defaultChainId = this._defaultChainId;
-    if (defaultChainId) return defaultChainId;
 
-    // If there is no default chain, then we can just return the chainId of the provider
-    return this.send('eth_chainId', []);
+  // @deprecated use getSigner() instead
+  getAddress() {
+    return this.client.getAddress();
   }
   getNetworks() {
-    return this.send('sequence_getNetworks', []);
+    return this.client.getNetworks();
   }
-}
-function isSequenceProvider(provider) {
-  const cand = provider;
-  return cand && cand.send !== undefined && cand._isSequenceProvider === true;
-}
-class LocalWeb3Provider extends Web3Provider {
-  constructor(account, networks) {
-    const walletRequestHandler = new WalletRequestHandler(account, null, networks || []);
-    super(walletRequestHandler);
+  getChainId() {
+    return this.client.getChainId();
   }
-}
-
-// TODO: in the future with ethers v6 we can remove/change this type name
-
-class Web3Signer extends wallet.Signer {
-  constructor(provider, defaultChainId) {
-    super();
-    this._providers = {};
-    this.provider = provider;
-    this.defaultChainId = defaultChainId;
+  setDefaultChainId(chainId) {
+    return this.client.setDefaultChainId(this.toChainId(chainId));
+  }
+  isOpened() {
+    return this.client.isOpened();
+  }
+  closeWallet() {
+    return this.client.closeWallet();
+  }
+  getWalletContext() {
+    return this.client.getWalletContext();
   }
 
-  // memoized
-
-  //
-  // 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.ethers.utils.getAddress(this._address);
+  // @deprecated use getSigner() instead
+  async getWalletConfig(chainId) {
+    const useChainId = await this.useChainId(chainId);
+    return this.client.getOnchainWalletConfig({
+      chainId: useChainId
+    });
   }
-  signTransaction(transaction) {
-    // TODO .. since ethers isn't using this method, perhaps we will?
-    throw new Error('signTransaction is unsupported, use signTransactions instead');
+  authorize(options) {
+    // Just an alias for connect with authorize: true
+    return this.client.connect(_extends({}, options, {
+      authorize: true
+    }));
   }
-  connect(provider) {
-    throw new Error('unsupported: cannot alter JSON-RPC Signer connection');
+  async openWallet(path, intent) {
+    await this.client.openWallet(path, intent);
+    return true;
+  }
+  toChainId(chainId) {
+    if (chainId === undefined) {
+      return undefined;
+    }
+    const resolved = network.findNetworkConfig(this.networks, chainId);
+    if (!resolved) {
+      throw new Error(`Unsupported network ${chainId}`);
+    }
+    return resolved.chainId;
   }
 
-  //
-  // Sequence Signer methods
-  //
+  /**
+   *  Resolves the chainId to use for the given request. If no chainId is provided,
+   *  it uses the chainId defined by the client (default chainId). This can be
+   *  overriden to build a single-network SequenceProvider.
+   */
+  async useChainId(chainId) {
+    return this.toChainId(chainId) || this.client.getChainId();
+  }
 
-  // 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).
-  async getProvider(chainId) {
-    if (chainId) {
-      const currentChainId = await this.getChainId();
-      if (currentChainId !== chainId) {
-        throw new Error(`signer is attempting to access chain ${chainId}, but is already bound to chain ${currentChainId}`);
-      }
+  /**
+   *  This generates a provider that ONLY works for the given chainId.
+   *  the generated provider can't switch networks, and can't handle requests
+   *  for other networks.
+   */
+
+  getProvider(chainId) {
+    // The provider without a chainId is... this one
+    if (!chainId) {
+      return this;
     }
-    return this.provider;
+    const useChainId = this.toChainId(chainId);
+    if (!this.singleNetworkProviders[useChainId]) {
+      this.singleNetworkProviders[useChainId] = new SingleNetworkSequenceProvider(this.client, this.providerFor, useChainId);
+    }
+    return this.singleNetworkProviders[useChainId];
   }
 
-  // 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.
-  async getSender(chainId) {
-    if (!chainId || chainId && chainId === this.defaultChainId) {
-      return this.provider;
-    }
-    if (!this._providers[chainId]) {
-      this._providers[chainId] = new Web3Provider(new network.JsonRpcSender(this.provider, chainId), chainId);
+  /**
+   *  This returns a subprovider, this is a regular non-sequence provider that
+   *  can be used to fulfill read only requests on a given network.
+   */
+  async _getSubprovider(chainId) {
+    const useChainId = await this.useChainId(chainId);
+
+    // Whoever implements providerFrom should memoize the generated provider
+    // otherwise every instance of SequenceProvider will create a new subprovider
+    const provider = this.providerFor(useChainId);
+    if (!provider) {
+      throw new Error(`Unsupported network ${useChainId}`);
     }
-    return this._providers[chainId];
+    return provider;
   }
-  getRelayer(chainId) {
-    // TODO: JsonRpcRelayer ......? or, Web3Relayer.. or SequenceRelayer?
-    // sequence_gasRefundOptions
-    // sequence_getNonce
-    // sequence_relay
-    throw new Error('TODO');
+  async perform(method, params) {
+    var _provider$prepareRequ;
+    // First we check if the method should be handled by the client
+    if (method === 'eth_chainId') {
+      return this.useChainId();
+    }
+    if (method === 'eth_accounts') {
+      return [this.client.getAddress()];
+    }
+    if (method === 'wallet_switchEthereumChain') {
+      const args = params[0];
+      const chainId = normalizeChainId(args);
+      return this.setDefaultChainId(chainId);
+    }
+
+    // Usually these methods aren't used by calling the provider
+    // but to maximize compatibility we support them too.
+    // The correct way of accessing these methods is by using .getSigner()
+    if (method === 'eth_sendTransaction' || method === 'eth_sign' || method === 'eth_signTypedData' || method === 'eth_signTypedData_v4' || method === 'personal_sign' ||
+    // These methods will use EIP-6492
+    // but this is handled directly by the wallet
+    method === 'sequence_sign' || method === 'sequence_signTypedData_v4') {
+      // We pass the chainId to the client, if we don't pass one
+      // the client will use its own default chainId
+      return this.client.send({
+        method,
+        params
+      }, this.getChainId());
+    }
+
+    // Forward call to the corresponding provider
+    // we use the provided chainId, or the default one provided by the client
+    const provider = await this._getSubprovider();
+    const prepared = (_provider$prepareRequ = provider.prepareRequest(method, params)) != null ? _provider$prepareRequ : [method, params];
+    return provider.send(prepared[0], prepared[1]);
+  }
+  send(method, params) {
+    return this.perform(method, params);
   }
-  async getWalletContext() {
-    if (!this._context) {
-      this._context = await this.provider.send('sequence_getWalletContext', []);
+  request(request) {
+    return this.perform(request.method, request.params);
+  }
+  async detectNetwork() {
+    const chainId = this.client.getChainId();
+    const network$1 = network.findNetworkConfig(this.networks, chainId);
+    if (!network$1) {
+      throw new Error(`Unknown network ${chainId}`);
     }
-    return this._context;
+    return network$1;
   }
-  async getWalletConfig(chainId) {
-    const reqChainId = network.maybeChainId(chainId) || this.defaultChainId;
-    if (!reqChainId) throw new Error('chainId is required');
-    return (await this.provider.send('sequence_getWalletConfig', [reqChainId], reqChainId))[0];
+
+  // Override most of the methods, so we add support for an optional chainId
+  // argument, which is used to select the provider to use.
+  //
+  // NOTICE: We could use generics to avoid repeating the same code
+  // but this would make the code harder to read, and it's not worth it
+  // since we only have a few methods to override.
+
+  async waitForTransaction(transactionHash, confirmations, timeout, optionals) {
+    const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
+    return provider.waitForTransaction(transactionHash, confirmations, timeout);
   }
-  async getWalletState(chainId) {
-    const reqChainId = network.maybeChainId(chainId) || this.defaultChainId;
-    if (!reqChainId) throw new Error('chainId is required');
-    return (await this.provider.send('sequence_getWalletState', [reqChainId], reqChainId))[0].status;
+  async getBlockNumber(optionals) {
+    const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
+    return provider.getBlockNumber();
   }
-  async getNetworks() {
-    if (!this._networks) this._networks = await this.provider.getNetworks();
-    return this._networks;
+  async getGasPrice(optionals) {
+    const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
+    return provider.getGasPrice();
   }
-  async getSigners() {
-    const networks = await this.getNetworks();
-
-    // TODO: Replace this with a method that aggregates signer addresses from all chains
-    const config = await this.getWalletConfig(networks[0].chainId);
-    if (!config) {
-      throw new Error(`walletConfig returned zero results for authChainId {authChainId}`);
-    }
-    return core.universal.genericCoderFor(config.version).config.signersOf(config).map(s => s.address);
+  async getBalance(addressOrName, blockTag, optionals) {
+    const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
+    return provider.getBalance(addressOrName, blockTag);
+  }
+  async getTransactionCount(addressOrName, blockTag, optionals) {
+    const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
+    return provider.getTransactionCount(addressOrName, blockTag);
+  }
+  async getCode(addressOrName, blockTag, optionals) {
+    const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
+    return provider.getCode(addressOrName, blockTag);
+  }
+  async getStorageAt(addressOrName, position, blockTag, optionals) {
+    const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
+    return provider.getStorageAt(addressOrName, position, blockTag);
+  }
+  async call(transaction, blockTag, optionals) {
+    const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
+    return provider.call(transaction, blockTag);
+  }
+  async estimateGas(transaction, optionals) {
+    const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
+    return provider.estimateGas(transaction);
+  }
+  async getBlock(blockHashOrBlockTag, optionals) {
+    const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
+    return provider.getBlock(blockHashOrBlockTag);
+  }
+  async getTransaction(transactionHash, optionals) {
+    const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
+    return provider.getTransaction(transactionHash);
+  }
+  async getLogs(filter, optionals) {
+    const provider = await this._getSubprovider(optionals == null ? void 0 : optionals.chainId);
+    return provider.getLogs(filter);
   }
 
-  // signMessage matches implementation from ethers JsonRpcSigner for compatibility, but with
-  // multi-chain support.
-  async signMessage(message, chainId, sequenceVerified = true) {
-    const provider = await this.getSender(network.maybeChainId(chainId) || this.defaultChainId);
-    const data = typeof message === 'string' ? ethers.ethers.utils.toUtf8Bytes(message) : message;
-    const address = await this.getAddress();
+  // ENS methods
 
-    // 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.
-    return provider.send(sequenceVerified ? 'sequence_sign' : 'personal_sign', [ethers.ethers.utils.hexlify(data), address]);
+  async supportsENS() {
+    const networks = await this.getNetworks();
+    return networks.some(n => n.chainId === 1);
   }
+  async getResolver(name) {
+    if (!(await this.supportsENS())) {
+      return null;
+    }
 
-  // signTypedData matches implementation from ethers JsonRpcSigner for compatibility, but with
-  // multi-chain support.
-  async signTypedData(domain, types, message, chainId, sequenceVerified = true) {
-    // Populate any ENS names (in-place)
-    // const populated = await ethers.utils._TypedDataEncoder.resolveNames(domain, types, message, (name: string) => {
-    //   return this.provider.resolveName(name)
-    // })
+    // Resolver is always on the chainId 1
+    const provider = await this._getSubprovider(1);
+    return provider.getResolver(name);
+  }
+  async resolveName(name) {
+    if (ethers.ethers.utils.isAddress(await name)) {
+      return name;
+    }
+    if (!(await this.supportsENS())) {
+      return null;
+    }
 
-    return this.provider.send(sequenceVerified ? 'sequence_signTypedData_v4' : 'eth_signTypedData_v4', [await this.getAddress(), ethers.ethers.utils._TypedDataEncoder.getPayload(domain, types, message)], network.maybeChainId(chainId) || this.defaultChainId);
+    // Resolver is always on the chainId 1
+    const provider = await this._getSubprovider(1);
+    return provider.resolveName(name);
   }
+  async lookupAddress(address) {
+    if (!(await this.supportsENS())) {
+      return null;
+    }
 
-  // sendTransaction matches implementation from ethers JsonRpcSigner for compatibility, but with
-  // multi-chain support.
-  async sendTransaction(transaction, chainId) {
-    const provider = await this.getSender(network.maybeChainId(chainId) || this.defaultChainId);
-    const tx = this.sendUncheckedTransaction(transaction, chainId).then(hash => {
-      return ethers.ethers.utils.poll(() => {
-        return provider.getTransaction(hash).then(tx => {
-          if (tx === null) {
-            return undefined;
-          }
-          return provider._wrapTransaction(tx, hash);
-        });
-      }, {
-        onceBlock: this.provider
-      }).catch(error => {
-        error.transactionHash = hash;
-        throw error;
-      });
-    });
+    // Resolver is always on the chainId 1
+    const provider = await this._getSubprovider(1);
+    return provider.lookupAddress(address);
+  }
+  async getAvatar(nameOrAddress) {
+    if (!(await this.supportsENS())) {
+      return null;
+    }
+    const provider = await this._getSubprovider(1);
+    return provider.getAvatar(nameOrAddress);
+  }
+}
+SequenceProvider.is = provider => {
+  return provider && typeof provider === 'object' && provider._isSequenceProvider === true;
+};
+function normalizeChainId(chainId) {
+  if (typeof chainId === 'object') return normalizeChainId(chainId.chainId);
+  return ethers.ethers.BigNumber.from(chainId).toNumber();
+}
 
-    // @ts-ignore
-    return tx;
+/**
+ *  This is the same provider, but it only allows a single network at a time.
+ *  the network defined by the constructor is the only one that can be used.
+ * 
+ *  Attempting to call any method with a different network will throw an error.
+ *  Attempting to change the network of this provider will throw an error.
+ * 
+ *  NOTICE: These networks won't support ENS unless they are the mainnet.
+ */
+class SingleNetworkSequenceProvider extends SequenceProvider {
+  constructor(client, providerFor, chainId) {
+    super(client, providerFor);
+    this._isSingleNetworkSequenceProvider = true;
+    this.chainId = chainId;
+  }
+  _useChainId(chainId) {
+    const provided = this.toChainId(chainId);
+    if (provided && provided !== this.chainId) {
+      throw new Error(`This provider only supports the network ${this.chainId}, but ${provided} was requested.`);
+    }
+    return provided || super.toChainId(this.chainId);
+  }
+  useChainId(chainId) {
+    return Promise.resolve(this._useChainId(chainId));
+  }
+  getChainId() {
+    return super.toChainId(this.chainId);
+  }
+  async getNetwork() {
+    const networks = await this.client.getNetworks();
+    const res = network.findNetworkConfig(networks, this.chainId);
+    if (!res) {
+      throw new Error(`Unsupported network ${this.chainId}`);
+    }
+    return res;
   }
 
-  // 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.
-  async sendTransactionBatch(transactions, chainId) {
-    const batch = await wallet.resolveArrayProperties(transactions);
-    if (!batch || batch.length === 0) {
-      throw new Error('cannot send empty batch');
+  /**
+   *  Override getProvider and getSigner so they always use `useChainId`
+   *  this way they can't return providers and signers that can switch networks,
+   *  or that don't match the chainId of this signer.
+   */
+  getProvider(chainId) {
+    if (this._useChainId(chainId) !== this.chainId) {
+      throw new Error(`Unreachable code`);
     }
+    return this;
+  }
+  getSigner(chainId) {
+    return super.getSigner(this._useChainId(chainId));
+  }
+  setDefaultChainId(_chainId) {
+    throw new Error(`This provider only supports the network ${this.chainId}; use the parent provider to switch networks.`);
+  }
+  static is(cand) {
+    return cand && typeof cand === 'object' && cand._isSingleNetworkSequenceProvider === true;
+  }
+}
 
-    // sendTransactionBatch only accepts TransactionRequest, not TransactionResponses
-    if (batch.find(v => v.wait !== undefined && v.wait !== null)) {
-      throw new Error('transaction request expected for sendTransactionBatch, transaction response found');
+/**
+ *  This session class is meant to persist the state of the wallet connection
+ *  whitin the dapp. This enables the client to retain the wallet address (and some more)
+ *  even if the user refreshes the page. Otherwise we would have to open the popup again.
+ */
+class SequenceClientSession {
+  constructor(store) {
+    this.store = store;
+  }
+  connectedSession() {
+    const session = this.getSession();
+    if (session && session.accountAddress && session.walletContext && session.networks) {
+      return {
+        accountAddress: session.accountAddress,
+        walletContext: session.walletContext,
+        networks: session.networks
+      };
+    }
+    throw new Error('Sequence session not connected');
+  }
+  hasSession() {
+    var _this$getSession;
+    return ((_this$getSession = this.getSession()) == null ? void 0 : _this$getSession.accountAddress) !== undefined;
+  }
+  setSession(session) {
+    return this.store.setItem(SequenceClientSession.SESSION_LOCALSTORE_KEY, JSON.stringify(session));
+  }
+  getSession() {
+    const session = this.store.getItem(SequenceClientSession.SESSION_LOCALSTORE_KEY);
+    if (session) {
+      return JSON.parse(session);
     }
-    const asExtended = toExtended(batch);
-    return this.sendTransaction(asExtended, chainId);
+    return undefined;
+  }
+  async clearSession() {
+    return this.store.removeItem(SequenceClientSession.SESSION_LOCALSTORE_KEY);
+  }
+}
+
+/**
+ *  The wallet webapp doesn't really care what's the "default chain" for the user.
+ *  so we don't even bother to send this information to the wallet. Instead, we
+ *  track it locally using storage, that way the data stays always in sync.
+ */
+SequenceClientSession.SESSION_LOCALSTORE_KEY = '@sequence.session';
+class DefaultChainIdTracker {
+  constructor(store, startingChainId = 1) {
+    this.callbacks = [];
+    this.store = store;
+    this.startingChainId = startingChainId;
+    store.onItemChange(DefaultChainIdTracker.SESSION_CHAIN_ID_KEY, value => {
+      if (value) {
+        const chainId = parseInt(value);
+        this.callbacks.forEach(cb => cb(chainId));
+      }
+    });
+  }
+  onDefaultChainIdChanged(callback) {
+    this.callbacks.push(callback);
+    return () => {
+      this.callbacks = this.callbacks.filter(cb => cb !== callback);
+    };
   }
-  signTransactions(transaction, chainId) {
-    transaction = utils.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], network.maybeChainId(chainId) || this.defaultChainId);
+  setDefaultChainId(chainId) {
+    if (chainId !== this.getDefaultChainId()) {
+      this.store.setItem(DefaultChainIdTracker.SESSION_CHAIN_ID_KEY, chainId.toString());
+    }
   }
-  sendSignedTransactions(signedTxs, chainId) {
-    // sequence_relay
-    throw new Error('TODO');
+  getDefaultChainId() {
+    const read = this.store.getItem(DefaultChainIdTracker.SESSION_CHAIN_ID_KEY);
+    if (!read || read.length === 0) {
+      return this.startingChainId;
+    }
+    return parseInt(read);
   }
+}
+
+/**
+ *  This is a wallet client for sequence wallet-webapp. It connects using *some* transport
+ *  and it allows to perform all sequence specific (or write) operations related to the wallet.
+ * 
+ *  It doesn't implement a full ethereum Provider, it doesn't include read-only methods.
+ */
+DefaultChainIdTracker.SESSION_CHAIN_ID_KEY = '@sequence.session.defaultChainId';
+class SequenceClient {
+  constructor(transport, store, defaultChainId) {
+    this.callbacks = {};
+    if (isMuxTransportTemplate(transport)) {
+      this.transport = MuxMessageProvider.new(transport);
+    } else if (isProviderTransport(transport)) {
+      this.transport = transport;
+    } else {
+      throw new Error('Invalid transport');
+    }
+    this.session = new SequenceClientSession(store);
+    this.defaultChainId = new DefaultChainIdTracker(store, defaultChainId);
+    this.transport.on('accountsChanged', accounts => {
+      var _this$callbacks$accou;
+      if (accounts.length > 1) {
+        console.warn('SequenceClient: wallet-webapp returned more than one account');
+      }
+      (_this$callbacks$accou = this.callbacks.accountsChanged) == null ? void 0 : _this$callbacks$accou.forEach(cb => cb(accounts));
+    });
+    this.transport.on('connect', response => {
+      var _this$callbacks$conne;
+      const chainIdHex = ethers.ethers.BigNumber.from(this.getChainId()).toHexString();
+      (_this$callbacks$conne = this.callbacks.connect) == null ? void 0 : _this$callbacks$conne.forEach(cb => cb(_extends({}, response, {
+        // Ignore the full connect response
+        // use the chainId defined locally
+        chainId: chainIdHex
+      })));
+    });
+    this.transport.on('disconnect', error => {
+      var _this$callbacks$disco;
+      (_this$callbacks$disco = this.callbacks.disconnect) == null ? void 0 : _this$callbacks$disco.forEach(cb => cb(error));
+    });
+    this.transport.on('networks', networks => {
+      var _this$callbacks$netwo;
+      (_this$callbacks$netwo = this.callbacks.networks) == null ? void 0 : _this$callbacks$netwo.forEach(cb => cb(networks));
+    });
+    this.transport.on('walletContext', context => {
+      var _this$callbacks$walle;
+      (_this$callbacks$walle = this.callbacks.walletContext) == null ? void 0 : _this$callbacks$walle.forEach(cb => cb(context));
+    });
+    this.transport.on('open', info => {
+      var _this$callbacks$open;
+      (_this$callbacks$open = this.callbacks.open) == null ? void 0 : _this$callbacks$open.forEach(cb => cb(info));
+    });
+    this.transport.on('close', () => {
+      var _this$callbacks$close;
+      (_this$callbacks$close = this.callbacks.close) == null ? void 0 : _this$callbacks$close.forEach(cb => cb());
+    });
 
-  // updateConfig..
-  // NOTE: this is not supported by the remote wallet by default.
-  async updateConfig(newConfig) {
-    // sequence_updateConfig
-    const [config, tx] = await this.provider.send('sequence_updateConfig', [newConfig], this.defaultChainId);
-    if (tx === null) {
-      return [config, undefined];
-    }
-    const provider = await this.getSender(this.defaultChainId);
-    return [config, provider._wrapTransaction(tx, tx.hash)];
+    // We don't listen for the transport chainChanged event
+    // instead we handle it locally, so we listen for changes in the store
+    this.defaultChainId.onDefaultChainIdChanged(chainId => {
+      var _this$callbacks$chain;
+      const chainIdHex = ethers.ethers.BigNumber.from(chainId).toHexString();
+      (_this$callbacks$chain = this.callbacks.chainChanged) == null ? void 0 : _this$callbacks$chain.forEach(cb => cb(chainIdHex));
+    });
   }
 
-  // publishConfig..
-  // NOTE: this is not supported by the remote wallet by default.
-  async publishConfig() {
-    const provider = await this.getSender(this.defaultChainId);
-    const tx = await provider.send('sequence_publishConfig', []);
-    if (tx === null) {
-      return undefined;
+  // Callbacks
+
+  registerCallback(eventName, callback) {
+    if (!this.callbacks[eventName]) {
+      this.callbacks[eventName] = [];
     }
-    return provider._wrapTransaction(tx, tx.hash);
-  }
-  async isDeployed(chainId) {
-    const provider = await this.getSender(network.maybeChainId(chainId));
-    const walletCode = await provider.getCode(await this.getAddress());
-    return !!walletCode && walletCode !== '0x';
+    this.callbacks[eventName].push(callback);
+    return () => {
+      this.callbacks[eventName] = this.callbacks[eventName].filter(c => c !== callback);
+    };
   }
 
-  //
-  // ethers JsonRpcSigner methods
-  //
-
-  async _legacySignMessage(message, chainId) {
-    const provider = await this.getSender(network.maybeChainId(chainId) || this.defaultChainId);
-    const data = typeof message === 'string' ? ethers.ethers.utils.toUtf8Bytes(message) : message;
-    const address = await this.getAddress();
+  // Individual callbacks lead to more idiomatic code
 
-    // 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.
-    return await provider.send('eth_sign', [address, ethers.ethers.utils.hexlify(data)]);
+  onOpen(callback) {
+    return this.registerCallback('open', callback);
   }
-  async _signTypedData(domain, types, message, chainId) {
-    return this.signTypedData(domain, types, message, chainId);
+  onClose(callback) {
+    return this.registerCallback('close', callback);
   }
-  async sendUncheckedTransaction(transaction, chainId) {
-    transaction = utils.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)
-    // }
-
-    const provider = await this.getSender(network.maybeChainId(chainId) || this.defaultChainId);
-    return utils.resolveProperties({
-      tx: utils.resolveProperties(transaction),
-      sender: await fromAddress
-    }).then(({
-      tx,
-      sender
-    }) => {
-      if (tx.from != null) {
-        if (ethers.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 error;
-      });
-    });
+  onConnect(callback) {
+    return this.registerCallback('connect', callback);
   }
-  connectUnchecked() {
-    return new UncheckedJsonRpcSigner(this.provider, this.defaultChainId);
+  onDisconnect(callback) {
+    return this.registerCallback('disconnect', callback);
   }
-  async unlock(password) {
-    const address = await this.getAddress();
-    return this.provider.send('personal_unlockAccount', [address, password, null]);
+  onNetworks(callback) {
+    return this.registerCallback('networks', callback);
   }
-}
-
-// NOTE: method has been copied + modified from ethers.js JsonRpcProvider
-// Convert an ethers.js transaction into a JSON-RPC transaction
-
-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
-};
-const hexlifyTransaction = (transaction, allowExtra) => {
-  // Check only allowed properties are given
-  const allowed = utils.shallowCopy(allowedTransactionKeys);
-  if (allowExtra) {
-    for (const key in allowExtra) {
-      if (allowExtra[key]) {
-        allowed[key] = true;
-      }
-    }
+  onAccountsChanged(callback) {
+    return this.registerCallback('accountsChanged', callback);
   }
-  ethers.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 => {
-    const value = transaction[key];
-    if (value === null || value === undefined) {
-      return;
-    }
-    const hexValue = ethers.ethers.utils.hexValue(value);
-    if (key === 'gasLimit') {
-      key = 'gas';
-    }
-    result[key] = hexValue;
-  });
-  ['from', 'to', 'data'].forEach(key => {
-    if (!transaction[key]) {
-      return;
-    }
-    result[key] = ethers.ethers.utils.hexlify(transaction[key]);
-  });
-  ['delegateCall', 'revertOnError'].forEach(key => {
-    const value = transaction[key];
-    if (value !== undefined && value !== null) {
-      result[key] = value;
-    }
-  });
-  const auxiliary = transaction['auxiliary'];
-  if (auxiliary && auxiliary.length > 0) {
-    result['auxiliary'] = [];
-    auxiliary.forEach(a => {
-      result['auxiliary'].push(hexlifyTransaction(a));
-    });
+  // @deprecated
+  onWalletContext(callback) {
+    return this.registerCallback('walletContext', callback);
   }
-  return result;
-};
-class UncheckedJsonRpcSigner extends Web3Signer {
-  sendTransaction(transaction) {
-    return this.sendUncheckedTransaction(transaction).then(hash => {
-      return {
-        chainId: 0,
-        confirmations: 0,
-        data: '',
-        from: '',
-        gasLimit: ethers.ethers.constants.Zero,
-        gasPrice: ethers.ethers.constants.Zero,
-        hash,
-        nonce: 0,
-        value: ethers.ethers.constants.Zero,
-        wait: confirmations => this.provider.waitForTransaction(hash, confirmations)
-      };
-    });
+  onDefaultChainIdChanged(callback) {
+    return this.registerCallback('chainChanged', callback);
   }
-}
-
-class WalletUtils {
-  constructor(walletProvider) {
-    this.wallet = walletProvider;
+  getChainId() {
+    return this.defaultChainId.getDefaultChainId();
   }
-
-  // Sign message on a specified chain, or DefaultChain by default
-  signMessage(message, chainId, allSigners) {
-    const signer = this.wallet.getSigner();
-    if (!signer) throw new Error('unable to get signer');
-    return signer.signMessage(message, chainId, allSigners);
+  setDefaultChainId(chainId) {
+    return this.defaultChainId.setDefaultChainId(chainId);
   }
 
-  // Sign message on the AuthChain
-  async signAuthMessage(message, allSigners) {
-    const signer = this.wallet.getSigner();
-    if (!signer) throw new Error('unable to get AuthChain signer');
-    return signer.signMessage(message, await signer.getChainId(), allSigners);
-  }
+  // Proxy transport methods
 
-  // Sign EIP-712 TypedData on a specified chain, or DefaultChain by default
-  signTypedData(domain, types, message, chainId, allSigners) {
-    const signer = this.wallet.getSigner();
-    if (!signer) throw new Error('unable to get signer');
-    return signer.signTypedData(domain, types, message, chainId, allSigners);
+  async openWallet(path, intent) {
+    this.transport.openWallet(path, intent, this.getChainId());
+    await this.transport.waitUntilOpened();
+    return this.isOpened();
   }
-
-  // Sign EIP-712 TypedData on the AuthChain
-  async signAuthTypedData(domain, types, message, allSigners) {
-    const signer = this.wallet.getSigner();
-    if (!signer) throw new Error('unable to get AuthChain signer');
-    return signer.signTypedData(domain, types, message, await signer.getChainId(), allSigners);
+  closeWallet() {
+    return this.transport.closeWallet();
   }
-
-  // Verify signature of a digest, one of a message, typedData or other
-  async isValidSignature(address, digest, signature, chainId) {
-    const provider = this.wallet.getProvider(chainId);
-    if (!provider) throw new Error(`unable to get provider for chainId ${chainId}`);
-    return isValidSignature(address, digest, signature, provider);
+  isOpened() {
+    return this.transport.isOpened();
   }
-
-  // Verify message signature
-  async isValidMessageSignature(address, message, signature, chainId) {
-    const provider = this.wallet.getProvider(chainId);
-    if (!provider) throw new Error(`unable to get provider for chainId ${chainId}`);
-    const prefixed = prefixEIP191Message(message);
-    const digest = utils.encodeMessageDigest(prefixed);
-    return isValidSignature(address, digest, signature, provider);
+  isConnected() {
+    return this.session.hasSession();
   }
-
-  // Verify typedData signature
-  isValidTypedDataSignature(address, typedData, signature, chainId) {
-    return this.isValidSignature(address, utils.encodeTypedDataDigest(typedData), signature, chainId);
+  getSession() {
+    return this.session.getSession();
   }
 
-  // // Recover the WalletConfig from a signature + digest combo
-  // recoverWalletConfig = async (
-  //   address: string,
-  //   digest: BytesLike,
-  //   signature: string | DecodedSignature,
-  //   chainId: BigNumberish,
-  //   walletContext?: WalletContext
-  // ): Promise<WalletConfig> => {
-  //   walletContext = walletContext || (await this.wallet.getWalletContext())
-  //   return recoverWalletConfig(address, digest, signature, chainId, walletContext)
-  // }
-
-  // // Recover the WalletConfig from a signature of a message
-  // recoverWalletConfigFromMessage = async (
-  //   address: string,
-  //   message: string | Uint8Array,
-  //   signature: string | DecodedSignature,
-  //   chainId: BigNumberish,
-  //   walletContext?: WalletContext
-  // ): Promise<WalletConfig> => {
-  //   walletContext = walletContext || (await this.wallet.getWalletContext())
-  //   return recoverWalletConfig(address, encodeMessageDigest(prefixEIP191Message(message)), signature, chainId, walletContext)
-  // }
-
-  // // Recover the WalletConfig from a signature of a typedData object
-  // recoverWalletConfigFromTypedData = async (
-  //   address: string,
-  //   typedData: TypedData,
-  //   signature: string | DecodedSignature,
-  //   chainId: BigNumberish,
-  //   walletContext?: WalletContext
-  // ): Promise<WalletConfig> => {
-  //   walletContext = walletContext || (await this.wallet.getWalletContext())
-  //   return recoverWalletConfig(address, encodeTypedDataDigest(typedData), signature, chainId, walletContext)
-  // }
-
-  // sendTransaction()
-  // sendTransactions()
-
-  // sendETH()
-  // sendToken()
-  // sendCoin() -- sugar for sendToken()
-  // sendCollectible() -- sugar for sendToken()
-  // callContract()
-
-  // transactionHistory()
-  // getReceipt()
-  // getLogs()
-  // // ..
-
-  // isWalletDeployed()
-  // deployWallet()
-
-  // validateSignature()
-  // recoverWalletConfig()
-  // recoverAddress()
-}
-
-const SESSION_LOCALSTORE_KEY = '@sequence.session';
-class Wallet {
-  constructor(_network, config) {
-    var _this = this;
-    this.init = () => {
-      var _this$config$transpor, _this$config$transpor2, _this$config$transpor3, _this$config$transpor4, _this$config$transpor5, _this$config$transpor6, _this$config$transpor7, _this$config$transpor8, _findSupportedNetwork;
-      if (this.transport.provider) {
-        // init must have already been called
-        return;
-      }
-
-      // Setup provider
-
-      this.transport.messageProvider = new MuxMessageProvider();
-
-      // multiple message provider setup, first one to connect will be the main transport
-      if ((_this$config$transpor = this.config.transports) != null && (_this$config$transpor2 = _this$config$transpor.windowTransport) != null && _this$config$transpor2.enabled && typeof window === 'object') {
-        this.transport.windowMessageProvider = new WindowMessageProvider(this.config.walletAppURL);
-        this.transport.messageProvider.add(this.transport.windowMessageProvider);
-      }
-      if ((_this$config$transpor3 = this.config.transports) != null && (_this$config$transpor4 = _this$config$transpor3.proxyTransport) != null && _this$config$transpor4.enabled) {
-        this.transport.proxyMessageProvider = new ProxyMessageProvider(this.config.transports.proxyTransport.appPort);
-        this.transport.messageProvider.add(this.transport.proxyMessageProvider);
-      }
-      if ((_this$config$transpor5 = this.config.transports) != null && (_this$config$transpor6 = _this$config$transpor5.extensionTransport) != null && _this$config$transpor6.enabled) {
-        this.transport.extensionMessageProvider = new ExtensionMessageProvider(this.config.transports.extensionTransport.runtime);
-        // this.transport.extensionMessageProvider.register()
-        this.transport.messageProvider.add(this.transport.extensionMessageProvider);
-
-        // NOTE/REVIEW: see note in mux-message-provider
-        //
-        // We don't add the extensionMessageProvider here because we don't send requests to it anyways, we seem to
-        // send all requests to the WindowMessageProvider anyways. By allowing it, if browser restarts, it will break
-        // the entire extension because messageProvider.provider will be undefined. So this is a hack to fix it.
-        //
-        // this.transport.messageProvider.add(this.transport.extensionMessageProvider)
-      }
-
-      if ((_this$config$transpor7 = this.config.transports) != null && (_this$config$transpor8 = _this$config$transpor7.unrealTransport) != null && _this$config$transpor8.enabled) {
-        this.transport.unrealMessageProvider = new UnrealMessageProvider(this.config.walletAppURL);
-        this.transport.messageProvider.add(this.transport.unrealMessageProvider);
-      }
-      this.transport.messageProvider.register();
-
-      // .....
-      this.transport.allowProvider = network.allowProviderMiddleware(request => {
-        if (request.method === 'sequence_setDefaultNetwork') return true;
-        const isConnected = this.isConnected();
-        if (!isConnected) {
-          throw new Error('Sequence: wallet not connected');
-        }
-        return isConnected;
-      });
-
-      // ...
-      this.transport.networkProvider = network.networkProviderMiddleware(request => {
-        // return stub chainId of 0 when not connected to any
-        if (!this.networks || this.networks.length === 0) return 0;
-
-        // return the default chainId as we're connected
-        return network.findNetworkConfig(this.networks, this.config.defaultNetworkId).chainId;
-      });
-
-      // Provider proxy to support middleware stack of logging, caching and read-only rpc calls
-      this.transport.cachedProvider = new network.CachedProvider();
-      this.transport.cachedProvider.onUpdate(() => {
-        if (!this.session) this.session = {
-          providerCache: {}
-        };
-        this.session.providerCache = this.transport.cachedProvider.getCache();
-        this.saveSession(this.session);
-      });
-
-      // ..
-      this.transport.router = new network.JsonRpcRouter([network.loggingProviderMiddleware, this.transport.networkProvider, this.transport.allowProvider, network.exceptionProviderMiddleware, this.transport.cachedProvider], this.transport.messageProvider);
-
-      // TODO: Move finding this config to upper in the stack
-      this.transport.provider = new Web3Provider(this.transport.router, (_findSupportedNetwork = network.findSupportedNetwork(this.config.defaultNetworkId)) == null ? void 0 : _findSupportedNetwork.chainId);
-
-      // NOTE: we don't listen on 'connect' even here as we handle it within connect() method
-      // in more synchronous flow.
-
-      // below will update the wallet session object and persist it. In case the session
-      // is undefined, we consider the session to have been removed by the user, so we clear it.
-      this.transport.messageProvider.on('open', openInfo => {
-        const {
-          session
-        } = openInfo;
-        if (!session) {
-          if (this.session && this.session.accountAddress) {
-            // emit disconnect even if previously we had a session, and now we don't.
-            this.transport.messageProvider.emit('disconnect');
-          }
-          this.clearSession();
-        } else {
-          this.useSession(session, true);
-        }
-      });
-
-      // below will update the account upon wallet connect/disconnect - aka, login/logout.
-      // if an origin is provided, this operation should be performed only on that origin
-      // and shouldn't affect the session of the wallet.
-      this.transport.messageProvider.on('accountsChanged', (accounts, origin) => {
-        if (origin) {
-          if (accounts.length > 0) {
-            this.useSession({
-              accountAddress: accounts[0]
-            }, true);
-          }
-          return;
-        }
-        if (!accounts || accounts.length === 0 || accounts[0] === '') {
-          this.clearSession();
-        } else {
-          this.useSession({
-            accountAddress: accounts[0]
-          }, true);
+  // Basic API
+  getAddress() {
+    const session = this.session.connectedSession();
+    return session.accountAddress;
+  }
+  async connect(options) {
+    if ((options == null ? void 0 : options.authorizeVersion) === undefined) {
+      // Populate default authorize version if not provided
+      options.authorizeVersion = 2;
+    }
+    if ((options == null ? void 0 : options.refresh) === true) {
+      this.disconnect();
+    }
+    if (options) {
+      if (options.authorize) {
+        if (!options.app) {
+          throw new Error(`connecting with 'authorize' option also requires 'app' to be set`);
         }
-      });
-
-      // below will update the networks automatically when the wallet networks change
-      this.transport.messageProvider.on('networks', networks => {
-        this.useSession({
-          networks: networks
-        }, true);
-      });
-
-      // below will update the wallet context automatically
-      this.transport.messageProvider.on('walletContext', walletContext => {
-        this.useSession({
-          walletContext: walletContext
-        }, true);
-      });
-    };
-    this.loadSession = async function (preferredNetwork) {
-      const data = await LocalStorage.getInstance().getItem(SESSION_LOCALSTORE_KEY);
-      if (!data || data === '') {
-        return undefined;
-      }
-      try {
-        const session = JSON.parse(data);
-        if (session) {
-          // Setting preferredNetwork as default network if it's in session.networks
-          if (preferredNetwork !== undefined) {
-            var _session$networks;
-            const preferredNetworkIdNum = typeof preferredNetwork === 'string' ? parseInt(preferredNetwork) : preferredNetwork;
-            const isPreferredNetwork = n => n.name === preferredNetwork || n.chainId === preferredNetworkIdNum;
-            const preferredNetworkInConfig = (_session$networks = session.networks) == null ? void 0 : _session$networks.find(isPreferredNetwork);
-            const isAlreadyDefaultChain = preferredNetworkInConfig == null ? void 0 : preferredNetworkInConfig.isDefaultChain;
-            if (session.networks && preferredNetworkInConfig && !isAlreadyDefaultChain) {
-              const updatedNetworks = session.networks.map(n => _extends({}, n, {
-                isDefaultChain: isPreferredNetwork(n)
-              }));
-              session.networks = network.sortNetworks(updatedNetworks);
-              session.providerCache = undefined;
-            }
-          }
-          _this.useSession(session, true);
+        if (options.authorizeVersion === undefined) {
+          options.authorizeVersion = 2;
         }
-        return session;
-      } catch (err) {
-        utils.logger.warn('loadSession failed, unable to parse session payload from storage.');
-        return undefined;
       }
-    };
-    this.connect = async function (options) {
-      if (options && (options == null ? void 0 : options.authorizeVersion) === undefined) {
-        // Populate default authorize version if not provided
-        options.authorizeVersion = 2;
-      }
-      if ((options == null ? void 0 : options.refresh) === true) {
-        _this.disconnect();
-      }
-      if (_this.isConnected() && (await _this.isSiteConnected(options == null ? void 0 : options.origin)) && !!_this.session && !(options != null && options.authorize) && !(options != null && options.askForEmail)) {
+    }
+    await this.openWallet(undefined, {
+      type: 'connect',
+      options: _extends({}, options, {
+        networkId: this.getChainId()
+      })
+    });
+    const connectDetails = await this.transport.waitUntilConnected().catch(error => {
+      if (error instanceof Error) {
         return {
-          connected: true,
-          session: _this.session,
-          chainId: ethers.ethers.utils.hexlify(await _this.getChainId())
+          connected: false,
+          error: error.message
         };
-      }
-      if (options) {
-        if (options.authorize) {
-          if (!options.app) {
-            throw new Error(`connecting with 'authorize' option also requires 'app' to be set`);
-          }
-          if (options.authorizeVersion === undefined) {
-            options.authorizeVersion = 2;
-          }
-        }
-      }
-      await _this.openWallet(undefined, {
-        type: 'connect',
-        options
-      });
-      const connectDetails = await _this.transport.messageProvider.waitUntilConnected().catch(error => {
-        if (error instanceof Error) {
-          return {
-            connected: false,
-            error: error.message
-          };
-        } else {
-          return {
-            connected: false,
-            error: JSON.stringify(error)
-          };
-        }
-      });
-      if (connectDetails.connected) {
-        if (!!connectDetails.session) {
-          _this.useSession(connectDetails.session, true);
-          _this.addConnectedSite(options == null ? void 0 : options.origin);
-        } else {
-          throw new Error('impossible state, connect response is missing session');
-        }
-      }
-      return connectDetails;
-    };
-    this.authorize = async function (options) {
-      return _this.connect(_extends({}, options, {
-        authorize: true
-      }));
-    };
-    this.getSession = () => {
-      if (!this.isConnected()) {
-        return undefined;
-      }
-      return this.session;
-    };
-    this.getAddress = async function () {
-      if (!_this.isConnected()) {
-        throw new Error('connect first');
-      }
-      const session = _this.getSession();
-      return session.accountAddress;
-    };
-    this.getNetworks = async function (chainId) {
-      if (!_this.isConnected() || !_this.networks) {
-        throw new Error('connect first');
-      }
-      if (chainId) {
-        // filter list to just the specific chain requested
-        const network$1 = network.findNetworkConfig(_this.networks, chainId);
-        return network$1 ? [network$1] : [];
-      }
-      return _this.networks;
-    };
-    // getChainId returns the default chain id
-    this.getChainId = async function () {
-      if (!_this.networks || _this.networks.length < 1) {
-        throw new Error('networks have not been set by session. connect first.');
-      }
-      const network$1 = network.findNetworkConfig(_this.networks, _this.config.defaultNetworkId);
-      if (!network$1) {
-        throw new Error('networks must have a default chain specified');
-      }
-      return network$1.chainId;
-    };
-    this.openWallet = async function (path, intent, networkId) {
-      if ((intent == null ? void 0 : intent.type) !== 'connect' && !_this.isConnected()) {
-        throw new Error('connect first');
-      }
-      let currentNetworkId;
-      if (!_this.networks || _this.networks.length < 1) {
-        currentNetworkId = _this.config.defaultNetworkId;
-      } else {
-        currentNetworkId = await _this.getChainId();
-      }
-      _this.transport.messageProvider.openWallet(path, intent, networkId || currentNetworkId);
-      await _this.transport.messageProvider.waitUntilOpened();
-      return true;
-    };
-    this.closeWallet = () => {
-      this.transport.messageProvider.closeWallet();
-    };
-    this.unregister = () => {
-      var _this$transport$messa;
-      this.disconnect();
-      (_this$transport$messa = this.transport.messageProvider) == null ? void 0 : _this$transport$messa.unregister();
-    };
-    this.saveSession = async function (session) {
-      utils.logger.debug('wallet provider: saving session');
-      const data = JSON.stringify(session);
-      await LocalStorage.getInstance().setItem(SESSION_LOCALSTORE_KEY, data);
-    };
-    this.useSession = async function (session, autoSave = true) {
-      if (!_this.session) _this.session = {};
-
-      // setup wallet context
-      if (_this.config.walletContext) {
-        _this.session.walletContext = _this.config.walletContext;
-      } else if (session.walletContext) {
-        _this.session.walletContext = session.walletContext;
-      }
-
-      // setup account
-      if (session.accountAddress) {
-        _this.useAccountAddress(session.accountAddress);
-      }
-
-      // setup networks
-      if (session.networks) {
-        _this.useNetworks(session.networks);
-      }
-
-      // setup provider cache
-      if (session.providerCache) {
-        _this.transport.cachedProvider.setCache(session.providerCache);
       } else {
-        _this.transport.cachedProvider.clearCache();
+        return {
+          connected: false,
+          error: JSON.stringify(error)
+        };
       }
+    });
 
-      // persist
-      if (autoSave) {
-        _this.saveSession(_this.session);
-      }
-    };
-    // config is a Partial, so that we may intersect it with the DefaultProviderConfig,
-    // which allows easy overriding and control of the config.
-    this.config = _extends({}, DefaultProviderConfig);
-    if (config) {
-      this.config = _extends({}, this.config, config);
-    }
-    if (_network) {
-      this.config.defaultNetworkId = _network;
-    } else if (!this.config.defaultNetworkId) {
-      this.config.defaultNetworkId = 'mainnet';
-    }
-    if (config != null && config.localStorage) {
-      LocalStorage.use(config.localStorage);
-    }
-    this.transport = {};
-    this.networks = [];
-    this.providers = {};
-    this.connectedSites = new LocalStore('@sequence.connectedSites', []);
-    this.utils = new WalletUtils(this);
-    this.init();
-  }
-  async addConnectedSite(origin) {
-    origin = origin || window.location.origin;
-    const connectedSites = await this.connectedSites.get();
-    if (connectedSites) {
-      if (connectedSites.includes(origin)) {
-        return;
-      }
-      this.connectedSites.set([...connectedSites, origin]);
-    } else {
-      this.connectedSites.set([origin]);
+    // Normalize chainId into a decimal string
+    // TODO: Remove this once wallet-webapp returns chainId as a string
+    if (connectDetails.chainId) {
+      connectDetails.chainId = ethers.ethers.BigNumber.from(connectDetails.chainId).toString();
     }
-  }
-  async removeConnectedSite(origin) {
-    const authorized = await this.connectedSites.get();
-    if (authorized) {
-      this.connectedSites.set(authorized.filter(domain => domain !== origin));
+    if (connectDetails.connected) {
+      if (!connectDetails.session) {
+        throw new Error('impossible state, connect response is missing session');
+      }
+      this.session.setSession(connectDetails.session);
     }
-  }
-  getConnectedSites() {
-    return this.connectedSites.get();
-  }
-  async isSiteConnected(origin) {
-    const authorized = await this.connectedSites.get();
-    return !!authorized && authorized.includes(origin || window.location.origin);
+    return connectDetails;
   }
   disconnect() {
     if (this.isOpened()) {
       this.closeWallet();
     }
-    return this.clearSession();
+    return this.session.clearSession();
   }
 
-  // TODO: add switchNetwork(network: string | number) which will call wallet_switchEthereumChain
-  // and on successful response, will update the provider info here, etc.
+  // Higher level API
 
-  getProviderConfig() {
-    return this.config;
+  // Working with sendAsync is less idiomatic
+  // but transport uses it instead of send, so we wrap it
+  send(request, chainId) {
+    return new Promise((resolve, reject) => {
+      this.transport.sendAsync(request, (error, response) => {
+        if (error) {
+          reject(error);
+        } else if (response === undefined) {
+          reject(new Error(`Got undefined response for request: ${request}`));
+        } else if (typeof response === 'object' && response.error) {
+          reject(response.error);
+        } else if (typeof response === 'object' && response.result) {
+          resolve(response.result);
+        } else {
+          reject(new Error(`Got invalid response for request: ${request}`));
+        }
+      }, chainId || this.getChainId());
+    });
   }
-  isOpened() {
-    return this.transport.messageProvider.isOpened();
+  async getNetworks(pull) {
+    const connectedSession = this.session.connectedSession();
+    if (pull) {
+      connectedSession.networks = await this.send({
+        method: 'sequence_getNetworks'
+      });
+      this.session.setSession(connectedSession);
+    }
+    return connectedSession.networks;
   }
-  isConnected() {
-    return this.session !== undefined && this.session.networks !== undefined && this.session.networks.length > 0 && this.networks !== undefined && this.networks.length > 0 && !!this.session.accountAddress && this.session.accountAddress.startsWith('0x');
+  async signMessage(message, options) {
+    const method = options != null && options.eip6492 ? 'sequence_sign' : 'personal_sign';
+
+    // Address is ignored by the wallet webapp
+    return this.send({
+      method,
+      params: [message, this.getAddress()]
+    }, options == null ? void 0 : options.chainId);
   }
-  getProvider(chainId) {
-    // return the top-level provider message transport when chainId is unspecified
-    // and user has not logged in
-    if (!this.isConnected()) {
-      if (chainId) {
-        throw new Error(`session is empty. connect and try again.`);
-      } else {
-        return this.transport.provider;
-      }
-    }
-    let network$1 = network.findNetworkConfig(this.networks, this.config.defaultNetworkId);
-    if (chainId) {
-      network$1 = network.findNetworkConfig(this.networks, chainId);
-      if (!network$1) {
-        throw new Error(`network ${chainId} is not in the network list`);
-      }
-    }
+  async signTypedData(typedData, options) {
+    const method = options != null && options.eip6492 ? 'sequence_signTypedData_v4' : 'eth_signTypedData_v4';
 
-    // return memoized network provider
-    if (this.providers[network$1.chainId]) {
-      return this.providers[network$1.chainId];
-    }
+    // TODO: Stop using ethers for this, this is the only place where we use it
+    // and it makes the client depend on ethers.
+    const encoded = ethers.ethers.utils._TypedDataEncoder.getPayload(typedData.domain, typedData.types, typedData.message);
 
-    // builder web3 provider stack
-    let provider;
+    // The sign typed data will use one of the following chainIds, in order:
+    // - The one provided in the options
+    // - The one provided in the typedData.domain.chainId
+    // - The default chainId
 
-    // network.provider may be set by the ProviderConfig override
-    const rpcProvider = new ethers.providers.JsonRpcProvider(utils.getDefaultConnectionInfo(network$1.rpcUrl), network$1.chainId);
-    if (network$1.isDefaultChain) {
-      // communicating with defaultChain will prioritize the wallet message transport
-      const router = new network.JsonRpcRouter([network.loggingProviderMiddleware, network.exceptionProviderMiddleware, new network.EagerProvider({
-        accountAddress: this.session.accountAddress,
-        walletContext: this.session.walletContext
-      }), new network.SigningProvider(this.transport.provider), this.transport.cachedProvider], new network.JsonRpcSender(rpcProvider));
-      provider = new Web3Provider(router, network$1.chainId);
-    } else {
-      // communicating with another chain will bind to that network, but will forward
-      // any signing-related requests to the wallet message transport
-      const router = new network.JsonRpcRouter([network.loggingProviderMiddleware, network.exceptionProviderMiddleware, new network.EagerProvider({
-        accountAddress: this.session.accountAddress,
-        walletContext: this.session.walletContext,
-        chainId: network$1.chainId
-      }), new network.SigningProvider(this.transport.provider), new network.CachedProvider({
-        defaultChainId: network$1.chainId
-      })], new network.JsonRpcSender(rpcProvider));
-      provider = new Web3Provider(router, network$1.chainId);
-    }
-    this.providers[network$1.chainId] = provider;
-    return provider;
-  }
-  getAllProviders() {
-    return this.providers;
-  }
-  getSigner(chainId) {
-    return this.getProvider(chainId).getSigner();
-  }
-  getWalletConfig(chainId) {
-    return this.getSigner().getWalletConfig(chainId);
-  }
-  getWalletState(chainId) {
-    return this.getSigner().getWalletState(chainId);
-  }
-  getWalletContext() {
-    return this.getSigner().getWalletContext();
-  }
-  isDeployed(chainId) {
-    return this.getSigner(chainId).isDeployed();
+    return this.send({
+      method,
+      params: [this.getAddress(), encoded]
+    }, (options == null ? void 0 : options.chainId) || typedData.domain.chainId && ethers.ethers.BigNumber.from(typedData.domain.chainId).toNumber() || this.getChainId());
   }
-  on(event, fn) {
-    this.transport.messageProvider.on(event, fn);
+  async sendTransaction(tx, options) {
+    const sequenceTxs = Array.isArray(tx) ? tx : [tx];
+    const extendedTxs = toExtended(sequenceTxs);
+    return this.send({
+      method: 'eth_sendTransaction',
+      params: [extendedTxs]
+    }, options == null ? void 0 : options.chainId);
   }
-  once(event, fn) {
-    this.transport.messageProvider.once(event, fn);
+  async getWalletContext() {
+    return this.send({
+      method: 'sequence_getWalletContext'
+    });
   }
-  useAccountAddress(accountAddress) {
-    if (!this.session) this.session = {};
-    this.session.accountAddress = ethers.ethers.utils.getAddress(accountAddress);
+  async getOnchainWalletConfig(options) {
+    // NOTICE: sequence_getWalletConfig sends the chainId as a param
+    const res = await this.send({
+      method: 'sequence_getWalletConfig',
+      params: [(options == null ? void 0 : options.chainId) || this.getChainId()]
+    }, options == null ? void 0 : options.chainId);
+    return Array.isArray(res) ? res[0] : res;
   }
-  useNetworks(networks) {
-    // set networks in the session
-    if (!this.session) this.session = {};
-
-    // set networks on session object
-    this.session.networks = networks;
-
-    // short-circuit if setting empty network list (aka logged out state)
-    if (!this.session.networks || this.session.networks.length === 0) {
-      return;
-    }
-
-    // check if any custom network settings, otherwise return early
-    if (!this.config.networks && !this.config.networkRpcUrl) {
-      this.networks = networks;
-      return;
-    }
-
-    // init networks
-    this.networks = networks;
-
-    // combine custom network config with networks in the session
-    if (this.config.networks) {
-      this.networks = networks.map(n => _extends({}, n)); // copy
-      this.config.networks.forEach(n => {
-        const network$1 = network.findNetworkConfig(this.networks, n.chainId || n.name);
-        if (!network$1) return;
-        network.updateNetworkConfig(n, network$1);
-      });
-      network.ensureValidNetworks(this.networks, true);
-    }
 
-    // an extra override for convenience
-    if (this.config.networkRpcUrl) {
-      const network = this.networks.find(network => network.isDefaultChain);
-      if (network) {
-        network.rpcUrl = this.config.networkRpcUrl;
-      }
-    }
-  }
-  async clearSession() {
-    var _this$transport$cache;
-    utils.logger.debug('wallet provider: clearing session');
-    await LocalStorage.getInstance().removeItem(SESSION_LOCALSTORE_KEY);
-    this.session = undefined;
-    this.networks = [];
-    this.providers = {};
-    (_this$transport$cache = this.transport.cachedProvider) == null ? void 0 : _this$transport$cache.clearCache();
-  }
+  // NOTICE: We are leaving out all the "regular" methods os a tipical
+  // JSON RPC Provider (eth_getBlockByNumber, eth_call, etc)
+  // wallet-webapp does implement them, but this client is meant to be
+  // exclusively used for Sequence specific methods
 }
-const DefaultProviderConfig = {
-  walletAppURL: 'https://sequence.app',
-  // walletSessionURL: 'https://session.sequence.app',
 
+const DefaultProviderConfig = {
   transports: {
+    walletAppURL: 'https://sequence.app',
     windowTransport: {
       enabled: true
     },
     proxyTransport: {
       enabled: false
     }
-  }
+  },
+  defaultNetwork: 1
 };
-let walletInstance;
-const initWallet = async (network, config) => {
-  if (walletInstance) {
-    return walletInstance;
-  }
-  walletInstance = new Wallet(network, config);
-  await walletInstance.loadSession(network);
-  return walletInstance;
+let sequenceWalletProvider;
+const initWallet = partialConfig => {
+  var _config$networks$filt, _config$networks, _findNetworkConfig;
+  if (sequenceWalletProvider) {
+    return sequenceWalletProvider;
+  }
+
+  // Combine both the provided config and the default config
+  const config = _extends({}, DefaultProviderConfig, partialConfig, {
+    transports: _extends({}, DefaultProviderConfig.transports, partialConfig == null ? void 0 : partialConfig.transports)
+  });
+  const rpcProviders = {};
+
+  // Find any new networks that aren't already defined in sequence.js
+  // and add them to the list of networks, (they must have a rpcUrl and chainId)
+  const newNetworks = (_config$networks$filt = (_config$networks = config.networks) == null ? void 0 : _config$networks.filter(n => {
+    n.rpcUrl !== undefined && n.chainId !== undefined && !network.allNetworks.find(an => an.chainId === n.chainId);
+  })) != null ? _config$networks$filt : [];
+
+  // Override any information about the networks using the config
+  const combinedNetworks = network.allNetworks.map(n => {
+    var _config$networks2;
+    const network = (_config$networks2 = config.networks) == null ? void 0 : _config$networks2.find(cn => cn.chainId === n.chainId);
+    return network ? _extends({}, n, network) : n;
+  }).concat(newNetworks);
+
+  // This build a "public rpc" on demand, we build them on demand because we don't want to
+  // generate a bunch of providers for networks that aren't used.
+  const providerForChainId = chainId => {
+    if (!rpcProviders[chainId]) {
+      var _combinedNetworks$fin;
+      const rpcUrl = (_combinedNetworks$fin = combinedNetworks.find(n => n.chainId === chainId)) == null ? void 0 : _combinedNetworks$fin.rpcUrl;
+      if (!rpcUrl) {
+        throw new Error(`no rpcUrl found for chainId: ${chainId}`);
+      }
+      const baseProvider = new ethers.ethers.providers.JsonRpcProvider(rpcUrl);
+      const router = new network.JsonRpcRouter([network.loggingProviderMiddleware, network.exceptionProviderMiddleware, new network.CachedProvider()], new network.JsonRpcSender(baseProvider));
+      rpcProviders[chainId] = new ethers.ethers.providers.Web3Provider(router, chainId);
+    }
+    return rpcProviders[chainId];
+  };
+
+  // This is the starting default network (as defined by the config)
+  // it can be later be changed using `wallet_switchEthereumChain` or some
+  // of the other methods on the provider.
+  const defaultNetwork = config.defaultNetwork ? (_findNetworkConfig = network.findNetworkConfig(combinedNetworks, config.defaultNetwork)) == null ? void 0 : _findNetworkConfig.chainId : undefined;
+  if (!defaultNetwork && config.defaultNetwork) {
+    throw new Error(`defaultNetwork not found for chainId: ${config.defaultNetwork}`);
+  }
+
+  // Generate ItemStore
+  const itemStore = config.localStorage || useBestStore();
+
+  // Create client, provider and return signer
+  const client = new SequenceClient(config.transports, itemStore, defaultNetwork);
+  sequenceWalletProvider = new SequenceProvider(client, providerForChainId);
+  return sequenceWalletProvider;
 };
 const unregisterWallet = () => {
-  if (!walletInstance) return;
-  walletInstance.closeWallet();
-  walletInstance.unregister();
+  if (!sequenceWalletProvider) return;
+  sequenceWalletProvider.client.closeWallet();
+  sequenceWalletProvider.client.transport.unregister();
+  sequenceWalletProvider = undefined;
 };
 const getWallet = () => {
-  if (!walletInstance) {
-    throw new Error('Wallet has not been initialized, call sequence.initWallet(network, config) first.');
+  if (!sequenceWalletProvider) {
+    throw new Error('Wallet has not been initialized, call sequence.initWallet(config) first.');
   }
-  return walletInstance;
+  return sequenceWalletProvider;
 };
 
 exports.BaseInjectedTransport = BaseInjectedTransport;
 exports.BaseProviderTransport = BaseProviderTransport;
 exports.BaseWalletTransport = BaseWalletTransport;
 exports.CHANNEL_ID = CHANNEL_ID;
+exports.DefaultChainIdTracker = DefaultChainIdTracker;
 exports.DefaultProviderConfig = DefaultProviderConfig;
 exports.ErrSignedInRequired = ErrSignedInRequired;
 exports.EventType = EventType;
@@ -3860,8 +3941,7 @@ exports.ExtensionMessageHandler = ExtensionMessageHandler;
 exports.ExtensionMessageProvider = ExtensionMessageProvider;
 exports.InitState = InitState;
 exports.LocalStorage = LocalStorage;
-exports.LocalStore = LocalStore;
-exports.LocalWeb3Provider = LocalWeb3Provider;
+exports.MemoryItemStore = MemoryItemStore;
 exports.MuxMessageProvider = MuxMessageProvider;
 exports.OpenState = OpenState;
 exports.PROVIDER_OPEN_TIMEOUT = PROVIDER_OPEN_TIMEOUT;
@@ -3870,20 +3950,23 @@ exports.ProxyMessageChannel = ProxyMessageChannel;
 exports.ProxyMessageChannelPort = ProxyMessageChannelPort;
 exports.ProxyMessageHandler = ProxyMessageHandler;
 exports.ProxyMessageProvider = ProxyMessageProvider;
-exports.SESSION_LOCALSTORE_KEY = SESSION_LOCALSTORE_KEY;
+exports.SequenceClient = SequenceClient;
+exports.SequenceClientSession = SequenceClientSession;
+exports.SequenceProvider = SequenceProvider;
+exports.SequenceSigner = SequenceSigner;
+exports.SingleNetworkSequenceProvider = SingleNetworkSequenceProvider;
+exports.SingleNetworkSequenceSigner = SingleNetworkSequenceSigner;
 exports.UnrealMessageHandler = UnrealMessageHandler;
 exports.UnrealMessageProvider = UnrealMessageProvider;
-exports.Wallet = Wallet;
 exports.WalletRequestHandler = WalletRequestHandler;
-exports.Web3Provider = Web3Provider;
-exports.Web3Signer = Web3Signer;
 exports.WindowMessageHandler = WindowMessageHandler;
 exports.WindowMessageProvider = WindowMessageProvider;
 exports.WindowSessionParams = WindowSessionParams;
 exports.getWallet = getWallet;
 exports.initWallet = initWallet;
 exports.isBrowserExtension = isBrowserExtension;
-exports.isSequenceProvider = isSequenceProvider;
+exports.isMuxTransportTemplate = isMuxTransportTemplate;
+exports.isProviderTransport = isProviderTransport;
 exports.isUnityPlugin = isUnityPlugin;
 exports.isValidMessageSignature = isValidMessageSignature;
 exports.isValidSignature = isValidSignature;
@@ -3892,5 +3975,7 @@ exports.isWalletUpToDate = isWalletUpToDate;
 exports.messageToBytes = messageToBytes;
 exports.nextMessageIdx = nextMessageIdx;
 exports.prefixEIP191Message = prefixEIP191Message;
+exports.resolveArrayProperties = resolveArrayProperties;
 exports.trimEIP191Prefix = trimEIP191Prefix;
 exports.unregisterWallet = unregisterWallet;
+exports.useBestStore = useBestStore;