@eluvio/elv-client-js 4.0.10 → 4.0.11

package/dist/src/ElvWallet.js

@@ -1,9 +1,15 @@
 var _regeneratorRuntime = require("@babel/runtime/regenerator");
+
 var _typeof = require("@babel/runtime/helpers/typeof");
+
 var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
+
 var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");
+
 var _createClass = require("@babel/runtime/helpers/createClass");
+
 var Ethers = require("ethers");
+
 var ElvWallet = /*#__PURE__*/function () {
   "use strict";
 
@@ -16,21 +22,22 @@ var ElvWallet = /*#__PURE__*/function () {
    */
   function ElvWallet(provider) {
     _classCallCheck(this, ElvWallet);
+
     this.provider = provider;
     this.signers = {};
   }
-
   /**
    * Generate a mnemonic that can be used to initialize a private key
    *
    * @returns {string} - Space-separated list of random words
    */
+
+
   _createClass(ElvWallet, [{
     key: "GenerateMnemonic",
     value: function GenerateMnemonic() {
       return Ethers.Wallet.createRandom().mnemonic.phrase;
     }
-
     /**
      * Generate a private key from the given mnemonic
      *
@@ -40,18 +47,18 @@ var ElvWallet = /*#__PURE__*/function () {
      *
      * @returns {Signer} - Signer with the generated private key, connected to the provider
      */
+
   }, {
     key: "AddAccountFromMnemonic",
     value: function AddAccountFromMnemonic(_ref) {
       var accountName = _ref.accountName,
-        mnemonic = _ref.mnemonic;
+          mnemonic = _ref.mnemonic;
       var signer = Ethers.Wallet.fromMnemonic(mnemonic);
       return this.AddAccount({
         accountName: accountName,
         privateKey: signer.privateKey
       });
     }
-
     /**
      * Add an account from an encrypted private key (Ethereum keystore format)
      *
@@ -62,35 +69,44 @@ var ElvWallet = /*#__PURE__*/function () {
      *
      * @returns {Promise<Signer>} - Signer with the decrypted private key, connected to the provider
      */
+
   }, {
     key: "AddAccountFromEncryptedPK",
     value: function () {
       var _AddAccountFromEncryptedPK = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref2) {
         var accountName, encryptedPrivateKey, password, signer;
         return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              accountName = _ref2.accountName, encryptedPrivateKey = _ref2.encryptedPrivateKey, password = _ref2.password;
-              if (_typeof(encryptedPrivateKey) === "object") {
-                encryptedPrivateKey = JSON.stringify(encryptedPrivateKey);
-              }
-              _context.next = 4;
-              return Ethers.Wallet.fromEncryptedJson(encryptedPrivateKey, password);
-            case 4:
-              signer = _context.sent;
-              return _context.abrupt("return", this.AddAccount({
-                accountName: accountName,
-                privateKey: signer.privateKey
-              }));
-            case 6:
-            case "end":
-              return _context.stop();
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                accountName = _ref2.accountName, encryptedPrivateKey = _ref2.encryptedPrivateKey, password = _ref2.password;
+
+                if (_typeof(encryptedPrivateKey) === "object") {
+                  encryptedPrivateKey = JSON.stringify(encryptedPrivateKey);
+                }
+
+                _context.next = 4;
+                return Ethers.Wallet.fromEncryptedJson(encryptedPrivateKey, password);
+
+              case 4:
+                signer = _context.sent;
+                return _context.abrupt("return", this.AddAccount({
+                  accountName: accountName,
+                  privateKey: signer.privateKey
+                }));
+
+              case 6:
+              case "end":
+                return _context.stop();
+            }
           }
         }, _callee, this);
       }));
+
       function AddAccountFromEncryptedPK(_x) {
         return _AddAccountFromEncryptedPK.apply(this, arguments);
       }
+
       return AddAccountFromEncryptedPK;
     }()
     /**
@@ -102,23 +118,26 @@ var ElvWallet = /*#__PURE__*/function () {
      *
      * @returns {Signer} - Signer with the private key, connected to the provider
      */
+
   }, {
     key: "AddAccount",
     value: function AddAccount(_ref3) {
       var accountName = _ref3.accountName,
-        privateKey = _ref3.privateKey;
+          privateKey = _ref3.privateKey;
+
       try {
         var signer = new Ethers.Wallet(privateKey);
         signer = signer.connect(this.provider);
+
         if (accountName) {
           this.signers[accountName] = signer;
         }
+
         return signer;
       } catch (error) {
         throw Error("Invalid private key");
       }
     }
-
     /**
      * Get the balance of the account. The account to query can be specified either by
      * passing the signer object, or by passing the account name of a saved account
@@ -131,39 +150,49 @@ var ElvWallet = /*#__PURE__*/function () {
      *
      * @returns {number} - Account balance of the specified account, in ETH
      */
+
   }, {
     key: "GetAccountBalance",
     value: function () {
       var _GetAccountBalance = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref4) {
         var accountName, signer, accountSigner;
         return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              accountName = _ref4.accountName, signer = _ref4.signer;
-              accountSigner = signer || this.GetAccount({
-                accountName: accountName
-              });
-              if (accountSigner) {
-                _context2.next = 4;
-                break;
-              }
-              throw Error("Unknown account: " + accountName);
-            case 4:
-              _context2.t0 = Ethers.utils;
-              _context2.next = 7;
-              return accountSigner.getBalance();
-            case 7:
-              _context2.t1 = _context2.sent;
-              return _context2.abrupt("return", _context2.t0.formatEther.call(_context2.t0, _context2.t1));
-            case 9:
-            case "end":
-              return _context2.stop();
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                accountName = _ref4.accountName, signer = _ref4.signer;
+                accountSigner = signer || this.GetAccount({
+                  accountName: accountName
+                });
+
+                if (accountSigner) {
+                  _context2.next = 4;
+                  break;
+                }
+
+                throw Error("Unknown account: " + accountName);
+
+              case 4:
+                _context2.t0 = Ethers.utils;
+                _context2.next = 7;
+                return accountSigner.getBalance();
+
+              case 7:
+                _context2.t1 = _context2.sent;
+                return _context2.abrupt("return", _context2.t0.formatEther.call(_context2.t0, _context2.t1));
+
+              case 9:
+              case "end":
+                return _context2.stop();
+            }
           }
         }, _callee2, this);
       }));
