@eluvio/elv-client-js 4.0.114 → 4.0.116

package/dist/src/RemoteSigner.js

@@ -0,0 +1,383 @@
+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");
+var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");
+var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");
+var _inherits = require("@babel/runtime/helpers/inherits");
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var Ethers = require("ethers");
+var Utils = require("./Utils");
+var HttpClient = require("./HttpClient");
+var UrlJoin = require("url-join");
+var UUID = require("uuid");
+var RemoteSigner = /*#__PURE__*/function (_Ethers$Signer) {
+  "use strict";
+
+  function RemoteSigner(_ref) {
+    var _this;
+    var signerURIs = _ref.signerURIs,
+      idToken = _ref.idToken,
+      authToken = _ref.authToken,
+      tenantId = _ref.tenantId,
+      provider = _ref.provider,
+      _ref$extraData = _ref.extraData,
+      extraData = _ref$extraData === void 0 ? {} : _ref$extraData,
+      _ref$unsignedPublicAu = _ref.unsignedPublicAuth,
+      unsignedPublicAuth = _ref$unsignedPublicAu === void 0 ? false : _ref$unsignedPublicAu;
+    _classCallCheck(this, RemoteSigner);
+    _this = _callSuper(this, RemoteSigner);
+    _this.remoteSigner = true;
+    _this.unsignedPublicAuth = unsignedPublicAuth;
+    _this.HttpClient = new HttpClient({
+      uris: signerURIs
+    });
+    _this.idToken = idToken;
+    _this.tenantId = tenantId;
+    _this.authToken = authToken;
+    _this.extraLoginData = extraData || {};
+    _this.provider = provider;
+    _this.signatureCache = {};
+    return _this;
+  }
+  _inherits(RemoteSigner, _Ethers$Signer);
+  return _createClass(RemoteSigner, [{
+    key: "Initialize",
+    value: function () {
+      var _Initialize = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var _yield$Utils$Response, addr, eth, token, keys, address;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (this.authToken) {
+                _context.next = 10;
+                break;
+              }
+              _context.next = 3;
+              return Utils.ResponseToJson(this.HttpClient.Request({
+                path: UrlJoin("as", "wlt", "login", "jwt"),
+                method: "POST",
+                body: this.tenantId ? {
+                  tid: this.tenantId,
+                  ext: this.extraLoginData || {}
+                } : {
+                  ext: this.extraLoginData || {}
+                },
+                headers: {
+                  Authorization: "Bearer ".concat(this.idToken)
+                }
+              }));
+            case 3:
+              _yield$Utils$Response = _context.sent;
+              addr = _yield$Utils$Response.addr;
+              eth = _yield$Utils$Response.eth;
+              token = _yield$Utils$Response.token;
+              this.authToken = token;
+              this.address = Utils.FormatAddress(addr);
+              this.id = eth;
+            case 10:
+              if (this.address) {
+                _context.next = 16;
+                break;
+              }
+              _context.next = 13;
+              return Utils.ResponseToJson(this.HttpClient.Request({
+                method: "GET",
+                path: UrlJoin("as", "wlt", "keys"),
+                headers: {
+                  Authorization: "Bearer ".concat(this.authToken)
+                }
+              }));
+            case 13:
+              keys = _context.sent;
+              address = keys.eth[0];
+              if (address && address.startsWith("0x")) {
+                this.address = address;
+              } else {
+                this.address = Utils.HashToAddress(keys.eth[0]);
+              }
+            case 16:
+              this.id = this.address ? "ikms".concat(Utils.AddressToHash(this.address)) : undefined;
+              this.signer = this.provider.getSigner(this.address);
+            case 18:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function Initialize() {
+        return _Initialize.apply(this, arguments);
+      }
+      return Initialize;
+    }()
+  }, {
+    key: "RetrieveCSAT",
+    value: function () {
+      var _RetrieveCSAT = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref2) {
+        var email, nonce, tenantId, _ref2$force, force, response;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              email = _ref2.email, nonce = _ref2.nonce, tenantId = _ref2.tenantId, _ref2$force = _ref2.force, force = _ref2$force === void 0 ? false : _ref2$force;
+              nonce = nonce || Utils.B58(UUID.parse(UUID.v4()));
+              _context2.next = 4;
+              return Utils.ResponseToJson(this.HttpClient.Request({
+                method: "POST",
+                body: {
+                  email: email,
+                  nonce: nonce,
+                  force: force,
+                  tid: tenantId
+                },
+                path: UrlJoin("as", "wlt", "sign", "csat"),
+                headers: {
+                  Authorization: "Bearer ".concat(this.authToken)
+                }
+              }));
+            case 4:
+              response = _context2.sent;
+              response.nonce = nonce;
+              return _context2.abrupt("return", response);
+            case 7:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function RetrieveCSAT(_x) {
+        return _RetrieveCSAT.apply(this, arguments);
+      }
+      return RetrieveCSAT;
+    }()
+  }, {
+    key: "CSATStatus",
+    value: function () {
+      var _CSATStatus = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref3) {
+        var accessToken, response;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              accessToken = _ref3.accessToken;
+              _context3.prev = 1;
+              _context3.next = 4;
+              return Utils.ResponseToJson(this.HttpClient.Request({
+                method: "POST",
+                path: UrlJoin("as", "wlt", "login", "status"),
+                headers: {
+                  Authorization: "Bearer ".concat(accessToken)
+                }
+              }));
+            case 4:
+              response = _context3.sent;
+              return _context3.abrupt("return", response && response.is_active);
+            case 8:
+              _context3.prev = 8;
+              _context3.t0 = _context3["catch"](1);
+              return _context3.abrupt("return", !_context3.t0 || _context3.t0.status !== 403);
+            case 11:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[1, 8]]);
+      }));
+      function CSATStatus(_x2) {
+        return _CSATStatus.apply(this, arguments);
+      }
+      return CSATStatus;
+    }()
+  }, {
+    key: "ReleaseCSAT",
+    value: function () {
+      var _ReleaseCSAT = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(_ref4) {
+        var accessToken;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              accessToken = _ref4.accessToken;
+              _context4.next = 3;
+              return Utils.ResponseToJson(this.HttpClient.Request({
+                method: "POST",
+                path: UrlJoin("as", "wlt", "login", "release"),
+                headers: {
+                  Authorization: "Bearer ".concat(accessToken)
+                }
+              }));
+            case 3:
+              return _context4.abrupt("return", _context4.sent);
+            case 4:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function ReleaseCSAT(_x3) {
+        return _ReleaseCSAT.apply(this, arguments);
+      }
+      return ReleaseCSAT;
+    }() // Overrides
+  }, {
+    key: "getAddress",
+    value: function getAddress() {
+      return this.address;
+    }
+  }, {
+    key: "signDigest",
+    value: function () {
+      var _signDigest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(digest) {
+        var _this2 = this;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              if (!this.signatureCache[digest]) {
+                this.signatureCache[digest] = new Promise( /*#__PURE__*/function () {
+                  var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(resolve, reject) {
+                    var signature;
+                    return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+                      while (1) switch (_context5.prev = _context5.next) {
+                        case 0:
+                          _context5.prev = 0;
+                          _context5.next = 3;
+                          return Utils.ResponseToJson(_this2.HttpClient.Request({
+                            method: "POST",
+                            path: UrlJoin("as", "wlt", "sign", "eth", _this2.id),
+                            headers: {
+                              Authorization: "Bearer ".concat(_this2.authToken)
+                            },
+                            body: {
+                              hash: digest
+                            }
+                          }));
+                        case 3:
+                          signature = _context5.sent;
+                          signature.v = parseInt(signature.v, 16);
+                          signature.recoveryParam = signature.v - 27;
+                          resolve(signature);
+                          _context5.next = 12;
+                          break;
+                        case 9:
+                          _context5.prev = 9;
+                          _context5.t0 = _context5["catch"](0);
+                          reject(_context5.t0);
+                        case 12:
+                        case "end":
+                          return _context5.stop();
+                      }
+                    }, _callee5, null, [[0, 9]]);
+                  }));
+                  return function (_x5, _x6) {
+                    return _ref5.apply(this, arguments);
+                  };
+                }());
+              }
+              _context6.next = 3;
+              return this.signatureCache[digest];
+            case 3:
+              return _context6.abrupt("return", _context6.sent);
+            case 4:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function signDigest(_x4) {
+        return _signDigest.apply(this, arguments);
+      }
+      return signDigest;
+    }()
+  }, {
+    key: "signMessage",
+    value: function () {
+      var _signMessage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(message) {
+        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _context7.t0 = Promise;
+              _context7.t1 = Ethers.utils;
+              _context7.t2 = "0x";
+              _context7.next = 5;
+              return this.signDigest(Ethers.utils.hashMessage(message));
+            case 5:
+              _context7.t3 = _context7.sent;
+              _context7.t4 = _context7.t2.concat.call(_context7.t2, _context7.t3);
+              _context7.t5 = _context7.t1.joinSignature.call(_context7.t1, _context7.t4);
+              return _context7.abrupt("return", _context7.t0.resolve.call(_context7.t0, _context7.t5));
+            case 9:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function signMessage(_x7) {
+        return _signMessage.apply(this, arguments);
+      }
+      return signMessage;
+    }()
+  }, {
+    key: "sign",
+    value: function () {
+      var _sign = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(transaction) {
+        var signature;
+        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              _context8.next = 2;
+              return Ethers.utils.resolveProperties(transaction);
+            case 2:
+              transaction = _context8.sent;
+              _context8.next = 5;
+              return this.signDigest(Ethers.utils.keccak256(Ethers.utils.serializeTransaction(transaction)));
+            case 5:
+              signature = _context8.sent;
+              return _context8.abrupt("return", Ethers.utils.serializeTransaction(transaction, signature));
+            case 7:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function sign(_x8) {
+        return _sign.apply(this, arguments);
+      }
+      return sign;
+    }()
+  }, {
+    key: "sendTransaction",
+    value: function () {
+      var _sendTransaction = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9(transaction) {
+        var _this3 = this;
+        return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              if (!(transaction.nonce == null)) {
+                _context9.next = 5;
+                break;
+              }
+              transaction = Ethers.utils.shallowCopy(transaction);
+              _context9.next = 4;
+              return this.provider.getTransactionCount(this.address, "pending");
+            case 4:
+              transaction.nonce = _context9.sent;
+            case 5:
+              return _context9.abrupt("return", this.populateTransaction(transaction, this.provider, this.address).then(function (tx) {
+                return _this3.sign(tx).then(function (signedTransaction) {
+                  return _this3.provider.sendTransaction(signedTransaction);
+                });
+              }));
+            case 6:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this);
+      }));
+      function sendTransaction(_x9) {
+        return _sendTransaction.apply(this, arguments);
+      }
+      return sendTransaction;
+    }()
+  }, {
+    key: "connect",
+    value: function connect() {}
+  }]);
+}(Ethers.Signer);
+module.exports = RemoteSigner;