@0xsequence/provider 0.40.1 → 0.40.4

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

@@ -593,19 +593,19 @@ class WalletRequestHandler {
               let sig = ''; // Message must be prefixed with "\x19Ethereum Signed Message:\n"
               // as defined by EIP-191
 
-              message = prefixEIP191Message(message); // TODO:
+              const prefixedMessage = prefixEIP191Message(message); // TODO:
               // if (process.env.TEST_MODE === 'true' && this.prompter === null) {
 
               if (_this.prompter === null) {
                 // prompter is null, so we'll sign from here
-                sig = await signer.signMessage(ethers.ethers.utils.arrayify(message), chainId);
+                sig = await signer.signMessage(prefixedMessage, chainId);
               } else {
                 const promptResultForDeployment = await _this.handleConfirmWalletDeployPrompt(_this.prompter, signer, chainId);
 
                 if (promptResultForDeployment) {
                   sig = await _this.prompter.promptSignMessage({
                     chainId: chainId,
-                    message
+                    message: prefixedMessage
                   }, _this.connectOptions);
                 }
               }
@@ -3145,6 +3145,257 @@ class BaseInjectedTransport extends eventemitter2.EventEmitter2 {
 
 }
 
+/**
+ * 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;
+  }
+}
+
+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.walletURL = void 0;
+
+    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 = exports.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);
+    };
+
+    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);
+  }
+
+  closeWallet() {
+    this.close();
+  } // onmessage, receives ProviderMessageResponse from the wallet unreal transport
+
+
+  // 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);
+  }
+
+}
+
+/**
+ * Initialized on Wallet side
+ */
+class UnrealMessageHandler extends BaseWalletTransport {
+  constructor(walletRequestHandler) {
+    super(walletRequestHandler);
+
+    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 = exports.InitState.NIL;
+  }
+
+  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; // 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('unreal session is undefined');
+      return;
+    } // listen for window-transport requests
+
+
+    window.ue.sequencewallettransport.onmessagefromsequencejs = this.onMessageFromUnreal;
+    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() {
+    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;
+  } // onmessage is called when (the wallet) receives request messages from the dapp
+  // over the unreal json-messaging transport
+
+
+  // sendMessage sends message to the dapp window
+  sendMessage(message) {
+    var _window$ue3, _window$ue3$sequencew;
+
+    if (message.type !== exports.EventType.INIT && this._init !== exports.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);
+  }
+
+}
+
 class WalletUtils {
   constructor(walletProvider) {
     var _this = this;
@@ -3250,7 +3501,7 @@ class Wallet {
     this.providers = void 0;
 
     this.init = () => {
-      var _this$config$transpor, _this$config$transpor2, _this$config$transpor3, _this$config$transpor4, _this$config$transpor5, _this$config$transpor6;
+      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;
 
       if (this.transport.provider) {
         // init must have already been called
@@ -3282,6 +3533,11 @@ class Wallet {
         // 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 => {
@@ -3366,13 +3622,28 @@ class Wallet {
         this.useSession({
           walletContext: walletContext
         }, true);
-      }); // Load existing session from localStorage
+      });
+    };
+
+    this.loadSession = async function () {
+      const data = await LocalStorage.getInstance().getItem('@sequence.session');
+
+      if (!data || data === '') {
+        return undefined;
+      }
+
+      try {
+        const session = JSON.parse(data);
 
-      this.loadSession().then(session => {
         if (session) {
-          this.useSession(session, false);
+          _this.useSession(session, false);
         }
-      });
+
+        return session;
+      } catch (err) {
+        utils.logger.warn('loadSession failed, unable to parse session payload from storage.');
+        return undefined;
+      }
     };
 
     this.connect = async function (options) {
@@ -3506,26 +3777,10 @@ class Wallet {
       this.transport.messageProvider.closeWallet();
     };
 
-    this.loadSession = async function () {
-      const data = await LocalStorage.getInstance().getItem('@sequence.session');
-
-      if (!data || data === '') {
-        return undefined;
-      }
-
-      try {
-        const session = JSON.parse(data);
-        return session;
-      } catch (err) {
-        utils.logger.warn('loadSession failed, unable to parse session payload from localStorage.');
-        return undefined;
-      }
-    };
-
-    this.saveSession = session => {
+    this.saveSession = async function (session) {
       utils.logger.debug('wallet provider: saving session');
       const data = JSON.stringify(session);
-      LocalStorage.getInstance().setItem('@sequence.session', data);
+      await LocalStorage.getInstance().setItem('@sequence.session', data);
     };
 
     this.useSession = async function (session, autoSave = true) {
@@ -3805,12 +4060,13 @@ const DefaultProviderConfig = {
   }
 };
 let walletInstance;
-const initWallet = (network, config) => {
+const initWallet = async (network, config) => {
   if (walletInstance && walletInstance.isOpened()) {
     walletInstance.closeWallet();
   }
 
   walletInstance = new Wallet(network, config);
+  await walletInstance.loadSession();
   return walletInstance;
 };
 const getWallet = () => {
@@ -3839,6 +4095,8 @@ exports.ProxyMessageChannel = ProxyMessageChannel;
 exports.ProxyMessageChannelPort = ProxyMessageChannelPort;
 exports.ProxyMessageHandler = ProxyMessageHandler;
 exports.ProxyMessageProvider = ProxyMessageProvider;
+exports.UnrealMessageHandler = UnrealMessageHandler;
+exports.UnrealMessageProvider = UnrealMessageProvider;
 exports.Wallet = Wallet;
 exports.WalletRequestHandler = WalletRequestHandler;
 exports.Web3Provider = Web3Provider;