@injectivelabs/sdk-ts 1.16.38-alpha.6 → 1.16.38

package/dist/cjs/client/chain/grpc/ChainGrpcDistributionApi.d.ts

@@ -0,0 +1,23 @@
+import { CosmosDistributionV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+import type { Coin } from '@injectivelabs/ts-types';
+import type { ValidatorRewards } from '../types/index.js';
+/**
+ * @category Chain Grpc API
+ */
+export declare class ChainGrpcDistributionApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: CosmosDistributionV1Beta1Query.QueryClientImpl;
+    constructor(endpoint: string);
+    fetchModuleParams(): Promise<import("../types/distribution.js").DistributionModuleParams>;
+    fetchDelegatorRewardsForValidator({ delegatorAddress, validatorAddress, }: {
+        delegatorAddress: string;
+        validatorAddress: string;
+    }): Promise<Coin[]>;
+    fetchDelegatorRewardsForValidatorNoThrow({ delegatorAddress, validatorAddress, }: {
+        delegatorAddress: string;
+        validatorAddress: string;
+    }): Promise<Coin[]>;
+    fetchDelegatorRewards(injectiveAddress: string): Promise<ValidatorRewards[]>;
+    fetchDelegatorRewardsNoThrow(injectiveAddress: string): Promise<ValidatorRewards[]>;
+}

