@provenanceio/wallet-utils/esm/services/grpc/grpc-service.js

Typescript Utilities for Provenance Blockchain Wallet

import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
import _regeneratorRuntime from "@babel/runtime/regenerator";
import { BaseAccount } from '../../proto/cosmos/auth/v1beta1/auth_pb';
import { QueryAccountRequest } from '../../proto/cosmos/auth/v1beta1/query_pb';
import { QueryClient as AuthQueryClient } from '../../proto/cosmos/auth/v1beta1/query_grpc_web_pb';
import { QueryAllBalancesRequest } from '../../proto/cosmos/bank/v1beta1/query_pb';
import { QueryClient as MsgFeeQueryClient } from '../../proto/provenance/msgfees/v1/query_grpc_web_pb';
import { ServiceClient as TxServiceClient } from '../../proto/cosmos/tx/v1beta1/service_grpc_web_pb';
import { QueryClient as BankQueryClient } from '../../proto/cosmos/bank/v1beta1/query_grpc_web_pb';
import { PageRequest } from '../../proto/cosmos/base/query/v1beta1/pagination_pb';
export var calculateTxFees = function calculateTxFees(serviceAddress, request) {
  return new Promise(function (resolve, reject) {
    var msgFeeQuery = new MsgFeeQueryClient(serviceAddress, null);
    msgFeeQuery.calculateTxFees(request, null, function (error, response) {
      if (error) {
        reject(new Error("msgFeeQuery.calculateTxFees error: Code: ".concat(error.code, " Message: ").concat(error.message)));
      } else {
        resolve(response.toObject());
      }
    });
  });
};
export var getAccountInfo = function getAccountInfo(address, serviceAddress) {
  var accountRequest = new QueryAccountRequest();
  accountRequest.setAddress(address);
  return new Promise(function (resolve, reject) {
    var authQuery = new AuthQueryClient(serviceAddress, null);
    authQuery.account(accountRequest, null, function (error, response) {
      if (error) reject(new Error("authQuery.account error: Code: ".concat(error.code, " Message: ").concat(error.message)));else {
        var accountAny = response.getAccount();

        if (accountAny) {
          var baseAccount = accountAny.unpack(BaseAccount.deserializeBinary, accountAny.getTypeName());

          if (baseAccount) {
            resolve({
              baseAccount: baseAccount,
              accountNumber: baseAccount.getAccountNumber(),
              sequence: baseAccount.getSequence()
            });
          } else reject(new Error("authQuery.account message unpacking failure"));
        } else reject(new Error("No response from authQuery.account"));
      }
    });
  });
};
export var getBalancesList = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(address, serviceAddress) {
    var pageRequest, bankRequest;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            pageRequest = new PageRequest();
            pageRequest.setOffset(0);
            pageRequest.setLimit(1000);
            pageRequest.setCountTotal(true);
            bankRequest = new QueryAllBalancesRequest();
            bankRequest.setAddress(address);
            bankRequest.setPagination(pageRequest);
            return _context.abrupt("return", new Promise(function (resolve, reject) {
              new BankQueryClient(serviceAddress, null).allBalances(bankRequest, null, function (error, response) {
                if (error) reject(new Error("bankQuery.allBalances error: Code: ".concat(error.code, " Message: ").concat(error.message)));else {
                  resolve(response.toObject());
                }
              });
            }));

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

  return function getBalancesList(_x, _x2) {
    return _ref.apply(this, arguments);
  };
}();
export var broadcastTx = /*#__PURE__*/function () {
  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(serviceAddress, request) {
    var txClient;
    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            if (serviceAddress) {
              _context2.next = 2;
              break;
            }

            throw new Error('GrpcService requires serviceAddress');

          case 2:
            txClient = new TxServiceClient(serviceAddress, null);
            return _context2.abrupt("return", new Promise(function (resolve, reject) {
              txClient.broadcastTx(request, null, function (error, response) {
                if (error) reject(new Error("broadcastTx error: Code: ".concat(error.code, " Message: ").concat(error.message)));else {
                  resolve(response.toObject());
                }
              });
            }));

          case 4:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));

  return function broadcastTx(_x3, _x4) {
    return _ref2.apply(this, arguments);
  };
}();