react-use-etherscan/dist/hooks/useTokenBalance.js

🌊 🏄 ⚛️ React hooks for interacting with Etherscan. Supports Android/iOS/Web/Expo.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = useTokenBalance;

var _react = require("react");

var _typeCheck = require("type-check");

var _ = require(".");

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var TYPEDEF_TOKEN_BALANCE = "{status:String,message:String,result:String,...}";

var fetchTokenBalance = function fetchTokenBalance(address, tokenName, contractAddress) {
  return /*#__PURE__*/function () {
    var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(_ref) {
      var account, data, message, result;
      return regeneratorRuntime.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              account = _ref.account;
              _context.next = 3;
              return account.tokenbalance(address, tokenName, contractAddress);

            case 3:
              data = _context.sent;

              if ((0, _typeCheck.typeCheck)(TYPEDEF_TOKEN_BALANCE, data)) {
                _context.next = 6;
                break;
              }

              throw new Error("Expected ".concat(TYPEDEF_TOKEN_BALANCE, ", encountered ").concat(data, "."));

            case 6:
              message = data.message, result = data.result;

              if (!(message !== "OK")) {
                _context.next = 9;
                break;
              }

              throw new Error(JSON.stringify(data));

            case 9:
              return _context.abrupt("return", result);

            case 10:
            case "end":
              return _context.stop();
          }
        }
      }, _callee);
    }));

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

function useTokenBalance(_ref3) {
  var address = _ref3.address,
      tokenName = _ref3.tokenName,
      contractAddress = _ref3.contractAddress;

  var _useEtherscanStateful = (0, _.useEtherscanStateful)(),
      query = _useEtherscanStateful.query,
      loading = _useEtherscanStateful.loading,
      result = _useEtherscanStateful.result,
      error = _useEtherscanStateful.error;

  var refetch = (0, _react.useCallback)(function () {
    return query(fetchTokenBalance(address, tokenName, contractAddress));
  }, [query, address, tokenName, contractAddress]);
  (0, _react.useEffect)(function () {
    return refetch() && undefined;
  }, [refetch]);
  return {
    loading: loading,
    result: result,
    error: error,
    refetch: refetch
  };
}

;