@injectivelabs/sdk-ts 1.15.0 → 1.15.2

package/dist/cjs/client/chain/rest/ChainRestTendermintApi.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainRestTendermintApi = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+const BaseRestConsumer_js_1 = __importDefault(require("../../base/BaseRestConsumer.js"));
+const index_js_1 = require("../types/index.js");
+/**
+ * @category Chain Rest API
+ */
+class ChainRestTendermintApi extends BaseRestConsumer_js_1.default {
+    async fetchLatestBlock(params = {}) {
+        const endpoint = `cosmos/base/tendermint/v1beta1/blocks/latest`;
+        try {
+            const response = await this.retry(() => this.get(endpoint, params));
+            return response.data.block;
+        }
+        catch (e) {
+            if (e instanceof exceptions_1.HttpRequestException) {
+                throw e;
+            }
+            throw new exceptions_1.HttpRequestException(new Error(e), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: `${this.endpoint}/${endpoint}`,
+                contextModule: index_js_1.ChainModule.Tendermint,
+            });
+        }
+    }
+    async fetchNodeInfo(params = {}) {
+        const endpoint = `cosmos/base/tendermint/v1beta1/node_info`;
+        try {
+            const response = await this.retry(() => this.get(endpoint, params));
+            return {
+                nodeInfo: response.data.default_node_info,
+                applicationVersion: response.data.application_version,
+            };
+        }
+        catch (e) {
+            if (e instanceof exceptions_1.HttpRequestException) {
+                throw e;
+            }
+            throw new exceptions_1.HttpRequestException(new Error(e), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: `${this.endpoint}/${endpoint}`,
+                contextModule: index_js_1.ChainModule.Tendermint,
+            });
+        }
+    }
+}
+exports.ChainRestTendermintApi = ChainRestTendermintApi;

package/dist/cjs/client/chain/rest/ChainRestWasmApi.d.ts

@@ -0,0 +1,8 @@
+import BaseRestConsumer from '../../base/BaseRestConsumer.js';
+export type SmartContractStateResponse = unknown;
+/**
+ * @category Chain Wasm API
+ */
+export declare class ChainRestWasmApi extends BaseRestConsumer {
+    fetchSmartContractState(contractAddress: string, query: string, params?: Record<string, any>): Promise<SmartContractStateResponse>;
+}

package/dist/cjs/client/chain/rest/ChainRestWasmApi.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainRestWasmApi = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+const BaseRestConsumer_js_1 = __importDefault(require("../../base/BaseRestConsumer.js"));
+const index_js_1 = require("../types/index.js");
+/**
+ * @category Chain Wasm API
+ */
+class ChainRestWasmApi extends BaseRestConsumer_js_1.default {
+    async fetchSmartContractState(contractAddress, query, params = {}) {
+        const endpoint = `cosmwasm/wasm/v1/contract/${contractAddress}/smart/${query}`;
+        try {
+            const response = await this.retry(() => this.get(endpoint, params));
+            return response.data;
+        }
+        catch (e) {
+            if (e instanceof exceptions_1.HttpRequestException) {
+                throw e;
+            }
+            throw new exceptions_1.HttpRequestException(new Error(e), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: `${this.endpoint}/${endpoint}`,
+                contextModule: index_js_1.ChainModule.Bank,
+            });
+        }
+    }
+}
+exports.ChainRestWasmApi = ChainRestWasmApi;

package/dist/cjs/client/chain/rest/index.d.ts

@@ -0,0 +1,4 @@
+export { ChainRestBankApi } from './ChainRestBankApi.js';
+export { ChainRestAuthApi } from './ChainRestAuthApi.js';
+export { ChainRestWasmApi } from './ChainRestWasmApi.js';
+export { ChainRestTendermintApi } from './ChainRestTendermintApi.js';

