@eluvio/elv-client-js 4.0.114 → 4.0.115

package/dist/src/walletClient/index.js

@@ -0,0 +1,2106 @@
+var _slicedToArray = require("@babel/runtime/helpers/slicedToArray");
+var _objectWithoutProperties = require("@babel/runtime/helpers/objectWithoutProperties");
+var _defineProperty = require("@babel/runtime/helpers/defineProperty");
+var _regeneratorRuntime = require("@babel/runtime/regenerator");
+var _typeof = require("@babel/runtime/helpers/typeof");
+var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
+var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");
+var _createClass = require("@babel/runtime/helpers/createClass");
+var _excluded = ["code", "address", "type", "authToken", "expiresAt"];
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var _require = require("../ElvClient"),
+  ElvClient = _require.ElvClient;
+var Configuration = require("./Configuration");
+var _require2 = require("./Utils"),
+  LinkTargetHash = _require2.LinkTargetHash,
+  FormatNFT = _require2.FormatNFT,
+  ActionPopup = _require2.ActionPopup;
+var HTTPClient = require("../HttpClient");
+var UrlJoin = require("url-join");
+var Utils = require("../Utils");
+var Ethers = require("ethers");
+var inBrowser = typeof window !== "undefined";
+var embedded = inBrowser && window.top !== window.self;
+var localStorageAvailable = false;
+try {
+  typeof localStorage !== "undefined" && localStorage.getItem("test");
+  localStorageAvailable = true;
+  // eslint-disable-next-line no-empty
+} catch (error) {}
+
+/**
+ * Use the <a href="#.Initialize">Initialize</a> method to initialize a new client.
+ *
+ *
+ * See the Modules section on the sidebar for all client methods unrelated to login and authorization
+ */
+var ElvWalletClient = /*#__PURE__*/function () {
+  "use strict";
+
+  function ElvWalletClient(_ref) {
+    var appId = _ref.appId,
+      client = _ref.client,
+      network = _ref.network,
+      mode = _ref.mode,
+      localization = _ref.localization,
+      marketplaceInfo = _ref.marketplaceInfo,
+      previewMarketplaceHash = _ref.previewMarketplaceHash,
+      storeAuthToken = _ref.storeAuthToken;
+    _classCallCheck(this, ElvWalletClient);
+    this.appId = appId;
+    this.client = client;
+    this.loggedIn = false;
+    this.localization = localization;
+    this.network = network;
+    this.mode = mode;
+    this.purchaseMode = Configuration[network][mode].purchaseMode;
+    this.mainSiteLibraryId = Configuration[network][mode].siteLibraryId;
+    this.mainSiteId = Configuration[network][mode].siteId;
+    this.appUrl = Configuration[network][mode].appUrl;
+    this.publicStaticToken = client.staticToken;
+    this.storeAuthToken = storeAuthToken;
+    this.selectedMarketplaceInfo = marketplaceInfo;
+    this.previewMarketplaceId = previewMarketplaceHash ? Utils.DecodeVersionHash(previewMarketplaceHash).objectId : undefined;
+    this.previewMarketplaceHash = previewMarketplaceHash;
+    this.availableMarketplaces = {};
+    this.availableMarketplacesById = {};
+    this.marketplaceHashes = {};
+    this.tenantConfigs = {};
+    this.stateStoreUrls = Configuration[network].stateStoreUrls;
+    this.stateStoreClient = new HTTPClient({
+      uris: this.stateStoreUrls
+    });
+    this.badgerAddress = Configuration[network].badgerAddress;
+
+    // Caches
+    this.cachedMarketplaces = {};
+    this.cachedCSS = {};
+    this.utils = client.utils;
+    this.ForbiddenMethods = ElvWalletClient.ForbiddenMethods;
+  }
+  _createClass(ElvWalletClient, [{
+    key: "Log",
+    value: function Log(message) {
+      var error = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var errorObject = arguments.length > 2 ? arguments[2] : undefined;
+      if (error) {
+        // eslint-disable-next-line no-console
+        console.error("Eluvio Wallet Client:", message);
+      } else {
+        // eslint-disable-next-line no-console
+        console.log("Eluvio Wallet Client:", message);
+      }
+      if (errorObject) {
+        // eslint-disable-next-line no-console
+        console.error(errorObject);
+      }
+    }
+
+    // Methods forbidden from usage by FrameClient
+  }, {
+    key: "CanSign",
+    value: /* Login and authorization */
+
+    /**
+     * Check if this client can sign without opening a popup.
+     *
+     * Generally, Eluvio custodial wallet users will require a popup prompt, while Metamask and custom OAuth users will not.
+     *
+     * @methodGroup Signatures
+     * @returns {boolean} - Whether or not this client can sign a message without a popup.
+     */
+    function CanSign() {
+      if (!this.loggedIn) {
+        return false;
+      }
+      return !!this.__authorization.clusterToken || inBrowser && !!(this.UserInfo().walletName.toLowerCase() === "metamask" && window.ethereum && window.ethereum.isMetaMask && window.ethereum.chainId);
+    }
+
+    /**
+     * <b><i>Requires login</i></b>
+     *
+     * Request the current user sign the specified message.
+     *
+     * If this client is not able to perform the signature (Eluvio custodial OAuth users), a popup will be opened and the user will be prompted to sign.
+     *
+     * To check if the signature can be done without a popup, use the <a href="#CanSign">CanSign</a> method.
+     *
+     * @methodGroup Signatures
+     * @namedParams
+     * @param {string} message - The message to sign
+     *
+     * @throws - If the user rejects the signature or closes the popup, an error will be thrown.
+     *
+     * @returns {Promise<string>} - The signature of the message
+     */
+  }, {
+    key: "PersonalSign",
+    value: function () {
+      var _PersonalSign = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref2) {
+        var message, parameters, url;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              message = _ref2.message;
+              if (this.loggedIn) {
+                _context3.next = 3;
+                break;
+              }
+              throw Error("ElvWalletClient: Unable to perform signature - Not logged in");
+            case 3:
+              if (!this.CanSign()) {
+                _context3.next = 19;
+                break;
+              }
+              if (!this.__authorization.clusterToken) {
+                _context3.next = 12;
+                break;
+              }
+              // Custodial wallet sign
+
+              message = _typeof(message) === "object" ? JSON.stringify(message) : message;
+              message = Ethers.utils.keccak256(Buffer.from("\x19Ethereum Signed Message:\n".concat(message.length).concat(message), "utf-8"));
+              _context3.next = 9;
+              return this.client.authClient.Sign(message);
+            case 9:
+              return _context3.abrupt("return", _context3.sent);
+            case 12:
+              if (!(this.UserInfo().walletName.toLowerCase() === "metamask")) {
+                _context3.next = 16;
+                break;
+              }
+              return _context3.abrupt("return", this.SignMetamask({
+                message: message,
+                address: this.UserAddress()
+              }));
+            case 16:
+              throw Error("ElvWalletClient: Unable to sign");
+            case 17:
+              _context3.next = 21;
+              break;
+            case 19:
+              if (inBrowser) {
+                _context3.next = 21;
+                break;
+              }
+              throw Error("ElvWalletClient: Unable to sign");
+            case 21:
+              parameters = {
+                action: "personal-sign",
+                message: message,
+                logIn: true
+              };
+              url = new URL(this.appUrl);
+              url.hash = UrlJoin("/action", "sign", Utils.B58(JSON.stringify(parameters)));
+              url.searchParams.set("origin", window.location.origin);
+              if (!(!embedded && window.location.origin === url.origin)) {
+                _context3.next = 27;
+                break;
+              }
+              throw Error("ElvWalletClient: Unable to sign");
+            case 27:
+              _context3.next = 29;
+              return new Promise( /*#__PURE__*/function () {
+                var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(resolve, reject) {
+                  return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+                    while (1) switch (_context2.prev = _context2.next) {
+                      case 0:
+                        _context2.next = 2;
+                        return ActionPopup({
+                          mode: "tab",
+                          url: url.toString(),
+                          onCancel: function onCancel() {
+                            return reject("User cancelled sign");
+                          },
+                          onMessage: function () {
+                            var _onMessage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(event, Close) {
+                              return _regeneratorRuntime.wrap(function _callee$(_context) {
+                                while (1) switch (_context.prev = _context.next) {
+                                  case 0:
+                                    if (!(!event || !event.data || event.data.type !== "FlowResponse")) {
+                                      _context.next = 2;
+                                      break;
+                                    }
+                                    return _context.abrupt("return");
+                                  case 2:
+                                    try {
+                                      resolve(event.data.response);
+                                    } catch (error) {
+                                      reject(error);
+                                    } finally {
+                                      Close();
+                                    }
+                                  case 3:
+                                  case "end":
+                                    return _context.stop();
+                                }
+                              }, _callee);
+                            }));
+                            function onMessage(_x4, _x5) {
+                              return _onMessage.apply(this, arguments);
+                            }
+                            return onMessage;
+                          }()
+                        });
+                      case 2:
+                      case "end":
+                        return _context2.stop();
+                    }
+                  }, _callee2);
+                }));
+                return function (_x2, _x3) {
+                  return _ref3.apply(this, arguments);
+                };
+              }());
+            case 29:
+              return _context3.abrupt("return", _context3.sent);
+            case 30:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function PersonalSign(_x) {
+        return _PersonalSign.apply(this, arguments);
+      }
+      return PersonalSign;
+    }()
+  }, {
+    key: "LogInURL",
+    value: function () {
+      var _LogInURL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(_ref4) {
+        var _ref4$mode, mode, provider, marketplaceParams, clearLogin, loginUrl;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _ref4$mode = _ref4.mode, mode = _ref4$mode === void 0 ? "login" : _ref4$mode, provider = _ref4.provider, marketplaceParams = _ref4.marketplaceParams, clearLogin = _ref4.clearLogin;
+              loginUrl = new URL(this.appUrl);
+              loginUrl.hash = "/login";
+              loginUrl.searchParams.set("action", "login");
+              if (typeof window !== "undefined") {
+                loginUrl.searchParams.set("origin", window.location.origin);
+              }
+              if (provider) {
+                loginUrl.searchParams.set("provider", provider);
+              }
+              if (mode) {
+                loginUrl.searchParams.set("mode", mode);
+              }
+              if (!marketplaceParams) {
+                _context4.next = 15;
+                break;
+              }
+              _context4.t0 = loginUrl.searchParams;
+              _context4.next = 11;
+              return this.MarketplaceInfo({
+                marketplaceParams: marketplaceParams
+              });
+            case 11:
+              _context4.t1 = _context4.sent.marketplaceHash;
+              _context4.t0.set.call(_context4.t0, "mid", _context4.t1);
+              _context4.next = 16;
+              break;
+            case 15:
+              if ((this.selectedMarketplaceInfo || {}).marketplaceHash) {
+                loginUrl.searchParams.set("mid", this.selectedMarketplaceInfo.marketplaceHash);
+              }
+            case 16:
+              if (clearLogin) {
+                loginUrl.searchParams.set("clear", "");
+              }
+              return _context4.abrupt("return", loginUrl);
+            case 18:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function LogInURL(_x6) {
+        return _LogInURL.apply(this, arguments);
+      }
+      return LogInURL;
+    }()
+    /**
+     * Direct the user to the Eluvio Media Wallet login page.
+     *
+     * For redirect login, the authorization token will be included in the URL parameters of the callbackUrl. Simply re-initialize the wallet client and it will authorize with this token,
+     * or you can retrieve the parameter (`elvToken`) yourself and use it in the <a href="#Authenticate">Authenticate</a> method.
+     *
+     * <b>NOTE:</b> The domain of the opening window (popup flow) or domain of the `callbackUrl` (redirect flow) MUST be allowed in the metadata of the specified marketplace.
+     *
+     * @methodGroup Login
+     * @namedParams
+     * @param {string=} method=redirect - How to present the login page.
+     * - `redirect` - Redirect to the wallet login page. Upon login, the page will be redirected back to the specified `redirectUrl` with the authorization token.
+     * - `popup` - Open the wallet login page in a new tab. Upon login, authorization information will be sent back to the client via message and the tab will be closed.
+     * @param {string=} provider - If logging in via a specific method, specify the provider and mode. Options: `oauth`, `metamask`
+     * @param {string=} mode - If logging in via a specific method, specify the mode. Options `login` (Log In), `create` (Sign Up)
+     * @param {string=} callbackUrl - If using the redirect flow, the URL to redirect back to after login.
+     * @param {Object=} marketplaceParams - Parameters of a marketplace to associate the login with. If not specified, the marketplace parameters used upon client initialization will be used. A marketplace is required when using the redirect flow.
+     * @param {boolean=} clearLogin=false - If specified, the user will be prompted to log in anew even if they are already logged in on the Eluvio Media Wallet app
+     *
+     * @throws - If using the popup flow and the user closes the popup, this method will throw an error.
+     */
+  }, {
+    key: "LogIn",
+    value: function () {
+      var _LogIn = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(_ref5) {
+        var _this = this;
+        var _ref5$method, method, provider, _ref5$mode, mode, callbackUrl, marketplaceParams, _ref5$clearLogin, clearLogin, callback, loginUrl;
+        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _ref5$method = _ref5.method, method = _ref5$method === void 0 ? "redirect" : _ref5$method, provider = _ref5.provider, _ref5$mode = _ref5.mode, mode = _ref5$mode === void 0 ? "login" : _ref5$mode, callbackUrl = _ref5.callbackUrl, marketplaceParams = _ref5.marketplaceParams, _ref5$clearLogin = _ref5.clearLogin, clearLogin = _ref5$clearLogin === void 0 ? false : _ref5$clearLogin, callback = _ref5.callback;
+              _context7.next = 3;
+              return this.LogInURL({
+                mode: mode,
+                provider: provider,
+                marketplaceParams: marketplaceParams,
+                clearLogin: clearLogin
+              });
+            case 3:
+              loginUrl = _context7.sent;
+              if (!(method === "redirect")) {
+                _context7.next = 11;
+                break;
+              }
+              loginUrl.searchParams.set("response", "redirect");
+              loginUrl.searchParams.set("source", "origin");
+              loginUrl.searchParams.set("redirect", callbackUrl);
+              window.location = loginUrl;
+              _context7.next = 15;
+              break;
+            case 11:
+              loginUrl.searchParams.set("response", "message");
+              loginUrl.searchParams.set("source", "parent");
+              _context7.next = 15;
+              return new Promise( /*#__PURE__*/function () {
+                var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(resolve, reject) {
+                  return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+                    while (1) switch (_context6.prev = _context6.next) {
+                      case 0:
+                        _context6.next = 2;
+                        return ActionPopup({
+                          mode: "tab",
+                          url: loginUrl.toString(),
+                          onCancel: function onCancel() {
+                            return reject("User cancelled login");
+                          },
+                          onMessage: function () {
+                            var _onMessage2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(event, Close) {
+                              return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+                                while (1) switch (_context5.prev = _context5.next) {
+                                  case 0:
+                                    if (!(!event || !event.data || event.data.type !== "LoginResponse")) {
+                                      _context5.next = 2;
+                                      break;
+                                    }
+                                    return _context5.abrupt("return");
+                                  case 2:
+                                    _context5.prev = 2;
+                                    if (!callback) {
+                                      _context5.next = 8;
+                                      break;
+                                    }
+                                    _context5.next = 6;
+                                    return callback(event.data.params);
+                                  case 6:
+                                    _context5.next = 10;
+                                    break;
+                                  case 8:
+                                    _context5.next = 10;
+                                    return _this.Authenticate({
+                                      token: event.data.params.clientSigningToken || event.data.params.clientAuthToken
+                                    });
+                                  case 10:
+                                    resolve();
+                                    _context5.next = 16;
+                                    break;
+                                  case 13:
+                                    _context5.prev = 13;
+                                    _context5.t0 = _context5["catch"](2);
+                                    reject(_context5.t0);
+                                  case 16:
+                                    _context5.prev = 16;
+                                    Close();
+                                    return _context5.finish(16);
+                                  case 19:
+                                  case "end":
+                                    return _context5.stop();
+                                }
+                              }, _callee5, null, [[2, 13, 16, 19]]);
+                            }));
+                            function onMessage(_x10, _x11) {
+                              return _onMessage2.apply(this, arguments);
+                            }
+                            return onMessage;
+                          }()
+                        });
+                      case 2:
+                      case "end":
+                        return _context6.stop();
+                    }
+                  }, _callee6);
+                }));
+                return function (_x8, _x9) {
+                  return _ref6.apply(this, arguments);
+                };
+              }());
+            case 15:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function LogIn(_x7) {
+        return _LogIn.apply(this, arguments);
+      }
+      return LogIn;
+    }()
+    /**
+     * Remove authorization for the current user.
+     *
+     * @methodGroup Login
+     */
+  }, {
+    key: "LogOut",
+    value: function () {
+      var _LogOut = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              if (!(this.__authorization && this.__authorization.nonce)) {
+                _context8.next = 9;
+                break;
+              }
+              _context8.prev = 1;
+              _context8.next = 4;
+              return this.client.signer.ReleaseCSAT({
+                accessToken: this.AuthToken()
+              });
+            case 4:
+              _context8.next = 9;
+              break;
+            case 6:
+              _context8.prev = 6;
+              _context8.t0 = _context8["catch"](1);
+              this.Log("Failed to release token", true, _context8.t0);
+            case 9:
+              this.__authorization = {};
+              this.loggedIn = false;
+              this.cachedMarketplaces = {};
+
+              // Delete saved auth token
+              if (localStorageAvailable) {
+                try {
+                  localStorage.removeItem("__elv-token-".concat(this.network));
+                  // eslint-disable-next-line no-empty
+                } catch (error) {}
+              }
+            case 13:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this, [[1, 6]]);
+      }));
+      function LogOut() {
+        return _LogOut.apply(this, arguments);
+      }
+      return LogOut;
+    }()
+  }, {
+    key: "TokenStatus",
+    value: function () {
+      var _TokenStatus = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+        return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              if (!(!this.__authorization || !this.__authorization.nonce)) {
+                _context9.next = 2;
+                break;
+              }
+              return _context9.abrupt("return", true);
+            case 2:
+              _context9.next = 4;
+              return this.client.signer.CSATStatus({
+                accessToken: this.AuthToken()
+              });
+            case 4:
+              return _context9.abrupt("return", _context9.sent);
+            case 5:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this);
+      }));
+      function TokenStatus() {
+        return _TokenStatus.apply(this, arguments);
+      }
+      return TokenStatus;
+    }()
+    /**
+     * Authenticate with an ElvWalletClient authorization token
+     *
+     * @methodGroup Authorization
+     * @namedParams
+     * @param {string} token - A previously generated ElvWalletClient authorization token;
+     */
+  }, {
+    key: "Authenticate",
+    value: function () {
+      var _Authenticate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10(_ref7) {
+        var token, decodedToken;
+        return _regeneratorRuntime.wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              token = _ref7.token;
+              _context10.prev = 1;
+              decodedToken = JSON.parse(this.utils.FromB58ToStr(token)) || {};
+              _context10.next = 8;
+              break;
+            case 5:
+              _context10.prev = 5;
+              _context10.t0 = _context10["catch"](1);
+              throw new Error("Invalid authorization token " + token);
+            case 8:
+              if (!(!decodedToken.expiresAt || Date.now() > decodedToken.expiresAt)) {
+                _context10.next = 10;
+                break;
+              }
+              throw Error("ElvWalletClient: Provided authorization token has expired");
+            case 10:
+              if (!decodedToken.clusterToken) {
+                _context10.next = 13;
+                break;
+              }
+              _context10.next = 13;
+              return this.client.SetRemoteSigner({
+                authToken: decodedToken.clusterToken,
+                signerURIs: decodedToken.signerURIs
+              });
+            case 13:
+              this.client.SetStaticToken({
+                token: decodedToken.fabricToken
+              });
+              return _context10.abrupt("return", this.SetAuthorization(_objectSpread({}, decodedToken)));
+            case 15:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this, [[1, 5]]);
+      }));
+      function Authenticate(_x12) {
+        return _Authenticate.apply(this, arguments);
+      }
+      return Authenticate;
+    }()
+    /**
+     * Authenticate with an OAuth ID token
+     *
+     * @methodGroup Authorization
+     * @namedParams
+     * @param {string} idToken - An OAuth ID token
+     * @param {string=} tenantId - ID of tenant with which to associate the user. If marketplace info was set upon initialization, this will be determined automatically.
+     * @param {string=} email - Email address of the user. If not specified, this method will attempt to extract the email from the ID token.
+     * @param {Array<string>=} signerURIs - (Only if using custom OAuth) - URIs corresponding to the key server(s) to use
+     * @param {boolean=} shareEmail=false - Whether or not the user consents to sharing their email
+     *
+     * @returns {Promise<Object>} - Returns an authorization tokens that can be used to initialize the client using <a href="#Authenticate">Authenticate</a>.
+     * Save this token to avoid having to reauthenticate with OAuth. This token expires after 24 hours.
+     *
+     * The result includes two tokens:
+     * - token - Standard client auth token used to access content and perform actions on behalf of the user.
+     * - signingToken - Identical to `authToken`, but also includes the ability to perform arbitrary signatures with the custodial wallet. This token should be protected and should not be
+     * shared with third parties.
+     */
+  }, {
+    key: "AuthenticateOAuth",
+    value: function () {
+      var _AuthenticateOAuth = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11(_ref8) {
+        var idToken, tenantId, email, signerURIs, _ref8$shareEmail, shareEmail, _ref8$extraData, extraData, nonce, _ref8$createRemoteTok, createRemoteToken, _ref8$force, force, tokenDuration, fabricToken, expiresAt, tokenResponse, address, decodedToken;
+        return _regeneratorRuntime.wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              idToken = _ref8.idToken, tenantId = _ref8.tenantId, email = _ref8.email, signerURIs = _ref8.signerURIs, _ref8$shareEmail = _ref8.shareEmail, shareEmail = _ref8$shareEmail === void 0 ? false : _ref8$shareEmail, _ref8$extraData = _ref8.extraData, extraData = _ref8$extraData === void 0 ? {} : _ref8$extraData, nonce = _ref8.nonce, _ref8$createRemoteTok = _ref8.createRemoteToken, createRemoteToken = _ref8$createRemoteTok === void 0 ? true : _ref8$createRemoteTok, _ref8$force = _ref8.force, force = _ref8$force === void 0 ? false : _ref8$force;
+              tokenDuration = 24;
+              if (!(!tenantId && this.selectedMarketplaceInfo)) {
+                _context11.next = 6;
+                break;
+              }
+              _context11.next = 5;
+              return this.AvailableMarketplaces();
+            case 5:
+              tenantId = this.selectedMarketplaceInfo.tenantId;
+            case 6:
+              _context11.next = 8;
+              return this.client.SetRemoteSigner({
+                idToken: idToken,
+                tenantId: tenantId,
+                signerURIs: signerURIs,
+                extraData: _objectSpread(_objectSpread({}, extraData), {}, {
+                  share_email: shareEmail
+                }),
+                unsignedPublicAuth: true
+              });
+            case 8:
+              if (!(createRemoteToken && this.client.signer.remoteSigner)) {
+                _context11.next = 17;
+                break;
+              }
+              expiresAt = Date.now() + 24 * 60 * 60 * 1000;
+              _context11.next = 12;
+              return this.client.signer.RetrieveCSAT({
+                email: email,
+                nonce: nonce,
+                tenantId: tenantId,
+                force: force
+              });
+            case 12:
+              tokenResponse = _context11.sent;
+              fabricToken = tokenResponse.token;
+              nonce = tokenResponse.nonce;
+              _context11.next = 21;
+              break;
+            case 17:
+              expiresAt = Date.now() + tokenDuration * 60 * 60 * 1000;
+              _context11.next = 20;
+              return this.client.CreateFabricToken({
+                duration: tokenDuration * 60 * 60 * 1000,
+                context: email ? {
+                  usr: {
+                    email: email
+                  }
+                } : {}
+              });
+            case 20:
+              fabricToken = _context11.sent;
+            case 21:
+              address = this.client.utils.FormatAddress(this.client.CurrentAccountAddress());
+              if (email) {
+                _context11.next = 31;
+                break;
+              }
+              _context11.prev = 23;
+              decodedToken = JSON.parse(this.utils.FromB64URL(idToken.split(".")[1]));
+              email = decodedToken.email;
+              _context11.next = 31;
+              break;
+            case 28:
+              _context11.prev = 28;
+              _context11.t0 = _context11["catch"](23);
+              throw Error("Failed to decode ID token");
+            case 31:
+              this.client.SetStaticToken({
+                token: fabricToken
+              });
+              return _context11.abrupt("return", {
+                authToken: this.SetAuthorization({
+                  fabricToken: fabricToken,
+                  tenantId: tenantId,
+                  address: address,
+                  email: email,
+                  expiresAt: expiresAt,
+                  signerURIs: signerURIs,
+                  walletType: "Custodial",
+                  walletName: "Eluvio",
+                  register: true,
+                  nonce: nonce
+                }),
+                signingToken: this.SetAuthorization({
+                  clusterToken: this.client.signer.authToken,
+                  fabricToken: fabricToken,
+                  tenantId: tenantId,
+                  address: address,
+                  email: email,
+                  expiresAt: expiresAt,
+                  signerURIs: signerURIs,
+                  walletType: "Custodial",
+                  walletName: "Eluvio",
+                  nonce: nonce
+                })
+              });
+            case 33:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this, [[23, 28]]);
+      }));
+      function AuthenticateOAuth(_x13) {
+        return _AuthenticateOAuth.apply(this, arguments);
+      }
+      return AuthenticateOAuth;
+    }()
+    /**
+     * Authenticate with an external Ethereum compatible wallet, like Metamask.
+     *
+     * @methodGroup Authorization
+     * @namedParams
+     * @param {string} address - The address of the wallet
+     * @param {number=} tokenDuration=24 - Number of hours the generated authorization token will last before expiring
+     * @param {string=} walletName=Metamask - Name of the external wallet
+     * @param {function=} Sign - The method used for signing by the wallet. If not specified, will attempt to sign with Metamask.
+     *
+     * @returns {Promise<string>} - Returns an authorization token that can be used to initialize the client using <a href="#Authenticate">Authenticate</a>.
+     * Save this token to avoid having to reauthenticate. This token expires after 24 hours.
+     */
+  }, {
+    key: "AuthenticateExternalWallet",
+    value: function () {
+      var _AuthenticateExternalWallet = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee13(_ref9) {
+        var _this2 = this;
+        var address, _ref9$tokenDuration, tokenDuration, _ref9$walletName, walletName, Sign, expiresAt, fabricToken;
+        return _regeneratorRuntime.wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              address = _ref9.address, _ref9$tokenDuration = _ref9.tokenDuration, tokenDuration = _ref9$tokenDuration === void 0 ? 24 : _ref9$tokenDuration, _ref9$walletName = _ref9.walletName, walletName = _ref9$walletName === void 0 ? "Metamask" : _ref9$walletName, Sign = _ref9.Sign;
+              if (!address) {
+                address = window.ethereum.selectedAddress;
+              }
+              address = this.utils.FormatAddress(address);
+              if (!Sign) {
+                Sign = /*#__PURE__*/function () {
+                  var _ref10 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12(message) {
+                    return _regeneratorRuntime.wrap(function _callee12$(_context12) {
+                      while (1) switch (_context12.prev = _context12.next) {
+                        case 0:
+                          return _context12.abrupt("return", _this2.SignMetamask({
+                            message: message,
+                            address: address
+                          }));
+                        case 1:
+                        case "end":
+                          return _context12.stop();
+                      }
+                    }, _callee12);
+                  }));
+                  return function Sign(_x15) {
+                    return _ref10.apply(this, arguments);
+                  };
+                }();
+              }
+              expiresAt = Date.now() + tokenDuration * 60 * 60 * 1000;
+              _context13.next = 7;
+              return this.client.CreateFabricToken({
+                address: address,
+                duration: tokenDuration * 60 * 60 * 1000,
+                Sign: Sign,
+                addEthereumPrefix: false
+              });
+            case 7:
+              fabricToken = _context13.sent;
+              return _context13.abrupt("return", this.SetAuthorization({
+                fabricToken: fabricToken,
+                address: address,
+                expiresAt: expiresAt,
+                walletType: "External",
+                walletName: walletName,
+                register: true
+              }));
+            case 9:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this);
+      }));
+      function AuthenticateExternalWallet(_x14) {
+        return _AuthenticateExternalWallet.apply(this, arguments);
+      }
+      return AuthenticateExternalWallet;
+    }()
+    /**
+     * <b><i>Requires login</i></b>
+     *
+     * Retrieve the current client auth token
+     *
+     * @returns {string} - The client auth token
+     */
+  }, {
+    key: "ClientAuthToken",
+    value: function ClientAuthToken() {
+      if (!this.loggedIn) {
+        return "";
+      }
+      return this.utils.B58(JSON.stringify(this.__authorization));
+    }
+  }, {
+    key: "AuthToken",
+    value: function AuthToken() {
+      if (!this.loggedIn) {
+        return this.publicStaticToken;
+      }
+      return this.__authorization.fabricToken;
+    }
+  }, {
+    key: "SetAuthorization",
+    value: function SetAuthorization(_ref11) {
+      var _this3 = this;
+      var clusterToken = _ref11.clusterToken,
+        fabricToken = _ref11.fabricToken,
+        tenantId = _ref11.tenantId,
+        address = _ref11.address,
+        email = _ref11.email,
+        expiresAt = _ref11.expiresAt,
+        signerURIs = _ref11.signerURIs,
+        walletType = _ref11.walletType,
+        walletName = _ref11.walletName,
+        nonce = _ref11.nonce,
+        _ref11$register = _ref11.register,
+        register = _ref11$register === void 0 ? false : _ref11$register;
+      address = this.client.utils.FormatAddress(address);
+      this.__authorization = {
+        fabricToken: fabricToken,
+        tenantId: tenantId,
+        address: address,
+        email: email,
+        expiresAt: expiresAt,
+        walletType: walletType,
+        walletName: walletName,
+        nonce: nonce
+      };
+      if (clusterToken) {
+        this.__authorization.clusterToken = clusterToken;
+        if (signerURIs) {
+          this.__authorization.signerURIs = signerURIs;
+        }
+      }
+      this.loggedIn = true;
+      this.cachedMarketplaces = {};
+      var token = this.ClientAuthToken();
+      if (this.storeAuthToken && localStorageAvailable) {
+        try {
+          localStorage.setItem("__elv-token-".concat(this.network), token);
+          // eslint-disable-next-line no-empty
+        } catch (error) {}
+      }
+      if (register) {
+        this.client.authClient.MakeAuthServiceRequest({
+          path: "/as/wlt/register",
+          method: "POST",
+          headers: {
+            Authorization: "Bearer ".concat(this.AuthToken())
+          }
+        })["catch"](function (error) {
+          _this3.Log("Failed to register account: ", true, error);
+        });
+      }
+      return token;
+    }
+  }, {
+    key: "SignMetamask",
+    value: function () {
+      var _SignMetamask = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee14(_ref12) {
+        var message, address, accounts;
+        return _regeneratorRuntime.wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              message = _ref12.message, address = _ref12.address;
+              if (!(!inBrowser || !window.ethereum)) {
+                _context14.next = 3;
+                break;
+              }
+              throw Error("ElvWalletClient: Unable to initialize - Metamask not available");
+            case 3:
+              address = address || this.UserAddress();
+              _context14.next = 6;
+              return window.ethereum.request({
+                method: "eth_requestAccounts"
+              });
+            case 6:
+              accounts = _context14.sent;
+              if (!(address && !Utils.EqualAddress(accounts[0], address))) {
+                _context14.next = 9;
+                break;
+              }
+              throw Error("ElvWalletClient: Incorrect MetaMask account selected. Expected ".concat(address, ", got ").concat(accounts[0]));
+            case 9:
+              _context14.next = 11;
+              return window.ethereum.request({
+                method: "personal_sign",
+                params: [message, address, ""]
+              });
+            case 11:
+              return _context14.abrupt("return", _context14.sent);
+            case 12:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14, this);
+      }));
+      function SignMetamask(_x16) {
+        return _SignMetamask.apply(this, arguments);
+      }
+      return SignMetamask;
+    }()
+  }, {
+    key: "FlowURL",
+    value: function FlowURL(_ref13) {
+      var _ref13$type = _ref13.type,
+        type = _ref13$type === void 0 ? "flow" : _ref13$type,
+        flow = _ref13.flow,
+        marketplaceId = _ref13.marketplaceId,
+        _ref13$parameters = _ref13.parameters,
+        parameters = _ref13$parameters === void 0 ? {} : _ref13$parameters;
+      var url = new URL(this.appUrl);
+      if (marketplaceId) {
+        url.pathname = UrlJoin("/", type, flow, "marketplace", marketplaceId, Utils.B58(JSON.stringify(parameters)));
+      } else {
+        url.pathname = UrlJoin("/", type, flow, Utils.B58(JSON.stringify(parameters)));
+      }
+      url.searchParams.set("origin", window.location.origin);
+      return url.toString();
+    }
+  }, {
+    key: "GenerateCodeAuth",
+    value: function () {
+      var _GenerateCodeAuth = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee15() {
+        var _ref14,
+          url,
+          response,
+          _args15 = arguments;
+        return _regeneratorRuntime.wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              _ref14 = _args15.length > 0 && _args15[0] !== undefined ? _args15[0] : {}, url = _ref14.url;
+              if (url) {
+                _context15.next = 7;
+                break;
+              }
+              _context15.next = 4;
+              return this.LogInURL({
+                mode: "login"
+              });
+            case 4:
+              url = _context15.sent;
+              url.searchParams.set("response", "code");
+              url.searchParams.set("source", "code");
+            case 7:
+              _context15.next = 9;
+              return Utils.ResponseToJson(this.client.authClient.MakeAuthServiceRequest({
+                path: UrlJoin("as", "wlt", "login", "redirect", "metamask"),
+                method: "POST",
+                body: {
+                  op: "create",
+                  dest: url.toString()
+                }
+              }));
+            case 9:
+              response = _context15.sent;
+              response.code = response.id;
+              response.url = response.url.startsWith("https://") ? response.url : "https://".concat(response.url);
+              response.metamask_url = response.metamask_url.startsWith("https://") ? response.metamask_url : "https://".concat(response.metamask_url);
+              return _context15.abrupt("return", response);
+            case 14:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this);
+      }));
+      function GenerateCodeAuth() {
+        return _GenerateCodeAuth.apply(this, arguments);
+      }
+      return GenerateCodeAuth;
+    }()
+  }, {
+    key: "SetCodeAuth",
+    value: function () {
+      var _SetCodeAuth = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee16(_ref15) {
+        var code, address, type, authToken, expiresAt, additionalPayload;
+        return _regeneratorRuntime.wrap(function _callee16$(_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              code = _ref15.code, address = _ref15.address, type = _ref15.type, authToken = _ref15.authToken, expiresAt = _ref15.expiresAt, additionalPayload = _objectWithoutProperties(_ref15, _excluded);
+              _context16.next = 3;
+              return Utils.ResponseToJson(this.client.authClient.MakeAuthServiceRequest({
+                path: UrlJoin("as", "wlt", "login", "session", code),
+                method: "POST",
+                headers: {
+                  Authorization: "Bearer ".concat(this.AuthToken())
+                },
+                body: {
+                  op: "set",
+                  id: code,
+                  format: "auth_token",
+                  payload: JSON.stringify(_objectSpread({
+                    addr: Utils.FormatAddress(address),
+                    eth: address ? "ikms".concat(Utils.AddressToHash(address)) : "",
+                    type: type,
+                    token: authToken,
+                    expiresAt: expiresAt
+                  }, additionalPayload))
+                }
+              }));
+            case 3:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16, this);
+      }));
+      function SetCodeAuth(_x17) {
+        return _SetCodeAuth.apply(this, arguments);
+      }
+      return SetCodeAuth;
+    }()
+  }, {
+    key: "GetCodeAuth",
+    value: function () {
+      var _GetCodeAuth = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee17(_ref16) {
+        var code, passcode;
+        return _regeneratorRuntime.wrap(function _callee17$(_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+              code = _ref16.code, passcode = _ref16.passcode;
+              _context17.prev = 1;
+              _context17.next = 4;
+              return Utils.ResponseToJson(this.client.authClient.MakeAuthServiceRequest({
+                path: UrlJoin("as", "wlt", "login", "redirect", "metamask", code, passcode),
+                method: "GET"
+              }));
+            case 4:
+              return _context17.abrupt("return", _context17.sent);
+            case 7:
+              _context17.prev = 7;
+              _context17.t0 = _context17["catch"](1);
+              if (!(_context17.t0 && _context17.t0.status === 404)) {
+                _context17.next = 11;
+                break;
+              }
+              return _context17.abrupt("return", undefined);
+            case 11:
+              throw _context17.t0;
+            case 12:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee17, this, [[1, 7]]);
+      }));
+      function GetCodeAuth(_x18) {
+        return _GetCodeAuth.apply(this, arguments);
+      }
+      return GetCodeAuth;
+    }() // Internal loading methods
+  }, {
+    key: "LoadAvailableMarketplaces",
+    value: function () {
+      var _LoadAvailableMarketplaces = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee18() {
+        var _this4 = this;
+        var forceReload,
+          metadata,
+          marketplaceOrder,
+          previewTenantSlug,
+          previewMarketplaceSlug,
+          previewMarketplaceMetadata,
+          availableMarketplaces,
+          availableMarketplacesById,
+          _args18 = arguments;
+        return _regeneratorRuntime.wrap(function _callee18$(_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+              forceReload = _args18.length > 0 && _args18[0] !== undefined ? _args18[0] : false;
+              if (!(!forceReload && Object.keys(this.availableMarketplaces) > 0)) {
+                _context18.next = 3;
+                break;
+              }
+              return _context18.abrupt("return");
+            case 3:
+              _context18.next = 5;
+              return this.client.ContentObjectMetadata({
+                libraryId: this.mainSiteLibraryId,
+                objectId: this.mainSiteId,
+                metadataSubtree: "public/asset_metadata",
+                resolveLinks: true,
+                linkDepthLimit: 2,
+                resolveIncludeSource: true,
+                resolveIgnoreErrors: true,
+                produceLinkUrls: true,
+                authorizationToken: this.publicStaticToken,
+                noAuth: true,
+                select: ["info/marketplace_order", "tenants/*/.", "tenants/*/info/branding/show", "tenants/*/info/branding/name", "tenants/*/marketplaces/*/.", "tenants/*/marketplaces/*/info/tenant_id", "tenants/*/marketplaces/*/info/tenant_name", "tenants/*/marketplaces/*/info/branding/show", "tenants/*/marketplaces/*/info/branding/name"]
+              });
+            case 5:
+              metadata = _context18.sent;
+              marketplaceOrder = ((metadata || {}).info || {}).marketplace_order || [];
+              metadata = (metadata || {}).tenants || {};
+
+              // If preview marketplace is specified, load it appropriately
+              if (!this.previewMarketplaceId) {
+                _context18.next = 23;
+                break;
+              }
+              previewTenantSlug = "PREVIEW";
+              Object.keys(metadata || {}).forEach(function (tenantSlug) {
+                return Object.keys(metadata[tenantSlug].marketplaces || {}).forEach(function (marketplaceSlug) {
+                  var versionHash = metadata[tenantSlug].marketplaces[marketplaceSlug]["."].source;
+                  var objectId = _this4.utils.DecodeVersionHash(versionHash).objectId;
+                  if (objectId === _this4.previewMarketplaceId) {
+                    // Marketplace exists in site meta
+                    previewTenantSlug = tenantSlug;
+                    previewMarketplaceSlug = marketplaceSlug;
+
+                    // Deployed marketplace is same as preview marketplace
+                    if (versionHash === _this4.previewMarketplaceHash) {
+                      previewMarketplaceMetadata = metadata[tenantSlug].marketplaces[marketplaceSlug];
+                    }
+                  }
+                });
+              });
+
+              // Marketplace not present in branch, or preview version is different - Load metadata directly
+              if (previewMarketplaceMetadata) {
+                _context18.next = 16;
+                break;
+              }
+              _context18.next = 14;
+              return this.client.ContentObjectMetadata({
+                versionHash: this.previewMarketplaceHash,
+                metadataSubtree: "public/asset_metadata",
+                produceLinkUrls: true,
+                authorizationToken: this.publicStaticToken,
+                noAuth: true,
+                select: ["slug", "info/tenant_id", "info/tenant_name", "info/branding"],
+                remove: ["info/branding/custom_css"]
+              });
+            case 14:
+              previewMarketplaceMetadata = _context18.sent;
+              if (!previewMarketplaceSlug) {
+                previewMarketplaceSlug = previewMarketplaceMetadata.slug;
+              }
+            case 16:
+              previewMarketplaceMetadata["."] = {
+                source: this.previewMarketplaceHash
+              };
+              previewMarketplaceMetadata.info["."] = {
+                source: this.previewMarketplaceHash
+              };
+              previewMarketplaceMetadata.info.branding.preview = true;
+              previewMarketplaceMetadata.info.branding.show = true;
+              metadata[previewTenantSlug] = metadata[previewTenantSlug] || {};
+              metadata[previewTenantSlug].marketplaces = metadata[previewTenantSlug].marketplaces || {};
+              metadata[previewTenantSlug].marketplaces[previewMarketplaceSlug] = previewMarketplaceMetadata;
+            case 23:
+              availableMarketplaces = _objectSpread({}, this.availableMarketplaces || {});
+              availableMarketplacesById = _objectSpread({}, this.availableMarketplacesById || {});
+              Object.keys(metadata || {}).forEach(function (tenantSlug) {
+                try {
+                  availableMarketplaces[tenantSlug] = metadata[tenantSlug]["."] ? {
+                    versionHash: metadata[tenantSlug]["."].source
+                  } : {};
+                  Object.keys(metadata[tenantSlug].marketplaces || {}).forEach(function (marketplaceSlug) {
+                    try {
+                      var versionHash = metadata[tenantSlug].marketplaces[marketplaceSlug]["."].source;
+                      var objectId = _this4.utils.DecodeVersionHash(versionHash).objectId;
+                      availableMarketplaces[tenantSlug][marketplaceSlug] = _objectSpread(_objectSpread({}, metadata[tenantSlug].marketplaces[marketplaceSlug].info || {}), {}, {
+                        tenantName: metadata[tenantSlug].marketplaces[marketplaceSlug].info.tenant_name,
+                        tenantId: metadata[tenantSlug].marketplaces[marketplaceSlug].info.tenant_id,
+                        tenantSlug: tenantSlug,
+                        marketplaceSlug: marketplaceSlug,
+                        marketplaceId: objectId,
+                        marketplaceHash: versionHash,
+                        tenantBranding: (metadata[tenantSlug].info || {}).branding || {},
+                        order: marketplaceOrder.findIndex(function (slug) {
+                          return slug === marketplaceSlug;
+                        })
+                      });
+                      availableMarketplacesById[objectId] = availableMarketplaces[tenantSlug][marketplaceSlug];
+                      _this4.marketplaceHashes[objectId] = versionHash;
+
+                      // Fill out selected marketplace info
+                      if (_this4.selectedMarketplaceInfo) {
+                        if (_this4.selectedMarketplaceInfo.tenantSlug === tenantSlug && _this4.selectedMarketplaceInfo.marketplaceSlug === marketplaceSlug || _this4.selectedMarketplaceInfo.marketplaceId === objectId) {
+                          _this4.selectedMarketplaceInfo = availableMarketplaces[tenantSlug][marketplaceSlug];
+                        }
+                      }
+                    } catch (error) {
+                      _this4.Log("Eluvio Wallet Client: Unable to load info for marketplace ".concat(tenantSlug, "/").concat(marketplaceSlug), true);
+                    }
+                  });
+                } catch (error) {
+                  _this4.Log("Eluvio Wallet Client: Failed to load tenant info ".concat(tenantSlug), true, error);
+                }
+              });
+              this.availableMarketplaces = availableMarketplaces;
+              this.availableMarketplacesById = availableMarketplacesById;
+            case 28:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee18, this);
+      }));
+      function LoadAvailableMarketplaces() {
+        return _LoadAvailableMarketplaces.apply(this, arguments);
+      }
+      return LoadAvailableMarketplaces;
+    }() // Get the hash of the currently linked marketplace
+  }, {
+    key: "LatestMarketplaceHash",
+    value: function () {
+      var _LatestMarketplaceHash = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee19(_ref17) {
+        var marketplaceParams, marketplaceInfo, marketplaceLink;
+        return _regeneratorRuntime.wrap(function _callee19$(_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              marketplaceParams = _ref17.marketplaceParams;
+              _context19.next = 3;
+              return this.MarketplaceInfo({
+                marketplaceParams: marketplaceParams
+              });
+            case 3:
+              marketplaceInfo = _context19.sent;
+              if (!(this.previewMarketplaceId && Utils.EqualHash(this.previewMarketplaceId, marketplaceInfo.marketplaceId))) {
+                _context19.next = 6;
+                break;
+              }
+              return _context19.abrupt("return", this.previewMarketplaceHash);
+            case 6:
+              _context19.next = 8;
+              return this.client.ContentObjectMetadata({
+                libraryId: this.mainSiteLibraryId,
+                objectId: this.mainSiteId,
+                metadataSubtree: UrlJoin("/public", "asset_metadata", "tenants", marketplaceInfo.tenantSlug, "marketplaces", marketplaceInfo.marketplaceSlug),
+                resolveLinks: false,
+                noAuth: true
+              });
+            case 8:
+              marketplaceLink = _context19.sent;
+              return _context19.abrupt("return", LinkTargetHash(marketplaceLink));
+            case 10:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee19, this);
+      }));
+      function LatestMarketplaceHash(_x19) {
+        return _LatestMarketplaceHash.apply(this, arguments);
+      }
+      return LatestMarketplaceHash;
+    }()
+  }, {
+    key: "LoadMarketplace",
+    value: function () {
+      var _LoadMarketplace = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee21(marketplaceParams) {
+        var _this5 = this;
+        var marketplaceInfo, marketplaceId, marketplaceHash, marketplace;
+        return _regeneratorRuntime.wrap(function _callee21$(_context21) {
+          while (1) switch (_context21.prev = _context21.next) {
+            case 0:
+              marketplaceInfo = this.MarketplaceInfo({
+                marketplaceParams: marketplaceParams
+              });
+              marketplaceId = marketplaceInfo.marketplaceId;
+              _context21.next = 4;
+              return this.LatestMarketplaceHash({
+                marketplaceParams: marketplaceParams
+              });
+            case 4:
+              marketplaceHash = _context21.sent;
+              if (this.cachedMarketplaces[marketplaceId] && this.cachedMarketplaces[marketplaceId].versionHash !== marketplaceHash) {
+                delete this.cachedMarketplaces[marketplaceId];
+              }
+              if (this.cachedMarketplaces[marketplaceId]) {
+                _context21.next = 34;
+                break;
+              }
+              if (!(this.previewMarketplaceId && Utils.EqualHash(marketplaceId, this.previewMarketplaceId))) {
+                _context21.next = 13;
+                break;
+              }
+              _context21.next = 10;
+              return this.client.ContentObjectMetadata({
+                versionHash: this.previewMarketplaceHash,
+                metadataSubtree: "/public/asset_metadata/info",
+                localizationSubtree: this.localization ? UrlJoin("public", "asset_metadata", "localizations", this.localization, "info") : undefined,
+                linkDepthLimit: 1,
+                resolveLinks: true,
+                resolveIgnoreErrors: true,
+                resolveIncludeSource: true,
+                produceLinkUrls: true,
+                authorizationToken: this.publicStaticToken
+              });
+            case 10:
+              marketplace = _context21.sent;
+              _context21.next = 16;
+              break;
+            case 13:
+              _context21.next = 15;
+              return this.client.ContentObjectMetadata({
+                libraryId: this.mainSiteLibraryId,
+                objectId: this.mainSiteId,
+                metadataSubtree: UrlJoin("/public", "asset_metadata", "tenants", marketplaceInfo.tenantSlug, "marketplaces", marketplaceInfo.marketplaceSlug, "info"),
+                localizationSubtree: this.localization ? UrlJoin("/public", "asset_metadata", "tenants", marketplaceInfo.tenantSlug, "marketplaces", marketplaceInfo.marketplaceSlug, "localizations", this.localization, "info") : undefined,
+                linkDepthLimit: 1,
+                resolveLinks: true,
+                resolveIgnoreErrors: true,
+                resolveIncludeSource: true,
+                produceLinkUrls: true,
+                authorizationToken: this.publicStaticToken
+              });
+            case 15:
+              marketplace = _context21.sent;
+            case 16:
+              if (!marketplace.branding.use_tenant_styling) {
+                _context21.next = 23;
+                break;
+              }
+              _context21.next = 19;
+              return this.client.ContentObjectMetadata({
+                libraryId: this.mainSiteLibraryId,
+                objectId: this.mainSiteId,
+                metadataSubtree: UrlJoin("/public", "asset_metadata", "tenants", marketplaceInfo.tenantSlug, "info", "branding"),
+                authorizationToken: this.publicStaticToken,
+                produceLinkUrls: true
+              });
+            case 19:
+              _context21.t0 = _context21.sent;
+              if (_context21.t0) {
+                _context21.next = 22;
+                break;
+              }
+              _context21.t0 = {};
+            case 22:
+              marketplace.tenantBranding = _context21.t0;
+            case 23:
+              _context21.next = 25;
+              return Promise.all(marketplace.items.map( /*#__PURE__*/function () {
+                var _ref18 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee20(item, index) {
+                  var authorizationToken;
+                  return _regeneratorRuntime.wrap(function _callee20$(_context20) {
+                    while (1) switch (_context20.prev = _context20.next) {
+                      case 0:
+                        if (!item.requires_permissions) {
+                          _context20.next = 14;
+                          break;
+                        }
+                        if (_this5.loggedIn) {
+                          _context20.next = 5;
+                          break;
+                        }
+                        _context20.next = 4;
+                        return _this5.client.CreateFabricToken({});
+                      case 4:
+                        authorizationToken = _context20.sent;
+                      case 5:
+                        _context20.prev = 5;
+                        _context20.next = 8;
+                        return _this5.client.ContentObjectMetadata({
+                          versionHash: LinkTargetHash(item.nft_template),
+                          metadataSubtree: "permissioned",
+                          authorizationToken: authorizationToken
+                        });
+                      case 8:
+                        item.authorized = true;
+                        _context20.next = 14;
+                        break;
+                      case 11:
+                        _context20.prev = 11;
+                        _context20.t0 = _context20["catch"](5);
+                        item.authorized = false;
+                      case 14:
+                        item.nftTemplateMetadata = (item.nft_template || {}).nft || {};
+                        item.nftTemplateHash = ((item.nft_template || {})["."] || {}).source;
+                        item.itemIndex = index;
+                        return _context20.abrupt("return", item);
+                      case 18:
+                      case "end":
+                        return _context20.stop();
+                    }
+                  }, _callee20, null, [[5, 11]]);
+                }));
+                return function (_x21, _x22) {
+                  return _ref18.apply(this, arguments);
+                };
+              }()));
+            case 25:
+              marketplace.items = _context21.sent;
+              marketplace.collections = (marketplace.collections || []).map(function (collection, collectionIndex) {
+                return _objectSpread(_objectSpread({}, collection), {}, {
+                  collectionIndex: collectionIndex
+                });
+              });
+              marketplace.retrievedAt = Date.now();
+              marketplace.marketplaceId = marketplaceId;
+              marketplace.versionHash = marketplaceHash;
+              marketplace.marketplaceHash = marketplaceHash;
+              if (this.previewMarketplaceId && marketplaceId === this.previewMarketplaceId) {
+                marketplace.branding.preview = true;
+              }
+
+              // Generate embed URLs for pack opening animations
+              ["purchase_animation", "purchase_animation_mobile", "reveal_animation", "reveal_animation_mobile"].forEach(function (key) {
+                try {
+                  if (marketplace.storefront[key]) {
+                    var embedUrl = new URL("https://embed.v3.contentfabric.io");
+                    var targetHash = LinkTargetHash(marketplace.storefront[key]);
+                    embedUrl.searchParams.set("p", "");
+                    embedUrl.searchParams.set("net", _this5.network === "main" ? "main" : "demo");
+                    embedUrl.searchParams.set("ath", (_this5.__authorization || {}).authToken || _this5.publicStaticToken);
+                    embedUrl.searchParams.set("vid", targetHash);
+                    embedUrl.searchParams.set("ap", "");
+                    if (!key.startsWith("reveal")) {
+                      embedUrl.searchParams.set("m", "");
+                      embedUrl.searchParams.set("lp", "");
+                    }
+                    marketplace.storefront["".concat(key, "_embed_url")] = embedUrl.toString();
+                  }
+                  // eslint-disable-next-line no-empty
+                } catch (error) {}
+              });
+              this.cachedMarketplaces[marketplaceId] = marketplace;
+            case 34:
+              return _context21.abrupt("return", this.cachedMarketplaces[marketplaceId]);
+            case 35:
+            case "end":
+              return _context21.stop();
+          }
+        }, _callee21, this);
+      }));
+      function LoadMarketplace(_x20) {
+        return _LoadMarketplace.apply(this, arguments);
+      }
+      return LoadMarketplace;
+    }()
+  }, {
+    key: "FilteredQuery",
+    value: function () {
+      var _FilteredQuery = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee22() {
+        var _this6 = this;
+        var _ref19,
+          _ref19$mode,
+          mode,
+          _ref19$sortBy,
+          sortBy,
+          _ref19$sortDesc,
+          sortDesc,
+          filter,
+          editionFilters,
+          attributeFilters,
+          contractAddress,
+          tokenId,
+          currency,
+          marketplaceParams,
+          tenantId,
+          collectionIndexes,
+          priceRange,
+          tokenIdRange,
+          capLimit,
+          userAddress,
+          sellerAddress,
+          _ref19$lastNDays,
+          lastNDays,
+          startTime,
+          endTime,
+          _ref19$includeCheckou,
+          includeCheckoutLocked,
+          _ref19$start,
+          start,
+          _ref19$limit,
+          limit,
+          params,
+          marketplaceInfo,
+          marketplace,
+          filters,
+          headers,
+          path,
+          _ref21,
+          contents,
+          paging,
+          modesToFormat,
+          _args22 = arguments;
+        return _regeneratorRuntime.wrap(function _callee22$(_context22) {
+          while (1) switch (_context22.prev = _context22.next) {
+            case 0:
+              _ref19 = _args22.length > 0 && _args22[0] !== undefined ? _args22[0] : {}, _ref19$mode = _ref19.mode, mode = _ref19$mode === void 0 ? "listings" : _ref19$mode, _ref19$sortBy = _ref19.sortBy, sortBy = _ref19$sortBy === void 0 ? "created" : _ref19$sortBy, _ref19$sortDesc = _ref19.sortDesc, sortDesc = _ref19$sortDesc === void 0 ? false : _ref19$sortDesc, filter = _ref19.filter, editionFilters = _ref19.editionFilters, attributeFilters = _ref19.attributeFilters, contractAddress = _ref19.contractAddress, tokenId = _ref19.tokenId, currency = _ref19.currency, marketplaceParams = _ref19.marketplaceParams, tenantId = _ref19.tenantId, collectionIndexes = _ref19.collectionIndexes, priceRange = _ref19.priceRange, tokenIdRange = _ref19.tokenIdRange, capLimit = _ref19.capLimit, userAddress = _ref19.userAddress, sellerAddress = _ref19.sellerAddress, _ref19$lastNDays = _ref19.lastNDays, lastNDays = _ref19$lastNDays === void 0 ? -1 : _ref19$lastNDays, startTime = _ref19.startTime, endTime = _ref19.endTime, _ref19$includeCheckou = _ref19.includeCheckoutLocked, includeCheckoutLocked = _ref19$includeCheckou === void 0 ? false : _ref19$includeCheckou, _ref19$start = _ref19.start, start = _ref19$start === void 0 ? 0 : _ref19$start, _ref19$limit = _ref19.limit, limit = _ref19$limit === void 0 ? 50 : _ref19$limit;
+              collectionIndexes = (collectionIndexes || []).map(function (i) {
+                return parseInt(i);
+              });
+              params = {
+                start: start,
+                limit: limit,
+                sort_descending: sortDesc
+              }; // Created isn't a valid sort mode for owned
+              if (mode === "owned" && sortBy === "created") {
+                sortBy = "default";
+              }
+              if (mode !== "leaderboard") {
+                params.sort_by = sortBy;
+              }
+              if (mode.includes("listings") && includeCheckoutLocked) {
+                params.checkout = true;
+              }
+              if (!marketplaceParams) {
+                _context22.next = 14;
+                break;
+              }
+              _context22.next = 9;
+              return this.MarketplaceInfo({
+                marketplaceParams: marketplaceParams
+              });
+            case 9:
+              marketplaceInfo = _context22.sent;
+              if (!(collectionIndexes.length > 0)) {
+                _context22.next = 14;
+                break;
+              }
+              _context22.next = 13;
+              return this.Marketplace({
+                marketplaceParams: marketplaceParams
+              });
+            case 13:
+              marketplace = _context22.sent;
+            case 14:
+              _context22.prev = 14;
+              filters = [];
+              if (sellerAddress) {
+                filters.push("seller:eq:".concat(this.client.utils.FormatAddress(sellerAddress)));
+              } else if (userAddress && mode !== "owned") {
+                filters.push("addr:eq:".concat(this.client.utils.FormatAddress(userAddress)));
+              }
+              if (marketplace && collectionIndexes.length >= 0) {
+                collectionIndexes.forEach(function (collectionIndex) {
+                  var collection = marketplace.collections[collectionIndex];
+                  collection.items.forEach(function (sku) {
+                    if (!sku) {
+                      return;
+                    }
+                    var item = marketplace.items.find(function (item) {
+                      return item.sku === sku;
+                    });
+                    if (!item) {
+                      return;
+                    }
+                    var address = Utils.SafeTraverse(item, "nft_template", "nft", "address");
+                    if (address) {
+                      filters.push("".concat(mode === "owned" ? "contract_addr" : "contract", ":eq:").concat(Utils.FormatAddress(address)));
+                    }
+                  });
+                });
+              } else if (marketplaceInfo || tenantId) {
+                filters.push("tenant:eq:".concat(marketplaceInfo ? marketplaceInfo.tenantId : tenantId));
+              }
+              if (contractAddress) {
+                if (mode === "owned") {
+                  filters.push("contract_addr:eq:".concat(Utils.FormatAddress(contractAddress)));
+                } else {
+                  filters.push("contract:eq:".concat(Utils.FormatAddress(contractAddress)));
+                }
+                if (tokenId) {
+                  filters.push("token:eq:".concat(tokenId));
+                }
+              } else if (filter) {
+                if (mode.includes("listing")) {
+                  filters.push("nft/display_name:eq:".concat(filter));
+                } else if (mode === "owned") {
+                  filters.push("meta/display_name:eq:".concat(filter));
+                } else {
+                  filters.push("name:eq:".concat(filter));
+                }
+              }
+              if (editionFilters) {
+                editionFilters.forEach(function (editionFilter) {
+                  if (mode.includes("listing")) {
+                    filters.push("nft/edition_name:eq:".concat(editionFilter));
+                  } else if (mode === "owned") {
+                    filters.push("meta:@>:{\"edition_name\":\"".concat(editionFilter, "\"}"));
+                    params.exact = false;
+                  } else {
+                    filters.push("edition:eq:".concat(editionFilter));
+                  }
+                });
+              }
+              if (attributeFilters) {
+                attributeFilters.map(function (_ref20) {
+                  var name = _ref20.name,
+                    value = _ref20.value;
+                  if (!name || !value) {
+                    return;
+                  }
+                  filters.push("nft/attributes/".concat(name, ":eq:").concat(value));
+                });
+              }
+              if (currency) {
+                filters.push("link_type:eq:sol");
+              }
+              if (startTime || endTime) {
+                if (startTime) {
+                  filters.push("created:gt:".concat(parseInt(startTime) / 1000));
+                }
+                if (endTime) {
+                  filters.push("created:lt:".concat(parseInt(endTime) / 1000));
+                }
+              } else if (lastNDays && lastNDays > 0) {
+                filters.push("created:gt:".concat((Date.now() / 1000 - lastNDays * 24 * 60 * 60).toFixed(0)));
+              }
+              if (priceRange) {
+                if (priceRange.min) {
+                  filters.push("price:ge:".concat(parseFloat(priceRange.min)));
+                }
+                if (priceRange.max) {
+                  filters.push("price:le:".concat(parseFloat(priceRange.max)));
+                }
+              }
+              if (tokenIdRange) {
+                if (tokenIdRange.min) {
+                  filters.push("info/token_id:ge:".concat(parseInt(tokenIdRange.min)));
+                }
+                if (tokenIdRange.max) {
+                  filters.push("info/token_id:le:".concat(parseInt(tokenIdRange.max)));
+                }
+              }
+              if (capLimit) {
+                filters.push("info/cap:le:".concat(parseInt(capLimit)));
+              }
+              _context22.t0 = mode;
+              _context22.next = _context22.t0 === "owned" ? 29 : _context22.t0 === "owned-full-meta" ? 31 : _context22.t0 === "listings" ? 34 : _context22.t0 === "transfers" ? 36 : _context22.t0 === "sales" ? 40 : _context22.t0 === "listing-stats" ? 44 : _context22.t0 === "sales-stats" ? 46 : _context22.t0 === "leaderboard" ? 49 : 51;
+              break;
+            case 29:
+              path = UrlJoin("as", "wlt", userAddress || this.UserAddress());
+              return _context22.abrupt("break", 51);
+            case 31:
+              path = UrlJoin("as", "apigw", "nfts");
+              headers = {
+                Authorization: "Bearer ".concat(this.AuthToken())
+              };
+              return _context22.abrupt("break", 51);
+            case 34:
+              path = UrlJoin("as", "mkt", "f");
+              return _context22.abrupt("break", 51);
+            case 36:
+              path = UrlJoin("as", "mkt", "hst", "f");
+              filters.push("action:eq:TRANSFERRED");
+              filters.push("action:eq:SOLD");
+              return _context22.abrupt("break", 51);
+            case 40:
+              path = UrlJoin("as", "mkt", "hst", "f");
+              filters.push("action:eq:SOLD");
+              filters.push("seller:co:0x");
+              return _context22.abrupt("break", 51);
+            case 44:
+              path = UrlJoin("as", "mkt", "stats", "listed");
+              return _context22.abrupt("break", 51);
+            case 46:
+              path = UrlJoin("as", "mkt", "stats", "sold");
+              filters.push("seller:co:0x");
+              return _context22.abrupt("break", 51);
+            case 49:
+              path = UrlJoin("as", "wlt", "leaders");
+              return _context22.abrupt("break", 51);
+            case 51:
+              if (filters.length > 0) {
+                params.filter = filters;
+              }
+              if (!mode.includes("stats")) {
+                _context22.next = 56;
+                break;
+              }
+              _context22.next = 55;
+              return Utils.ResponseToJson(this.client.authClient.MakeAuthServiceRequest({
+                path: path,
+                method: "GET",
+                queryParams: params,
+                headers: headers
+              }));
+            case 55:
+              return _context22.abrupt("return", _context22.sent);
+            case 56:
+              _context22.t2 = Utils;
+              _context22.next = 59;
+              return this.client.authClient.MakeAuthServiceRequest({
+                path: path,
+                method: "GET",
+                queryParams: params,
+                headers: headers
+              });
+            case 59:
+              _context22.t3 = _context22.sent;
+              _context22.next = 62;
+              return _context22.t2.ResponseToJson.call(_context22.t2, _context22.t3);
+            case 62:
+              _context22.t1 = _context22.sent;
+              if (_context22.t1) {
+                _context22.next = 65;
+                break;
+              }
+              _context22.t1 = [];
+            case 65:
+              _ref21 = _context22.t1;
+              contents = _ref21.contents;
+              paging = _ref21.paging;
+              modesToFormat = ["owned", "listings", "owned-full-meta"];
+              return _context22.abrupt("return", {
+                paging: {
+                  start: params.start,
+                  limit: params.limit,
+                  total: paging.total,
+                  more: paging.total > start + limit
+                },
+                results: (contents || []).map(function (item) {
+                  return modesToFormat.includes(mode) ? FormatNFT(_this6, item) : item;
+                })
+              });
+            case 72:
+              _context22.prev = 72;
+              _context22.t4 = _context22["catch"](14);
+              if (!(_context22.t4.status && _context22.t4.status.toString() === "404")) {
+                _context22.next = 76;
+                break;
+              }
+              return _context22.abrupt("return", {
+                paging: {
+                  start: params.start,
+                  limit: params.limit,
+                  total: 0,
+                  more: false
+                },
+                results: []
+              });
+            case 76:
+              throw _context22.t4;
+            case 77:
+            case "end":
+              return _context22.stop();
+          }
+        }, _callee22, this, [[14, 72]]);
+      }));
+      function FilteredQuery() {
+        return _FilteredQuery.apply(this, arguments);
+      }
+      return FilteredQuery;
+    }()
+  }, {
+    key: "MintingStatus",
+    value: function () {
+      var _MintingStatus = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee23(_ref22) {
+        var marketplaceParams, tenantId, marketplaceInfo, response;
+        return _regeneratorRuntime.wrap(function _callee23$(_context23) {
+          while (1) switch (_context23.prev = _context23.next) {
+            case 0:
+              marketplaceParams = _ref22.marketplaceParams, tenantId = _ref22.tenantId;
+              if (tenantId) {
+                _context23.next = 6;
+                break;
+              }
+              _context23.next = 4;
+              return this.MarketplaceInfo({
+                marketplaceParams: marketplaceParams || this.selectedMarketplaceInfo
+              });
+            case 4:
+              marketplaceInfo = _context23.sent;
+              tenantId = marketplaceInfo.tenantId;
+            case 6:
+              _context23.prev = 6;
+              _context23.next = 9;
+              return Utils.ResponseToJson(this.client.authClient.MakeAuthServiceRequest({
+                path: UrlJoin("as", "wlt", "status", "act", tenantId),
+                method: "GET",
+                headers: {
+                  Authorization: "Bearer ".concat(this.AuthToken())
+                }
+              }));
+            case 9:
+              response = _context23.sent;
+              return _context23.abrupt("return", response.map(function (status) {
+                var _status$op$split = status.op.split(":"),
+                  _status$op$split2 = _slicedToArray(_status$op$split, 3),
+                  op = _status$op$split2[0],
+                  address = _status$op$split2[1],
+                  id = _status$op$split2[2];
+                address = address.startsWith("0x") ? Utils.FormatAddress(address) : address;
+                var confirmationId, tokenId, offerId, giftId;
+                if (op === "nft-buy") {
+                  confirmationId = id;
+                } else if (op === "nft-claim") {
+                  confirmationId = id;
+                  status.marketplaceId = address;
+                  if (status.extra && status.extra["0"]) {
+                    address = status.extra.token_addr;
+                    tokenId = status.extra.token_id_str;
+                  }
+                } else if (op === "nft-redeem") {
+                  confirmationId = status.op.split(":").slice(-1)[0];
+                } else {
+                  tokenId = id;
+                }
+                if (op === "nft-transfer") {
+                  confirmationId = status.extra && status.extra.trans_id;
+                  tokenId = status.extra && status.extra.token_id_str || tokenId;
+                  if (status.extra && status.extra.gift_action === "nft-gift-claim") {
+                    giftId = status.extra.gift_id;
+                  }
+                }
+                if (op === "nft-offer-redeem") {
+                  offerId = status.op.split(":")[3];
+                }
+                if (op === "nft-claim-entitlement") {
+                  var _status$op$split3 = status.op.split(":"),
+                    _status$op$split4 = _slicedToArray(_status$op$split3, 4),
+                    _op = _status$op$split4[0],
+                    marketplace = _status$op$split4[1],
+                    sku = _status$op$split4[2],
+                    purchaseId = _status$op$split4[3];
+                  confirmationId = purchaseId;
+                  if (status.extra && status.extra["0"]) {
+                    address = status.extra["0"].token_addr;
+                    tokenId = status.extra["0"].token_id;
+                    address = address.startsWith("0x") ? Utils.FormatAddress(address) : address;
+                    status.marketplaceId = marketplace;
+                  }
+                }
+                return _objectSpread(_objectSpread({}, status), {}, {
+                  timestamp: new Date(status.ts),
+                  state: status.state && _typeof(status.state) === "object" ? Object.values(status.state) : status.state,
+                  extra: status.extra && _typeof(status.extra) === "object" ? Object.values(status.extra) : status.extra,
+                  confirmationId: confirmationId,
+                  op: op,
+                  address: Utils.FormatAddress(address),
+                  tokenId: tokenId,
+                  offerId: offerId,
+                  giftId: giftId
+                });
+              }).sort(function (a, b) {
+                return a.ts < b.ts ? 1 : -1;
+              }));
+            case 13:
+              _context23.prev = 13;
+              _context23.t0 = _context23["catch"](6);
+              this.Log("Failed to retrieve minting status", true, _context23.t0);
+              return _context23.abrupt("return", []);
+            case 17:
+            case "end":
+              return _context23.stop();
+          }
+        }, _callee23, this, [[6, 13]]);
+      }));
+      function MintingStatus(_x23) {
+        return _MintingStatus.apply(this, arguments);
+      }
+      return MintingStatus;
+    }()
+  }, {
+    key: "DeployTenant",
+    value: function () {
+      var _DeployTenant = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee24(_ref23) {
+        var tenantId, _ref23$tenantSlug, tenantSlug, tenantHash, _ref23$environment, environment, tenantLink, deployedTenantHash, body, token;
+        return _regeneratorRuntime.wrap(function _callee24$(_context24) {
+          while (1) switch (_context24.prev = _context24.next) {
+            case 0:
+              tenantId = _ref23.tenantId, _ref23$tenantSlug = _ref23.tenantSlug, tenantSlug = _ref23$tenantSlug === void 0 ? "" : _ref23$tenantSlug, tenantHash = _ref23.tenantHash, _ref23$environment = _ref23.environment, environment = _ref23$environment === void 0 ? "production" : _ref23$environment;
+              if (tenantHash) {
+                _context24.next = 11;
+                break;
+              }
+              _context24.next = 4;
+              return this.client.ContentObjectMetadata({
+                libraryId: this.mainSiteLibraryId,
+                objectId: this.mainSiteId,
+                metadataSubtree: UrlJoin("public/asset_metadata/tenants", tenantSlug),
+                resolveLinks: true,
+                linkDepthLimit: 1,
+                resolveIncludeSource: true,
+                resolveIgnoreErrors: true,
+                select: ["."]
+              });
+            case 4:
+              tenantLink = _context24.sent;
+              if (tenantLink) {
+                _context24.next = 7;
+                break;
+              }
+              throw Error("Eluvio Wallet Client: Invalid or missing tenancy: ".concat(tenantSlug));
+            case 7:
+              deployedTenantHash = tenantLink["."].source;
+              _context24.next = 10;
+              return this.client.LatestVersionHash({
+                versionHash: deployedTenantHash
+              });
+            case 10:
+              tenantHash = _context24.sent;
+            case 11:
+              body = {
+                content_hash: tenantHash,
+                env: environment,
+                ts: Date.now()
+              };
+              _context24.next = 14;
+              return this.client.Sign(JSON.stringify(body));
+            case 14:
+              token = _context24.sent;
+              _context24.next = 17;
+              return this.client.authClient.MakeAuthServiceRequest({
+                path: UrlJoin("as", "tnt", "config", tenantId, "metadata"),
+                method: "POST",
+                body: body,
+                headers: {
+                  Authorization: "Bearer ".concat(token)
+                }
+              });
+            case 17:
+            case "end":
+              return _context24.stop();
+          }
+        }, _callee24, this);
+      }));
+      function DeployTenant(_x24) {
+        return _DeployTenant.apply(this, arguments);
+      }
+      return DeployTenant;
+    }()
+  }], [{
+    key: "ForbiddenMethods",
+    value: function ForbiddenMethods() {
+      return ["constructor", "Authenticate", "AuthenticateOAuth", "AuthenticateExternalWallet", "AuthToken", "ClientAuthToken", "Initialize", "Log", "LogIn", "LogOut", "PersonalSign", "SetAuthorization", "SignMetamask"];
+    }
+
+    // Used to generate AllowedWalletClientMethods for FrameClient
+    // Note: Do not import ElvWalletClient in FrameClient directly
+  }, {
+    key: "AllowedMethods",
+    value: function AllowedMethods() {
+      return Object.getOwnPropertyNames(ElvWalletClient.prototype).filter(function (methodName) {
+        return !ElvWalletClient.ForbiddenMethods().includes(methodName);
+      }).sort();
+    }
+
+    /**
+     * Initialize the wallet client.
+     *
+     * Specify tenantSlug and marketplaceSlug to automatically associate this tenant with a particular marketplace.
+     *
+     *
+     * @methodGroup Initialization
+     * @namedParams
+     * @param {string} appId - A string identifying your app. This is used for namespacing user profile data.
+     * @param {string} network=main - Name of the Fabric network to use (`main`, `demo`)
+     * @param {string} mode=production - Environment to use (`production`, `staging`)
+     * @param {Object=} marketplaceParams - Marketplace parameters
+     * @param {boolean=} storeAuthToken=true - If specified, auth tokens will be stored in localstorage (if available)
+     * @param {Object=} client - Existing instance of ElvClient to use instead of initializing a new one
+     *
+     * @returns {Promise<ElvWalletClient>}
+     */
+  }, {
+    key: "Initialize",
+    value: function () {
+      var _Initialize = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee25(_ref24) {
+        var client, _ref24$appId, appId, _ref24$network, network, _ref24$mode, mode, localization, marketplaceParams, previewMarketplaceId, _ref24$storeAuthToken, storeAuthToken, _ref24$skipMarketplac, skipMarketplaceLoad, _ref25, tenantSlug, marketplaceSlug, marketplaceId, marketplaceHash, previewMarketplaceHash, walletClient, url, savedToken;
+        return _regeneratorRuntime.wrap(function _callee25$(_context25) {
+          while (1) switch (_context25.prev = _context25.next) {
+            case 0:
+              client = _ref24.client, _ref24$appId = _ref24.appId, appId = _ref24$appId === void 0 ? "general" : _ref24$appId, _ref24$network = _ref24.network, network = _ref24$network === void 0 ? "main" : _ref24$network, _ref24$mode = _ref24.mode, mode = _ref24$mode === void 0 ? "production" : _ref24$mode, localization = _ref24.localization, marketplaceParams = _ref24.marketplaceParams, previewMarketplaceId = _ref24.previewMarketplaceId, _ref24$storeAuthToken = _ref24.storeAuthToken, storeAuthToken = _ref24$storeAuthToken === void 0 ? true : _ref24$storeAuthToken, _ref24$skipMarketplac = _ref24.skipMarketplaceLoad, skipMarketplaceLoad = _ref24$skipMarketplac === void 0 ? false : _ref24$skipMarketplac;
+              _ref25 = marketplaceParams || {}, tenantSlug = _ref25.tenantSlug, marketplaceSlug = _ref25.marketplaceSlug, marketplaceId = _ref25.marketplaceId, marketplaceHash = _ref25.marketplaceHash;
+              if (Configuration[network]) {
+                _context25.next = 6;
+                break;
+              }
+              throw Error("ElvWalletClient: Invalid network ".concat(network));
+            case 6:
+              if (Configuration[network][mode]) {
+                _context25.next = 8;
+                break;
+              }
+              throw Error("ElvWalletClient: Invalid mode ".concat(mode));
+            case 8:
+              if (client) {
+                _context25.next = 12;
+                break;
+              }
+              _context25.next = 11;
+              return ElvClient.FromNetworkName({
+                networkName: network,
+                assumeV3: true
+              });
+            case 11:
+              client = _context25.sent;
+            case 12:
+              previewMarketplaceHash = previewMarketplaceId;
+              if (!(previewMarketplaceHash && !previewMarketplaceHash.startsWith("hq__"))) {
+                _context25.next = 17;
+                break;
+              }
+              _context25.next = 16;
+              return client.LatestVersionHash({
+                objectId: previewMarketplaceId
+              });
+            case 16:
+              previewMarketplaceHash = _context25.sent;
+            case 17:
+              walletClient = new ElvWalletClient({
+                appId: appId,
+                client: client,
+                network: network,
+                mode: mode,
+                localization: localization,
+                marketplaceInfo: {
+                  tenantSlug: tenantSlug,
+                  marketplaceSlug: marketplaceSlug,
+                  marketplaceId: marketplaceHash ? client.utils.DecodeVersionHash(marketplaceHash).objectId : marketplaceId,
+                  marketplaceHash: marketplaceHash
+                },
+                previewMarketplaceHash: previewMarketplaceHash,
+                storeAuthToken: storeAuthToken
+              });
+              if (!(inBrowser && window.location && window.location.href)) {
+                _context25.next = 37;
+                break;
+              }
+              url = new URL(window.location.href);
+              if (!url.searchParams.get("elvToken")) {
+                _context25.next = 27;
+                break;
+              }
+              _context25.next = 23;
+              return walletClient.Authenticate({
+                token: url.searchParams.get("elvToken")
+              });
+            case 23:
+              url.searchParams["delete"]("elvToken");
+              window.history.replaceState("", "", url);
+              _context25.next = 37;
+              break;
+            case 27:
+              if (!(storeAuthToken && localStorageAvailable)) {
+                _context25.next = 37;
+                break;
+              }
+              _context25.prev = 28;
+              // Load saved auth token
+              savedToken = localStorage.getItem("__elv-token-".concat(network));
+              if (!savedToken) {
+                _context25.next = 33;
+                break;
+              }
+              _context25.next = 33;
+              return walletClient.Authenticate({
+                token: savedToken
+              });
+            case 33:
+              _context25.next = 37;
+              break;
+            case 35:
+              _context25.prev = 35;
+              _context25.t0 = _context25["catch"](28);
+            case 37:
+              if (skipMarketplaceLoad) {
+                _context25.next = 40;
+                break;
+              }
+              _context25.next = 40;
+              return walletClient.LoadAvailableMarketplaces();
+            case 40:
+              return _context25.abrupt("return", walletClient);
+            case 41:
+            case "end":
+              return _context25.stop();
+          }
+        }, _callee25, null, [[28, 35]]);
+      }));
+      function Initialize(_x25) {
+        return _Initialize.apply(this, arguments);
+      }
+      return Initialize;
+    }()
+  }]);
+  return ElvWalletClient;
+}();
+Object.assign(ElvWalletClient.prototype, require("./ClientMethods"));
+Object.assign(ElvWalletClient.prototype, require("./Profile"));
+Object.assign(ElvWalletClient.prototype, require("./Notifications"));
+exports.ElvWalletClient = ElvWalletClient;