injectivejs 1.6.5 → 1.7.1

package/esm/ibc/core/channel/v1/tx.rpc.func.js

@@ -5,113 +5,132 @@ export const createChannelOpenInit = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelOpenInit.typeUrl,
     encoders: toEncoders(MsgChannelOpenInit),
-    converters: toConverters(MsgChannelOpenInit)
+    converters: toConverters(MsgChannelOpenInit),
+    deps: [MsgChannelOpenInit]
 });
 export const createChannelOpenTry = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelOpenTry.typeUrl,
     encoders: toEncoders(MsgChannelOpenTry),
-    converters: toConverters(MsgChannelOpenTry)
+    converters: toConverters(MsgChannelOpenTry),
+    deps: [MsgChannelOpenTry]
 });
 export const createChannelOpenAck = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelOpenAck.typeUrl,
     encoders: toEncoders(MsgChannelOpenAck),
-    converters: toConverters(MsgChannelOpenAck)
+    converters: toConverters(MsgChannelOpenAck),
+    deps: [MsgChannelOpenAck]
 });
 export const createChannelOpenConfirm = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelOpenConfirm.typeUrl,
     encoders: toEncoders(MsgChannelOpenConfirm),
-    converters: toConverters(MsgChannelOpenConfirm)
+    converters: toConverters(MsgChannelOpenConfirm),
+    deps: [MsgChannelOpenConfirm]
 });
 export const createChannelCloseInit = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelCloseInit.typeUrl,
     encoders: toEncoders(MsgChannelCloseInit),
-    converters: toConverters(MsgChannelCloseInit)
+    converters: toConverters(MsgChannelCloseInit),
+    deps: [MsgChannelCloseInit]
 });
 export const createChannelCloseConfirm = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelCloseConfirm.typeUrl,
     encoders: toEncoders(MsgChannelCloseConfirm),
-    converters: toConverters(MsgChannelCloseConfirm)
+    converters: toConverters(MsgChannelCloseConfirm),
+    deps: [MsgChannelCloseConfirm]
 });
 export const createRecvPacket = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgRecvPacket.typeUrl,
     encoders: toEncoders(MsgRecvPacket),
-    converters: toConverters(MsgRecvPacket)
+    converters: toConverters(MsgRecvPacket),
+    deps: [MsgRecvPacket]
 });
 export const createTimeout = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgTimeout.typeUrl,
     encoders: toEncoders(MsgTimeout),
-    converters: toConverters(MsgTimeout)
+    converters: toConverters(MsgTimeout),
+    deps: [MsgTimeout]
 });
 export const createTimeoutOnClose = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgTimeoutOnClose.typeUrl,
     encoders: toEncoders(MsgTimeoutOnClose),
-    converters: toConverters(MsgTimeoutOnClose)
+    converters: toConverters(MsgTimeoutOnClose),
+    deps: [MsgTimeoutOnClose]
 });
 export const createAcknowledgement = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgAcknowledgement.typeUrl,
     encoders: toEncoders(MsgAcknowledgement),
-    converters: toConverters(MsgAcknowledgement)
+    converters: toConverters(MsgAcknowledgement),
+    deps: [MsgAcknowledgement]
 });
 export const createChannelUpgradeInit = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelUpgradeInit.typeUrl,
     encoders: toEncoders(MsgChannelUpgradeInit),
-    converters: toConverters(MsgChannelUpgradeInit)
+    converters: toConverters(MsgChannelUpgradeInit),
+    deps: [MsgChannelUpgradeInit]
 });
 export const createChannelUpgradeTry = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelUpgradeTry.typeUrl,
     encoders: toEncoders(MsgChannelUpgradeTry),
-    converters: toConverters(MsgChannelUpgradeTry)
+    converters: toConverters(MsgChannelUpgradeTry),
+    deps: [MsgChannelUpgradeTry]
 });
 export const createChannelUpgradeAck = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelUpgradeAck.typeUrl,
     encoders: toEncoders(MsgChannelUpgradeAck),
-    converters: toConverters(MsgChannelUpgradeAck)
+    converters: toConverters(MsgChannelUpgradeAck),
+    deps: [MsgChannelUpgradeAck]
 });
 export const createChannelUpgradeConfirm = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelUpgradeConfirm.typeUrl,
     encoders: toEncoders(MsgChannelUpgradeConfirm),