package/dist/cjs/client/chain/rest/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainRestTendermintApi = exports.ChainRestWasmApi = exports.ChainRestAuthApi = exports.ChainRestBankApi = void 0;
+var ChainRestBankApi_js_1 = require("./ChainRestBankApi.js");
+Object.defineProperty(exports, "ChainRestBankApi", { enumerable: true, get: function () { return ChainRestBankApi_js_1.ChainRestBankApi; } });
+var ChainRestAuthApi_js_1 = require("./ChainRestAuthApi.js");
+Object.defineProperty(exports, "ChainRestAuthApi", { enumerable: true, get: function () { return ChainRestAuthApi_js_1.ChainRestAuthApi; } });
+var ChainRestWasmApi_js_1 = require("./ChainRestWasmApi.js");
+Object.defineProperty(exports, "ChainRestWasmApi", { enumerable: true, get: function () { return ChainRestWasmApi_js_1.ChainRestWasmApi; } });
+var ChainRestTendermintApi_js_1 = require("./ChainRestTendermintApi.js");
+Object.defineProperty(exports, "ChainRestTendermintApi", { enumerable: true, get: function () { return ChainRestTendermintApi_js_1.ChainRestTendermintApi; } });

package/dist/cjs/client/chain/transformers/ChainGrpcAuctionTransformer.d.ts

@@ -0,0 +1,13 @@
+import { AuctionBid, GrpcAuctionBid, AuctionModuleState, AuctionCurrentBasket, AuctionModuleStateParams, AuctionLastAuctionResult, GrpcAuctionLastAuctionResult } from '../types/auction.js';
+import { InjectiveAuctionV1Beta1Query } from '@injectivelabs/core-proto-ts';
+/**
+ * @category Chain Grpc Transformer
+ */
+export declare class ChainGrpcAuctionTransformer {
+    static grpcBidToBid(grpcBid: GrpcAuctionBid): AuctionBid;
+    static grpcLastAuctionResultToLastAuctionResult(grpcLastAuctionResult: GrpcAuctionLastAuctionResult): AuctionLastAuctionResult;
+    static moduleParamsResponseToModuleParams(response: InjectiveAuctionV1Beta1Query.QueryAuctionParamsResponse): AuctionModuleStateParams;
+    static currentBasketResponseToCurrentBasket(response: InjectiveAuctionV1Beta1Query.QueryCurrentAuctionBasketResponse): AuctionCurrentBasket;
+    static auctionModuleStateResponseToAuctionModuleState(response: InjectiveAuctionV1Beta1Query.QueryModuleStateResponse): AuctionModuleState;
+    static LastAuctionResultResponseToLastAuctionResult(response: InjectiveAuctionV1Beta1Query.QueryLastAuctionResultResponse): AuctionLastAuctionResult | undefined;
+}

package/dist/cjs/client/chain/transformers/ChainGrpcAuctionTransformer.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainGrpcAuctionTransformer = void 0;
+const ChainGrpcCommonTransformer_js_1 = require("./ChainGrpcCommonTransformer.js");
+/**
+ * @category Chain Grpc Transformer
+ */
+class ChainGrpcAuctionTransformer {
+    static grpcBidToBid(grpcBid) {
+        return {
+            bidder: grpcBid.bidder,
+            amount: grpcBid.amount
+                ? ChainGrpcCommonTransformer_js_1.ChainGrpcCommonTransformer.grpcCoinToCoin(grpcBid.amount)
+                : undefined,
+        };
+    }
+    static grpcLastAuctionResultToLastAuctionResult(grpcLastAuctionResult) {
+        return {
+            winner: grpcLastAuctionResult.winner,
+            amount: grpcLastAuctionResult.amount
+                ? ChainGrpcCommonTransformer_js_1.ChainGrpcCommonTransformer.grpcCoinToCoin(grpcLastAuctionResult.amount)
+                : undefined,
+            round: grpcLastAuctionResult.round,
+        };
+    }
+    static moduleParamsResponseToModuleParams(response) {
+        const params = response.params;
+        return {
+            auctionPeriod: parseInt(params?.auctionPeriod || '0', 10),
+            minNextBidIncrementRate: params?.minNextBidIncrementRate || '0',
+        };
+    }
+    static currentBasketResponseToCurrentBasket(response) {
+        return {
+            amountList: response.amount.map(ChainGrpcCommonTransformer_js_1.ChainGrpcCommonTransformer.grpcCoinToCoin),
+            auctionRound: parseInt(response.auctionRound, 10),
+            auctionClosingTime: parseInt(response.auctionClosingTime, 10),
+            highestBidder: response.highestBidAmount,
+            highestBidAmount: response.highestBidAmount,
+        };
+    }
+    static auctionModuleStateResponseToAuctionModuleState(response) {
+        const state = response.state;
+        const params = state.params;
+        return {
+            params: {
+                auctionPeriod: parseInt(params.auctionPeriod, 10),
+                minNextBidIncrementRate: params.minNextBidIncrementRate,
+            },
+            auctionRound: parseInt(state.auctionRound, 10),
+            highestBid: state.highestBid
+                ? ChainGrpcAuctionTransformer.grpcBidToBid(state.highestBid)
+                : undefined,
+            auctionEndingTimestamp: parseInt(state.auctionEndingTimestamp, 10),
+            lastAuctionResult: state.lastAuctionResult
+                ? ChainGrpcAuctionTransformer.grpcLastAuctionResultToLastAuctionResult(state.lastAuctionResult)
+                : undefined,
+        };
+    }
+    static LastAuctionResultResponseToLastAuctionResult(response) {
+        if (!response.lastAuctionResult) {
+            return;
+        }
+        return ChainGrpcAuctionTransformer.grpcLastAuctionResultToLastAuctionResult(response.lastAuctionResult);
+    }
+}
+exports.ChainGrpcAuctionTransformer = ChainGrpcAuctionTransformer;

