@eluvio/elv-client-js 4.0.114 → 4.0.116

package/dist/src/ElvClient.js

@@ -0,0 +1,2063 @@
+var _toConsumableArray = require("@babel/runtime/helpers/toConsumableArray");
+var _typeof = require("@babel/runtime/helpers/typeof");
+var _defineProperty = require("@babel/runtime/helpers/defineProperty");
+var _regeneratorRuntime = require("@babel/runtime/regenerator");
+var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
+var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");
+var _createClass = require("@babel/runtime/helpers/createClass");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+if (typeof globalThis.Buffer === "undefined") {
+  globalThis.Buffer = require("buffer/").Buffer;
+}
+var URI = require("urijs");
+var Ethers = require("ethers");
+var AuthorizationClient = require("./AuthorizationClient");
+var ElvWallet = require("./ElvWallet");
+var EthClient = require("./EthClient");
+var UserProfileClient = require("./UserProfileClient");
+var HttpClient = require("./HttpClient");
+var RemoteSigner = require("./RemoteSigner");
+var Utils = require("./Utils");
+var Crypto = require("./Crypto");
+var _require = require("./LogMessage"),
+  LogMessage = _require.LogMessage;
+var Pako = require("pako");
+var _require2 = require("./Validation"),
+  ValidatePresence = _require2.ValidatePresence;
+var UrlJoin = require("url-join");
+var networks = {
+  "main": "https://main.net955305.contentfabric.io",
+  "demo": "https://demov3.net955210.contentfabric.io",
+  "demov3": "https://demov3.net955210.contentfabric.io",
+  "local": "http://127.0.0.1:8008/config?qspace=dev&self",
+  "test": "https://test.net955203.contentfabric.io"
+};
+if (Utils.Platform() === Utils.PLATFORM_NODE) {
+  // Define Response in node
+  // eslint-disable-next-line no-global-assign
+  globalThis.Response = require("node-fetch").Response;
+}
+
+/**
+ * See the Modules section on the sidebar for details about methods related to interacting with the Fabric.
+ *
+ * <br/>
+ *
+ * For information about the Eluvio Wallet Client, go <a href="wallet-client/index.html">here</a>.
+ */
+var ElvClient = /*#__PURE__*/function () {
+  "use strict";
+
+  /**
+   * Create a new ElvClient
+   *
+   * NOTE: It is highly recommended to use the <a href="#.FromConfigurationUrl">FromConfigurationUrl</a> or <a href="#.FromNetworkName">FromNetworkName</a> method
+   * automatically import the client settings from the fabric
+   *
+   * @constructor
+   *
+   * @namedParams
+   * @param {string} contentSpaceId - ID of the content space
+   * @param {string} networkId - ID of the blockchain network
+   * @param {string} networkName - Name of the blockchain network
+   * @param {number} fabricVersion - The version of the target content fabric
+   * @param {Array<string>} fabricURIs - A list of full URIs to content fabric nodes
+   * @param {Array<string>} ethereumURIs - A list of full URIs to ethereum nodes
+   * @param {Array<string>} authServiceURIs - A list of full URIs to auth service endpoints
+   * @param {Array<string>} fileServiceURIs - A list of full URIs to file service endpoints
+   * @param {Array<string>=} searchURIs - A list of full URIs to search service endpoints
+   * @param {number=} ethereumContractTimeout=10 - Number of seconds to wait for contract calls
+   * @param {string=} trustAuthorityId - (OAuth) The ID of the trust authority to use for OAuth authentication
+   * @param {string=} staticToken - Static token that will be used for all authorization in place of normal auth. Also known as an anonymous token containing the space
+   * @param {boolean=} noCache=false - If enabled, blockchain transactions will not be cached
+   * @param {boolean=} noAuth=false - If enabled, blockchain authorization will not be performed
+   * @param {boolean=} assumeV3=false - If enabled, V3 fabric will be assumed
+   * @param {string=} service=default - The mode that determines how HttpClient will be initialized.
+   * If 'default' is set, HttpClient uris will use fabricUris. If 'search' is used, searchUris will be used
+   *
+   * @return {ElvClient} - New ElvClient connected to the specified content fabric and blockchain
+   */
+  function ElvClient(_ref) {
+    var contentSpaceId = _ref.contentSpaceId,
+      networkId = _ref.networkId,
+      networkName = _ref.networkName,
+      fabricVersion = _ref.fabricVersion,
+      fabricURIs = _ref.fabricURIs,
+      ethereumURIs = _ref.ethereumURIs,
+      authServiceURIs = _ref.authServiceURIs,
+      fileServiceURIs = _ref.fileServiceURIs,
+      searchURIs = _ref.searchURIs,
+      _ref$ethereumContract = _ref.ethereumContractTimeout,
+      ethereumContractTimeout = _ref$ethereumContract === void 0 ? 10 : _ref$ethereumContract,
+      trustAuthorityId = _ref.trustAuthorityId,
+      staticToken = _ref.staticToken,
+      _ref$noCache = _ref.noCache,
+      noCache = _ref$noCache === void 0 ? false : _ref$noCache,
+      _ref$noAuth = _ref.noAuth,
+      noAuth = _ref$noAuth === void 0 ? false : _ref$noAuth,
+      _ref$assumeV = _ref.assumeV3,
+      assumeV3 = _ref$assumeV === void 0 ? false : _ref$assumeV,
+      _ref$service = _ref.service,
+      service = _ref$service === void 0 ? "default" : _ref$service;
+    _classCallCheck(this, ElvClient);
+    this.Configuration = ElvClient.Configuration;
+    this.utils = Utils;
+    this.contentSpaceId = contentSpaceId;
+    this.contentSpaceAddress = this.utils.HashToAddress(contentSpaceId);
+    this.contentSpaceLibraryId = this.utils.AddressToLibraryId(this.contentSpaceAddress);
+    this.contentSpaceObjectId = this.utils.AddressToObjectId(this.contentSpaceAddress);
+    this.networkId = networkId;
+    this.networkName = networkName;
+    this.fabricVersion = fabricVersion;
+    this.fabricURIs = fabricURIs;
+    this.authServiceURIs = authServiceURIs;
+    this.fileServiceURIs = fileServiceURIs || fabricURIs;
+    this.ethereumURIs = ethereumURIs;
+    this.searchURIs = searchURIs;
+    this.ethereumContractTimeout = ethereumContractTimeout;
+    this.trustAuthorityId = trustAuthorityId;
+    this.noCache = noCache;
+    this.noAuth = noAuth;
+    this.assumeV3 = assumeV3;
+    if (!["search", "default"].includes(service)) {
+      throw Error("Invalid service: ".concat(service));
+    }
+    this.service = service;
+    this.debug = false;
+    this.InitializeClients({
+      staticToken: staticToken
+    });
+  }
+
+  /**
+   * Retrieve content space info and preferred fabric and blockchain URLs from the fabric
+   *
+   * @methodGroup Constructor
+   * @namedParams
+   * @param {string} configUrl - Full URL to the config endpoint
+   * @param {Array<string>} kmsUrls - List of KMS urls to use for OAuth authentication
+   * @param {string=} region - Preferred region - the fabric will auto-detect the best region if not specified
+   * - Available regions: as-east, au-east, eu-east-north, eu-west-north, na-east-north, na-east-south, na-west-north, na-west-south, eu-east-south, eu-west-south
+   * @param {string=} clientIP - IP address to use in determining the region to use
+   * @return {Promise<Object>} - Object containing content space ID and fabric and ethereum URLs
+   */
+  return _createClass(ElvClient, [{
+    key: "Log",
+    value: function Log(message) {
+      var error = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      LogMessage(this, message, error);
+    }
+
+    /**
+     * Enable or disable verbose logging
+     *
+     * @methodGroup Miscellaneous
+     *
+     * @param {boolean} enable - Set logging
+     * @param {Object=} options - Additional options for customizing logging
+     * - log: custom log() function
+     * - error: custom error() function
+     * - (custom functions must accept same arguments as console.log/console.error)
+     */
+  }, {
+    key: "ToggleLogging",
+    value: function ToggleLogging(enable) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      // define func with closure to pass to forEach
+      var setDebug = function setDebug(reporter) {
+        if (reporter) {
+          reporter.debug = enable;
+          reporter.debugOptions = options;
+        }
+      };
+      [this, this.authClient, this.ethClient, this.HttpClient, this.AuthHttpClient, this.FileServiceHttpClient, this.SearchHttpClient, this.userProfileClient].forEach(setDebug);
+      if (enable) {
+        this.Log("Debug Logging Enabled:\n        Content Space: ".concat(this.contentSpaceId, "\n        Fabric URLs: [\n\t\t").concat(this.fabricURIs.join(", \n\t\t"), "\n\t]\n        Ethereum URLs: [\n\t\t").concat(this.ethereumURIs.join(", \n\t\t"), "\n\t]\n        Auth Service URLs: [\\n\\t\\t").concat(this.authServiceURIs.join(", \n\t\t"), "\\n\\t]\n        File Service URLs: [\\n\\t\\t").concat(this.fileServiceURIs.join(", \n\t\t"), "\\n\\t]\n        "));
+      }
+    }
+  }, {
+    key: "EnableMethodLogging",
+    value: function EnableMethodLogging() {
+      var MethodLogger = function MethodLogger(klass) {
+        Object.getOwnPropertyNames(Object.getPrototypeOf(klass)).filter(function (method) {
+          return typeof klass[method] === "function";
+        }).forEach(function (methodName) {
+          var originalMethod = klass[methodName].bind(klass);
+          if (originalMethod.constructor.name === "AsyncFunction") {
+            klass[methodName] = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+              var start,
+                _len,
+                args,
+                _key,
+                result,
+                _args = arguments;
+              return _regeneratorRuntime.wrap(function _callee$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    start = Date.now();
+                    for (_len = _args.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+                      args[_key] = _args[_key];
+                    }
+                    _context.next = 4;
+                    return originalMethod.apply(void 0, args);
+                  case 4:
+                    result = _context.sent;
+                    // eslint-disable-next-line no-console
+                    console.log(methodName, Date.now() - start, "ms", JSON.stringify(args));
+                    return _context.abrupt("return", result);
+                  case 7:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _callee);
+            }));
+          } else {
+            klass[methodName] = function () {
+              var start = Date.now();
+              for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+                args[_key2] = arguments[_key2];
+              }
+              var result = originalMethod.apply(void 0, args);
+              // eslint-disable-next-line no-console
+              console.log(methodName, Date.now() - start, "ms", JSON.stringify(args));
+              return result;
+            };
+          }
+        });
+      };
+      MethodLogger(this);
+    }
+  }, {
+    key: "InitializeClients",
+    value: function () {
+      var _InitializeClients = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        var _ref3,
+          staticToken,
+          uris,
+          wallet,
+          signer,
+          _args2 = arguments;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _ref3 = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : {}, staticToken = _ref3.staticToken;
+              // Cached info
+              this.contentTypes = {};
+              this.encryptionConks = {};
+              this.stateChannelAccess = {};
+              this.objectTenantIds = {};
+              this.objectLibraryIds = {};
+              this.objectImageUrls = {};
+              this.visibilityInfo = {};
+              this.inaccessibleLibraries = {};
+              uris = this.service === "search" ? this.searchURIs : this.fabricURIs;
+              this.HttpClient = new HttpClient({
+                uris: uris,
+                debug: this.debug
+              });
+              this.AuthHttpClient = new HttpClient({
+                uris: this.authServiceURIs,
+                debug: this.debug
+              });
+              this.FileServiceHttpClient = new HttpClient({
+                uris: this.fileServiceURIs,
+                debug: this.debug
+              });
+              this.SearchHttpClient = new HttpClient({
+                uris: this.searchURIs || [],
+                debug: this.debug
+              });
+              this.ethClient = new EthClient({
+                client: this,
+                uris: this.ethereumURIs,
+                networkId: this.networkId,
+                debug: this.debug,
+                timeout: this.ethereumContractTimeout
+              });
+              if (!this.signer) {
+                wallet = this.GenerateWallet();
+                signer = wallet.AddAccountFromMnemonic({
+                  mnemonic: wallet.GenerateMnemonic()
+                });
+                this.SetSigner({
+                  signer: signer,
+                  reset: false
+                });
+                this.SetStaticToken({
+                  token: staticToken
+                });
+              }
+              this.authClient = new AuthorizationClient({
+                client: this,
+                contentSpaceId: this.contentSpaceId,
+                signer: this.signer,
+                noCache: this.noCache,
+                noAuth: this.noAuth,
+                debug: this.debug
+              });
+              this.userProfileClient = new UserProfileClient({
+                client: this,
+                debug: this.debug
+              });
+
+              // Initialize crypto wasm
+              this.Crypto = Crypto;
+              this.Crypto.ElvCrypto();
+            case 20:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function InitializeClients() {
+        return _InitializeClients.apply(this, arguments);
+      }
+      return InitializeClients;
+    }()
+  }, {
+    key: "ConfigUrl",
+    value: function ConfigUrl() {
+      return this.configUrl;
+    }
+  }, {
+    key: "SetAuth",
+    value: function SetAuth(auth) {
+      this.noAuth = !auth;
+      this.authClient.noAuth = !auth;
+    }
+
+    /**
+     * Update fabric URLs to prefer the specified region.
+     *
+     * Note: Client must have been initialized with FromConfigurationUrl or FromNetworkName
+     *
+     * @methodGroup Nodes
+     * @namedParams
+     * @param {string} region - Preferred region - the fabric will auto-detect the best region if not specified
+     * - Available regions: as-east, au-east, eu-east-north, eu-west-north, na-east-north, na-east-south, na-west-north, na-west-south, eu-east-south, eu-west-south
+     *
+     * @return {Promise<Object>} - An object containing the updated fabric, ethereum, auth service, and search URLs in order of preference
+     */
+  }, {
+    key: "UseRegion",
+    value: (function () {
+      var _UseRegion = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref4) {
+        var region, _yield$ElvClient$Conf, fabricURIs, ethereumURIs, authServiceURIs, fileServiceURIs, searchURIs;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              region = _ref4.region;
+              if (this.configUrl) {
+                _context3.next = 3;
+                break;
+              }
+              throw Error("Unable to change region: Configuration URL not set");
+            case 3:
+              _context3.next = 5;
+              return ElvClient.Configuration({
+                configUrl: this.configUrl,
+                region: region
+              });
+            case 5:
+              _yield$ElvClient$Conf = _context3.sent;
+              fabricURIs = _yield$ElvClient$Conf.fabricURIs;
+              ethereumURIs = _yield$ElvClient$Conf.ethereumURIs;
+              authServiceURIs = _yield$ElvClient$Conf.authServiceURIs;
+              fileServiceURIs = _yield$ElvClient$Conf.fileServiceURIs;
+              searchURIs = _yield$ElvClient$Conf.searchURIs;
+              this.region = region;
+              this.SetNodes({
+                fabricURIs: fabricURIs,
+                ethereumURIs: ethereumURIs,
+                authServiceURIs: authServiceURIs,
+                fileServiceURIs: fileServiceURIs,
+                searchURIs: searchURIs
+              });
+              return _context3.abrupt("return", {
+                fabricURIs: fabricURIs,
+                ethereumURIs: ethereumURIs,
+                fileServiceURIs: fileServiceURIs,
+                authServiceURIs: authServiceURIs,
+                searchURIs: searchURIs
+              });
+            case 14:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function UseRegion(_x) {
+        return _UseRegion.apply(this, arguments);
+      }
+      return UseRegion;
+    }()
+    /**
+     * Reset fabric URLs to prefer the best region auto-detected by the fabric.
+     *
+     * Note: Client must have been initialized with FromConfigurationUrl or FromNetworkName
+     *
+     * @methodGroup Nodes
+     *
+     * @return {Promise<Object>} - An object containing the updated fabric and ethereum URLs in order of preference
+     */
+    )
+  }, {
+    key: "ResetRegion",
+    value: (function () {
+      var _ResetRegion = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              if (this.configUrl) {
+                _context4.next = 2;
+                break;
+              }
+              throw Error("Unable to change region: Configuration URL not set");
+            case 2:
+              _context4.next = 4;
+              return this.UseRegion({
+                region: ""
+              });
+            case 4:
+              return _context4.abrupt("return", _context4.sent);
+            case 5:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function ResetRegion() {
+        return _ResetRegion.apply(this, arguments);
+      }
+      return ResetRegion;
+    }()
+    /**
+     * Retrieve the node ID reported by the fabric for the specified region
+     *
+     * Note: Client must have been initialized with FromConfigurationUrl or FromNetworkName
+     *
+     * @methodGroup Nodes
+     *
+     * @namedParams
+     * @param {string} region - Region from which to retrieve the node ID
+     *
+     * @return {Promise<string>} - The node ID reported by the fabric
+     */
+    )
+  }, {
+    key: "NodeId",
+    value: (function () {
+      var _NodeId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(_ref5) {
+        var region, _yield$ElvClient$Conf2, nodeId;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              region = _ref5.region;
+              _context5.next = 3;
+              return ElvClient.Configuration({
+                configUrl: this.configUrl,
+                region: region
+              });
+            case 3:
+              _yield$ElvClient$Conf2 = _context5.sent;
+              nodeId = _yield$ElvClient$Conf2.nodeId;
+              return _context5.abrupt("return", nodeId);
+            case 6:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function NodeId(_x2) {
+        return _NodeId.apply(this, arguments);
+      }
+      return NodeId;
+    }()
+    /**
+     * Retrieve the fabric, ethereum, auth service, and search nodes currently used by the client, in preference order
+     *
+     * @methodGroup Nodes
+     *
+     * @return {Promise<Object>} - An object containing the lists of fabric, ethereum, auth service, and search urls in use by the client
+     */
+    )
+  }, {
+    key: "Nodes",
+    value: function Nodes() {
+      return {
+        fabricURIs: this.fabricURIs,
+        ethereumURIs: this.ethereumURIs,
+        authServiceURIs: this.authServiceURIs,
+        fileServiceURIs: this.fileServiceURIs,
+        searchURIs: this.searchURIs
+      };
+    }
+
+    /**
+     * Set the client to use the specified fabric, ethereum, auth service, and search nodes, in preference order
+     *
+     * @namedParams
+     * @param {Array<string>=} fabricURIs - A list of URLs for the fabric, in preference order
+     * @param {Array<string>=} ethereumURIs - A list of URLs for the blockchain, in preference order
+     * @param {Array<string>=} authServiceURIs - A list of URLs for the auth service, in preference order
+     * @param {Array<string>=} fileServiceURIs - A list of URLs for file service jobs, in preference order
+     * @param {Array<string>=} searchURIs - A list of URLs for the search nodes, in preference order
+     *
+     * @methodGroup Nodes
+     */
+  }, {
+    key: "SetNodes",
+    value: function SetNodes(_ref6) {
+      var fabricURIs = _ref6.fabricURIs,
+        ethereumURIs = _ref6.ethereumURIs,
+        authServiceURIs = _ref6.authServiceURIs,
+        fileServiceURIs = _ref6.fileServiceURIs,
+        searchURIs = _ref6.searchURIs;
+      if (fabricURIs) {
+        this.fabricURIs = fabricURIs;
+        this.HttpClient.uris = fabricURIs;
+        this.HttpClient.uriIndex = 0;
+      }
+      if (ethereumURIs) {
+        this.ethereumURIs = ethereumURIs;
+        this.ethClient.ethereumURIs = ethereumURIs;
+        this.ethClient.ethereumURIIndex = 0;
+      }
+      if (authServiceURIs) {
+        this.authServiceURIs = authServiceURIs;
+        this.AuthHttpClient.uris = authServiceURIs;
+        this.AuthHttpClient.uriIndex = 0;
+      }
+      if (fileServiceURIs) {
+        this.fileServiceURIs = fileServiceURIs;
+        this.FileServiceHttpClient.uris = fileServiceURIs;
+        this.FileServiceHttpClient.uriIndex = 0;
+      }
+      if (searchURIs) {
+        this.searchURIs = searchURIs;
+        this.SearchHttpClient.uris = searchURIs;
+        this.SearchHttpClient.uriIndex = 0;
+      }
+    }
+
+    /**
+     * Return a list of nodes in the content space, optionally filtered by node ID or endpoint.
+     *
+     * @methodGroup Nodes
+     * @namedParams
+     * @param {string=} matchEndpoint - Return node(s) matching the specified endpoint
+     * @param {string=} matchNodeId - Return node(s) matching the specified node ID
+     *
+     * @return {Promise<Array<Object>>} - A list of nodes in the space matching the parameters
+     */
+  }, {
+    key: "SpaceNodes",
+    value: (function () {
+      var _SpaceNodes = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+        var _this = this;
+        var _ref7,
+          matchEndpoint,
+          matchNodeId,
+          nodes,
+          _yield$this$utils$Res,
+          node,
+          _args6 = arguments;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              _ref7 = _args6.length > 0 && _args6[0] !== undefined ? _args6[0] : {}, matchEndpoint = _ref7.matchEndpoint, matchNodeId = _ref7.matchNodeId;
+              this.SetStaticToken();
+              if (!matchEndpoint) {
+                _context6.next = 12;
+                break;
+              }
+              _context6.next = 5;
+              return this.utils.ResponseToJson(this.HttpClient.Request({
+                path: UrlJoin("nodes"),
+                method: "GET",
+                headers: {
+                  Authorization: "Bearer ".concat(this.staticToken)
+                }
+              }));
+            case 5:
+              _yield$this$utils$Res = _context6.sent;
+              nodes = _yield$this$utils$Res.nodes;
+              if (!(!nodes || !Array.isArray(nodes) || nodes.length === 0)) {
+                _context6.next = 9;
+                break;
+              }
+              return _context6.abrupt("return", []);
+            case 9:
+              return _context6.abrupt("return", nodes.filter(function (node) {
+                var match = false;
+                if (node.services && node.services.fabric_api && node.services.fabric_api.urls) {
+                  var results = (node.services.fabric_api.urls || []).find(function (url) {
+                    return url.includes(matchEndpoint);
+                  });
+                  if (results) {
+                    match = true;
+                  }
+                }
+                if (matchNodeId && node.id === matchNodeId) {
+                  match = true;
+                }
+                _this.ClearStaticToken();
+                return match;
+              }));
+            case 12:
+              if (!matchNodeId) {
+                _context6.next = 19;
+                break;
+              }
+              this.SetStaticToken();
+              _context6.next = 16;
+              return this.utils.ResponseToJson(this.HttpClient.Request({
+                path: UrlJoin("nodes", matchNodeId),
+                method: "GET",
+                headers: {
+                  Authorization: "Bearer ".concat(this.staticToken)
+                }
+              }));
+            case 16:
+              node = _context6.sent;
+              this.ClearStaticToken();
+              return _context6.abrupt("return", [node]);
+            case 19:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function SpaceNodes() {
+        return _SpaceNodes.apply(this, arguments);
+      }
+      return SpaceNodes;
+    }()
+    /**
+     * Return information about how the client was connected to the network
+     *
+     * @methodGroup Nodes
+     * @returns {Object} - The name, ID and configuration URL of the network
+     */
+    )
+  }, {
+    key: "NetworkInfo",
+    value: function NetworkInfo() {
+      return {
+        name: this.networkName,
+        id: this.networkId,
+        configUrl: this.configUrl
+      };
+    }
+  }, {
+    key: "WriteTokenNodeUrl",
+    value: function WriteTokenNodeUrl(_ref8) {
+      var writeToken = _ref8.writeToken;
+      var nodeUrl = this.HttpClient.draftURIs[writeToken];
+      return nodeUrl ? nodeUrl.toString() : undefined;
+    }
+  }, {
+    key: "RecordWriteToken",
+    value: function RecordWriteToken(_ref9) {
+      var writeToken = _ref9.writeToken,
+        fabricNodeUrl = _ref9.fabricNodeUrl;
+      this.HttpClient.RecordWriteToken(writeToken, fabricNodeUrl);
+    }
+
+    /* Wallet and signers */
+
+    /**
+     * Generate a new ElvWallet that is connected to the client's provider
+     *
+     * @methodGroup Signers
+     * @returns {ElvWallet} - ElvWallet instance with this client's provider
+     */
+  }, {
+    key: "GenerateWallet",
+    value: function GenerateWallet() {
+      return new ElvWallet(this.ethClient.Provider());
+    }
+
+    /**
+     * Remove the signer from this client
+     *
+     * @methodGroup Signers
+     */
+  }, {
+    key: "ClearSigner",
+    value: function ClearSigner() {
+      this.signer = undefined;
+      this.InitializeClients();
+    }
+
+    /**
+     * Clear saved access and state channel tokens
+     *
+     * @methodGroup Access Requests
+     */
+  }, {
+    key: "ClearCache",
+    value: function ClearCache() {
+      this.authClient.ClearCache();
+    }
+
+    /**
+     * Set the signer for this client to use for blockchain transactions
+     *
+     * @methodGroup Signers
+     * @namedParams
+     * @param {object} signer - The ethers.js signer object
+     */
+  }, {
+    key: "SetSigner",
+    value: function SetSigner(_ref10) {
+      var signer = _ref10.signer,
+        _ref10$reset = _ref10.reset,
+        reset = _ref10$reset === void 0 ? true : _ref10$reset;
+      this.staticToken = undefined;
+      signer.connect(this.ethClient.Provider());
+      signer.provider.pollingInterval = 500;
+      this.signer = signer;
+      if (reset) {
+        this.InitializeClients();
+      }
+    }
+
+    /**
+     * Set signer using OAuth ID token
+     *
+     * @methodGroup Signers
+     * @namedParams
+     * @param {string=} idToken - OAuth ID token
+     * @param {string=} authToken - Eluvio authorization token previously issued from OAuth ID token
+     * @param {string=} tenantId - If specified, user will be associated with the tenant
+     * @param {Object=} extraData - Additional data to pass to the login API
+     * @param {Array<string>=} signerURIs - (Only if using custom OAuth) - URIs corresponding to the key server(s) to use
+     * @param {boolean=} unsignedPublicAuth=false - If specified, the client will use an unsigned static token for calls that don't require authorization (reduces remote signature calls)
+     */
+  }, {
+    key: "SetRemoteSigner",
+    value: (function () {
+      var _SetRemoteSigner = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(_ref11) {
+        var idToken, authToken, tenantId, extraData, signerURIs, unsignedPublicAuth, signer;
+        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              idToken = _ref11.idToken, authToken = _ref11.authToken, tenantId = _ref11.tenantId, extraData = _ref11.extraData, signerURIs = _ref11.signerURIs, unsignedPublicAuth = _ref11.unsignedPublicAuth;
+              _context7.t0 = RemoteSigner;
+              _context7.t1 = signerURIs || this.authServiceURIs;
+              _context7.t2 = idToken;
+              _context7.t3 = authToken;
+              _context7.t4 = tenantId;
+              _context7.next = 8;
+              return this.ethClient.Provider();
+            case 8:
+              _context7.t5 = _context7.sent;
+              _context7.t6 = extraData;
+              _context7.t7 = unsignedPublicAuth;
+              _context7.t8 = {
+                signerURIs: _context7.t1,
+                idToken: _context7.t2,
+                authToken: _context7.t3,
+                tenantId: _context7.t4,
+                provider: _context7.t5,
+                extraData: _context7.t6,
+                unsignedPublicAuth: _context7.t7
+              };
+              signer = new _context7.t0(_context7.t8);
+              _context7.next = 15;
+              return signer.Initialize();
+            case 15:
+              this.SetSigner({
+                signer: signer
+              });
+            case 16:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function SetRemoteSigner(_x3) {
+        return _SetRemoteSigner.apply(this, arguments);
+      }
+      return SetRemoteSigner;
+    }()
+    /**
+     * Set the signer for this client to use for blockchain transactions from an existing web3 provider.
+     * Useful for integrating with MetaMask
+     *
+     * @see https://github.com/ethers-io/ethers.js/issues/59#issuecomment-358224800
+     *
+     * @methodGroup Signers
+     * @namedParams
+     * @param {object} provider - The web3 provider object
+     */
+    )
+  }, {
+    key: "SetSignerFromWeb3Provider",
+    value: (function () {
+      var _SetSignerFromWeb3Provider = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(_ref12) {
+        var provider, ethProvider;
+        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              provider = _ref12.provider;
+              this.staticToken = undefined;
+              ethProvider = new Ethers.providers.Web3Provider(provider);
+              ethProvider.pollingInterval = 250;
+              this.signer = ethProvider.getSigner();
+              _context8.next = 7;
+              return this.signer.getAddress();
+            case 7:
+              this.signer.address = _context8.sent;
+              _context8.next = 10;
+              return this.InitializeClients();
+            case 10:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function SetSignerFromWeb3Provider(_x4) {
+        return _SetSignerFromWeb3Provider.apply(this, arguments);
+      }
+      return SetSignerFromWeb3Provider;
+    }()
+    /**
+     * Initialize a new account using the provided funding and group tokens.
+     *
+     * This method will redeem the tokens for the current account (or create a new one if not set) in order to
+     * retrieve funds and optionally have the user added to appropriate access groups.
+     *
+     * @methodGroup Signers
+     * @namedParams
+     * @param {string} tenantId - The ID of the tenant
+     * @param {string} fundingToken - A token permitting the user to retrieve funds
+     * @param {number=} funds=0.5 - The amount to fund this user. The maximum amount is limited by the token issuer.
+     * @param {string=} groupToken - A token permitting the user to be added to access groups
+     *
+     * @return {string} - The address of the user
+     */
+    )
+  }, {
+    key: "CreateAccount",
+    value: (function () {
+      var _CreateAccount = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9(_ref13) {
+        var tenantId, fundingToken, _ref13$funds, funds, groupToken, wallet, signer;
+        return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              tenantId = _ref13.tenantId, fundingToken = _ref13.fundingToken, _ref13$funds = _ref13.funds, funds = _ref13$funds === void 0 ? 0.5 : _ref13$funds, groupToken = _ref13.groupToken;
+              if (!this.signer) {
+                wallet = this.GenerateWallet();
+                signer = wallet.AddAccountFromMnemonic({
+                  mnemonic: wallet.GenerateMnemonic()
+                });
+                this.SetSigner({
+                  signer: signer
+                });
+              }
+              _context9.next = 4;
+              return this.authClient.MakeKMSRequest({
+                method: "POST",
+                path: "/ks/otp/fnd/".concat(tenantId),
+                body: {
+                  toAddr: this.signer.address,
+                  amtStr: this.utils.EtherToWei(funds)
+                },
+                headers: {
+                  Authorization: "Bearer ".concat(fundingToken)
+                }
+              });
+            case 4:
+              _context9.next = 6;
+              return this.userProfileClient.CreateWallet();
+            case 6:
+              _context9.next = 8;
+              return this.userProfileClient.ReplaceUserMetadata({
+                metadataSubtree: "tenantContractId",
+                metadata: tenantId
+              });
+            case 8:
+              if (!groupToken) {
+                _context9.next = 11;
+                break;
+              }
+              _context9.next = 11;
+              return this.authClient.MakeKMSRequest({
+                method: "POST",
+                path: "/ks/otp/grp/".concat(tenantId),
+                body: {
+                  addAddr: this.signer.address
+                },
+                headers: {
+                  Authorization: "Bearer ".concat(groupToken)
+                }
+              });
+            case 11:
+              return _context9.abrupt("return", this.utils.FormatAddress(this.signer.address));
+            case 12:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this);
+      }));
+      function CreateAccount(_x5) {
+        return _CreateAccount.apply(this, arguments);
+      }
+      return CreateAccount;
+    }()
+    /*
+      TOKEN                  211b  PREFIX + BODY | aplsjcJf1HYcDDUuCdXcSZtU86nYK162YmYJeuqwMczEBJVkD5D5EvsBvVwYDRsf4hzDvBWMoe9piBpqx...
+      PREFIX                   6b  aplsjc | apl=plain s=ES256K jc=json-compressed
+      BODY                   205b  base58(SIGNATURE + PAYLOAD)
+      SIGNATURE + PAYLOAD    151b  151b * 138 / 100 + 1 = 209b (>= 205b)
+      SIGNATURE               66b  ES256K_Di9Lu83mz4wMoehCEeQhKpJJ7ApmDZLumAa2Cge48F6EHYnbn8msATGGpjucScwimei1TWGd7aeyQY45AdXd5tT1Z
+      PAYLOAD                 85b  json-compressed
+      json                    79b  {"adr":"VVf4DQU357tDnZGYQeDrntRJ5rs=","spc":"ispc3ANoVSzNA3P6t7abLR69ho5YPPZU"}
+     */
+    )
+  }, {
+    key: "PersonalSign",
+    value: (function () {
+      var _PersonalSign = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11(_ref14) {
+        var _this2 = this;
+        var message, addEthereumPrefix, Sign;
+        return _regeneratorRuntime.wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              message = _ref14.message, addEthereumPrefix = _ref14.addEthereumPrefix, Sign = _ref14.Sign;
+              if (!Sign) {
+                // Same as authClient.Sign, but authClient may not yet be initialized
+                Sign = /*#__PURE__*/function () {
+                  var _ref15 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10(message) {
+                    return _regeneratorRuntime.wrap(function _callee10$(_context10) {
+                      while (1) switch (_context10.prev = _context10.next) {
+                        case 0:
+                          _context10.t0 = Ethers.utils;
+                          if (!_this2.signer.signDigest) {
+                            _context10.next = 7;
+                            break;
+                          }
+                          _context10.next = 4;
+                          return _this2.signer.signDigest(message);
+                        case 4:
+                          _context10.t1 = _context10.sent;
+                          _context10.next = 10;
+                          break;
+                        case 7:
+                          _context10.next = 9;
+                          return _this2.signer._signingKey().signDigest(message);
+                        case 9:
+                          _context10.t1 = _context10.sent;
+                        case 10:
+                          _context10.t2 = _context10.t1;
+                          return _context10.abrupt("return", _context10.t0.joinSignature.call(_context10.t0, _context10.t2));
+                        case 12:
+                        case "end":
+                          return _context10.stop();
+                      }
+                    }, _callee10);
+                  }));
+                  return function Sign(_x7) {
+                    return _ref15.apply(this, arguments);
+                  };
+                }();
+              }
+              if (addEthereumPrefix) {
+                message = Ethers.utils.keccak256(Buffer.from("\x19Ethereum Signed Message:\n".concat(message.length).concat(message), "utf-8"));
+              }
+              _context11.next = 5;
+              return Sign(message);
+            case 5:
+              return _context11.abrupt("return", _context11.sent);
+            case 6:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11);
+      }));
+      function PersonalSign(_x6) {
+        return _PersonalSign.apply(this, arguments);
+      }
+      return PersonalSign;
+    }()
+    /**
+     * Create a signed authorization token that can be used to authorize against the fabric
+     *
+     * @methodGroup Authorization
+     * @namedParams
+     * @param {number} duration=86400000 - Time until the token expires, in milliseconds (1 hour = 60 * 60 * 1000 = 3600000). Default is 24 hours.
+     * @param {Object=} spec - Additional attributes for this token
+     * @param {string=} address - Address of the signing account - if not specified, the current signer address will be used.
+     * @param {function=} Sign - If specified, this function will be used to produce the signature instead of the client's current signer
+     * @param {boolean=} addEthereumPrefix=true - If specified, the 'Ethereum Signed Message' prefixed hash format will be performed. Disable this if the provided Sign method already does this (e.g. Metamask)
+     */
+    )
+  }, {
+    key: "CreateFabricToken",
+    value: (function () {
+      var _CreateFabricToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12() {
+        var _ref16,
+          _ref16$duration,
+          duration,
+          _ref16$spec,
+          spec,
+          address,
+          Sign,
+          _ref16$addEthereumPre,
+          addEthereumPrefix,
+          _ref16$context,
+          context,
+          token,
+          message,
+          signature,
+          compressedToken,
+          _args12 = arguments;
+        return _regeneratorRuntime.wrap(function _callee12$(_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+              _ref16 = _args12.length > 0 && _args12[0] !== undefined ? _args12[0] : {}, _ref16$duration = _ref16.duration, duration = _ref16$duration === void 0 ? 24 * 60 * 60 * 1000 : _ref16$duration, _ref16$spec = _ref16.spec, spec = _ref16$spec === void 0 ? {} : _ref16$spec, address = _ref16.address, Sign = _ref16.Sign, _ref16$addEthereumPre = _ref16.addEthereumPrefix, addEthereumPrefix = _ref16$addEthereumPre === void 0 ? true : _ref16$addEthereumPre, _ref16$context = _ref16.context, context = _ref16$context === void 0 ? {} : _ref16$context;
+              address = address || this.CurrentAccountAddress();
+              _context12.t0 = _objectSpread;
+              _context12.t1 = _objectSpread({}, spec);
+              _context12.t2 = {};
+              _context12.t3 = "iusr".concat(Utils.AddressToHash(address));
+              _context12.t4 = Buffer.from(address.replace(/^0x/, ""), "hex").toString("base64");
+              _context12.next = 9;
+              return this.ContentSpaceId();
+            case 9:
+              _context12.t5 = _context12.sent;
+              _context12.t6 = Date.now();
+              _context12.t7 = Date.now() + duration;
+              _context12.t8 = context;
+              _context12.t9 = {
+                sub: _context12.t3,
+                adr: _context12.t4,
+                spc: _context12.t5,
+                iat: _context12.t6,
+                exp: _context12.t7,
+                ctx: _context12.t8
+              };
+              token = (0, _context12.t0)(_context12.t1, _context12.t2, _context12.t9);
+              message = "Eluvio Content Fabric Access Token 1.0\n".concat(JSON.stringify(token));
+              _context12.next = 18;
+              return this.PersonalSign({
+                message: message,
+                addEthereumPrefix: addEthereumPrefix,
+                Sign: Sign
+              });
+            case 18:
+              signature = _context12.sent;
+              compressedToken = Pako.deflateRaw(Buffer.from(JSON.stringify(token), "utf-8"));
+              return _context12.abrupt("return", "acspjc".concat(this.utils.B58(Buffer.concat([Buffer.from(signature.replace(/^0x/, ""), "hex"), Buffer.from(compressedToken)]))));
+            case 21:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee12, this);
+      }));
+      function CreateFabricToken() {
+        return _CreateFabricToken.apply(this, arguments);
+      }
+      return CreateFabricToken;
+    }()
+    /**
+     * Issue a self-signed authorization token
+     *
+     * @methodGroup Authorization
+     * @namedParams
+     * @param {string=} libraryId - Library ID to authorize
+     * @param {string=} objectId - Object ID to authorize
+     * @param {string=} versionHash - Version hash to authorize
+     * @param {string=} policyId - The object ID of the policy for this token
+     * @param {string=} subject - The subject of the token
+     * @param {string} grantType=read - Permissions to grant for this token. Options: "access", "read", "create", "update", "read-crypt"
+     * @param {number} duration - Time until the token expires, in milliseconds (1 hour = 60 * 60 * 1000 = 3600000)
+     * @param {boolean} allowDecryption=false - If specified, the re-encryption key will be included in the token,
+     * enabling the user of this token to download encrypted content from the specified object
+     * @param {Object=} context - Additional JSON context
+     */
+    )
+  }, {
+    key: "CreateSignedToken",
+    value: (function () {
+      var _CreateSignedToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee13(_ref17) {
+        var libraryId, objectId, versionHash, policyId, subject, _ref17$grantType, grantType, _ref17$allowDecryptio, allowDecryption, duration, _ref17$context, context, token, cap, compressedToken, signature;
+        return _regeneratorRuntime.wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              libraryId = _ref17.libraryId, objectId = _ref17.objectId, versionHash = _ref17.versionHash, policyId = _ref17.policyId, subject = _ref17.subject, _ref17$grantType = _ref17.grantType, grantType = _ref17$grantType === void 0 ? "read" : _ref17$grantType, _ref17$allowDecryptio = _ref17.allowDecryption, allowDecryption = _ref17$allowDecryptio === void 0 ? false : _ref17$allowDecryptio, duration = _ref17.duration, _ref17$context = _ref17.context, context = _ref17$context === void 0 ? {} : _ref17$context;
+              if (subject) {
+                _context13.next = 9;
+                break;
+              }
+              _context13.t0 = "iusr";
+              _context13.t1 = this.utils;
+              _context13.next = 6;
+              return this.CurrentAccountAddress();
+            case 6:
+              _context13.t2 = _context13.sent;
+              _context13.t3 = _context13.t1.AddressToHash.call(_context13.t1, _context13.t2);
+              subject = _context13.t0.concat.call(_context13.t0, _context13.t3);
+            case 9:
+              if (policyId) {
+                context["elv:delegation-id"] = policyId;
+              }
+              _context13.t4 = Buffer;
+              _context13.next = 13;
+              return this.CurrentAccountAddress().replace(/^0x/, "");
+            case 13:
+              _context13.t5 = _context13.sent;
+              _context13.t6 = _context13.t4.from.call(_context13.t4, _context13.t5, "hex").toString("base64");
+              _context13.t7 = subject;
+              _context13.next = 18;
+              return this.ContentSpaceId();
+            case 18:
+              _context13.t8 = _context13.sent;
+              _context13.t9 = Date.now();
+              _context13.t10 = Date.now() + duration;
+              _context13.t11 = grantType;
+              _context13.t12 = context;
+              token = {
+                adr: _context13.t6,
+                sub: _context13.t7,
+                spc: _context13.t8,
+                iat: _context13.t9,
+                exp: _context13.t10,
+                gra: _context13.t11,
+                ctx: _context13.t12
+              };
+              if (versionHash) {
+                objectId = this.utils.DecodeVersionHash(versionHash).objectId;
+              }
+              if (!objectId) {
+                _context13.next = 31;
+                break;
+              }
+              token.qid = objectId;
+              if (libraryId) {
+                _context13.next = 31;
+                break;
+              }
+              _context13.next = 30;
+              return this.ContentObjectLibraryId({
+                objectId: objectId
+              });
+            case 30:
+              libraryId = _context13.sent;
+            case 31:
+              if (libraryId) {
+                token.lib = libraryId;
+              }
+              if (!allowDecryption) {
+                _context13.next = 37;
+                break;
+              }
+              _context13.next = 35;
+              return this.authClient.ReEncryptionConk({
+                libraryId: libraryId,
+                objectId: objectId
+              });
+            case 35:
+              cap = _context13.sent;
+              token.apk = cap.public_key;
+            case 37:
+              compressedToken = Pako.deflateRaw(Buffer.from(JSON.stringify(token), "utf-8"));
+              _context13.next = 40;
+              return this.authClient.Sign(Ethers.utils.keccak256(compressedToken));
+            case 40:
+              signature = _context13.sent;
+              return _context13.abrupt("return", "aessjc".concat(this.utils.B58(Buffer.concat([Buffer.from(signature.replace(/^0x/, ""), "hex"), Buffer.from(compressedToken)]))));
+            case 42:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this);
+      }));
+      function CreateSignedToken(_x8) {
+        return _CreateSignedToken.apply(this, arguments);
+      }
+      return CreateSignedToken;
+    }()
+    /**
+     * Build a signed message (JSON) using the current signer.
+     * Signed messages have a similar format to signed access tokens and they include the message itself
+     * such that they can be both verified and decoded by the receiving entity.
+     *
+     * Messages can be encoded and signed using different methods, and the encoding and signature types
+     * are described in the header of the resulting signed message blob.
+     *
+     * Note this type of message can not be verified and decoded on chain.
+     *
+     * @methodGroup Authorization
+     * @namedParams
+     * @param {string} messasge - A JSON object representing the message to sign
+     */
+    )
+  }, {
+    key: "CreateSignedMessageJSON",
+    value: (function () {
+      var _CreateSignedMessageJSON = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee14(_ref18) {
+        var message, type, msg, signature;
+        return _regeneratorRuntime.wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              message = _ref18.message;
+              // Only one kind of signature supported currently
+              type = "mje_"; // JSON message, EIP192 signature
+              msg = JSON.stringify(message);
+              _context14.next = 5;
+              return this.PersonalSign({
+                message: msg,
+                addEthereumPrefix: true
+              });
+            case 5:
+              signature = _context14.sent;
+              return _context14.abrupt("return", "".concat(type).concat(Utils.B58(Buffer.concat([Buffer.from(signature.replace(/^0x/, ""), "hex"), Buffer.from(msg)]))));
+            case 7:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14, this);
+      }));
+      function CreateSignedMessageJSON(_x9) {
+        return _CreateSignedMessageJSON.apply(this, arguments);
+      }
+      return CreateSignedMessageJSON;
+    }()
+    /**
+     * Verify and decode a signed message (JSON).
+     *
+     * @methodGroup Authorization
+     * @namedParams
+     * @param {string} signedMessage - a signed message as created by CreateSignedMessageJSON
+     * @returns {Promise<Object>} - The decoded message, signer address, signature and signature type
+     */
+    )
+  }, {
+    key: "DecodeSignedMessageJSON",
+    value: (function () {
+      var _DecodeSignedMessageJSON = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee15(_ref19) {
+        var signedMessage, type, msgBytes, signature, msg, obj, prefixedMsgHash, signerAddr;
+        return _regeneratorRuntime.wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              signedMessage = _ref19.signedMessage;
+              type = signedMessage.slice(0, 4);
+              _context15.t0 = type;
+              _context15.next = _context15.t0 === "mje_" ? 5 : 12;
+              break;
+            case 5:
+              msgBytes = Utils.FromB58(signedMessage.slice(4));
+              signature = msgBytes.slice(0, 65);
+              msg = msgBytes.slice(65);
+              obj = JSON.parse(msg);
+              prefixedMsgHash = Ethers.utils.keccak256(Buffer.from("\x19Ethereum Signed Message:\n".concat(msg.length).concat(msg), "utf-8"));
+              signerAddr = Ethers.utils.recoverAddress(prefixedMsgHash, signature);
+              return _context15.abrupt("return", {
+                type: type,
+                message: obj,
+                signerAddress: signerAddr,
+                signature: "0x" + signature.toString("hex")
+              });
+            case 12:
+              throw new Error("Bad message type: ".concat(type));
+            case 13:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15);
+      }));
+      function DecodeSignedMessageJSON(_x10) {
+        return _DecodeSignedMessageJSON.apply(this, arguments);
+      }
+      return DecodeSignedMessageJSON;
+    }()
+    /**
+     * Get the account address of the current signer
+     *
+     * @methodGroup Signers
+     * @returns {string} - The address of the current signer
+     */
+    )
+  }, {
+    key: "CurrentAccountAddress",
+    value: function CurrentAccountAddress() {
+      return this.signer ? this.utils.FormatAddress(this.signer.address) : "";
+    }
+
+    /**
+     * Set the OAuth token for use in state channel calls
+     *
+     * @methodGroup Authorization
+     * @namedParams
+     * @param {string} token - The OAuth ID token
+     */
+  }, {
+    key: "SetOauthToken",
+    value: (function () {
+      var _SetOauthToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee16(_ref20) {
+        var token, wallet, signer;
+        return _regeneratorRuntime.wrap(function _callee16$(_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              token = _ref20.token;
+              this.oauthToken = token;
+              wallet = this.GenerateWallet();
+              signer = wallet.AddAccountFromMnemonic({
+                mnemonic: wallet.GenerateMnemonic()
+              });
+              this.SetSigner({
+                signer: signer
+              });
+            case 5:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16, this);
+      }));
+      function SetOauthToken(_x11) {
+        return _SetOauthToken.apply(this, arguments);
+      }
+      return SetOauthToken;
+    }()
+    /**
+     * Set the signer for this client via OAuth token. The client will exchange the given token
+     * for the user's private key using the KMS specified in the configuration.
+     *
+     * NOTE: The KMS URL(s) must be set in the initial configuration of the client (FromConfigurationUrl or FromNetworkName)
+     *
+     * @methodGroup Authorization
+     * @namedParams
+     * @param {string} token - The OAuth ID
+     */
+    )
+  }, {
+    key: "SetSignerFromOauthToken",
+    value: (function () {
+      var _SetSignerFromOauthToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee17(_ref21) {
+        var token, wallet, client, _yield$client$authCli, urls, path, httpClient, response, privateKey;
+        return _regeneratorRuntime.wrap(function _callee17$(_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+              token = _ref21.token;
+              if (this.trustAuthorityId) {
+                _context17.next = 3;
+                break;
+              }
+              throw Error("Unable to authorize with OAuth token: No trust authority ID set");
+            case 3:
+              wallet = this.GenerateWallet();
+              _context17.prev = 4;
+              if (this.kmsURIs) {
+                _context17.next = 17;
+                break;
+              }
+              _context17.next = 8;
+              return ElvClient.FromConfigurationUrl({
+                configUrl: this.configUrl
+              });
+            case 8:
+              client = _context17.sent;
+              client.SetSigner({
+                signer: wallet.AddAccountFromMnemonic({
+                  mnemonic: wallet.GenerateMnemonic()
+                })
+              });
+              _context17.next = 12;
+              return client.authClient.KMSInfo({
+                kmsId: this.trustAuthorityId
+              });
+            case 12:
+              _yield$client$authCli = _context17.sent;
+              urls = _yield$client$authCli.urls;
+              if (!(!urls || urls.length === 0)) {
+                _context17.next = 16;
+                break;
+              }
+              throw Error("Unable to authorize with OAuth token: No KMS URLs set");
+            case 16:
+              this.kmsURIs = urls;
+            case 17:
+              this.oauthToken = token;
+              path = "/ks/jwt/wlt";
+              httpClient = new HttpClient({
+                uris: this.kmsURIs,
+                debug: this.debug
+              });
+              _context17.next = 22;
+              return this.utils.ResponseToJson(httpClient.Request({
+                headers: {
+                  Authorization: "Bearer ".concat(token)
+                },
+                method: "PUT",
+                path: path,
+                forceFailover: true
+              }));
+            case 22:
+              response = _context17.sent;
+              privateKey = response["UserSKHex"];
+              this.SetSigner({
+                signer: wallet.AddAccount({
+                  privateKey: privateKey
+                })
+              });
+
+              // Ensure wallet is initialized
+              _context17.next = 27;
+              return this.userProfileClient.WalletAddress();
+            case 27:
+              _context17.next = 36;
+              break;
+            case 29:
+              _context17.prev = 29;
+              _context17.t0 = _context17["catch"](4);
+              this.Log("Failed to set signer from OAuth token:", true);
+              this.Log(_context17.t0, true);
+              _context17.next = 35;
+              return this.ClearSigner();
+            case 35:
+              throw _context17.t0;
+            case 36:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee17, this, [[4, 29]]);
+      }));
+      function SetSignerFromOauthToken(_x12) {
+        return _SetSignerFromOauthToken.apply(this, arguments);
+      }
+      return SetSignerFromOauthToken;
+    }()
+    /**
+     * Create a static authorization token
+     *
+     * @methodGroup Authorization
+     * @namedParams
+     * @param {string=} libraryId - The library ID to associate with the static token
+     *
+     * @return {string} - The created static token
+     */
+    )
+  }, {
+    key: "CreateStaticToken",
+    value: function CreateStaticToken(_ref22) {
+      var libraryId = _ref22.libraryId;
+      var token = {
+        qspace_id: this.client.contentSpaceId
+      };
+      if (libraryId) {
+        token.qlib_id = libraryId;
+      }
+      return Utils.B64(JSON.stringify(token));
+    }
+
+    /**
+     * Set a static token for the client to use for all authorization
+     *
+     * @methodGroup Authorization
+     * @namedParams
+     * @param {string=} token - The static token to use. If not provided, the default static token will be set.
+     */
+  }, {
+    key: "SetStaticToken",
+    value: function SetStaticToken() {
+      var _ref23 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        token = _ref23.token;
+      if (token) {
+        this.staticToken = token;
+      } else {
+        this.staticToken = this.utils.B64(JSON.stringify({
+          qspace_id: this.contentSpaceId
+        }));
+      }
+    }
+
+    /**
+     * Clear the set static token for the client
+     */
+  }, {
+    key: "ClearStaticToken",
+    value: function ClearStaticToken() {
+      this.staticToken = undefined;
+    }
+
+    /**
+     * Authorize the client against the specified policy.
+     *
+     * NOTE: After authorizing, the client will only be able to access content allowed by the policy
+     *
+     * @methodGroup Authorization
+     * @namedParams
+     * @param {string} objectId - The ID of the policy object
+     */
+  }, {
+    key: "SetPolicyAuthorization",
+    value: (function () {
+      var _SetPolicyAuthorization = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee18(_ref24) {
+        var objectId;
+        return _regeneratorRuntime.wrap(function _callee18$(_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+              objectId = _ref24.objectId;
+              _context18.t0 = this;
+              _context18.next = 4;
+              return this.GenerateStateChannelToken({
+                objectId: objectId
+              });
+            case 4:
+              _context18.t1 = _context18.sent;
+              _context18.t2 = {
+                token: _context18.t1
+              };
+              _context18.t0.SetStaticToken.call(_context18.t0, _context18.t2);
+            case 7:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee18, this);
+      }));
+      function SetPolicyAuthorization(_x13) {
+        return _SetPolicyAuthorization.apply(this, arguments);
+      }
+      return SetPolicyAuthorization;
+    }()
+    /**
+     * Create a signature for the specified string
+     *
+     * @param {string} string - The string to sign
+     * @return {Promise<string>} - The signed string
+     */
+    )
+  }, {
+    key: "Sign",
+    value: (function () {
+      var _Sign = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee19(string) {
+        var signature;
+        return _regeneratorRuntime.wrap(function _callee19$(_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              _context19.next = 2;
+              return this.authClient.Sign(Ethers.utils.keccak256(Ethers.utils.toUtf8Bytes(string)));
+            case 2:
+              signature = _context19.sent;
+              return _context19.abrupt("return", this.utils.FormatSignature(signature));
+            case 4:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee19, this);
+      }));
+      function Sign(_x14) {
+        return _Sign.apply(this, arguments);
+      }
+      return Sign;
+    }()
+    /**
+     * Encrypt the given string or object with the current signer's public key
+     *
+     * @namedParams
+     * @param {string | Object} message - The string or object to encrypt
+     * @param {string=} publicKey - If specified, message will be encrypted with this public key instead of the current user's
+     *
+     * @return {Promise<string>} - The encrypted message
+     */
+    )
+  }, {
+    key: "EncryptECIES",
+    value: (function () {
+      var _EncryptECIES = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee20(_ref25) {
+        var message, publicKey;
+        return _regeneratorRuntime.wrap(function _callee20$(_context20) {
+          while (1) switch (_context20.prev = _context20.next) {
+            case 0:
+              message = _ref25.message, publicKey = _ref25.publicKey;
+              if (this.signer) {
+                _context20.next = 3;
+                break;
+              }
+              throw "Signer not set";
+            case 3:
+              ValidatePresence("message", message);
+              _context20.next = 6;
+              return this.Crypto.EncryptConk(message, publicKey || this.signer._signingKey().publicKey);
+            case 6:
+              return _context20.abrupt("return", _context20.sent);
+            case 7:
+            case "end":
+              return _context20.stop();
+          }
+        }, _callee20, this);
+      }));
+      function EncryptECIES(_x15) {
+        return _EncryptECIES.apply(this, arguments);
+      }
+      return EncryptECIES;
+    }()
+    /**
+     * Decrypt the given encrypted message with the current signer's private key
+     *
+     * @namedParams
+     * @param {string} message - The message to decrypt
+     *
+     * @return {Promise<string | Object>} - The decrypted string or object
+     */
+    )
+  }, {
+    key: "DecryptECIES",
+    value: (function () {
+      var _DecryptECIES = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee21(_ref26) {
+        var message;
+        return _regeneratorRuntime.wrap(function _callee21$(_context21) {
+          while (1) switch (_context21.prev = _context21.next) {
+            case 0:
+              message = _ref26.message;
+              if (this.signer) {
+                _context21.next = 3;
+                break;
+              }
+              throw "Signer not set";
+            case 3:
+              ValidatePresence("message", message);
+              _context21.next = 6;
+              return this.Crypto.DecryptCap(message, this.signer._signingKey().privateKey);
+            case 6:
+              return _context21.abrupt("return", _context21.sent);
+            case 7:
+            case "end":
+              return _context21.stop();
+          }
+        }, _callee21, this);
+      }));
+      function DecryptECIES(_x16) {
+        return _DecryptECIES.apply(this, arguments);
+      }
+      return DecryptECIES;
+    }()
+    /**
+     * Request the specified URL with the given method and body, and return the result in the specified format
+     *
+     * @param {string} url - URL to request
+     * @param {string=} format="json" - Format of response
+     * @param {string=} method="GET" - Request method
+     * @param {object=} body - Request body
+     * @param {object=} headers - Request headers
+     *
+     * @return {Promise<*>} - Response in the specified format
+     */
+    )
+  }, {
+    key: "Request",
+    value: (function () {
+      var _Request = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee22(_ref27) {
+        var url, _ref27$format, format, _ref27$method, method, _ref27$headers, headers, body;
+        return _regeneratorRuntime.wrap(function _callee22$(_context22) {
+          while (1) switch (_context22.prev = _context22.next) {
+            case 0:
+              url = _ref27.url, _ref27$format = _ref27.format, format = _ref27$format === void 0 ? "json" : _ref27$format, _ref27$method = _ref27.method, method = _ref27$method === void 0 ? "GET" : _ref27$method, _ref27$headers = _ref27.headers, headers = _ref27$headers === void 0 ? {} : _ref27$headers, body = _ref27.body;
+              return _context22.abrupt("return", this.utils.ResponseToFormat(format, HttpClient.Fetch(url, {
+                method: method,
+                headers: headers,
+                body: body
+              })));
+            case 2:
+            case "end":
+              return _context22.stop();
+          }
+        }, _callee22, this);
+      }));
+      function Request(_x17) {
+        return _Request.apply(this, arguments);
+      }
+      return Request;
+    }())
+  }, {
+    key: "MakeAuthServiceRequest",
+    value: function () {
+      var _MakeAuthServiceRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee23(_ref28) {
+        var kmsId, objectId, versionHash, _ref28$method, method, path, bodyType, _ref28$body, body, _ref28$queryParams, queryParams, headers;
+        return _regeneratorRuntime.wrap(function _callee23$(_context23) {
+          while (1) switch (_context23.prev = _context23.next) {
+            case 0:
+              kmsId = _ref28.kmsId, objectId = _ref28.objectId, versionHash = _ref28.versionHash, _ref28$method = _ref28.method, method = _ref28$method === void 0 ? "GET" : _ref28$method, path = _ref28.path, bodyType = _ref28.bodyType, _ref28$body = _ref28.body, body = _ref28$body === void 0 ? {} : _ref28$body, _ref28$queryParams = _ref28.queryParams, queryParams = _ref28$queryParams === void 0 ? {} : _ref28$queryParams, headers = _ref28.headers;
+              return _context23.abrupt("return", this.authClient.MakeAuthServiceRequest({
+                kmsId: kmsId,
+                objectId: objectId,
+                versionHash: versionHash,
+                method: method,
+                path: path,
+                bodyType: bodyType,
+                body: body,
+                queryParams: queryParams,
+                headers: headers
+              }));
+            case 2:
+            case "end":
+              return _context23.stop();
+          }
+        }, _callee23, this);
+      }));
+      function MakeAuthServiceRequest(_x18) {
+        return _MakeAuthServiceRequest.apply(this, arguments);
+      }
+      return MakeAuthServiceRequest;
+    }()
+    /* FrameClient related */
+    // Whitelist of methods allowed to be called using the frame API
+  }, {
+    key: "FrameAllowedMethods",
+    value: function FrameAllowedMethods() {
+      var _this3 = this;
+      var forbiddenMethods = ["constructor", "AccessGroupMembershipMethod", "CallFromFrameMessage", "ClearSigner", "CreateAccount", "EnableMethodLogging", "FormatBlockNumbers", "FrameAllowedMethods", "FromConfigurationUrl", "GenerateWallet", "InitializeClients", "Log", "PersonalSign", "SetRemoteSigner", "SetSigner", "SetSignerFromWeb3Provider", "Sign", "ToggleLogging"];
+      return Object.getOwnPropertyNames(Object.getPrototypeOf(this)).filter(function (method) {
+        return typeof _this3[method] === "function" && !forbiddenMethods.includes(method);
+      });
+    }
+
+    // Call a method specified in a message from a frame
+  }, {
+    key: "CallFromFrameMessage",
+    value: function () {
+      var _CallFromFrameMessage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee24(message, Respond) {
+        var _this4 = this;
+        var callback, method, methodResults, responseError;
+        return _regeneratorRuntime.wrap(function _callee24$(_context24) {
+          while (1) switch (_context24.prev = _context24.next) {
+            case 0:
+              if (!(message.type !== "ElvFrameRequest")) {
+                _context24.next = 2;
+                break;
+              }
+              return _context24.abrupt("return");
+            case 2:
+              if (message.callbackId) {
+                callback = function callback(result) {
+                  Respond(_this4.utils.MakeClonable({
+                    type: "ElvFrameResponse",
+                    requestId: message.callbackId,
+                    response: result
+                  }));
+                };
+                message.args.callback = callback;
+              }
+              _context24.prev = 3;
+              method = message.calledMethod;
+              if (!(message.module === "walletClient")) {
+                _context24.next = 15;
+                break;
+              }
+              if (this.walletClient) {
+                _context24.next = 8;
+                break;
+              }
+              throw Error("Wallet client not set");
+            case 8:
+              if (!this.walletClient.ForbiddenMethods().includes(method)) {
+                _context24.next = 10;
+                break;
+              }
+              throw Error("Invalid user profile method: " + method);
+            case 10:
+              _context24.next = 12;
+              return this.walletClient[method](message.args);
+            case 12:
+              methodResults = _context24.sent;
+              _context24.next = 28;
+              break;
+            case 15:
+              if (!(message.module === "userProfileClient")) {
+                _context24.next = 23;
+                break;
+              }
+              if (this.userProfileClient.FrameAllowedMethods().includes(method)) {
+                _context24.next = 18;
+                break;
+              }
+              throw Error("Invalid user profile method: " + method);
+            case 18:
+              _context24.next = 20;
+              return this.userProfileClient[method](message.args);
+            case 20:
+              methodResults = _context24.sent;
+              _context24.next = 28;
+              break;
+            case 23:
+              if (this.FrameAllowedMethods().includes(method)) {
+                _context24.next = 25;
+                break;
+              }
+              throw Error("Invalid method: " + method);
+            case 25:
+              _context24.next = 27;
+              return this[method](message.args);
+            case 27:
+              methodResults = _context24.sent;
+            case 28:
+              Respond(this.utils.MakeClonable({
+                type: "ElvFrameResponse",
+                requestId: message.requestId,
+                response: methodResults
+              }));
+              _context24.next = 37;
+              break;
+            case 31:
+              _context24.prev = 31;
+              _context24.t0 = _context24["catch"](3);
+              // eslint-disable-next-line no-console
+              this.Log("Frame Message Error:\n        Method: ".concat(message.calledMethod, "\n        Arguments: ").concat(JSON.stringify(message.args, null, 2), "\n        Error: ").concat(_typeof(_context24.t0) === "object" ? JSON.stringify(_context24.t0, null, 2) : _context24.t0), true);
+
+              // eslint-disable-next-line no-console
+              console.error(_context24.t0);
+              responseError = _context24.t0 instanceof Error ? _context24.t0.message : _context24.t0;
+              Respond(this.utils.MakeClonable({
+                type: "ElvFrameResponse",
+                requestId: message.requestId,
+                error: responseError
+              }));
+            case 37:
+            case "end":
+              return _context24.stop();
+          }
+        }, _callee24, this, [[3, 31]]);
+      }));
+      function CallFromFrameMessage(_x19, _x20) {
+        return _CallFromFrameMessage.apply(this, arguments);
+      }
+      return CallFromFrameMessage;
+    }()
+  }], [{
+    key: "Configuration",
+    value: (function () {
+      var _Configuration = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee25(_ref29) {
+        var configUrl, _ref29$kmsUrls, kmsUrls, region, clientIP, uri, fabricInfo, filterHTTPS, fabricURIs, ethereumURIs, authServiceURIs, fileServiceURIs, searchURIs, fabricVersion;
+        return _regeneratorRuntime.wrap(function _callee25$(_context25) {
+          while (1) switch (_context25.prev = _context25.next) {
+            case 0:
+              configUrl = _ref29.configUrl, _ref29$kmsUrls = _ref29.kmsUrls, kmsUrls = _ref29$kmsUrls === void 0 ? [] : _ref29$kmsUrls, region = _ref29.region, clientIP = _ref29.clientIP;
+              _context25.prev = 1;
+              uri = new URI(configUrl);
+              uri.pathname("/config");
+              if (region) {
+                uri.addSearch("elvgeo", region);
+              }
+              if (clientIP) {
+                uri.addSearch("client_ip", clientIP);
+              }
+              _context25.next = 8;
+              return Utils.ResponseToJson(HttpClient.Fetch(uri.toString()));
+            case 8:
+              fabricInfo = _context25.sent;
+              // If any HTTPS urls present, throw away HTTP urls so only HTTPS will be used
+              filterHTTPS = function filterHTTPS(uri) {
+                return uri.toLowerCase().startsWith("https");
+              };
+              fabricURIs = fabricInfo.network.services.fabric_api;
+              if (fabricURIs.find(filterHTTPS)) {
+                fabricURIs = fabricURIs.filter(filterHTTPS);
+              }
+              ethereumURIs = fabricInfo.network.services.ethereum_api;
+              if (ethereumURIs.find(filterHTTPS)) {
+                ethereumURIs = ethereumURIs.filter(filterHTTPS);
+              }
+              authServiceURIs = fabricInfo.network.services.authority_service || [];
+              if (authServiceURIs.find(filterHTTPS)) {
+                authServiceURIs = authServiceURIs.filter(filterHTTPS);
+              }
+              fileServiceURIs = fabricInfo.network.services.file_service || fabricURIs;
+              if (fileServiceURIs.find(filterHTTPS)) {
+                fileServiceURIs = fileServiceURIs.filter(filterHTTPS);
+              }
+              searchURIs = fabricInfo.network.services.search || [];
+              fabricVersion = Math.max.apply(Math, _toConsumableArray(fabricInfo.network.api_versions || [2]));
+              return _context25.abrupt("return", {
+                nodeId: fabricInfo.node_id,
+                contentSpaceId: fabricInfo.qspace.id,
+                networkId: (fabricInfo.qspace.ethereum || {}).network_id,
+                networkName: ((fabricInfo.qspace || {}).names || [])[0],
+                fabricURIs: fabricURIs,
+                ethereumURIs: ethereumURIs,
+                authServiceURIs: authServiceURIs,
+                fileServiceURIs: fileServiceURIs,
+                kmsURIs: kmsUrls,
+                searchURIs: searchURIs,
+                fabricVersion: fabricVersion
+              });
+            case 23:
+              _context25.prev = 23;
+              _context25.t0 = _context25["catch"](1);
+              // eslint-disable-next-line no-console
+              console.error("Error retrieving fabric configuration:");
+              // eslint-disable-next-line no-console
+              console.error(_context25.t0);
+              throw _context25.t0;
+            case 28:
+            case "end":
+              return _context25.stop();
+          }
+        }, _callee25, null, [[1, 23]]);
+      }));
+      function Configuration(_x21) {
+        return _Configuration.apply(this, arguments);
+      }
+      return Configuration;
+    }()
+    /**
+     * Return a list of valid Eluvio Content Fabric network names and their associated configuration URLs
+     *
+     * @methodGroup Miscellaneous
+     *
+     * @return {Object} - An object using network names as keys and configuration URLs as values.
+     */
+    )
+  }, {
+    key: "Networks",
+    value: function Networks() {
+      return Object.assign({}, networks);
+    }
+
+    /**
+     * Create a new ElvClient for the specified network
+     *
+     * @methodGroup Constructor
+     * @namedParams
+     * @param {string} networkName - Name of the network to connect to ("main", "demo", "test)
+     * @param {string=} region - Preferred region - the fabric will auto-detect the best region if not specified
+     * - Available regions: as-east, au-east, eu-east-north, eu-west-north, na-east-north, na-east-south, na-west-north, na-west-south, eu-east-south, eu-west-south
+     * @param {string=} clientIP - IP address to use in determining the region to use
+     * @param {string=} trustAuthorityId - (OAuth) The ID of the trust authority to use for OAuth authentication   * @param {boolean=} noCache=false - If enabled, blockchain transactions will not be cached
+     * @param {string=} staticToken - Static token that will be used for all authorization in place of normal auth
+     * @param {number=} ethereumContractTimeout=10 - Number of seconds to wait for contract calls
+     * @param {boolean=} noAuth=false - If enabled, blockchain authorization will not be performed
+     *
+     * @return {Promise<ElvClient>} - New ElvClient connected to the specified content fabric and blockchain
+     */
+  }, {
+    key: "FromNetworkName",
+    value: (function () {
+      var _FromNetworkName = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee26(_ref30) {
+        var networkName, region, clientIP, trustAuthorityId, staticToken, _ref30$ethereumContra, ethereumContractTimeout, _ref30$noCache, noCache, _ref30$noAuth, noAuth, assumeV3, configUrl;
+        return _regeneratorRuntime.wrap(function _callee26$(_context26) {
+          while (1) switch (_context26.prev = _context26.next) {
+            case 0:
+              networkName = _ref30.networkName, region = _ref30.region, clientIP = _ref30.clientIP, trustAuthorityId = _ref30.trustAuthorityId, staticToken = _ref30.staticToken, _ref30$ethereumContra = _ref30.ethereumContractTimeout, ethereumContractTimeout = _ref30$ethereumContra === void 0 ? 10 : _ref30$ethereumContra, _ref30$noCache = _ref30.noCache, noCache = _ref30$noCache === void 0 ? false : _ref30$noCache, _ref30$noAuth = _ref30.noAuth, noAuth = _ref30$noAuth === void 0 ? false : _ref30$noAuth, assumeV3 = _ref30.assumeV3;
+              configUrl = networks[networkName];
+              if (configUrl) {
+                _context26.next = 4;
+                break;
+              }
+              throw Error("Invalid network name: " + networkName);
+            case 4:
+              _context26.next = 6;
+              return this.FromConfigurationUrl({
+                configUrl: configUrl,
+                region: region,
+                clientIP: clientIP,
+                trustAuthorityId: trustAuthorityId,
+                staticToken: staticToken,
+                ethereumContractTimeout: ethereumContractTimeout,
+                noCache: noCache,
+                noAuth: noAuth,
+                assumeV3: assumeV3
+              });
+            case 6:
+              return _context26.abrupt("return", _context26.sent);
+            case 7:
+            case "end":
+              return _context26.stop();
+          }
+        }, _callee26, this);
+      }));
+      function FromNetworkName(_x22) {
+        return _FromNetworkName.apply(this, arguments);
+      }
+      return FromNetworkName;
+    }()
+    /**
+     * Create a new ElvClient from the specified configuration URL
+     *
+     * @methodGroup Constructor
+     * @namedParams
+     * @param {string} configUrl - Full URL to the config endpoint
+     * @param {string=} region - Preferred region - the fabric will auto-detect the best region if not specified
+     * - Available regions: as-east, au-east, eu-east-north, eu-west-north, na-east-north, na-east-south, na-west-north, na-west-south, eu-east-south, eu-west-south
+     * @param {string=} clientIP - IP address to use in determining the region to use
+     * @param {string=} trustAuthorityId - (OAuth) The ID of the trust authority to use for OAuth authentication   * @param {boolean=} noCache=false - If enabled, blockchain transactions will not be cached
+     * @param {string=} staticToken - Static token that will be used for all authorization in place of normal auth
+     * @param {number=} ethereumContractTimeout=10 - Number of seconds to wait for contract calls
+     * @param {boolean=} noAuth=false - If enabled, blockchain authorization will not be performed
+     *
+     * @return {Promise<ElvClient>} - New ElvClient connected to the specified content fabric and blockchain
+     */
+    )
+  }, {
+    key: "FromConfigurationUrl",
+    value: (function () {
+      var _FromConfigurationUrl = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee27(_ref31) {
+        var configUrl, region, clientIP, trustAuthorityId, staticToken, _ref31$ethereumContra, ethereumContractTimeout, _ref31$noCache, noCache, _ref31$noAuth, noAuth, _ref31$assumeV, assumeV3, _yield$ElvClient$Conf3, contentSpaceId, networkId, networkName, fabricURIs, ethereumURIs, authServiceURIs, fileServiceURIs, searchURIs, fabricVersion, client;
+        return _regeneratorRuntime.wrap(function _callee27$(_context27) {
+          while (1) switch (_context27.prev = _context27.next) {
+            case 0:
+              configUrl = _ref31.configUrl, region = _ref31.region, clientIP = _ref31.clientIP, trustAuthorityId = _ref31.trustAuthorityId, staticToken = _ref31.staticToken, _ref31$ethereumContra = _ref31.ethereumContractTimeout, ethereumContractTimeout = _ref31$ethereumContra === void 0 ? 10 : _ref31$ethereumContra, _ref31$noCache = _ref31.noCache, noCache = _ref31$noCache === void 0 ? false : _ref31$noCache, _ref31$noAuth = _ref31.noAuth, noAuth = _ref31$noAuth === void 0 ? false : _ref31$noAuth, _ref31$assumeV = _ref31.assumeV3, assumeV3 = _ref31$assumeV === void 0 ? false : _ref31$assumeV;
+              _context27.next = 3;
+              return ElvClient.Configuration({
+                configUrl: configUrl,
+                clientIP: clientIP,
+                region: region
+              });
+            case 3:
+              _yield$ElvClient$Conf3 = _context27.sent;
+              contentSpaceId = _yield$ElvClient$Conf3.contentSpaceId;
+              networkId = _yield$ElvClient$Conf3.networkId;
+              networkName = _yield$ElvClient$Conf3.networkName;
+              fabricURIs = _yield$ElvClient$Conf3.fabricURIs;
+              ethereumURIs = _yield$ElvClient$Conf3.ethereumURIs;
+              authServiceURIs = _yield$ElvClient$Conf3.authServiceURIs;
+              fileServiceURIs = _yield$ElvClient$Conf3.fileServiceURIs;
+              searchURIs = _yield$ElvClient$Conf3.searchURIs;
+              fabricVersion = _yield$ElvClient$Conf3.fabricVersion;
+              client = new ElvClient({
+                contentSpaceId: contentSpaceId,
+                networkId: networkId,
+                networkName: networkName,
+                fabricVersion: fabricVersion,
+                fabricURIs: fabricURIs,
+                ethereumURIs: ethereumURIs,
+                authServiceURIs: authServiceURIs,
+                fileServiceURIs: fileServiceURIs,
+                searchURIs: searchURIs,
+                ethereumContractTimeout: ethereumContractTimeout,
+                trustAuthorityId: trustAuthorityId,
+                staticToken: staticToken,
+                noCache: noCache,
+                noAuth: noAuth,
+                assumeV3: assumeV3
+              });
+              client.configUrl = configUrl;
+              client.region = region;
+              client.clientIP = clientIP;
+              return _context27.abrupt("return", client);
+            case 18:
+            case "end":
+              return _context27.stop();
+          }
+        }, _callee27);
+      }));
+      function FromConfigurationUrl(_x23) {
+        return _FromConfigurationUrl.apply(this, arguments);
+      }
+      return FromConfigurationUrl;
+    }())
+  }]);
+}();
+Object.assign(ElvClient.prototype, require("./client/AccessGroups"));
+Object.assign(ElvClient.prototype, require("./client/ContentAccess"));
+Object.assign(ElvClient.prototype, require("./client/Contracts"));
+Object.assign(ElvClient.prototype, require("./client/Files"));
+Object.assign(ElvClient.prototype, require("./client/ABRPublishing"));
+Object.assign(ElvClient.prototype, require("./client/LiveStream"));
+Object.assign(ElvClient.prototype, require("./client/ContentManagement"));
+Object.assign(ElvClient.prototype, require("./client/NTP"));
+Object.assign(ElvClient.prototype, require("./client/NFT"));
+exports.ElvClient = ElvClient;