injectivejs 1.4.0 → 1.6.0

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

@@ -0,0 +1,947 @@
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { Metadata, Params } from "../../../cosmos/bank/v1beta1/bank";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseMsgCreateDenom() {
+    return {
+        sender: "",
+        subdenom: "",
+        name: "",
+        symbol: "",
+        decimals: 0
+    };
+}
+export const MsgCreateDenom = {
+    typeUrl: "/injective.tokenfactory.v1beta1.MsgCreateDenom",
+    aminoType: "injective/tokenfactory/create-denom",
+    is(o) {
+        return o && (o.$typeUrl === MsgCreateDenom.typeUrl || typeof o.sender === "string" && typeof o.subdenom === "string" && typeof o.name === "string" && typeof o.symbol === "string" && typeof o.decimals === "number");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgCreateDenom.typeUrl || typeof o.sender === "string" && typeof o.subdenom === "string" && typeof o.name === "string" && typeof o.symbol === "string" && typeof o.decimals === "number");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.subdenom !== "") {
+            writer.uint32(18).string(message.subdenom);
+        }
+        if (message.name !== "") {
+            writer.uint32(26).string(message.name);
+        }
+        if (message.symbol !== "") {
+            writer.uint32(34).string(message.symbol);
+        }
+        if (message.decimals !== 0) {
+            writer.uint32(40).uint32(message.decimals);
+        }
+        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 = createBaseMsgCreateDenom();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.subdenom = reader.string();
+                    break;
+                case 3:
+                    message.name = reader.string();
+                    break;
+                case 4:
+                    message.symbol = reader.string();
+                    break;
+                case 5:
+                    message.decimals = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCreateDenom();
+        message.sender = object.sender ?? "";
+        message.subdenom = object.subdenom ?? "";
+        message.name = object.name ?? "";
+        message.symbol = object.symbol ?? "";
+        message.decimals = object.decimals ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCreateDenom();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.subdenom !== undefined && object.subdenom !== null) {
+            message.subdenom = object.subdenom;
+        }
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.symbol !== undefined && object.symbol !== null) {
+            message.symbol = object.symbol;
+        }
+        if (object.decimals !== undefined && object.decimals !== null) {
+            message.decimals = object.decimals;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.subdenom = message.subdenom === "" ? undefined : message.subdenom;
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.symbol = message.symbol === "" ? undefined : message.symbol;
+        obj.decimals = message.decimals === 0 ? undefined : message.decimals;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCreateDenom.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "injective/tokenfactory/create-denom",
+            value: MsgCreateDenom.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgCreateDenom.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCreateDenom.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.tokenfactory.v1beta1.MsgCreateDenom",
+            value: MsgCreateDenom.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgCreateDenom.typeUrl, MsgCreateDenom);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgCreateDenom.aminoType, MsgCreateDenom.typeUrl);
+function createBaseMsgCreateDenomResponse() {
+    return {
+        newTokenDenom: ""
+    };
+}
+export const MsgCreateDenomResponse = {
+    typeUrl: "/injective.tokenfactory.v1beta1.MsgCreateDenomResponse",
+    is(o) {
+        return o && (o.$typeUrl === MsgCreateDenomResponse.typeUrl || typeof o.newTokenDenom === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgCreateDenomResponse.typeUrl || typeof o.new_token_denom === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.newTokenDenom !== "") {
+            writer.uint32(10).string(message.newTokenDenom);
+        }
+        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 = createBaseMsgCreateDenomResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.newTokenDenom = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCreateDenomResponse();
+        message.newTokenDenom = object.newTokenDenom ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCreateDenomResponse();
+        if (object.new_token_denom !== undefined && object.new_token_denom !== null) {
+            message.newTokenDenom = object.new_token_denom;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.new_token_denom = message.newTokenDenom === "" ? undefined : message.newTokenDenom;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCreateDenomResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgCreateDenomResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCreateDenomResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.tokenfactory.v1beta1.MsgCreateDenomResponse",
+            value: MsgCreateDenomResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgCreateDenomResponse.typeUrl, MsgCreateDenomResponse);
+function createBaseMsgMint() {
+    return {
+        sender: "",
+        amount: Coin.fromPartial({})
+    };
+}
+export const MsgMint = {
+    typeUrl: "/injective.tokenfactory.v1beta1.MsgMint",
+    aminoType: "injective/tokenfactory/mint",
+    is(o) {
+        return o && (o.$typeUrl === MsgMint.typeUrl || typeof o.sender === "string" && Coin.is(o.amount));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgMint.typeUrl || typeof o.sender === "string" && Coin.isAmino(o.amount));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.amount !== undefined) {
+            Coin.encode(message.amount, 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 = createBaseMsgMint();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.amount = Coin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgMint();
+        message.sender = object.sender ?? "";
+        message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgMint();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = Coin.fromAmino(object.amount);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.amount = message.amount ? Coin.toAmino(message.amount) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgMint.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "injective/tokenfactory/mint",
+            value: MsgMint.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgMint.decode(message.value);
+    },
+    toProto(message) {
+        return MsgMint.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.tokenfactory.v1beta1.MsgMint",
+            value: MsgMint.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgMint.typeUrl, MsgMint);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgMint.aminoType, MsgMint.typeUrl);
+function createBaseMsgMintResponse() {
+    return {};
+}
+export const MsgMintResponse = {
+    typeUrl: "/injective.tokenfactory.v1beta1.MsgMintResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgMintResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgMintResponse.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 = createBaseMsgMintResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgMintResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgMintResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgMintResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgMintResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgMintResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.tokenfactory.v1beta1.MsgMintResponse",
+            value: MsgMintResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgMintResponse.typeUrl, MsgMintResponse);
+function createBaseMsgBurn() {
+    return {
+        sender: "",
+        amount: Coin.fromPartial({})
+    };
+}
+export const MsgBurn = {
+    typeUrl: "/injective.tokenfactory.v1beta1.MsgBurn",
+    aminoType: "injective/tokenfactory/burn",
+    is(o) {
+        return o && (o.$typeUrl === MsgBurn.typeUrl || typeof o.sender === "string" && Coin.is(o.amount));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgBurn.typeUrl || typeof o.sender === "string" && Coin.isAmino(o.amount));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.amount !== undefined) {
+            Coin.encode(message.amount, 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 = createBaseMsgBurn();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.amount = Coin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgBurn();
+        message.sender = object.sender ?? "";
+        message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgBurn();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = Coin.fromAmino(object.amount);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.amount = message.amount ? Coin.toAmino(message.amount) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgBurn.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "injective/tokenfactory/burn",
+            value: MsgBurn.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgBurn.decode(message.value);
+    },
+    toProto(message) {
+        return MsgBurn.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.tokenfactory.v1beta1.MsgBurn",
+            value: MsgBurn.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgBurn.typeUrl, MsgBurn);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgBurn.aminoType, MsgBurn.typeUrl);
+function createBaseMsgBurnResponse() {
+    return {};
+}
+export const MsgBurnResponse = {
+    typeUrl: "/injective.tokenfactory.v1beta1.MsgBurnResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgBurnResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgBurnResponse.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 = createBaseMsgBurnResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgBurnResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgBurnResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgBurnResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgBurnResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgBurnResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.tokenfactory.v1beta1.MsgBurnResponse",
+            value: MsgBurnResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgBurnResponse.typeUrl, MsgBurnResponse);
+function createBaseMsgChangeAdmin() {
+    return {
+        sender: "",
+        denom: "",
+        newAdmin: ""
+    };
+}
+export const MsgChangeAdmin = {
+    typeUrl: "/injective.tokenfactory.v1beta1.MsgChangeAdmin",
+    aminoType: "injective/tokenfactory/change-admin",
+    is(o) {
+        return o && (o.$typeUrl === MsgChangeAdmin.typeUrl || typeof o.sender === "string" && typeof o.denom === "string" && typeof o.newAdmin === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgChangeAdmin.typeUrl || typeof o.sender === "string" && typeof o.denom === "string" && typeof o.new_admin === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.denom !== "") {
+            writer.uint32(18).string(message.denom);
+        }
+        if (message.newAdmin !== "") {
+            writer.uint32(26).string(message.newAdmin);
+        }
+        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 = createBaseMsgChangeAdmin();
+        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;
+                case 3:
+                    message.newAdmin = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgChangeAdmin();
+        message.sender = object.sender ?? "";
+        message.denom = object.denom ?? "";
+        message.newAdmin = object.newAdmin ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgChangeAdmin();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.denom !== undefined && object.denom !== null) {
+            message.denom = object.denom;
+        }
+        if (object.new_admin !== undefined && object.new_admin !== null) {
+            message.newAdmin = object.new_admin;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.denom = message.denom === "" ? undefined : message.denom;
+        obj.new_admin = message.newAdmin === "" ? undefined : message.newAdmin;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgChangeAdmin.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "injective/tokenfactory/change-admin",
+            value: MsgChangeAdmin.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgChangeAdmin.decode(message.value);
+    },
+    toProto(message) {
+        return MsgChangeAdmin.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.tokenfactory.v1beta1.MsgChangeAdmin",
+            value: MsgChangeAdmin.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgChangeAdmin.typeUrl, MsgChangeAdmin);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgChangeAdmin.aminoType, MsgChangeAdmin.typeUrl);
+function createBaseMsgChangeAdminResponse() {
+    return {};
+}
+export const MsgChangeAdminResponse = {
+    typeUrl: "/injective.tokenfactory.v1beta1.MsgChangeAdminResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgChangeAdminResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgChangeAdminResponse.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 = createBaseMsgChangeAdminResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgChangeAdminResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgChangeAdminResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgChangeAdminResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgChangeAdminResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgChangeAdminResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.tokenfactory.v1beta1.MsgChangeAdminResponse",
+            value: MsgChangeAdminResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgChangeAdminResponse.typeUrl, MsgChangeAdminResponse);
+function createBaseMsgSetDenomMetadata() {
+    return {
+        sender: "",
+        metadata: Metadata.fromPartial({})
+    };
+}
+export const MsgSetDenomMetadata = {
+    typeUrl: "/injective.tokenfactory.v1beta1.MsgSetDenomMetadata",
+    aminoType: "injective/tokenfactory/set-denom-metadata",
+    is(o) {
+        return o && (o.$typeUrl === MsgSetDenomMetadata.typeUrl || typeof o.sender === "string" && Metadata.is(o.metadata));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MsgSetDenomMetadata.typeUrl || typeof o.sender === "string" && Metadata.isAmino(o.metadata));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.metadata !== undefined) {
+            Metadata.encode(message.metadata, 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 = createBaseMsgSetDenomMetadata();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.metadata = Metadata.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgSetDenomMetadata();
+        message.sender = object.sender ?? "";
+        message.metadata = object.metadata !== undefined && object.metadata !== null ? Metadata.fromPartial(object.metadata) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgSetDenomMetadata();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.metadata !== undefined && object.metadata !== null) {
+            message.metadata = Metadata.fromAmino(object.metadata);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.metadata = message.metadata ? Metadata.toAmino(message.metadata) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgSetDenomMetadata.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "injective/tokenfactory/set-denom-metadata",
+            value: MsgSetDenomMetadata.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgSetDenomMetadata.decode(message.value);
+    },
+    toProto(message) {
+        return MsgSetDenomMetadata.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.tokenfactory.v1beta1.MsgSetDenomMetadata",
+            value: MsgSetDenomMetadata.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgSetDenomMetadata.typeUrl, MsgSetDenomMetadata);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgSetDenomMetadata.aminoType, MsgSetDenomMetadata.typeUrl);
+function createBaseMsgSetDenomMetadataResponse() {
+    return {};
+}
+export const MsgSetDenomMetadataResponse = {
+    typeUrl: "/injective.tokenfactory.v1beta1.MsgSetDenomMetadataResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgSetDenomMetadataResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === MsgSetDenomMetadataResponse.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 = createBaseMsgSetDenomMetadataResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgSetDenomMetadataResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgSetDenomMetadataResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgSetDenomMetadataResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgSetDenomMetadataResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgSetDenomMetadataResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.tokenfactory.v1beta1.MsgSetDenomMetadataResponse",
+            value: MsgSetDenomMetadataResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgSetDenomMetadataResponse.typeUrl, MsgSetDenomMetadataResponse);
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: Params.fromPartial({})
+    };
+}
+export const MsgUpdateParams = {
+    typeUrl: "/injective.tokenfactory.v1beta1.MsgUpdateParams",
+    aminoType: "injective/tokenfactory/update-params",
+    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: "injective/tokenfactory/update-params",
+            value: MsgUpdateParams.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.tokenfactory.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.tokenfactory.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.tokenfactory.v1beta1.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);