package/dist/cjs/client/chain/transformers/ChainGrpcAuthTransformer.d.ts

@@ -0,0 +1,14 @@
+import { Account, AuthModuleParams } from '../types/auth.js';
+import { GoogleProtobufAny, CosmosAuthV1Beta1Query } from '@injectivelabs/core-proto-ts';
+/**
+ * @category Chain Grpc Transformer
+ */
+export declare class ChainGrpcAuthTransformer {
+    static moduleParamsResponseToModuleParams(response: CosmosAuthV1Beta1Query.QueryParamsResponse): AuthModuleParams;
+    static grpcAccountToAccount(ethAccount: GoogleProtobufAny.Any): Account;
+    static accountResponseToAccount(response: CosmosAuthV1Beta1Query.QueryAccountResponse): Account;
+    static accountsResponseToAccounts(response: CosmosAuthV1Beta1Query.QueryAccountsResponse): {
+        pagination: import("../../../index.js").Pagination;
+        accounts: Account[];
+    };
+}

package/dist/cjs/client/chain/transformers/ChainGrpcAuthTransformer.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainGrpcAuthTransformer = void 0;
+const pagination_js_1 = require("../../../utils/pagination.js");
+const index_js_1 = require("../../../utils/index.js");
+const core_proto_ts_1 = require("@injectivelabs/core-proto-ts");
+/**
+ * @category Chain Grpc Transformer
+ */
+class ChainGrpcAuthTransformer {
+    static moduleParamsResponseToModuleParams(response) {
+        const params = response.params;
+        return {
+            maxMemoCharacters: parseInt(params.maxMemoCharacters, 10),
+            txSigLimit: parseInt(params.txSigLimit, 10),
+            txSizeCostPerByte: parseInt(params.txSizeCostPerByte, 10),
+            sigVerifyCostEd25519: parseInt(params.sigVerifyCostEd25519, 10),
+            sigVerifyCostSecp256k1: parseInt(params.sigVerifyCostSecp256k1, 10),
+        };
+    }
+    static grpcAccountToAccount(ethAccount) {
+        const account = core_proto_ts_1.InjectiveTypesV1Beta1Account.EthAccount.decode(ethAccount.value);
+        const baseAccount = account.baseAccount;
+        const pubKey = baseAccount.pubKey;
+        return {
+            codeHash: (0, index_js_1.uint8ArrayToString)(account.codeHash),
+            baseAccount: {
+                address: baseAccount.address,
+                pubKey: pubKey
+                    ? {
+                        key: Buffer.from(core_proto_ts_1.InjectiveCryptoV1Beta1Ethsecp256k1Keys.PubKey.decode(pubKey.value).key).toString('base64'),
+                        typeUrl: pubKey.typeUrl,
+                    }
+                    : undefined,
+                accountNumber: parseInt(baseAccount.accountNumber, 10),
+                sequence: parseInt(baseAccount.sequence, 10),
+            },
+        };
+    }
+    static accountResponseToAccount(response) {
+        return ChainGrpcAuthTransformer.grpcAccountToAccount(response.account);
+    }
+    static accountsResponseToAccounts(response) {
+        return {
+            pagination: (0, pagination_js_1.grpcPaginationToPagination)(response.pagination),
+            accounts: response.accounts.map(ChainGrpcAuthTransformer.grpcAccountToAccount),
+        };
+    }
+}
+exports.ChainGrpcAuthTransformer = ChainGrpcAuthTransformer;

