injectivejs 1.11.5 → 1.11.7

package/esm/injective/ocr/v1beta1/tx.js

@@ -1,6 +1,7 @@
 import { FeedConfig, Report, Params } from "./ocr";
 import { Coin } from "../../../cosmos/base/v1beta1/coin";
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 import { bytesFromBase64, base64FromBytes } from "../../../helpers";
 function createBaseMsgCreateFeed() {
     return {
@@ -90,6 +91,9 @@ export const MsgCreateFeed = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgCreateFeed.typeUrl)) {
+            return;
+        }
         FeedConfig.registerTypeUrl();
     }
 };
@@ -549,6 +553,9 @@ export const MsgTransmit = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgTransmit.typeUrl)) {
+            return;
+        }
         Report.registerTypeUrl();
     }
 };
@@ -709,6 +716,9 @@ export const MsgFundFeedRewardPool = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgFundFeedRewardPool.typeUrl)) {
+            return;
+        }
         Coin.registerTypeUrl();
     }
 };
@@ -869,6 +879,9 @@ export const MsgWithdrawFeedRewardPool = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgWithdrawFeedRewardPool.typeUrl)) {
+            return;
+        }
         Coin.registerTypeUrl();
     }
 };
@@ -1521,6 +1534,9 @@ export const MsgUpdateParams = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgUpdateParams.typeUrl)) {
+            return;
+        }
         Params.registerTypeUrl();
     }
 };

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

@@ -1,6 +1,7 @@
 import { StorkPriceState, PythPriceState } from "./oracle";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { Decimal } from "@interchainjs/math";
+import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseSetChainlinkPriceEvent() {
     return {
         feedId: "",
@@ -961,6 +962,9 @@ export const EventSetStorkPrices = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(EventSetStorkPrices.typeUrl)) {
+            return;
+        }
         StorkPriceState.registerTypeUrl();
     }
 };
@@ -1036,6 +1040,9 @@ export const EventSetPythPrices = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(EventSetPythPrices.typeUrl)) {
+            return;
+        }
         PythPriceState.registerTypeUrl();
     }
 };

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

@@ -1,5 +1,6 @@
 import { Params, BandPriceState, PriceFeedState, CoinbasePriceState, BandOracleRequest, BandIBCParams, ChainlinkPriceState, PriceRecords, ProviderState, PythPriceState, StorkPriceState } from "./oracle";
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 import { bytesFromBase64, base64FromBytes } from "../../../helpers";
 function createBaseGenesisState() {
     return {
@@ -301,6 +302,9 @@ export const GenesisState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(GenesisState.typeUrl)) {
+            return;
+        }
         Params.registerTypeUrl();
         BandPriceState.registerTypeUrl();
         PriceFeedState.registerTypeUrl();

package/esm/injective/oracle/v1beta1/oracle.js

@@ -2,6 +2,7 @@ import { Coin } from "../../../cosmos/base/v1beta1/coin";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { isSet, bytesFromBase64, base64FromBytes } from "../../../helpers";
 import { Decimal } from "@interchainjs/math";
+import { GlobalDecoderRegistry } from "../../../registry";
 export var OracleType;
 (function (OracleType) {
     OracleType[OracleType["Unspecified"] = 0] = "Unspecified";
@@ -364,6 +365,9 @@ export const ChainlinkPriceState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(ChainlinkPriceState.typeUrl)) {
+            return;
+        }
         PriceState.registerTypeUrl();
     }
 };
@@ -484,6 +488,9 @@ export const BandPriceState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(BandPriceState.typeUrl)) {
+            return;
+        }
         PriceState.registerTypeUrl();
     }
 };
@@ -595,6 +602,9 @@ export const PriceFeedState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(PriceFeedState.typeUrl)) {
+            return;
+        }
         PriceState.registerTypeUrl();
     }
 };
@@ -767,6 +777,9 @@ export const ProviderState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(ProviderState.typeUrl)) {
+            return;
+        }
         ProviderInfo.registerTypeUrl();
         ProviderPriceState.registerTypeUrl();
     }
@@ -852,6 +865,9 @@ export const ProviderPriceState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(ProviderPriceState.typeUrl)) {
+            return;
+        }
         PriceState.registerTypeUrl();
     }
 };
@@ -1124,6 +1140,9 @@ export const CoinbasePriceState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(CoinbasePriceState.typeUrl)) {
+            return;
+        }
         PriceState.registerTypeUrl();
     }
 };
@@ -1232,6 +1251,9 @@ export const StorkPriceState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(StorkPriceState.typeUrl)) {
+            return;
+        }
         PriceState.registerTypeUrl();
     }
 };
@@ -1458,6 +1480,9 @@ export const PythPriceState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(PythPriceState.typeUrl)) {
+            return;
+        }
         PriceState.registerTypeUrl();
     }
 };
