injectivejs 1.6.5 → 1.7.1

package/esm/injective/exchange/v1beta1/tx.rpc.func.js

@@ -5,209 +5,244 @@ export const createDeposit = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgDeposit.typeUrl,
     encoders: toEncoders(MsgDeposit),
-    converters: toConverters(MsgDeposit)
+    converters: toConverters(MsgDeposit),
+    deps: [MsgDeposit]
 });
 export const createWithdraw = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgWithdraw.typeUrl,
     encoders: toEncoders(MsgWithdraw),
-    converters: toConverters(MsgWithdraw)
+    converters: toConverters(MsgWithdraw),
+    deps: [MsgWithdraw]
 });
 export const createInstantSpotMarketLaunch = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgInstantSpotMarketLaunch.typeUrl,
     encoders: toEncoders(MsgInstantSpotMarketLaunch),
-    converters: toConverters(MsgInstantSpotMarketLaunch)
+    converters: toConverters(MsgInstantSpotMarketLaunch),
+    deps: [MsgInstantSpotMarketLaunch]
 });
 export const createInstantPerpetualMarketLaunch = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgInstantPerpetualMarketLaunch.typeUrl,
     encoders: toEncoders(MsgInstantPerpetualMarketLaunch),
-    converters: toConverters(MsgInstantPerpetualMarketLaunch)
+    converters: toConverters(MsgInstantPerpetualMarketLaunch),
+    deps: [MsgInstantPerpetualMarketLaunch]
 });
 export const createInstantExpiryFuturesMarketLaunch = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgInstantExpiryFuturesMarketLaunch.typeUrl,
     encoders: toEncoders(MsgInstantExpiryFuturesMarketLaunch),
-    converters: toConverters(MsgInstantExpiryFuturesMarketLaunch)
+    converters: toConverters(MsgInstantExpiryFuturesMarketLaunch),
+    deps: [MsgInstantExpiryFuturesMarketLaunch]
 });
 export const createCreateSpotLimitOrder = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCreateSpotLimitOrder.typeUrl,
     encoders: toEncoders(MsgCreateSpotLimitOrder),
-    converters: toConverters(MsgCreateSpotLimitOrder)
+    converters: toConverters(MsgCreateSpotLimitOrder),
+    deps: [MsgCreateSpotLimitOrder]
 });
 export const createBatchCreateSpotLimitOrders = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgBatchCreateSpotLimitOrders.typeUrl,
     encoders: toEncoders(MsgBatchCreateSpotLimitOrders),
-    converters: toConverters(MsgBatchCreateSpotLimitOrders)
+    converters: toConverters(MsgBatchCreateSpotLimitOrders),
+    deps: [MsgBatchCreateSpotLimitOrders]
 });
 export const createCreateSpotMarketOrder = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCreateSpotMarketOrder.typeUrl,
     encoders: toEncoders(MsgCreateSpotMarketOrder),
-    converters: toConverters(MsgCreateSpotMarketOrder)
+    converters: toConverters(MsgCreateSpotMarketOrder),
+    deps: [MsgCreateSpotMarketOrder]
 });
 export const createCancelSpotOrder = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCancelSpotOrder.typeUrl,
     encoders: toEncoders(MsgCancelSpotOrder),
-    converters: toConverters(MsgCancelSpotOrder)
+    converters: toConverters(MsgCancelSpotOrder),
+    deps: [MsgCancelSpotOrder]
 });
 export const createBatchCancelSpotOrders = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgBatchCancelSpotOrders.typeUrl,
     encoders: toEncoders(MsgBatchCancelSpotOrders),
-    converters: toConverters(MsgBatchCancelSpotOrders)
+    converters: toConverters(MsgBatchCancelSpotOrders),
+    deps: [MsgBatchCancelSpotOrders]
 });
 export const createBatchUpdateOrders = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgBatchUpdateOrders.typeUrl,
     encoders: toEncoders(MsgBatchUpdateOrders),
-    converters: toConverters(MsgBatchUpdateOrders)
+    converters: toConverters(MsgBatchUpdateOrders),
+    deps: [MsgBatchUpdateOrders]
 });
 export const createPrivilegedExecuteContract = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgPrivilegedExecuteContract.typeUrl,
     encoders: toEncoders(MsgPrivilegedExecuteContract),
