@injectivelabs/sdk-ts 1.20.40 → 1.20.41

package/dist/esm/{chain-lwkNu_TP.js → chain-CN3u6aoh.js}

@@ -1,6 +1,7 @@
 import { d as toBase64, h as uint8ArrayToString, o as fromUtf8, p as uint8ArrayToBase64, t as base64ToUint8Array } from "./encoding-light-BpntDob-.js";
 import { t as _defineProperty } from "./defineProperty-BwBXXd7t.js";
 import { Ft as protobufTimestampToDate, Lt as protobufTimestampToUnixSeconds, _t as bigIntToString, l as ChainGrpcCommonTransformer, n as fetchAllWithPagination, y as denomAmountFromGrpcChainDenomAmount } from "./utils-BPuX8T_g.js";
+import { n as bytesToHex } from "./address-light-B2JvY3Or.js";
 import { o as ChainModule, p as BondStatus } from "./ChainRestTendermintApi-bwqA_ww1.js";
 import { t as BaseGrpcConsumer } from "./BaseGrpcConsumer-DEDRwnCk.js";
 import { t as BaseRestConsumer } from "./BaseRestConsumer-BjN9JApr.js";
@@ -35,14 +36,16 @@ import * as InjectiveAuctionV1Beta1QueryPb from "@injectivelabs/core-proto-ts-v2
 import { QueryClient as QueryClient$12 } from "@injectivelabs/core-proto-ts-v2/generated/injective/auction/v1beta1/query_pb.client";
 import * as CosmosStakingV1Beta1QueryPb from "@injectivelabs/core-proto-ts-v2/generated/cosmos/staking/v1beta1/query_pb";
 import { QueryClient as QueryClient$13 } from "@injectivelabs/core-proto-ts-v2/generated/cosmos/staking/v1beta1/query_pb.client";
+import * as InjectiveExchangeV2QueryPb from "@injectivelabs/core-proto-ts-v2/generated/injective/exchange/v2/query_pb";
+import { QueryClient as QueryClient$14 } from "@injectivelabs/core-proto-ts-v2/generated/injective/exchange/v2/query_pb.client";
 import * as InjectivePermissionsV1Beta1QueryPb from "@injectivelabs/core-proto-ts-v2/generated/injective/permissions/v1beta1/query_pb";
-import { QueryClient as QueryClient$14 } from "@injectivelabs/core-proto-ts-v2/generated/injective/permissions/v1beta1/query_pb.client";
+import { QueryClient as QueryClient$15 } from "@injectivelabs/core-proto-ts-v2/generated/injective/permissions/v1beta1/query_pb.client";
 import * as CosmosDistributionV1Beta1QueryPb from "@injectivelabs/core-proto-ts-v2/generated/cosmos/distribution/v1beta1/query_pb";
-import { QueryClient as QueryClient$15 } from "@injectivelabs/core-proto-ts-v2/generated/cosmos/distribution/v1beta1/query_pb.client";
+import { QueryClient as QueryClient$16 } from "@injectivelabs/core-proto-ts-v2/generated/cosmos/distribution/v1beta1/query_pb.client";
 import * as InjectiveTokenFactoryV1Beta1QueryPb from "@injectivelabs/core-proto-ts-v2/generated/injective/tokenfactory/v1beta1/query_pb";
-import { QueryClient as QueryClient$16 } from "@injectivelabs/core-proto-ts-v2/generated/injective/tokenfactory/v1beta1/query_pb.client";
+import { QueryClient as QueryClient$17 } from "@injectivelabs/core-proto-ts-v2/generated/injective/tokenfactory/v1beta1/query_pb.client";
 import * as InjectiveInsuranceV1Beta1QueryPb from "@injectivelabs/core-proto-ts-v2/generated/injective/insurance/v1beta1/query_pb";
-import { QueryClient as QueryClient$17 } from "@injectivelabs/core-proto-ts-v2/generated/injective/insurance/v1beta1/query_pb.client";
+import { QueryClient as QueryClient$18 } from "@injectivelabs/core-proto-ts-v2/generated/injective/insurance/v1beta1/query_pb.client";
 import { StatusCodes } from "http-status-codes";
 
 //#region src/client/chain/transformers/ChainGrpcGovTransformer.ts
@@ -831,6 +834,546 @@ var ChainGrpcStakingTransformer = class ChainGrpcStakingTransformer {
 	}
 };
 