@@ -1632,6 +1657,9 @@ export const BandOracleRequest = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(BandOracleRequest.typeUrl)) {
+            return;
+        }
         Coin.registerTypeUrl();
     }
 };
@@ -1944,6 +1972,9 @@ export const LastPriceTimestamps = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(LastPriceTimestamps.typeUrl)) {
+            return;
+        }
         SymbolPriceTimestamp.registerTypeUrl();
     }
 };
@@ -2043,6 +2074,9 @@ export const PriceRecords = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(PriceRecords.typeUrl)) {
+            return;
+        }
         PriceRecord.registerTypeUrl();
     }
 };
@@ -2532,6 +2566,9 @@ export const AssetPair = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(AssetPair.typeUrl)) {
+            return;
+        }
         SignedPriceOfAssetPair.registerTypeUrl();
     }
 };

package/esm/injective/oracle/v1beta1/proposal.js

@@ -104,6 +104,9 @@ export const GrantBandOraclePrivilegeProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(GrantBandOraclePrivilegeProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(GrantBandOraclePrivilegeProposal.typeUrl, GrantBandOraclePrivilegeProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(GrantBandOraclePrivilegeProposal.aminoType, GrantBandOraclePrivilegeProposal.typeUrl);
     }
@@ -211,6 +214,9 @@ export const RevokeBandOraclePrivilegeProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(RevokeBandOraclePrivilegeProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(RevokeBandOraclePrivilegeProposal.typeUrl, RevokeBandOraclePrivilegeProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(RevokeBandOraclePrivilegeProposal.aminoType, RevokeBandOraclePrivilegeProposal.typeUrl);
     }
@@ -342,6 +348,9 @@ export const GrantPriceFeederPrivilegeProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(GrantPriceFeederPrivilegeProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(GrantPriceFeederPrivilegeProposal.typeUrl, GrantPriceFeederPrivilegeProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(GrantPriceFeederPrivilegeProposal.aminoType, GrantPriceFeederPrivilegeProposal.typeUrl);
     }
@@ -461,6 +470,9 @@ export const GrantProviderPrivilegeProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(GrantProviderPrivilegeProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(GrantProviderPrivilegeProposal.typeUrl, GrantProviderPrivilegeProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(GrantProviderPrivilegeProposal.aminoType, GrantProviderPrivilegeProposal.typeUrl);
     }
@@ -580,6 +592,9 @@ export const RevokeProviderPrivilegeProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(RevokeProviderPrivilegeProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(RevokeProviderPrivilegeProposal.typeUrl, RevokeProviderPrivilegeProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(RevokeProviderPrivilegeProposal.aminoType, RevokeProviderPrivilegeProposal.typeUrl);
     }
@@ -711,6 +726,9 @@ export const RevokePriceFeederPrivilegeProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(RevokePriceFeederPrivilegeProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(RevokePriceFeederPrivilegeProposal.typeUrl, RevokePriceFeederPrivilegeProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(RevokePriceFeederPrivilegeProposal.aminoType, RevokePriceFeederPrivilegeProposal.typeUrl);
     }
@@ -815,6 +833,9 @@ export const AuthorizeBandOracleRequestProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(AuthorizeBandOracleRequestProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(AuthorizeBandOracleRequestProposal.typeUrl, AuthorizeBandOracleRequestProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(AuthorizeBandOracleRequestProposal.aminoType, AuthorizeBandOracleRequestProposal.typeUrl);
         BandOracleRequest.registerTypeUrl();
@@ -945,6 +966,9 @@ export const UpdateBandOracleRequestProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(UpdateBandOracleRequestProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(UpdateBandOracleRequestProposal.typeUrl, UpdateBandOracleRequestProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(UpdateBandOracleRequestProposal.aminoType, UpdateBandOracleRequestProposal.typeUrl);
         BandOracleRequest.registerTypeUrl();
@@ -1050,6 +1074,9 @@ export const EnableBandIBCProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(EnableBandIBCProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(EnableBandIBCProposal.typeUrl, EnableBandIBCProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(EnableBandIBCProposal.aminoType, EnableBandIBCProposal.typeUrl);
         BandIBCParams.registerTypeUrl();
@@ -1158,6 +1185,9 @@ export const GrantStorkPublisherPrivilegeProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(GrantStorkPublisherPrivilegeProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(GrantStorkPublisherPrivilegeProposal.typeUrl, GrantStorkPublisherPrivilegeProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(GrantStorkPublisherPrivilegeProposal.aminoType, GrantStorkPublisherPrivilegeProposal.typeUrl);
     }
@@ -1265,6 +1295,9 @@ export const RevokeStorkPublisherPrivilegeProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(RevokeStorkPublisherPrivilegeProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(RevokeStorkPublisherPrivilegeProposal.typeUrl, RevokeStorkPublisherPrivilegeProposal);
         GlobalDecoderRegistry.registerAminoProtoMapping(RevokeStorkPublisherPrivilegeProposal.aminoType, RevokeStorkPublisherPrivilegeProposal.typeUrl);
     }

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

@@ -2,6 +2,7 @@ import { OracleInfo, PythPriceState, Params, BandPriceState, PriceFeedState, Coi
 import { GenesisState } from "./genesis";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { isSet } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
 import { Decimal } from "@interchainjs/math";
 function createBaseQueryPythPriceRequest() {
     return {
@@ -142,6 +143,9 @@ export const QueryPythPriceResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryPythPriceResponse.typeUrl)) {
+            return;
+        }
         PythPriceState.registerTypeUrl();
     }
 };
@@ -271,6 +275,9 @@ export const QueryParamsResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryParamsResponse.typeUrl)) {
+            return;
+        }
         Params.registerTypeUrl();
     }
 };
@@ -533,6 +540,9 @@ export const QueryBandPriceStatesResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryBandPriceStatesResponse.typeUrl)) {
+            return;
+        }
         BandPriceState.registerTypeUrl();
     }
 };
@@ -665,6 +675,9 @@ export const QueryBandIBCPriceStatesResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryBandIBCPriceStatesResponse.typeUrl)) {
+            return;
+        }
         BandPriceState.registerTypeUrl();
     }
 };