-    converters: toConverters(MsgPrivilegedExecuteContract)
+    converters: toConverters(MsgPrivilegedExecuteContract),
+    deps: [MsgPrivilegedExecuteContract]
 });
 export const createCreateDerivativeLimitOrder = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCreateDerivativeLimitOrder.typeUrl,
     encoders: toEncoders(MsgCreateDerivativeLimitOrder),
-    converters: toConverters(MsgCreateDerivativeLimitOrder)
+    converters: toConverters(MsgCreateDerivativeLimitOrder),
+    deps: [MsgCreateDerivativeLimitOrder]
 });
 export const createBatchCreateDerivativeLimitOrders = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgBatchCreateDerivativeLimitOrders.typeUrl,
     encoders: toEncoders(MsgBatchCreateDerivativeLimitOrders),
-    converters: toConverters(MsgBatchCreateDerivativeLimitOrders)
+    converters: toConverters(MsgBatchCreateDerivativeLimitOrders),
+    deps: [MsgBatchCreateDerivativeLimitOrders]
 });
 export const createCreateDerivativeMarketOrder = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCreateDerivativeMarketOrder.typeUrl,
     encoders: toEncoders(MsgCreateDerivativeMarketOrder),
-    converters: toConverters(MsgCreateDerivativeMarketOrder)
+    converters: toConverters(MsgCreateDerivativeMarketOrder),
+    deps: [MsgCreateDerivativeMarketOrder]
 });
 export const createCancelDerivativeOrder = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCancelDerivativeOrder.typeUrl,
     encoders: toEncoders(MsgCancelDerivativeOrder),
-    converters: toConverters(MsgCancelDerivativeOrder)
+    converters: toConverters(MsgCancelDerivativeOrder),
+    deps: [MsgCancelDerivativeOrder]
 });
 export const createBatchCancelDerivativeOrders = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgBatchCancelDerivativeOrders.typeUrl,
     encoders: toEncoders(MsgBatchCancelDerivativeOrders),
-    converters: toConverters(MsgBatchCancelDerivativeOrders)
+    converters: toConverters(MsgBatchCancelDerivativeOrders),
+    deps: [MsgBatchCancelDerivativeOrders]
 });
 export const createInstantBinaryOptionsMarketLaunch = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgInstantBinaryOptionsMarketLaunch.typeUrl,
     encoders: toEncoders(MsgInstantBinaryOptionsMarketLaunch),
-    converters: toConverters(MsgInstantBinaryOptionsMarketLaunch)
+    converters: toConverters(MsgInstantBinaryOptionsMarketLaunch),
+    deps: [MsgInstantBinaryOptionsMarketLaunch]
 });
 export const createCreateBinaryOptionsLimitOrder = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCreateBinaryOptionsLimitOrder.typeUrl,
     encoders: toEncoders(MsgCreateBinaryOptionsLimitOrder),
-    converters: toConverters(MsgCreateBinaryOptionsLimitOrder)
+    converters: toConverters(MsgCreateBinaryOptionsLimitOrder),
+    deps: [MsgCreateBinaryOptionsLimitOrder]
 });
 export const createCreateBinaryOptionsMarketOrder = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCreateBinaryOptionsMarketOrder.typeUrl,
     encoders: toEncoders(MsgCreateBinaryOptionsMarketOrder),
-    converters: toConverters(MsgCreateBinaryOptionsMarketOrder)
+    converters: toConverters(MsgCreateBinaryOptionsMarketOrder),
+    deps: [MsgCreateBinaryOptionsMarketOrder]
 });
 export const createCancelBinaryOptionsOrder = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCancelBinaryOptionsOrder.typeUrl,
     encoders: toEncoders(MsgCancelBinaryOptionsOrder),
-    converters: toConverters(MsgCancelBinaryOptionsOrder)
+    converters: toConverters(MsgCancelBinaryOptionsOrder),
+    deps: [MsgCancelBinaryOptionsOrder]
 });
 export const createBatchCancelBinaryOptionsOrders = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgBatchCancelBinaryOptionsOrders.typeUrl,
     encoders: toEncoders(MsgBatchCancelBinaryOptionsOrders),
