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

package/dist/esm/client/chain/transformers/ChainGrpcEvmTransformer.js

@@ -0,0 +1,98 @@
+/**
+ * @category Chain Grpc Transformer
+ */
+export class ChainGrpcEvmTransformer {
+    static grpcBlobConfigToBlobConfig(config) {
+        return {
+            max: config.max,
+            target: config.target,
+            baseFeeUpdateFraction: config.baseFeeUpdateFraction,
+        };
+    }
+    static grpcBlockScheduleConfigToBlockScheduleConfig(config) {
+        return {
+            cancun: config.cancun
+                ? this.grpcBlobConfigToBlobConfig(config.cancun)
+                : undefined,
+            prague: config.prague
+                ? this.grpcBlobConfigToBlobConfig(config.prague)
+                : undefined,
+            osaka: config.osaka
+                ? this.grpcBlobConfigToBlobConfig(config.osaka)
+                : undefined,
+            verkle: config.verkle
+                ? this.grpcBlobConfigToBlobConfig(config.verkle)
+                : undefined,
+        };
+    }
+    static grpcChainConfigToChainConfig(config) {
+        return {
+            homesteadBlock: config.homesteadBlock,
+            daoForkBlock: config.daoForkBlock,
+            daoForkSupport: config.daoForkSupport,
+            eip150Block: config.eip150Block,
+            eip150Hash: config.eip150Hash,
+            eip155Block: config.eip155Block,
+            eip158Block: config.eip158Block,
+            byzantiumBlock: config.byzantiumBlock,
+            constantinopleBlock: config.constantinopleBlock,
+            petersburgBlock: config.petersburgBlock,
+            istanbulBlock: config.istanbulBlock,
+            muirGlacierBlock: config.muirGlacierBlock,
+            berlinBlock: config.berlinBlock,
+            londonBlock: config.londonBlock,
+            arrowGlacierBlock: config.arrowGlacierBlock,
+            grayGlacierBlock: config.grayGlacierBlock,
+            mergeNetsplitBlock: config.mergeNetsplitBlock,
+            shanghaiTime: config.shanghaiTime,
+            cancunTime: config.cancunTime,
+            pragueTime: config.pragueTime,
+            eip155ChainId: config.eip155ChainId,
+            blobScheduleConfig: config.blobScheduleConfig
+                ? this.grpcBlockScheduleConfigToBlockScheduleConfig(config.blobScheduleConfig)
+                : undefined,
+        };
+    }
+    /**
+     * response transformers
+     * */
+    static accountResponseToAccount(response) {
+        return {
+            balance: response.balance,
+            codeHash: response.codeHash,
+            nonce: response.nonce,
+        };
+    }
+    static cosmosAccountResponseToCosmosAccount(response) {
+        return {
+            sequence: response.sequence,
+            cosmosAddress: response.cosmosAddress,
+            accountNumber: response.accountNumber,
+        };
+    }
+    static validatorAccountResponseToValidatorAccount(response) {
+        return {
+            sequence: response.sequence,
+            accountNumber: response.accountNumber,
+            accountAddress: response.accountAddress,
+        };
+    }
+    static paramsResponseToParams(response) {
+        const { params } = response;
+        if (!params) {
+            return;
+        }
+        return {
+            evmDenom: params.evmDenom,
+            enableCreate: params.enableCreate,
+            enableCall: params.enableCall,
+            extraEips: params.extraEips,
+            chainConfig: params.chainConfig
+                ? this.grpcChainConfigToChainConfig(params.chainConfig)
+                : undefined,
+            allowUnprotectedTxs: params.allowUnprotectedTxs,
+            authorizedDeployers: params.authorizedDeployers,
+            permissioned: params.permissioned,
+        };
+    }
+}

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