@@ -797,6 +810,9 @@ export const QueryPriceFeedPriceStatesResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryPriceFeedPriceStatesResponse.typeUrl)) {
+            return;
+        }
         PriceFeedState.registerTypeUrl();
     }
 };
@@ -929,6 +945,9 @@ export const QueryCoinbasePriceStatesResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryCoinbasePriceStatesResponse.typeUrl)) {
+            return;
+        }
         CoinbasePriceState.registerTypeUrl();
     }
 };
@@ -1061,6 +1080,9 @@ export const QueryPythPriceStatesResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryPythPriceStatesResponse.typeUrl)) {
+            return;
+        }
         PythPriceState.registerTypeUrl();
     }
 };
@@ -1193,6 +1215,9 @@ export const QueryStorkPriceStatesResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryStorkPriceStatesResponse.typeUrl)) {
+            return;
+        }
         StorkPriceState.registerTypeUrl();
     }
 };
@@ -1477,6 +1502,9 @@ export const QueryProviderPriceStateResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryProviderPriceStateResponse.typeUrl)) {
+            return;
+        }
         PriceState.registerTypeUrl();
     }
 };
@@ -1606,6 +1634,9 @@ export const QueryModuleStateResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryModuleStateResponse.typeUrl)) {
+            return;
+        }
         GenesisState.registerTypeUrl();
     }
 };
@@ -1763,6 +1794,9 @@ export const QueryHistoricalPriceRecordsResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryHistoricalPriceRecordsResponse.typeUrl)) {
+            return;
+        }
         PriceRecords.registerTypeUrl();
     }
 };
@@ -1953,6 +1987,9 @@ export const QueryOracleVolatilityRequest = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryOracleVolatilityRequest.typeUrl)) {
+            return;
+        }
         OracleInfo.registerTypeUrl();
         OracleHistoryOptions.registerTypeUrl();
     }
@@ -2053,6 +2090,9 @@ export const QueryOracleVolatilityResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryOracleVolatilityResponse.typeUrl)) {
+            return;
+        }
         MetadataStatistics.registerTypeUrl();
         PriceRecord.registerTypeUrl();
     }
@@ -2186,6 +2226,9 @@ export const QueryOracleProvidersInfoResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryOracleProvidersInfoResponse.typeUrl)) {
+            return;
+        }
         ProviderInfo.registerTypeUrl();
     }
 };
@@ -2331,6 +2374,9 @@ export const QueryOracleProviderPricesResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryOracleProviderPricesResponse.typeUrl)) {
+            return;
+        }
         ProviderState.registerTypeUrl();
     }
 };
@@ -2521,6 +2567,9 @@ export const QueryOraclePriceRequest = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryOraclePriceRequest.typeUrl)) {
+            return;
+        }
         ScalingOptions.registerTypeUrl();
     }
 };
@@ -2735,6 +2784,9 @@ export const QueryOraclePriceResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryOraclePriceResponse.typeUrl)) {
+            return;
+        }
         PricePairState.registerTypeUrl();
     }
 };

package/esm/injective/oracle/v1beta1/tx.js

