@injectivelabs/sdk-ts 1.16.16 → 1.16.17

package/dist/esm/client/chain/ChainGrpcClient.js

@@ -1,11 +1,13 @@
 import { ChainGrpcGovApi } from './grpc/ChainGrpcGovApi.js';
 import { ChainGrpcIbcApi } from './grpc/ChainGrpcIbcApi.js';
+import { ChainGrpcEvmApi } from './grpc/ChainGrpcEvmApi.js';
 import { ChainGrpcAuthApi } from './grpc/ChainGrpcAuthApi.js';
 import { ChainGrpcBankApi } from './grpc/ChainGrpcBankApi.js';
 import { ChainGrpcMintApi } from './grpc/ChainGrpcMintApi.js';
 import { ChainGrpcWasmApi } from './grpc/ChainGrpcWasmApi.js';
 import { ChainGrpcPeggyApi } from './grpc/ChainGrpcPeggyApi.js';
 import { ChainGrpcWasmXApi } from './grpc/ChainGrpcWasmXApi.js';
+import { ChainGrpcErc20Api } from './grpc/ChainGrpcErc20Api.js';
 import { ChainGrpcOracleApi } from './grpc/ChainGrpcOracleApi.js';
 import { ChainGrpcAuctionApi } from './grpc/ChainGrpcAuctionApi.js';
 import { ChainGrpcStakingApi } from './grpc/ChainGrpcStakingApi.js';
@@ -19,38 +21,42 @@ import { ChainGrpcInsuranceFundApi } from './grpc/ChainGrpcInsuranceFundApi.js';
  * @hidden
  */
 export class ChainGrpcClient {
-    auction;
-    auth;
-    bank;
-    distribution;
-    exchange;
     gov;
     ibc;
-    insuranceFund;
+    evm;
+    auth;
+    bank;
     mint;
-    oracle;
+    wasm;
     peggy;
-    permissions;
+    wasmX;
+    erc20;
+    oracle;
+    auction;
     staking;
+    exchange;
+    permissions;
+    distribution;
     tokenfactory;
-    wasm;
-    wasmX;
+    insuranceFund;
     constructor(endpoint) {
-        this.auction = new ChainGrpcAuctionApi(endpoint);
-        this.auth = new ChainGrpcAuthApi(endpoint);
-        this.bank = new ChainGrpcBankApi(endpoint);
-        this.distribution = new ChainGrpcDistributionApi(endpoint);
-        this.exchange = new ChainGrpcExchangeApi(endpoint);
+        this.evm = new ChainGrpcEvmApi(endpoint);
         this.gov = new ChainGrpcGovApi(endpoint);
         this.ibc = new ChainGrpcIbcApi(endpoint);
-        this.insuranceFund = new ChainGrpcInsuranceFundApi(endpoint);
+        this.auth = new ChainGrpcAuthApi(endpoint);
+        this.bank = new ChainGrpcBankApi(endpoint);
         this.mint = new ChainGrpcMintApi(endpoint);
-        this.oracle = new ChainGrpcOracleApi(endpoint);
+        this.wasm = new ChainGrpcWasmApi(endpoint);
+        this.erc20 = new ChainGrpcErc20Api(endpoint);
         this.peggy = new ChainGrpcPeggyApi(endpoint);
-        this.permissions = new ChainGrpcPermissionsApi(endpoint);
+        this.wasmX = new ChainGrpcWasmXApi(endpoint);
+        this.oracle = new ChainGrpcOracleApi(endpoint);
+        this.auction = new ChainGrpcAuctionApi(endpoint);
         this.staking = new ChainGrpcStakingApi(endpoint);
+        this.exchange = new ChainGrpcExchangeApi(endpoint);
+        this.permissions = new ChainGrpcPermissionsApi(endpoint);
+        this.distribution = new ChainGrpcDistributionApi(endpoint);
         this.tokenfactory = new ChainGrpcTokenFactoryApi(endpoint);
-        this.wasm = new ChainGrpcWasmApi(endpoint);
-        this.wasmX = new ChainGrpcWasmXApi(endpoint);
+        this.insuranceFund = new ChainGrpcInsuranceFundApi(endpoint);
     }
 }

package/dist/esm/client/chain/grpc/ChainGrpcAuthApi.js

@@ -2,8 +2,8 @@ import { CosmosAuthV1Beta1Query } from '@injectivelabs/core-proto-ts';
 import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
 import { ChainModule } from '../types/index.js';
 import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