@@ -0,0 +1,37 @@
+import { InjectiveExchangeV1Beta1Exchange } from '@injectivelabs/core-proto-ts';
+import type { SpotMarket } from '../../indexer/types/spot.js';
+import type { DerivativeMarket } from '../../indexer/types/derivatives.js';
+import type { InjectiveExchangeV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import type { GrpcChainSpotMarket, GrpcChainFullSpotMarket, GrpcChainFullDerivativeMarket } from '../types/exchange.js';
+import type { ChainPosition, PointsMultiplier, ChainDenomDecimal, GrpcChainPosition, CampaignRewardPool, FeeDiscountTierTTL, IsOptedOutOfRewards, FeeDiscountSchedule, FeeDiscountTierInfo, TradeRewardCampaign, ChainDenomMinNotional, GrpcPointsMultiplier, ExchangeModuleParams, GrpcCampaignRewardPool, FeeDiscountAccountInfo, GrpcFeeDiscountTierTTL, GrpcFeeDiscountTierInfo, ChainDerivativePosition, TradingRewardCampaignInfo, GrpcTradingRewardCampaignInfo, TradingRewardCampaignBoostInfo, GrpcTradingRewardCampaignBoostInfo } from '../types/exchange.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;
+}

package/dist/esm/client/chain/transformers/ChainGrpcExchangeTransformer.js