package/dist/cjs/client/chain/transformers/ChainGrpcAuthZTransformer.d.ts

@@ -0,0 +1,21 @@
+import { CosmosAuthzV1Beta1Authz, CosmosAuthzV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import { GrantAuthorizationWithDecodedAuthorization, GrantWithDecodedAuthorization } from '../types/index.js';
+/**
+ * @category Chain Grpc Transformer
+ */
+export declare class ChainGrpcAuthZTransformer {
+    static grpcGrantToGrant(grant: CosmosAuthzV1Beta1Authz.Grant): GrantWithDecodedAuthorization;
+    static grpcGrantAuthorizationToGrantAuthorization(grant: CosmosAuthzV1Beta1Authz.GrantAuthorization): GrantAuthorizationWithDecodedAuthorization;
+    static grpcGrantsToGrants(response: CosmosAuthzV1Beta1Query.QueryGrantsResponse): {
+        pagination: import("../../../index.js").Pagination;
+        grants: GrantWithDecodedAuthorization[];
+    };
+    static grpcGranteeGrantsToGranteeGrants(response: CosmosAuthzV1Beta1Query.QueryGranteeGrantsResponse): {
+        pagination: import("../../../index.js").Pagination;
+        grants: GrantAuthorizationWithDecodedAuthorization[];
+    };
+    static grpcGranterGrantsToGranterGrants(response: CosmosAuthzV1Beta1Query.QueryGranterGrantsResponse): {
+        pagination: import("../../../index.js").Pagination;
+        grants: GrantAuthorizationWithDecodedAuthorization[];
+    };
+}

package/dist/cjs/client/chain/transformers/ChainGrpcAuthZTransformer.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainGrpcAuthZTransformer = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+const pagination_js_1 = require("../../../utils/pagination.js");
+const core_proto_ts_1 = require("@injectivelabs/core-proto-ts");
+/**
+ * @category Chain Grpc Transformer
+ */
+class ChainGrpcAuthZTransformer {
+    static grpcGrantToGrant(grant) {
+        const authorization = decodeAuthorizationNoThrow(grant.authorization);
+        return {
+            authorization: authorization?.authorization,
+            authorizationType: authorization?.authorizationType || '',
+            expiration: grant.expiration,
+        };
+    }
+    static grpcGrantAuthorizationToGrantAuthorization(grant) {
+        const authorization = decodeAuthorizationNoThrow(grant.authorization);
+        return {
+            granter: grant.granter,
+            grantee: grant.grantee,
+            authorization: authorization?.authorization,
+            authorizationType: authorization?.authorizationType || '',
+            expiration: grant.expiration,
+        };
+    }
+    static grpcGrantsToGrants(response) {
+        return {
+            pagination: (0, pagination_js_1.grpcPaginationToPagination)(response.pagination),
+            grants: response.grants.map(ChainGrpcAuthZTransformer.grpcGrantToGrant),
+        };
+    }
+    static grpcGranteeGrantsToGranteeGrants(response) {
+        return {
+            pagination: (0, pagination_js_1.grpcPaginationToPagination)(response.pagination),
+            grants: response.grants.map(ChainGrpcAuthZTransformer.grpcGrantAuthorizationToGrantAuthorization),
+        };
+    }
+    static grpcGranterGrantsToGranterGrants(response) {
+        return {
+            pagination: (0, pagination_js_1.grpcPaginationToPagination)(response.pagination),
+            grants: response.grants.map(ChainGrpcAuthZTransformer.grpcGrantAuthorizationToGrantAuthorization),
+        };
+    }
+}
+exports.ChainGrpcAuthZTransformer = ChainGrpcAuthZTransformer;
+const decodeAuthorization = (authorization) => {
+    switch (authorization.typeUrl) {
+        case '/cosmos.authz.v1beta1.GenericAuthorization':
+            return {
+                authorization: core_proto_ts_1.CosmosAuthzV1Beta1Authz.GenericAuthorization.decode(authorization.value),
+                authorizationType: '/cosmos.authz.v1beta1.GenericAuthorization',
+            };
+        default:
+            throw new exceptions_1.GeneralException(new Error('Unsupported authorization type'));
+    }
+};
+const decodeAuthorizationNoThrow = (authorization) => {
+    if (!authorization) {
+        return undefined;
+    }
+    try {
+        return decodeAuthorization(authorization);
+    }
+    catch {
+        return undefined;
+    }
+};

package/dist/cjs/client/chain/transformers/ChainGrpcBankTransformer.d.ts

@@ -0,0 +1,31 @@
+import { Coin } from '@injectivelabs/ts-types';
+import { Pagination } from '../../../types/index.js';
+import { BankModuleParams, Metadata, TotalSupply } from '../types/index.js';
+import { CosmosBankV1Beta1Bank, CosmosBankV1Beta1Query } from '@injectivelabs/core-proto-ts';
+/**
+ * @category Chain Grpc Transformer
+ */
+export declare class ChainGrpcBankTransformer {
+    static metadataToMetadata(metadata: CosmosBankV1Beta1Bank.Metadata): Metadata;
+    static moduleParamsResponseToModuleParams(response: CosmosBankV1Beta1Query.QueryParamsResponse): BankModuleParams;
+    static denomOwnersResponseToDenomOwners(response: CosmosBankV1Beta1Query.QueryDenomOwnersResponse): {
+        denomOwners: {
+            address: string;
+            balance: Coin | undefined;
+        }[];
+        pagination: Pagination;
+    };
+    static totalSupplyResponseToTotalSupply(response: CosmosBankV1Beta1Query.QueryTotalSupplyResponse): {
+        supply: TotalSupply;
+        pagination: Pagination;
+    };
+    static denomsMetadataResponseToDenomsMetadata(response: CosmosBankV1Beta1Query.QueryDenomsMetadataResponse): {
+        metadatas: Metadata[];
+        pagination: Pagination;
+    };
+    static balanceResponseToBalance(response: CosmosBankV1Beta1Query.QueryBalanceResponse): Coin;
+    static balancesResponseToBalances(response: CosmosBankV1Beta1Query.QueryAllBalancesResponse): {
+        balances: Coin[];
+        pagination: Pagination;
+    };
+}

package/dist/cjs/client/chain/transformers/ChainGrpcBankTransformer.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainGrpcBankTransformer = void 0;
+const ChainGrpcCommonTransformer_js_1 = require("./ChainGrpcCommonTransformer.js");
+const pagination_js_1 = require("../../../utils/pagination.js");
+/**
+ * @category Chain Grpc Transformer
+ */
+class ChainGrpcBankTransformer {
+    static metadataToMetadata(metadata) {
+        return metadata;
+    }
+    static moduleParamsResponseToModuleParams(response) {
+        const params = response.params;
+        return {
+            sendEnabledList: params.sendEnabled,
+            defaultSendEnabled: params.defaultSendEnabled,
+        };
+    }
+    static denomOwnersResponseToDenomOwners(response) {
+        const denomOwners = response.denomOwners;
+        const pagination = response.pagination;
+        return {
+            denomOwners,
+            pagination: (0, pagination_js_1.grpcPaginationToPagination)(pagination),
+        };
+    }
+    static totalSupplyResponseToTotalSupply(response) {
+        const balances = response.supply;
+        const pagination = response.pagination;
+        return {
+            supply: balances.map(ChainGrpcCommonTransformer_js_1.ChainGrpcCommonTransformer.grpcCoinToCoin),
+            pagination: (0, pagination_js_1.grpcPaginationToPagination)(pagination),
+        };
+    }
+    static denomsMetadataResponseToDenomsMetadata(response) {
+        const metadatas = response.metadatas;
+        const pagination = response.pagination;
+        return {
+            metadatas: metadatas.map(ChainGrpcBankTransformer.metadataToMetadata),
+            pagination: (0, pagination_js_1.grpcPaginationToPagination)(pagination),
+        };
+    }
+    static balanceResponseToBalance(response) {
+        return ChainGrpcCommonTransformer_js_1.ChainGrpcCommonTransformer.grpcCoinToCoin(response.balance);
+    }
+    static balancesResponseToBalances(response) {
+        const balances = response.balances;
+        const pagination = response.pagination;
+        return {
+            balances: balances.map(ChainGrpcCommonTransformer_js_1.ChainGrpcCommonTransformer.grpcCoinToCoin),
+            pagination: (0, pagination_js_1.grpcPaginationToPagination)(pagination),
+        };
+    }
+}
+exports.ChainGrpcBankTransformer = ChainGrpcBankTransformer;

package/dist/cjs/client/chain/transformers/ChainGrpcCommonTransformer.d.ts

@@ -0,0 +1,5 @@
+import { Coin } from '@injectivelabs/ts-types';
+import { GrpcCoin } from '../../../types/index.js';
+export declare class ChainGrpcCommonTransformer {
+    static grpcCoinToCoin(coin: GrpcCoin): Coin;
+}

package/dist/cjs/client/chain/transformers/ChainGrpcCommonTransformer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainGrpcCommonTransformer = void 0;
+class ChainGrpcCommonTransformer {
+    static grpcCoinToCoin(coin) {
+        return {
+            denom: coin.denom,
+            amount: coin.amount,
+        };
+    }
+}
+exports.ChainGrpcCommonTransformer = ChainGrpcCommonTransformer;

package/dist/cjs/client/chain/transformers/ChainGrpcDistributionTransformer.d.ts

@@ -0,0 +1,12 @@
+import { Coin } from '@injectivelabs/ts-types';
+import { DistributionModuleParams } from '../types/distribution.js';
+import { ValidatorRewards } from '../types/distribution.js';
+import { CosmosDistributionV1Beta1Query } from '@injectivelabs/core-proto-ts';
+/**
+ * @category Chain Grpc Transformer
+ */
+export declare class ChainGrpcDistributionTransformer {
+    static moduleParamsResponseToModuleParams(response: CosmosDistributionV1Beta1Query.QueryParamsResponse): DistributionModuleParams;
+    static delegationRewardResponseToReward(response: CosmosDistributionV1Beta1Query.QueryDelegationRewardsResponse): Coin[];
+    static totalDelegationRewardResponseToTotalReward(response: CosmosDistributionV1Beta1Query.QueryDelegationTotalRewardsResponse): ValidatorRewards[];
+}

package/dist/cjs/client/chain/transformers/ChainGrpcDistributionTransformer.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainGrpcDistributionTransformer = void 0;
+const index_js_1 = require("../../../utils/index.js");
+/**
+ * @category Chain Grpc Transformer
+ */
+class ChainGrpcDistributionTransformer {
+    static moduleParamsResponseToModuleParams(response) {
+        const params = response.params;
+        return {
+            communityTax: (0, index_js_1.cosmosSdkDecToBigNumber)(params.communityTax).toFixed(),
+            baseProposerReward: params.baseProposerReward,
+            bonusProposerReward: params.bonusProposerReward,
+            withdrawAddrEnabled: params.withdrawAddrEnabled,
+        };
+    }
+    static delegationRewardResponseToReward(response) {
+        const grpcRewards = response.rewards;
+        return grpcRewards.map((grpcReward) => {
+            return {
+                amount: (0, index_js_1.cosmosSdkDecToBigNumber)(grpcReward.amount).toFixed(),
+                denom: grpcReward.denom,
+            };
+        });
+    }
+    static totalDelegationRewardResponseToTotalReward(response) {
+        const grpcRewards = response.rewards;
+        return grpcRewards.map((grpcReward) => {
+            const rewards = grpcReward.reward.map((reward) => ({
+                amount: (0, index_js_1.cosmosSdkDecToBigNumber)(reward.amount).toFixed(),
+                denom: reward.denom,
+            }));
+            return {
+                rewards,
+                validatorAddress: grpcReward.validatorAddress,
+            };
+        });
+    }
+}
+exports.ChainGrpcDistributionTransformer = ChainGrpcDistributionTransformer;

package/dist/cjs/client/chain/transformers/ChainGrpcExchangeTransformer.d.ts

@@ -0,0 +1,35 @@
+import { InjectiveExchangeV1Beta1Query, InjectiveExchangeV1Beta1Exchange } from '@injectivelabs/core-proto-ts';
+import { ChainPosition, PointsMultiplier, ChainDenomDecimal, GrpcChainPosition, CampaignRewardPool, FeeDiscountTierTTL, IsOptedOutOfRewards, FeeDiscountSchedule, FeeDiscountTierInfo, TradeRewardCampaign, ChainDenomMinNotional, GrpcPointsMultiplier, ExchangeModuleParams, GrpcCampaignRewardPool, FeeDiscountAccountInfo, GrpcFeeDiscountTierTTL, GrpcFeeDiscountTierInfo, ChainDerivativePosition, TradingRewardCampaignInfo, GrpcTradingRewardCampaignInfo, TradingRewardCampaignBoostInfo, GrpcTradingRewardCampaignBoostInfo, type GrpcChainFullDerivativeMarket, type GrpcChainFullSpotMarket, type GrpcChainSpotMarket } from '../types/exchange.js';
+import type { DerivativeMarket } from '../../indexer/types/derivatives.js';
+import type { SpotMarket } from '../../indexer/types/spot.js';
+/**
+ * @category Chain Grpc Transformer
+ */
+export declare class ChainGrpcExchangeTransformer {
+    static moduleParamsResponseToParams(response: InjectiveExchangeV1Beta1Query.QueryExchangeParamsResponse): ExchangeModuleParams;
+    static feeDiscountScheduleResponseToFeeDiscountSchedule(response: InjectiveExchangeV1Beta1Query.QueryFeeDiscountScheduleResponse): FeeDiscountSchedule;
+    static tradingRewardsCampaignResponseToTradingRewardsCampaign(response: InjectiveExchangeV1Beta1Query.QueryTradeRewardCampaignResponse): TradeRewardCampaign;
+    static feeDiscountAccountInfoResponseToFeeDiscountAccountInfo(response: InjectiveExchangeV1Beta1Query.QueryFeeDiscountAccountInfoResponse): FeeDiscountAccountInfo;
+    static grpcFeeDiscountTierInfoToFeeDiscountTierInfo(info?: GrpcFeeDiscountTierInfo): FeeDiscountTierInfo | undefined;
+    static grpcFeeDiscountTierTTLToFeeDiscountTierTTL(info?: GrpcFeeDiscountTierTTL): FeeDiscountTierTTL | undefined;
+    static grpcPointsMultiplierToPointsMultiplier(point: GrpcPointsMultiplier): PointsMultiplier;
+    static grpcTradingRewardCampaignBoostInfoToTradingRewardCampaignBoostInfo(info?: GrpcTradingRewardCampaignBoostInfo): TradingRewardCampaignBoostInfo | undefined;
+    static grpcTradingRewardCampaignInfoToTradingRewardCampaignInfo(info?: GrpcTradingRewardCampaignInfo): TradingRewardCampaignInfo | undefined;
+    static grpcCampaignRewardPoolToCampaignRewardPool(pool: GrpcCampaignRewardPool): CampaignRewardPool;
+    static grpcPositionToPosition(position: GrpcChainPosition): ChainPosition;
+    static positionsResponseToPositions(response: InjectiveExchangeV1Beta1Query.QueryPositionsResponse): ChainDerivativePosition[];
+    static isOptedOutOfRewardsResponseToIsOptedOutOfRewards(response: InjectiveExchangeV1Beta1Query.QueryIsOptedOutOfRewardsResponse): IsOptedOutOfRewards;
+    static activeStakeGrantResponseToActiveStakeGrant(response: InjectiveExchangeV1Beta1Query.QueryActiveStakeGrantResponse): {
+        grant: InjectiveExchangeV1Beta1Exchange.ActiveGrant;
+        effectiveGrant: InjectiveExchangeV1Beta1Exchange.EffectiveGrant;
+    };
+    static denomMinNotionalResponseToDenomMinNotional(response: InjectiveExchangeV1Beta1Query.QueryDenomMinNotionalResponse): string;
+    static denomDecimalsResponseToDenomDecimals(response: InjectiveExchangeV1Beta1Query.QueryDenomDecimalsResponse): ChainDenomDecimal[];
+    static denomMinNotionalsResponseToDenomMinNotionals(response: InjectiveExchangeV1Beta1Query.QueryDenomMinNotionalsResponse): ChainDenomMinNotional[];
+    static spotMarketsResponseToSpotMarkets(response: InjectiveExchangeV1Beta1Query.QuerySpotMarketsResponse): SpotMarket[];
+    static grpcSpotMarketToSpotMarket(market: GrpcChainSpotMarket): SpotMarket;
+    static fullSpotMarketsResponseToSpotMarkets(response: InjectiveExchangeV1Beta1Query.QueryFullSpotMarketsResponse): SpotMarket[];
+    static grpcFullSpotMarketToSpotMarket(market: GrpcChainFullSpotMarket): SpotMarket;
+    static fullDerivativeMarketsResponseToDerivativeMarkets(response: InjectiveExchangeV1Beta1Query.QueryDerivativeMarketsResponse): DerivativeMarket[];
+    static grpcFullDerivativeMarketToDerivativeMarket(market: GrpcChainFullDerivativeMarket): DerivativeMarket;
+}