-    converters: toConverters(MsgBatchCancelBinaryOptionsOrders)
+    converters: toConverters(MsgBatchCancelBinaryOptionsOrders),
+    deps: [MsgBatchCancelBinaryOptionsOrders]
 });
 export const createSubaccountTransfer = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgSubaccountTransfer.typeUrl,
     encoders: toEncoders(MsgSubaccountTransfer),
-    converters: toConverters(MsgSubaccountTransfer)
+    converters: toConverters(MsgSubaccountTransfer),
+    deps: [MsgSubaccountTransfer]
 });
 export const createExternalTransfer = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgExternalTransfer.typeUrl,
     encoders: toEncoders(MsgExternalTransfer),
-    converters: toConverters(MsgExternalTransfer)
+    converters: toConverters(MsgExternalTransfer),
+    deps: [MsgExternalTransfer]
 });
 export const createLiquidatePosition = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgLiquidatePosition.typeUrl,
     encoders: toEncoders(MsgLiquidatePosition),
-    converters: toConverters(MsgLiquidatePosition)
+    converters: toConverters(MsgLiquidatePosition),
+    deps: [MsgLiquidatePosition]
 });
 export const createEmergencySettleMarket = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgEmergencySettleMarket.typeUrl,
     encoders: toEncoders(MsgEmergencySettleMarket),
-    converters: toConverters(MsgEmergencySettleMarket)
+    converters: toConverters(MsgEmergencySettleMarket),
+    deps: [MsgEmergencySettleMarket]
 });
 export const createIncreasePositionMargin = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgIncreasePositionMargin.typeUrl,
     encoders: toEncoders(MsgIncreasePositionMargin),
-    converters: toConverters(MsgIncreasePositionMargin)
+    converters: toConverters(MsgIncreasePositionMargin),
+    deps: [MsgIncreasePositionMargin]
 });
 export const createDecreasePositionMargin = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgDecreasePositionMargin.typeUrl,
     encoders: toEncoders(MsgDecreasePositionMargin),
-    converters: toConverters(MsgDecreasePositionMargin)
+    converters: toConverters(MsgDecreasePositionMargin),
+    deps: [MsgDecreasePositionMargin]
 });
 export const createRewardsOptOut = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgRewardsOptOut.typeUrl,
     encoders: toEncoders(MsgRewardsOptOut),
-    converters: toConverters(MsgRewardsOptOut)
+    converters: toConverters(MsgRewardsOptOut),
+    deps: [MsgRewardsOptOut]
 });
 export const createAdminUpdateBinaryOptionsMarket = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgAdminUpdateBinaryOptionsMarket.typeUrl,
     encoders: toEncoders(MsgAdminUpdateBinaryOptionsMarket),
-    converters: toConverters(MsgAdminUpdateBinaryOptionsMarket)
+    converters: toConverters(MsgAdminUpdateBinaryOptionsMarket),
+    deps: [MsgAdminUpdateBinaryOptionsMarket]
 });
 export const createUpdateParams = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgUpdateParams.typeUrl,
     encoders: toEncoders(MsgUpdateParams),
-    converters: toConverters(MsgUpdateParams)
+    converters: toConverters(MsgUpdateParams),
+    deps: [MsgUpdateParams]
 });
 export const createUpdateSpotMarket = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgUpdateSpotMarket.typeUrl,
     encoders: toEncoders(MsgUpdateSpotMarket),
-    converters: toConverters(MsgUpdateSpotMarket)
+    converters: toConverters(MsgUpdateSpotMarket),
+    deps: [MsgUpdateSpotMarket]
 });
 export const createUpdateDerivativeMarket = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgUpdateDerivativeMarket.typeUrl,
     encoders: toEncoders(MsgUpdateDerivativeMarket),
-    converters: toConverters(MsgUpdateDerivativeMarket)
+    converters: toConverters(MsgUpdateDerivativeMarket),
+    deps: [MsgUpdateDerivativeMarket]
 });
 export const createAuthorizeStakeGrants = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgAuthorizeStakeGrants.typeUrl,
     encoders: toEncoders(MsgAuthorizeStakeGrants),