@@ -0,0 +1,269 @@
+import { toHumanReadable } from '@injectivelabs/utils';
+import { InjectiveOracleV1Beta1Oracle, InjectiveExchangeV1Beta1Exchange, } from '@injectivelabs/core-proto-ts';
+import { denomAmountFromGrpcChainDenomAmount } from './../../../utils/numbers.js';
+/**
+ * @category Chain Grpc Transformer
+ */
+export class ChainGrpcExchangeTransformer {
+    static moduleParamsResponseToParams(response) {
+        const params = response.params;
+        const spotMarketInstantListingFee = params.spotMarketInstantListingFee;
+        const derivativeMarketInstantListingFee = params.derivativeMarketInstantListingFee;
+        return {
+            spotMarketInstantListingFee: spotMarketInstantListingFee
+                ? {
+                    amount: spotMarketInstantListingFee.amount,
+                    denom: spotMarketInstantListingFee.denom,
+                }
+                : undefined,
+            derivativeMarketInstantListingFee: derivativeMarketInstantListingFee
+                ? {
+                    amount: derivativeMarketInstantListingFee.amount,
+                    denom: derivativeMarketInstantListingFee.denom,
+                }
+                : undefined,
+            defaultSpotMakerFeeRate: params.defaultSpotMakerFeeRate,
+            defaultSpotTakerFeeRate: params.defaultSpotTakerFeeRate,
+            defaultDerivativeMakerFeeRate: params.defaultDerivativeMakerFeeRate,
+            defaultDerivativeTakerFeeRate: params.defaultDerivativeTakerFeeRate,
+            defaultInitialMarginRatio: params.defaultInitialMarginRatio,
+            defaultMaintenanceMarginRatio: params.defaultMaintenanceMarginRatio,
+            defaultFundingInterval: parseInt(params.defaultFundingInterval, 10),
+            fundingMultiple: parseInt(params.fundingMultiple, 10),
+            relayerFeeShareRate: params.relayerFeeShareRate,
+            defaultHourlyFundingRateCap: params.defaultHourlyFundingRateCap,
+            defaultHourlyInterestRate: params.defaultHourlyInterestRate,
+            maxDerivativeOrderSideCount: params.maxDerivativeOrderSideCount,
+            injRewardStakedRequirementThreshold: params.injRewardStakedRequirementThreshold,
+            tradingRewardsVestingDuration: parseInt(params.tradingRewardsVestingDuration, 10),
+            liquidatorRewardShareRate: params.liquidatorRewardShareRate,
+            binaryOptionsMarketInstantListingFee: params.binaryOptionsMarketInstantListingFee
+                ? {
+                    amount: params.binaryOptionsMarketInstantListingFee.amount,
+                    denom: params.binaryOptionsMarketInstantListingFee.denom,
+                }
+                : undefined,
+            atomicMarketOrderAccessLevel: InjectiveExchangeV1Beta1Exchange.atomicMarketOrderAccessLevelToJSON(params.atomicMarketOrderAccessLevel),
+            spotAtomicMarketOrderFeeMultiplier: params.spotAtomicMarketOrderFeeMultiplier,
+            derivativeAtomicMarketOrderFeeMultiplier: params.derivativeAtomicMarketOrderFeeMultiplier,
+            binaryOptionsAtomicMarketOrderFeeMultiplier: params.binaryOptionsAtomicMarketOrderFeeMultiplier,
+            minimalProtocolFeeRate: params.minimalProtocolFeeRate,
+            isInstantDerivativeMarketLaunchEnabled: params.isInstantDerivativeMarketLaunchEnabled,
+            postOnlyModeHeightThreshold: params.postOnlyModeHeightThreshold,
+            marginDecreasePriceTimestampThresholdSeconds: params.marginDecreasePriceTimestampThresholdSeconds,
+            exchangeAdmins: params.exchangeAdmins,
+        };
+    }
+    static feeDiscountScheduleResponseToFeeDiscountSchedule(response) {
+        const schedule = response.feeDiscountSchedule;
+        return {
+            bucketCount: parseInt(schedule.bucketCount, 10),
+            bucketDuration: parseInt(schedule.bucketDuration, 10),
+            quoteDenomsList: schedule.quoteDenoms,
+            tierInfosList: schedule.tierInfos
+                .map(ChainGrpcExchangeTransformer.grpcFeeDiscountTierInfoToFeeDiscountTierInfo)
+                .filter((info) => info),
+            disqualifiedMarketIdsList: schedule.disqualifiedMarketIds,
+        };
+    }
+    static tradingRewardsCampaignResponseToTradingRewardsCampaign(response) {
+        return {
+            tradingRewardCampaignInfo: ChainGrpcExchangeTransformer.grpcTradingRewardCampaignInfoToTradingRewardCampaignInfo(response.tradingRewardCampaignInfo),
+            tradingRewardPoolCampaignScheduleList: response.tradingRewardPoolCampaignSchedule.map(ChainGrpcExchangeTransformer.grpcCampaignRewardPoolToCampaignRewardPool),
+            pendingTradingRewardPoolCampaignScheduleList: response.pendingTradingRewardPoolCampaignSchedule.map(ChainGrpcExchangeTransformer.grpcCampaignRewardPoolToCampaignRewardPool),
+            totalTradeRewardPoints: response.totalTradeRewardPoints,
+            pendingTotalTradeRewardPointsList: response.pendingTotalTradeRewardPoints,
+        };
+    }
+    static feeDiscountAccountInfoResponseToFeeDiscountAccountInfo(response) {
+        return {
+            tierLevel: parseInt(response.tierLevel, 10),
+            accountInfo: ChainGrpcExchangeTransformer.grpcFeeDiscountTierInfoToFeeDiscountTierInfo(response.accountInfo),
+            accountTtl: ChainGrpcExchangeTransformer.grpcFeeDiscountTierTTLToFeeDiscountTierTTL(response.accountTtl),
+        };
+    }
+    static grpcFeeDiscountTierInfoToFeeDiscountTierInfo(info) {
+        if (!info) {
+            return;
+        }
+        return {
+            makerDiscountRate: info.makerDiscountRate,
+            takerDiscountRate: info.takerDiscountRate,
+            stakedAmount: info.stakedAmount,
+            volume: info.volume == undefined ? '0' : info.volume,
+        };
+    }
+    static grpcFeeDiscountTierTTLToFeeDiscountTierTTL(info) {
+        if (!info) {
+            return;
+        }
+        return {
+            tier: parseInt(info.tier, 10),
+            ttlTimestamp: parseInt(info.ttlTimestamp, 10),
+        };
+    }
+    static grpcPointsMultiplierToPointsMultiplier(point) {
+        return {
+            makerPointsMultiplier: point.makerPointsMultiplier,
+            takerPointsMultiplier: point.takerPointsMultiplier,
+        };
+    }
+    static grpcTradingRewardCampaignBoostInfoToTradingRewardCampaignBoostInfo(info) {
+        if (!info) {
+            return;
+        }
+        return {
+            boostedSpotMarketIdsList: info.boostedSpotMarketIds,
+            boostedDerivativeMarketIdsList: info.boostedDerivativeMarketIds,
+            spotMarketMultipliersList: info.spotMarketMultipliers.map(ChainGrpcExchangeTransformer.grpcPointsMultiplierToPointsMultiplier),
+            derivativeMarketMultipliersList: info.derivativeMarketMultipliers.map(ChainGrpcExchangeTransformer.grpcPointsMultiplierToPointsMultiplier),
+        };
+    }
+    static grpcTradingRewardCampaignInfoToTradingRewardCampaignInfo(info) {
+        if (!info) {
+            return;
+        }
+        return {
+            campaignDurationSeconds: parseInt(info.campaignDurationSeconds, 10),
+            quoteDenomsList: info.quoteDenoms,
+            tradingRewardBoostInfo: ChainGrpcExchangeTransformer.grpcTradingRewardCampaignBoostInfoToTradingRewardCampaignBoostInfo(info.tradingRewardBoostInfo),
+            disqualifiedMarketIdsList: info.disqualifiedMarketIds,
+        };
+    }
+    static grpcCampaignRewardPoolToCampaignRewardPool(pool) {
+        return {
+            startTimestamp: parseInt(pool.startTimestamp, 10),
+            maxCampaignRewardsList: pool.maxCampaignRewards.map((coin) => ({
+                amount: coin.amount,
+                denom: coin.denom,
+            })),
+        };
+    }
+    static grpcPositionToPosition(position) {
+        return {
+            islong: position.isLong,
+            ...position,
+        };
+    }
+    static positionsResponseToPositions(response) {
+        return response.state.map((position) => {
+            return {
+                subaccountId: position.subaccountId,
+                marketId: position.marketId,
+                position: ChainGrpcExchangeTransformer.grpcPositionToPosition(position.position),
+            };
+        });
+    }
+    static isOptedOutOfRewardsResponseToIsOptedOutOfRewards(response) {
+        return {
+            isOptedOut: response.isOptedOut,
+        };
+    }
+    static activeStakeGrantResponseToActiveStakeGrant(response) {
+        return {
+            grant: response.grant,
+            effectiveGrant: response.effectiveGrant,
+        };
+    }
+    static denomMinNotionalResponseToDenomMinNotional(response) {
+        return response.amount;
+    }
+    static denomDecimalsResponseToDenomDecimals(response) {
+        return response.denomDecimals.map((denomDecimals) => ({
+            denom: denomDecimals.denom,
+            decimals: denomDecimals.decimals,
+        }));
+    }
+    static denomMinNotionalsResponseToDenomMinNotionals(response) {
+        return response.denomMinNotionals.map((denomDecimals) => ({
+            denom: denomDecimals.denom,
+            minNotional: toHumanReadable(denomDecimals.minNotional).toFixed(),
+        }));
+    }
+    static spotMarketsResponseToSpotMarkets(response) {
+        return response.markets.map((market) => {
+            return ChainGrpcExchangeTransformer.grpcSpotMarketToSpotMarket(market);
+        });
+    }
+    static grpcSpotMarketToSpotMarket(market) {
+        const marketInfo = market;
+        return {
+            marketId: marketInfo.marketId,
+            marketStatus: InjectiveExchangeV1Beta1Exchange.marketStatusToJSON(marketInfo.status),
+            ticker: marketInfo.ticker,
+            baseDenom: marketInfo.baseDenom,
+            quoteDenom: marketInfo.quoteDenom,
+            makerFeeRate: denomAmountFromGrpcChainDenomAmount(marketInfo.makerFeeRate).toFixed(),
+            quoteToken: undefined,
+            baseToken: undefined,
+            takerFeeRate: denomAmountFromGrpcChainDenomAmount(marketInfo.takerFeeRate).toFixed(),
+            serviceProviderFee: '',
+            minPriceTickSize: denomAmountFromGrpcChainDenomAmount(marketInfo.minPriceTickSize).toNumber(),
+            minQuantityTickSize: denomAmountFromGrpcChainDenomAmount(marketInfo.minQuantityTickSize).toNumber(),
+            minNotional: denomAmountFromGrpcChainDenomAmount(marketInfo.minNotional).toNumber(),
+        };
+    }
+    static fullSpotMarketsResponseToSpotMarkets(response) {
+        return response.markets.map((market) => {
+            return ChainGrpcExchangeTransformer.grpcFullSpotMarketToSpotMarket(market);
+        });
+    }
+    static grpcFullSpotMarketToSpotMarket(market) {
+        const marketInfo = market.market;
+        return {
+            marketId: marketInfo.marketId,
+            marketStatus: InjectiveExchangeV1Beta1Exchange.marketStatusToJSON(marketInfo.status),
+            ticker: marketInfo.ticker,
+            baseDenom: marketInfo.baseDenom,
+            quoteDenom: marketInfo.quoteDenom,
+            makerFeeRate: marketInfo.makerFeeRate,
+            quoteToken: undefined,
+            baseToken: undefined,
+            takerFeeRate: marketInfo.takerFeeRate,
+            serviceProviderFee: '',
+            minPriceTickSize: Number(marketInfo.minPriceTickSize),
+            minQuantityTickSize: Number(marketInfo.minQuantityTickSize),
+            minNotional: Number(marketInfo.minNotional),
+        };
+    }
+    static fullDerivativeMarketsResponseToDerivativeMarkets(response) {
+        return response.markets.map((market) => {
+            return ChainGrpcExchangeTransformer.grpcFullDerivativeMarketToDerivativeMarket(market);
+        });
+    }
+    static grpcFullDerivativeMarketToDerivativeMarket(market) {
+        const marketInfo = market.market;
+        return {
+            oracleType: InjectiveOracleV1Beta1Oracle.oracleTypeToJSON(marketInfo.oracleType),
+            marketId: marketInfo.marketId,
+            marketStatus: InjectiveExchangeV1Beta1Exchange.marketStatusToJSON(marketInfo.status),
+            ticker: marketInfo.ticker,
+            quoteDenom: marketInfo.quoteDenom,
+            makerFeeRate: denomAmountFromGrpcChainDenomAmount(marketInfo.makerFeeRate).toFixed(),
+            takerFeeRate: denomAmountFromGrpcChainDenomAmount(marketInfo.takerFeeRate).toFixed(),
+            serviceProviderFee: '',
+            quoteToken: undefined,
+            minPriceTickSize: denomAmountFromGrpcChainDenomAmount(marketInfo.minPriceTickSize).toNumber(),
+            minQuantityTickSize: denomAmountFromGrpcChainDenomAmount(marketInfo.minQuantityTickSize).toNumber(),
+            minNotional: denomAmountFromGrpcChainDenomAmount(marketInfo.minNotional).toNumber(),
+            reduceMarginRatio: denomAmountFromGrpcChainDenomAmount(marketInfo.reduceMarginRatio).toFixed(),
+            initialMarginRatio: denomAmountFromGrpcChainDenomAmount(marketInfo.initialMarginRatio).toFixed(),
+            maintenanceMarginRatio: denomAmountFromGrpcChainDenomAmount(marketInfo.maintenanceMarginRatio).toFixed(),
+            isPerpetual: marketInfo.isPerpetual,
+            oracleBase: marketInfo.oracleBase,
+            oracleQuote: marketInfo.oracleQuote,
+            oracleScaleFactor: marketInfo.oracleScaleFactor,
+            perpetualMarketInfo: {
+                hourlyFundingRateCap: denomAmountFromGrpcChainDenomAmount(market.perpetualInfo?.marketInfo?.hourlyFundingRateCap ?? '0').toFixed(),
+                hourlyInterestRate: denomAmountFromGrpcChainDenomAmount(market.perpetualInfo?.marketInfo?.hourlyInterestRate ?? '0').toFixed(),
+                nextFundingTimestamp: parseInt(market.perpetualInfo?.marketInfo?.nextFundingTimestamp ?? '', 10),
+                fundingInterval: parseInt(market.perpetualInfo?.marketInfo?.fundingInterval ?? '', 10),
+            },
+            perpetualMarketFunding: {
+                cumulativeFunding: denomAmountFromGrpcChainDenomAmount(market.perpetualInfo?.fundingInfo?.cumulativeFunding ?? '0').toFixed(),
+                cumulativePrice: denomAmountFromGrpcChainDenomAmount(market.perpetualInfo?.fundingInfo?.cumulativePrice ?? '0').toFixed(),
+                lastTimestamp: parseInt(market.perpetualInfo?.fundingInfo?.lastTimestamp ?? '', 10),
+            },
+        };
+    }
+}