package/dist/cjs/client/chain/grpc/ChainGrpcDistributionApi.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainGrpcDistributionApi = void 0;
+const core_proto_ts_1 = require("@injectivelabs/core-proto-ts");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const index_js_1 = require("../types/index.js");
+const BaseGrpcConsumer_js_1 = __importDefault(require("../../base/BaseGrpcConsumer.js"));
+const index_js_2 = require("../transformers/index.js");
+/**
+ * @category Chain Grpc API
+ */
+class ChainGrpcDistributionApi extends BaseGrpcConsumer_js_1.default {
+    module = index_js_1.ChainModule.Distribution;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new core_proto_ts_1.CosmosDistributionV1Beta1Query.QueryClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchModuleParams() {
+        const request = core_proto_ts_1.CosmosDistributionV1Beta1Query.QueryParamsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.Params(request, this.metadata));
+            return index_js_2.ChainGrpcDistributionTransformer.moduleParamsResponseToModuleParams(response);
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.CosmosDistributionV1Beta1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'Params',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Params',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchDelegatorRewardsForValidator({ delegatorAddress, validatorAddress, }) {
+        const request = core_proto_ts_1.CosmosDistributionV1Beta1Query.QueryDelegationRewardsRequest.create();
+        request.validatorAddress = validatorAddress;
+        request.delegatorAddress = delegatorAddress;
+        try {
+            const response = await this.retry(() => this.client.DelegationRewards(request, this.metadata));
+            return index_js_2.ChainGrpcDistributionTransformer.delegationRewardResponseToReward(response);
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.CosmosDistributionV1Beta1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'DelegationRewards',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'DelegationRewards',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchDelegatorRewardsForValidatorNoThrow({ delegatorAddress, validatorAddress, }) {
+        const request = core_proto_ts_1.CosmosDistributionV1Beta1Query.QueryDelegationRewardsRequest.create();
+        request.validatorAddress = validatorAddress;
+        request.delegatorAddress = delegatorAddress;
+        try {
+            const response = await this.retry(() => this.client.DelegationRewards(request, this.metadata));
+            return index_js_2.ChainGrpcDistributionTransformer.delegationRewardResponseToReward(response);
+        }
+        catch (e) {
+            if (e.message.includes('does not exist') ||
+                e.message.includes('no delegation for (address, validator) tuple')) {
+                return [];
+            }
+            if (e instanceof core_proto_ts_1.CosmosDistributionV1Beta1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'DelegationRewards',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'DelegationRewards',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchDelegatorRewards(injectiveAddress) {
+        const request = core_proto_ts_1.CosmosDistributionV1Beta1Query.QueryDelegationTotalRewardsRequest.create();
+        request.delegatorAddress = injectiveAddress;
+        try {
+            const response = await this.retry(() => this.client.DelegationTotalRewards(request, this.metadata));
+            return index_js_2.ChainGrpcDistributionTransformer.totalDelegationRewardResponseToTotalReward(response);
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.CosmosDistributionV1Beta1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'DelegationTotalRewards',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'DelegationTotalRewards',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchDelegatorRewardsNoThrow(injectiveAddress) {
+        const request = core_proto_ts_1.CosmosDistributionV1Beta1Query.QueryDelegationTotalRewardsRequest.create();
+        request.delegatorAddress = injectiveAddress;
+        try {
+            const response = await this.retry(() => this.client.DelegationTotalRewards(request, this.metadata));
+            return index_js_2.ChainGrpcDistributionTransformer.totalDelegationRewardResponseToTotalReward(response);
+        }
+        catch (e) {
+            if (e.message.includes('does not exist')) {
+                return [];
+            }
+            if (e instanceof core_proto_ts_1.CosmosDistributionV1Beta1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'DelegationTotalRewards',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'DelegationTotalRewards',
+                contextModule: this.module,
+            });
+        }
+    }
+}
+exports.ChainGrpcDistributionApi = ChainGrpcDistributionApi;

package/dist/cjs/client/chain/grpc/ChainGrpcErc20Api.d.ts

@@ -0,0 +1,28 @@
+import { InjectiveErc20V1Beta1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+import type { PaginationOption } from '../../../types/pagination.js';
+/**
+ * @category Chain Grpc API
+ */
+export declare class ChainGrpcErc20Api extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectiveErc20V1Beta1Query.QueryClientImpl;
+    constructor(endpoint: string);
+    fetchModuleParams(): Promise<import("../types/erc20.js").Params>;
+    fetchTokenPairs(pagination?: PaginationOption): Promise<{
+        tokenPairs: {
+            bankDenom: string;
+            erc20Address: string;
+        }[];
+        pagination: import("../../../types/pagination.js").Pagination;
+    }>;
+    fetchAllTokenPairsWithPagination(pagination?: PaginationOption): Promise<{
+        tokenPairs: {
+            bankDenom: string;
+            erc20Address: string;
+        }[];
+        pagination: import("../../../types/pagination.js").Pagination;
+    }>;
+    fetchTokenPairByDenom(denom: string): Promise<import("../types/erc20.js").TokenPair | undefined>;
+    fetchTokenPairByErc20Address(erc20Address: string): Promise<import("../types/erc20.js").TokenPair | undefined>;
+}

package/dist/cjs/client/chain/grpc/ChainGrpcErc20Api.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainGrpcErc20Api = void 0;
+const core_proto_ts_1 = require("@injectivelabs/core-proto-ts");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const index_js_1 = require("../types/index.js");
+const BaseGrpcConsumer_js_1 = __importDefault(require("../../base/BaseGrpcConsumer.js"));
+const pagination_js_1 = require("../../../utils/pagination.js");
+const index_js_2 = require("../transformers/index.js");
+const MAX_LIMIT_FOR_SUPPLY = 10000;
+/**
+ * @category Chain Grpc API
+ */
+class ChainGrpcErc20Api extends BaseGrpcConsumer_js_1.default {
+    module = index_js_1.ChainModule.Erc20;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new core_proto_ts_1.InjectiveErc20V1Beta1Query.QueryClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchModuleParams() {
+        const request = core_proto_ts_1.InjectiveErc20V1Beta1Query.QueryParamsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.Params(request, this.metadata));
+            return index_js_2.ChainGrpcErc20Transformer.paramsResponseToParams(response);
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.InjectiveErc20V1Beta1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'Erc20Params',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Erc20Params',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchTokenPairs(pagination) {
+        const request = core_proto_ts_1.InjectiveErc20V1Beta1Query.QueryAllTokenPairsRequest.create();
+        const paginationForRequest = index_js_2.ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
+        if (paginationForRequest) {
+            request.pagination = paginationForRequest;
+        }
+        try {
+            const response = await this.retry(() => this.client.AllTokenPairs(request, this.metadata));
+            return index_js_2.ChainGrpcErc20Transformer.tokenPairsResponseToTokenPairs(response);
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.InjectiveErc20V1Beta1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'Erc20TokenPairs',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Erc20TokenPairs',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchAllTokenPairsWithPagination(pagination = { limit: MAX_LIMIT_FOR_SUPPLY }) {
+        return (0, pagination_js_1.fetchAllWithPagination)(pagination, this.fetchTokenPairs.bind(this));
+    }
+    async fetchTokenPairByDenom(denom) {
+        const request = core_proto_ts_1.InjectiveErc20V1Beta1Query.QueryTokenPairByDenomRequest.create();
+        request.bankDenom = denom;
+        try {
+            const response = await this.retry(() => this.client.TokenPairByDenom(request, this.metadata));
+            if (!response.tokenPair) {
+                return undefined;
+            }
+            return index_js_2.ChainGrpcErc20Transformer.grpcTokenPairToTokenPair(response.tokenPair);
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.InjectiveErc20V1Beta1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'Erc20TokenPairByDenom',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Erc20TokenPairByDenom',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchTokenPairByErc20Address(erc20Address) {
+        const request = core_proto_ts_1.InjectiveErc20V1Beta1Query.QueryTokenPairByERC20AddressRequest.create();
+        request.erc20Address = erc20Address;
+        try {
+            const response = await this.retry(() => this.client.TokenPairByERC20Address(request, this.metadata));
+            if (!response.tokenPair) {
+                return undefined;
+            }
+            return index_js_2.ChainGrpcErc20Transformer.grpcTokenPairToTokenPair(response.tokenPair);
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.InjectiveErc20V1Beta1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'Erc20TokenPairByErc20Address',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Erc20TokenPairByErc20Address',
+                contextModule: this.module,
+            });
+        }
+    }
+}
+exports.ChainGrpcErc20Api = ChainGrpcErc20Api;

package/dist/cjs/client/chain/grpc/ChainGrpcEvmApi.d.ts

@@ -0,0 +1,30 @@
+import { InjectiveEvmV1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+/**
+ * @category Chain Grpc API
+ */
+export declare class ChainGrpcEvmApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectiveEvmV1Query.QueryClientImpl;
+    constructor(endpoint: string);
+    fetchAccount(ethAddress: string): Promise<{
+        balance: string;
+        codeHash: string;
+        nonce: string;
+    }>;
+    fetchCosmosAccount(ethAddress: string): Promise<{
+        sequence: string;
+        cosmosAddress: string;
+        accountNumber: string;
+    }>;
+    fetchValidatorAccount(consAddress: string): Promise<{
+        sequence: string;
+        accountNumber: string;
+        accountAddress: string;
+    }>;
+    fetchBalance(ethAddress: string): Promise<string>;
+    fetchStorage(ethAddress: string, key: string): Promise<string>;
+    fetchCode(ethAddress: string): Promise<Uint8Array<ArrayBufferLike>>;
+    fetchParams(): Promise<import("../types/evm.js").EvmParams | undefined>;
+    fetchBaseFee(): Promise<string>;
+}

package/dist/cjs/client/chain/grpc/ChainGrpcEvmApi.js

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainGrpcEvmApi = void 0;
+const core_proto_ts_1 = require("@injectivelabs/core-proto-ts");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const index_js_1 = require("../types/index.js");
+const BaseGrpcConsumer_js_1 = __importDefault(require("../../base/BaseGrpcConsumer.js"));
+const index_js_2 = require("../transformers/index.js");
+/**
+ * @category Chain Grpc API
+ */
+class ChainGrpcEvmApi extends BaseGrpcConsumer_js_1.default {
+    module = index_js_1.ChainModule.Evm;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new core_proto_ts_1.InjectiveEvmV1Query.QueryClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchAccount(ethAddress) {
+        const request = core_proto_ts_1.InjectiveEvmV1Query.QueryAccountRequest.create();
+        request.address = ethAddress;
+        try {
+            const response = await this.retry(() => this.client.Account(request, this.metadata));
+            return index_js_2.ChainGrpcEvmTransformer.accountResponseToAccount(response);
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.InjectiveEvmV1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'EvmAccount',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'EvmAccount',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchCosmosAccount(ethAddress) {
+        const request = core_proto_ts_1.InjectiveEvmV1Query.QueryCosmosAccountRequest.create();
+        request.address = ethAddress;
+        try {
+            const response = await this.retry(() => this.client.CosmosAccount(request, this.metadata));
+            return index_js_2.ChainGrpcEvmTransformer.cosmosAccountResponseToCosmosAccount(response);
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.InjectiveEvmV1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'CosmosAccount',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'CosmosAccount',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchValidatorAccount(consAddress) {
+        const request = core_proto_ts_1.InjectiveEvmV1Query.QueryValidatorAccountRequest.create();
+        request.consAddress = consAddress;
+        try {
+            const response = await this.retry(() => this.client.ValidatorAccount(request, this.metadata));
+            return index_js_2.ChainGrpcEvmTransformer.validatorAccountResponseToValidatorAccount(response);
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.InjectiveEvmV1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'EvmValidatorAccount',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'EvmValidatorAccount',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchBalance(ethAddress) {
+        const request = core_proto_ts_1.InjectiveEvmV1Query.QueryBalanceRequest.create();
+        request.address = ethAddress;
+        try {
+            const response = await this.retry(() => this.client.Balance(request, this.metadata));
+            return response.balance;
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.InjectiveEvmV1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'EvmBalance',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'EvmBalance',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchStorage(ethAddress, key) {
+        const request = core_proto_ts_1.InjectiveEvmV1Query.QueryStorageRequest.create();
+        request.address = ethAddress;
+        request.key = key;
+        try {
+            const response = await this.retry(() => this.client.Storage(request, this.metadata));
+            return response.value;
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.InjectiveEvmV1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'EvmStorage',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'EvmStorage',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchCode(ethAddress) {
+        const request = core_proto_ts_1.InjectiveEvmV1Query.QueryCodeRequest.create();
+        request.address = ethAddress;
+        try {
+            const response = await this.retry(() => this.client.Code(request, this.metadata));
+            return response.code;
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.InjectiveEvmV1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'EvmCode',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'EvmCode',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchParams() {
+        const request = core_proto_ts_1.InjectiveEvmV1Query.QueryParamsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.Params(request, this.metadata));
+            return index_js_2.ChainGrpcEvmTransformer.paramsResponseToParams(response);
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.InjectiveEvmV1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'EvmParams',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'EvmParams',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchBaseFee() {
+        const request = core_proto_ts_1.InjectiveEvmV1Query.QueryBaseFeeRequest.create();
+        try {
+            const response = await this.retry(() => this.client.BaseFee(request, this.metadata));
+            return response.baseFee;
+        }
+        catch (e) {
+            if (e instanceof core_proto_ts_1.InjectiveEvmV1Query.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'EvmBaseFee',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'EvmBaseFee',
+                contextModule: this.module,
+            });
+        }
+    }
+}
+exports.ChainGrpcEvmApi = ChainGrpcEvmApi;

package/dist/cjs/client/chain/grpc/ChainGrpcExchangeApi.d.ts

@@ -0,0 +1,31 @@
+import { InjectiveExchangeV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+/**
+ * @category Chain Grpc API
+ */
+export declare class ChainGrpcExchangeApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectiveExchangeV1Beta1Query.QueryClientImpl;
+    constructor(endpoint: string);
+    fetchModuleParams(): Promise<import("../types/exchange.js").ExchangeModuleParams>;
+    fetchModuleState(): Promise<import("@injectivelabs/core-proto-ts/cjs/injective/exchange/v1beta1/genesis.js").GenesisState>;
+    fetchFeeDiscountSchedule(): Promise<import("../types/exchange.js").FeeDiscountSchedule>;
+    fetchFeeDiscountAccountInfo(injectiveAddress: string): Promise<import("../types/exchange.js").FeeDiscountAccountInfo>;
+    fetchTradingRewardsCampaign(): Promise<import("../types/exchange.js").TradeRewardCampaign>;
+    fetchTradeRewardPoints(injectiveAddresses: string[]): Promise<string[]>;
+    fetchPendingTradeRewardPoints(injectiveAddresses: string[], timestamp?: number): Promise<string[]>;
+    fetchPositions(): Promise<import("../types/exchange.js").ChainDerivativePosition[]>;
+    fetchSubaccountTradeNonce(subaccountId: string): Promise<InjectiveExchangeV1Beta1Query.QuerySubaccountTradeNonceResponse>;
+    fetchIsOptedOutOfRewards(account: string): Promise<import("../types/exchange.js").IsOptedOutOfRewards>;
+    fetchActiveStakeGrant(account: string): Promise<{
+        grant: import("@injectivelabs/core-proto-ts/cjs/injective/exchange/v1beta1/exchange.js").ActiveGrant;
+        effectiveGrant: import("@injectivelabs/core-proto-ts/cjs/injective/exchange/v1beta1/exchange.js").EffectiveGrant;
+    }>;
+    fetchDenomDecimal(denom: string): Promise<string>;
+    fetchDenomDecimals(): Promise<import("../types/exchange.js").ChainDenomDecimal[]>;
+    fetchDenomMinNotional(denom: string): Promise<string>;
+    fetchDenomMinNotionals(): Promise<import("../types/exchange.js").ChainDenomMinNotional[]>;
+    fetchDerivativeMarkets(status?: string, marketIds?: string[]): Promise<import("../../index.js").DerivativeMarket[]>;
+    fetchSpotMarkets(status?: string, marketIds?: string[]): Promise<import("../../index.js").SpotMarket[]>;
+    fetchFullSpotMarkets(status?: string, marketIds?: string[]): Promise<import("../../index.js").SpotMarket[]>;
+}