@bnb-chain/greenfield-js-sdk
Version:
greenfield js chain and sp sdk
1,445 lines (1,403 loc) • 230 kB
JavaScript
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
require('reflect-metadata');
var tsyringe = require('tsyringe');
var any = require('@bnb-chain/greenfield-cosmos-types/google/protobuf/any');
var base64 = require('@ethersproject/base64');
var bytes = require('@ethersproject/bytes');
var strings = require('@ethersproject/strings');
var cloneDeep = require('lodash.clonedeep');
var get = require('lodash.get');
var mapValues = require('lodash.mapvalues');
var set = require('lodash.set');
var sortBy = require('lodash.sortby');
var ethSigUtil = require('@metamask/eth-sig-util');
var secp256k1Compat = require('ethereum-cryptography/secp256k1-compat');
var query$d = require('@bnb-chain/greenfield-cosmos-types/cosmos/base/tendermint/v1beta1/query');
var Long = require('long');
var query = require('@bnb-chain/greenfield-cosmos-types/cosmos/auth/v1beta1/query');
var query$1 = require('@bnb-chain/greenfield-cosmos-types/cosmos/bank/v1beta1/query');
var query$5 = require('@bnb-chain/greenfield-cosmos-types/cosmos/crosschain/v1/query');
var tx = require('@bnb-chain/greenfield-cosmos-types/cosmos/distribution/v1beta1/tx');
var query$8 = require('@bnb-chain/greenfield-cosmos-types/cosmos/feegrant/v1beta1/query');
var query$a = require('@bnb-chain/greenfield-cosmos-types/cosmos/gashub/v1beta1/query');
var query$6 = require('@bnb-chain/greenfield-cosmos-types/cosmos/oracle/v1/query');
var query$c = require('@bnb-chain/greenfield-cosmos-types/cosmos/staking/v1beta1/query');
var query$7 = require('@bnb-chain/greenfield-cosmos-types/greenfield/bridge/query');
var query$4 = require('@bnb-chain/greenfield-cosmos-types/greenfield/challenge/query');
var query$2 = require('@bnb-chain/greenfield-cosmos-types/greenfield/payment/query');
var query$3 = require('@bnb-chain/greenfield-cosmos-types/greenfield/sp/query');
var query$9 = require('@bnb-chain/greenfield-cosmos-types/greenfield/storage/query');
var query$b = require('@bnb-chain/greenfield-cosmos-types/greenfield/virtualgroup/query');
var stargate = require('@cosmjs/stargate');
var tendermintRpc = require('@cosmjs/tendermint-rpc');
var wrapper = require('@bnb-chain/greenfield-cosmos-types/greenfield/common/wrapper');
var common = require('@bnb-chain/greenfield-cosmos-types/greenfield/permission/common');
var common$1 = require('@bnb-chain/greenfield-cosmos-types/greenfield/storage/common');
var tx$5 = require('@bnb-chain/greenfield-cosmos-types/greenfield/storage/tx');
var common$2 = require('@bnb-chain/greenfield-cosmos-types/greenfield/virtualgroup/common');
var helpers = require('@bnb-chain/greenfield-cosmos-types/helpers');
var fetch = require('cross-fetch');
var tx$6 = require('@bnb-chain/greenfield-cosmos-types/greenfield/challenge/tx');
var tx$8 = require('@bnb-chain/greenfield-cosmos-types/cosmos/oracle/v1/tx');
var tx$7 = require('@bnb-chain/greenfield-cosmos-types/greenfield/bridge/tx');
var tx$9 = require('@bnb-chain/greenfield-cosmos-types/cosmos/feegrant/v1beta1/tx');
var signingKey = require('@ethersproject/signing-key');
var ed25519 = require('@noble/curves/ed25519');
var keccak_js = require('ethereum-cryptography/keccak.js');
var utils_js = require('ethereum-cryptography/utils.js');
var tx$3 = require('@bnb-chain/greenfield-cosmos-types/greenfield/payment/tx');
var gov = require('@bnb-chain/greenfield-cosmos-types/cosmos/gov/v1/gov');
var tx$a = require('@bnb-chain/greenfield-cosmos-types/cosmos/gov/v1/tx');
var fastXmlParser = require('fast-xml-parser');
var superagent = require('superagent');
var feegrant = require('@bnb-chain/greenfield-cosmos-types/cosmos/feegrant/v1beta1/feegrant');
var tx$b = require('@bnb-chain/greenfield-cosmos-types/cosmos/staking/v1beta1/tx');
var tx$4 = require('@bnb-chain/greenfield-cosmos-types/greenfield/virtualgroup/tx');
var keys = require('@bnb-chain/greenfield-cosmos-types/cosmos/crypto/secp256k1/keys');
var timestamp = require('@bnb-chain/greenfield-cosmos-types/google/protobuf/timestamp');
var types = require('@bnb-chain/greenfield-cosmos-types/greenfield/resource/types');
var dayjs = require('dayjs');
var utc = require('dayjs/plugin/utc');
var timezone = require('dayjs/plugin/timezone');
var units = require('@ethersproject/units');
var browserOrNode = require('browser-or-node');
var types$1 = require('@bnb-chain/greenfield-cosmos-types/greenfield/sp/types');
var utils = require('ethereum-cryptography/utils');
var service = require('@bnb-chain/greenfield-cosmos-types/cosmos/tx/v1beta1/service');
var tx$1 = require('@bnb-chain/greenfield-cosmos-types/cosmos/tx/v1beta1/tx');
var protoSigning = require('@cosmjs/proto-signing');
var auth = require('@bnb-chain/greenfield-cosmos-types/cosmos/auth/v1beta1/auth');
var tx$2 = require('@bnb-chain/greenfield-cosmos-types/cosmos/bank/v1beta1/tx');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n["default"] = e;
return Object.freeze(n);
}
var base64__namespace = /*#__PURE__*/_interopNamespace(base64);
var cloneDeep__default = /*#__PURE__*/_interopDefaultLegacy(cloneDeep);
var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
var mapValues__default = /*#__PURE__*/_interopDefaultLegacy(mapValues);
var set__default = /*#__PURE__*/_interopDefaultLegacy(set);
var sortBy__default = /*#__PURE__*/_interopDefaultLegacy(sortBy);
var Long__default = /*#__PURE__*/_interopDefaultLegacy(Long);
var common__namespace = /*#__PURE__*/_interopNamespace(common);
var common__namespace$1 = /*#__PURE__*/_interopNamespace(common$1);
var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
var superagent__default = /*#__PURE__*/_interopDefaultLegacy(superagent);
var timestamp__namespace = /*#__PURE__*/_interopNamespace(timestamp);
var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
var utc__default = /*#__PURE__*/_interopDefaultLegacy(utc);
var timezone__default = /*#__PURE__*/_interopDefaultLegacy(timezone);
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
const typeWrapper = (type, msg) => {
return Object.assign(Object.assign({}, msg), { type });
};
const generateMsg = (typeUrl, msgBytes) => {
return any.Any.fromPartial({
typeUrl,
value: msgBytes,
});
};
const createEIP712 = (types, chainId, message) => {
return {
types,
primaryType: 'Tx',
domain: {
name: 'Greenfield Tx',
version: '1.0.0',
chainId,
verifyingContract: '0x71e835aff094655dEF897fbc85534186DbeaB75d',
salt: '0',
},
message,
};
};
const generateMessage = (accountNumber, sequence, chainCosmosId, memo, fee, msg, timeoutHeight) => {
let res = {
account_number: accountNumber,
chain_id: chainCosmosId,
sequence,
memo,
fee,
timeout_height: timeoutHeight,
};
if (Object.keys(msg).length == 0) {
return res;
}
if (msg.hasOwnProperty('msg1')) {
res = Object.assign(Object.assign({}, res), msg);
}
else {
res.msg1 = msg;
}
return res;
};
const generateTypes = (newTypes) => {
const types = {
Coin: [
{ name: 'denom', type: 'string' },
{ name: 'amount', type: 'uint256' },
],
EIP712Domain: [
{ name: 'name', type: 'string' },
{ name: 'version', type: 'string' },
{ name: 'chainId', type: 'uint256' },
{ name: 'verifyingContract', type: 'string' },
{ name: 'salt', type: 'string' },
],
Fee: [
{ name: 'amount', type: 'Coin[]' },
{ name: 'gas_limit', type: 'uint256' },
{ name: 'payer', type: 'string' },
{ name: 'granter', type: 'string' },
],
Tx: [
{
name: 'account_number',
type: 'uint256',
},
{
name: 'chain_id',
type: 'uint256',
},
{
name: 'fee',
type: 'Fee',
},
{
name: 'memo',
type: 'string',
},
{
name: 'sequence',
type: 'uint256',
},
{
name: 'timeout_height',
type: 'uint256',
},
],
};
if (Array.isArray(newTypes)) {
for (let i = 0; i < newTypes.length; i++) {
types.Tx.push({
name: `msg${i + 1}`,
type: `Msg${i + 1}`,
});
}
Object.assign(types, ...newTypes);
}
else if (typeof newTypes === 'object') {
const msgLen = Object.keys(newTypes).filter((k) => k.startsWith('Msg')).length;
for (let i = 0; i < msgLen; i++) {
types.Tx.push({
name: `msg${i + 1}`,
type: `Msg${i + 1}`,
});
}
Object.assign(types, newTypes);
}
else {
types.Tx.push({
name: 'msg1',
type: 'Msg1',
});
Object.assign(types, newTypes);
}
return mapValues__default["default"](types, (o) => {
return sortBy__default["default"](o, ['name']);
});
};
const generateFee = (amount, denom, gas_limit, payer, granter) => {
return {
amount: [
{
amount,
denom,
},
],
gas_limit,
payer,
granter,
};
};
const mergeMultiEip712 = (eip712s) => {
const res = [];
eip712s.forEach((eip712, index) => {
if (index === 0) {
res.push(eip712);
}
else {
const str = JSON.stringify(eip712);
const reStr = str.replaceAll('Msg1', `Msg${index + 1}`);
res.push(JSON.parse(reStr));
}
});
return res;
};
const mergeMultiMessage = (txs) => {
const msgs = txs.map((tx) => tx.MsgSDK);
const res = {};
msgs.forEach((msg, index) => {
res[`msg${index + 1}`] = Object.assign(Object.assign({}, msg), { type: txs[index].typeUrl });
});
return res;
};
const findAnyType = (msgData) => {
const results = [];
function findTypeAnyFields(obj, path = []) {
if (typeof obj === 'object' && obj !== null) {
for (const key in obj) {
const newPath = [...path, key];
// console.log(newPath.join('.'));
if (key === 'value') {
results.push(newPath);
}
findTypeAnyFields(obj[key], newPath);
}
}
}
findTypeAnyFields(msgData);
return results;
};
const convertAnyTypeData = (msgData, fields) => {
const resData = cloneDeep__default["default"](msgData);
fields.forEach((field) => {
const path = field.join('.');
const anyValue = get__default["default"](resData, path);
// console.log('path', path, anyValue);
if (anyValue.startsWith('ZXl')) {
// TypeAny: need base64 decode
set__default["default"](resData, path, strings.toUtf8String(base64__namespace.decode(anyValue)));
}
else if (anyValue.startsWith('eyJ')) {
// TypeAny[]: need base64 decode and encode hex
set__default["default"](resData, path, bytes.hexlify(base64__namespace.decode(anyValue)));
}
else ;
});
return resData;
};
/**
* @priKey 0x prefix
*/
const getPubKeyByPriKey = (priKey) => {
const privateKeyBytes = bytes.arrayify(priKey);
const publicKeyBytes = secp256k1Compat.publicKeyCreate(privateKeyBytes);
const pk = bytes.hexlify(bytes.arrayify(publicKeyBytes));
const pubKey = makeCosmsPubKey(pk);
return pubKey;
};
/**
* recover public key from signature
*
* @messageHash message hash
* @signature message signature
*
* @returns uncompressed public key
*/
const recoverPk = ({ messageHash, signature }) => {
const uncompressedPubKey = signingKey.recoverPublicKey(messageHash, signature);
return signingKey.computePublicKey(uncompressedPubKey, true);
};
/**
* @pk compressed public key from signature
* @return eg. { typeUrl: '/ethermint.crypto.v1.ethsecp256k1.PubKey', value: 'CiEC+hp2uVKio9T7x0goOPyHgwUYiRsZ8MeYUrfRX8MxrzM=' }
*/
const makeCosmsPubKey = (pk) => {
const pubKey = keys.PubKey.fromPartial({
key: bytes.arrayify(pk),
});
return {
typeUrl: '/cosmos.crypto.eth.ethsecp256k1.PubKey',
value: keys.PubKey.encode(pubKey).finish(),
};
};
const eip712Hash = (message) => {
return ethSigUtil.TypedDataUtils.eip712Hash(JSON.parse(message), ethSigUtil.SignTypedDataVersion.V4);
};
/**
* @addr wallet address
* @message sign typed v4 data
*/
const sign712Tx = (addr, message) => __awaiter(void 0, void 0, void 0, function* () {
var _a;
// TODO: eth-sig-utils
/* eslint-disable @typescript-eslint/no-explicit-any */
const signature = yield ((_a = window.ethereum) === null || _a === void 0 ? void 0 : _a.request({
method: 'eth_signTypedData_v4',
params: [addr, message],
}));
const messageHash = eip712Hash(message);
return {
signature,
messageHash,
};
});
const defaultSignTypedData = (addr, message) => __awaiter(void 0, void 0, void 0, function* () {
var _b;
const signature = yield ((_b = window.ethereum) === null || _b === void 0 ? void 0 : _b.request({
method: 'eth_signTypedData_v4',
params: [addr, message],
}));
return signature;
});
const getGasFeeBySimulate = (simulateTxInfo, denom = 'BNB') => {
var _a, _b;
if (!simulateTxInfo.gasInfo)
throw new Error('gasInfo not found');
const gasLimit = BigInt((_a = simulateTxInfo.gasInfo) === null || _a === void 0 ? void 0 : _a.gasUsed.toNumber());
const gasPrice = (_b = simulateTxInfo.gasInfo) === null || _b === void 0 ? void 0 : _b.minGasPrice.replace(denom, '');
const gasFee = gasLimit * BigInt(gasPrice);
return {
gasLimit,
gasPrice,
gasFee: units.formatEther(String(gasFee)),
};
};
let RpcQueryClient = class RpcQueryClient {
constructor(rpcUrl) {
this.rpcUrl = rpcUrl;
this.rpcClient = null;
this.txQueryClient = null;
this.rpcUrl = rpcUrl;
}
getRpcClient() {
return __awaiter(this, void 0, void 0, function* () {
if (!this.rpcClient) {
this.rpcClient = yield makeRpcClient(this.rpcUrl);
}
return this.rpcClient;
});
}
getQueryClient() {
return __awaiter(this, void 0, void 0, function* () {
if (!this.txQueryClient) {
const [client] = yield makeClientWithExtension(this.rpcUrl);
this.txQueryClient = client;
}
return this.txQueryClient;
});
}
getAuthQueryClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query.QueryClientImpl(rpcClient);
});
}
getBankQueryClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query$1.QueryClientImpl(rpcClient);
});
}
getPaymentQueryClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query$2.QueryClientImpl(rpcClient);
});
}
getSpQueryClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query$3.QueryClientImpl(rpcClient);
});
}
getChallengeQueryClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query$4.QueryClientImpl(rpcClient);
});
}
getCrosschainQueryClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query$5.QueryClientImpl(rpcClient);
});
}
getOracleQueryClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query$6.QueryClientImpl(rpcClient);
});
}
getBridgeQueryClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query$7.QueryClientImpl(rpcClient);
});
}
getFeeGrantQueryClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query$8.QueryClientImpl(rpcClient);
});
}
getStorageQueryClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query$9.QueryClientImpl(rpcClient);
});
}
getMsgClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new tx.MsgClientImpl(rpcClient);
});
}
getGashubClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query$a.QueryClientImpl(rpcClient);
});
}
getVirtualGroupClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query$b.QueryClientImpl(rpcClient);
});
}
getStakingClient() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.getRpcClient();
return new query$c.QueryClientImpl(rpcClient);
});
}
};
RpcQueryClient = __decorate([
tsyringe.injectable(),
__param(0, tsyringe.inject('RPC_URL')),
__metadata("design:paramtypes", [String])
], RpcQueryClient);
const makeClientWithExtension = (rpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
const tmClient = yield tendermintRpc.Tendermint37Client.connect(rpcUrl);
return [
stargate.QueryClient.withExtensions(tmClient, stargate.setupAuthExtension, stargate.setupAuthzExtension, stargate.setupBankExtension, stargate.setupDistributionExtension, stargate.setupFeegrantExtension, stargate.setupGovExtension, stargate.setupIbcExtension, stargate.setupMintExtension, stargate.setupSlashingExtension, stargate.setupStakingExtension, stargate.setupTxExtension),
tmClient,
];
});
const makeRpcClient = (rpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
const [, tmClient] = yield makeClientWithExtension(rpcUrl);
const rpc = stargate.createProtobufRpcClient(new stargate.QueryClient(tmClient));
return rpc;
});
const MsgSendTypeUrl = '/cosmos.bank.v1beta1.MsgSend';
const MsgMultiSendTypeUrl = '/cosmos.bank.v1beta1.MsgMultiSend';
const MsgClaimTypeUrl = '/cosmos.oracle.v1.MsgClaim';
const MsgGrantAllowanceTypeUrl = '/cosmos.feegrant.v1beta1.MsgGrantAllowance';
const MsgRevokeAllowanceTypeUrl = '/cosmos.feegrant.v1beta1.MsgRevokeAllowance';
const MsgTransferOutTypeUrl = '/greenfield.bridge.MsgTransferOut';
const MsgAttestTypeUrl = '/greenfield.challenge.MsgAttest';
const MsgSubmitTypeUrl = '/greenfield.challenge.MsgSubmit';
const MsgCreatePaymentAccountTypeUrl = '/greenfield.payment.MsgCreatePaymentAccount';
const MsgDepositTypeUrl = '/greenfield.payment.MsgDeposit';
const MsgDisableRefundTypeUrl = '/greenfield.payment.MsgDisableRefund';
const MsgWithdrawTypeUrl = '/greenfield.payment.MsgWithdraw';
const MsgCancelCreateObjectTypeUrl = '/greenfield.storage.MsgCancelCreateObject';
const MsgMigrateBucketTypeUrl = '/greenfield.storage.MsgMigrateBucket';
const MsgCancelMigrateBucketTypeUrl = '/greenfield.storage.MsgCancelMigrateBucket';
const MsgCreateBucketTypeUrl = '/greenfield.storage.MsgCreateBucket';
const MsgCreateGroupTypeUrl = '/greenfield.storage.MsgCreateGroup';
const MsgCreateObjectTypeUrl = '/greenfield.storage.MsgCreateObject';
const MsgDeleteBucketTypeUrl = '/greenfield.storage.MsgDeleteBucket';
const MsgDeleteGroupTypeUrl = '/greenfield.storage.MsgDeleteGroup';
const MsgDeleteObjectTypeUrl = '/greenfield.storage.MsgDeleteObject';
const MsgDeletePolicyTypeUrl = '/greenfield.storage.MsgDeletePolicy';
const MsgSetTagTypeUrl = '/greenfield.storage.MsgSetTag';
const MsgToggleSPAsDelegatedAgentTypeUrl = '/greenfield.storage.MsgToggleSPAsDelegatedAgent';
const MsgLeaveGroupTypeUrl = '/greenfield.storage.MsgLeaveGroup';
const MsgMirrorBucketTypeUrl = '/greenfield.storage.MsgMirrorBucket';
const MsgMirrorGroupTypeUrl = '/greenfield.storage.MsgMirrorGroup';
const MsgMirrorObjectTypeUrl = '/greenfield.storage.MsgMirrorObject';
const MsgPutPolicyTypeUrl = '/greenfield.storage.MsgPutPolicy';
const MsgUpdateBucketInfoTypeUrl = '/greenfield.storage.MsgUpdateBucketInfo';
const MsgUpdateGroupExtraTypeUrl = '/greenfield.storage.MsgUpdateGroupExtra';
const MsgUpdateGroupMemberTypeUrl = '/greenfield.storage.MsgUpdateGroupMember';
const MsgUpdateObjectInfoTypeUrl = '/greenfield.storage.MsgUpdateObjectInfo';
const BasicAllowanceTypeUrl = '/cosmos.feegrant.v1beta1.BasicAllowance';
const AllowedMsgAllowanceTypeUrl = '/cosmos.feegrant.v1beta1.AllowedMsgAllowance';
const MsgEditValidatorTypeUrl = '/cosmos.staking.v1beta1.MsgEditValidator';
const MsgCreateValidatorTypeUrl = '/cosmos.staking.v1beta1.MsgCreateValidator';
const MsgVoteTypeUrl = '/cosmos.gov.v1.MsgVote';
const MsgSetBucketFlowRateLimitTypeUrl = '/greenfield.storage.MsgSetBucketFlowRateLimit';
const MsgSubmitProposalTypeUrl = '/cosmos.gov.v1.MsgSubmitProposal';
const MsgWithdrawDelegatorRewardTypeUrl = '/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward';
const MsgSetWithdrawAddressTypeUrl = '/cosmos.distribution.v1beta1.MsgSetWithdrawAddress';
const MsgWithdrawValidatorCommissionTypeUrl = '/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission';
const MsgFundCommunityPoolTypeUrl = '/cosmos.distribution.v1beta1.MsgFundCommunityPool';
const MsgSettleTypeUrl = '/greenfield.virtualgroup.MsgSettle';
const EMPTY_STRING_SHA256 = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855';
const NORMAL_ERROR_CODE = 404;
const METHOD_GET = 'GET';
const METHOD_POST = 'POST';
const METHOD_PUT = 'PUT';
// SPECIAL ERROR CODE
const SP_NOT_AVAILABLE_ERROR_CODE = 429;
// SPECIAL ERROR MESSAGE
const SP_NOT_AVAILABLE_ERROR_MSG = 'SP not available';
const ZERO_PUBKEY = '0x000000000000000000000000000000000000000000000000000000000000000000';
const DEFAULT_DENOM = 'BNB';
// 32 MB
const DEFAULT_PART_SIZE = 1024 * 1024 * 32;
let TxClient = class TxClient {
constructor(rpcUrl, chainId) {
this.account = tsyringe.container.resolve(Account);
this.rpcQueryClient = tsyringe.container.resolve(RpcQueryClient);
this.rpcUrl = rpcUrl;
this.chainId = chainId;
}
tx(typeUrl, address, MsgSDKTypeEIP712, MsgSDK, msgBytes) {
return __awaiter(this, void 0, void 0, function* () {
const txBodyBytes = this.getBodyBytes([
{
typeUrl,
msgBytes,
},
]);
const tx = yield this.multiTx([
{
metaTxInfo: {
typeUrl,
address,
MsgSDKTypeEIP712,
MsgSDK,
msgBytes,
bodyBytes: txBodyBytes,
},
},
]);
return {
simulate: tx.simulate,
broadcast: tx.broadcast,
metaTxInfo: {
typeUrl,
address,
MsgSDKTypeEIP712,
MsgSDK,
msgBytes,
bodyBytes: txBodyBytes,
},
};
});
}
txRaw({ address, txRawHex, eip712MsgType, msgData, }) {
return __awaiter(this, void 0, void 0, function* () {
const accountInfo = yield this.account.getAccount(address);
const txRawBytes = bytes.arrayify(txRawHex);
const txRawData = tx$1.TxRaw.decode(txRawBytes);
return {
simulate: (opts) => __awaiter(this, void 0, void 0, function* () {
return yield this.simulateRawTx(txRawData.bodyBytes, accountInfo, opts);
}),
broadcast: (opts) => __awaiter(this, void 0, void 0, function* () {
const { denom, gasLimit, gasPrice, payer, granter, privateKey, signTypedDataCallback = defaultSignTypedData, } = opts;
const fee = generateFee(String(BigInt(gasLimit) * BigInt(gasPrice)), denom, String(gasLimit), payer, granter);
// console.log('eip712MsgType', eip712MsgType);
const wrapperTypes = generateTypes(eip712MsgType);
// find type any and convert
const anyFields = findAnyType(msgData);
// console.log('anyFields', anyFields);
const convertedMsg = convertAnyTypeData(msgData, anyFields);
const messages = generateMessage(accountInfo.accountNumber.toString(), accountInfo.sequence.toString(), this.chainId, '', fee, convertedMsg, '0');
const eip712 = createEIP712(wrapperTypes, this.chainId, messages);
// console.log('eip712', eip712);
const { pubKey, signature } = privateKey
? this.getSignByPriKey(eip712, privateKey)
: yield this.getSignByWallet(eip712, accountInfo.address, signTypedDataCallback);
const authInfoBytes = this.getAuthInfoBytes({
denom,
sequence: accountInfo.sequence + '',
gasLimit,
gasPrice,
pubKey,
granter,
payer,
});
const txRaw = tx$1.TxRaw.fromPartial({
bodyBytes: txRawData.bodyBytes,
authInfoBytes,
signatures: [bytes.arrayify(signature)],
});
const txBytes = tx$1.TxRaw.encode(txRaw).finish();
// console.log('txBytes', hexlify(txBytes));
return yield this.broadcastRawTx(txBytes);
}),
};
});
}
getBodyBytes(params) {
const multiMsgBytes = params.map((tx) => {
return generateMsg(tx.typeUrl, tx.msgBytes);
});
const txBody = tx$1.TxBody.fromPartial({
messages: multiMsgBytes,
});
const txBodyBytes = tx$1.TxBody.encode(txBody).finish();
return txBodyBytes;
}
getSignByPriKey(eip712, privateKey) {
assertPrivateKey(privateKey);
const pubKey = getPubKeyByPriKey(privateKey);
const signature = ethSigUtil.signTypedData({
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
data: eip712,
version: ethSigUtil.SignTypedDataVersion.V4,
privateKey: Buffer.from(bytes.arrayify(privateKey)),
});
return {
pubKey,
signature,
};
}
getSignByWallet(eip712, address, signTypedDataCallback) {
return __awaiter(this, void 0, void 0, function* () {
const signature = yield signTypedDataCallback(address, JSON.stringify(eip712));
const messageHash = eip712Hash(JSON.stringify(eip712));
// console.log('eip712 hash', hexlify(messageHash));
const pk = recoverPk({
signature,
messageHash,
});
const pubKey = makeCosmsPubKey(pk);
return {
pubKey,
signature,
};
});
}
getAuthInfoBytes(params) {
const { pubKey, denom = DEFAULT_DENOM, sequence, gasLimit, gasPrice, granter, payer } = params;
if (!pubKey)
throw new Error('pubKey is required');
const feeAmount = [
{
denom,
amount: String(BigInt(gasLimit) * BigInt(gasPrice)),
},
];
const authInfoBytes = protoSigning.makeAuthInfoBytes([{ pubkey: pubKey, sequence: Number(sequence) }], feeAmount, gasLimit, granter, payer,
// @ts-ignore
712);
return authInfoBytes;
}
simulateRawTx(txBodyBytes, accountInfo, options) {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.rpcQueryClient.getRpcClient();
const rpc = new service.ServiceClientImpl(rpcClient);
const { denom } = options;
const authInfoBytes = this.getAuthInfoBytes({
sequence: accountInfo.sequence + '',
denom,
gasLimit: 0,
gasPrice: '0',
pubKey: makeCosmsPubKey(ZERO_PUBKEY),
granter: '',
payer: '',
});
const tx = tx$1.Tx.fromPartial({
authInfo: tx$1.AuthInfo.decode(authInfoBytes),
body: tx$1.TxBody.decode(txBodyBytes),
signatures: [Uint8Array.from([])],
});
const request = service.SimulateRequest.fromPartial({
txBytes: tx$1.Tx.encode(tx).finish(),
});
const res = yield rpc.Simulate(request);
return getGasFeeBySimulate(res, denom);
});
}
broadcastRawTx(txRawBytes) {
return __awaiter(this, void 0, void 0, function* () {
const tmClient = yield tendermintRpc.Tendermint37Client.connect(this.rpcUrl);
const client = yield stargate.StargateClient.create(tmClient);
return yield client.broadcastTx(txRawBytes);
});
}
multiTx(txResList) {
return __awaiter(this, void 0, void 0, function* () {
const txs = txResList.map((txRes) => txRes.metaTxInfo);
const accountInfo = yield this.account.getAccount(txs[0].address);
const txBodyBytes = this.getBodyBytes(txs);
return {
simulate: (opts) => __awaiter(this, void 0, void 0, function* () {
return yield this.simulateRawTx(txBodyBytes, accountInfo, opts);
}),
broadcast: (opts) => __awaiter(this, void 0, void 0, function* () {
const { denom, gasLimit, gasPrice, payer, granter, privateKey, signTypedDataCallback = defaultSignTypedData, } = opts;
const types = mergeMultiEip712(txs.map((tx) => tx.MsgSDKTypeEIP712));
const fee = generateFee(String(BigInt(gasLimit) * BigInt(gasPrice)), denom, String(gasLimit), payer, granter);
const wrapperTypes = generateTypes(types);
const multiMessages = mergeMultiMessage(txs);
const messages = generateMessage(accountInfo.accountNumber.toString(), accountInfo.sequence.toString(), this.chainId, '', fee, multiMessages, '0');
const eip712 = createEIP712(wrapperTypes, this.chainId, messages);
// console.log('eip712', eip712);
const { pubKey, signature } = privateKey
? this.getSignByPriKey(eip712, privateKey)
: yield this.getSignByWallet(eip712, accountInfo.address, signTypedDataCallback);
const authInfoBytes = this.getAuthInfoBytes({
denom,
sequence: accountInfo.sequence + '',
gasLimit,
gasPrice,
pubKey,
granter,
payer,
});
const txRaw = tx$1.TxRaw.fromPartial({
bodyBytes: txBodyBytes,
authInfoBytes,
signatures: [bytes.arrayify(signature)],
});
const txBytes = tx$1.TxRaw.encode(txRaw).finish();
// console.log('txBytes', hexlify(txBytes));
return yield this.broadcastRawTx(txBytes);
}),
};
});
}
};
TxClient = __decorate([
tsyringe.injectable(),
__param(0, tsyringe.inject('RPC_URL')),
__param(1, tsyringe.inject('CHAIN_ID')),
__metadata("design:paramtypes", [String, String])
], TxClient);
const MsgMultiSendSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'inputs',
type: 'TypeMsg1Inputs[]',
},
{
name: 'outputs',
type: 'TypeMsg1Outputs[]',
},
],
TypeMsg1Inputs: [
{
name: 'address',
type: 'string',
},
{
name: 'coins',
type: 'TypeMsg1InputsCoins[]',
},
],
TypeMsg1InputsCoins: [
{
name: 'denom',
type: 'string',
},
{
name: 'amount',
type: 'string',
},
],
TypeMsg1Outputs: [
{
name: 'address',
type: 'string',
},
{
name: 'coins',
type: 'TypeMsg1OutputsCoins[]',
},
],
TypeMsg1OutputsCoins: [
{
name: 'denom',
type: 'string',
},
{
name: 'amount',
type: 'string',
},
],
};
const MsgSendSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'from_address',
type: 'string',
},
{
name: 'to_address',
type: 'string',
},
{
name: 'amount',
type: 'TypeMsg1Amount[]',
},
],
TypeMsg1Amount: [
{
name: 'denom',
type: 'string',
},
{
name: 'amount',
type: 'string',
},
],
};
const MsgCreatePaymentAccountSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'creator',
type: 'string',
},
],
};
let Account = class Account {
constructor(txClient) {
this.txClient = txClient;
this.queryClient = tsyringe.container.resolve(RpcQueryClient);
}
multiTransfer(address, msg) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.txClient.tx(MsgMultiSendTypeUrl, address, MsgMultiSendSDKTypeEIP712, tx$2.MsgMultiSend.toSDK(msg), tx$2.MsgMultiSend.encode(msg).finish());
});
}
createPaymentAccount(msg) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.txClient.tx(MsgCreatePaymentAccountTypeUrl, msg.creator, MsgCreatePaymentAccountSDKTypeEIP712, tx$3.MsgCreatePaymentAccount.toSDK(msg), tx$3.MsgCreatePaymentAccount.encode(msg).finish());
});
}
getPaymentAccountsByOwner(owner) {
return __awaiter(this, void 0, void 0, function* () {
const rpc = yield this.queryClient.getPaymentQueryClient();
return yield rpc.PaymentAccountsByOwner({
owner,
});
});
}
getModuleAccountByName(name) {
return __awaiter(this, void 0, void 0, function* () {
const rpc = yield this.queryClient.getAuthQueryClient();
return rpc.ModuleAccountByName({
name,
});
});
}
getModuleAccounts() {
return __awaiter(this, void 0, void 0, function* () {
const rpc = yield this.queryClient.getAuthQueryClient();
return yield rpc.ModuleAccounts();
});
}
getAccountBalance(request) {
return __awaiter(this, void 0, void 0, function* () {
const rpc = yield this.queryClient.getBankQueryClient();
return yield rpc.Balance(request);
});
}
getAccount(address) {
return __awaiter(this, void 0, void 0, function* () {
const client = yield this.queryClient.getQueryClient();
const account = yield client.auth.account(address);
if (!account)
return auth.BaseAccount.fromJSON({});
return auth.BaseAccount.toJSON(auth.BaseAccount.decode(account.value));
});
}
transfer(msg) {
return __awaiter(this, void 0, void 0, function* () {
return yield this.txClient.tx(MsgSendTypeUrl, msg.fromAddress, MsgSendSDKTypeEIP712, tx$2.MsgSend.toSDK(msg), tx$2.MsgSend.encode(msg).finish());
});
}
};
Account = __decorate([
tsyringe.injectable(),
__param(0, tsyringe.inject(tsyringe.delay(() => TxClient))),
__metadata("design:paramtypes", [TxClient])
], Account);
let Basic = class Basic {
constructor() {
this.rpcQueryClient = tsyringe.container.resolve(RpcQueryClient);
}
getNodeInfo() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.rpcQueryClient.getRpcClient();
const rpc = new query$d.ServiceClientImpl(rpcClient);
return yield rpc.GetNodeInfo();
});
}
getLatestBlock() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.rpcQueryClient.getRpcClient();
const rpc = new query$d.ServiceClientImpl(rpcClient);
return yield rpc.GetLatestBlock();
});
}
getLatestBlockHeight() {
var _a, _b;
return __awaiter(this, void 0, void 0, function* () {
const latestBlock = yield this.getLatestBlock();
const height = (_b = (_a = latestBlock.sdkBlock) === null || _a === void 0 ? void 0 : _a.header) === null || _b === void 0 ? void 0 : _b.height;
if (!height)
return 0;
return height.toNumber();
});
}
getSyncing() {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.rpcQueryClient.getRpcClient();
const rpc = new query$d.ServiceClientImpl(rpcClient);
const syncing = yield rpc.GetSyncing();
return syncing.syncing;
});
}
getBlockByHeight(height) {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.rpcQueryClient.getRpcClient();
const rpc = new query$d.ServiceClientImpl(rpcClient);
return yield rpc.GetBlockByHeight({
height: Long__default["default"].fromInt(height),
});
});
}
GetLatestValidatorSet(request) {
return __awaiter(this, void 0, void 0, function* () {
const rpcClient = yield this.rpcQueryClient.getRpcClient();
const rpc = new query$d.ServiceClientImpl(rpcClient);
const validatorSet = yield rpc.GetLatestValidatorSet(request);
return validatorSet.blockHeight.toNumber();
});
}
};
Basic = __decorate([
tsyringe.injectable()
], Basic);
const MsgTransferOutSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'from',
type: 'string',
},
{
name: 'to',
type: 'string',
},
{
name: 'amount',
type: 'TypeMsg1Amount',
},
],
TypeMsg1Amount: [
{
name: 'denom',
type: 'string',
},
{
name: 'amount',
type: 'string',
},
],
};
const MsgAttestSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'submitter',
type: 'string',
},
{
name: 'challenge_id',
type: 'uint64',
},
{
name: 'object_id',
type: 'string',
},
{
name: 'sp_operator_address',
type: 'string',
},
{
name: 'vote_result',
type: 'string',
},
{
name: 'challenger_address',
type: 'string',
},
],
};
const MsgSubmitSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'challenger',
type: 'string',
},
{
name: 'sp_operator_address',
type: 'string',
},
{
name: 'bucket_name',
type: 'string',
},
{
name: 'object_name',
type: 'string',
},
{
name: 'segment_index',
type: 'uint32',
},
{
name: 'random_index',
type: 'bool',
},
],
};
const MsgDepositSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'creator',
type: 'string',
},
{
name: 'to',
type: 'string',
},
{
name: 'amount',
type: 'string',
},
],
};
const MsgDisableRefundSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'owner',
type: 'string',
},
{
name: 'addr',
type: 'string',
},
],
};
const MsgWithdrawSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'creator',
type: 'string',
},
{
name: 'from',
type: 'string',
},
{
name: 'amount',
type: 'string',
},
],
};
const MsgCancelCreateObjectSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'operator',
type: 'string',
},
{
name: 'bucket_name',
type: 'string',
},
{
name: 'object_name',
type: 'string',
},
],
};
const MsgCreateBucketSDKTypeEIP712 = {
Msg1: [
{
name: 'bucket_name',
type: 'string',
},
{
name: 'charged_read_quota',
type: 'uint64',
},
{
name: 'creator',
type: 'string',
},
{
name: 'payment_address',
type: 'string',
},
{
name: 'primary_sp_address',
type: 'string',
},
{
name: 'primary_sp_approval',
type: 'TypeMsg1PrimarySpApproval',
},
{
name: 'type',
type: 'string',
},
{
name: 'visibility',
type: 'string',
},
],
TypeMsg1PrimarySpApproval: [
{
name: 'expired_height',
type: 'uint64',
},
{
name: 'global_virtual_group_family_id',
type: 'uint32',
},
// {
// name: 'sig',
// type: 'bytes',
// },
],
};
const MsgCreateGroupSDKTypeEIP712 = {
Msg1: [
{
name: 'creator',
type: 'string',
},
{
name: 'extra',
type: 'string',
},
{
name: 'group_name',
type: 'string',
},
{
name: 'type',
type: 'string',
},
],
};
const MsgCreateObjectSDKTypeEIP712 = {
Msg1: [
{
name: 'bucket_name',
type: 'string',
},
{
name: 'content_type',
type: 'string',
},
{
name: 'creator',
type: 'string',
},
{
name: 'expect_checksums',
type: 'bytes[]',
},
{
name: 'object_name',
type: 'string',
},
{
name: 'payload_size',
type: 'uint64',
},
{
name: 'primary_sp_approval',
type: 'TypeMsg1PrimarySpApproval',
},
{
name: 'redundancy_type',
type: 'string',
},
{
name: 'type',
type: 'string',
},
{
name: 'visibility',
type: 'string',
},
],
TypeMsg1PrimarySpApproval: [
{
name: 'expired_height',
type: 'uint64',
},
{
name: 'global_virtual_group_family_id',
type: 'uint32',
},
// {
// name: 'sig',
// type: 'bytes',
// },
],
};
const MsgDeleteBucketSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'operator',
type: 'string',
},
{
name: 'bucket_name',
type: 'string',
},
],
};
const MsgDeleteGroupSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'operator',
type: 'string',
},
{
name: 'group_name',
type: 'string',
},
],
};
const MsgDeleteObjectSDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'operator',
type: 'string',
},
{
name: 'bucket_name',
type: 'string',
},
{
name: 'object_name',
type: 'string',
},
],
};
const MsgDeletePolicySDKTypeEIP712 = {
Msg1: [
{
name: 'type',
type: 'string',
},
{
name: 'operator',
type: 'string',
},
{
name: 'resource',
type: 'string',
},
{
name: 'principal',
type: 'TypeMsg1Principal',
},
],
TypeMsg1Principal