package/dist/esm/client/chain/transformers/ChainGrpcGovTransformer.d.ts

@@ -0,0 +1,31 @@
+import type { Pagination } from '../../../types/index.js';
+import type { CosmosGovV1Query } from '@injectivelabs/core-proto-ts';
+import type { Vote, Proposal, GrpcVote, TallyResult, GrpcProposal, ProposalDeposit, GrpcTallyResult, GovModuleStateParams, GrpcGovernanceTallyParams, GrpcGovernanceVotingParams, GrpcGovernanceDepositParams } from '../types/gov.js';
+/**
+ * @category Chain Grpc Transformer
+ */
+export declare class ChainGrpcGovTransformer {
+    static moduleParamsResponseToModuleParams(response: CosmosGovV1Query.QueryParamsResponse): GovModuleStateParams;
+    static moduleParamsResponseToModuleParamsByType({ depositParams, votingParams, tallyParams, }: {
+        depositParams: GrpcGovernanceDepositParams;
+        votingParams: GrpcGovernanceVotingParams;
+        tallyParams: GrpcGovernanceTallyParams;
+    }): GovModuleStateParams;
+    static proposalResponseToProposal(response: CosmosGovV1Query.QueryProposalResponse): Proposal | undefined;
+    static proposalsResponseToProposals(response: CosmosGovV1Query.QueryProposalsResponse): {
+        proposals: Proposal[];
+        pagination: Pagination;
+    };
+    static depositsResponseToDeposits(response: CosmosGovV1Query.QueryDepositsResponse): {
+        deposits: ProposalDeposit[];
+        pagination: Pagination;
+    };
+    static grpcVoteToVote(vote: GrpcVote): Vote;
+    static votesResponseToVotes(response: CosmosGovV1Query.QueryVotesResponse): {
+        votes: Vote[];
+        pagination: Pagination;
+    };
+    static tallyResultResponseToTallyResult(response: CosmosGovV1Query.QueryTallyResultResponse): TallyResult;
+    static grpcTallyResultToTallyResult(result: GrpcTallyResult | undefined): TallyResult;
+    static grpcProposalToProposal(proposal: GrpcProposal): Proposal | undefined;
+}