+//#endregion
+//#region src/client/chain/transformers/ChainGrpcExchangeTransformerV2.ts
+/**
+* @category Chain Grpc Transformer
+*/
+var ChainGrpcExchangeTransformerV2 = class ChainGrpcExchangeTransformerV2 {
+	static moduleStateResponseToModuleState(response) {
+		if (!response.state) throw new Error("Exchange module state not found in response");
+		return response.state;
+	}
+	static moduleParamsResponseToParams(response) {
+		const params = response.params;
+		return {
+			spotMarketInstantListingFee: params.spotMarketInstantListingFee,
+			derivativeMarketInstantListingFee: params.derivativeMarketInstantListingFee,
+			defaultSpotMakerFeeRate: params.defaultSpotMakerFeeRate,
+			defaultSpotTakerFeeRate: params.defaultSpotTakerFeeRate,
+			defaultDerivativeMakerFeeRate: params.defaultDerivativeMakerFeeRate,
+			defaultDerivativeTakerFeeRate: params.defaultDerivativeTakerFeeRate,
+			defaultInitialMarginRatio: params.defaultInitialMarginRatio,
+			defaultMaintenanceMarginRatio: params.defaultMaintenanceMarginRatio,
+			defaultFundingInterval: Number(params.defaultFundingInterval),
+			fundingMultiple: Number(params.fundingMultiple),
+			relayerFeeShareRate: params.relayerFeeShareRate,
+			defaultHourlyFundingRateCap: params.defaultHourlyFundingRateCap,
+			defaultHourlyInterestRate: params.defaultHourlyInterestRate,
+			maxDerivativeOrderSideCount: params.maxDerivativeOrderSideCount,
+			injRewardStakedRequirementThreshold: params.injRewardStakedRequirementThreshold,
+			tradingRewardsVestingDuration: Number(params.tradingRewardsVestingDuration),
+			liquidatorRewardShareRate: params.liquidatorRewardShareRate,
+			binaryOptionsMarketInstantListingFee: params.binaryOptionsMarketInstantListingFee,
+			atomicMarketOrderAccessLevel: params.atomicMarketOrderAccessLevel.toString(),
+			spotAtomicMarketOrderFeeMultiplier: params.spotAtomicMarketOrderFeeMultiplier,
+			derivativeAtomicMarketOrderFeeMultiplier: params.derivativeAtomicMarketOrderFeeMultiplier,
+			binaryOptionsAtomicMarketOrderFeeMultiplier: params.binaryOptionsAtomicMarketOrderFeeMultiplier,
+			minimalProtocolFeeRate: params.minimalProtocolFeeRate,
+			isInstantDerivativeMarketLaunchEnabled: params.isInstantDerivativeMarketLaunchEnabled,
+			postOnlyModeHeightThreshold: params.postOnlyModeHeightThreshold.toString(),
+			marginDecreasePriceTimestampThresholdSeconds: params.marginDecreasePriceTimestampThresholdSeconds.toString(),
+			exchangeAdmins: params.exchangeAdmins
+		};
+	}
+	static feeDiscountScheduleResponseToFeeDiscountSchedule(response) {
+		const schedule = response.feeDiscountSchedule;
+		return {
+			bucketCount: Number(schedule.bucketCount),
+			bucketDuration: Number(schedule.bucketDuration),
+			quoteDenomsList: schedule.quoteDenoms,
+			tierInfosList: schedule.tierInfos.map(ChainGrpcExchangeTransformerV2.grpcFeeDiscountTierInfoToFeeDiscountTierInfo).filter((info) => info !== void 0),
+			disqualifiedMarketIdsList: schedule.disqualifiedMarketIds
+		};
+	}
+	static feeDiscountAccountInfoResponseToFeeDiscountAccountInfo(response) {
+		return {
+			tierLevel: Number(response.tierLevel),
+			accountInfo: ChainGrpcExchangeTransformerV2.grpcFeeDiscountTierInfoToFeeDiscountTierInfo(response.accountInfo),
+			accountTtl: ChainGrpcExchangeTransformerV2.grpcFeeDiscountTierTTLToFeeDiscountTierTTL(response.accountTtl)
+		};
+	}
+	static grpcFeeDiscountTierInfoToFeeDiscountTierInfo(info) {
+		var _info$volume;
+		return info ? {
+			makerDiscountRate: info.makerDiscountRate,
+			takerDiscountRate: info.takerDiscountRate,
+			stakedAmount: info.stakedAmount,
+			volume: (_info$volume = info.volume) !== null && _info$volume !== void 0 ? _info$volume : "0"
+		} : void 0;
+	}
+	static grpcFeeDiscountTierTTLToFeeDiscountTierTTL(info) {
+		return info ? {
+			tier: Number(info.tier),
+			ttlTimestamp: Number(info.ttlTimestamp)
+		} : void 0;
+	}
+	static grpcPointsMultiplierToPointsMultiplier(point) {
+		return {
+			makerPointsMultiplier: point.makerPointsMultiplier,
+			takerPointsMultiplier: point.takerPointsMultiplier
+		};
+	}
+	static grpcTradingRewardCampaignBoostInfoToTradingRewardCampaignBoostInfo(info) {
+		return info ? {
+			boostedSpotMarketIdsList: info.boostedSpotMarketIds,
+			spotMarketMultipliersList: info.spotMarketMultipliers.map(ChainGrpcExchangeTransformerV2.grpcPointsMultiplierToPointsMultiplier),
+			boostedDerivativeMarketIdsList: info.boostedDerivativeMarketIds,
+			derivativeMarketMultipliersList: info.derivativeMarketMultipliers.map(ChainGrpcExchangeTransformerV2.grpcPointsMultiplierToPointsMultiplier)
+		} : void 0;
+	}
+	static grpcTradingRewardCampaignInfoToTradingRewardCampaignInfo(info) {
+		return info ? {
+			campaignDurationSeconds: Number(info.campaignDurationSeconds),
+			quoteDenomsList: info.quoteDenoms,
+			tradingRewardBoostInfo: ChainGrpcExchangeTransformerV2.grpcTradingRewardCampaignBoostInfoToTradingRewardCampaignBoostInfo(info.tradingRewardBoostInfo),
+			disqualifiedMarketIdsList: info.disqualifiedMarketIds
+		} : void 0;
+	}
+	static grpcCampaignRewardPoolToCampaignRewardPool(pool) {
+		return {
+			startTimestamp: Number(pool.startTimestamp),
+			maxCampaignRewardsList: pool.maxCampaignRewards.map((coin) => ({
+				amount: coin.amount,
+				denom: coin.denom
+			}))
+		};
+	}
+	static tradingRewardsCampaignResponseToTradingRewardsCampaign(response) {
+		return {
+			tradingRewardCampaignInfo: ChainGrpcExchangeTransformerV2.grpcTradingRewardCampaignInfoToTradingRewardCampaignInfo(response.tradingRewardCampaignInfo),
+			tradingRewardPoolCampaignScheduleList: response.tradingRewardPoolCampaignSchedule.map(ChainGrpcExchangeTransformerV2.grpcCampaignRewardPoolToCampaignRewardPool),
+			pendingTradingRewardPoolCampaignScheduleList: response.pendingTradingRewardPoolCampaignSchedule.map(ChainGrpcExchangeTransformerV2.grpcCampaignRewardPoolToCampaignRewardPool),
+			totalTradeRewardPoints: response.totalTradeRewardPoints,
+			pendingTotalTradeRewardPointsList: response.pendingTotalTradeRewardPoints
+		};
+	}
+	static isOptedOutOfRewardsResponseToIsOptedOutOfRewards(response) {
+		return { isOptedOut: response.isOptedOut };
+	}
+	static activeStakeGrantResponseToActiveStakeGrant(response) {
+		if (!response.grant || !response.effectiveGrant) throw new Error("Active stake grant not found in response");
+		return {
+			grant: response.grant,
+			effectiveGrant: response.effectiveGrant
+		};
+	}
+	static denomDecimalsResponseToDenomDecimals(response) {
+		return response.denomDecimals.map((item) => ({
+			denom: item.denom,
+			decimals: item.decimals.toString()
+		}));
+	}
+	static denomMinNotionalsResponseToDenomMinNotionals(response) {
+		return response.denomMinNotionals.map((item) => ({
+			denom: item.denom,
+			minNotional: item.minNotional
+		}));
+	}
+	static l3OrderbookResponseToOrderbook(response) {
+		return {
+			bids: response.bids.map((order) => ({
+				price: order.price,
+				quantity: order.quantity,
+				orderHash: order.orderHash,
+				subaccountId: order.subaccountId
+			})),
+			asks: response.asks.map((order) => ({
+				price: order.price,
+				quantity: order.quantity,
+				orderHash: order.orderHash,
+				subaccountId: order.subaccountId
+			})),
+			sequence: Number(response.seq)
+		};
+	}
+	static orderbookResponseToOrderbook(response) {
+		return {
+			buys: response.buysPriceLevel.map(ChainGrpcExchangeTransformerV2.grpcLevelToOrderbookLevel),
+			sells: response.sellsPriceLevel.map(ChainGrpcExchangeTransformerV2.grpcLevelToOrderbookLevel),
+			sequence: Number(response.seq)
+		};
+	}
+	static grpcLevelToOrderbookLevel(level) {
+		return {
+			price: level.p,
+			quantity: level.q
+		};
+	}
+	static grpcTrimmedSpotLimitOrderToOrder(order) {
+		return {
+			price: order.price,
+			quantity: order.quantity,
+			fillable: order.fillable,
+			isBuy: order.isBuy,
+			orderHash: order.orderHash,
+			cid: order.cid
+		};
+	}
+	static grpcTrimmedDerivativeLimitOrderToOrder(order) {
+		return {
+			...ChainGrpcExchangeTransformerV2.grpcTrimmedSpotLimitOrderToOrder(order),
+			margin: order.margin
+		};
+	}
+	static spotOrdersResponseToOrders(response) {
+		return { orders: response.orders.map(ChainGrpcExchangeTransformerV2.grpcTrimmedSpotLimitOrderToOrder) };
+	}
+	static derivativeOrdersResponseToOrders(response) {
+		return { orders: response.orders.map(ChainGrpcExchangeTransformerV2.grpcTrimmedDerivativeLimitOrderToOrder) };
+	}
+	static grpcSubaccountOrderDataToOrderData(data) {
+		return {
+			order: data.order ? {
+				price: data.order.price,
+				quantity: data.order.quantity,
+				isReduceOnly: data.order.isReduceOnly,
+				cid: data.order.cid
+			} : void 0,
+			orderHash: bytesToHex(data.orderHash)
+		};
+	}
+	static subaccountOrdersResponseToOrders(response) {
+		return {
+			buyOrders: response.buyOrders.map(ChainGrpcExchangeTransformerV2.grpcSubaccountOrderDataToOrderData),
+			sellOrders: response.sellOrders.map(ChainGrpcExchangeTransformerV2.grpcSubaccountOrderDataToOrderData)
+		};
+	}
+	static crossMarginPoolSnapshotResponseToCrossMarginPoolSnapshot(response) {
+		return {
+			quoteDenom: response.quoteDenom,
+			quoteBalance: response.quoteBalance,
+			positionMarginTotal: response.positionMarginTotal,
+			unrealizedPnl: response.unrealizedPnl,
+			unrealizedPnlEffective: response.unrealizedPnlEffective,
+			equityAdmission: response.equityAdmission,
+			equityLiquidation: response.equityLiquidation,
+			initialMarginTotal: response.initialMarginTotal,
+			maintenanceMarginTotal: response.maintenanceMarginTotal,
+			initialMarginWithOrdersTotal: response.initialMarginWithOrdersTotal,
+			entryLossTotal: response.entryLossTotal,
+			feeReserveTotal: response.feeReserveTotal,
+			orderLockRequirement: response.orderLockRequirement,
+			positiveUpnlHaircutRate: response.positiveUpnlHaircutRate,
+			healthFactor: response.healthFactor
+		};
+	}
+	static tradeRewardPointsResponseToTradeRewardPoints(response) {
+		return { accountTradeRewardPoints: response.accountTradeRewardPoints };
+	}
+	static openInterestResponseToOpenInterest(response) {
+		return { amount: response.amount ? {
+			marketId: response.amount.marketId,
+			balance: response.amount.balance
+		} : void 0 };
+	}
+	static subaccountDepositsResponseToSubaccountDeposits(response) {
+		return { deposits: Object.fromEntries(Object.entries(response.deposits).map(([denom, deposit]) => [denom, {
+			availableBalance: deposit.availableBalance,
+			totalBalance: deposit.totalBalance
+		}])) };
+	}
+	static subaccountDepositResponseToSubaccountDeposit(response) {
+		return { deposits: response.deposits ? {
+			availableBalance: response.deposits.availableBalance,
+			totalBalance: response.deposits.totalBalance
+		} : void 0 };
+	}
+	static aggregateVolumeResponseToAggregateVolume(response) {
+		return { aggregateVolumes: response.aggregateVolumes.map(ChainGrpcExchangeTransformerV2.grpcMarketVolumeToMarketVolume) };
+	}
+	static aggregateVolumesResponseToAggregateVolumes(response) {
+		return {
+			aggregateAccountVolumes: response.aggregateAccountVolumes.map((record) => ({
+				account: record.account,
+				marketVolumes: record.marketVolumes.map(ChainGrpcExchangeTransformerV2.grpcMarketVolumeToMarketVolume)
+			})),
+			aggregateMarketVolumes: response.aggregateMarketVolumes.map(ChainGrpcExchangeTransformerV2.grpcMarketVolumeToMarketVolume)
+		};
+	}
+	static aggregateMarketVolumeResponseToAggregateMarketVolume(response) {
+		return { volume: response.volume ? {
+			makerVolume: response.volume.makerVolume,
+			takerVolume: response.volume.takerVolume
+		} : void 0 };
+	}
+	static aggregateMarketVolumesResponseToAggregateMarketVolumes(response) {
+		return { volumes: response.volumes.map(ChainGrpcExchangeTransformerV2.grpcMarketVolumeToMarketVolume) };
+	}
+	static midPriceAndTobResponseToMidPriceAndTob(response) {
+		return {
+			midPrice: response.midPrice,
+			bestBuyPrice: response.bestBuyPrice,
+			bestSellPrice: response.bestSellPrice
+		};
+	}
+	static derivativeMarketAddressResponseToDerivativeMarketAddress(response) {
+		return {
+			address: response.address,
+			subaccountId: response.subaccountId
+		};
+	}
+	static grpcMarketVolumeToMarketVolume(marketVolume) {
+		return {
+			marketId: marketVolume.marketId,
+			volume: marketVolume.volume ? {
+				makerVolume: marketVolume.volume.makerVolume,
+				takerVolume: marketVolume.volume.takerVolume
+			} : void 0
+		};
+	}
+	static spotMarketsResponseToSpotMarkets(response) {
+		return response.markets.map(ChainGrpcExchangeTransformerV2.grpcSpotMarketToSpotMarket);
+	}
+	static grpcSpotMarketToSpotMarket(market) {
+		return {
+			marketId: market.marketId,
+			marketStatus: market.status.toString(),
+			ticker: market.ticker,
+			baseDenom: market.baseDenom,
+			quoteDenom: market.quoteDenom,
+			makerFeeRate: market.makerFeeRate,
+			quoteToken: void 0,
+			baseToken: void 0,
+			takerFeeRate: market.takerFeeRate,
+			serviceProviderFee: "",
+			minPriceTickSize: Number(market.minPriceTickSize),
+			minQuantityTickSize: Number(market.minQuantityTickSize),
+			minNotional: Number(market.minNotional)
+		};
+	}
+	static fullSpotMarketsResponseToSpotMarkets(response) {
+		return response.markets.map(ChainGrpcExchangeTransformerV2.grpcFullSpotMarketToSpotMarket);
+	}
+	static grpcFullSpotMarketToSpotMarket(market) {
+		return ChainGrpcExchangeTransformerV2.grpcSpotMarketToSpotMarket(market.market);
+	}
+	static derivativeMarketsResponseToDerivativeMarkets(response) {
+		return response.markets.map(ChainGrpcExchangeTransformerV2.grpcFullDerivativeMarketToDerivativeMarket);
+	}
+	static grpcFullDerivativeMarketToDerivativeMarket(market) {
+		var _market$info, _perpetualMarketInfo$, _perpetualMarketInfo$2, _perpetualMarketInfo$3, _perpetualMarketInfo$4;
+		const marketInfo = market.market;
+		const perpetualMarketInfo = ((_market$info = market.info) === null || _market$info === void 0 ? void 0 : _market$info.oneofKind) === "perpetualInfo" ? market.info.perpetualInfo.marketInfo : void 0;
+		return {
+			oracleType: marketInfo.oracleType.toString(),
+			marketId: marketInfo.marketId,
+			marketStatus: marketInfo.status.toString(),
+			ticker: marketInfo.ticker,
+			quoteDenom: marketInfo.quoteDenom,
+			makerFeeRate: marketInfo.makerFeeRate,
+			takerFeeRate: marketInfo.takerFeeRate,
+			serviceProviderFee: "",
+			quoteToken: void 0,
+			minPriceTickSize: Number(marketInfo.minPriceTickSize),
+			minQuantityTickSize: Number(marketInfo.minQuantityTickSize),
+			minNotional: Number(marketInfo.minNotional),
+			reduceMarginRatio: marketInfo.reduceMarginRatio,
+			initialMarginRatio: marketInfo.initialMarginRatio,
+			maintenanceMarginRatio: marketInfo.maintenanceMarginRatio,
+			isPerpetual: marketInfo.isPerpetual,
+			oracleBase: marketInfo.oracleBase,
+			oracleQuote: marketInfo.oracleQuote,
+			oracleScaleFactor: marketInfo.oracleScaleFactor,
+			perpetualMarketInfo: {
+				hourlyFundingRateCap: (_perpetualMarketInfo$ = perpetualMarketInfo === null || perpetualMarketInfo === void 0 ? void 0 : perpetualMarketInfo.hourlyFundingRateCap) !== null && _perpetualMarketInfo$ !== void 0 ? _perpetualMarketInfo$ : "0",
+				hourlyInterestRate: (_perpetualMarketInfo$2 = perpetualMarketInfo === null || perpetualMarketInfo === void 0 ? void 0 : perpetualMarketInfo.hourlyInterestRate) !== null && _perpetualMarketInfo$2 !== void 0 ? _perpetualMarketInfo$2 : "0",
+				nextFundingTimestamp: Number((_perpetualMarketInfo$3 = perpetualMarketInfo === null || perpetualMarketInfo === void 0 ? void 0 : perpetualMarketInfo.nextFundingTimestamp) !== null && _perpetualMarketInfo$3 !== void 0 ? _perpetualMarketInfo$3 : 0),
+				fundingInterval: Number((_perpetualMarketInfo$4 = perpetualMarketInfo === null || perpetualMarketInfo === void 0 ? void 0 : perpetualMarketInfo.fundingInterval) !== null && _perpetualMarketInfo$4 !== void 0 ? _perpetualMarketInfo$4 : 0)
+			}
+		};
+	}
+	static subaccountRiskProfileResponseToSubaccountRiskProfile(response) {
+		return {
+			profile: response.profile ? {
+				mode: response.profile.mode,
+				reservationPolicy: response.profile.reservationPolicy,
+				creditLineId: response.profile.creditLineId
+			} : void 0,
+			isDefault: response.isDefault
+		};
+	}
+	static positionsResponseToPositions(response) {
+		return response.state.map(ChainGrpcExchangeTransformerV2.grpcDerivativePositionToDerivativePosition);
+	}
+	static positionsInMarketResponseToPositions(response) {
+		return { state: response.state.map(ChainGrpcExchangeTransformerV2.grpcDerivativePositionToDerivativePosition) };
+	}
+	static grpcDerivativePositionToDerivativePosition(position) {
+		return {
+			subaccountId: position.subaccountId,
+			marketId: position.marketId,
+			position: position.position ? {
+				islong: position.position.isLong,
+				quantity: position.position.quantity,
+				entryPrice: position.position.entryPrice,
+				margin: position.position.margin,
+				cumulativeFundingEntry: position.position.cumulativeFundingEntry
+			} : void 0
+		};
+	}
+	static effectivePositionResponseToEffectivePosition(response) {
+		return {
+			state: response.state ? {
+				isLong: response.state.isLong,
+				quantity: response.state.quantity,
+				entryPrice: response.state.entryPrice,
+				effectiveMargin: response.state.effectiveMargin
+			} : void 0,
+			riskMode: response.riskMode
+		};
+	}
+	static positionInMarketResponseToPositionInMarket(response) {
+		return {
+			state: response.state ? {
+				islong: response.state.isLong,
+				quantity: response.state.quantity,
+				entryPrice: response.state.entryPrice,
+				margin: response.state.margin,
+				cumulativeFundingEntry: response.state.cumulativeFundingEntry
+			} : void 0,
+			riskMode: response.riskMode
+		};
+	}
+	static perpetualMarketInfoResponseToPerpetualMarketInfo(response) {
+		return { info: response.info ? {
+			marketId: response.info.marketId,
+			hourlyFundingRateCap: response.info.hourlyFundingRateCap,
+			hourlyInterestRate: response.info.hourlyInterestRate,
+			nextFundingTimestamp: Number(response.info.nextFundingTimestamp),
+			fundingInterval: Number(response.info.fundingInterval)
+		} : void 0 };
+	}
+	static expiryFuturesMarketInfoResponseToExpiryFuturesMarketInfo(response) {
+		return { info: response.info ? {
+			marketId: response.info.marketId,
+			expirationTimestamp: Number(response.info.expirationTimestamp),
+			twapStartTimestamp: Number(response.info.twapStartTimestamp),
+			expirationTwapStartPriceCumulative: response.info.expirationTwapStartPriceCumulative,
+			settlementPrice: response.info.settlementPrice,
+			expirationTwapStartBaseCumulativePrice: response.info.expirationTwapStartBaseCumulativePrice,
+			expirationTwapStartQuoteCumulativePrice: response.info.expirationTwapStartQuoteCumulativePrice
+		} : void 0 };
+	}
+	static perpetualMarketFundingResponseToPerpetualMarketFunding(response) {
+		return { state: response.state ? {
+			cumulativeFunding: response.state.cumulativeFunding,
+			cumulativePrice: response.state.cumulativePrice,
+			lastTimestamp: Number(response.state.lastTimestamp)
+		} : void 0 };
+	}
+	static feeDiscountTierStatisticsResponseToFeeDiscountTierStatistics(response) {
+		return { statistics: response.statistics.map((statistic) => ({
+			tier: Number(statistic.tier),
+			count: Number(statistic.count)
+		})) };
+	}
+	static historicalTradeRecordsResponseToHistoricalTradeRecords(response) {
+		return { tradeRecords: response.tradeRecords.map((records) => ({
+			marketId: records.marketId,
+			latestTradeRecords: records.latestTradeRecords.map(ChainGrpcExchangeTransformerV2.grpcTradeRecordToTradeRecord)
+		})) };
+	}
+	static grpcTradeRecordToTradeRecord(record) {
+		return {
+			timestamp: Number(record.timestamp),
+			price: record.price,
+			quantity: record.quantity
+		};
+	}
+	static grantAuthorizationsResponseToGrantAuthorizations(response) {
+		return {
+			totalGrantAmount: response.totalGrantAmount,
+			grants: response.grants.map((grant) => ({
+				grantee: grant.grantee,
+				amount: grant.amount
+			}))
+		};
+	}
+	static marketBalanceResponseToMarketBalance(response) {
+		return { balance: response.balance ? {
+			marketId: response.balance.marketId,
+			balance: response.balance.balance
+		} : void 0 };
+	}
+	static derivativeConditionalOrdersResponseToDerivativeConditionalOrders(response) {
+		return { orders: response.orders.map((order) => ({
+			price: order.price,
+			quantity: order.quantity,
+			margin: order.margin,
+			triggerPrice: order.triggerPrice,
+			isBuy: order.isBuy,
+			isLimit: order.isLimit,
+			orderHash: order.orderHash,
+			cid: order.cid
+		})) };
+	}
+	static subaccountOrderMetadataResponseToSubaccountOrderMetadata(response) {
+		return { metadata: response.metadata.map((item) => ({
+			marketId: item.marketId,
+			isBuy: item.isBuy,
+			metadata: item.metadata ? {
+				vanillaLimitOrderCount: item.metadata.vanillaLimitOrderCount,
+				reduceOnlyLimitOrderCount: item.metadata.reduceOnlyLimitOrderCount,
+				aggregateReduceOnlyQuantity: item.metadata.aggregateReduceOnlyQuantity,
+				aggregateVanillaQuantity: item.metadata.aggregateVanillaQuantity,
+				vanillaConditionalOrderCount: item.metadata.vanillaConditionalOrderCount,
+				reduceOnlyConditionalOrderCount: item.metadata.reduceOnlyConditionalOrderCount
+			} : void 0
+		})) };
+	}
+	static binaryOptionsMarketsResponseToBinaryOptionsMarkets(response) {
+		return { markets: response.markets.map((market) => ({
+			ticker: market.ticker,
+			oracleSymbol: market.oracleSymbol,
+			oracleProvider: market.oracleProvider,
+			oracleType: market.oracleType,
+			oracleScaleFactor: market.oracleScaleFactor,
+			expirationTimestamp: Number(market.expirationTimestamp),
+			settlementTimestamp: Number(market.settlementTimestamp),
+			admin: market.admin,
+			quoteDenom: market.quoteDenom,
+			marketId: market.marketId,
+			makerFeeRate: market.makerFeeRate,
+			takerFeeRate: market.takerFeeRate,
+			relayerFeeShareRate: market.relayerFeeShareRate,
+			status: market.status,
+			minPriceTickSize: market.minPriceTickSize,
+			minQuantityTickSize: market.minQuantityTickSize,
+			settlementPrice: market.settlementPrice,
+			minNotional: market.minNotional,
+			adminPermissions: market.adminPermissions,
+			quoteDecimals: market.quoteDecimals,
+			openNotionalCap: market.openNotionalCap && market.openNotionalCap.cap.oneofKind !== void 0 ? {
+				type: market.openNotionalCap.cap.oneofKind === "capped" ? "capped" : "uncapped",
+				value: market.openNotionalCap.cap.oneofKind === "capped" ? market.openNotionalCap.cap.capped.value : void 0
+			} : void 0,
+			hasDisabledMinimalProtocolFee: market.hasDisabledMinimalProtocolFee,
+			forcePausedInfo: market.forcePausedInfo ? {
+				reason: market.forcePausedInfo.reason,
+				markPriceAtPausing: market.forcePausedInfo.markPriceAtPausing
+			} : void 0
+		})) };
+	}
+	static marketVolatilityResponseToMarketVolatility(response) {
+		return {
+			volatility: response.volatility,
+			historyMetadata: response.historyMetadata ? {
+				groupCount: response.historyMetadata.groupCount,
+				recordsSampleSize: response.historyMetadata.recordsSampleSize,
+				mean: response.historyMetadata.mean,
+				twap: response.historyMetadata.twap,
+				firstTimestamp: Number(response.historyMetadata.firstTimestamp),
+				lastTimestamp: Number(response.historyMetadata.lastTimestamp),
+				minPrice: response.historyMetadata.minPrice,
+				maxPrice: response.historyMetadata.maxPrice,
+				medianPrice: response.historyMetadata.medianPrice
+			} : void 0,
+			rawHistory: response.rawHistory.map(ChainGrpcExchangeTransformerV2.grpcTradeRecordToTradeRecord)
+		};
+	}
+};
+
 //#endregion
 //#region src/client/chain/transformers/ChainGrpcPermissionsTransformer.ts
 /**
@@ -1804,6 +2347,424 @@ var ChainGrpcStakingApi = class extends BaseGrpcConsumer {
 	}
 };
 
+//#endregion
+//#region src/client/chain/grpc/ChainGrpcExchangeApiV2.ts
+/**
+* @category Chain Grpc API
+*/
+var ChainGrpcExchangeApiV2 = class extends BaseGrpcConsumer {
+	constructor(..._args) {
+		super(..._args);
+		_defineProperty(this, "module", ChainModule.Exchange);
+	}
+	get client() {
+		return this.initClient(QueryClient$14);
+	}
+	async fetchModuleParams() {
+		const request = InjectiveExchangeV2QueryPb.QueryExchangeParamsRequest.create();
+		const response = await this.executeGrpcCall(request, this.client.queryExchangeParams.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.moduleParamsResponseToParams(response);
+	}
+	async fetchModuleState() {
+		const request = InjectiveExchangeV2QueryPb.QueryModuleStateRequest.create();
+		const response = await this.executeGrpcCall(request, this.client.exchangeModuleState.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.moduleStateResponseToModuleState(response);
+	}
+	async fetchFeeDiscountSchedule() {
+		const request = InjectiveExchangeV2QueryPb.QueryFeeDiscountScheduleRequest.create();
+		const response = await this.executeGrpcCall(request, this.client.feeDiscountSchedule.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.feeDiscountScheduleResponseToFeeDiscountSchedule(response);
+	}
+	async fetchFeeDiscountAccountInfo(injectiveAddress) {
+		const request = InjectiveExchangeV2QueryPb.QueryFeeDiscountAccountInfoRequest.create();
+		request.account = injectiveAddress;
+		const response = await this.executeGrpcCall(request, this.client.feeDiscountAccountInfo.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.feeDiscountAccountInfoResponseToFeeDiscountAccountInfo(response);
+	}
+	async fetchTradingRewardsCampaign() {
+		const request = InjectiveExchangeV2QueryPb.QueryTradeRewardCampaignRequest.create();
+		const response = await this.executeGrpcCall(request, this.client.tradeRewardCampaign.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.tradingRewardsCampaignResponseToTradingRewardsCampaign(response);
+	}
+	async fetchTradeRewardPoints(injectiveAddresses) {
+		const request = InjectiveExchangeV2QueryPb.QueryTradeRewardPointsRequest.create();
+		request.accounts = injectiveAddresses;
+		const response = await this.executeGrpcCall(request, this.client.tradeRewardPoints.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.tradeRewardPointsResponseToTradeRewardPoints(response);
+	}
+	async fetchPendingTradeRewardPoints(injectiveAddresses, timestamp) {
+		const request = InjectiveExchangeV2QueryPb.QueryTradeRewardPointsRequest.create();
+		request.accounts = injectiveAddresses;
+		if (timestamp !== void 0) request.pendingPoolTimestamp = BigInt(timestamp);
+		const response = await this.executeGrpcCall(request, this.client.pendingTradeRewardPoints.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.tradeRewardPointsResponseToTradeRewardPoints(response);
+	}
+	async fetchPositions() {
+		const request = InjectiveExchangeV2QueryPb.QueryPositionsRequest.create();
+		const response = await this.executeGrpcCall(request, this.client.positions.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.positionsResponseToPositions(response);
+	}
+	async fetchSubaccountTradeNonce(subaccountId) {
+		const request = InjectiveExchangeV2QueryPb.QuerySubaccountTradeNonceRequest.create();
+		request.subaccountId = subaccountId;
+		return { nonce: (await this.executeGrpcCall(request, this.client.subaccountTradeNonce.bind(this.client))).nonce };
+	}
+	async fetchIsOptedOutOfRewards(account) {
+		const request = InjectiveExchangeV2QueryPb.QueryIsOptedOutOfRewardsRequest.create();
+		request.account = account;
+		const response = await this.executeGrpcCall(request, this.client.isOptedOutOfRewards.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.isOptedOutOfRewardsResponseToIsOptedOutOfRewards(response);
+	}
+	async fetchActiveStakeGrant(account) {
+		const request = InjectiveExchangeV2QueryPb.QueryActiveStakeGrantRequest.create();
+		request.grantee = account;
+		const response = await this.executeGrpcCall(request, this.client.activeStakeGrant.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.activeStakeGrantResponseToActiveStakeGrant(response);
+	}
+	async fetchDenomDecimal(denom) {
+		const request = InjectiveExchangeV2QueryPb.QueryAuctionExchangeTransferDenomDecimalRequest.create();
+		request.denom = denom;
+		return { decimal: (await this.executeGrpcCall(request, this.client.auctionExchangeTransferDenomDecimal.bind(this.client))).decimal };
+	}
+	async fetchDenomDecimals() {
+		const request = InjectiveExchangeV2QueryPb.QueryAuctionExchangeTransferDenomDecimalsRequest.create();
+		const response = await this.executeGrpcCall(request, this.client.auctionExchangeTransferDenomDecimals.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.denomDecimalsResponseToDenomDecimals(response);
+	}
+	async fetchDenomMinNotional(denom) {
+		const request = InjectiveExchangeV2QueryPb.QueryDenomMinNotionalRequest.create();
+		request.denom = denom;
+		return { amount: (await this.executeGrpcCall(request, this.client.denomMinNotional.bind(this.client))).amount };
+	}
+	async fetchDenomMinNotionals() {
+		const request = InjectiveExchangeV2QueryPb.QueryDenomMinNotionalsRequest.create();
+		const response = await this.executeGrpcCall(request, this.client.denomMinNotionals.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.denomMinNotionalsResponseToDenomMinNotionals(response);
+	}
+	async fetchOpenInterest(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryOpenInterestRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.openInterest.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.openInterestResponseToOpenInterest(response);
+	}
+	async fetchDerivativeMarkets(status, marketIds) {
+		const request = InjectiveExchangeV2QueryPb.QueryDerivativeMarketsRequest.create();
+		if (status) request.status = status;
+		if (marketIds) request.marketIds = marketIds;
+		const response = await this.executeGrpcCall(request, this.client.derivativeMarkets.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.derivativeMarketsResponseToDerivativeMarkets(response);
+	}
+	async fetchSpotMarkets(status, marketIds) {
+		const request = InjectiveExchangeV2QueryPb.QuerySpotMarketsRequest.create();
+		if (status) request.status = status;
+		if (marketIds) request.marketIds = marketIds;
+		const response = await this.executeGrpcCall(request, this.client.spotMarkets.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.spotMarketsResponseToSpotMarkets(response);
+	}
+	async fetchFullSpotMarkets(status, marketIds) {
+		const request = InjectiveExchangeV2QueryPb.QueryFullSpotMarketsRequest.create();
+		if (status) request.status = status;
+		if (marketIds) request.marketIds = marketIds;
+		const response = await this.executeGrpcCall(request, this.client.fullSpotMarkets.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.fullSpotMarketsResponseToSpotMarkets(response);
+	}
+	async fetchL3DerivativeOrderbook(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryFullDerivativeOrderbookRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.l3DerivativeOrderBook.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.l3OrderbookResponseToOrderbook(response);
+	}
+	async fetchL3SpotOrderbook(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryFullSpotOrderbookRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.l3SpotOrderBook.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.l3OrderbookResponseToOrderbook(response);
+	}
+	async fetchSubaccountDeposits(subaccountId) {
+		const request = InjectiveExchangeV2QueryPb.QuerySubaccountDepositsRequest.create();
+		request.subaccountId = subaccountId;
+		const response = await this.executeGrpcCall(request, this.client.subaccountDeposits.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.subaccountDepositsResponseToSubaccountDeposits(response);
+	}
+	async fetchSubaccountDeposit({ subaccountId, denom }) {
+		const request = InjectiveExchangeV2QueryPb.QuerySubaccountDepositRequest.create();
+		request.subaccountId = subaccountId;
+		request.denom = denom;
+		const response = await this.executeGrpcCall(request, this.client.subaccountDeposit.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.subaccountDepositResponseToSubaccountDeposit(response);
+	}
+	async fetchAggregateVolume(account) {
+		const request = InjectiveExchangeV2QueryPb.QueryAggregateVolumeRequest.create();
+		request.account = account;
+		const response = await this.executeGrpcCall(request, this.client.aggregateVolume.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.aggregateVolumeResponseToAggregateVolume(response);
+	}
+	async fetchAggregateVolumes({ accounts, marketIds }) {
+		const request = InjectiveExchangeV2QueryPb.QueryAggregateVolumesRequest.create();
+		request.accounts = accounts;
+		request.marketIds = marketIds;
+		const response = await this.executeGrpcCall(request, this.client.aggregateVolumes.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.aggregateVolumesResponseToAggregateVolumes(response);
+	}
+	async fetchAggregateMarketVolume(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryAggregateMarketVolumeRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.aggregateMarketVolume.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.aggregateMarketVolumeResponseToAggregateMarketVolume(response);
+	}
+	async fetchAggregateMarketVolumes(marketIds) {
+		const request = InjectiveExchangeV2QueryPb.QueryAggregateMarketVolumesRequest.create();
+		request.marketIds = marketIds;
+		const response = await this.executeGrpcCall(request, this.client.aggregateMarketVolumes.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.aggregateMarketVolumesResponseToAggregateMarketVolumes(response);
+	}
+	async fetchSpotMarket(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QuerySpotMarketRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.spotMarket.bind(this.client));
+		return response.market ? ChainGrpcExchangeTransformerV2.grpcSpotMarketToSpotMarket(response.market) : void 0;
+	}
+	async fetchFullSpotMarket(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryFullSpotMarketRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.fullSpotMarket.bind(this.client));
+		return response.market ? ChainGrpcExchangeTransformerV2.grpcFullSpotMarketToSpotMarket(response.market) : void 0;
+	}
+	async fetchSpotOrderbook({ marketId, limit, orderSide, limitCumulativeNotional, limitCumulativeQuantity }) {
+		const request = InjectiveExchangeV2QueryPb.QuerySpotOrderbookRequest.create();
+		request.marketId = marketId;
+		if (limit !== void 0) request.limit = BigInt(limit);
+		if (orderSide !== void 0) request.orderSide = orderSide;
+		if (limitCumulativeNotional) request.limitCumulativeNotional = limitCumulativeNotional;
+		if (limitCumulativeQuantity) request.limitCumulativeQuantity = limitCumulativeQuantity;
+		const response = await this.executeGrpcCall(request, this.client.spotOrderbook.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.orderbookResponseToOrderbook(response);
+	}
+	async fetchTraderSpotOrders({ marketId, subaccountId }) {
+		const request = InjectiveExchangeV2QueryPb.QueryTraderSpotOrdersRequest.create();
+		request.marketId = marketId;
+		request.subaccountId = subaccountId;
+		const response = await this.executeGrpcCall(request, this.client.traderSpotOrders.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.spotOrdersResponseToOrders(response);
+	}
+	async fetchAccountAddressSpotOrders({ marketId, accountAddress }) {
+		const request = InjectiveExchangeV2QueryPb.QueryAccountAddressSpotOrdersRequest.create();
+		request.marketId = marketId;
+		request.accountAddress = accountAddress;
+		const response = await this.executeGrpcCall(request, this.client.accountAddressSpotOrders.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.spotOrdersResponseToOrders(response);
+	}
+	async fetchSpotOrdersByHashes({ marketId, subaccountId, orderHashes }) {
+		const request = InjectiveExchangeV2QueryPb.QuerySpotOrdersByHashesRequest.create();
+		request.marketId = marketId;
+		request.subaccountId = subaccountId;
+		request.orderHashes = orderHashes;
+		const response = await this.executeGrpcCall(request, this.client.spotOrdersByHashes.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.spotOrdersResponseToOrders(response);
+	}
+	async fetchSubaccountOrders({ subaccountId, marketId }) {
+		const request = InjectiveExchangeV2QueryPb.QuerySubaccountOrdersRequest.create();
+		request.subaccountId = subaccountId;
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.subaccountOrders.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.subaccountOrdersResponseToOrders(response);
+	}
+	async fetchTraderSpotTransientOrders({ marketId, subaccountId }) {
+		const request = InjectiveExchangeV2QueryPb.QueryTraderSpotOrdersRequest.create();
+		request.marketId = marketId;
+		request.subaccountId = subaccountId;
+		const response = await this.executeGrpcCall(request, this.client.traderSpotTransientOrders.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.spotOrdersResponseToOrders(response);
+	}
+	async fetchSpotMidPriceAndTOB(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QuerySpotMidPriceAndTOBRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.spotMidPriceAndTOB.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.midPriceAndTobResponseToMidPriceAndTob(response);
+	}
+	async fetchDerivativeMidPriceAndTOB(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryDerivativeMidPriceAndTOBRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.derivativeMidPriceAndTOB.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.midPriceAndTobResponseToMidPriceAndTob(response);
+	}
+	async fetchDerivativeOrderbook({ marketId, limit, limitCumulativeNotional }) {
+		const request = InjectiveExchangeV2QueryPb.QueryDerivativeOrderbookRequest.create();
+		request.marketId = marketId;
+		if (limit !== void 0) request.limit = BigInt(limit);
+		if (limitCumulativeNotional) request.limitCumulativeNotional = limitCumulativeNotional;
+		const response = await this.executeGrpcCall(request, this.client.derivativeOrderbook.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.orderbookResponseToOrderbook(response);
+	}
+	async fetchTraderDerivativeOrders({ marketId, subaccountId }) {
+		const request = InjectiveExchangeV2QueryPb.QueryTraderDerivativeOrdersRequest.create();
+		request.marketId = marketId;
+		request.subaccountId = subaccountId;
+		const response = await this.executeGrpcCall(request, this.client.traderDerivativeOrders.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.derivativeOrdersResponseToOrders(response);
+	}
+	async fetchAccountAddressDerivativeOrders({ marketId, accountAddress }) {
+		const request = InjectiveExchangeV2QueryPb.QueryAccountAddressDerivativeOrdersRequest.create();
+		request.marketId = marketId;
+		request.accountAddress = accountAddress;
+		const response = await this.executeGrpcCall(request, this.client.accountAddressDerivativeOrders.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.derivativeOrdersResponseToOrders(response);
+	}
+	async fetchDerivativeOrdersByHashes({ marketId, subaccountId, orderHashes }) {
+		const request = InjectiveExchangeV2QueryPb.QueryDerivativeOrdersByHashesRequest.create();
+		request.marketId = marketId;
+		request.subaccountId = subaccountId;
+		request.orderHashes = orderHashes;
+		const response = await this.executeGrpcCall(request, this.client.derivativeOrdersByHashes.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.derivativeOrdersResponseToOrders(response);
+	}
+	async fetchTraderDerivativeTransientOrders({ marketId, subaccountId }) {
+		const request = InjectiveExchangeV2QueryPb.QueryTraderDerivativeOrdersRequest.create();
+		request.marketId = marketId;
+		request.subaccountId = subaccountId;
+		const response = await this.executeGrpcCall(request, this.client.traderDerivativeTransientOrders.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.derivativeOrdersResponseToOrders(response);
+	}
+	async fetchDerivativeMarket(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryDerivativeMarketRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.derivativeMarket.bind(this.client));
+		return response.market ? ChainGrpcExchangeTransformerV2.grpcFullDerivativeMarketToDerivativeMarket(response.market) : void 0;
+	}
+	async fetchDerivativeMarketAddress(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryDerivativeMarketAddressRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.derivativeMarketAddress.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.derivativeMarketAddressResponseToDerivativeMarketAddress(response);
+	}
+	async fetchSubaccountRiskProfile(subaccountId) {
+		const request = InjectiveExchangeV2QueryPb.QuerySubaccountRiskProfileRequest.create();
+		request.subaccountId = subaccountId;
+		const response = await this.executeGrpcCall(request, this.client.subaccountRiskProfile.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.subaccountRiskProfileResponseToSubaccountRiskProfile(response);
+	}
+	async fetchCrossMarginPoolSnapshot({ subaccountId, quoteDenom }) {
+		const request = InjectiveExchangeV2QueryPb.QueryCrossMarginPoolSnapshotRequest.create();
+		request.subaccountId = subaccountId;
+		request.quoteDenom = quoteDenom;
+		const response = await this.executeGrpcCall(request, this.client.crossMarginPoolSnapshot.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.crossMarginPoolSnapshotResponseToCrossMarginPoolSnapshot(response);
+	}
+	async fetchPositionsInMarket(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryPositionsInMarketRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.positionsInMarket.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.positionsInMarketResponseToPositions(response);
+	}
+	async fetchSubaccountPositions(subaccountId) {
+		const request = InjectiveExchangeV2QueryPb.QuerySubaccountPositionsRequest.create();
+		request.subaccountId = subaccountId;
+		const response = await this.executeGrpcCall(request, this.client.subaccountPositions.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.positionsInMarketResponseToPositions(response);
+	}
+	async fetchSubaccountPositionInMarket({ subaccountId, marketId }) {
+		const request = InjectiveExchangeV2QueryPb.QuerySubaccountPositionInMarketRequest.create();
+		request.subaccountId = subaccountId;
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.subaccountPositionInMarket.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.positionInMarketResponseToPositionInMarket(response);
+	}
+	async fetchSubaccountEffectivePositionInMarket({ subaccountId, marketId }) {
+		const request = InjectiveExchangeV2QueryPb.QuerySubaccountEffectivePositionInMarketRequest.create();
+		request.subaccountId = subaccountId;
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.subaccountEffectivePositionInMarket.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.effectivePositionResponseToEffectivePosition(response);
+	}
+	async fetchPerpetualMarketInfo(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryPerpetualMarketInfoRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.perpetualMarketInfo.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.perpetualMarketInfoResponseToPerpetualMarketInfo(response);
+	}
+	async fetchExpiryFuturesMarketInfo(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryExpiryFuturesMarketInfoRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.expiryFuturesMarketInfo.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.expiryFuturesMarketInfoResponseToExpiryFuturesMarketInfo(response);
+	}
+	async fetchPerpetualMarketFunding(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryPerpetualMarketFundingRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.perpetualMarketFunding.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.perpetualMarketFundingResponseToPerpetualMarketFunding(response);
+	}
+	async fetchSubaccountOrderMetadata(subaccountId) {
+		const request = InjectiveExchangeV2QueryPb.QuerySubaccountOrderMetadataRequest.create();
+		request.subaccountId = subaccountId;
+		const response = await this.executeGrpcCall(request, this.client.subaccountOrderMetadata.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.subaccountOrderMetadataResponseToSubaccountOrderMetadata(response);
+	}
+	async fetchFeeDiscountTierStatistics() {
+		const request = InjectiveExchangeV2QueryPb.QueryFeeDiscountTierStatisticsRequest.create();
+		const response = await this.executeGrpcCall(request, this.client.feeDiscountTierStatistics.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.feeDiscountTierStatisticsResponseToFeeDiscountTierStatistics(response);
+	}
+	async fetchMarketIdFromVault(vaultAddress) {
+		const request = InjectiveExchangeV2QueryPb.QueryMarketIDFromVaultRequest.create();
+		request.vaultAddress = vaultAddress;
+		return { marketId: (await this.executeGrpcCall(request, this.client.queryMarketIDFromVault.bind(this.client))).marketId };
+	}
+	async fetchHistoricalTradeRecords(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryHistoricalTradeRecordsRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.historicalTradeRecords.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.historicalTradeRecordsResponseToHistoricalTradeRecords(response);
+	}
+	async fetchOptedOutOfRewardsAccounts() {
+		const request = InjectiveExchangeV2QueryPb.QueryOptedOutOfRewardsAccountsRequest.create();
+		return { accounts: (await this.executeGrpcCall(request, this.client.optedOutOfRewardsAccounts.bind(this.client))).accounts };
+	}
+	async fetchMarketVolatility({ marketId, tradeHistoryOptions }) {
+		const request = InjectiveExchangeV2QueryPb.QueryMarketVolatilityRequest.create();
+		request.marketId = marketId;
+		if (tradeHistoryOptions) request.tradeHistoryOptions = tradeHistoryOptions;
+		const response = await this.executeGrpcCall(request, this.client.marketVolatility.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.marketVolatilityResponseToMarketVolatility(response);
+	}
+	async fetchBinaryOptionsMarkets(status) {
+		const request = InjectiveExchangeV2QueryPb.QueryBinaryMarketsRequest.create();
+		if (status) request.status = status;
+		const response = await this.executeGrpcCall(request, this.client.binaryOptionsMarkets.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.binaryOptionsMarketsResponseToBinaryOptionsMarkets(response);
+	}
+	async fetchTraderDerivativeConditionalOrders({ subaccountId, marketId }) {
+		const request = InjectiveExchangeV2QueryPb.QueryTraderDerivativeConditionalOrdersRequest.create();
+		request.subaccountId = subaccountId;
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.traderDerivativeConditionalOrders.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.derivativeConditionalOrdersResponseToDerivativeConditionalOrders(response);
+	}
+	async fetchMarketAtomicExecutionFeeMultiplier(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryMarketAtomicExecutionFeeMultiplierRequest.create();
+		request.marketId = marketId;
+		return { multiplier: (await this.executeGrpcCall(request, this.client.marketAtomicExecutionFeeMultiplier.bind(this.client))).multiplier };
+	}
+	async fetchGrantAuthorization({ granter, grantee }) {
+		const request = InjectiveExchangeV2QueryPb.QueryGrantAuthorizationRequest.create();
+		request.granter = granter;
+		request.grantee = grantee;
+		return { amount: (await this.executeGrpcCall(request, this.client.grantAuthorization.bind(this.client))).amount };
+	}
+	async fetchGrantAuthorizations(granter) {
+		const request = InjectiveExchangeV2QueryPb.QueryGrantAuthorizationsRequest.create();
+		request.granter = granter;
+		const response = await this.executeGrpcCall(request, this.client.grantAuthorizations.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.grantAuthorizationsResponseToGrantAuthorizations(response);
+	}
+	async fetchMarketBalance(marketId) {
+		const request = InjectiveExchangeV2QueryPb.QueryMarketBalanceRequest.create();
+		request.marketId = marketId;
+		const response = await this.executeGrpcCall(request, this.client.marketBalance.bind(this.client));
+		return ChainGrpcExchangeTransformerV2.marketBalanceResponseToMarketBalance(response);
+	}
+};
+
 //#endregion
 //#region src/client/chain/grpc/ChainGrpcPermissionsApi.ts
 /**
@@ -1815,7 +2776,7 @@ var ChainGrpcPermissionsApi = class extends BaseGrpcConsumer {
 		_defineProperty(this, "module", ChainModule.Permissions);
 	}
 	get client() {
-		return this.initClient(QueryClient$14);
+		return this.initClient(QueryClient$15);
 	}
 	async fetchModuleParams() {
 		const request = InjectivePermissionsV1Beta1QueryPb.QueryParamsRequest.create();
@@ -1906,7 +2867,7 @@ var ChainGrpcDistributionApi = class extends BaseGrpcConsumer {
 		_defineProperty(this, "module", ChainModule.Distribution);
 	}
 	get client() {
-		return this.initClient(QueryClient$15);
+		return this.initClient(QueryClient$16);
 	}
 	async fetchModuleParams() {
 		const request = CosmosDistributionV1Beta1QueryPb.QueryParamsRequest.create();
@@ -1962,7 +2923,7 @@ var ChainGrpcTokenFactoryApi = class extends BaseGrpcConsumer {
 		_defineProperty(this, "module", ChainModule.WasmX);
 	}
 	get client() {
-		return this.initClient(QueryClient$16);
+		return this.initClient(QueryClient$17);
 	}
 	async fetchDenomsFromCreator(creator) {
 		const request = InjectiveTokenFactoryV1Beta1QueryPb.QueryDenomsFromCreatorRequest.create();
@@ -2000,7 +2961,7 @@ var ChainGrpcInsuranceFundApi = class extends BaseGrpcConsumer {
 		_defineProperty(this, "module", ChainModule.InsuranceFund);
 	}
 	get client() {
-		return this.initClient(QueryClient$17);
+		return this.initClient(QueryClient$18);
 	}
 	async fetchModuleParams() {
 		const request = InjectiveInsuranceV1Beta1QueryPb.QueryInsuranceParamsRequest.create();
@@ -2120,4 +3081,4 @@ var ChainRestWasmApi = class extends BaseRestConsumer {
 };
 
 //#endregion
-export { ChainGrpcAuthZTransformer as A, ChainGrpcDistributionTransformer as C, ChainGrpcTxFeesTransformer as D, ChainGrpcAuctionTransformer as E, ChainGrpcGovTransformer as F, ChainGrpcMintTransformer as M, ChainGrpcBankTransformer as N, ChainGrpcErc20Transformer as O, ChainGrpcEvmTransformer as P, ChainGrpcTokenFactoryTransformer as S, ChainGrpcStakingTransformer as T, ChainGrpcBankApi as _, ChainGrpcDistributionApi as a, ChainGrpcGovApi as b, ChainGrpcAuctionApi as c, ChainGrpcErc20Api as d, ChainGrpcWasmXApi as f, ChainGrpcMintApi as g, ChainGrpcWasmApi as h, ChainGrpcTokenFactoryApi as i, ChainGrpcWasmTransformer as j, ChainGrpcPeggyTransformer as k, ChainGrpcTxFeesApi as l, ChainGrpcAuthZApi as m, ChainRestBankApi as n, ChainGrpcPermissionsApi as o, ChainGrpcPeggyApi as p, ChainGrpcInsuranceFundApi as r, ChainGrpcStakingApi as s, ChainRestWasmApi as t, ChainGrpcOracleApi as u, ChainGrpcEvmApi as v, ChainGrpcPermissionsTransformer as w, ChainGrpcInsuranceFundTransformer as x, ChainGrpcIbcApi as y };
+export { ChainGrpcErc20Transformer as A, ChainGrpcTokenFactoryTransformer as C, ChainGrpcStakingTransformer as D, ChainGrpcExchangeTransformerV2 as E, ChainGrpcBankTransformer as F, ChainGrpcEvmTransformer as I, ChainGrpcGovTransformer as L, ChainGrpcAuthZTransformer as M, ChainGrpcWasmTransformer as N, ChainGrpcAuctionTransformer as O, ChainGrpcMintTransformer as P, ChainGrpcInsuranceFundTransformer as S, ChainGrpcPermissionsTransformer as T, ChainGrpcMintApi as _, ChainGrpcDistributionApi as a, ChainGrpcIbcApi as b, ChainGrpcStakingApi as c, ChainGrpcOracleApi as d, ChainGrpcErc20Api as f, ChainGrpcWasmApi as g, ChainGrpcAuthZApi as h, ChainGrpcTokenFactoryApi as i, ChainGrpcPeggyTransformer as j, ChainGrpcTxFeesTransformer as k, ChainGrpcAuctionApi as l, ChainGrpcPeggyApi as m, ChainRestBankApi as n, ChainGrpcPermissionsApi as o, ChainGrpcWasmXApi as p, ChainGrpcInsuranceFundApi as r, ChainGrpcExchangeApiV2 as s, ChainRestWasmApi as t, ChainGrpcTxFeesApi as u, ChainGrpcBankApi as v, ChainGrpcDistributionTransformer as w, ChainGrpcGovApi as x, ChainGrpcEvmApi as y };