@injectivelabs/sdk-ts 1.15.0 → 1.15.2

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

@@ -0,0 +1,170 @@
+import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { CosmosGovV1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+import { ChainModule } from '../types/index.js';
+import { paginationRequestFromPagination } from '../../../utils/pagination.js';
+import { ChainGrpcGovTransformer } from '../transformers/ChainGrpcGovTransformer.js';
+/**
+ * @category Chain Grpc API
+ */
+export class ChainGrpcGovApi extends BaseGrpcConsumer {
+    module = ChainModule.Gov;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new CosmosGovV1Query.QueryClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchModuleParams() {
+        const paramTypes = ['voting', 'deposit', 'tallying'];
+        const requests = paramTypes.map((type) => {
+            const request = CosmosGovV1Query.QueryParamsRequest.create();
+            request.paramsType = type;
+            return request;
+        });
+        try {
+            const responses = await Promise.all(requests.map((request) => this.client.Params(request, this.metadata)));
+            const [votingParams, depositParams, tallyParams] = responses;
+            return ChainGrpcGovTransformer.moduleParamsResponseToModuleParamsByType({
+                votingParams: votingParams.params,
+                tallyParams: tallyParams.params,
+                depositParams: depositParams.params,
+            });
+        }
+        catch (e) {
+            if (e instanceof CosmosGovV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Params',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Params',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchProposals({ status, pagination, }) {
+        const request = CosmosGovV1Query.QueryProposalsRequest.create();
+        request.proposalStatus = status;
+        const paginationForRequest = paginationRequestFromPagination(pagination);
+        if (paginationForRequest) {
+            request.pagination = paginationForRequest;
+        }
+        try {
+            const response = await this.retry(() => this.client.Proposals(request, this.metadata));
+            return ChainGrpcGovTransformer.proposalsResponseToProposals(response);
+        }
+        catch (e) {
+            if (e instanceof CosmosGovV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Proposals',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Proposals',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchProposal(proposalId) {
+        const request = CosmosGovV1Query.QueryProposalRequest.create();
+        request.proposalId = proposalId.toString();
+        try {
+            const response = await this.retry(() => this.client.Proposal(request, this.metadata));
+            return ChainGrpcGovTransformer.proposalResponseToProposal(response);
+        }
+        catch (e) {
+            if (e instanceof CosmosGovV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Proposal',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Proposal',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchProposalDeposits({ proposalId, pagination, }) {
+        const request = CosmosGovV1Query.QueryDepositsRequest.create();
+        request.proposalId = proposalId.toString();
+        const paginationForRequest = paginationRequestFromPagination(pagination);
+        if (paginationForRequest) {
+            request.pagination = paginationForRequest;
+        }
+        try {
+            const response = await this.retry(() => this.client.Deposits(request, this.metadata));
+            return ChainGrpcGovTransformer.depositsResponseToDeposits(response);
+        }
+        catch (e) {
+            if (e instanceof CosmosGovV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Deposits',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Deposits',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchProposalVotes({ proposalId, pagination, }) {
+        const request = CosmosGovV1Query.QueryVotesRequest.create();
+        request.proposalId = proposalId.toString();
+        const paginationForRequest = paginationRequestFromPagination(pagination);
+        if (paginationForRequest) {
+            request.pagination = paginationForRequest;
+        }
+        try {
+            const response = await this.retry(() => this.client.Votes(request, this.metadata));
+            return ChainGrpcGovTransformer.votesResponseToVotes(response);
+        }
+        catch (e) {
+            if (e instanceof CosmosGovV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Votes',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Votes',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchProposalTally(proposalId) {
+        const request = CosmosGovV1Query.QueryTallyResultRequest.create();
+        request.proposalId = proposalId.toString();
+        try {
+            const response = await this.retry(() => this.client.TallyResult(request, this.metadata));
+            return ChainGrpcGovTransformer.tallyResultResponseToTallyResult(response);
+        }
+        catch (e) {
+            if (e instanceof CosmosGovV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'TallyResult',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'TallyResult',
+                contextModule: this.module,
+            });
+        }
+    }
+}

package/dist/esm/client/chain/grpc/ChainGrpcIbcApi.d.ts

@@ -0,0 +1,13 @@
+import { IbcApplicationsTransferV1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+import { PaginationOption } from '../../../types/pagination.js';
+/**
+ * @category Chain Grpc API
+ */
+export declare class ChainGrpcIbcApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: IbcApplicationsTransferV1Query.QueryClientImpl;
+    constructor(endpoint: string);
+    fetchDenomTrace(hash: string): Promise<import("@injectivelabs/core-proto-ts/cjs/ibc/applications/transfer/v1/transfer.js").DenomTrace>;
+    fetchDenomsTrace(pagination?: PaginationOption): Promise<import("@injectivelabs/core-proto-ts/cjs/ibc/applications/transfer/v1/transfer.js").DenomTrace[]>;
+}

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

@@ -0,0 +1,63 @@
+import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { IbcApplicationsTransferV1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+import { ChainModule } from '../types/index.js';
+import { paginationRequestFromPagination } from '../../../utils/pagination.js';
+/**
+ * @category Chain Grpc API
+ */
+export class ChainGrpcIbcApi extends BaseGrpcConsumer {
+    module = ChainModule.Ibc;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new IbcApplicationsTransferV1Query.QueryClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchDenomTrace(hash) {
+        const request = IbcApplicationsTransferV1Query.QueryDenomTraceRequest.create();
+        request.hash = hash;
+        try {
+            const response = await this.retry(() => this.client.DenomTrace(request, this.metadata));
+            return response.denomTrace;
+        }
+        catch (e) {
+            if (e instanceof IbcApplicationsTransferV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'DenomTrace',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'DenomTrace',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchDenomsTrace(pagination) {
+        const request = IbcApplicationsTransferV1Query.QueryDenomTracesRequest.create();
+        const paginationForRequest = paginationRequestFromPagination(pagination);
+        if (paginationForRequest) {
+            request.pagination = paginationForRequest;
+        }
+        try {
+            const response = await this.retry(() => this.client.DenomTraces(request, this.metadata));
+            return response.denomTraces;
+        }
+        catch (e) {
+            if (e instanceof IbcApplicationsTransferV1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'DenomTraces',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'DenomTraces',
+                contextModule: this.module,
+            });
+        }
+    }
+}

package/dist/esm/client/chain/grpc/ChainGrpcInsuranceFundApi.d.ts

@@ -0,0 +1,27 @@
+import { InjectiveInsuranceV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+/**
+ * @category Chain Grpc API
+ */
+export declare class ChainGrpcInsuranceFundApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectiveInsuranceV1Beta1Query.QueryClientImpl;
+    constructor(endpoint: string);
+    fetchModuleParams(): Promise<import("../types/insurance.js").InsuranceModuleParams>;
+    fetchInsuranceFunds(): Promise<import("../types/insurance.js").InsuranceFund[]>;
+    fetchInsuranceFund(marketId: string): Promise<import("../types/insurance.js").InsuranceFund>;
+    fetchEstimatedRedemptions({ marketId, address, }: {
+        marketId: string;
+        address: string;
+    }): Promise<{
+        amount: string;
+        denom: string;
+    }[]>;
+    fetchPendingRedemptions({ marketId, address, }: {
+        marketId: string;
+        address: string;
+    }): Promise<{
+        amount: string;
+        denom: string;
+    }[]>;
+}

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

@@ -0,0 +1,126 @@
+import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { InjectiveInsuranceV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+import { ChainModule } from '../types/index.js';
+import { ChainGrpcInsuranceFundTransformer } from '../transformers/ChainGrpcInsuranceFundTransformer.js';
+/**
+ * @category Chain Grpc API
+ */
+export class ChainGrpcInsuranceFundApi extends BaseGrpcConsumer {
+    module = ChainModule.InsuranceFund;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new InjectiveInsuranceV1Beta1Query.QueryClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchModuleParams() {
+        const request = InjectiveInsuranceV1Beta1Query.QueryInsuranceParamsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.InsuranceParams(request, this.metadata));
+            return ChainGrpcInsuranceFundTransformer.moduleParamsResponseToModuleParams(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveInsuranceV1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'InsuranceParams',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'InsuranceParams',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchInsuranceFunds() {
+        const request = InjectiveInsuranceV1Beta1Query.QueryInsuranceFundsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.InsuranceFunds(request, this.metadata));
+            return ChainGrpcInsuranceFundTransformer.insuranceFundsResponseToInsuranceFunds(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveInsuranceV1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'InsuranceFunds',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'InsuranceFunds',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchInsuranceFund(marketId) {
+        const request = InjectiveInsuranceV1Beta1Query.QueryInsuranceFundRequest.create();
+        request.marketId = marketId;
+        try {
+            const response = await this.retry(() => this.client.InsuranceFund(request, this.metadata));
+            return ChainGrpcInsuranceFundTransformer.insuranceFundResponseToInsuranceFund(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveInsuranceV1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'InsuranceFund',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'InsuranceFund',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchEstimatedRedemptions({ marketId, address, }) {
+        const request = InjectiveInsuranceV1Beta1Query.QueryEstimatedRedemptionsRequest.create();
+        request.marketId = marketId;
+        request.address = address;
+        try {
+            const response = await this.retry(() => this.client.EstimatedRedemptions(request, this.metadata));
+            return ChainGrpcInsuranceFundTransformer.estimatedRedemptionsResponseToEstimatedRedemptions(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveInsuranceV1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'EstimatedRedemptions',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'EstimatedRedemptions',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchPendingRedemptions({ marketId, address, }) {
+        const request = InjectiveInsuranceV1Beta1Query.QueryPendingRedemptionsRequest.create();
+        request.marketId = marketId;
+        request.address = address;
+        try {
+            const response = await this.retry(() => this.client.PendingRedemptions(request, this.metadata));
+            return ChainGrpcInsuranceFundTransformer.redemptionsResponseToRedemptions(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveInsuranceV1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'PendingRedemptions',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'PendingRedemptions',
+                contextModule: this.module,
+            });
+        }
+    }
+}

package/dist/esm/client/chain/grpc/ChainGrpcMintApi.d.ts

@@ -0,0 +1,17 @@
+import { CosmosMintV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+/**
+ * @category Chain Grpc API
+ */
+export declare class ChainGrpcMintApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: CosmosMintV1Beta1Query.QueryClientImpl;
+    constructor(endpoint: string);
+    fetchModuleParams(): Promise<import("../types/mint.js").MinModuleParams>;
+    fetchInflation(): Promise<{
+        inflation: string;
+    }>;
+    fetchAnnualProvisions(): Promise<{
+        annualProvisions: string;
+    }>;
+}

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

@@ -0,0 +1,85 @@
+import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { CosmosMintV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import { cosmosSdkDecToBigNumber, uint8ArrayToString } from '../../../utils/index.js';
+import { BigNumberInBase } from '@injectivelabs/utils';
+import { ChainGrpcMintTransformer } from './../transformers/ChainGrpcMintTransformer.js';
+import { ChainModule } from '../types/index.js';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+/**
+ * @category Chain Grpc API
+ */
+export class ChainGrpcMintApi extends BaseGrpcConsumer {
+    module = ChainModule.Mint;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new CosmosMintV1Beta1Query.QueryClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchModuleParams() {
+        const request = CosmosMintV1Beta1Query.QueryParamsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.Params(request, this.metadata));
+            return ChainGrpcMintTransformer.moduleParamsResponseToModuleParams(response);
+        }
+        catch (e) {
+            if (e instanceof CosmosMintV1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Params',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Params',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchInflation() {
+        const request = CosmosMintV1Beta1Query.QueryInflationRequest.create();
+        try {
+            const response = await this.retry(() => this.client.Inflation(request, this.metadata));
+            return {
+                inflation: cosmosSdkDecToBigNumber(new BigNumberInBase(uint8ArrayToString(response.inflation))).toFixed(),
+            };
+        }
+        catch (e) {
+            if (e instanceof CosmosMintV1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Inflation',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Inflation',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchAnnualProvisions() {
+        const request = CosmosMintV1Beta1Query.QueryAnnualProvisionsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.AnnualProvisions(request, this.metadata));
+            return {
+                annualProvisions: cosmosSdkDecToBigNumber(new BigNumberInBase(uint8ArrayToString(response.annualProvisions))).toFixed(),
+            };
+        }
+        catch (e) {
+            if (e instanceof CosmosMintV1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'AnnualProvisions',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'AnnualProvisions',
+                contextModule: this.module,
+            });
+        }
+    }
+}

package/dist/esm/client/chain/grpc/ChainGrpcOracleApi.d.ts

@@ -0,0 +1,12 @@
+import { InjectiveOracleV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+import { OracleModuleParams } from '../types/index.js';
+/**
+ * @category Chain Grpc API
+ */
+export declare class ChainGrpcOracleApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectiveOracleV1Beta1Query.QueryClientImpl;
+    constructor(endpoint: string);
+    fetchModuleParams(): Promise<OracleModuleParams>;
+}

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

@@ -0,0 +1,36 @@
+import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { InjectiveOracleV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+import { ChainModule } from '../types/index.js';
+/**
+ * @category Chain Grpc API
+ */
+export class ChainGrpcOracleApi extends BaseGrpcConsumer {
+    module = ChainModule.Oracle;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new InjectiveOracleV1Beta1Query.QueryClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchModuleParams() {
+        const request = InjectiveOracleV1Beta1Query.QueryParamsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.Params(request, this.metadata));
+            return response.params;
+        }
+        catch (e) {
+            if (e instanceof InjectiveOracleV1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Params',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Params',
+                contextModule: this.module,
+            });
+        }
+    }
+}

package/dist/esm/client/chain/grpc/ChainGrpcPeggyApi.d.ts

@@ -0,0 +1,11 @@
+import { InjectivePeggyV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+/**
+ * @category Chain Grpc API
+ */
+export declare class ChainGrpcPeggyApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectivePeggyV1Beta1Query.QueryClientImpl;
+    constructor(endpoint: string);
+    fetchModuleParams(): Promise<import("../types/peggy.js").PeggyModuleParams>;
+}

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

@@ -0,0 +1,37 @@
+import { UnspecifiedErrorCode, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { InjectivePeggyV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+import { ChainModule } from '../types/index.js';
+import { ChainGrpcPeggyTransformer } from '../transformers/index.js';
+/**
+ * @category Chain Grpc API
+ */
+export class ChainGrpcPeggyApi extends BaseGrpcConsumer {
+    module = ChainModule.Peggy;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new InjectivePeggyV1Beta1Query.QueryClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchModuleParams() {
+        const request = InjectivePeggyV1Beta1Query.QueryParamsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.Params(request, this.metadata));
+            return ChainGrpcPeggyTransformer.moduleParamsResponseToModuleParams(response);
+        }
+        catch (e) {
+            if (e instanceof InjectivePeggyV1Beta1Query.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'Params',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'Params',
+                contextModule: this.module,
+            });
+        }
+    }
+}

package/dist/esm/client/chain/grpc/ChainGrpcPermissionsApi.d.ts

@@ -0,0 +1,43 @@
+import { InjectivePermissionsV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseGrpcConsumer.js';
+/**
+ * @category Chain Grpc API
+ */
+export declare class ChainGrpcPermissionsApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectivePermissionsV1Beta1Query.QueryClientImpl;
+    constructor(endpoint: string);
+    fetchModuleParams(): Promise<import("../types/permissions.js").PermissionsModuleParams>;
+    fetchNamespaceDenoms(): Promise<string[]>;
+    fetchNamespaces(): Promise<void[]>;
+    fetchNamespace(denom: string): Promise<import("../types/permissions.js").PermissionNamespace | undefined>;
+    fetchActorsByRole({ denom, role }: {
+        denom: string;
+        role: string;
+    }): Promise<{
+        roles: string;
+    }[]>;
+    fetchRolesByActor({ actor, denom }: {
+        actor: string;
+        denom: string;
+    }): Promise<{
+        roles: string;
+    }[]>;
+    fetchRoleManager({ denom, manager, }: {
+        denom: string;
+        manager: string;
+    }): Promise<import("../types/permissions.js").PermissionRoleManager | undefined>;
+    fetchRoleManagers(): Promise<import("../types/permissions.js").PermissionRoleManager[]>;
+    fetchPolicyStatuses(): Promise<import("../types/permissions.js").PermissionPolicyStatus[]>;
+    fetchPolicyManagerCapabilities(denom: string): Promise<import("../types/permissions.js").PermissionPolicyManagerCapability[]>;
+    fetchVoucher({ denom, address }: {
+        denom: string;
+        address: string;
+    }): Promise<import("@injectivelabs/ts-types").Coin | undefined>;
+    fetchVouchers(denom: string): Promise<import("../types/permissions.js").PermissionAddressVoucher[]>;
+    fetchModuleState(): Promise<{
+        params: import("../types/permissions.js").PermissionsModuleParams;
+        namespaces: import("../types/permissions.js").PermissionNamespace[];
+        vouchers: import("../types/permissions.js").PermissionAddressVoucher[];
+    } | undefined>;
+}