package/dist/esm/client/chain/transformers/ChainGrpcGovTransformer.js

@@ -0,0 +1,142 @@
+import { toHumanReadable } from '@injectivelabs/utils';
+import { uint8ArrayToString } from '../../../utils/index.js';
+import { ChainGrpcCommonTransformer } from './ChainGrpcCommonTransformer.js';
+/**
+ * @category Chain Grpc Transformer
+ */
+export class ChainGrpcGovTransformer {
+    static moduleParamsResponseToModuleParams(response) {
+        const params = response.params;
+        return {
+            depositParams: {
+                minDeposit: params?.minDeposit || [],
+                expeditedMinDeposit: params?.expeditedMinDeposit || [],
+                maxDepositPeriod: parseInt(params?.maxDepositPeriod?.seconds || '0', 10),
+            },
+            votingParams: {
+                votingPeriod: parseInt(params?.votingPeriod?.seconds || '0'),
+                expeditedVotingPeriod: parseInt(params?.expeditedVotingPeriod?.seconds || '0'),
+            },
+            tallyParams: {
+                quorum: uint8ArrayToString(params?.quorum || '0'),
+                threshold: uint8ArrayToString(params?.threshold || '0'),
+                vetoThreshold: uint8ArrayToString(params?.vetoThreshold || '0'),
+                expeditedThreshold: uint8ArrayToString(params?.expeditedThreshold || '0'),
+            },
+        };
+    }
+    static moduleParamsResponseToModuleParamsByType({ depositParams, votingParams, tallyParams, }) {
+        return {
+            depositParams: {
+                minDeposit: depositParams?.minDeposit,
+                expeditedMinDeposit: depositParams?.expeditedMinDeposit,
+                maxDepositPeriod: parseInt(depositParams?.maxDepositPeriod?.seconds || '0', 10),
+            },
+            votingParams: {
+                votingPeriod: parseInt(votingParams.votingPeriod?.seconds || '0'),
+                expeditedVotingPeriod: parseInt(votingParams.expeditedVotingPeriod?.seconds || '0'),
+            },
+            tallyParams: {
+                quorum: uint8ArrayToString(tallyParams.quorum),
+                threshold: uint8ArrayToString(tallyParams.threshold),
+                vetoThreshold: uint8ArrayToString(tallyParams.vetoThreshold),
+                expeditedThreshold: uint8ArrayToString(tallyParams.expeditedThreshold),
+            },
+        };
+    }
+    static proposalResponseToProposal(response) {
+        const proposal = response.proposal;
+        if (!proposal) {
+            return undefined;
+        }
+        return ChainGrpcGovTransformer.grpcProposalToProposal(proposal);
+    }
+    static proposalsResponseToProposals(response) {
+        const proposals = response.proposals.map((p) => ChainGrpcGovTransformer.grpcProposalToProposal(p));
+        const pagination = response.pagination;
+        return {
+            proposals: proposals.filter((p) => p),
+            pagination: ChainGrpcCommonTransformer.grpcPaginationToPagination(pagination),
+        };
+    }
+    static depositsResponseToDeposits(response) {
+        const pagination = response.pagination;
+        const deposits = response.deposits.map((deposit) => {
+            return {
+                depositor: deposit.depositor,
+                amounts: deposit.amount.map((coin) => ({
+                    denom: coin.denom,
+                    amount: toHumanReadable(coin.amount).toFixed(),
+                })),
+            };
+        });
+        return {
+            deposits: deposits,
+            pagination: ChainGrpcCommonTransformer.grpcPaginationToPagination(pagination),
+        };
+    }
+    static grpcVoteToVote(vote) {
+        return {
+            proposalId: parseInt(vote.proposalId, 10),
+            voter: vote.voter,
+            metadata: vote.metadata,
+            options: vote.options,
+        };
+    }
+    static votesResponseToVotes(response) {
+        return {
+            votes: response.votes.map(ChainGrpcGovTransformer.grpcVoteToVote),
+            pagination: ChainGrpcCommonTransformer.grpcPaginationToPagination(response.pagination),
+        };
+    }
+    static tallyResultResponseToTallyResult(response) {
+        const result = response.tally;
+        return ChainGrpcGovTransformer.grpcTallyResultToTallyResult(result);
+    }
+    static grpcTallyResultToTallyResult(result) {
+        return {
+            yesCount: result ? result.yesCount : '0',
+            abstainCount: result ? result.abstainCount : '0',
+            noCount: result ? result.noCount : '0',
+            noWithVetoCount: result ? result.noWithVetoCount : '0',
+        };
+    }
+    static grpcProposalToProposal(proposal) {
+        const finalTallyResult = proposal.finalTallyResult;
+        const [message] = proposal.messages;
+        if (!message) {
+            return;
+        }
+        return {
+            proposalId: parseInt(proposal.id, 10),
+            title: proposal.title,
+            summary: proposal.summary,
+            proposer: proposal.proposer,
+            content: {
+                type: message.typeUrl,
+                value: message.value,
+            },
+            type: message.typeUrl,
+            submitTime: proposal.submitTime
+                ? Math.floor(proposal.submitTime.getTime() / 1000)
+                : 0,
+            status: proposal.status,
+            expedited: proposal.expedited,
+            failedReason: proposal.failedReason,
+            finalTallyResult: ChainGrpcGovTransformer.grpcTallyResultToTallyResult(finalTallyResult),
+            depositEndTime: proposal.depositEndTime
+                ? Math.floor(proposal.depositEndTime.getTime() / 1000)
+                : 0,
+            totalDeposits: proposal.totalDeposit.map((coin) => ({
+                denom: coin.denom,
+                amount: toHumanReadable(coin.amount).toFixed(),
+            })),
+            votingStartTime: proposal.votingStartTime
+                ? Math.floor(proposal.votingStartTime.getTime() / 1000)
+                : 0,
+            votingEndTime: proposal.votingEndTime
+                ? Math.floor(proposal.votingEndTime.getTime() / 1000)
+                : 0,
+        };
+    }
+}