-    converters: toConverters(MsgChannelUpgradeConfirm)
+    converters: toConverters(MsgChannelUpgradeConfirm),
+    deps: [MsgChannelUpgradeConfirm]
 });
 export const createChannelUpgradeOpen = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelUpgradeOpen.typeUrl,
     encoders: toEncoders(MsgChannelUpgradeOpen),
-    converters: toConverters(MsgChannelUpgradeOpen)
+    converters: toConverters(MsgChannelUpgradeOpen),
+    deps: [MsgChannelUpgradeOpen]
 });
 export const createChannelUpgradeTimeout = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelUpgradeTimeout.typeUrl,
     encoders: toEncoders(MsgChannelUpgradeTimeout),
-    converters: toConverters(MsgChannelUpgradeTimeout)
+    converters: toConverters(MsgChannelUpgradeTimeout),
+    deps: [MsgChannelUpgradeTimeout]
 });
 export const createChannelUpgradeCancel = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgChannelUpgradeCancel.typeUrl,
     encoders: toEncoders(MsgChannelUpgradeCancel),
-    converters: toConverters(MsgChannelUpgradeCancel)
+    converters: toConverters(MsgChannelUpgradeCancel),
+    deps: [MsgChannelUpgradeCancel]
 });
 export const createUpdateChannelParams = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgUpdateParams.typeUrl,
     encoders: toEncoders(MsgUpdateParams),
-    converters: toConverters(MsgUpdateParams)
+    converters: toConverters(MsgUpdateParams),
+    deps: [MsgUpdateParams]
 });
 export const createPruneAcknowledgements = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgPruneAcknowledgements.typeUrl,
     encoders: toEncoders(MsgPruneAcknowledgements),
-    converters: toConverters(MsgPruneAcknowledgements)
+    converters: toConverters(MsgPruneAcknowledgements),
+    deps: [MsgPruneAcknowledgements]
 });

package/esm/ibc/core/channel/v1/upgrade.js

@@ -1,7 +1,6 @@
 import { Timeout } from "./channel";
 import { BinaryReader, BinaryWriter } from "../../../../binary";
 import { isSet } from "../../../../helpers";
