@r3l/app/lib/modules/wallet/wallet.actions.js

Relevant App

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.cashOutCall = cashOutCall;
exports.connectAddress = connectAddress;
exports.addEthAddress = addEthAddress;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _eth = require("../../utils/eth");

var _utils = require("../../utils");

var _auth = require("../auth/auth.actions");

var _earnings = require("./earnings.actions");

var _utils2 = require("../../web3/utils");

var Alert = _utils.alert.Alert();

function cashOutCall() {
  var customAmount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
  var token = arguments.length > 1 ? arguments[1] : undefined;
  return /*#__PURE__*/function () {
    var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(dispatch) {
      var _yield$dispatch, user, earning, _user$cashOut, amnt, sig;

      return _regenerator.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _context.prev = 0;
              _context.next = 3;
              return dispatch(_utils.api.request({
                method: 'POST',
                endpoint: 'user',
                path: '/cashOut',
                body: JSON.stringify({
                  customAmount: customAmount,
                  token: token
                })
              }));

            case 3:
              _yield$dispatch = _context.sent;
              user = _yield$dispatch.user;
              earning = _yield$dispatch.earning;
              dispatch((0, _auth.updateAuthUser)(user));
              earning && dispatch((0, _earnings.addEarning)(earning));
              _user$cashOut = user.cashOut, amnt = _user$cashOut.amountBN, sig = _user$cashOut.signature;
              return _context.abrupt("return", {
                amnt: amnt,
                sig: sig
              });

            case 12:
              _context.prev = 12;
              _context.t0 = _context["catch"](0);
              console.log(_context.t0); // eslint-disable-line

              return _context.abrupt("return", Alert.alert(_context.t0.message, 'error'));

            case 16:
            case "end":
              return _context.stop();
          }
        }
      }, _callee, null, [[0, 12]]);
    }));

    return function (_x) {
      return _ref.apply(this, arguments);
    };
  }();
}

function connectAddress(account) {
  return /*#__PURE__*/function () {
    var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(dispatch) {
      var signer, sig;
      return _regenerator.default.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              _context2.prev = 0;
              signer = (0, _utils2.getSigner)();

              if (signer) {
                _context2.next = 4;
                break;
              }

              return _context2.abrupt("return");

            case 4:
              _context2.next = 6;
              return (0, _eth.signMessage)(signer, account);

            case 6:
              sig = _context2.sent;
              dispatch(addEthAddress(sig));
              _context2.next = 13;
              break;

            case 10:
              _context2.prev = 10;
              _context2.t0 = _context2["catch"](0);
              Alert.alert('Failed signing message: ' + _context2.t0.message);

            case 13:
            case "end":
              return _context2.stop();
          }
        }
      }, _callee2, null, [[0, 10]]);
    }));

    return function (_x2) {
      return _ref2.apply(this, arguments);
    };
  }();
}

function addEthAddress(sig) {
  return /*#__PURE__*/function () {
    var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(dispatch) {
      var result;
      return _regenerator.default.wrap(function _callee3$(_context3) {
        while (1) {
          switch (_context3.prev = _context3.next) {
            case 0:
              _context3.prev = 0;
              _context3.next = 3;
              return dispatch(_utils.api.request({
                method: 'PUT',
                endpoint: 'user',
                path: '/ethAddress',
                body: JSON.stringify(sig)
              }));

            case 3:
              result = _context3.sent;
              dispatch((0, _auth.updateAuthUser)(result));
              return _context3.abrupt("return", true);

            case 8:
              _context3.prev = 8;
              _context3.t0 = _context3["catch"](0);
              Alert.alert(_context3.t0.message, 'error');
              return _context3.abrupt("return", false);

            case 12:
            case "end":
              return _context3.stop();
          }
        }
      }, _callee3, null, [[0, 8]]);
    }));

    return function (_x3) {
      return _ref3.apply(this, arguments);
    };
  }();
}
//# sourceMappingURL=wallet.actions.js.map