-    converters: toConverters(MsgAuthorizeStakeGrants)
+    converters: toConverters(MsgAuthorizeStakeGrants),
+    deps: [MsgAuthorizeStakeGrants]
 });
 export const createActivateStakeGrant = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgActivateStakeGrant.typeUrl,
     encoders: toEncoders(MsgActivateStakeGrant),
-    converters: toConverters(MsgActivateStakeGrant)
+    converters: toConverters(MsgActivateStakeGrant),
+    deps: [MsgActivateStakeGrant]
 });

package/esm/injective/insurance/v1beta1/events.js

@@ -1,7 +1,6 @@
 import { InsuranceFund, RedemptionSchedule } from "./insurance";
 import { Coin } from "../../../cosmos/base/v1beta1/coin";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseEventInsuranceFundUpdate() {
     return {
         fund: undefined
@@ -69,9 +68,11 @@ export const EventInsuranceFundUpdate = {
             typeUrl: "/injective.insurance.v1beta1.EventInsuranceFundUpdate",
             value: EventInsuranceFundUpdate.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        InsuranceFund.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(EventInsuranceFundUpdate.typeUrl, EventInsuranceFundUpdate);
 function createBaseEventRequestRedemption() {
     return {
         schedule: undefined
@@ -139,9 +140,11 @@ export const EventRequestRedemption = {
             typeUrl: "/injective.insurance.v1beta1.EventRequestRedemption",
             value: EventRequestRedemption.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        RedemptionSchedule.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(EventRequestRedemption.typeUrl, EventRequestRedemption);
 function createBaseEventWithdrawRedemption() {
     return {
         schedule: undefined,
@@ -221,9 +224,12 @@ export const EventWithdrawRedemption = {
             typeUrl: "/injective.insurance.v1beta1.EventWithdrawRedemption",
             value: EventWithdrawRedemption.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        RedemptionSchedule.registerTypeUrl();
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(EventWithdrawRedemption.typeUrl, EventWithdrawRedemption);
 function createBaseEventUnderwrite() {
     return {
         underwriter: "",
@@ -327,9 +333,11 @@ export const EventUnderwrite = {
             typeUrl: "/injective.insurance.v1beta1.EventUnderwrite",
             value: EventUnderwrite.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(EventUnderwrite.typeUrl, EventUnderwrite);
 function createBaseEventInsuranceWithdraw() {
     return {
         marketId: "",
@@ -421,6 +429,8 @@ export const EventInsuranceWithdraw = {
             typeUrl: "/injective.insurance.v1beta1.EventInsuranceWithdraw",
             value: EventInsuranceWithdraw.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(EventInsuranceWithdraw.typeUrl, EventInsuranceWithdraw);

package/esm/injective/insurance/v1beta1/genesis.js

@@ -1,6 +1,5 @@
 import { Params, InsuranceFund, RedemptionSchedule } from "./insurance";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseGenesisState() {
     return {
         params: Params.fromPartial({}),
@@ -122,6 +121,10 @@ export const GenesisState = {
             typeUrl: "/injective.insurance.v1beta1.GenesisState",
             value: GenesisState.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Params.registerTypeUrl();
+        InsuranceFund.registerTypeUrl();
+        RedemptionSchedule.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(GenesisState.typeUrl, GenesisState);

package/esm/injective/insurance/v1beta1/insurance.js

@@ -3,7 +3,6 @@ import { Timestamp } from "../../../google/protobuf/timestamp";
 import { Coin } from "../../../cosmos/base/v1beta1/coin";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { isSet, toTimestamp, fromTimestamp } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseParams() {
     return {
         defaultRedemptionNoticePeriodDuration: Duration.fromPartial({})
@@ -78,10 +77,9 @@ export const Params = {
             typeUrl: "/injective.insurance.v1beta1.Params",
             value: Params.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Params.typeUrl, Params);
-GlobalDecoderRegistry.registerAminoProtoMapping(Params.aminoType, Params.typeUrl);
 function createBaseInsuranceFund() {
     return {
         depositDenom: "",
@@ -269,9 +267,9 @@ export const InsuranceFund = {
             typeUrl: "/injective.insurance.v1beta1.InsuranceFund",
             value: InsuranceFund.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(InsuranceFund.typeUrl, InsuranceFund);
 function createBaseRedemptionSchedule() {
     return {
         id: BigInt(0),
@@ -387,6 +385,8 @@ export const RedemptionSchedule = {
             typeUrl: "/injective.insurance.v1beta1.RedemptionSchedule",
             value: RedemptionSchedule.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(RedemptionSchedule.typeUrl, RedemptionSchedule);

package/esm/injective/insurance/v1beta1/query.js

@@ -2,7 +2,6 @@ import { Params, InsuranceFund } from "./insurance";
 import { Coin } from "../../../cosmos/base/v1beta1/coin";
 import { GenesisState } from "./genesis";
 import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseQueryInsuranceParamsRequest() {
     return {};
 }
@@ -57,9 +56,9 @@ export const QueryInsuranceParamsRequest = {
             typeUrl: "/injective.insurance.v1beta1.QueryInsuranceParamsRequest",
             value: QueryInsuranceParamsRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryInsuranceParamsRequest.typeUrl, QueryInsuranceParamsRequest);
 function createBaseQueryInsuranceParamsResponse() {
     return {
         params: Params.fromPartial({})
@@ -127,9 +126,11 @@ export const QueryInsuranceParamsResponse = {
             typeUrl: "/injective.insurance.v1beta1.QueryInsuranceParamsResponse",
             value: QueryInsuranceParamsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Params.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryInsuranceParamsResponse.typeUrl, QueryInsuranceParamsResponse);
 function createBaseQueryInsuranceFundRequest() {
     return {
         marketId: ""
@@ -197,9 +198,9 @@ export const QueryInsuranceFundRequest = {
             typeUrl: "/injective.insurance.v1beta1.QueryInsuranceFundRequest",
             value: QueryInsuranceFundRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryInsuranceFundRequest.typeUrl, QueryInsuranceFundRequest);
 function createBaseQueryInsuranceFundResponse() {
     return {
         fund: undefined
@@ -267,9 +268,11 @@ export const QueryInsuranceFundResponse = {
             typeUrl: "/injective.insurance.v1beta1.QueryInsuranceFundResponse",
             value: QueryInsuranceFundResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        InsuranceFund.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryInsuranceFundResponse.typeUrl, QueryInsuranceFundResponse);
 function createBaseQueryInsuranceFundsRequest() {
     return {};
 }
@@ -324,9 +327,9 @@ export const QueryInsuranceFundsRequest = {
             typeUrl: "/injective.insurance.v1beta1.QueryInsuranceFundsRequest",
             value: QueryInsuranceFundsRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryInsuranceFundsRequest.typeUrl, QueryInsuranceFundsRequest);
 function createBaseQueryInsuranceFundsResponse() {
     return {
         funds: []
@@ -397,9 +400,11 @@ export const QueryInsuranceFundsResponse = {
             typeUrl: "/injective.insurance.v1beta1.QueryInsuranceFundsResponse",
             value: QueryInsuranceFundsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        InsuranceFund.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryInsuranceFundsResponse.typeUrl, QueryInsuranceFundsResponse);
 function createBaseQueryEstimatedRedemptionsRequest() {
     return {
         marketId: "",
@@ -479,9 +484,9 @@ export const QueryEstimatedRedemptionsRequest = {
             typeUrl: "/injective.insurance.v1beta1.QueryEstimatedRedemptionsRequest",
             value: QueryEstimatedRedemptionsRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryEstimatedRedemptionsRequest.typeUrl, QueryEstimatedRedemptionsRequest);
 function createBaseQueryEstimatedRedemptionsResponse() {
     return {
         amount: []
@@ -552,9 +557,11 @@ export const QueryEstimatedRedemptionsResponse = {
             typeUrl: "/injective.insurance.v1beta1.QueryEstimatedRedemptionsResponse",
             value: QueryEstimatedRedemptionsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryEstimatedRedemptionsResponse.typeUrl, QueryEstimatedRedemptionsResponse);
 function createBaseQueryPendingRedemptionsRequest() {
     return {
         marketId: "",
@@ -634,9 +641,9 @@ export const QueryPendingRedemptionsRequest = {
             typeUrl: "/injective.insurance.v1beta1.QueryPendingRedemptionsRequest",
             value: QueryPendingRedemptionsRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryPendingRedemptionsRequest.typeUrl, QueryPendingRedemptionsRequest);
 function createBaseQueryPendingRedemptionsResponse() {
     return {
         amount: []
@@ -707,9 +714,11 @@ export const QueryPendingRedemptionsResponse = {
             typeUrl: "/injective.insurance.v1beta1.QueryPendingRedemptionsResponse",
             value: QueryPendingRedemptionsResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Coin.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryPendingRedemptionsResponse.typeUrl, QueryPendingRedemptionsResponse);
 function createBaseQueryModuleStateRequest() {
     return {};
 }
@@ -764,9 +773,9 @@ export const QueryModuleStateRequest = {
             typeUrl: "/injective.insurance.v1beta1.QueryModuleStateRequest",
             value: QueryModuleStateRequest.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(QueryModuleStateRequest.typeUrl, QueryModuleStateRequest);
 function createBaseQueryModuleStateResponse() {
     return {
         state: undefined
@@ -834,6 +843,8 @@ export const QueryModuleStateResponse = {
             typeUrl: "/injective.insurance.v1beta1.QueryModuleStateResponse",
             value: QueryModuleStateResponse.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        GenesisState.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(QueryModuleStateResponse.typeUrl, QueryModuleStateResponse);

package/esm/injective/insurance/v1beta1/query.rpc.func.js

@@ -5,40 +5,46 @@ export const createGetInsuranceParams = (clientResolver) => buildQuery({
     decode: QueryInsuranceParamsResponse.decode,
     service: "injective.insurance.v1beta1.Query",
     method: "InsuranceParams",
-    clientResolver
+    clientResolver,
+    deps: [QueryInsuranceParamsRequest, QueryInsuranceParamsResponse]
 });
 export const createGetInsuranceFund = (clientResolver) => buildQuery({
     encode: QueryInsuranceFundRequest.encode,
     decode: QueryInsuranceFundResponse.decode,
     service: "injective.insurance.v1beta1.Query",
     method: "InsuranceFund",
-    clientResolver
+    clientResolver,
+    deps: [QueryInsuranceFundRequest, QueryInsuranceFundResponse]
 });
 export const createGetInsuranceFunds = (clientResolver) => buildQuery({
     encode: QueryInsuranceFundsRequest.encode,
     decode: QueryInsuranceFundsResponse.decode,
     service: "injective.insurance.v1beta1.Query",
     method: "InsuranceFunds",
-    clientResolver
+    clientResolver,
+    deps: [QueryInsuranceFundsRequest, QueryInsuranceFundsResponse]
 });
 export const createGetEstimatedRedemptions = (clientResolver) => buildQuery({
     encode: QueryEstimatedRedemptionsRequest.encode,
     decode: QueryEstimatedRedemptionsResponse.decode,
     service: "injective.insurance.v1beta1.Query",
     method: "EstimatedRedemptions",
-    clientResolver
+    clientResolver,
+    deps: [QueryEstimatedRedemptionsRequest, QueryEstimatedRedemptionsResponse]
 });
 export const createGetPendingRedemptions = (clientResolver) => buildQuery({
     encode: QueryPendingRedemptionsRequest.encode,
     decode: QueryPendingRedemptionsResponse.decode,
     service: "injective.insurance.v1beta1.Query",
     method: "PendingRedemptions",
-    clientResolver
+    clientResolver,
+    deps: [QueryPendingRedemptionsRequest, QueryPendingRedemptionsResponse]
 });
 export const createGetInsuranceModuleState = (clientResolver) => buildQuery({
     encode: QueryModuleStateRequest.encode,
     decode: QueryModuleStateResponse.decode,
     service: "injective.insurance.v1beta1.Query",
     method: "InsuranceModuleState",
-    clientResolver
+    clientResolver,
+    deps: [QueryModuleStateRequest, QueryModuleStateResponse]
 });