-import { GlobalDecoderRegistry } from "../../../../registry";
 function createBaseUpgrade() {
     return {
         fields: UpgradeFields.fromPartial({}),
@@ -100,10 +99,12 @@ export const Upgrade = {
             typeUrl: "/ibc.core.channel.v1.Upgrade",
             value: Upgrade.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        UpgradeFields.registerTypeUrl();
+        Timeout.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(Upgrade.typeUrl, Upgrade);
-GlobalDecoderRegistry.registerAminoProtoMapping(Upgrade.aminoType, Upgrade.typeUrl);
 function createBaseUpgradeFields() {
     return {
         ordering: 0,
@@ -205,10 +206,9 @@ export const UpgradeFields = {
             typeUrl: "/ibc.core.channel.v1.UpgradeFields",
             value: UpgradeFields.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(UpgradeFields.typeUrl, UpgradeFields);
-GlobalDecoderRegistry.registerAminoProtoMapping(UpgradeFields.aminoType, UpgradeFields.typeUrl);
 function createBaseErrorReceipt() {
     return {
         sequence: BigInt(0),
@@ -295,7 +295,6 @@ export const ErrorReceipt = {
             typeUrl: "/ibc.core.channel.v1.ErrorReceipt",
             value: ErrorReceipt.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(ErrorReceipt.typeUrl, ErrorReceipt);
-GlobalDecoderRegistry.registerAminoProtoMapping(ErrorReceipt.aminoType, ErrorReceipt.typeUrl);

package/esm/ibc/core/client/v1/client.js

@@ -1,6 +1,5 @@
 import { Any } from "../../../../google/protobuf/any";
 import { BinaryReader, BinaryWriter } from "../../../../binary";
-import { GlobalDecoderRegistry } from "../../../../registry";
 function createBaseIdentifiedClientState() {
     return {
         clientId: "",
@@ -87,10 +86,9 @@ export const IdentifiedClientState = {
             typeUrl: "/ibc.core.client.v1.IdentifiedClientState",
             value: IdentifiedClientState.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(IdentifiedClientState.typeUrl, IdentifiedClientState);
-GlobalDecoderRegistry.registerAminoProtoMapping(IdentifiedClientState.aminoType, IdentifiedClientState.typeUrl);
 function createBaseConsensusStateWithHeight() {
     return {
         height: Height.fromPartial({}),
@@ -177,10 +175,9 @@ export const ConsensusStateWithHeight = {
             typeUrl: "/ibc.core.client.v1.ConsensusStateWithHeight",
             value: ConsensusStateWithHeight.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(ConsensusStateWithHeight.typeUrl, ConsensusStateWithHeight);
-GlobalDecoderRegistry.registerAminoProtoMapping(ConsensusStateWithHeight.aminoType, ConsensusStateWithHeight.typeUrl);
 function createBaseClientConsensusStates() {
     return {
         clientId: "",
@@ -270,10 +267,11 @@ export const ClientConsensusStates = {
             typeUrl: "/ibc.core.client.v1.ClientConsensusStates",
             value: ClientConsensusStates.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        ConsensusStateWithHeight.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(ClientConsensusStates.typeUrl, ClientConsensusStates);
-GlobalDecoderRegistry.registerAminoProtoMapping(ClientConsensusStates.aminoType, ClientConsensusStates.typeUrl);
 function createBaseHeight() {
     return {
         revisionNumber: BigInt(0),
@@ -356,10 +354,9 @@ export const Height = {
             typeUrl: "/ibc.core.client.v1.Height",
             value: Height.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Height.typeUrl, Height);
-GlobalDecoderRegistry.registerAminoProtoMapping(Height.aminoType, Height.typeUrl);
 function createBaseParams() {
     return {
         allowedClients: []
@@ -437,7 +434,6 @@ export const Params = {
             typeUrl: "/ibc.core.client.v1.Params",
             value: Params.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Params.typeUrl, Params);
-GlobalDecoderRegistry.registerAminoProtoMapping(Params.aminoType, Params.typeUrl);

package/esm/ibc/core/client/v1/tx.js

@@ -3,7 +3,6 @@ import { Plan } from "../../../../cosmos/upgrade/v1beta1/upgrade";
 import { Params } from "./client";
 import { BinaryReader, BinaryWriter } from "../../../../binary";
 import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
-import { GlobalDecoderRegistry } from "../../../../registry";
 function createBaseMsgCreateClient() {
     return {
         clientState: undefined,
@@ -102,10 +101,9 @@ export const MsgCreateClient = {
             typeUrl: "/ibc.core.client.v1.MsgCreateClient",
             value: MsgCreateClient.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgCreateClient.typeUrl, MsgCreateClient);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgCreateClient.aminoType, MsgCreateClient.typeUrl);
 function createBaseMsgCreateClientResponse() {
     return {
         clientId: ""
@@ -180,10 +178,9 @@ export const MsgCreateClientResponse = {
             typeUrl: "/ibc.core.client.v1.MsgCreateClientResponse",
             value: MsgCreateClientResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgCreateClientResponse.typeUrl, MsgCreateClientResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgCreateClientResponse.aminoType, MsgCreateClientResponse.typeUrl);
 function createBaseMsgUpdateClient() {
     return {
         clientId: "",
@@ -282,10 +279,9 @@ export const MsgUpdateClient = {
             typeUrl: "/ibc.core.client.v1.MsgUpdateClient",
             value: MsgUpdateClient.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgUpdateClient.typeUrl, MsgUpdateClient);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateClient.aminoType, MsgUpdateClient.typeUrl);
 function createBaseMsgUpdateClientResponse() {
     return {};
 }
@@ -347,10 +343,9 @@ export const MsgUpdateClientResponse = {
             typeUrl: "/ibc.core.client.v1.MsgUpdateClientResponse",
             value: MsgUpdateClientResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgUpdateClientResponse.typeUrl, MsgUpdateClientResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateClientResponse.aminoType, MsgUpdateClientResponse.typeUrl);
 function createBaseMsgUpgradeClient() {
     return {
         clientId: "",
@@ -485,10 +480,9 @@ export const MsgUpgradeClient = {
             typeUrl: "/ibc.core.client.v1.MsgUpgradeClient",
             value: MsgUpgradeClient.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgUpgradeClient.typeUrl, MsgUpgradeClient);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpgradeClient.aminoType, MsgUpgradeClient.typeUrl);
 function createBaseMsgUpgradeClientResponse() {
     return {};
 }
@@ -550,10 +544,9 @@ export const MsgUpgradeClientResponse = {
             typeUrl: "/ibc.core.client.v1.MsgUpgradeClientResponse",
             value: MsgUpgradeClientResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgUpgradeClientResponse.typeUrl, MsgUpgradeClientResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpgradeClientResponse.aminoType, MsgUpgradeClientResponse.typeUrl);
 function createBaseMsgSubmitMisbehaviour() {
     return {
         clientId: "",
@@ -652,10 +645,9 @@ export const MsgSubmitMisbehaviour = {
             typeUrl: "/ibc.core.client.v1.MsgSubmitMisbehaviour",
             value: MsgSubmitMisbehaviour.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgSubmitMisbehaviour.typeUrl, MsgSubmitMisbehaviour);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSubmitMisbehaviour.aminoType, MsgSubmitMisbehaviour.typeUrl);
 function createBaseMsgSubmitMisbehaviourResponse() {
     return {};
 }
@@ -717,10 +709,9 @@ export const MsgSubmitMisbehaviourResponse = {
             typeUrl: "/ibc.core.client.v1.MsgSubmitMisbehaviourResponse",
             value: MsgSubmitMisbehaviourResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgSubmitMisbehaviourResponse.typeUrl, MsgSubmitMisbehaviourResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgSubmitMisbehaviourResponse.aminoType, MsgSubmitMisbehaviourResponse.typeUrl);
 function createBaseMsgRecoverClient() {
     return {
         subjectClientId: "",
@@ -819,10 +810,9 @@ export const MsgRecoverClient = {
             typeUrl: "/ibc.core.client.v1.MsgRecoverClient",
             value: MsgRecoverClient.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgRecoverClient.typeUrl, MsgRecoverClient);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgRecoverClient.aminoType, MsgRecoverClient.typeUrl);
 function createBaseMsgRecoverClientResponse() {
     return {};
 }
@@ -884,10 +874,9 @@ export const MsgRecoverClientResponse = {
             typeUrl: "/ibc.core.client.v1.MsgRecoverClientResponse",
             value: MsgRecoverClientResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgRecoverClientResponse.typeUrl, MsgRecoverClientResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgRecoverClientResponse.aminoType, MsgRecoverClientResponse.typeUrl);
 function createBaseMsgIBCSoftwareUpgrade() {
     return {
         plan: Plan.fromPartial({}),
@@ -986,10 +975,9 @@ export const MsgIBCSoftwareUpgrade = {
             typeUrl: "/ibc.core.client.v1.MsgIBCSoftwareUpgrade",
             value: MsgIBCSoftwareUpgrade.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgIBCSoftwareUpgrade.typeUrl, MsgIBCSoftwareUpgrade);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgIBCSoftwareUpgrade.aminoType, MsgIBCSoftwareUpgrade.typeUrl);
 function createBaseMsgIBCSoftwareUpgradeResponse() {
     return {};
 }
@@ -1051,10 +1039,9 @@ export const MsgIBCSoftwareUpgradeResponse = {
             typeUrl: "/ibc.core.client.v1.MsgIBCSoftwareUpgradeResponse",
             value: MsgIBCSoftwareUpgradeResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgIBCSoftwareUpgradeResponse.typeUrl, MsgIBCSoftwareUpgradeResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgIBCSoftwareUpgradeResponse.aminoType, MsgIBCSoftwareUpgradeResponse.typeUrl);
 function createBaseMsgUpdateParams() {
     return {
         signer: "",
@@ -1141,10 +1128,11 @@ export const MsgUpdateParams = {
             typeUrl: "/ibc.core.client.v1.MsgUpdateParams",
             value: MsgUpdateParams.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Params.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(MsgUpdateParams.typeUrl, MsgUpdateParams);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParams.aminoType, MsgUpdateParams.typeUrl);
 function createBaseMsgUpdateParamsResponse() {
     return {};
 }
@@ -1206,7 +1194,6 @@ export const MsgUpdateParamsResponse = {
             typeUrl: "/ibc.core.client.v1.MsgUpdateParamsResponse",
             value: MsgUpdateParamsResponse.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParamsResponse.aminoType, MsgUpdateParamsResponse.typeUrl);

package/esm/ibc/core/client/v1/tx.rpc.func.js

@@ -5,41 +5,48 @@ export const createCreateClient = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgCreateClient.typeUrl,
     encoders: toEncoders(MsgCreateClient),
-    converters: toConverters(MsgCreateClient)
+    converters: toConverters(MsgCreateClient),
+    deps: [MsgCreateClient]
 });
 export const createUpdateClient = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgUpdateClient.typeUrl,
     encoders: toEncoders(MsgUpdateClient),
-    converters: toConverters(MsgUpdateClient)
+    converters: toConverters(MsgUpdateClient),
+    deps: [MsgUpdateClient]
 });
 export const createUpgradeClient = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgUpgradeClient.typeUrl,
     encoders: toEncoders(MsgUpgradeClient),
-    converters: toConverters(MsgUpgradeClient)
+    converters: toConverters(MsgUpgradeClient),
+    deps: [MsgUpgradeClient]
 });
 export const createSubmitMisbehaviour = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgSubmitMisbehaviour.typeUrl,
     encoders: toEncoders(MsgSubmitMisbehaviour),
-    converters: toConverters(MsgSubmitMisbehaviour)
+    converters: toConverters(MsgSubmitMisbehaviour),
+    deps: [MsgSubmitMisbehaviour]
 });
 export const createRecoverClient = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgRecoverClient.typeUrl,
     encoders: toEncoders(MsgRecoverClient),
-    converters: toConverters(MsgRecoverClient)
+    converters: toConverters(MsgRecoverClient),
+    deps: [MsgRecoverClient]
 });
 export const createIBCSoftwareUpgrade = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgIBCSoftwareUpgrade.typeUrl,
     encoders: toEncoders(MsgIBCSoftwareUpgrade),
-    converters: toConverters(MsgIBCSoftwareUpgrade)
+    converters: toConverters(MsgIBCSoftwareUpgrade),
+    deps: [MsgIBCSoftwareUpgrade]
 });
 export const createUpdateClientParams = (clientResolver) => buildTx({
     clientResolver,
     typeUrl: MsgUpdateParams.typeUrl,
     encoders: toEncoders(MsgUpdateParams),
-    converters: toConverters(MsgUpdateParams)
+    converters: toConverters(MsgUpdateParams),
+    deps: [MsgUpdateParams]
 });

package/esm/ibc/core/commitment/v1/commitment.js

@@ -1,7 +1,6 @@
 import { CommitmentProof } from "../../../../cosmos/ics23/v1/proofs";
 import { BinaryReader, BinaryWriter } from "../../../../binary";
 import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
-import { GlobalDecoderRegistry } from "../../../../registry";
 function createBaseMerkleRoot() {
     return {
         hash: new Uint8Array()
@@ -76,10 +75,9 @@ export const MerkleRoot = {
             typeUrl: "/ibc.core.commitment.v1.MerkleRoot",
             value: MerkleRoot.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MerkleRoot.typeUrl, MerkleRoot);
-GlobalDecoderRegistry.registerAminoProtoMapping(MerkleRoot.aminoType, MerkleRoot.typeUrl);
 function createBaseMerklePrefix() {
     return {
         keyPrefix: new Uint8Array()
@@ -154,10 +152,9 @@ export const MerklePrefix = {
             typeUrl: "/ibc.core.commitment.v1.MerklePrefix",
             value: MerklePrefix.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(MerklePrefix.typeUrl, MerklePrefix);
-GlobalDecoderRegistry.registerAminoProtoMapping(MerklePrefix.aminoType, MerklePrefix.typeUrl);
 function createBaseMerkleProof() {
     return {
         proofs: []
@@ -235,7 +232,8 @@ export const MerkleProof = {
             typeUrl: "/ibc.core.commitment.v1.MerkleProof",
             value: MerkleProof.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        CommitmentProof.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(MerkleProof.typeUrl, MerkleProof);
-GlobalDecoderRegistry.registerAminoProtoMapping(MerkleProof.aminoType, MerkleProof.typeUrl);

package/esm/ibc/core/connection/v1/connection.js

@@ -1,7 +1,6 @@
 import { MerklePrefix } from "../../commitment/v1/commitment";
 import { isSet } from "../../../../helpers";
 import { BinaryReader, BinaryWriter } from "../../../../binary";
-import { GlobalDecoderRegistry } from "../../../../registry";
 /**
  * State defines if a connection is in one of the following states:
  * INIT, TRYOPEN, OPEN or UNINITIALIZED.
@@ -182,10 +181,12 @@ export const ConnectionEnd = {
             typeUrl: "/ibc.core.connection.v1.ConnectionEnd",
             value: ConnectionEnd.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Version.registerTypeUrl();
+        Counterparty.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(ConnectionEnd.typeUrl, ConnectionEnd);
-GlobalDecoderRegistry.registerAminoProtoMapping(ConnectionEnd.aminoType, ConnectionEnd.typeUrl);
 function createBaseIdentifiedConnection() {
     return {
         id: "",
@@ -323,10 +324,12 @@ export const IdentifiedConnection = {
             typeUrl: "/ibc.core.connection.v1.IdentifiedConnection",
             value: IdentifiedConnection.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        Version.registerTypeUrl();
+        Counterparty.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(IdentifiedConnection.typeUrl, IdentifiedConnection);
-GlobalDecoderRegistry.registerAminoProtoMapping(IdentifiedConnection.aminoType, IdentifiedConnection.typeUrl);
 function createBaseCounterparty() {
     return {
         clientId: "",
@@ -425,10 +428,11 @@ export const Counterparty = {
             typeUrl: "/ibc.core.connection.v1.Counterparty",
             value: Counterparty.encode(message).finish()
         };
+    },
+    registerTypeUrl() {
+        MerklePrefix.registerTypeUrl();
     }
 };
-GlobalDecoderRegistry.register(Counterparty.typeUrl, Counterparty);
-GlobalDecoderRegistry.registerAminoProtoMapping(Counterparty.aminoType, Counterparty.typeUrl);
 function createBaseClientPaths() {
     return {
         paths: []
@@ -506,10 +510,9 @@ export const ClientPaths = {
             typeUrl: "/ibc.core.connection.v1.ClientPaths",
             value: ClientPaths.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(ClientPaths.typeUrl, ClientPaths);
-GlobalDecoderRegistry.registerAminoProtoMapping(ClientPaths.aminoType, ClientPaths.typeUrl);
 function createBaseConnectionPaths() {
     return {
         clientId: "",
@@ -599,10 +602,9 @@ export const ConnectionPaths = {
             typeUrl: "/ibc.core.connection.v1.ConnectionPaths",
             value: ConnectionPaths.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(ConnectionPaths.typeUrl, ConnectionPaths);
-GlobalDecoderRegistry.registerAminoProtoMapping(ConnectionPaths.aminoType, ConnectionPaths.typeUrl);
 function createBaseVersion() {
     return {
         identifier: "",
@@ -692,10 +694,9 @@ export const Version = {
             typeUrl: "/ibc.core.connection.v1.Version",
             value: Version.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Version.typeUrl, Version);
-GlobalDecoderRegistry.registerAminoProtoMapping(Version.aminoType, Version.typeUrl);
 function createBaseParams() {
     return {
         maxExpectedTimePerBlock: BigInt(0)
@@ -770,7 +771,6 @@ export const Params = {
             typeUrl: "/ibc.core.connection.v1.Params",
             value: Params.encode(message).finish()
         };
-    }
+    },
+    registerTypeUrl() { }
 };
-GlobalDecoderRegistry.register(Params.typeUrl, Params);
-GlobalDecoderRegistry.registerAminoProtoMapping(Params.aminoType, Params.typeUrl);