package/dist/esm/client/chain/transformers/ChainGrpcInsuranceFundTransformer.d.ts

@@ -0,0 +1,20 @@
+import type { GrpcInsuranceFund } from '../types/insurance.js';
+import type { InjectiveInsuranceV1Beta1Query } from '@injectivelabs/core-proto-ts';
+import type { InsuranceFund, InsuranceModuleParams } from '../types/insurance.js';
+/**
+ * @category Chain Grpc Transformer
+ */
+export declare class ChainGrpcInsuranceFundTransformer {
+    static moduleParamsResponseToModuleParams(response: InjectiveInsuranceV1Beta1Query.QueryInsuranceParamsResponse): InsuranceModuleParams;
+    static grpcInsuranceFundToInsuranceFund(grpcFund: GrpcInsuranceFund): InsuranceFund;
+    static insuranceFundResponseToInsuranceFund(response: InjectiveInsuranceV1Beta1Query.QueryInsuranceFundResponse): InsuranceFund;
+    static insuranceFundsResponseToInsuranceFunds(response: InjectiveInsuranceV1Beta1Query.QueryInsuranceFundsResponse): InsuranceFund[];
+    static redemptionsResponseToRedemptions(response: InjectiveInsuranceV1Beta1Query.QueryEstimatedRedemptionsResponse): {
+        amount: string;
+        denom: string;
+    }[];
+    static estimatedRedemptionsResponseToEstimatedRedemptions(response: InjectiveInsuranceV1Beta1Query.QueryPendingRedemptionsResponse): {
+        amount: string;
+        denom: string;
+    }[];
+}

