injectivejs 1.4.0 → 1.6.0

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

@@ -0,0 +1,1406 @@
+import { Params } from "../../../cosmos/bank/v1beta1/bank";
+import { Namespace, Role, AddressRoles } from "./permissions";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: Params.fromPartial({})
+    };
+}
+export const MsgUpdateParams = {
+    typeUrl: "/injective.permissions.v1beta1.MsgUpdateParams",
+    aminoType: "permissions/MsgUpdateParams",
+    is(o) {
+        return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.is(o.params));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.isAmino(o.params));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateParams();
+        message.authority = object.authority ?? "";
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateParams();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.params = message.params ? Params.toAmino(message.params) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParams.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "permissions/MsgUpdateParams",
+            value: MsgUpdateParams.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgUpdateParams",
+            value: MsgUpdateParams.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateParams.typeUrl, MsgUpdateParams);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParams.aminoType, MsgUpdateParams.typeUrl);
+function createBaseMsgUpdateParamsResponse() {
+    return {};
+}
+export const MsgUpdateParamsResponse = {
+    typeUrl: "/injective.permissions.v1beta1.MsgUpdateParamsResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
+    },
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);
+function createBaseMsgCreateNamespace() {
+    return {
+        sender: "",
+        namespace: Namespace.fromPartial({})
+    };
+}
+export const MsgCreateNamespace = {
+    typeUrl: "/injective.permissions.v1beta1.MsgCreateNamespace",
+    aminoType: "permissions/MsgCreateNamespace",
+    is(o) {
+        return o && (o.$typeUrl === MsgCreateNamespace.typeUrl || typeof o.sender === "string" && Namespace.is(o.namespace));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgCreateNamespace.typeUrl || typeof o.sender === "string" && Namespace.isAmino(o.namespace));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.namespace !== undefined) {
+            Namespace.encode(message.namespace, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgCreateNamespace();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.namespace = Namespace.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCreateNamespace();
+        message.sender = object.sender ?? "";
+        message.namespace = object.namespace !== undefined && object.namespace !== null ? Namespace.fromPartial(object.namespace) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCreateNamespace();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.namespace !== undefined && object.namespace !== null) {
+            message.namespace = Namespace.fromAmino(object.namespace);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.namespace = message.namespace ? Namespace.toAmino(message.namespace) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCreateNamespace.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "permissions/MsgCreateNamespace",
+            value: MsgCreateNamespace.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgCreateNamespace.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCreateNamespace.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgCreateNamespace",
+            value: MsgCreateNamespace.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgCreateNamespace.typeUrl, MsgCreateNamespace);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgCreateNamespace.aminoType, MsgCreateNamespace.typeUrl);
+function createBaseMsgCreateNamespaceResponse() {
+    return {};
+}
+export const MsgCreateNamespaceResponse = {
+    typeUrl: "/injective.permissions.v1beta1.MsgCreateNamespaceResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgCreateNamespaceResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgCreateNamespaceResponse.typeUrl;
+    },
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgCreateNamespaceResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgCreateNamespaceResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgCreateNamespaceResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCreateNamespaceResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgCreateNamespaceResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCreateNamespaceResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgCreateNamespaceResponse",
+            value: MsgCreateNamespaceResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgCreateNamespaceResponse.typeUrl, MsgCreateNamespaceResponse);
+function createBaseMsgDeleteNamespace() {
+    return {
+        sender: "",
+        namespaceDenom: ""
+    };
+}
+export const MsgDeleteNamespace = {
+    typeUrl: "/injective.permissions.v1beta1.MsgDeleteNamespace",
+    aminoType: "permissions/MsgDeleteNamespace",
+    is(o) {
+        return o && (o.$typeUrl === MsgDeleteNamespace.typeUrl || typeof o.sender === "string" && typeof o.namespaceDenom === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgDeleteNamespace.typeUrl || typeof o.sender === "string" && typeof o.namespace_denom === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.namespaceDenom !== "") {
+            writer.uint32(18).string(message.namespaceDenom);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgDeleteNamespace();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.namespaceDenom = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgDeleteNamespace();
+        message.sender = object.sender ?? "";
+        message.namespaceDenom = object.namespaceDenom ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgDeleteNamespace();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.namespace_denom !== undefined && object.namespace_denom !== null) {
+            message.namespaceDenom = object.namespace_denom;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.namespace_denom = message.namespaceDenom === "" ? undefined : message.namespaceDenom;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgDeleteNamespace.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "permissions/MsgDeleteNamespace",
+            value: MsgDeleteNamespace.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgDeleteNamespace.decode(message.value);
+    },
+    toProto(message) {
+        return MsgDeleteNamespace.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgDeleteNamespace",
+            value: MsgDeleteNamespace.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgDeleteNamespace.typeUrl, MsgDeleteNamespace);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgDeleteNamespace.aminoType, MsgDeleteNamespace.typeUrl);
+function createBaseMsgDeleteNamespaceResponse() {
+    return {};
+}
+export const MsgDeleteNamespaceResponse = {
+    typeUrl: "/injective.permissions.v1beta1.MsgDeleteNamespaceResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgDeleteNamespaceResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgDeleteNamespaceResponse.typeUrl;
+    },
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgDeleteNamespaceResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgDeleteNamespaceResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgDeleteNamespaceResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgDeleteNamespaceResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgDeleteNamespaceResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgDeleteNamespaceResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgDeleteNamespaceResponse",
+            value: MsgDeleteNamespaceResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgDeleteNamespaceResponse.typeUrl, MsgDeleteNamespaceResponse);
+function createBaseMsgUpdateNamespace() {
+    return {
+        sender: "",
+        namespaceDenom: "",
+        wasmHook: undefined,
+        mintsPaused: undefined,
+        sendsPaused: undefined,
+        burnsPaused: undefined
+    };
+}
+export const MsgUpdateNamespace = {
+    typeUrl: "/injective.permissions.v1beta1.MsgUpdateNamespace",
+    aminoType: "permissions/MsgUpdateNamespace",
+    is(o) {
+        return o && (o.$typeUrl === MsgUpdateNamespace.typeUrl || typeof o.sender === "string" && typeof o.namespaceDenom === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgUpdateNamespace.typeUrl || typeof o.sender === "string" && typeof o.namespace_denom === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.namespaceDenom !== "") {
+            writer.uint32(18).string(message.namespaceDenom);
+        }
+        if (message.wasmHook !== undefined) {
+            MsgUpdateNamespace_MsgSetWasmHook.encode(message.wasmHook, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.mintsPaused !== undefined) {
+            MsgUpdateNamespace_MsgSetMintsPaused.encode(message.mintsPaused, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.sendsPaused !== undefined) {
+            MsgUpdateNamespace_MsgSetSendsPaused.encode(message.sendsPaused, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.burnsPaused !== undefined) {
+            MsgUpdateNamespace_MsgSetBurnsPaused.encode(message.burnsPaused, writer.uint32(50).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateNamespace();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.namespaceDenom = reader.string();
+                    break;
+                case 3:
+                    message.wasmHook = MsgUpdateNamespace_MsgSetWasmHook.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.mintsPaused = MsgUpdateNamespace_MsgSetMintsPaused.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.sendsPaused = MsgUpdateNamespace_MsgSetSendsPaused.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.burnsPaused = MsgUpdateNamespace_MsgSetBurnsPaused.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateNamespace();
+        message.sender = object.sender ?? "";
+        message.namespaceDenom = object.namespaceDenom ?? "";
+        message.wasmHook = object.wasmHook !== undefined && object.wasmHook !== null ? MsgUpdateNamespace_MsgSetWasmHook.fromPartial(object.wasmHook) : undefined;
+        message.mintsPaused = object.mintsPaused !== undefined && object.mintsPaused !== null ? MsgUpdateNamespace_MsgSetMintsPaused.fromPartial(object.mintsPaused) : undefined;
+        message.sendsPaused = object.sendsPaused !== undefined && object.sendsPaused !== null ? MsgUpdateNamespace_MsgSetSendsPaused.fromPartial(object.sendsPaused) : undefined;
+        message.burnsPaused = object.burnsPaused !== undefined && object.burnsPaused !== null ? MsgUpdateNamespace_MsgSetBurnsPaused.fromPartial(object.burnsPaused) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateNamespace();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.namespace_denom !== undefined && object.namespace_denom !== null) {
+            message.namespaceDenom = object.namespace_denom;
+        }
+        if (object.wasm_hook !== undefined && object.wasm_hook !== null) {
+            message.wasmHook = MsgUpdateNamespace_MsgSetWasmHook.fromAmino(object.wasm_hook);
+        }
+        if (object.mints_paused !== undefined && object.mints_paused !== null) {
+            message.mintsPaused = MsgUpdateNamespace_MsgSetMintsPaused.fromAmino(object.mints_paused);
+        }
+        if (object.sends_paused !== undefined && object.sends_paused !== null) {
+            message.sendsPaused = MsgUpdateNamespace_MsgSetSendsPaused.fromAmino(object.sends_paused);
+        }
+        if (object.burns_paused !== undefined && object.burns_paused !== null) {
+            message.burnsPaused = MsgUpdateNamespace_MsgSetBurnsPaused.fromAmino(object.burns_paused);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.namespace_denom = message.namespaceDenom === "" ? undefined : message.namespaceDenom;
+        obj.wasm_hook = message.wasmHook ? MsgUpdateNamespace_MsgSetWasmHook.toAmino(message.wasmHook) : undefined;
+        obj.mints_paused = message.mintsPaused ? MsgUpdateNamespace_MsgSetMintsPaused.toAmino(message.mintsPaused) : undefined;
+        obj.sends_paused = message.sendsPaused ? MsgUpdateNamespace_MsgSetSendsPaused.toAmino(message.sendsPaused) : undefined;
+        obj.burns_paused = message.burnsPaused ? MsgUpdateNamespace_MsgSetBurnsPaused.toAmino(message.burnsPaused) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateNamespace.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "permissions/MsgUpdateNamespace",
+            value: MsgUpdateNamespace.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateNamespace.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateNamespace.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgUpdateNamespace",
+            value: MsgUpdateNamespace.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateNamespace.typeUrl, MsgUpdateNamespace);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateNamespace.aminoType, MsgUpdateNamespace.typeUrl);
+function createBaseMsgUpdateNamespace_MsgSetWasmHook() {
+    return {
+        newValue: ""
+    };
+}
+export const MsgUpdateNamespace_MsgSetWasmHook = {
+    typeUrl: "/injective.permissions.v1beta1.MsgSetWasmHook",
+    is(o) {
+        return o && (o.$typeUrl === MsgUpdateNamespace_MsgSetWasmHook.typeUrl || typeof o.newValue === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgUpdateNamespace_MsgSetWasmHook.typeUrl || typeof o.new_value === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.newValue !== "") {
+            writer.uint32(10).string(message.newValue);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateNamespace_MsgSetWasmHook();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.newValue = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateNamespace_MsgSetWasmHook();
+        message.newValue = object.newValue ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateNamespace_MsgSetWasmHook();
+        if (object.new_value !== undefined && object.new_value !== null) {
+            message.newValue = object.new_value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.new_value = message.newValue === "" ? undefined : message.newValue;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateNamespace_MsgSetWasmHook.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateNamespace_MsgSetWasmHook.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateNamespace_MsgSetWasmHook.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgSetWasmHook",
+            value: MsgUpdateNamespace_MsgSetWasmHook.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateNamespace_MsgSetWasmHook.typeUrl, MsgUpdateNamespace_MsgSetWasmHook);
+function createBaseMsgUpdateNamespace_MsgSetMintsPaused() {
+    return {
+        newValue: false
+    };
+}
+export const MsgUpdateNamespace_MsgSetMintsPaused = {
+    typeUrl: "/injective.permissions.v1beta1.MsgSetMintsPaused",
+    is(o) {
+        return o && (o.$typeUrl === MsgUpdateNamespace_MsgSetMintsPaused.typeUrl || typeof o.newValue === "boolean");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgUpdateNamespace_MsgSetMintsPaused.typeUrl || typeof o.new_value === "boolean");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.newValue === true) {
+            writer.uint32(8).bool(message.newValue);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateNamespace_MsgSetMintsPaused();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.newValue = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateNamespace_MsgSetMintsPaused();
+        message.newValue = object.newValue ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateNamespace_MsgSetMintsPaused();
+        if (object.new_value !== undefined && object.new_value !== null) {
+            message.newValue = object.new_value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.new_value = message.newValue === false ? undefined : message.newValue;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateNamespace_MsgSetMintsPaused.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateNamespace_MsgSetMintsPaused.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateNamespace_MsgSetMintsPaused.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgSetMintsPaused",
+            value: MsgUpdateNamespace_MsgSetMintsPaused.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateNamespace_MsgSetMintsPaused.typeUrl, MsgUpdateNamespace_MsgSetMintsPaused);
+function createBaseMsgUpdateNamespace_MsgSetSendsPaused() {
+    return {
+        newValue: false
+    };
+}
+export const MsgUpdateNamespace_MsgSetSendsPaused = {
+    typeUrl: "/injective.permissions.v1beta1.MsgSetSendsPaused",
+    is(o) {
+        return o && (o.$typeUrl === MsgUpdateNamespace_MsgSetSendsPaused.typeUrl || typeof o.newValue === "boolean");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgUpdateNamespace_MsgSetSendsPaused.typeUrl || typeof o.new_value === "boolean");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.newValue === true) {
+            writer.uint32(8).bool(message.newValue);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateNamespace_MsgSetSendsPaused();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.newValue = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateNamespace_MsgSetSendsPaused();
+        message.newValue = object.newValue ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateNamespace_MsgSetSendsPaused();
+        if (object.new_value !== undefined && object.new_value !== null) {
+            message.newValue = object.new_value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.new_value = message.newValue === false ? undefined : message.newValue;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateNamespace_MsgSetSendsPaused.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateNamespace_MsgSetSendsPaused.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateNamespace_MsgSetSendsPaused.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgSetSendsPaused",
+            value: MsgUpdateNamespace_MsgSetSendsPaused.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateNamespace_MsgSetSendsPaused.typeUrl, MsgUpdateNamespace_MsgSetSendsPaused);
+function createBaseMsgUpdateNamespace_MsgSetBurnsPaused() {
+    return {
+        newValue: false
+    };
+}
+export const MsgUpdateNamespace_MsgSetBurnsPaused = {
+    typeUrl: "/injective.permissions.v1beta1.MsgSetBurnsPaused",
+    is(o) {
+        return o && (o.$typeUrl === MsgUpdateNamespace_MsgSetBurnsPaused.typeUrl || typeof o.newValue === "boolean");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgUpdateNamespace_MsgSetBurnsPaused.typeUrl || typeof o.new_value === "boolean");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.newValue === true) {
+            writer.uint32(8).bool(message.newValue);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateNamespace_MsgSetBurnsPaused();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.newValue = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateNamespace_MsgSetBurnsPaused();
+        message.newValue = object.newValue ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateNamespace_MsgSetBurnsPaused();
+        if (object.new_value !== undefined && object.new_value !== null) {
+            message.newValue = object.new_value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.new_value = message.newValue === false ? undefined : message.newValue;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateNamespace_MsgSetBurnsPaused.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateNamespace_MsgSetBurnsPaused.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateNamespace_MsgSetBurnsPaused.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgSetBurnsPaused",
+            value: MsgUpdateNamespace_MsgSetBurnsPaused.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateNamespace_MsgSetBurnsPaused.typeUrl, MsgUpdateNamespace_MsgSetBurnsPaused);
+function createBaseMsgUpdateNamespaceResponse() {
+    return {};
+}
+export const MsgUpdateNamespaceResponse = {
+    typeUrl: "/injective.permissions.v1beta1.MsgUpdateNamespaceResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgUpdateNamespaceResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgUpdateNamespaceResponse.typeUrl;
+    },
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateNamespaceResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateNamespaceResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUpdateNamespaceResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateNamespaceResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateNamespaceResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateNamespaceResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgUpdateNamespaceResponse",
+            value: MsgUpdateNamespaceResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateNamespaceResponse.typeUrl, MsgUpdateNamespaceResponse);
+function createBaseMsgUpdateNamespaceRoles() {
+    return {
+        sender: "",
+        namespaceDenom: "",
+        rolePermissions: [],
+        addressRoles: []
+    };
+}
+export const MsgUpdateNamespaceRoles = {
+    typeUrl: "/injective.permissions.v1beta1.MsgUpdateNamespaceRoles",
+    aminoType: "permissions/MsgUpdateNamespaceRoles",
+    is(o) {
+        return o && (o.$typeUrl === MsgUpdateNamespaceRoles.typeUrl || typeof o.sender === "string" && typeof o.namespaceDenom === "string" && Array.isArray(o.rolePermissions) && (!o.rolePermissions.length || Role.is(o.rolePermissions[0])) && Array.isArray(o.addressRoles) && (!o.addressRoles.length || AddressRoles.is(o.addressRoles[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgUpdateNamespaceRoles.typeUrl || typeof o.sender === "string" && typeof o.namespace_denom === "string" && Array.isArray(o.role_permissions) && (!o.role_permissions.length || Role.isAmino(o.role_permissions[0])) && Array.isArray(o.address_roles) && (!o.address_roles.length || AddressRoles.isAmino(o.address_roles[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.namespaceDenom !== "") {
+            writer.uint32(18).string(message.namespaceDenom);
+        }
+        for (const v of message.rolePermissions) {
+            Role.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.addressRoles) {
+            AddressRoles.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateNamespaceRoles();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.namespaceDenom = reader.string();
+                    break;
+                case 3:
+                    message.rolePermissions.push(Role.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.addressRoles.push(AddressRoles.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateNamespaceRoles();
+        message.sender = object.sender ?? "";
+        message.namespaceDenom = object.namespaceDenom ?? "";
+        message.rolePermissions = object.rolePermissions?.map(e => Role.fromPartial(e)) || [];
+        message.addressRoles = object.addressRoles?.map(e => AddressRoles.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateNamespaceRoles();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.namespace_denom !== undefined && object.namespace_denom !== null) {
+            message.namespaceDenom = object.namespace_denom;
+        }
+        message.rolePermissions = object.role_permissions?.map(e => Role.fromAmino(e)) || [];
+        message.addressRoles = object.address_roles?.map(e => AddressRoles.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.namespace_denom = message.namespaceDenom === "" ? undefined : message.namespaceDenom;
+        if (message.rolePermissions) {
+            obj.role_permissions = message.rolePermissions.map(e => e ? Role.toAmino(e) : undefined);
+        }
+        else {
+            obj.role_permissions = message.rolePermissions;
+        }
+        if (message.addressRoles) {
+            obj.address_roles = message.addressRoles.map(e => e ? AddressRoles.toAmino(e) : undefined);
+        }
+        else {
+            obj.address_roles = message.addressRoles;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateNamespaceRoles.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "permissions/MsgUpdateNamespaceRoles",
+            value: MsgUpdateNamespaceRoles.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateNamespaceRoles.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateNamespaceRoles.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgUpdateNamespaceRoles",
+            value: MsgUpdateNamespaceRoles.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateNamespaceRoles.typeUrl, MsgUpdateNamespaceRoles);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateNamespaceRoles.aminoType, MsgUpdateNamespaceRoles.typeUrl);
+function createBaseMsgUpdateNamespaceRolesResponse() {
+    return {};
+}
+export const MsgUpdateNamespaceRolesResponse = {
+    typeUrl: "/injective.permissions.v1beta1.MsgUpdateNamespaceRolesResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgUpdateNamespaceRolesResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgUpdateNamespaceRolesResponse.typeUrl;
+    },
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateNamespaceRolesResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateNamespaceRolesResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUpdateNamespaceRolesResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateNamespaceRolesResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateNamespaceRolesResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateNamespaceRolesResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgUpdateNamespaceRolesResponse",
+            value: MsgUpdateNamespaceRolesResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateNamespaceRolesResponse.typeUrl, MsgUpdateNamespaceRolesResponse);
+function createBaseMsgRevokeNamespaceRoles() {
+    return {
+        sender: "",
+        namespaceDenom: "",
+        addressRolesToRevoke: []
+    };
+}
+export const MsgRevokeNamespaceRoles = {
+    typeUrl: "/injective.permissions.v1beta1.MsgRevokeNamespaceRoles",
+    aminoType: "permissions/MsgRevokeNamespaceRoles",
+    is(o) {
+        return o && (o.$typeUrl === MsgRevokeNamespaceRoles.typeUrl || typeof o.sender === "string" && typeof o.namespaceDenom === "string" && Array.isArray(o.addressRolesToRevoke) && (!o.addressRolesToRevoke.length || AddressRoles.is(o.addressRolesToRevoke[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgRevokeNamespaceRoles.typeUrl || typeof o.sender === "string" && typeof o.namespace_denom === "string" && Array.isArray(o.address_roles_to_revoke) && (!o.address_roles_to_revoke.length || AddressRoles.isAmino(o.address_roles_to_revoke[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.namespaceDenom !== "") {
+            writer.uint32(18).string(message.namespaceDenom);
+        }
+        for (const v of message.addressRolesToRevoke) {
+            AddressRoles.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgRevokeNamespaceRoles();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.namespaceDenom = reader.string();
+                    break;
+                case 3:
+                    message.addressRolesToRevoke.push(AddressRoles.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRevokeNamespaceRoles();
+        message.sender = object.sender ?? "";
+        message.namespaceDenom = object.namespaceDenom ?? "";
+        message.addressRolesToRevoke = object.addressRolesToRevoke?.map(e => AddressRoles.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRevokeNamespaceRoles();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.namespace_denom !== undefined && object.namespace_denom !== null) {
+            message.namespaceDenom = object.namespace_denom;
+        }
+        message.addressRolesToRevoke = object.address_roles_to_revoke?.map(e => AddressRoles.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.namespace_denom = message.namespaceDenom === "" ? undefined : message.namespaceDenom;
+        if (message.addressRolesToRevoke) {
+            obj.address_roles_to_revoke = message.addressRolesToRevoke.map(e => e ? AddressRoles.toAmino(e) : undefined);
+        }
+        else {
+            obj.address_roles_to_revoke = message.addressRolesToRevoke;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRevokeNamespaceRoles.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "permissions/MsgRevokeNamespaceRoles",
+            value: MsgRevokeNamespaceRoles.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRevokeNamespaceRoles.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRevokeNamespaceRoles.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgRevokeNamespaceRoles",
+            value: MsgRevokeNamespaceRoles.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRevokeNamespaceRoles.typeUrl, MsgRevokeNamespaceRoles);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgRevokeNamespaceRoles.aminoType, MsgRevokeNamespaceRoles.typeUrl);
+function createBaseMsgRevokeNamespaceRolesResponse() {
+    return {};
+}
+export const MsgRevokeNamespaceRolesResponse = {
+    typeUrl: "/injective.permissions.v1beta1.MsgRevokeNamespaceRolesResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgRevokeNamespaceRolesResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgRevokeNamespaceRolesResponse.typeUrl;
+    },
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgRevokeNamespaceRolesResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRevokeNamespaceRolesResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRevokeNamespaceRolesResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRevokeNamespaceRolesResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRevokeNamespaceRolesResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRevokeNamespaceRolesResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgRevokeNamespaceRolesResponse",
+            value: MsgRevokeNamespaceRolesResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgRevokeNamespaceRolesResponse.typeUrl, MsgRevokeNamespaceRolesResponse);
+function createBaseMsgClaimVoucher() {
+    return {
+        sender: "",
+        denom: ""
+    };
+}
+export const MsgClaimVoucher = {
+    typeUrl: "/injective.permissions.v1beta1.MsgClaimVoucher",
+    aminoType: "permissions/MsgClaimVoucher",
+    is(o) {
+        return o && (o.$typeUrl === MsgClaimVoucher.typeUrl || typeof o.sender === "string" && typeof o.denom === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgClaimVoucher.typeUrl || typeof o.sender === "string" && typeof o.denom === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.denom !== "") {
+            writer.uint32(18).string(message.denom);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgClaimVoucher();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.denom = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgClaimVoucher();
+        message.sender = object.sender ?? "";
+        message.denom = object.denom ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgClaimVoucher();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.denom !== undefined && object.denom !== null) {
+            message.denom = object.denom;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.denom = message.denom === "" ? undefined : message.denom;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgClaimVoucher.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "permissions/MsgClaimVoucher",
+            value: MsgClaimVoucher.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgClaimVoucher.decode(message.value);
+    },
+    toProto(message) {
+        return MsgClaimVoucher.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgClaimVoucher",
+            value: MsgClaimVoucher.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgClaimVoucher.typeUrl, MsgClaimVoucher);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgClaimVoucher.aminoType, MsgClaimVoucher.typeUrl);
+function createBaseMsgClaimVoucherResponse() {
+    return {};
+}
+export const MsgClaimVoucherResponse = {
+    typeUrl: "/injective.permissions.v1beta1.MsgClaimVoucherResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgClaimVoucherResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgClaimVoucherResponse.typeUrl;
+    },
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgClaimVoucherResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgClaimVoucherResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgClaimVoucherResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgClaimVoucherResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgClaimVoucherResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgClaimVoucherResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.permissions.v1beta1.MsgClaimVoucherResponse",
+            value: MsgClaimVoucherResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgClaimVoucherResponse.typeUrl, MsgClaimVoucherResponse);