-import { paginationRequestFromPagination } from '../../../utils/pagination.js';
 import { ChainGrpcAuthTransformer } from '../transformers/ChainGrpcAuthTransformer.js';
+import { ChainGrpcCommonTransformer } from '../transformers/ChainGrpcCommonTransformer.js';
 /**
  * @category Chain Grpc API
  */
@@ -59,7 +59,7 @@ export class ChainGrpcAuthApi extends BaseGrpcConsumer {
     }
     async fetchAccounts(pagination) {
         const request = CosmosAuthV1Beta1Query.QueryAccountsRequest.create();
-        const paginationForRequest = paginationRequestFromPagination(pagination);
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
         if (paginationForRequest) {
             request.pagination = paginationForRequest;
         }

package/dist/esm/client/chain/grpc/ChainGrpcAuthZApi.js

@@ -2,8 +2,8 @@ import { CosmosAuthzV1Beta1Query } from '@injectivelabs/core-proto-ts';
 import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
 import { ChainModule } from '../types/index.js';
 import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
-import { paginationRequestFromPagination } from '../../../utils/pagination.js';
 import { ChainGrpcAuthZTransformer } from '../transformers/ChainGrpcAuthZTransformer.js';
+import { ChainGrpcCommonTransformer } from '../transformers/ChainGrpcCommonTransformer.js';
 /**
  * @category Chain Grpc API
  */
@@ -25,7 +25,7 @@ export class ChainGrpcAuthZApi extends BaseGrpcConsumer {
         if (msgTypeUrl) {
             request.msgTypeUrl = msgTypeUrl;
         }
-        const paginationForRequest = paginationRequestFromPagination(pagination);
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
         if (paginationForRequest) {
             request.pagination = paginationForRequest;
         }
@@ -53,7 +53,7 @@ export class ChainGrpcAuthZApi extends BaseGrpcConsumer {
         if (granter) {
             request.granter = granter;
         }
-        const paginationForRequest = paginationRequestFromPagination(pagination);
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
         if (paginationForRequest) {
             request.pagination = paginationForRequest;
         }
@@ -81,7 +81,7 @@ export class ChainGrpcAuthZApi extends BaseGrpcConsumer {
         if (grantee) {
             request.grantee = grantee;
         }
-        const paginationForRequest = paginationRequestFromPagination(pagination);
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
         if (paginationForRequest) {
             request.pagination = paginationForRequest;
         }

package/dist/esm/client/chain/grpc/ChainGrpcBankApi.js

@@ -3,8 +3,8 @@ import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestExcepti
 import { ChainModule } from '../types/index.js';
 import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
 import { ChainGrpcBankTransformer } from '../transformers/index.js';
+import { fetchAllWithPagination } from '../../../utils/pagination.js';
 import { ChainGrpcCommonTransformer } from '../transformers/ChainGrpcCommonTransformer.js';
-import { fetchAllWithPagination, paginationRequestFromPagination, } from '../../../utils/pagination.js';
 const MAX_LIMIT_FOR_SUPPLY = 10000;
 /**
  * @category Chain Grpc API
@@ -63,7 +63,7 @@ export class ChainGrpcBankApi extends BaseGrpcConsumer {
     async fetchBalances(address, pagination) {
         const request = CosmosBankV1Beta1Query.QueryAllBalancesRequest.create();
         request.address = address;
-        const paginationForRequest = paginationRequestFromPagination(pagination);
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
         if (paginationForRequest) {
             request.pagination = paginationForRequest;
         }
@@ -88,7 +88,7 @@ export class ChainGrpcBankApi extends BaseGrpcConsumer {
     }
     async fetchTotalSupply(pagination) {
         const request = CosmosBankV1Beta1Query.QueryTotalSupplyRequest.create();
-        const paginationForRequest = paginationRequestFromPagination(pagination);
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
         if (paginationForRequest) {
             request.pagination = paginationForRequest;
         }
@@ -139,7 +139,7 @@ export class ChainGrpcBankApi extends BaseGrpcConsumer {
     }
     async fetchDenomsMetadata(pagination) {
         const request = CosmosBankV1Beta1Query.QueryDenomsMetadataRequest.create();
-        const paginationForRequest = paginationRequestFromPagination(pagination);
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
         if (paginationForRequest) {
             request.pagination = paginationForRequest;
         }
@@ -187,7 +187,7 @@ export class ChainGrpcBankApi extends BaseGrpcConsumer {
     async fetchDenomOwners(denom, pagination) {
         const request = CosmosBankV1Beta1Query.QueryDenomOwnersRequest.create();
         request.denom = denom;
-        const paginationForRequest = paginationRequestFromPagination(pagination);
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
         if (paginationForRequest) {
             request.pagination = paginationForRequest;
         }

package/dist/esm/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/esm/client/chain/grpc/ChainGrpcErc20Api.js

@@ -0,0 +1,117 @@
+import { InjectiveErc20V1Beta1Query } from '@injectivelabs/core-proto-ts';
+import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { ChainModule } from '../types/index.js';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+import { fetchAllWithPagination } from '../../../utils/pagination.js';
+import { ChainGrpcErc20Transformer, ChainGrpcCommonTransformer, } from '../transformers/index.js';
+const MAX_LIMIT_FOR_SUPPLY = 10000;
+/**
+ * @category Chain Grpc API
+ */
+export class ChainGrpcErc20Api extends BaseGrpcConsumer {
+    module = ChainModule.Erc20;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new InjectiveErc20V1Beta1Query.QueryClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchModuleParams() {
+        const request = InjectiveErc20V1Beta1Query.QueryParamsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.Params(request, this.metadata));
+            return ChainGrpcErc20Transformer.paramsResponseToParams(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveErc20V1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Erc20Params',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Erc20Params',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchTokenPairs(pagination) {
+        const request = InjectiveErc20V1Beta1Query.QueryAllTokenPairsRequest.create();
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
+        if (paginationForRequest) {
+            request.pagination = paginationForRequest;
+        }
+        try {
+            const response = await this.retry(() => this.client.AllTokenPairs(request, this.metadata));
+            return ChainGrpcErc20Transformer.tokenPairsResponseToTokenPairs(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveErc20V1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Erc20TokenPairs',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Erc20TokenPairs',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchAllTokenPairsWithPagination(pagination = { limit: MAX_LIMIT_FOR_SUPPLY }) {
+        return fetchAllWithPagination(pagination, this.fetchTokenPairs.bind(this));
+    }
+    async fetchTokenPairByDenom(denom) {
+        const request = InjectiveErc20V1Beta1Query.QueryTokenPairByDenomRequest.create();
+        request.bankDenom = denom;
+        try {
+            const response = await this.retry(() => this.client.TokenPairByDenom(request, this.metadata));
+            if (!response.tokenPair) {
+                return undefined;
+            }
+            return ChainGrpcErc20Transformer.grpcTokenPairToTokenPair(response.tokenPair);
+        }
+        catch (e) {
+            if (e instanceof InjectiveErc20V1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Erc20TokenPairByDenom',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Erc20TokenPairByDenom',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchTokenPairByErc20Address(erc20Address) {
+        const request = InjectiveErc20V1Beta1Query.QueryTokenPairByERC20AddressRequest.create();
+        request.erc20Address = erc20Address;
+        try {
+            const response = await this.retry(() => this.client.TokenPairByERC20Address(request, this.metadata));
+            if (!response.tokenPair) {
+                return undefined;
+            }
+            return ChainGrpcErc20Transformer.grpcTokenPairToTokenPair(response.tokenPair);
+        }
+        catch (e) {
+            if (e instanceof InjectiveErc20V1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Erc20TokenPairByErc20Address',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Erc20TokenPairByErc20Address',
+                contextModule: this.module,
+            });
+        }
+    }
+}

package/dist/esm/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/esm/client/chain/grpc/ChainGrpcEvmApi.js

@@ -0,0 +1,191 @@
+import { InjectiveEvmV1Query } from '@injectivelabs/core-proto-ts';
+import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { ChainModule } from '../types/index.js';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+import { ChainGrpcEvmTransformer } from '../transformers/index.js';
+/**
+ * @category Chain Grpc API
+ */
+export class ChainGrpcEvmApi extends BaseGrpcConsumer {
+    module = ChainModule.Evm;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new InjectiveEvmV1Query.QueryClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchAccount(ethAddress) {
+        const request = InjectiveEvmV1Query.QueryAccountRequest.create();
+        request.address = ethAddress;
+        try {
+            const response = await this.retry(() => this.client.Account(request, this.metadata));
+            return ChainGrpcEvmTransformer.accountResponseToAccount(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveEvmV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'EvmAccount',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'EvmAccount',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchCosmosAccount(ethAddress) {
+        const request = InjectiveEvmV1Query.QueryCosmosAccountRequest.create();
+        request.address = ethAddress;
+        try {
+            const response = await this.retry(() => this.client.CosmosAccount(request, this.metadata));
+            return ChainGrpcEvmTransformer.cosmosAccountResponseToCosmosAccount(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveEvmV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'CosmosAccount',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'CosmosAccount',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchValidatorAccount(consAddress) {
+        const request = InjectiveEvmV1Query.QueryValidatorAccountRequest.create();
+        request.consAddress = consAddress;
+        try {
+            const response = await this.retry(() => this.client.ValidatorAccount(request, this.metadata));
+            return ChainGrpcEvmTransformer.validatorAccountResponseToValidatorAccount(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveEvmV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'EvmValidatorAccount',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'EvmValidatorAccount',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchBalance(ethAddress) {
+        const request = 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 InjectiveEvmV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'EvmBalance',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'EvmBalance',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchStorage(ethAddress, key) {
+        const request = 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 InjectiveEvmV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'EvmStorage',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'EvmStorage',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchCode(ethAddress) {
+        const request = 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 InjectiveEvmV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'EvmCode',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'EvmCode',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchParams() {
+        const request = InjectiveEvmV1Query.QueryParamsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.Params(request, this.metadata));
+            return ChainGrpcEvmTransformer.paramsResponseToParams(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveEvmV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'EvmParams',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'EvmParams',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchBaseFee() {
+        const request = InjectiveEvmV1Query.QueryBaseFeeRequest.create();
+        try {
+            const response = await this.retry(() => this.client.BaseFee(request, this.metadata));
+            return response.baseFee;
+        }
+        catch (e) {
+            if (e instanceof InjectiveEvmV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'EvmBaseFee',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'EvmBaseFee',
+                contextModule: this.module,
+            });
+        }
+    }
+}

package/dist/esm/client/chain/grpc/ChainGrpcGovApi.js

@@ -2,8 +2,8 @@ import { CosmosGovV1Query } from '@injectivelabs/core-proto-ts';
 import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
 import { ChainModule } from '../types/index.js';
 import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
-import { paginationRequestFromPagination } from '../../../utils/pagination.js';
 import { ChainGrpcGovTransformer } from '../transformers/ChainGrpcGovTransformer.js';
+import { ChainGrpcCommonTransformer } from '../transformers/ChainGrpcCommonTransformer.js';
 /**
  * @category Chain Grpc API
  */
@@ -48,7 +48,7 @@ export class ChainGrpcGovApi extends BaseGrpcConsumer {
     async fetchProposals({ status, pagination, }) {
         const request = CosmosGovV1Query.QueryProposalsRequest.create();
         request.proposalStatus = status;
-        const paginationForRequest = paginationRequestFromPagination(pagination);
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
         if (paginationForRequest) {
             request.pagination = paginationForRequest;
         }
@@ -96,7 +96,7 @@ export class ChainGrpcGovApi extends BaseGrpcConsumer {
     async fetchProposalDeposits({ proposalId, pagination, }) {
         const request = CosmosGovV1Query.QueryDepositsRequest.create();
         request.proposalId = proposalId.toString();
-        const paginationForRequest = paginationRequestFromPagination(pagination);
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
         if (paginationForRequest) {
             request.pagination = paginationForRequest;
         }
@@ -122,7 +122,7 @@ export class ChainGrpcGovApi extends BaseGrpcConsumer {
     async fetchProposalVotes({ proposalId, pagination, }) {
         const request = CosmosGovV1Query.QueryVotesRequest.create();
         request.proposalId = proposalId.toString();
-        const paginationForRequest = paginationRequestFromPagination(pagination);
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
         if (paginationForRequest) {
             request.pagination = paginationForRequest;
         }

package/dist/esm/client/chain/grpc/ChainGrpcIbcApi.js

@@ -2,7 +2,7 @@ import { IbcApplicationsTransferV1Query } from '@injectivelabs/core-proto-ts';
 import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
 import { ChainModule } from '../types/index.js';
 import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
-import { paginationRequestFromPagination } from '../../../utils/pagination.js';
+import { ChainGrpcCommonTransformer } from '../transformers/ChainGrpcCommonTransformer.js';
 /**
  * @category Chain Grpc API
  */
@@ -37,7 +37,7 @@ export class ChainGrpcIbcApi extends BaseGrpcConsumer {
     }
     async fetchDenomsTrace(pagination) {
         const request = IbcApplicationsTransferV1Query.QueryDenomTracesRequest.create();
-        const paginationForRequest = paginationRequestFromPagination(pagination);
+        const paginationForRequest = ChainGrpcCommonTransformer.pageRequestToGrpcPageRequest(pagination);
         if (paginationForRequest) {
             request.pagination = paginationForRequest;
         }