package/dist/esm/client/chain/transformers/ChainGrpcInsuranceFundTransformer.js

@@ -0,0 +1,48 @@
+/**
+ * @category Chain Grpc Transformer
+ */
+export class ChainGrpcInsuranceFundTransformer {
+    static moduleParamsResponseToModuleParams(response) {
+        const params = response.params;
+        return {
+            defaultRedemptionNoticePeriodDuration: parseInt(params.defaultRedemptionNoticePeriodDuration?.seconds || '0', 10),
+        };
+    }
+    static grpcInsuranceFundToInsuranceFund(grpcFund) {
+        return {
+            depositDenom: grpcFund.depositDenom,
+            insurancePoolTokenDenom: grpcFund.insurancePoolTokenDenom,
+            redemptionNoticePeriodDuration: parseInt(grpcFund.redemptionNoticePeriodDuration?.seconds || '0', 10),
+            balance: grpcFund.balance,
+            totalShare: grpcFund.totalShare,
+            marketId: grpcFund.marketId,
+            marketTicker: grpcFund.marketTicker,
+            oracleBase: grpcFund.oracleBase,
+            oracleQuote: grpcFund.oracleQuote,
+            oracleType: grpcFund.oracleType,
+            expiry: parseInt(grpcFund.expiry, 10),
+        };
+    }
+    static insuranceFundResponseToInsuranceFund(response) {
+        return ChainGrpcInsuranceFundTransformer.grpcInsuranceFundToInsuranceFund(response.fund);
+    }
+    static insuranceFundsResponseToInsuranceFunds(response) {
+        return response.funds.map((fund) => ChainGrpcInsuranceFundTransformer.grpcInsuranceFundToInsuranceFund(fund));
+    }
+    static redemptionsResponseToRedemptions(response) {
+        return response.amount.map((amount) => {
+            return {
+                amount: amount.amount,
+                denom: amount.denom,
+            };
+        });
+    }
+    static estimatedRedemptionsResponseToEstimatedRedemptions(response) {
+        return response.amount.map((amount) => {
+            return {
+                amount: amount.amount,
+                denom: amount.denom,
+            };
+        });
+    }
+}

package/dist/esm/client/chain/transformers/ChainGrpcMintTransformer.d.ts

@@ -0,0 +1,8 @@
+import type { MinModuleParams } from '../types/mint.js';
+import type { CosmosMintV1Beta1Query } from '@injectivelabs/core-proto-ts';
+/**
+ * @category Chain Grpc Transformer
+ */
+export declare class ChainGrpcMintTransformer {
+    static moduleParamsResponseToModuleParams(response: CosmosMintV1Beta1Query.QueryParamsResponse): MinModuleParams;
+}

package/dist/esm/client/chain/transformers/ChainGrpcMintTransformer.js

@@ -0,0 +1,9 @@
+/**
+ * @category Chain Grpc Transformer
+ */
+export class ChainGrpcMintTransformer {
+    static moduleParamsResponseToModuleParams(response) {
+        const params = response.params;
+        return params;
+    }
+}