@@ -2,6 +2,7 @@ import { AssetPair, PriceAttestation, Params } from "./oracle";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { Decimal } from "@interchainjs/math";
 import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseMsgRelayProviderPrices() {
     return {
         sender: "",
@@ -829,6 +830,9 @@ export const MsgRelayStorkPrices = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgRelayStorkPrices.typeUrl)) {
+            return;
+        }
         AssetPair.registerTypeUrl();
     }
 };
@@ -1126,6 +1130,9 @@ export const MsgRelayPythPrices = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgRelayPythPrices.typeUrl)) {
+            return;
+        }
         PriceAttestation.registerTypeUrl();
     }
 };
@@ -1274,6 +1281,9 @@ export const MsgUpdateParams = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgUpdateParams.typeUrl)) {
+            return;
+        }
         Params.registerTypeUrl();
     }
 };

package/esm/injective/peggy/v1/batch.js

@@ -1,5 +1,6 @@
 import { ERC20Token } from "./attestation";
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseOutgoingTxBatch() {
     return {
         batchNonce: BigInt(0),
@@ -120,6 +121,9 @@ export const OutgoingTxBatch = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(OutgoingTxBatch.typeUrl)) {
+            return;
+        }
         OutgoingTransferTx.registerTypeUrl();
     }
 };
@@ -240,6 +244,9 @@ export const OutgoingTransferTx = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(OutgoingTransferTx.typeUrl)) {
+            return;
+        }
         ERC20Token.registerTypeUrl();
     }
 };

package/esm/injective/peggy/v1/events.js

@@ -1,6 +1,7 @@
 import { BridgeValidator } from "./types";
 import { isSet, bytesFromBase64, base64FromBytes } from "../../../helpers";
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseEventAttestationObserved() {
     return {
         attestationType: 0,
@@ -558,6 +559,9 @@ export const EventValsetUpdateRequest = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(EventValsetUpdateRequest.typeUrl)) {
+            return;
+        }
         BridgeValidator.registerTypeUrl();
     }
 };
@@ -1649,6 +1653,9 @@ export const EventValsetUpdateClaim = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(EventValsetUpdateClaim.typeUrl)) {
+            return;
+        }
         BridgeValidator.registerTypeUrl();
     }
 };

package/esm/injective/peggy/v1/genesis.js

@@ -4,6 +4,7 @@ import { MsgValsetConfirm, MsgConfirmBatch, MsgSetOrchestratorAddresses } from "
 import { OutgoingTxBatch, OutgoingTransferTx } from "./batch";
 import { Attestation } from "./attestation";
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseGenesisState() {
     return {
         params: undefined,
@@ -268,6 +269,9 @@ export const GenesisState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(GenesisState.typeUrl)) {
+            return;
+        }
         Params.registerTypeUrl();
         Valset.registerTypeUrl();
         MsgValsetConfirm.registerTypeUrl();

package/esm/injective/peggy/v1/msgs.js

@@ -3,6 +3,7 @@ import { BridgeValidator } from "./types";
 import { Any } from "../../../google/protobuf/any";
 import { Params } from "./params";
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 function createBaseMsgSetOrchestratorAddresses() {
     return {
         sender: "",
@@ -443,6 +444,9 @@ export const MsgSendToEth = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgSendToEth.typeUrl)) {
+            return;
+        }
         Coin.registerTypeUrl();
     }
 };
@@ -1904,6 +1908,9 @@ export const MsgValsetUpdatedClaim = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgValsetUpdatedClaim.typeUrl)) {
+            return;
+        }
         BridgeValidator.registerTypeUrl();
     }
 };
@@ -2052,6 +2059,9 @@ export const MsgUpdateParams = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgUpdateParams.typeUrl)) {
+            return;
+        }
         Params.registerTypeUrl();
     }
 };

package/esm/injective/peggy/v1/params.js

@@ -1,5 +1,6 @@
 import { Coin } from "../../../cosmos/base/v1beta1/coin";
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
 import { bytesFromBase64, base64FromBytes } from "../../../helpers";
 function createBaseParams() {
     return {
@@ -332,6 +333,9 @@ export const Params = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Params.typeUrl)) {
+            return;
+        }
         Coin.registerTypeUrl();
     }
 };

package/esm/injective/peggy/v1/proposal.js

@@ -96,6 +96,9 @@ export const BlacklistEthereumAddressesProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(BlacklistEthereumAddressesProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(BlacklistEthereumAddressesProposal.typeUrl, BlacklistEthereumAddressesProposal);
     }
 };
@@ -195,6 +198,9 @@ export const RevokeEthereumBlacklistProposal = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(RevokeEthereumBlacklistProposal.typeUrl)) {
+            return;
+        }
         GlobalDecoderRegistry.register(RevokeEthereumBlacklistProposal.typeUrl, RevokeEthereumBlacklistProposal);
     }
 };