+
       function GetAccountBalance(_x2) {
         return _GetAccountBalance.apply(this, arguments);
       }
+
       return GetAccountBalance;
     }()
     /**
@@ -180,37 +209,47 @@ var ElvWallet = /*#__PURE__*/function () {
      *
      * @returns {Promise<string>} - The encrypted private key (in Ethereum keystore format)
      */
+
   }, {
     key: "GenerateEncryptedPrivateKey",
     value: function () {
       var _GenerateEncryptedPrivateKey = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref5) {
         var accountName, signer, password, options, accountSigner;
         return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              accountName = _ref5.accountName, signer = _ref5.signer, password = _ref5.password, options = _ref5.options;
-              accountSigner = signer || this.GetAccount({
-                accountName: accountName
-              });
-              if (accountSigner) {
-                _context3.next = 4;
-                break;
-              }
-              throw Error("Unknown account: " + accountName);
-            case 4:
-              _context3.next = 6;
-              return accountSigner.encrypt(password, options);
-            case 6:
-              return _context3.abrupt("return", _context3.sent);
-            case 7:
-            case "end":
-              return _context3.stop();
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                accountName = _ref5.accountName, signer = _ref5.signer, password = _ref5.password, options = _ref5.options;
+                accountSigner = signer || this.GetAccount({
+                  accountName: accountName
+                });
+
+                if (accountSigner) {
+                  _context3.next = 4;
+                  break;
+                }
+
+                throw Error("Unknown account: " + accountName);
+
+              case 4:
+                _context3.next = 6;
+                return accountSigner.encrypt(password, options);
+
+              case 6:
+                return _context3.abrupt("return", _context3.sent);
+
+              case 7:
+              case "end":
+                return _context3.stop();
+            }
           }
         }, _callee3, this);
       }));
+
       function GenerateEncryptedPrivateKey(_x3) {
         return _GenerateEncryptedPrivateKey.apply(this, arguments);
       }
+
       return GenerateEncryptedPrivateKey;
     }()
     /**
@@ -220,19 +259,20 @@ var ElvWallet = /*#__PURE__*/function () {
      * @param {string} accountName - Name of the account
       * @returns {(Signer|undefined)} - Signer of the saved account, if it exists
      */
+
   }, {
     key: "GetAccount",
     value: function GetAccount(_ref6) {
       var accountName = _ref6.accountName;
       return this.signers[accountName];
     }
-
     /**
      * Remove a previously saved account from this wallet
      *
      * @namedParams
      * @param {string} accountName - Name of the account to delete
      */
+
   }, {
     key: "RemoveAccount",
     value: function RemoveAccount(_ref7) {
@@ -240,6 +280,8 @@ var ElvWallet = /*#__PURE__*/function () {
       delete this.signers[accountName];
     }
   }]);
+
   return ElvWallet;
 }();
+
 module.exports = ElvWallet;